Delen via

Problemen met hoog CPU-gebruik in Azure SQL Database vaststellen en oplossen

  • Artikel

Van toepassing op: Azure SQL Database

Azure SQL Database biedt ingebouwde hulpprogramma's om de oorzaken van hoog CPU-gebruik te identificeren en de prestaties van workloads te optimaliseren. U kunt deze hulpprogramma's gebruiken om problemen met hoog CPU-gebruik op te lossen tijdens het optreden, of reactief nadat het incident is voltooid. U kunt ook automatisch afstemmen inschakelen om het CPU-gebruik in de loop van de tijd voor uw database proactief te verminderen. In dit artikel leert u hoe u een hoge CPU kunt vaststellen en oplossen met ingebouwde hulpprogramma's in Azure SQL Database en wordt uitgelegd wanneer u CPU-resources toevoegt.

Inzicht in het aantal vCores

Het is handig om inzicht te hebben in het aantal virtuele kernen (vCores) dat beschikbaar is voor uw database bij het diagnosticeren van een hoog CPU-incident. Een vCore is gelijk aan een logische CPU. Het aantal vCores helpt u inzicht te krijgen in de CPU-resources die beschikbaar zijn voor uw database.

Aantal vCores identificeren in Azure Portal

U kunt snel het aantal vCores voor een database in Azure Portal identificeren als u een vCore-servicelaag gebruikt met de ingerichte rekenlaag. In dit geval bevat de prijscategorie die wordt vermeld voor de database op de overzichtspagina het aantal vCores. De prijscategorie van een database kan bijvoorbeeld 'Algemeen gebruik: Standard-serie (Gen5), 16 vCores' zijn.

Voor databases in de serverloze rekenlaag is het aantal vCores altijd gelijk aan de maximale vCore-instelling voor de database. Het aantal VCores wordt weergegeven in de prijscategorie die wordt vermeld voor de database op de overzichtspagina. De prijscategorie van een database kan bijvoorbeeld 'Algemeen gebruik: Serverloze, Standard Series (Gen5), 16 vCores' zijn.

Als u een database gebruikt onder het aankoopmodel op basis van DTU, moet u Transact-SQL gebruiken om een query uit te voeren op het aantal vCores van de database.

Aantal vCores identificeren met Transact-SQL

U kunt het huidige aantal vCores voor elke database met Transact-SQL identificeren. U kunt Transact-SQL uitvoeren op Azure SQL Database met SQL Server Management Studio (SSMS), Azure Data Studio of de Query-editor van Azure Portal.

Verbinding maken naar uw database en voer de volgende query uit:

SELECT 
    COUNT(*) as vCores
FROM sys.dm_os_schedulers
WHERE status = N'VISIBLE ONLINE';
GO

De oorzaken van een hoog CPU-gebruik identificeren

U kunt het CPU-gebruik meten en analyseren met behulp van de Azure-portal, interactieve hulpprogramma's van Query Store in SSMS en Transact-SQL-query's in SSMS en Azure Data Studio.

In Azure Portal en Query Store worden uitvoeringsstatistieken weergegeven, zoals metrische CPU-gegevens, voor voltooide query's. Als u een actueel hoog CPU-incident ondervindt dat mogelijk wordt veroorzaakt door een of meer lopende langlopende query's, identificeert u momenteel actieve query's met Transact-SQL.

Veelvoorkomende oorzaken van een nieuw en ongebruikelijk hoog CPU-gebruik zijn:

  • Nieuwe query's in de workload die een grote hoeveelheid CPU gebruiken.
  • Een toename van de frequentie van het regelmatig uitvoeren van query's.
  • Regressie van queryplannen, inclusief regressie vanwege problemen met parametergevoelig plan (PSP), wat resulteert in een of meer query's die meer CPU verbruiken.
  • Een aanzienlijke toename van de compilatie of hercompilatie van queryplannen.
  • Databases waarin query's overmatige parallelle uitvoering gebruiken.

Als u wilt weten wat uw hoge CPU-incident veroorzaakt, identificeert u wanneer er een hoog CPU-gebruik plaatsvindt voor uw database en de belangrijkste query's die gebruikmaken van CPU op dat moment.

Onderzoeken:

Notitie

Azure SQL Database vereist rekenresources om kernservicefuncties te implementeren, zoals hoge beschikbaarheid en herstel na noodgevallen, back-up en herstel van databases, bewaking, Query Store, automatisch afstemmen, enzovoort. Het gebruik van deze rekenresources kan met name merkbaar zijn voor databases met een laag aantal vCores of databases in dichte elastische pools. Meer informatie over resourcebeheer in Azure SQL Database.

Gebruik Azure Portal om verschillende CPU-metrische gegevens bij te houden, inclusief het percentage beschikbare CPU dat in de loop van de tijd door uw database wordt gebruikt. De Azure-portal combineert cpu-metrische gegevens met informatie uit de Query Store van uw database, waarmee u kunt bepalen welke query's de CPU in uw database op een bepaald moment verbruiken.

Volg deze stappen om metrische gegevens van het CPU-percentage te vinden.

  1. Navigeer naar de database in Azure Portal.
  2. Selecteer onder Intelligent Performance In het linkermenu Query Performance Insight.

In de standaardweergave van Query Performance Insight worden 24 uur aan gegevens weergegeven. CPU-gebruik wordt weergegeven als een percentage van het totale beschikbare CPU-gebruik voor de database.

De vijf belangrijkste query's die in die periode worden uitgevoerd, worden weergegeven in verticale balken boven de grafiek cpu-gebruik. Selecteer een tijdsband in de grafiek of gebruik het menu Aanpassen om specifieke perioden te verkennen. U kunt ook het aantal weergegeven query's verhogen.

Screenshot shows Query Performance Insight in the Azure portal.

Selecteer elke query-id met een hoog CPU-gebruik om details voor de query te openen. Details omvatten querytekst samen met prestatiegeschiedenis voor de query. Controleer of de CPU onlangs is toegenomen voor de query.

Noteer de query-id om het queryplan verder te onderzoeken met behulp van Query Store in de volgende sectie.

Queryplannen bekijken voor de belangrijkste query's die zijn geïdentificeerd in Azure Portal

Volg deze stappen om een query-id te gebruiken in de interactieve Query Store-hulpprogramma's van SSMS om het uitvoeringsplan van de query in de loop van de tijd te onderzoeken.

  1. Open SQL Server Management Studio.
  2. Verbinding maken naar uw Azure SQL Database in Objectverkenner.
  3. Vouw het databaseknooppunt uit in Objectverkenner.
  4. Vouw de map Query Store uit.
  5. Open het deelvenster Bijgehouden query's .
  6. Voer de query-id in het vak Traceringsquery linksboven in het scherm in en druk op Enter.
  7. Selecteer indien nodig Configureren om het tijdsinterval aan te passen aan de tijd waarop hoog CPU-gebruik plaatsvond.

Op de pagina worden de uitvoeringsplan(en) en gerelateerde metrische gegevens voor de query weergegeven gedurende de afgelopen 24 uur.

Momenteel uitgevoerde query's identificeren met Transact-SQL

Met Transact-SQL kunt u momenteel actieve query's identificeren met de CPU-tijd die ze tot nu toe hebben gebruikt. U kunt Transact-SQL ook gebruiken om een query uit te voeren op recent CPU-gebruik in uw database, topquery's per CPU en query's die het vaakst zijn gecompileerd.

U kunt query's uitvoeren op metrische CPU-gegevens met BEHULP van SQL Server Management Studio (SSMS), Azure Data Studio of de query-editor van Azure Portal. Wanneer u SSMS of Azure Data Studio gebruikt, opent u een nieuw queryvenster en verbindt u dit met uw database (niet de master database).

Zoek momenteel actieve query's met CPU-gebruiks- en uitvoeringsplannen door de volgende query uit te voeren. DE CPU-tijd wordt geretourneerd in milliseconden.

SELECT
    req.session_id,
    req.status,
    req.start_time,
    req.cpu_time AS 'cpu_time_ms',
    req.logical_reads,
    req.dop,
    s.login_name,
    s.host_name,
    s.program_name,
    object_name(st.objectid,st.dbid) 'ObjectName',
    REPLACE (REPLACE (SUBSTRING (st.text,(req.statement_start_offset/2) + 1,
        ((CASE req.statement_end_offset    WHEN -1    THEN DATALENGTH(st.text) 
        ELSE req.statement_end_offset END - req.statement_start_offset)/2) + 1),
        CHAR(10), ' '), CHAR(13), ' ') AS statement_text,
    qp.query_plan,
    qsx.query_plan as query_plan_with_in_flight_statistics
FROM sys.dm_exec_requests as req  
JOIN sys.dm_exec_sessions as s on req.session_id=s.session_id
CROSS APPLY sys.dm_exec_sql_text(req.sql_handle) as st
OUTER APPLY sys.dm_exec_query_plan(req.plan_handle) as qp
OUTER APPLY sys.dm_exec_query_statistics_xml(req.session_id) as qsx
ORDER BY req.cpu_time desc;
GO

Deze query retourneert twee kopieën van het uitvoeringsplan. De kolom query_plan bevat het uitvoeringsplan van sys.dm_exec_query_plan. Deze versie van het queryplan bevat alleen schattingen van het aantal rijen en bevat geen uitvoeringsstatistieken.

Als de kolom query_plan_with_in_flight_statistics een uitvoeringsplan retourneert, biedt dit plan meer informatie. De query_plan_with_in_flight_statistics kolom retourneert gegevens uit sys.dm_exec_query_statistics_xml, waaronder uitvoeringsstatistieken 'in vlucht', zoals het werkelijke aantal rijen dat tot nu toe is geretourneerd door een query die momenteel wordt uitgevoerd.

Metrische gegevens over CPU-gebruik voor het afgelopen uur bekijken

De volgende query retourneert sys.dm_db_resource_stats het gemiddelde CPU-gebruik gedurende ongeveer het afgelopen uur gedurende ongeveer het afgelopen uur.

SELECT
    end_time,
    avg_cpu_percent,
    avg_instance_cpu_percent
FROM sys.dm_db_resource_stats
ORDER BY end_time DESC; 
GO

Het is belangrijk dat u zich niet alleen op de avg_cpu_percent kolom richt. De avg_instance_cpu_percent kolom bevat CPU die wordt gebruikt door zowel gebruikers- als interne workloads. Als avg_instance_cpu_percent dit bijna 100% is, zijn CPU-resources verzadigd. In dit geval moet u problemen met een hoge CPU oplossen als de doorvoer van apps onvoldoende is of de querylatentie hoog is.

Meer informatie over resourcebeheer in Azure SQL Database.

Bekijk de voorbeelden in sys.dm_db_resource_stats voor meer query's.

Query's uitvoeren op de 15 meest recente query's op basis van CPU-gebruik

Query Store houdt uitvoeringsstatistieken bij, inclusief CPU-gebruik, voor query's. De volgende query retourneert de top 15 query's die in de afgelopen 2 uur zijn uitgevoerd, gesorteerd op CPU-gebruik. DE CPU-tijd wordt geretourneerd in milliseconden.

WITH AggregatedCPU AS 
    (SELECT
        q.query_hash, 
        SUM(count_executions * avg_cpu_time / 1000.0) AS total_cpu_ms, 
        SUM(count_executions * avg_cpu_time / 1000.0)/ SUM(count_executions) AS avg_cpu_ms, 
        MAX(rs.max_cpu_time / 1000.00) AS max_cpu_ms, 
        MAX(max_logical_io_reads) max_logical_reads, 
        COUNT(DISTINCT p.plan_id) AS number_of_distinct_plans, 
        COUNT(DISTINCT p.query_id) AS number_of_distinct_query_ids, 
        SUM(CASE WHEN rs.execution_type_desc='Aborted' THEN count_executions ELSE 0 END) AS aborted_execution_count, 
        SUM(CASE WHEN rs.execution_type_desc='Regular' THEN count_executions ELSE 0 END) AS regular_execution_count, 
        SUM(CASE WHEN rs.execution_type_desc='Exception' THEN count_executions ELSE 0 END) AS exception_execution_count, 
        SUM(count_executions) AS total_executions, 
        MIN(qt.query_sql_text) AS sampled_query_text
    FROM sys.query_store_query_text AS qt
    JOIN sys.query_store_query AS q ON qt.query_text_id=q.query_text_id
    JOIN sys.query_store_plan AS p ON q.query_id=p.query_id
    JOIN sys.query_store_runtime_stats AS rs ON rs.plan_id=p.plan_id
    JOIN sys.query_store_runtime_stats_interval AS rsi ON rsi.runtime_stats_interval_id=rs.runtime_stats_interval_id
    WHERE 
            rs.execution_type_desc IN ('Regular', 'Aborted', 'Exception') AND 
        rsi.start_time>=DATEADD(HOUR, -2, GETUTCDATE())
     GROUP BY q.query_hash), 
OrderedCPU AS 
    (SELECT *, 
    ROW_NUMBER() OVER (ORDER BY total_cpu_ms DESC, query_hash ASC) AS RN
    FROM AggregatedCPU)
SELECT *
FROM OrderedCPU AS OD
WHERE OD.RN<=15
ORDER BY total_cpu_ms DESC;
GO

Deze query wordt gegroepeerd op een gehashte waarde van de query. Als u een hoge waarde in de number_of_distinct_query_ids kolom vindt, moet u onderzoeken of een query die vaak wordt uitgevoerd niet juist is geparameteriseerd. Niet-geparameteriseerde query's kunnen worden gecompileerd voor elke uitvoering, die aanzienlijke CPU verbruikt en invloed heeft op de prestaties van Query Store.

Als u meer wilt weten over een afzonderlijke query, noteert u de query-hash en gebruikt u deze om het CPU-gebruik en het queryplan voor een bepaalde query-hash te identificeren.

Query's uitvoeren op de meest vaak gecompileerde query's per query-hash

Het compileren van een queryplan is een CPU-intensief proces. Azure SQL Database-cacheplannen in het geheugen voor hergebruik. Sommige query's kunnen vaak worden gecompileerd als ze niet worden geparameteriseerd of als RECOMPILE-hints hercompilatie afdwingen.

Query Store houdt het aantal keren bij dat query's worden gecompileerd. Voer de volgende query uit om de top 20 query's in Query Store te identificeren op basis van het aantal compilaties, samen met het gemiddelde aantal compilaties per minuut:

SELECT TOP (20)
    query_hash,
    MIN(initial_compile_start_time) as initial_compile_start_time,
    MAX(last_compile_start_time) as last_compile_start_time,
    CASE WHEN DATEDIFF(mi,MIN(initial_compile_start_time), MAX(last_compile_start_time)) > 0
        THEN 1.* SUM(count_compiles) / DATEDIFF(mi,MIN(initial_compile_start_time), 
            MAX(last_compile_start_time)) 
        ELSE 0 
        END as avg_compiles_minute,
    SUM(count_compiles) as count_compiles
FROM sys.query_store_query AS q
GROUP BY query_hash
ORDER BY count_compiles DESC;
GO

Als u meer wilt weten over een afzonderlijke query, noteert u de query-hash en gebruikt u deze om het CPU-gebruik en het queryplan voor een bepaalde query-hash te identificeren.

Het CPU-gebruik en het queryplan voor een bepaalde query-hash identificeren

Voer de volgende query uit om de afzonderlijke query-id, querytekst en uitvoeringsplannen voor een bepaalde query_hashquery te vinden. DE CPU-tijd wordt geretourneerd in milliseconden.

Vervang de waarde voor de @query_hash variabele door een geldige query_hash waarde voor uw workload.

declare @query_hash binary(8);

SET @query_hash = 0x6557BE7936AA2E91;

with query_ids as (
    SELECT
        q.query_hash,
        q.query_id,
        p.query_plan_hash,
        SUM(qrs.count_executions) * AVG(qrs.avg_cpu_time)/1000. as total_cpu_time_ms,
        SUM(qrs.count_executions) AS sum_executions,
        AVG(qrs.avg_cpu_time)/1000. AS avg_cpu_time_ms
    FROM sys.query_store_query q
    JOIN sys.query_store_plan p on q.query_id=p.query_id
    JOIN sys.query_store_runtime_stats qrs on p.plan_id = qrs.plan_id
    WHERE q.query_hash = @query_hash
    GROUP BY q.query_id, q.query_hash, p.query_plan_hash)
SELECT qid.*,
    qt.query_sql_text,
    p.count_compiles,
    TRY_CAST(p.query_plan as XML) as query_plan
FROM query_ids as qid
JOIN sys.query_store_query AS q ON qid.query_id=q.query_id
JOIN sys.query_store_query_text AS qt on q.query_text_id = qt.query_text_id
JOIN sys.query_store_plan AS p ON qid.query_id=p.query_id and qid.query_plan_hash=p.query_plan_hash
ORDER BY total_cpu_time_ms DESC;
GO

Deze query retourneert één rij voor elke variatie van een uitvoeringsplan voor de query_hash hele geschiedenis van uw Query Store. De resultaten worden gesorteerd op totale CPU-tijd.

Interactieve Query Store-hulpprogramma's gebruiken om historisch CPU-gebruik bij te houden

Als u liever grafische hulpprogramma's gebruikt, volgt u deze stappen om de interactieve Query Store-hulpprogramma's in SSMS te gebruiken.

  1. Open SSMS en maak verbinding met uw database in Objectverkenner.
  2. Vouw het databaseknooppunt uit in Objectverkenner
  3. Vouw de map Query Store uit.
  4. Open het deelvenster Algemeen resourceverbruik .

De totale CPU-tijd voor uw database gedurende de afgelopen maand in milliseconden wordt weergegeven in het linkerbenedengedeelte van het deelvenster. In de standaardweergave wordt DE CPU-tijd geaggregeerd per dag.

Screenshot shows the Overall Resource Consumption view of Query Store in SSMS.

Selecteer Configureren in de rechterbovenhoek van het deelvenster om een andere periode te selecteren. U kunt ook de aggregatie-eenheid wijzigen. U kunt er bijvoorbeeld voor kiezen om gegevens voor een specifiek datumbereik weer te geven en de gegevens per uur samen te voegen.

Interactieve Query Store-hulpprogramma's gebruiken om de belangrijkste query's te identificeren op CPU-tijd

Selecteer een staaf in de grafiek om in te zoomen en te zien hoe query's in een bepaalde periode worden uitgevoerd. Het deelvenster Query's voor het grootste resourcegebruik wordt geopend. U kunt ook query's voor het grootste aantal resources openen vanuit het Query Store-knooppunt onder uw database in Objectverkenner rechtstreeks.

Screenshot shows the Top Resource Consuming Queries pane for Query Store in S S M S.

In de standaardweergave worden in het deelvenster Query's voor het grootste resourcegebruik query's weergegeven op duur (ms). Duur kan soms lager zijn dan DE CPU-tijd: query's die parallellisme gebruiken, kunnen veel meer CPU-tijd gebruiken dan hun totale duur. De duur kan ook hoger zijn dan de CPU-tijd als de wachttijden aanzienlijk zijn. Als u query's per CPU-tijd wilt bekijken, selecteert u de vervolgkeuzelijst Metrische gegevens linksboven in het deelvenster en selecteert u CPU-tijd(ms).

Elke balk in het kwadrant linksboven vertegenwoordigt een query. Selecteer een balk om details voor die query weer te geven. In het kwadrant rechtsboven van het scherm ziet u hoeveel uitvoeringsplannen er zijn in Query Store voor die query en worden deze toegewezen op basis van het moment waarop ze zijn uitgevoerd en hoeveel van de geselecteerde metrische gegevens zijn gebruikt. Selecteer elke plan-id om te bepalen welk queryuitvoeringsplan wordt weergegeven in de onderste helft van het scherm.

Notitie

Zie Best practices met Query Store voor een handleiding voor het interpreteren van Query Store-weergaven en de shapes die worden weergegeven in de weergave Topresourceconsumenten

CPU-gebruik verminderen

Een deel van uw probleemoplossing moet meer informatie bevatten over de query's die in de vorige sectie zijn geïdentificeerd. U kunt het CPU-gebruik verminderen door indexen af te stemmen, toepassingspatronen te wijzigen, query's af te stemmen en CPU-gerelateerde instellingen voor uw database aan te passen.

Bekijk de volgende strategieën in deze sectie.

CPU-gebruik verminderen met automatisch afstemmen van indexen

Effectieve indexafstemming vermindert het CPU-gebruik voor veel query's. Geoptimaliseerde indexen verminderen de logische en fysieke leesbewerkingen voor een query, wat vaak leidt tot minder werk voor de query.

Azure SQL Database biedt automatisch indexbeheer voor workloads op primaire replica's. Automatisch indexbeheer maakt gebruik van machine learning voor het bewaken van uw workload en het optimaliseren van niet-geclusterde indexen op basis van een rijopslagschijf voor uw database.

Bekijk de aanbevelingen voor prestaties, inclusief indexaan aanbevelingen, in Azure Portal. U kunt deze aanbevelingen handmatig toepassen of de optie voor automatisch afstemmen van CREATE INDEX inschakelen om de prestaties van nieuwe indexen in uw database te maken en te controleren.

CPU-gebruik verminderen met automatische correctie van plannen (force plan)

Een andere veelvoorkomende oorzaak van hoge CPU-incidenten is regressie van het uitvoeringsplan. Azure SQL Database biedt de optie voor automatisch afstemmen van geforceerde plannen om regressies in queryuitvoeringsplannen in workloads op primaire replica's te identificeren. Als deze functie voor automatisch afstemmen is ingeschakeld, test Azure SQL Database of het afdwingen van een queryuitvoeringsplan resulteert in betrouwbare verbeterde prestaties voor query's met regressie van het uitvoeringsplan.

Als uw database na maart 2020 is gemaakt, is de optie voor automatisch afstemmen van geforceerd plannen automatisch ingeschakeld. Als uw database vóór deze tijd is gemaakt, wilt u mogelijk de optie voor automatisch afstemmen van het geforceerde plan inschakelen.

Indexen handmatig afstemmen

Gebruik de methoden die worden beschreven in Identificeren van de oorzaken van een hoog CPU-gebruik om queryplannen te identificeren voor uw meest cpu-verbruikende query's. Deze uitvoeringsplannen helpen u bij het identificeren en toevoegen van niet-geclusterde indexen om uw query's sneller te maken.

Elke niet-geclusterde index op basis van een schijf in uw database vereist opslagruimte en moet worden onderhouden door de SQL-engine. Wijzig bestaande indexen in plaats van nieuwe indexen toe te voegen indien mogelijk en zorg ervoor dat nieuwe indexen het CPU-gebruik kunnen verminderen. Zie Ontwerprichtlijnen voor niet-geclusterde indexen voor een overzicht van niet-geclusterde indexen.

Voor sommige workloads kunnen columnstore-indexen de beste keuze zijn om de CPU van frequente leesquery's te verminderen. Zie Columnstore-indexen - Ontwerprichtlijnen voor aanbevelingen op hoog niveau voor scenario's waarin columnstore-indexen mogelijk geschikt zijn.

Uw toepassing, query's en database-instellingen afstemmen

Bij het onderzoeken van uw belangrijkste query's vindt u mogelijk antipatroon van toepassingen, zoals 'chatty'-gedrag, workloads die baat hebben bij sharding en suboptimale databasetoegangsontwerp. Voor leesintensieve workloads kunt u alleen-lezen replica's overwegen om alleen-lezen queryworkloads te offloaden en caching in de toepassingslaag als langetermijnstrategieën om regelmatig leesgegevens uit te schalen.

U kunt er ook voor kiezen om de belangrijkste CPU handmatig af te stemmen met behulp van query's die zijn geïdentificeerd in uw workload. Handmatige afstemmingsopties omvatten het herschrijven van Transact-SQL-instructies, het afdwingen van plannen in Query Store en het toepassen van queryhints.

Als u gevallen identificeert waarbij query's soms een uitvoeringsplan gebruiken dat niet optimaal is voor prestaties, bekijkt u de oplossingen in query's die problemen met parametergevoelig plan (PSP) ondervinden

Als u niet-geparameteriseerde query's met een groot aantal plannen identificeert, kunt u overwegen om deze query's te parameteriseren en ervoor te zorgen dat u de parametergegevenstypen volledig declareert, inclusief lengte en precisie. Dit kan worden gedaan door de query's te wijzigen, een planhandleiding te maken om parameters van een specifieke query af te dwingen of door geforceerde parameterisatie op databaseniveau in te schakelen.

Als u query's met hoge compilatiepercentages identificeert, identificeert u wat de frequente compilatie veroorzaakt. De meest voorkomende oorzaak van frequente compilatie is RECOMPILE-hints. Identificeer waar mogelijk wanneer de RECOMPILE hint is toegevoegd en welk probleem het was bedoeld om op te lossen. Onderzoek of een alternatieve oplossing voor het afstemmen van prestaties kan worden geïmplementeerd om consistente prestaties te bieden voor vaak uitgevoerde query's zonder hint RECOMPILE .

CPU-gebruik verminderen door de maximale mate van parallelle uitvoering af te stemmen

De maximale mate van parallelle uitvoering (MAXDOP) bepaalt intraqueryparallelisme in de database-engine. Hogere MAXDOP-waarden leiden doorgaans tot meer parallelle threads per query en snellere uitvoering van query's.

In sommige gevallen kan een groot aantal parallelle query's die gelijktijdig worden uitgevoerd, een workload vertragen en een hoog CPU-gebruik veroorzaken. Overmatige parallelle uitvoering is het meest waarschijnlijk in databases met een groot aantal vCores waarbij MAXDOP is ingesteld op een hoog getal of op nul. Wanneer MAXDOP is ingesteld op nul, stelt de database-engine het aantal schedulers in dat door parallelle threads moet worden gebruikt voor het totale aantal logische kernen of 64, afhankelijk van wat kleiner is.

U kunt de maximale mate van parallelle uitvoering voor uw database identificeren met Transact-SQL. Verbinding maken naar uw database met SSMS of Azure Data Studio en voer de volgende query uit:

SELECT 
    name, 
    value, 
    value_for_secondary, 
    is_value_default 
FROM sys.database_scoped_configurations
WHERE name=N'MAXDOP';
GO

U kunt experimenteren met kleine wijzigingen in de MAXDOP-configuratie op databaseniveau of afzonderlijke problematische query's wijzigen om een niet-standaard MAXDOP te gebruiken met behulp van een queryhint. Zie de voorbeelden voor het configureren van de maximale mate van parallelle uitvoering voor meer informatie.

Wanneer cpu-resources toevoegen

Het kan zijn dat de query's en indexen van uw workload goed zijn afgestemd of dat voor het afstemmen van de prestaties wijzigingen zijn vereist die u op korte termijn niet kunt aanbrengen vanwege interne processen of andere redenen. Het toevoegen van meer CPU-resources kan nuttig zijn voor deze databases. U kunt databasebronnen schalen met minimale downtime.

U kunt meer CPU-resources toevoegen aan uw Azure SQL Database door het aantal vCores of de hardwareconfiguratie voor databases te configureren met behulp van het vCore-aankoopmodel.

Onder het aankoopmodel op basis van DTU kunt u uw servicelaag verhogen en het aantal DTU's (Database Transaction Units) verhogen. Een DTU vertegenwoordigt een gemengde meting van CPU, geheugen, leesbewerkingen en schrijfbewerkingen. Een voordeel van het vCore-aankoopmodel is dat het meer gedetailleerde controle over de hardware in gebruik en het aantal vCores mogelijk maakt. U kunt Azure SQL Database migreren van het DTU-model naar het vCore-model om over te stappen tussen aankoopmodellen.

Gerelateerde inhoud

Meer informatie over het bewaken en afstemmen van prestaties van Azure SQL Database vindt u in de volgende artikelen: