Por que minha tarefa ETL do AWS Glue é executada por muito tempo?

Resolução

Os fatores comuns que podem fazer com que as tarefas do AWS Glue sejam executadas por muito tempo incluem as definições de configuração e a estrutura dos dados e scripts.

As etapas a seguir ajudam a otimizar o desempenho.

Configurar métricas e registros em log

Para identificar problemas e otimizar o desempenho, use as ferramentas de monitoramento integradas do AWS Glue, como o Amazon CloudWatch e as métricas de observabilidade de tarefas.

Além disso, configure alertas para anomalias e ative a interface do usuário do Apache Spark para obter uma melhor visão da operação das tarefas do AWS Glue. É possível usar o atributo AWS Glue Job Run Insights para entender detalhadamente o comportamento da tarefa durante a execução.

Para ativar as métricas, preencha uma das seguintes opções.

Do console do AWS Glue

1. Abra o console do AWS Glue.
2. No painel de navegação, selecione tarefas ETL.
3. Selecione a tarefa para a qual você deseja ativar as métricas.
4. Escolha Ação e, em seguida, Editar tarefa.
5. Na guia Detalhes da tarefa, em Opções avançadas, escolha Métricas da tarefa, Métricas de observabilidade da tarefa, Registro em log contínuo e Interface de usuário do Spark.
6. Escolha Salvar.

Da CLI ou SDK

Observação: Se você receber erros ao executar comandos da AWS Command Line Interface (AWS CLI), consulte Solução de problemas da AWS CLI. Além disso, verifique se você está usando a versão mais recente da AWS CLI.

Nas chamadas de API ou na CLI, passe os seguintes parâmetros no parâmetro DefaultArguments:

'--enable-metrics' : 'true'
'--enable-observability-metrics' : 'true'
'--enable-continuous-cloudwatch-log' : 'true'
'--enable-spark-ui' : 'true'
'--spark-event-logs-path' : '<s3://path/to/log/>'

Identificar gargalos

Para identificar gargalos, use os logs do driver do CloudWatch gerados pela execução da tarefa ou use os logs da interface do usuário do Spark. O AWS Glue 3.0 e versões posteriores podem lidar com junções distorcidas com recursos nativos do Spark, como execução adaptativa de consultas (AQE). Para mais informações, consulte interface de usuário da web no site do Apache.

Logs do driver

Para verificar os logs do driver:

1. Abra a tarefa no console do AWS Glue.
2. Na guia Execuções, selecione a execução da tarefa que você deseja verificar nos logs.
3. No grupo de logs do CloudWatch /aws-glue/jobs/error, selecione o Fluxo de logs que tem o mesmo nome do ID de execução da tarefa para a qual você abriu os logs. Procure fluxos que tenham nomes com o sufixo "\ _g-xxxxxx" - esses são os logs do executor.
4. Nos logs do driver, verifique se há tarefas que são executadas por muito tempo antes de serem concluídas. No exemplo a seguir, uma tarefa foi executada por 34 minutos e a tarefa do Spark para a qual essa tarefa foi criada terminou em 35 minutos.

   2024-09-13 10:06:13,847 INFO [task-result-getter-0] scheduler.TaskSetManager (Logging.scala:logInfo(61)): Finished task 0.0 in stage 0.0 (TID 0) in 2054673 ms on 172.35.184.56 (executor 1) (1/1)
   2024-09-13 10:06:13,894 INFO [Thread-13] scheduler.DAGScheduler (Logging.scala:logInfo(61)): Job 0 finished: save at DataSink.scala:666, took 2164.67 s

Logs da interface de usuário do Spark

Nos logs da interface de usuário do Spark, nas guias Tarefas e Etapas, procure etapas e tarefas que foram executadas por um longo tempo.

Corrigir gargalos

Particione os dados com mais eficiência. As tarefas do AWS Glue dependem do processamento distribuído. Se os dados não forem particionados de forma eficiente, os processadores do Spark podem precisar processar partições grandes e desbalanceadas. Esse tempo de processamento causa atrasos. Para controlar o número de partições, use as funções repartition () ou coalesce () no Spark. Certifique-se de que os dados estejam bem particionados para aproveitar a natureza distribuída do Spark. Também é possível configurar o AWS Glue DynamicFrame para particionar dados com SplitFields ou chaves de partição personalizadas.

Aumente a capacidade adicionando nós de processamento. Se não houver nós de processamento suficientes para lidar com o volume de dados, a tarefa será executada lentamente devido ao paralelismo limitado. Aumente o número de nós de processamento ou mude para um tipo de processador maior. Certifique-se de usar o tamanho certo de processador e de ter alocado DPUs (unidades de processamento de dados) suficientes para processar os dados com eficiência. O número de tarefas processadas por processador é igual a quatro vezes o número de DPUs. Por exemplo, um tipo de processador G.1X tem uma DPU e lida com quatro tarefas por executor. Observe que os tipos de processador G.4X e G.8X estão disponíveis somente para tarefas ETL do Spark no AWS Glue versão 3.0 ou posterior.

Redistribua os dados para reduzir a distorção entre as partições. A distorção de dados ocorre quando as partições têm quantidades significativamente diferentes de dados. Os nós com mais dados estão sobrecarregados, enquanto outros estão ociosos. Identifique chaves distorcidas analisando a distribuição de dados. Redistribua ou equilibre os dados entre partições ou use a técnica de aplicação de salt para distribuir as teclas de atalho. O AWS Glue 3.0 e versões posteriores podem lidar com junções distorcidas com recursos nativos do Spark, como execução adaptativa de consultas (AQE), no site do Apache. Para isso, ative a execução adaptativa de consultas (AQE) e defina spark.sql.adaptive.skewJoin.enabled como verdadeiro (true). A AQE é ativada por padrão a partir do spark 3.2.0. Para ativar a AQE no Glue 3.0, adicione um parâmetro spark.sql.adaptive.enabled e defina-o como verdadeiro (true).

Substitua UDFs por funções nativas do Spark. Funções personalizadas definidas pelo usuário (UDFs) ou transformações complexas podem ser caras para executar e podem atrasar as tarefas do Spark. Evite UDFs sempre que possível e confie nas funções nativas do Spark que são otimizadas para desempenho. Se os UDFs forem necessários, reescreva em Scala em vez de Python, pois os UDFs Scala geralmente têm melhor desempenho. Além disso, para uma melhor otimização, aplique transformações usando DataFrames ou DynamicFrames.

Minimize as operações aleatórias. Operações aleatórias, como groupBy, join ou orderBy, transferem dados entre os nós, podendo se tornar gargalos se usadas em excesso ou se não forem gerenciadas adequadamente. Minimize as operações aleatórias filtrando e agregando dados o quanto antes no processo de transformação. Para evitar transferências desnecessárias de dados, use junções de transmissão quando aplicável. Além disso, certifique-se de que os dados aleatórios sejam particionados de forma eficiente.

Remova o cache desnecessário. O uso excessivo ou inadequado do cache pode aumentar o consumo de memória e retardar a tarefa. Use cache () ou persist () somente ao reutilizar um conjunto de dados várias vezes em um fluxo de trabalho. Observe a memória disponível e limpe todos os conjuntos de dados em cache com unpersist () quando esses conjuntos de dados não forem mais necessários.

Quebre longas cadeias de dependência. Se a tarefa tem uma longa cadeia de transformações, o Spark recalcula toda a cadeia de dependências. Essas ações podem retardar o processamento. Divida tarefas complexas em tarefas menores. Se necessário, mantenha os resultados intermediários. Isso reduz a sobrecarga de recálculo e ajuda você a depurar e monitorar o desempenho de cada etapa individualmente.

Reduza a latência da rede e as operações de E/S. Ler e gravar dados em fontes externas, como Amazon Simple Storage Service (Amazon S3), Amazon Relational Database Service (Amazon RDS) ou Amazon Redshift, pode introduzir latência, especialmente com grandes conjuntos de dados. Use os conectores integrados do AWS Glue. Armazene dados em um formato compatível com a leituras e gravações mais rápidas, como Parquet ou ORC. Ative o S3 Transfer Acceleration para obter taxas de transferência de dados mais rápidas e use o Catálogo de Dados do AWS Glue para otimizar a recuperação de metadados.

Otimize as operações nativas. As operações nativas do Glue, incluindo marcadores de tarefa e conectores de exportação do DynamoDB, podem aumentar os tempos de execução de uma tarefa do AWS Glue. Para verificar os tempos de execução, identifique nos logs do driver quando a tarefa do AWS Glue começou e quando as tarefas de marcação ou exportação do DynamoDB terminaram. No DynamoDB, verifique se há mensagens semelhantes ao exemplo a seguir:

2024-08-24 03:33:37.000Z connections.DynamoExportConnection (DynamoExportConnection.scala:dynamodbexport(129)): Dynamodb Export complete...exported 712948751 item(s) or 4859215204353 byte(s)

Reduzir o efeito dos marcadores de tarefa

• Para reduzir o número de arquivos digitalizados, consolide arquivos pequenos em arquivos maiores.
• Remova as partições para um local de arquivo quando o processamento já estiver concluído.
• Use estratégias de partição eficientes para que o AWS Glue possa ignorar partições inteiras que não foram alteradas.
• Para filtrar dados com antecedência, use predicados push-down.
• Desative temporariamente os marcadores de tarefas se eles não agregarem valor ao processo da tarefa.

Reduzir o efeito dos conectores do DynamoDB

• Quando possível, reduza o volume de dados exportados.
• Para identificar problemas que causam atrasos na exportação, monitore o DynamoDB e o AWS Glue.
• Para acelerar os tempos de exportação, otimize as configurações de tabela do DynamoDB.
• Sempre que possível, exporte dados fora da tarefa principal ou ajuste os cronogramas para evitar gargalos.

Informações relacionadas

Usar parâmetros de tarefa em tarefas do AWS Glue

Monitorar trabalhos usando a interface do usuário da Web do Apache Spark

Monitoramento do planejamento da capacidade de DPU