Otimizar consultas de log no Azure MonitorOptimize log queries in Azure Monitor

O Azure Monitor Logs utiliza o Azure Data Explorer (ADX) para armazenar dados de registo e executar consultas para analisar esses dados.Azure Monitor Logs uses Azure Data Explorer (ADX) to store log data and run queries for analyzing that data. Cria, gere e mantém os clusters ADX para si, e otimiza-os para a sua carga de trabalho de análise de registo.It creates, manages, and maintains the ADX clusters for you, and optimizes them for your log analysis workload. Quando você faz uma consulta, é otimizado, e encaminhado para o cluster ADX apropriado que armazena os dados do espaço de trabalho.When you run a query, it's optimized, and routed to the appropriate ADX cluster that stores the workspace data. Tanto os Registos monitores Azure como o Azure Data Explorer utilizam muitos mecanismos automáticos de otimização de consultas.Both Azure Monitor Logs and Azure Data Explorer uses many automatic query optimization mechanisms. Embora as otimizações automáticas proporcionem um impulso significativo, existem alguns casos em que pode melhorar drasticamente o seu desempenho de consulta.While automatic optimizations provide significant boost, there are some cases where you can dramatically improve your query performance. Este artigo explica as considerações de desempenho e várias técnicas para corrigi-las.This article explains the performance considerations and several techniques to fix them.

A maioria das técnicas são comuns a consultas que são executadas diretamente em Azure Data Explorer e Azure Monitor Logs, embora existam várias considerações únicas de Registos do Monitor Azure que são discutidas aqui.Most of the techniques are common to queries that are run directly on Azure Data Explorer and Azure Monitor Logs, though there are several unique Azure Monitor Logs considerations that are discussed here. Para obter mais dicas de otimização do Azure Data Explorer, consulte as melhores práticas de consulta.For more Azure Data Explorer optimization tips, see Query best practices.

Consultas otimizadas:Optimized queries will:

  • Corra mais rápido, reduza a duração total da execução da consulta.Run faster, reduce overall duration of the query execution.
  • Ter menores hipóteses de ser estrangulado ou rejeitado.Have smaller chance of being throttled or rejected.

Deve prestar especial atenção às consultas que são usadas para utilização recorrente e rebentada, tais como dashboards, alertas, Aplicações Lógicas e Power BI.You should give particular attention to queries that are used for recurrent and bursty usage such as dashboards, alerts, Logic Apps and Power BI. O impacto de uma consulta ineficaz nestes casos é substancial.The impact of an ineffective query in these cases is substantial.

Painel de desempenho de consultaQuery performance pane

Depois de fazer uma consulta no Log Analytics, clique na seta para baixo acima dos resultados da consulta para ver o painel de desempenho da consulta que mostra os resultados de vários indicadores de desempenho para a consulta.After you run a query in Log Analytics, click the down arrow above the query results to view the query performance pane that shows the results of several performance indicators for the query. Estes indicadores de desempenho são descritos na secção seguinte.These performance indicators are each described in the following section.

Painel de desempenho de consulta

Indicadores de desempenho de consultaQuery performance indicators

Estão disponíveis os seguintes indicadores de desempenho de consulta para cada consulta que for executada:The following query performance indicators are available for every query that is executed:

  • CPU Total: Computação geral utilizada para processar a consulta em todos os nós computacional.Total CPU: Overall compute used to process the query across all compute nodes. Representa o tempo utilizado para computação, análise e recolha de dados.It represents time used for computing, parsing, and data fetching.

  • Dados utilizados para consulta processada: Dados globais que foram acedidos para processar a consulta.Data used for processed query: Overall data that was accessed to process the query. Influenciado pelo tamanho da tabela-alvo, o tempo de utilização, os filtros aplicados e o número de colunas referenciadas.Influenced by the size of the target table, time span used, filters applied, and the number of columns referenced.

  • Período de tempo da consulta processada: O fosso entre os dados mais recentes e os mais antigos que foram acedidos para processar a consulta.Time span of the processed query: The gap between the newest and the oldest data that was accessed to process the query. Influenciado pelo intervalo de tempo explícito especificado para a consulta.Influenced by the explicit time range specified for the query.

  • Idade dos dados processados: A diferença entre agora e os dados mais antigos que foram acedidos para processar a consulta.Age of processed data: The gap between now and the oldest data that was accessed to process the query. Influencia muito a eficiência da obtenção de dados.It highly influences the efficiency of data fetching.

  • Número de espaços de trabalho: Quantos espaços de trabalho foram acedidos durante o processamento de consulta devido à seleção implícita ou explícita.Number of workspaces: How many workspaces were accessed during the query processing due to implicit or explicit selection.

  • Número de regiões: Quantas regiões foram acedidas durante o processamento de consultas com base na seleção implícita ou explícita dos espaços de trabalho.Number of regions: How many regions were accessed during the query processing based due to implicit or explicit selection of workspaces. As consultas multi-regiões são muito menos eficientes e os indicadores de desempenho apresentam uma cobertura parcial.Multi-region queries are much less efficient and performance indicators present partial coverage.

  • Paralelismo: Indica quanto o sistema foi capaz de executar esta consulta em múltiplos nós.Parallelism: Indicates how much the system was able to execute this query on multiple nodes. Relevante apenas para consultas que têm elevado consumo de CPU.Relevant only to queries that have high CPU consumption. Influenciado pelo uso de funções específicas e operadores.Influenced by usage of specific functions and operators.

Total CPUTotal CPU

O CPU de computação real que foi investido para processar esta consulta em todos os nós de processamento de consulta.The actual compute CPU that was invested to process this query across all the query processing nodes. Uma vez que a maioria das consultas são executadas em um grande número de nós, este será geralmente muito maior do que a duração que a consulta realmente levou a executar.Since most queries are executed on large numbers of nodes, this will usually be much larger than the duration the query actually took to execute.

A consulta que utiliza mais de 100 segundos de CPU é considerada uma consulta que consome recursos excessivos.Query that utilizes more than 100 seconds of CPU is considered a query that consumes excessive resources. A consulta que utiliza mais de 1.000 segundos de CPU é considerada uma consulta abusiva e pode ser estrangulada.Query that utilizes more than 1,000 seconds of CPU is considered an abusive query and might be throttled.

O tempo de processamento de consultas é gasto em:Query processing time is spent on:

  • Recuperação de dados – a recuperação de dados antigos consumirá mais tempo do que a recuperação de dados recentes.Data retrieval – retrieval of old data will consume more time than retrieval of recent data.
  • Processamento de dados – lógica e avaliação dos dados.Data processing – logic and evaluation of the data.

Para além do tempo gasto nos nós de processamento de consultas, existe tempo adicional que é gasto pelos Registos do Monitor Azure para: autenticar o utilizador e verificar se estão autorizados a aceder a estes dados, localizar a loja de dados, analisar a consulta e alocar os nós de processamento de consulta.Other than time spent in the query processing nodes, there is additional time that is spend by Azure Monitor Logs to: authenticate the user and verify that they are permitted to access this data, locate the data store, parse the query, and allocate the query processing nodes. Desta vez não está incluído no tempo total de consulta cpu.This time is not included in the query total CPU time.

Filtragem precoce dos registos antes da utilização de funções de CPU elevadasEarly filtering of records prior of using high CPU functions

Alguns dos comandos e funções de consulta são pesados no seu consumo de CPU.Some of the query commands and functions are heavy in their CPU consumption. Isto é especialmente verdade para comandos que analisam JSON e XML ou extraem expressões regulares complexas.This is especially true for commands that parse JSON and XML or extract complex regular expressions. Tal análise pode acontecer explicitamente através de funções parse_json ou parse_xml() ou implicitamente quando se refere a colunas dinâmicas.Such parsing can happen explicitly via parse_json() or parse_xml() functions or implicitly when referring to dynamic columns.

Estas funções consomem CPU proporcionalmente ao número de linhas que estão a processar.These functions consume CPU in proportion to the number of rows they are processing. A otimização mais eficiente é adicionar onde as condições no início da consulta que podem filtrar o maior número possível de registos antes da função intensiva da CPU ser executada.The most efficient optimization is to add where conditions early in the query that can filter out as many records as possible before the CPU intensive function is executed.

Por exemplo, as seguintes consultas produzem exatamente o mesmo resultado, mas a segunda é de longe a mais eficiente como a condição antes de analisar exclui muitos registos:For example, the following queries produce exactly the same result but the second one is by far the most efficient as the where condition before parsing excludes many records:

//less efficient
SecurityEvent
| extend Details = parse_xml(EventData)
| extend FilePath = tostring(Details.UserData.RuleAndFileData.FilePath)
| extend FileHash = tostring(Details.UserData.RuleAndFileData.FileHash)
| where FileHash != "" and FilePath !startswith "%SYSTEM32"  // Problem: irrelevant results are filtered after all processing and parsing is done
| summarize count() by FileHash, FilePath
//more efficient
SecurityEvent
| where EventID == 8002 //Only this event have FileHash
| where EventData !has "%SYSTEM32" //Early removal of unwanted records
| extend Details = parse_xml(EventData)
| extend FilePath = tostring(Details.UserData.RuleAndFileData.FilePath)
| extend FileHash = tostring(Details.UserData.RuleAndFileData.FileHash)
| where FileHash != "" and FilePath !startswith "%SYSTEM32"  // exact removal of results. Early filter is not accurate enough
| summarize count() by FileHash, FilePath
| where FileHash != "" // No need to filter out %SYSTEM32 here as it was removed before

Evite utilizar a avaliação de onde as cláusulasAvoid using evaluated where clauses

As consultas que contêm onde as cláusulas numa coluna avaliada e não em colunas fisicamente presentes no conjunto de dados perdem eficiência.Queries that contain where clauses on an evaluated column rather than on columns that are physically present in the dataset lose efficiency. A filtragem em colunas avaliadas impede algumas otimizações do sistema quando grandes conjuntos de dados são tratados.Filtering on evaluated columns prevents some system optimizations when large sets of data are handled. Por exemplo, as seguintes consultas produzem exatamente o mesmo resultado, mas a segunda é mais eficiente como a condição se refere a coluna incorporadaFor example, the following queries produce exactly the same result but the second one is more efficient as the where condition refers to built-in column

//less efficient
Syslog
| extend Msg = strcat("Syslog: ",SyslogMessage)
| where  Msg  has "Error"
| count 
//more efficient
Syslog
| where  SyslogMessage  has "Error"
| count 

Em alguns casos, a coluna avaliada é criada implicitamente pelo motor de processamento de consultas, uma vez que a filtragem é feita não apenas no campo:In some cases the evaluated column is created implicitly by the query processing engine since the filtering is done not just on the field:

//less efficient
SecurityEvent
| where tolower(Process) == "conhost.exe"
| count 
//more efficient
SecurityEvent
| where Process =~ "conhost.exe"
| count 

Use comandos e dimensões de agregação eficazes em resumir e juntarUse effective aggregation commands and dimensions in summarize and join

Enquanto alguns comandos de agregação como max(), sum()( count()e avg() têm baixo impacto cpU devido à sua lógica, outros são mais complexos e incluem heurísticas e estimativas que permitem que sejam executados eficientemente.While some aggregation commands like max(), sum(), count(), and avg() have low CPU impact due to their logic, other are more complex and include heuristics and estimations that allow them to be executed efficiently. Por exemplo, o dcount() utiliza o algoritmo HyperLogLog para fornecer uma estimativa próxima à contagem distinta de grandes conjuntos de dados sem realmente contar cada valor; as funções percentil estão a fazer aproximações semelhantes usando o algoritmo percentil de classificação mais próximo.For example, dcount() uses the HyperLogLog algorithm to provide close estimation to distinct count of large sets of data without actually counting each value; the percentile functions are doing similar approximations using the nearest rank percentile algorithm. Vários dos comandos incluem parâmetros opcionais para reduzir o seu impacto.Several of the commands include optional parameters to reduce their impact. Por exemplo, a função makeset() tem um parâmetro opcional para definir o tamanho máximo definido, que afeta significativamente o CPU e a memória.For example, the makeset() function has an optional parameter to define the maximum set size, which significantly affects the CPU and memory.

Junte e resumir os comandos pode causar uma alta utilização do CPU quando estão a processar um grande conjunto de dados.Join and summarize commands may cause high CPU utilization when they are processing a large set of data. A sua complexidade está diretamente relacionada com o número de valores possíveis, referidos como cardinalidade, das colunas que estão a usar como o by in summarize ou como os atributos de união.Their complexity is directly related to the number of possible values, referred to as cardinality, of the columns that are using as the by in summarize or as the join attributes. Para explicação e otimização de juntar e resumir, consulte os seus artigos de documentação e dicas de otimização.For explanation and optimization of join and summarize, see their documentation articles and optimization tips.

Por exemplo, as seguintes consultas produzem exatamente o mesmo resultado porque o CounterPath é sempre um para um mapeado para o ContraName e o ObjectName.For example, the following queries produce exactly the same result because CounterPath is always one-to-one mapped to CounterName and ObjectName. A segunda é mais eficiente, uma vez que a dimensão da agregação é menor:The second one is more efficient as the aggregation dimension is smaller:

//less efficient
Perf
| summarize avg(CounterValue) 
by CounterName, CounterPath, ObjectName
//make the group expression more compact improve the performance
Perf
| summarize avg(CounterValue), any(CounterName), any(ObjectName) 
by CounterPath

O consumo de CPU também pode ser impactado quando as condições ou colunas estendidas requerem computação intensiva.CPU consumption might also be impacted by where conditions or extended columns that require intensive computing. Todas as comparações de cordas triviais tais como igual == e começacom têm aproximadamente o mesmo impacto cpU, enquanto jogos de texto avançados têm mais impacto.All trivial string comparisons such as equal == and startswith have roughly the same CPU impact while advanced text matches have more impact. Especificamente, o operador tem um operador mais eficiente que o operador contém.Specifically, the has operator is more efficient that the contains operator. Devido às técnicas de manuseamento de cordas, é mais eficiente procurar cordas que sejam mais compridas do que quatro caracteres do que cordas curtas.Due to string handling techniques, it is more efficient to look for strings that are longer than four characters than short strings.

Por exemplo, as seguintes consultas produzem resultados semelhantes, dependendo da política de nomeação de computador, mas a segunda é mais eficiente:For example, the following queries produce similar results, depending on Computer naming policy, but the second one is more efficient:

//less efficient – due to filter based on contains
Heartbeat
| where Computer contains "Production" 
| summarize count() by ComputerIP 
//less efficient – due to filter based on extend
Heartbeat
| extend MyComputer = Computer
| where MyComputer startswith "Production" 
| summarize count() by ComputerIP 
//more efficient
Heartbeat
| where Computer startswith "Production" 
| summarize count() by ComputerIP 

Nota

Este indicador apresenta apenas CPU do cluster imediato.This indicator presents only CPU from the immediate cluster. Em consultas multi-regiões, representaria apenas uma das regiões.In multi-region query, it would represent only one of the regions. Em consulta de vários espaços de trabalho, pode não incluir todos os espaços de trabalho.In multi-workspace query, it might not include all workspaces.

Evite análises completas de XML e JSON quando a análise das cordas funcionarAvoid full XML and JSON parsing when string parsing works

A análise completa de um objeto XML ou JSON pode consumir elevados recursos de CPU e memória.Full parsing of an XML or JSON object may consume high CPU and memory resources. Em muitos casos, quando apenas um ou dois parâmetros são necessários e os objetos XML ou JSON são simples, é mais fácil analisá-los como cordas usando o operador de parse ou outras técnicas de análise de texto.In many cases, when only one or two parameters are needed and the XML or JSON objects are simple, it is easier to parse them as strings using the parse operator or other text parsing techniques. O aumento de desempenho será mais significativo à medida que o número de registos no objeto XML ou JSON aumenta.The performance boost will be more significant as the number of records in the XML or JSON object increases. É essencial quando o número de registos atinge dezenas de milhões.It is essential when the number of records reaches tens of millions.

Por exemplo, a seguinte consulta devolverá exatamente os mesmos resultados que as consultas acima sem efetuar a análise completa do XML.For example, the following query will return exactly the same results as the queries above without performing full XML parsing. Note que faz algumas suposições na estrutura de ficheiros XML, como o elemento FilePath vem depois do FileHash e nenhum deles tem atributos.Note that it makes some assumptions on the XML file structure such as that FilePath element comes after FileHash and none of them has attributes.

//even more efficient
SecurityEvent
| where EventID == 8002 //Only this event have FileHash
| where EventData !has "%SYSTEM32" //Early removal of unwanted records
| parse EventData with * "<FilePath>" FilePath "</FilePath>" * "<FileHash>" FileHash "</FileHash>" *
| summarize count() by FileHash, FilePath
| where FileHash != "" // No need to filter out %SYSTEM32 here as it was removed before

Dados utilizados para consulta processadaData used for processed query

Um fator crítico no processamento da consulta é o volume de dados que é digitalizado e utilizado para o processamento de consultas.A critical factor in the processing of the query is the volume of data that is scanned and used for the query processing. O Azure Data Explorer utiliza otimizações agressivas que reduzem drasticamente o volume de dados em comparação com outras plataformas de dados.Azure Data Explorer uses aggressive optimizations that dramatically reduce the data volume compared to other data platforms. Ainda assim, existem fatores críticos na consulta que podem impactar o volume de dados que é usado.Still, there are critical factors in the query that can impact the data volume that is used.

A consulta que processa mais de 2.000KB de dados é considerada uma consulta que consome recursos excessivos.Query that processes more than 2,000KB of data is considered a query that consumes excessive resources. A consulta que está a processar mais de 20.000KB de dados é considerada uma consulta abusiva e pode ser estrangulada.Query that is processing more than 20,000KB of data is considered an abusive query and might be throttled.

Nos Registos do Monitor Azure, a coluna TimeGenerated é utilizada como forma de indexar os dados.In Azure Monitor Logs, the TimeGenerated column is used as a way to index the data. Restringir os valores timeGenerated para um intervalo o mais estreito possível fará uma melhoria significativa no desempenho da consulta, limitando significativamente a quantidade de dados que tem de ser processado.Restricting the TimeGenerated values to as narrow a range as possible will make a significant improvement to query performance by significantly limiting the amount of data that has to be processed.

Evitar o uso desnecessário de operadores de pesquisa e sindicatoAvoid unnecessary use of search and union operators

Outro fator que aumenta os dados que são processados é o uso de um grande número de tabelas.Another factor that increases the data that is process is the use of large number of tables. Isto geralmente acontece quando search * e union * os comandos são usados.This usually happens when search * and union * commands are used. Estes comandos forçam o sistema a avaliar e digitalizar dados de todas as tabelas do espaço de trabalho.These commands force the system to evaluate and scan data from all tables in the workspace. Em alguns casos, pode haver centenas de mesas no espaço de trabalho.In some cases, there might be hundreds of tables in the workspace. Tente evitar o máximo possível usando "search *" ou qualquer pesquisa sem a digitalizar para uma mesa específica.Try to avoid as much as possible using "search *" or any search without scoping it to a specific table.

Por exemplo, as seguintes consultas produzem exatamente o mesmo resultado, mas a última é de longe a mais eficiente:For example, the following queries produce exactly the same result but the last one is by far the most efficient:

// This version scans all tables though only Perf has this kind of data
search "Processor Time" 
| summarize count(), avg(CounterValue)  by Computer
// This version scans all strings in Perf tables – much more efficient
Perf
| search "Processor Time" 
| summarize count(), avg(CounterValue)  by Computer
// This is the most efficient version 
Perf 
| where CounterName == "% Processor Time"  
| summarize count(), avg(CounterValue)  by Computer

Adicione filtros iniciais à consultaAdd early filters to the query

Outro método para reduzir o volume de dados é ter onde as condições no início da consulta.Another method to reduce the data volume is to have where conditions early in the query. A plataforma Azure Data Explorer inclui uma cache que lhe permite saber quais as divisórias que incluem dados que são relevantes para uma condição específica.The Azure Data Explorer platform includes a cache that lets it know which partitions include data that is relevant for a specific where condition. Por exemplo, se uma consulta contiver, where EventID == 4624 então distribuiria a consulta apenas a nós que manuseiam divisórias com eventos correspondentes.For example, if a query contains where EventID == 4624 then it would distribute the query only to nodes that handle partitions with matching events.

As seguintes consultas de exemplo produzem exatamente o mesmo resultado, mas a segunda é mais eficiente:The following example queries produce exactly the same result but the second one is more efficient:

//less efficient
SecurityEvent
| summarize LoginSessions = dcount(LogonGuid) by Account
//more efficient
SecurityEvent
| where EventID == 4624 //Logon GUID is relevant only for logon event
| summarize LoginSessions = dcount(LogonGuid) by Account

Evite múltiplas análises de dados de mesma origem utilizando funções de agregação condicional e materialize a funçãoAvoid multiple scans of same source data using conditional aggregation functions and materialize function

Quando uma consulta tem várias sub-consultas que são fundidas usando operadores de junta ou união, cada sub-consulta digitaliza toda a fonte separadamente e, em seguida, funde os resultados.When a query has several sub-queries that are merged using join or union operators, each sub-query scans the entire source separately and then merge the results. Isto múltipla o número de vezes que os dados são digitalizados - fator crítico em conjuntos de dados muito grandes.This multiples the number of times data is scanned - critical factor in very large data sets.

Uma técnica para evitar isto é utilizando as funções de agregação condicional.A technique to avoid this is by using the conditional aggregation functions. A maioria das funções de agregação que são utilizadas no operador resumido tem uma versão condicionada que lhe permite utilizar um único operador sumário com múltiplas condições.Most of the aggregation functions that are used in summary operator has a conditioned version that allow you to use a single summarize operator with multiple conditions.

Por exemplo, as seguintes consultas mostram o número de eventos de login e o número de eventos de execução de processos para cada conta.For example, the following queries show the number of login events and the number of process execution events for each account. Devolvem os mesmos resultados, mas o primeiro é digitalizar os dados duas vezes, o segundo só uma vez:They return the same results but the first is scanning the data twice, the second scan it only once:

//Scans the SecurityEvent table twice and perform expensive join
SecurityEvent
| where EventID == 4624 //Login event
| summarize LoginCount = count() by Account
| join 
(
    SecurityEvent
    | where EventID == 4688 //Process execution event
    | summarize ExecutionCount = count(), ExecutedProcesses = make_set(Process) by Account
) on Account
//Scan only once with no join
SecurityEvent
| where EventID == 4624 or EventID == 4688 //early filter
| summarize LoginCount = countif(EventID == 4624), ExecutionCount = countif(EventID == 4688), ExecutedProcesses = make_set_if(Process,EventID == 4688)  by Account

Outro caso em que as sub-consultas são desnecessárias é a pré-filtragem para o operador de parse para se certificar de que processa apenas registos que correspondam a um padrão específico.Another case where sub-queries are unnecessary is pre-filtering for parse operator to make sure that it processes only records that match specific pattern. Isto é desnecessário, uma vez que o operador de parse e outros operadores similares retornam resultados vazios quando o padrão não corresponde.This is unnecessary as the parse operator and other similar operators return empty results when the pattern doesn't match. Aqui estão duas consultas que devolvem exatamente os mesmos resultados enquanto a segunda consulta de dados de verificação apenas uma vez.Here are two queries that return exactly the same results while the second query scan data only once. Na segunda consulta, cada comando de parse é relevante apenas para os seus eventos.In the second query, each parse command is relevant only for its events. O operador de extensão mostra depois como se referir à situação de dados vazios.The extend operator afterwards shows how to refer to empty data situation.

//Scan SecurityEvent table twice
union(
SecurityEvent
| where EventID == 8002 
| parse EventData with * "<FilePath>" FilePath "</FilePath>" * "<FileHash>" FileHash "</FileHash>" *
| distinct FilePath
),(
SecurityEvent
| where EventID == 4799
| parse EventData with * "CallerProcessName\">" CallerProcessName1 "</Data>" * 
| distinct CallerProcessName1
)
//Single scan of the SecurityEvent table
SecurityEvent
| where EventID == 8002 or EventID == 4799
| parse EventData with * "<FilePath>" FilePath "</FilePath>" * "<FileHash>" FileHash "</FileHash>" * //Relevant only for event 8002
| parse EventData with * "CallerProcessName\">" CallerProcessName1 "</Data>" *  //Relevant only for event 4799
| extend FilePath = iif(isempty(CallerProcessName1),FilePath,"")
| distinct FilePath, CallerProcessName1

Quando o acima referido não permite evitar a utilização de sub-consultas, outra técnica é sugerir ao motor de consulta que existe um único dado de origem utilizado em cada um deles utilizando a função de materialização.When the above doesn't allow to avoid using sub-queries, another technique is to hint to the query engine that there is a single source data used in each one of them using the materialize() function. Isto é útil quando os dados de origem vêm de uma função que é usada várias vezes dentro da consulta.This is useful when the source data is coming from a function that is used several times within the query. Materializar é eficaz quando a saída da sub-consulta é muito menor do que a entrada.Materialize is effective when the output of the sub-query is much smaller than the input. O motor de consulta cache e reutilizar a saída em todas as ocorrências.The query engine will cache and reuse the output in all occurrences.

Reduzir o número de colunas que são recuperadasReduce the number of columns that is retrieved

Uma vez que o Azure Data Explorer é uma loja de dados colunar, a recuperação de cada coluna é independente das outras.Since Azure Data Explorer is a columnar data store, retrieval of every column is independent of the others. O número de colunas que são recuperadas influencia diretamente o volume global de dados.The number of columns that are retrieved directly influences the overall data volume. Deve incluir apenas as colunas na saída que são necessárias resumindo os resultados ou projetando as colunas específicas.You should only include the columns in the output that are needed by summarizing the results or projecting the specific columns. O Azure Data Explorer tem várias otimizações para reduzir o número de colunas recuperadas.Azure Data Explorer has several optimizations to reduce the number of retrieved columns. Se determinar que uma coluna não é necessária, por exemplo, se não for referenciada no comando resumido, não a recuperará.If it determines that a column isn't needed, for example if it's not referenced in the summarize command, it won't retrieve it.

Por exemplo, a segunda consulta pode processar três vezes mais dados, uma vez que precisa de ir buscar não uma coluna, mas três:For example, the second query may process three times more data since it needs to fetch not one column but three:

//Less columns --> Less data
SecurityEvent
| summarize count() by Computer  
//More columns --> More data
SecurityEvent
| summarize count(), dcount(EventID), avg(Level) by Computer  

Período de tempo da consulta processadaTime span of the processed query

Todos os registos em Registos monitores Azure são divididos de acordo com a coluna TimeGenerated.All logs in Azure Monitor Logs are partitioned according to the TimeGenerated column. O número de divisórias acedidas está diretamente relacionado com o período de tempo.The number of partitions that are accessed are directly related to the time span. Reduzir o intervalo de tempo é a forma mais eficiente de assegurar uma rápida execução de consultas.Reducing the time range is the most efficient way of assuring a prompt query execution.

Consulta com tempo de mais de 15 dias é considerada uma consulta que consome recursos excessivos.Query with time span of more than 15 days is considered a query that consumes excessive resources. Consulta com tempo de mais de 90 dias é considerada uma consulta abusiva e pode ser estrangulada.Query with time span of more than 90 days is considered an abusive query and might be throttled.

O intervalo de tempo pode ser definido utilizando o seletor de intervalo de tempo no ecrã Log Analytics, conforme descrito no âmbito de consulta de Log e intervalo de tempo no Azure Monitor Log Analytics.The time range can be set using the time range selector in the Log Analytics screen as described in Log query scope and time range in Azure Monitor Log Analytics. Este é o método recomendado, uma vez que o intervalo de tempo selecionado é passado para o backend utilizando os metadados de consulta.This is the recommended method as the selected time range is passed to the backend using the query metadata.

Um método alternativo é incluir explicitamente uma condição em que a condição do TempoGerado na consulta.An alternative method is to explicitly include a where condition on TimeGenerated in the query. Deve utilizar este método pois assegura que o tempo é fixado, mesmo quando a consulta é utilizada a partir de uma interface diferente.You should use this method as it assures that the time span is fixed, even when the query is used from a different interface. Deve certificar-se de que todas as partes da consulta possuem filtros TimeGenerated.You should ensure that all parts of the query have TimeGenerated filters. Quando uma consulta tem sub-consultas que recolhem dados de várias tabelas ou da mesma tabela, cada uma tem de incluir a sua própria condição.When a query has sub-queries fetching data from various tables or the same table, each has to include its own where condition.

Certifique-se de que todas as sub-consultas têm filtro TimeGeneratedMake sure all sub-queries have TimeGenerated filter

Por exemplo, na seguinte consulta, enquanto a tabela Perf será digitalizada apenas para o último dia, a tabela Heartbeat será digitalizada para toda a sua história, que pode ser até dois anos:For example, in the following query, while the Perf table will be scanned only for the last day, the Heartbeat table will be scanned for all of its history, which might be up to two years:

Perf
| where TimeGenerated > ago(1d)
| summarize avg(CounterValue) by Computer, CounterName
| join kind=leftouter (
    Heartbeat
    //No time span filter in this part of the query
    | summarize IPs = makeset(ComputerIP, 10) by  Computer
) on Computer

Um caso comum em que tal erro ocorre é quando arg_max() é usado para encontrar a ocorrência mais recente.A common case where such a mistake occurs is when arg_max() is used to find the most recent occurrence. Por exemplo:For example:

Perf
| where TimeGenerated > ago(1d)
| summarize avg(CounterValue) by Computer, CounterName
| join kind=leftouter (
    Heartbeat
    //No time span filter in this part of the query
    | summarize arg_max(TimeGenerated, *), min(TimeGenerated)   
by Computer
) on Computer

Isto pode ser facilmente corrigido adicionando um filtro de tempo na consulta interna:This can be easily corrected by adding a time filter in the inner query:

Perf
| where TimeGenerated > ago(1d)
| summarize avg(CounterValue) by Computer, CounterName
| join kind=leftouter (
    Heartbeat
    | where TimeGenerated > ago(1d) //filter for this part
    | summarize arg_max(TimeGenerated, *), min(TimeGenerated)   
by Computer
) on Computer

Outro exemplo para esta falha é quando se executa a filtragem do âmbito do tempo logo após uma união sobre várias mesas.Another example for this fault is when performing the time scope filtering just after a union over several tables. Ao realizar a união, cada sub-consulta deve ser examinado.When performing the union, each sub-query should be scoped. Pode usar uma declaração de let para garantir a consistência da deteção.You can use let statement to assure scoping consistency.

Por exemplo, a seguinte consulta irá digitalizar todos os dados nas tabelas Heartbeat e Perf, e não apenas no último dia:For example, the following query will scan all the data in the Heartbeat and Perf tables, not just the last 1 day:

Heartbeat 
| summarize arg_min(TimeGenerated,*) by Computer
| union (
    Perf 
    | summarize arg_min(TimeGenerated,*) by Computer) 
| where TimeGenerated > ago(1d)
| summarize min(TimeGenerated) by Computer

Esta consulta deve ser corrigida da seguinte forma:This query should be fixed as follows:

let MinTime = ago(1d);
Heartbeat 
| where TimeGenerated > MinTime
| summarize arg_min(TimeGenerated,*) by Computer
| union (
    Perf 
    | where TimeGenerated > MinTime
    | summarize arg_min(TimeGenerated,*) by Computer) 
| summarize min(TimeGenerated) by Computer

Limitações de medição de tempoTime span measurement limitations

A medição é sempre maior do que o tempo real especificado.The measurement is always larger than the actual time specified. Por exemplo, se o filtro na consulta for de 7 dias, o sistema pode digitalizar 7,5 ou 8,1 dias.For example, if the filter on the query is 7 days, the system might scan 7.5 or 8.1 days. Isto porque o sistema está a dividir os dados em pedaços de tamanho variável.This is because the system is partitioning the data into chunks in variable size. Para garantir que todos os registos relevantes são digitalizados, digitaliza toda a partição que pode cobrir várias horas e até mais de um dia.To assure that all relevant records are scanned, it scans the entire partition that might cover several hours and even more than a day.

Existem vários casos em que o sistema não pode fornecer uma medição precisa do intervalo de tempo.There are several cases where the system cannot provide an accurate measurement of the time range. Isto acontece na maioria dos casos em que a consulta se estende menos de um dia ou em consultas multi-workspace.This happens in most of the cases where the query's span less than a day or in multi-workspace queries.

Importante

Este indicador apresenta apenas dados processados no cluster imediato.This indicator presents only data processed in the immediate cluster. Em consultas multi-regiões, representaria apenas uma das regiões.In multi-region query, it would represent only one of the regions. Em consulta de vários espaços de trabalho, pode não incluir todos os espaços de trabalho.In multi-workspace query, it might not include all workspaces.

Idade dos dados processadosAge of processed data

O Azure Data Explorer utiliza vários níveis de armazenamento: em memória, discos SSD locais e Blobs Azure muito mais lentos.Azure Data Explorer uses several storage tiers: in-memory, local SSD disks and much slower Azure Blobs. Quanto mais recentes os dados, maior é a possibilidade de ser armazenado num nível mais performante com menor latência, reduzindo a duração da consulta e CPU.The newer the data, the higher is the chance that it is stored in a more performant tier with smaller latency, reducing the query duration and CPU. Além dos dados em si, o sistema também tem uma cache para metadados.Other than the data itself, the system also has a cache for metadata. Quanto mais velhos os dados, menos hipóteses os seus metadados estarão em cache.The older the data, the less chance its metadata will be in cache.

A consulta de que processa dados com mais de 14 dias é considerada uma consulta que consome recursos excessivos.Query that processes data than is more than 14 days old is considered a query that consumes excessive resources.

Embora algumas consultas exijam o uso de dados antigos, há casos em que dados antigos são usados por engano.While some queries require usage of old data, there are cases where old data is used by mistake. Isto acontece quando as consultas são executadas sem fornecer intervalo de tempo nos seus meta-dados e nem todas as referências de tabela incluem filtro na coluna TimeGenerated.This happens when queries are executed without providing time range in their meta-data and not all table references include filter on the TimeGenerated column. Nestes casos, o sistema irá digitalizar todos os dados que são armazenados nessa tabela.In these cases, the system will scan all the data that is stored in that table. Quando a retenção de dados é longa, pode abranger intervalos de longo tempo e, portanto, dados tão antigos quanto o período de retenção de dados.When the data retention is long, it can cover long time ranges and thus data that is as old as the data retention period.

Tais casos podem ser, por exemplo:Such cases can be for example:

  • Não definir o intervalo de tempo no Log Analytics com uma sub-consulta que não é limitada.Not setting the time range in Log Analytics with a sub-query that isn't limited. Veja o exemplo acima.See example above.
  • Utilização da API sem os parâmetros opcionais do intervalo de tempo.Using the API without the time range optional parameters.
  • Usando um cliente que não force um intervalo de tempo como o conector Power BI.Using a client that doesn't force a time range such as the Power BI connector.

Consulte exemplos e notas na secção perversa, uma vez que também são relevantes neste caso.See examples and notes in the pervious section as they are also relevant in this case.

Número de regiõesNumber of regions

Existem várias situações em que uma única consulta pode ser executada em diferentes regiões:There are several situations where a single query might be executed across different regions:

  • Quando vários espaços de trabalho são explicitamente listados, e estão localizados em diferentes regiões.When several workspaces are explicitly listed, and they are located in different regions.
  • Quando uma consulta de recursos está a recolher dados e os dados são armazenados em múltiplos espaços de trabalho que estão localizados em diferentes regiões.When a resource-scoped query is fetching data and the data is stored in multiple workspaces that are located in different regions.

A execução de consultas entre regiões requer que o sistema serialize e transfira no backend grandes pedaços de dados intermédios que são geralmente muito maiores do que os resultados finais da consulta.Cross-region query execution requires the system to serialize and transfer in the backend large chunks of intermediate data that are usually much larger than the query final results. Também limita a capacidade do sistema de realizar otimizações, heurísticas e caches de utilização.It also limits the system's ability to perform optimizations, heuristics, and utilize caches. Se não houver uma verdadeira razão para digitalizar todas estas regiões, deve ajustar o âmbito de aplicação para abranger menos regiões.If there is no real reason to scan all these regions, you should adjust the scope so it covers fewer regions. Se o âmbito de recursos for minimizado, mas ainda assim muitas regiões forem utilizadas, isso poderá acontecer devido a uma má configuração.If the resource scope is minimized but still many regions are used, it might happen due to misconfiguration. Por exemplo, os registos de auditoria e as definições de diagnóstico são enviados para diferentes espaços de trabalho em diferentes regiões ou existem múltiplas configurações de diagnóstico.For example, audit logs and diagnostic settings are sent to different workspaces in different regions or there are multiple diagnostic settings configurations.

A consulta que abrange mais de 3 regiões é considerada uma consulta que consome recursos excessivos.Query that spans more than 3 regions is considered a query that consumes excessive resources. A consulta que abrange mais de 6 regiões é considerada uma consulta abusiva e pode ser estrangulada.Query that spans more than 6 regions is considered an abusive query and might be throttled.

Importante

Quando uma consulta é efetuada em várias regiões, a CPU e as medições de dados não serão precisas e representarão a medição apenas numa das regiões.When a query is run across several regions, the CPU and data measurements will not be accurate and will represent the measurement only on one of the regions.

Número de espaços de trabalhoNumber of workspaces

Os espaços de trabalho são recipientes lógicos que são usados para segregar e administrar dados de registos.Workspaces are logical containers that are used to segregate and administer logs data. O backend otimiza as colocações de espaço de trabalho em aglomerados físicos dentro da região selecionada.The backend optimizes workspace placements on physical clusters within the selected region.

A utilização de múltiplos espaços de trabalho pode resultar de:Usage of multiple workspaces can result from:

  • Onde vários espaços de trabalho estão explicitamente listados.Where several workspaces are explicitly listed.
  • Quando uma consulta de âmbito de recursos está a recolher dados e os dados são armazenados em vários espaços de trabalho.When a resource-scoped query is fetching data and the data is stored in multiple workspaces.

A execução transversal e transversal de consultas requer que o sistema serialize e transfira no backend grandes pedaços de dados intermédios que são geralmente muito maiores do que os resultados finais da consulta.Cross-region and cross-cluster execution of queries requires the system to serialize and transfer in the backend large chunks of intermediate data that are usually much larger than the query final results. Também limita a capacidade do sistema de realizar otimizações, heurísticas e caches usando.It also limits the system ability to perform optimizations, heuristics and utilizing caches.

A consulta que abrange mais de 5 espaços de trabalho é considerada uma consulta que consome recursos excessivos.Query that spans more than 5 workspace is considered a query that consumes excessive resources. As consultas não podem ir até mais de 100 espaços de trabalho.Queries cannot span to to more than 100 workspaces.

Importante

Em alguns cenários multi-workspace, o CPU e as medições de dados não serão precisos e representarão a medição apenas para poucos dos espaços de trabalho.In some multi-workspace scenarios, the CPU and data measurements will not be accurate and will represent the measurement only to few of the workspaces.

ParalelismoParallelism

O Azure Monitor Logs está a usar grandes aglomerados de Azure Data Explorer para executar consultas, e estes clusters variam em escala, potencialmente chegando a dezenas de nós computacional.Azure Monitor Logs is using large clusters of Azure Data Explorer to run queries, and these clusters vary in scale, potentially getting up to dozens of compute nodes. O sistema escala automaticamente os clusters de acordo com a lógica e capacidade de colocação do espaço de trabalho.The system automatically scales the clusters according to workspace placement logic and capacity.

Para executar eficientemente uma consulta, é dividida e distribuída para nómadas de computação com base nos dados necessários para o seu processamento.To efficiently execute a query, it is partitioned and distributed to compute nodes based on the data that is required for its processing. Há algumas situações em que o sistema não pode fazê-lo de forma eficiente.There are some situations where the system cannot do this efficiently. Isto pode levar a uma longa duração da consulta.This can lead to a long duration of the query.

Os comportamentos de consulta que podem reduzir o paralelismo incluem:Query behaviors that can reduce parallelism include:

  • Utilização de funções de serialização e janela, tais como o operador de serialização, o próximo() prev()e as funções de linha.Use of serialization and window functions such as the serialize operator, next(), prev(), and the row functions. As funções de análise de séries temporárias e de análise de utilizadores podem ser utilizadas em alguns destes casos.Time series and user analytics functions can be used in some of these cases. A serialização ineficiente também pode acontecer se os seguintes operadores não forem utilizados no final da consulta: intervalo, ordenar, encomendar, topo, top-hitters, getschema.Inefficient serialization may also happen if the following operators are used not at the end of the query: range, sort, order, top, top-hitters, getschema.
  • A utilização da função de agregação dcount() força o sistema a ter cópia central dos valores distintos.Usage of dcount() aggregation function force the system to have central copy of the distinct values. Quando a escala de dados for elevada, considere usar os parâmetros opcionais da função dcount para reduzir a precisão.When the scale of data is high, consider using the dcount function optional parameters to reduced accuracy.
  • Em muitos casos, o operador de união reduz o paralelismo geral.In many cases, the join operator lowers overall parallelism. Examine a mistura como alternativa quando o desempenho é problemático.Examine shuffle join as an alternative when performance is problematic.
  • Nas consultas de âmbito de recursos, os controlos de Pré-execução de Kubernetes RBAC ou Azure RBAC podem permanecer em situações em que há um número muito grande de atribuições de papel Azure.In resource-scope queries, the pre-execution Kubernetes RBAC or Azure RBAC checks may linger in situations where there is very large number of Azure role assignments. Isto pode levar a controlos mais longos que resultariam num paraleloismo mais baixo.This may lead to longer checks that would result in lower parallelism. Por exemplo, uma consulta é executada numa subscrição onde existem milhares de recursos e cada recurso tem muitas atribuições de funções ao nível dos recursos, não no grupo de subscrição ou recursos.For example, a query is executed on a subscription where there are thousands of resources and each resource has many role assignments in the resource level, not on the subscription or resource group.
  • Se uma consulta estiver a processar pequenos pedaços de dados, o seu paralelismo será baixo, uma vez que o sistema não o espalhará por muitos nós computacional.If a query is processing small chunks of data, its parallelism will be low as the system will not spread it across many compute nodes.

Passos seguintesNext steps