Editar

Padrões de observabilidade e métricas para ajuste de desempenho

Azure Databricks
Azure Log Analytics
Azure Monitor

Nota

Este artigo conta com uma biblioteca de código aberto hospedada no GitHub em: https://github.com/mspnp/spark-monitoring.

A biblioteca original suporta o Azure Databricks Runtimes 10.x (Spark 3.2.x) e anteriores.

O Databricks contribuiu com uma versão atualizada para dar suporte ao Azure Databricks Runtimes 11.0 (Spark 3.3.x) e superior na l4jv2 ramificação em: https://github.com/mspnp/spark-monitoring/tree/l4jv2.

Observe que a versão 11.0 não é compatível com versões anteriores devido aos diferentes sistemas de registro usados no Databricks Runtimes. Certifique-se de usar a compilação correta para seu Databricks Runtime. A biblioteca e o repositório GitHub estão em modo de manutenção. Não há planos para novos lançamentos, e o suporte a problemas será apenas o melhor esforço. Para quaisquer perguntas adicionais sobre a biblioteca ou o roteiro para monitoramento e registro em log de seus ambientes do Azure Databricks, entre em contato com azure-spark-monitoring-help@databricks.com.

Esta solução demonstra padrões de observabilidade e métricas para melhorar o desempenho de processamento de um sistema de big data que usa o Azure Databricks.

Arquitetura

Diagram of performance tuning using observability patterns with Azure Databricks, Azure Monitor, Azure Log Analytics, and Azure Data Lake Storage.

Transfira um ficheiro do Visio desta arquitetura.

Fluxo de trabalho

A solução envolve as seguintes etapas:

  1. O servidor envia um arquivo GZIP grande que é agrupado pelo cliente para a pasta Origem no Azure Data Lake Storage (ADLS).

  2. Em seguida, o ADLS envia um arquivo de cliente extraído com êxito para a Grade de Eventos do Azure, que transforma os dados do arquivo do cliente em várias mensagens.

  3. A Grade de Eventos do Azure envia as mensagens para o serviço de Armazenamento de Filas do Azure, que as armazena em uma fila.

  4. O Armazenamento de Filas do Azure envia a fila para a plataforma de análise de dados do Azure Databricks para processamento.

  5. O Azure Databricks descompacta e processa dados da fila em um arquivo processado que ele envia de volta para o ADLS:

    1. Se o arquivo processado for válido, ele vai para a pasta de destino .

    2. Caso contrário, o arquivo vai para a árvore de pastas Bad . Inicialmente, o arquivo vai para a subpasta Repetir e o ADLS tenta processar o arquivo do cliente novamente (etapa 2). Se um par de tentativas de repetição ainda levar o Azure Databricks a retornar arquivos processados que não são válidos, o arquivo processado irá para a subpasta Falha .

  6. À medida que o Azure Databricks descompacta e processa dados na etapa anterior, ele também envia logs e métricas de aplicativos para o Azure Monitor para armazenamento.

  7. Um espaço de trabalho do Azure Log Analytics aplica consultas Kusto nos logs e métricas do aplicativo do Azure Monitor para solução de problemas e diagnósticos profundos.

Componentes

  • O Armazenamento Azure Data Lake é um conjunto de recursos dedicados à análise de big data.
  • A Grade de Eventos do Azure permite que um desenvolvedor crie facilmente aplicativos com arquiteturas baseadas em eventos.
  • O Armazenamento de Filas do Azure é um serviço para armazenar um grande número de mensagens. Ele permite o acesso a mensagens de qualquer lugar do mundo através de chamadas autenticadas usando HTTP ou HTTPS. Você pode usar filas para criar uma lista de pendências de trabalho para processar de forma assíncrona.
  • O Azure Databricks é uma plataforma de análise de dados otimizada para a plataforma de nuvem do Azure. Um dos dois ambientes que o Azure Databricks oferece para o desenvolvimento de aplicativos com uso intensivo de dados é o Azure Databricks Workspace, um mecanismo de análise unificado baseado no Apache Spark para processamento de dados em grande escala.
  • O Azure Monitor coleta e analisa a telemetria do aplicativo, como métricas de desempenho e logs de atividades.
  • O Azure Log Analytics é uma ferramenta usada para editar e executar consultas de log com dados.

Detalhes do cenário

Sua equipe de desenvolvimento pode usar padrões e métricas de observabilidade para encontrar gargalos e melhorar o desempenho de um sistema de big data. Sua equipe precisa fazer testes de carga de um fluxo de alto volume de métricas em um aplicativo de alta escala.

Este cenário oferece orientação para ajuste de desempenho. Como o cenário apresenta um desafio de desempenho para o registro em log por cliente, ele usa o Azure Databricks, que pode monitorar esses itens de forma robusta:

  • Métricas personalizadas do aplicativo
  • Transmissão de eventos de consulta
  • Mensagens de log do aplicativo

O Azure Databricks pode enviar esses dados de monitoramento para diferentes serviços de log, como o Azure Log Analytics.

Este cenário descreve a ingestão de um grande conjunto de dados que foram agrupados por cliente e armazenados em um arquivo GZIP. Os logs detalhados não estão disponíveis no Azure Databricks fora da interface de usuário do Apache Spark™ em tempo real, portanto, sua equipe precisa de uma maneira de armazenar todos os dados de cada cliente e, em seguida, comparar e comparar. Com um cenário de dados grandes, é importante encontrar uma combinação ideal de pool de executores e tamanho de máquina virtual (VM) para o tempo de processamento mais rápido. Para esse cenário de negócios, o aplicativo geral depende da velocidade dos requisitos de ingestão e consulta, para que a taxa de transferência do sistema não se degrade inesperadamente com o aumento do volume de trabalho. O cenário deve garantir que o sistema atenda aos SLAs (Service Level Agreements, contratos de nível de serviço) estabelecidos com seus clientes.

Potenciais casos de utilização

Os cenários que podem se beneficiar dessa solução incluem:

  • Monitorização do estado de funcionamento do sistema.
  • Manutenção de desempenho.
  • Monitorização da utilização diária do sistema.
  • Detetar tendências que podem causar problemas futuros se não forem abordadas.

Considerações

Essas considerações implementam os pilares do Azure Well-Architected Framework, que é um conjunto de princípios orientadores que podem ser usados para melhorar a qualidade de uma carga de trabalho. Para obter mais informações, consulte Microsoft Azure Well-Architected Framework.

Tenha estes pontos em mente ao considerar esta arquitetura:

  • O Azure Databricks pode alocar automaticamente os recursos de computação necessários para um trabalho grande, o que evita problemas introduzidos por outras soluções. Por exemplo, com o dimensionamento automático otimizado para Databricks no Apache Spark, o provisionamento excessivo pode causar o uso subótimo de recursos. Ou você pode não saber o número de executores necessários para um trabalho.

  • Uma mensagem de fila no Armazenamento de Filas do Azure pode ter até 64 KB de tamanho. Uma fila pode conter milhões de mensagens de fila, até o limite de capacidade total de uma conta de armazenamento.

Otimização de custos

A otimização de custos consiste em procurar formas de reduzir despesas desnecessárias e melhorar a eficiência operacional. Para obter mais informações, consulte Visão geral do pilar de otimização de custos.

Use a calculadora de preços do Azure para estimar o custo de implementação dessa solução.

Implementar este cenário

Nota

As etapas de implantação descritas aqui se aplicam somente ao Azure Databricks, Azure Monitor e Azure Log Analytics. A implantação dos outros componentes não é abordada neste artigo.

Para obter todos os logs e informações do processo, configure o Azure Log Analytics e a biblioteca de monitoramento do Azure Databricks. A biblioteca de monitoramento transmite eventos no nível Apache Spark e métricas do Spark Structured Streaming de seus trabalhos para o Azure Monitor. Você não precisa fazer alterações no código do aplicativo para esses eventos e métricas.

As etapas para configurar o ajuste de desempenho para um sistema de big data são as seguintes:

  1. No portal do Azure, crie um espaço de trabalho do Azure Databricks. Copie e salve a ID de assinatura do Azure (um GUID), o nome do grupo de recursos, o nome do espaço de trabalho Databricks e a URL do portal do espaço de trabalho para uso posterior.

  2. Em um navegador da Web, vá para a URL do espaço de trabalho Databricks e gere um token de acesso pessoal Databricks. Copie e salve a cadeia de caracteres de token que aparece (que começa com dapi um valor hexadecimal de 32 caracteres) para uso posterior.

  3. Clone o repositório GitHub mspnp/spark-monitoring em seu computador local. Este repositório tem o código-fonte para os seguintes componentes:

    • O modelo do Azure Resource Manager (ARM) para criar um espaço de trabalho do Azure Log Analytics, que também instala consultas pré-criadas para coletar métricas do Spark
    • Bibliotecas de monitoramento do Azure Databricks
    • O aplicativo de exemplo para enviar métricas de aplicativo e logs de aplicativo do Azure Databricks para o Azure Monitor
  4. Usando o comando da CLI do Azure para implantar um modelo ARM, crie um espaço de trabalho do Azure Log Analytics com consultas de métricas do Spark pré-criadas. Na saída do comando, copie e salve o nome gerado para o novo espaço de trabalho do Log Analytics (no formato spark-monitoring-randomized-string><).

  5. No portal do Azure, copie e salve a ID e a chave do espaço de trabalho do Log Analytics para uso posterior.

  6. Instale o Community Edition do IntelliJ IDEA, um ambiente de desenvolvimento integrado (IDE) que tem suporte integrado para o Java Development Kit (JDK) e Apache Maven. Adicione o plug-in Scala.

  7. Usando o IntelliJ IDEA, crie as bibliotecas de monitoramento do Azure Databricks. Para executar a etapa de compilação real, selecione View>Tool Windows>Maven para mostrar a janela de ferramentas do Maven e, em seguida, selecione Executar pacote mvn do Maven Goal.>

  8. Usando uma ferramenta de instalação de pacote Python, instale a CLI do Azure Databricks e configure a autenticação com o token de acesso pessoal Databricks copiado anteriormente.

  9. Configure o espaço de trabalho do Azure Databricks modificando o script de inicialização do Databricks com os valores do Databricks e do Log Analytics copiados anteriormente e, em seguida, usando a CLI do Azure Databricks para copiar o script init e as bibliotecas de monitoramento do Azure Databricks para seu espaço de trabalho do Databricks.

  10. No portal de espaço de trabalho do Databricks, crie e configure um cluster do Azure Databricks.

  11. No IntelliJ IDEA, crie o aplicativo de exemplo usando o Maven. Em seguida, em seu portal de espaço de trabalho Databricks, execute o aplicativo de exemplo para gerar logs e métricas de exemplo para o Azure Monitor.

  12. Enquanto o trabalho de exemplo está sendo executado no Azure Databricks, vá para o portal do Azure para exibir e consultar os tipos de evento (logs e métricas do aplicativo) na interface do Log Analytics:

    1. Selecione Logs personalizados de tabelas>para exibir o esquema de tabela para eventos de ouvinte do Spark (SparkListenerEvent_CL), eventos de log do Spark (SparkLoggingEvent_CL) e métricas do Spark (SparkMetric_CL).
    2. Selecione Métricas de faísca de consultas salvas>do explorador>de consultas para exibir e executar as consultas que foram adicionadas quando você criou o espaço de trabalho do Log Analytics.

    Leia mais sobre como visualizar e executar consultas pré-criadas e personalizadas na próxima seção.

Consultar os logs e métricas no Azure Log Analytics

Aceda a consultas pré-criadas

Os nomes de consulta pré-criados para recuperar métricas do Spark estão listados abaixo.

  • % de tempo de CPU por executor
  • % de tempo de desserialização por executor
  • % de tempo da JVM por executor
  • % de tempo de serialização por executor
  • Bytes de disco derramados
  • Rastreamentos de erro (registro incorreto ou arquivos incorretos)
  • Bytes do sistema de arquivos lidos por executor
  • Gravação de bytes do sistema de arquivos por executor
  • Erros de trabalho por trabalho
  • Latência do trabalho por trabalho (duração do lote)
  • Taxa de transferência do trabalho
  • Executando executores
  • Leitura de bytes aleatórios
  • Bytes aleatórios lidos por executor
  • Bytes aleatórios lidos no disco por executor
  • Memória direta do cliente aleatório
  • Embaralhar a memória do cliente por executor
  • Bytes de disco aleatórios derramados por executor
  • Memória de pilha aleatória por executor
  • Bytes de memória aleatórios derramados por executor
  • Latência do estágio por estágio (duração do estágio)
  • Taxa de transferência do estágio por estágio
  • Erros de streaming por fluxo
  • Latência de streaming por fluxo
  • Linhas de entrada de taxa de transferência de streaming/s
  • Taxa de transferência de streaming de linhas processadas/s
  • Somar a execução de tarefas por host
  • Tempo de desserialização da tarefa
  • Erros de tarefa por estágio
  • Tempo de computação do executor de tarefas (tempo de distorção de dados)
  • Leitura de bytes de entrada de tarefas
  • Latência da tarefa por estágio (duração das tarefas)
  • Tempo de serialização do resultado da tarefa
  • Latência de atraso do Agendador de Tarefas
  • Leitura de bytes aleatórios de tarefas
  • Bytes aleatórios de tarefas gravados
  • Tempo de leitura aleatório de tarefas
  • Tempo de escrita aleatório de tarefas
  • Taxa de transferência de tarefas (soma de tarefas por estágio)
  • Tarefas por executor (soma de tarefas por executor)
  • Tarefas por estágio

Escrever consultas personalizadas

Você também pode escrever suas próprias consultas em Kusto Query Language (KQL). Basta selecionar o painel central superior, que é editável, e personalizar a consulta para atender às suas necessidades.

As duas consultas a seguir extraem dados dos eventos de log do Spark:

SparkLoggingEvent_CL | where logger_name_s contains "com.microsoft.pnp"
SparkLoggingEvent_CL
| where TimeGenerated > ago(7d)
| project TimeGenerated, clusterName_s, logger_name_s
| summarize Count=count() by clusterName_s, logger_name_s, bin(TimeGenerated, 1h)

E esses dois exemplos são consultas no log de métricas do Spark:

SparkMetric_CL
| where name_s contains "executor.cpuTime"
| extend sname = split(name_s, ".")
| extend executor=strcat(sname[0], ".", sname[1])
| project TimeGenerated, cpuTime=count_d / 100000
SparkMetric_CL
| where name_s contains "driver.jvm.total."
| where executorId_s == "driver"
| extend memUsed_GB = value_d / 1000000000
| project TimeGenerated, name_s, memUsed_GB
| summarize max(memUsed_GB) by tostring(name_s), bin(TimeGenerated, 1m)

Terminologia da consulta

A tabela a seguir explica alguns dos termos usados quando você constrói uma consulta de logs e métricas de aplicativos.

Termo ID Observações
Cluster_init ID da aplicação
Queue o ID da Execução Um ID de execução equivale a vários lotes.
Batch ID do lote Um lote equivale a dois trabalhos.
Tarefa ID da tarefa Um trabalho equivale a duas etapas.
Fase ID do estágio Um estágio tem de 100 a 200 IDs de tarefa, dependendo da tarefa (leitura, embaralhamento ou gravação).
Tarefas ID de tarefa Uma tarefa é atribuída a um executor. Uma tarefa é atribuída para fazer uma partitionBy partição. Para cerca de 200 clientes, deve haver 200 tarefas.

As seções a seguir contêm as métricas típicas usadas neste cenário para monitorar a taxa de transferência do sistema, o status de execução do trabalho do Spark e o uso de recursos do sistema.

Taxa de transferência do sistema
Nome Medida Units
Taxa de transferência de fluxo Taxa média de entrada sobre a taxa média processada por minuto Linhas por minuto
Duração do trabalho Duração média do trabalho Spark terminado por minuto Duração(ões) por minuto
Contagem de empregos Número médio de trabalhos Spark encerrados por minuto Número de trabalhos por minuto
Duração do estágio Duração média das etapas concluídas por minuto Duração(ões) por minuto
Contagem de estágios Número médio de etapas concluídas por minuto Número de etapas por minuto
Duração da tarefa Duração média das tarefas concluídas por minuto Duração(ões) por minuto
Contagem de tarefas Número médio de tarefas concluídas por minuto Número de tarefas por minuto
Status de execução do trabalho do Spark
Nome Medida Units
Contagem de pool do agendador Número de contagem distinta de pools de agendadores por minuto (número de filas em operação) Número de grupos de agendadores
Número de executores em execução Número de executores em execução por minuto Número de executores em execução
Rastreamento de erros Todos os logs de erro com Error nível e as tarefas correspondentes/ID do estágio (mostrado em thread_name_s)
Utilização dos recursos do sistema
Nome Medida Units
Uso médio da CPU por executor/geral Porcentagem de CPU usada por executor por minuto % por minuto
Média de memória direta usada (MB) por host Média de memória direta usada por executores por minuto MB por minuto
Memória derramada por host Média de memória derramada por executor MB por minuto
Monitorar o impacto da distorção de dados na duração Intervalo de medidas e diferença do percentil 70-90 e percentil 90-100 na duração das tarefas Diferença líquida entre 100%, 90% e 70%; diferença percentual entre 100%, 90% e 70%

Decida como relacionar a entrada do cliente, que foi combinada em um arquivo GZIP, a um arquivo de saída específico do Azure Databricks, já que o Azure Databricks lida com toda a operação em lote como uma unidade. Aqui, você aplica granularidade ao rastreamento. Você também usa métricas personalizadas para rastrear um arquivo de saída para o arquivo de entrada original.

Para obter definições mais detalhadas de cada métrica, consulte Visualizações nos painéis deste site ou consulte a seção Métricas na documentação do Apache Spark.

Avalie as opções de ajuste de desempenho

Definição da linha de base

Você e sua equipe de desenvolvimento devem estabelecer uma linha de base, para que você possa comparar estados futuros do aplicativo.

Meça o desempenho do seu aplicativo quantitativamente. Nesse cenário, a métrica chave é a latência do trabalho, que é típica da maioria dos pré-processamento e ingestão de dados. Tente acelerar o tempo de processamento de dados e concentre-se na medição da latência, como no gráfico abaixo:

Job latency chart for performance tuning. The chart measures job latency per minute (0-50 seconds) while the application is running.

Meça a latência de execução de um trabalho: uma visão grosseira do desempenho geral do trabalho e da duração da execução do trabalho do início à conclusão (tempo de microlote). No gráfico acima, na marca das 19:30, leva cerca de 40 segundos de duração para processar o trabalho.

Se você olhar mais para esses 40 segundos, verá os dados abaixo para estágios:

Stage latency chart for performance tuning. The chart measures stage latency per minute (0-30 seconds) while the application is running.

Na marca das 19h30, há duas etapas: uma etapa laranja de 10 segundos e uma etapa verde de 30 segundos. Monitore se um estágio tem picos, porque um pico indica um atraso em um estágio.

Investigue quando um determinado estágio está sendo executado lentamente. No cenário de particionamento, normalmente há pelo menos dois estágios: um estágio para ler um arquivo e o outro estágio para embaralhar, particionar e gravar o arquivo. Se você tiver alta latência de estágio principalmente no estágio de escrita, poderá ter um problema de afunilamento durante o particionamento.

Task latency per stage chart for performance tuning, at the 90th percentile. The chart measures latency (0.032-16 seconds) while the app is running.

Observe as tarefas como os estágios de um trabalho executados sequencialmente, com os estágios anteriores bloqueando os estágios posteriores. Dentro de um estágio, se uma tarefa executar uma partição aleatória mais lentamente do que outras tarefas, todas as tarefas no cluster deverão aguardar a conclusão da tarefa mais lenta para que o estágio seja concluído. As tarefas são, então, uma maneira de monitorar a distorção de dados e possíveis gargalos. No gráfico acima, você pode ver que todas as tarefas estão distribuídas uniformemente.

Agora monitore o tempo de processamento. Como você tem um cenário de streaming, observe a taxa de transferência de streaming.

Streaming throughput/latency chart for performance tuning. The chart measures throughput (105-135 K) and latency per batch while the app is running.

No gráfico de taxa de transferência/latência de lote de streaming acima, a linha laranja representa a taxa de entrada (linhas de entrada por segundo). A linha azul representa a taxa de processamento (linhas processadas por segundo). Em alguns pontos, a taxa de processamento não captura a taxa de entrada. O problema potencial é que os arquivos de entrada estão se acumulando na fila.

Como a taxa de processamento não corresponde à taxa de entrada no gráfico, procure melhorar a taxa de processo para cobrir totalmente a taxa de entrada. Uma possível razão pode ser o desequilíbrio dos dados do cliente em cada chave de partição que leva a um gargalo. Para uma próxima etapa e uma possível solução, aproveite a escalabilidade do Azure Databricks.

Investigação de particionamento

Primeiro, identifique ainda mais o número correto de executores de dimensionamento de que você precisa com o Azure Databricks. Aplique a regra geral de atribuir cada partição com uma CPU dedicada em executores em execução. Por exemplo, se você tiver 200 chaves de partição, o número de CPUs multiplicado pelo número de executores deve ser igual a 200. (Por exemplo, oito CPUs combinadas com 25 executores seriam uma boa combinação.) Com 200 chaves de partição, cada executor pode trabalhar apenas em uma tarefa, o que reduz a chance de um gargalo.

Como algumas partições lentas estão nesse cenário, investigue a alta variância na duração das tarefas. Verifique se há picos na duração da tarefa. Uma tarefa lida com uma partição. Se uma tarefa requer mais tempo, a partição pode ser muito grande e causar um afunilamento.

List of results of a check skew query for performance tuning. The query is used for a partitioning investigation.

Rastreio de erros

Adicione um painel para rastreamento de erros para que você possa detetar falhas de dados específicas do cliente. No pré-processamento de dados, há momentos em que os arquivos estão corrompidos e os registros dentro de um arquivo não correspondem ao esquema de dados. O painel a seguir captura muitos arquivos e registros ruins.

Dashboard of error tracing information for performance tuning. Components include streaming errors, cluster (job/task) errors, and exception traces.

Este painel exibe a contagem de erros, a mensagem de erro e a ID da tarefa para depuração. Na mensagem, você pode facilmente rastrear o erro de volta para o arquivo de erro. Há vários arquivos em erro durante a leitura. Você revisa a linha do tempo superior e investiga nos pontos específicos do nosso gráfico (16:20 e 16:40).

Outros estrangulamentos

Para obter mais exemplos e orientações, consulte Solucionar problemas de gargalos de desempenho no Azure Databricks.

Resumo da avaliação de ajuste de desempenho

Para esse cenário, essas métricas identificaram as seguintes observações:

  • No gráfico de latência do estágio, os estágios de escrita levam a maior parte do tempo de processamento.
  • No gráfico de latência da tarefa, a latência da tarefa é estável.
  • No gráfico de taxa de transferência de streaming, a taxa de saída é menor do que a taxa de entrada em alguns pontos.
  • Na tabela de duração da tarefa, há variação da tarefa devido ao desequilíbrio dos dados do cliente.
  • Para obter um desempenho otimizado no estágio de particionamento, o número de executores de dimensionamento deve corresponder ao número de partições.
  • Há erros de rastreamento, como arquivos incorretos e registros incorretos.

Para diagnosticar esses problemas, você usou as seguintes métricas:

  • Latência do trabalho
  • Latência do estágio
  • Latência da tarefa
  • Taxa de transferência de streaming
  • Duração da tarefa (máx, média, min) por estágio
  • Rastreamento de erro (contagem, mensagem, ID da tarefa)

Contribuidores

Este artigo é mantido pela Microsoft. Foi originalmente escrito pelos seguintes contribuidores.

Autor principal:

Para ver perfis não públicos do LinkedIn, inicie sessão no LinkedIn.

Próximos passos