Share via

Diagnosticar e resolver problemas de CPU elevada na Base de Dados SQL do Azure

  • Artigo

Aplica-se a:Banco de Dados SQL do Azure

O Banco de Dados SQL do Azure fornece ferramentas internas para identificar as causas do alto uso da CPU e otimizar o desempenho da carga de trabalho. Você pode usar essas ferramentas para solucionar problemas de alto uso da CPU enquanto ele está ocorrendo, ou reativamente após a conclusão do incidente. Você também pode habilitar o ajuste automático para reduzir proativamente o uso da CPU ao longo do tempo para seu banco de dados. Este artigo ensina a diagnosticar e solucionar problemas de alta CPU com ferramentas internas no Banco de Dados SQL do Azure e explica quando adicionar recursos de CPU.

Compreender a contagem de vCore

É útil entender o número de núcleos virtuais (vCores) disponíveis para seu banco de dados ao diagnosticar um incidente de alta CPU. Um vCore é equivalente a uma CPU lógica. O número de vCores ajuda você a entender os recursos de CPU disponíveis para seu banco de dados.

Identificar a contagem de vCore no portal do Azure

Você pode identificar rapidamente a contagem de vCore para um banco de dados no portal do Azure se estiver usando uma camada de serviço baseada em vCore com a camada de computação provisionada. Nesse caso, a camada de preço listada para o banco de dados em sua página Visão geral conterá a contagem de vCore. Por exemplo, o nível de preços de um banco de dados pode ser 'Propósito geral: série padrão (Gen5), 16 vCores'.

Para bancos de dados na camada de computação sem servidor, a contagem de vCore sempre será equivalente à configuração máxima de vCore para o banco de dados. A contagem de VCore será exibida no nível de preço listado para o banco de dados em sua página Visão geral. Por exemplo, a camada de preço de um banco de dados pode ser 'Propósito geral: sem servidor, série padrão (Gen5), 16 vCores'.

Se você estiver usando um banco de dados no modelo de compra baseado em DTU, precisará usar o Transact-SQL para consultar a contagem vCore do banco de dados.

Identificar a contagem de vCore com o Transact-SQL

Você pode identificar a contagem vCore atual para qualquer banco de dados com o Transact-SQL. Você pode executar o Transact-SQL no Banco de Dados SQL do Azure com o SQL Server Management Studio (SSMS), o Azure Data Studio ou o editor de consultas do portal do Azure.

Conecte-se ao seu banco de dados e execute a seguinte consulta:

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

Identificar as causas da alta CPU

Você pode medir e analisar a utilização da CPU usando o portal do Azure, as ferramentas interativas do Repositório de Consultas no SSMS e as consultas Transact-SQL no SSMS e no Azure Data Studio.

O portal do Azure e o Repositório de Consultas mostram estatísticas de execução, como métricas de CPU, para consultas concluídas. Se você estiver enfrentando um incidente atual de alta CPU que possa ser causado por uma ou mais consultas de longa execução em andamento, identifique as consultas atualmente em execução com o Transact-SQL.

As causas comuns da alta utilização da CPU nova e incomum são:

  • Novas consultas na carga de trabalho que usam uma grande quantidade de CPU.
  • Um aumento na frequência de consultas em execução regular.
  • Regressão do plano de consulta, incluindo regressão devido a problemas de plano sensível a parâmetros (PSP), resultando em uma ou mais consultas consumindo mais CPU.
  • Aumento significativo da compilação ou recompilação de planos de consulta.
  • Bancos de dados onde as consultas usam paralelismo excessivo.

Para entender o que está causando seu incidente de alta CPU, identifique quando a alta utilização da CPU está ocorrendo em relação ao seu banco de dados e as principais consultas que usam a CPU naquele momento.

Examinar:

Nota

O Banco de Dados SQL do Azure requer recursos de computação para implementar recursos de serviço principais, como alta disponibilidade e recuperação de desastres, backup e restauração de banco de dados, monitoramento, Repositório de Consultas, ajuste automático, etc. O uso desses recursos de computação pode ser particularmente percetível em bancos de dados com baixas contagens de vCore ou bancos de dados em pools elásticos densos. Saiba mais em Gerenciamento de recursos no Banco de Dados SQL do Azure.

Use o portal do Azure para acompanhar várias métricas de CPU, incluindo a porcentagem de CPU disponível usada pelo seu banco de dados ao longo do tempo. O portal do Azure combina métricas de CPU com informações do Repositório de Consultas do seu banco de dados, o que permite identificar quais consultas consumiram CPU em seu banco de dados em um determinado momento.

Siga estas etapas para encontrar métricas de porcentagem de CPU.

  1. Navegue até o banco de dados no portal do Azure.
  2. Em Desempenho Inteligente no menu à esquerda, selecione Query Performance Insight.

O modo de exibição padrão do Query Performance Insight mostra 24 horas de dados. O uso da CPU é mostrado como uma porcentagem do total de CPU disponível usada para o banco de dados.

As cinco principais consultas em execução nesse período são exibidas em barras verticais acima do gráfico de uso da CPU. Selecione uma faixa de tempo no gráfico ou use o menu Personalizar para explorar períodos de tempo específicos. Você também pode aumentar o número de consultas mostradas.

Screenshot shows Query Performance Insight in the Azure portal.

Selecione cada ID de consulta exibindo CPU alta para abrir os detalhes da consulta. Os detalhes incluem o texto da consulta juntamente com o histórico de desempenho da consulta. Examine se a CPU aumentou para a consulta recentemente.

Anote a ID da consulta para investigar melhor o plano de consulta usando o Repositório de Consultas na seção a seguir.

Rever os planos de consulta para as principais consultas identificadas no portal do Azure

Siga estas etapas para usar uma ID de consulta nas ferramentas interativas do Repositório de Consultas do SSMS para examinar o plano de execução da consulta ao longo do tempo.

  1. Abra o SQL Server Management Studio.
  2. Conecte-se ao Banco de Dados SQL do Azure no Pesquisador de Objetos.
  3. Expanda o nó do banco de dados no Pesquisador de Objetos.
  4. Expanda a pasta Repositório de Consultas.
  5. Abra o painel Consultas controladas .
  6. Insira o ID da consulta na caixa Acompanhamento de consulta no canto superior esquerdo da tela e pressione enter.
  7. Se necessário, selecione Configurar para ajustar o intervalo de tempo para corresponder ao tempo em que estava ocorrendo alta utilização da CPU.

A página mostrará o(s) plano(s) de execução e as métricas relacionadas para a consulta nas últimas 24 horas.

Identificar consultas atualmente em execução com o Transact-SQL

O Transact-SQL permite identificar consultas em execução no momento com o tempo de CPU usado até agora. Você também pode usar o Transact-SQL para consultar o uso recente da CPU em seu banco de dados, as principais consultas por CPU e as consultas compiladas com mais frequência.

Você pode consultar métricas de CPU com o SQL Server Management Studio (SSMS), o Azure Data Studio ou o editor de consultas do portal do Azure. Ao usar o SSMS ou o Azure Data Studio, abra uma nova janela de consulta e conecte-a ao seu banco de dados (não ao master banco de dados).

Encontre consultas atualmente em execução com o uso da CPU e planos de execução executando a consulta a seguir. O tempo da CPU é retornado em milissegundos.

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

Esta consulta retorna duas cópias do plano de execução. A coluna query_plan contém o plano de execução de sys.dm_exec_query_plan. Esta versão do plano de consulta contém apenas estimativas de contagens de linhas e não contém estatísticas de execução.

Se a coluna query_plan_with_in_flight_statistics retornar um plano de execução, esse plano fornecerá mais informações. A query_plan_with_in_flight_statistics coluna retorna dados do sys.dm_exec_query_statistics_xml, que inclui estatísticas de execução "em voo", como o número real de linhas retornadas até agora por uma consulta em execução no momento.

Revise as métricas de uso da CPU para a última hora

A consulta a seguir retorna o uso médio da CPU em intervalos de 15 segundos para aproximadamente a sys.dm_db_resource_stats última hora.

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

É importante não focar apenas na avg_cpu_percent coluna. A avg_instance_cpu_percent coluna inclui a CPU usada por cargas de trabalho internas e de usuário. Se avg_instance_cpu_percent estiver perto de 100%, os recursos da CPU estão saturados. Nesse caso, você deve solucionar problemas de alta taxa de transferência do aplicativo se a taxa de transferência do aplicativo for insuficiente ou a latência da consulta for alta.

Saiba mais em Gerenciamento de recursos no Banco de Dados SQL do Azure.

Analise os exemplos em sys.dm_db_resource_stats para obter mais consultas.

Consultar as 15 principais consultas recentes por uso da CPU

O Repositório de Consultas rastreia as estatísticas de execução, incluindo o uso da CPU, para consultas. A consulta a seguir retorna as 15 principais consultas executadas nas últimas 2 horas, classificadas por uso da CPU. O tempo da CPU é retornado em milissegundos.

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

Esta consulta agrupa-se por um valor em hash da consulta. Se você encontrar um valor alto na number_of_distinct_query_ids coluna, investigue se uma consulta executada com frequência não está parametrizada corretamente. Consultas não parametrizadas podem ser compiladas em cada execução, o que consome CPU significativa e afeta o desempenho do Repositório de Consultas.

Para saber mais sobre uma consulta individual, anote o hash de consulta e use-o para Identificar o uso da CPU e o plano de consulta para um determinado hash de consulta.

Consultar as consultas compiladas com mais frequência por hash de consulta

A compilação de um plano de consulta é um processo que consome muita CPU. Planos de cache do Banco de Dados SQL do Azure na memória para reutilização. Algumas consultas podem ser compiladas com frequência se não forem parametrizadas ou se as dicas RECOMPILE forçarem a recompilação.

O Repositório de Consultas controla o número de vezes que as consultas são compiladas. Execute a seguinte consulta para identificar as 20 principais consultas no Repositório de Consultas por contagem de compilações, juntamente com o número médio de compilações por minuto:

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

Para saber mais sobre uma consulta individual, anote o hash de consulta e use-o para Identificar o uso da CPU e o plano de consulta para um determinado hash de consulta.

Identificar o uso da CPU e o plano de consulta para um determinado hash de consulta

Execute a consulta a seguir para localizar a ID de consulta individual, o texto da consulta e os planos de execução de consulta para um determinado query_hash. O tempo da CPU é retornado em milissegundos.

Substitua o valor da @query_hash variável por um válido query_hash para sua carga de trabalho.

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

Essa consulta retorna uma linha para cada variação de um plano de execução para todo o query_hash histórico do seu Repositório de Consultas. Os resultados são ordenados por tempo total de CPU.

Use ferramentas interativas do Repositório de Consultas para rastrear a utilização histórica da CPU

Se preferir usar ferramentas gráficas, siga estas etapas para usar as ferramentas interativas do Repositório de Consultas no SSMS.

  1. Abra o SSMS e conecte-se ao seu banco de dados no Pesquisador de Objetos.
  2. Expandir o nó do banco de dados no Pesquisador de Objetos
  3. Expanda a pasta Repositório de Consultas.
  4. Abra o painel Consumo Geral de Recursos .

O tempo total de CPU do banco de dados no último mês, em milissegundos, é mostrado na parte inferior esquerda do painel. Na visualização padrão, o tempo da CPU é agregado por dia.

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

Selecione Configurar no canto superior direito do painel para selecionar um período de tempo diferente. Você também pode alterar a unidade de agregação. Por exemplo, você pode optar por ver os dados de um intervalo de datas específico e agregar os dados por hora.

Use ferramentas interativas do Repositório de Consultas para identificar as principais consultas por tempo de CPU

Selecione uma barra no gráfico para detalhar e ver as consultas em execução em um período de tempo específico. O painel Principais Consultas que Consomem Recursos será aberto. Como alternativa, você pode abrir diretamente as Consultas que Consomem Principais Recursos a partir do nó Repositório de Consultas em seu banco de dados no Pesquisador de Objetos.

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

No modo de exibição padrão, o painel Principais Consultas que Consomem Recursos mostra consultas por Duração (ms). Às vezes, a duração pode ser menor do que o tempo da CPU: as consultas que usam paralelismo podem usar muito mais tempo da CPU do que a duração total. A duração também pode ser maior do que o tempo da CPU se os tempos de espera forem significativos. Para ver as consultas por tempo de CPU, selecione a lista suspensa Métrica no canto superior esquerdo do painel e selecione Tempo(s) da CPU.

Cada barra no quadrante superior esquerdo representa uma consulta. Selecione uma barra para ver os detalhes dessa consulta. O quadrante superior direito da tela mostra quantos planos de execução estão no Repositório de Consultas para essa consulta e os mapeia de acordo com quando foram executados e quanto da métrica selecionada foi usada. Selecione cada ID do plano para controlar qual plano de execução de consulta é exibido na metade inferior da tela.

Nota

Para obter um guia para interpretar os modos de exibição do Repositório de Consultas e as formas que aparecem no modo de exibição Principais Consumidores de Recursos, consulte Práticas recomendadas com o Repositório de Consultas

Reduza o uso da CPU

Parte da solução de problemas deve incluir saber mais sobre as consultas identificadas na seção anterior. Você pode reduzir o uso da CPU ajustando índices, modificando os padrões do aplicativo, ajustando consultas e ajustando as configurações relacionadas à CPU para o banco de dados.

Considere as seguintes estratégias nesta seção.

Reduza o uso da CPU com ajuste automático de índice

O ajuste eficaz do índice reduz o uso da CPU para muitas consultas. Os índices otimizados reduzem as leituras lógicas e físicas de uma consulta, o que geralmente faz com que a consulta precise fazer menos trabalho.

O Banco de Dados SQL do Azure oferece gerenciamento automático de índice para cargas de trabalho em réplicas primárias. O gerenciamento automático de índices usa aprendizado de máquina para monitorar sua carga de trabalho e otimizar índices não clusterizados baseados em disco de armazenamento de linha para seu banco de dados.

Analise as recomendações de desempenho, incluindo recomendações de índice, no portal do Azure. Você pode aplicar essas recomendações manualmente ou habilitar a opção de ajuste automático CREATE INDEX para criar e verificar o desempenho de novos índices em seu banco de dados.

Reduza o uso da CPU com a correção automática do plano (plano de força)

Outra causa comum de altos incidentes de CPU é a regressão de escolha do plano de execução. O Banco de Dados SQL do Azure oferece a opção de ajuste automático de plano de força para identificar regressões em planos de execução de consulta em cargas de trabalho em réplicas primárias. Com esse recurso de ajuste automático habilitado, o Banco de Dados SQL do Azure testará se forçar um plano de execução de consulta resulta em desempenho aprimorado confiável para consultas com regressão de plano de execução.

Se o banco de dados tiver sido criado após março de 2020, a opção de ajuste automático do plano de força foi ativada automaticamente. Se o banco de dados tiver sido criado antes desse período, convém habilitar a opção de ajuste automático do plano de força.

Ajustar índices manualmente

Use os métodos descritos em Identificar as causas da alta CPU para identificar planos de consulta para suas principais consultas consumidoras de CPU . Esses planos de execução ajudarão você a identificar e adicionar índices não clusterizados para acelerar suas consultas.

Cada índice não clusterizado baseado em disco em seu banco de dados requer espaço de armazenamento e deve ser mantido pelo mecanismo SQL. Modifique os índices existentes em vez de adicionar novos índices quando possível e garanta que os novos índices reduzam com êxito o uso da CPU. Para obter uma visão geral dos índices não clusterizados, consulte Diretrizes de design de índice não clusterizado.

Para algumas cargas de trabalho, os índices columnstore podem ser a melhor opção para reduzir a CPU de consultas de leitura frequentes. Consulte Columnstore indexes - Design guidance para obter recomendações de alto nível sobre cenários em que os índices columnstore podem ser apropriados.

Ajuste suas configurações de aplicativo, consultas e banco de dados

Ao examinar suas principais consultas, você pode encontrar antipadrões de aplicativos, como comportamento "tagarela", cargas de trabalho que se beneficiariam da fragmentação e design de acesso ao banco de dados abaixo do ideal. Para cargas de trabalho com muita leitura, considere réplicas somente leitura para descarregar cargas de trabalho de consulta somente leitura e cache da camada de aplicativo como estratégias de longo prazo para expandir dados lidos com frequência.

Você também pode optar por ajustar manualmente a CPU superior usando consultas identificadas em sua carga de trabalho. As opções de ajuste manual incluem reescrever instruções Transact-SQL, forçar planos no Repositório de Consultas e aplicar dicas de consulta.

Se você identificar casos em que as consultas às vezes usam um plano de execução que não é ideal para o desempenho, revise as soluções em consultas que apresentam problemas de plano sensível a parâmetros (PSP)

Se você identificar consultas não parametrizadas com um alto número de planos, considere parametrizar essas consultas, certificando-se de declarar totalmente os tipos de dados de parâmetros, incluindo comprimento e precisão. Isso pode ser feito modificando as consultas, criando um guia de plano para forçar a parametrização de uma consulta específica ou habilitando a parametrização forçada no nível do banco de dados.

Se você identificar consultas com altas taxas de compilação, identifique o que causa a compilação frequente. A causa mais comum de compilação frequente são as dicas RECOMPILE. Sempre que possível, identifique quando a dica foi adicionada e qual problema RECOMPILE deveria ser resolvido. Investigue se uma solução alternativa de ajuste de desempenho pode ser implementada para fornecer desempenho consistente para consultas executadas com frequência sem uma RECOMPILE dica.

Reduza o uso da CPU ajustando o grau máximo de paralelismo

A configuração de grau máximo de paralelismo (MAXDOP) controla o paralelismo intraconsulta no mecanismo de banco de dados. Valores MAXDOP mais altos geralmente resultam em mais threads paralelos por consulta e execução de consulta mais rápida.

Em alguns casos, um grande número de consultas paralelas em execução simultânea pode diminuir a carga de trabalho e causar alto uso da CPU. É mais provável que ocorra paralelismo excessivo em bancos de dados com um grande número de vCores onde MAXDOP é definido como um número alto ou zero. Quando MAXDOP é definido como zero, o mecanismo de banco de dados define o número de agendadores a serem usados por threads paralelos para o número total de núcleos lógicos ou 64, o que for menor.

Você pode identificar a configuração do grau máximo de paralelismo para seu banco de dados com o Transact-SQL. Conecte-se ao seu banco de dados com o SSMS ou o Azure Data Studio e execute a seguinte consulta:

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

Considere experimentar pequenas alterações na configuração do MAXDOP no nível do banco de dados ou modificar consultas problemáticas individuais para usar um MAXDOP não padrão usando uma dica de consulta. Para obter mais informações, consulte os exemplos em configurar o grau máximo de paralelismo.

Quando adicionar recursos da CPU

Você pode achar que as consultas e os índices da sua carga de trabalho estão ajustados corretamente ou que o ajuste de desempenho requer alterações que não podem ser feitas a curto prazo devido a processos internos ou outros motivos. Adicionar mais recursos de CPU pode ser benéfico para esses bancos de dados. Você pode dimensionar os recursos do banco de dados com o mínimo de tempo de inatividade.

Você pode adicionar mais recursos de CPU ao seu Banco de Dados SQL do Azure configurando a contagem vCore ou a configuração de hardware para bancos de dados usando o modelo de compra vCore.

No modelo de compra baseado em DTU, você pode aumentar sua camada de serviço e aumentar o número de unidades de transação de banco de dados (DTUs). Uma DTU representa uma medida combinada de CPU, memória, leituras e gravações. Um benefício do modelo de compra vCore é que ele permite um controle mais granular sobre o hardware em uso e o número de vCores. Você pode migrar o Banco de Dados SQL do Azure do modelo baseado em DTU para o modelo baseado em vCore para fazer a transição entre modelos de compra.

Conteúdos relacionados

Saiba mais sobre como monitorar e ajustar o desempenho do Banco de Dados SQL do Azure nos seguintes artigos: