Como solucionar problemas do programador do Airflow

Airflow Gerenciado (Geração 3) | Airflow Gerenciado (Geração 2) | Airflow Gerenciado (Geração 1 legada)

Nesta página, você encontra etapas de solução de problemas e informações sobre problemas comuns com programadores e processadores de DAG do Airflow.

Identificar a origem do problema

Para começar a solução de problemas, identifique se o problema ocorre:

  • No momento da análise do DAG, enquanto o DAG é analisado por um processador de DAG do Airflow
  • No momento da execução, enquanto o DAG é processado por um programador do Airflow

Para mais informações sobre o tempo de análise e o tempo de execução do DAG, leia Diferença entre o tempo de análise do DAG e o tempo de execução do DAG.

Inspecionar problemas de processamento de DAG

  1. Inspecione os registros do processador de DAG.
  2. Verifique os tempos de análise do DAG.

Monitoramento de tarefas em execução e na fila

Para verificar se há tarefas travadas em uma fila, siga estas etapas.

  1. No Google Cloud console do, acesse a página Ambientes.

    Acessar "Ambientes"

  2. Na lista de ambientes, clique no nome do seu ambiente. A página Detalhes do ambiente será aberta.

  3. Acesse a guia Monitoramento.

  4. Na guia Monitoramento, consulte o gráfico Tarefas do Airflow na seção Execuções do DAG e identifique possíveis problemas. As tarefas do Airflow são tarefas que estão em um estado enfileirado no Airflow. Elas podem ir para a fila de agentes do executor do Celery ou do Kubernetes. As tarefas em fila do Celery são instâncias de tarefas colocadas na fila de agentes do Celery.

Solução de problemas no momento da análise do DAG

As seções a seguir descrevem sintomas e possíveis correções para alguns problemas comuns no tempo de análise do DAG.

Análise e programação de DAGs no Airflow Gerenciado (Geração 1 legada) e no Airflow 1

A eficiência da análise de DAGs foi significativamente melhorada no Airflow 2. Se você tiver problemas de desempenho relacionados à análise e programação de DAGs, considere migrar para o Airflow 2.

No Airflow Gerenciado (Geração 1 legada), o programador é executado em nós de cluster com outros componentes do Airflow Gerenciado. Por isso, a carga de nós de cluster individuais pode ser maior ou menor em comparação com outros nós. O desempenho do programador (análise e programação de DAGs) pode variar dependendo do nó em que o programador é executado. Além disso, um nó individual em que o programador é executado pode mudar como resultado de operações de upgrade ou manutenção. Essa limitação foi resolvida no Airflow Gerenciado (Geração 2), em que é possível alocar recursos de CPU e memória para o escalonador, e o desempenho dele não depende da carga dos nós do cluster.

Número e distribuição de tempo das tarefas

O Airflow pode ter problemas ao programar um grande número de DAGs ou tarefas ao mesmo tempo. Para evitar problemas com a programação, você pode:

  • Ajustar os DAGs para usar um número menor de tarefas mais consolidadas.
  • Ajustar os intervalos de programação dos DAGs para distribuir as execuções de DAGs de maneira mais uniforme ao longo do tempo.

Como escalonar a configuração do Airflow

O Airflow oferece opções de configuração que controlam quantas tarefas e DAGs o Airflow pode executar ao mesmo tempo. Para definir essas opções de configuração, substitua os valores delas no seu ambiente. Também é possível definir alguns desses valores no nível do DAG ou da tarefa.

  • Simultaneidade do worker

    O parâmetro [celery]worker_concurrency controla o número máximo de tarefas que um worker do Airflow pode executar ao mesmo tempo. Se você multiplicar o valor desse parâmetro pelo número de workers do Airflow no ambiente do Airflow Gerenciado, você receberá o número máximo de tarefas que podem ser executadas em um determinado momento no ambiente. Esse número é limitado pela opção de configuração do Airflow [core]parallelism, que é descrita em mais detalhes.

  • Máximo de execuções de DAGs ativas

    A opção de configuração do Airflow [core]max_active_runs_per_dag controla o número máximo de execuções ativas de DAGs por DAG. O programador não criará mais execuções de DAGs se atingir esse limite.

    Se esse parâmetro for definido incorretamente, você poderá encontrar um problema em que o programador restringe a execução do DAG, porque não é possível criar mais instâncias de execução do DAG em um determinado momento.

    Também é possível definir esse valor no nível do DAG com o parâmetro max_active_runs.

  • Número máximo de tarefas ativas por DAG

    A opção de configuração do Airflow [core]max_active_tasks_per_dag controla o número máximo de instâncias de tarefa que podem ser executadas simultaneamente em cada DAG.

    Se esse parâmetro for definido incorretamente, você poderá encontrar um problema em que a execução de uma única instância do DAG é lenta porque há apenas um número limitado de tarefas do DAG que podem ser executadas em um determinado momento Nesse caso, é possível aumentar o valor dessa opção de configuração.

    Também é possível definir esse valor no nível do DAG com o parâmetro max_active_tasks.

    É possível usar max_active_tis_per_dag e max_active_tis_per_dagrun parâmetros no nível da tarefa para controlar quantas instâncias com um ID de tarefa específico podem ser executadas por DAG e por execução de DAG.

  • Paralelismo e tamanho do pool

    A opção de configuração [core]parallelism do Airflow controla quantas tarefas o programador do Airflow pode enfileirar na fila do executor após todas as dependências dessas tarefas serem atendidas.

    Este é um parâmetro global para toda a configuração do Airflow.

    As tarefas são enfileiradas e executadas em um pool. Os ambientes do Airflow Gerenciado usam apenas um pool. O tamanho desse pool controla quantas tarefas podem ser enfileiradas pelo programador para execução em um determinado momento. Se o tamanho do pool for muito pequeno, o programador não poderá enfileirar tarefas para execução, mesmo que os limites sejam definidos pela opção de configuração [core]parallelism e pela opção de configuração [celery]worker_concurrency multiplicada pelo número de workers do Airflow ainda não foi atendida.

    É possível configurar o tamanho do pool na interface do Airflow (Admin > Pools). Ajuste o tamanho do pool com o nível de paralelismo esperado no ambiente.

    Normalmente, [core]parallelism é definido como um produto do número máximo de workers e [celery]worker_concurrency.

Solução de problemas com tarefas em execução e na fila

As seções a seguir descrevem sintomas e possíveis correções para alguns problemas comuns com tarefas em execução e na fila.

As execuções de DAG não são realizadas

Sintoma:

Quando uma data de programação para um DAG é definida dinamicamente, isso pode levar a vários efeitos colaterais inesperados. Exemplo:

  • Uma execução de DAG está sempre no futuro, e o DAG nunca é executado.

  • As execuções de DAG anteriores são marcadas como executadas e bem-sucedidas, mesmo que não tenham sido executadas.

Mais informações estão disponíveis na documentação do Apache Airflow.

Soluções possíveis:

  • Siga as recomendações na documentação do Apache Airflow.

  • Defina start_date estático para DAGs. Como opção, é possível usar catchup=False para desativar a execução do DAG para datas anteriores.

  • Evite usar datetime.now() ou days_ago(<number of days>), a menos que você esteja ciente dos efeitos colaterais dessa abordagem.

Como usar o recurso TimeTable do programador do Airflow

As tabelas de tempo estão disponíveis a partir do Airflow 2.2.

É possível definir uma tabela de tempo para um DAG com um dos seguintes métodos:

Também é possível usar tabelas de tempo integradas.

Recursos de cluster limitados

É possível que ocorram problemas de desempenho se o cluster do GKE do ambiente for muito pequeno para processar todos os DAGs e tarefas. Nesse caso, tente uma destas soluções:

  • Crie um novo ambiente com um tipo de máquina que ofereça mais desempenho e migre seus DAGs para ele.
  • Crie mais ambientes do Airflow Gerenciado e divida os DAGs entre eles.
  • Altere o tipo de máquina dos nós do GKE, conforme descrito em Como fazer upgrade do tipo de máquina para os nós do GKE. Como esse procedimento é propenso a erros, é a opção menos recomendada.
  • Faça upgrade do tipo de máquina da instância do Cloud SQL que executa o banco de dados do Airflow no ambiente, por exemplo, usando os gcloud composer environments update comandos. O baixo desempenho do banco de dados do Airflow pode ser o motivo da lentidão do programador.

Evite programar tarefas durante janelas de manutenção

É possível definir janelas de manutenção para o ambiente para que a manutenção do ambiente ocorra fora dos horários em que você executa os DAGs. Ainda é possível executar os DAGs durante as janelas de manutenção, desde que seja aceitável que algumas tarefas possam ser interrompidas e repetidas. Para mais informações sobre como as janelas de manutenção afetam seu ambiente, consulte Especificar janelas de manutenção.

Uso de "wait_for_downstream" nos DAGs

Se você definir o parâmetro wait_for_downstream como True nos DAGs, para que uma tarefa seja bem-sucedida, todas as tarefas que estiverem imediatamente downstream também serão bem-sucedidas. Isso significa que a execução de tarefas pertencentes a uma determinada execução do DAG pode ser reduzida pela execução de tarefas da execução anterior do DAG. Leia mais sobre isso em a documentação do Airflow.

As tarefas enfileiradas por muito tempo serão canceladas e reprogramadas

Se uma tarefa do Airflow for mantida na fila por muito tempo, o programador a reprogramará para execução após o período definido na opção de configuração do Airflow [scheduler]task_queued_timeout. O valor padrão é 2400. Em versões do Airflow anteriores à 2.3.1, a tarefa também é marcada como com falha e repetida se for qualificada para uma nova tentativa.

Uma maneira de observar os sintomas dessa situação é analisar o gráfico com o número de tarefas enfileiradas (guia "Monitoramento" na interface do Airflow Gerenciado). Se os picos nesse gráfico não caírem em cerca de duas horas, as tarefas provavelmente serão reprogramadas (sem registros), seguidas pelas entradas de registro "As tarefas adotadas ainda estavam pendentes..." nos registros do programador. Nesses casos, a mensagem "O arquivo de registro não foi encontrado..." pode aparecer nos registros de tarefas do Airflow porque a tarefa não foi executada.

Em geral, esse comportamento é esperado, e a próxima instância da tarefa programada deve ser executada de acordo com a programação. Se você observar muitos casos desse tipo nos ambientes do Airflow Gerenciado, isso pode significar que não há workers do Airflow suficientes no ambiente para processar todas as tarefas programadas.

Resolução: para resolver esse problema, verifique se sempre há capacidade nos workers do Airflow para executar tarefas enfileiradas. Por exemplo, é possível aumentar o número de workers ou a simultaneidade do worker. Também é possível ajustar o paralelismo ou os pools para evitar o enfileiramento de tarefas além da capacidade disponível.

Abordagem do Airflow Gerenciado para o parâmetro min_file_process_interval

O Airflow Gerenciado muda a maneira como [scheduler]min_file_process_interval é usado pelo programador do Airflow.

Airflow 1

No caso do Airflow Gerenciado usando o Airflow 1, os usuários podem definir o valor de [scheduler]min_file_process_interval entre 0 e 600 segundos. Valores maiores que 600 segundos trazem os mesmos resultados que se [scheduler]min_file_process_interval estiver definido como 600 segundos.

Airflow 2

Em versões do Airflow Gerenciado anteriores à 1.19.9, [scheduler]min_file_process_interval é ignorado.

Versões do Airflow Gerenciado posteriores à 1.19.9:

O programador do Airflow é reiniciado depois que todos os DAGs são programados um determinado número de vezes, e o [scheduler]num_runs parâmetro controla quantas vezes isso é feito pelo programador. Quando o programador atinge os loops de programação [scheduler]num_runs, ele é reiniciado. O programador é um componente sem estado, e essa reinicialização é um mecanismo de recuperação automática para problemas que o programador possa encontrar. O valor padrão de [scheduler]num_runs é 5000.

[scheduler]min_file_process_interval pode ser usado para configurar a frequência com que a análise de DAGs ocorre, mas esse parâmetro não pode ser maior que o tempo necessário para que um programador execute loops [scheduler]num_runs ao programar os DAGs.

Como marcar tarefas como com falha após atingir dagrun_timeout

O programador marca as tarefas que não estão concluídas (em execução, programadas e enfileiradas) como com falha se uma execução de DAG não for concluída dentro de dagrun_timeout (um parâmetro de DAG).

Solução:

Sintomas do banco de dados do Airflow sob carga pesada

Às vezes, nos registros do programador do Airflow, você pode encontrar a seguinte entrada de registro de aviso:

Scheduler heartbeat got an exception: (_mysql_exceptions.OperationalError) (2006, "Lost connection to MySQL server at 'reading initial communication packet', system error: 0")"

Sintomas semelhantes também podem ser observados nos registros de worker do Airflow:

Para MySQL:

(_mysql_exceptions.OperationalError) (2006, "Lost connection to MySQL server at
'reading initial communication packet', system error: 0")"

Para PostgreSQL:

psycopg2.OperationalError: connection to server at ... failed

Esses erros ou avisos podem ser um sintoma de que o banco de dados do Airflow está sobrecarregado pelo número de conexões abertas ou pelo número de consultas executadas ao mesmo tempo, seja por programadores ou por outros componentes do Airflow, como workers, engatilhadores e servidores da Web.

Soluções possíveis:

O servidor da Web mostra o aviso "O programador não parece estar em execução"

O programador informa o sinal de funcionamento regularmente ao banco de dados do Airflow. Com base nessas informações, o servidor da Web do Airflow determina se o programador está ativo.

Às vezes, se o programador estiver sob carga pesada, ele poderá não conseguir informar o sinal de funcionamento a cada [scheduler]scheduler_heartbeat_sec.

Nessa situação, o servidor da Web do Airflow poderá mostrar o seguinte aviso:

The scheduler does not appear to be running. Last heartbeat was received <X>
seconds ago.

Soluções possíveis:

  • Aumente os recursos de CPU e memória para o programador.

  • Otimize os DAGs para que a análise e a programação sejam mais rápidas e não consumam muitos recursos do programador.

  • Evite usar variáveis globais em DAGs do Airflow. Em vez disso, use variáveis de ambiente e variáveis do Airflow.

  • Aumente o valor da opção de configuração do Airflow [scheduler]scheduler_health_check_threshold para que o servidor da Web espere mais tempo antes de informar a indisponibilidade do programador.

Soluções alternativas para problemas encontrados durante o preenchimento de DAGs

Às vezes, talvez você queira executar novamente DAGs que já foram executados. É possível fazer isso com um comando da CLI do Airflow da seguinte maneira:

Airflow 2 

gcloud composer environments run \
  ENVIRONMENT_NAME \
  --location LOCATION \
   dags backfill -- -B \
   -s START_DATE \
   -e END_DATE \
   DAG_NAME

Para executar novamente apenas as tarefas com falha de um DAG específico, use também o argumento --rerun-failed-tasks.

Airflow 1 

gcloud composer environments run \
  ENVIRONMENT_NAME \
  --location LOCATION \
  backfill -- -B \
  -s START_DATE \
  -e END_DATE \
  DAG_NAME

Para executar novamente apenas as tarefas com falha de um DAG específico, use também o argumento --rerun_failed_tasks.

Substitua:

  • ENVIRONMENT_NAME pelo nome do ambiente
  • LOCATION pela região em que o ambiente está localizado
  • START_DATE por um valor para o parâmetro start_date do DAG, no formato YYYY-MM-DD
  • END_DATE por um valor para o parâmetro end_date do DAG, no formato YYYY-MM-DD
  • DAG_NAME pelo nome do DAG

A operação de preenchimento pode gerar uma situação de deadlock em que um preenchimento não é possível porque há um bloqueio em uma tarefa. Exemplo:

2022-11-08 21:24:18.198 CET DAG ID Task ID Run ID Try number
2022-11-08 21:24:18.201 CET -------- --------- -------- ------------
2022-11-08 21:24:18.202 CET 2022-11-08 21:24:18.203 CET These tasks are deadlocked:
2022-11-08 21:24:18.203 CET DAG ID Task ID Run ID Try number
2022-11-08 21:24:18.204 CET ----------------------- ----------- ----------------------------------- ------------
2022-11-08 21:24:18.204 CET <DAG name> <Task name> backfill__2022-10-27T00:00:00+00:00 1
2022-11-08 21:24:19.249 CET Command exited with return code 1
...
2022-11-08 21:24:19.348 CET Failed to execute job 627927 for task backfill

Em alguns casos, é possível usar as seguintes soluções alternativas para superar deadlocks:

A seguir