top of page
Buscar

Pools e Filas de Tarefas no Apache Airflow

O Apache Airflow é hoje uma das principais ferramentas de orquestração de pipelines de dados. Um dos seus pontos fortes é a capacidade de gerenciar concorrência de execução, garantindo que recursos sejam usados de forma eficiente. Isso é possível através de dois mecanismos-chave: pools e filas de tarefas (queues).

Neste guia , vamos explorar conceitos, usos práticos, exemplos e boas práticas para dominar o controle de tarefas no Airflow.

🔑 Conceito de Pools

Os pools são mecanismos de limitação de concorrência no Airflow. Eles servem para controlar quantas tarefas podem rodar em paralelo em um determinado grupo.

Características:

  • Cada pool tem um número fixo de slots.

  • Cada tarefa que usa o pool consome um ou mais slots durante sua execução.

  • Se não houver slots disponíveis, as tarefas ficam em estado queued até que haja espaço.

Exemplo prático:

  • Criar um pool chamado etl_pool com 5 slots.

  • Se uma DAG disparar 10 tarefas associadas a esse pool, apenas 5 rodam em paralelo; as demais ficam aguardando.

📦 Conceito de Queues (Filas de Tarefas)

As filas definem para qual worker (executor) as tarefas serão direcionadas.

  • Cada tarefa pode ter um parâmetro queue="nome_da_queue".

  • Os workers (Celery, Kubernetes ou Local executors) precisam estar configurados para escutar as filas certas.

  • Diferente dos pools, as filas não limitam diretamente a concorrência, mas controlam a distribuição de tarefas.

Exemplo prático:

  • Uma DAG pode mandar tarefas de ingestão para a queue="ingest", e tarefas de transformação para a queue="transform".

  • Isso permite segmentar recursos (ex.: workers com mais CPU ficam na fila de transformação).

🔎 Observando Pools e Filas no Airflow UI

Pools:

  1. Acesse: Admin > Pools

  2. Veja slots usados, livres e tarefas em espera.

  3. Monitore como tarefas entram em “queued” quando o pool atinge a capacidade máxima.

DAG Views:

  • Tree View: tarefas “queued” aparecem em cinza, “running” em verde.

  • Graph View: ótimo para entender dependências entre tarefas e gargalos.

Queues:

  • A fila de cada tarefa aparece na aba Task Instance ou via log da execução.

  • Em setups com Celery Executor, é possível mapear o comportamento de distribuição de tasks.

⚙️ Exemplos Práticos

1. Configurando um Pool

from airflow import DAG
from airflow.operators.dummy import DummyOperator
from datetime import datetime

with DAG("dag_pool_example", start_date=datetime(2025, 1, 1), schedule_interval=None) as dag:
    t1 = DummyOperator(task_id="task_1", pool="etl_pool")
    t2 = DummyOperator(task_id="task_2", pool="etl_pool")
    t3 = DummyOperator(task_id="task_3", pool="etl_pool")

Se o etl_pool tiver apenas 2 slots, apenas duas tarefas rodarão simultaneamente.



2. Usando pool_slots para pesar tarefas

from airflow.operators.bash import BashOperator

heavy_task = BashOperator(
    task_id="heavy",
    bash_command="sleep 60",
    pool="etl_pool",
    pool_slots=3  # ocupa 3 slots
)

Uma única tarefa pode consumir múltiplos slots, simulando maior carga de recursos.

3. Trabalhando com Queues

from airflow.operators.bash import BashOperator

ingest_task = BashOperator(
    task_id="ingest",
    bash_command="python ingest.py",
    queue="ingest"
)

transform_task = BashOperator(
    task_id="transform",
    bash_command="python transform.py",
    queue="transform"
)

Assim, cada worker pode processar apenas tarefas específicas de sua fila.

📊 Monitoramento Avançado

  • UI nativa (Admin > Pools e DAG views)

  • CLI:

    airflow pools list airflow pools set etl_pool 10 "Pool para ETL"

  • Integrações externas:

    • Datadog → métricas de tasks em fila e execução.

    • Prometheus + Grafana → dashboards de concorrência por pool/queue.

    • New Relic / OpenTelemetry → tracing e insights de performance.

🧭 Boas Práticas

  • Crie pools por tipo de workload (ETL, relatórios, machine learning).

  • Ajuste dinamicamente os slots conforme carga e capacidade dos workers.

  • Use pool_slots para tarefas pesadas e evite sobrecarga.

  • Combine pools (controle de concorrência) com queues (distribuição por worker) para máxima eficiência.

  • Monitore continuamente → gargalos em pools podem ser sinais de falta de recursos ou necessidade de balanceamento.

As pools e filas de tarefas no Airflow são recursos fundamentais para garantir eficiência, evitar gargalos e distribuir cargas de forma inteligente.

  • Pools limitam concorrência.

  • Queues distribuem execução entre workers.

  • Juntos, eles dão controle fino sobre recursos, performance e estabilidade.


Dominar esses conceitos é essencial para qualquer engenheiro de dados ou DevOps que trabalha com pipelines em escala.


ree

3 exemplos práticos de tuning das filas (queues) e pools (slots) para diferentes cenários:


1. Pipeline de ETL Noturno (Batch Pesado)

  • Problema: Um time de dados executa cargas noturnas que puxam dados de várias fontes. Algumas tarefas consomem muita CPU e acabam competindo com transformações mais leves, atrasando a conclusão.

  • Tuning:

    • Criar um pool exclusivo com poucos slots para as tarefas pesadas.

    • Configurar pool_slots=3 para simular “peso” maior em tarefas que fazem full load.

    • Usar a fila padrão (default_queue) para tarefas leves, liberando execução em paralelo.

  • Benefício: O throughput geral melhora porque cargas pesadas não sufocam a fila de execução.

2. Processamento em Tempo Real + Relatórios

  • Problema: No mesmo cluster, DAGs de streaming precisam ser processadas com prioridade, mas jobs de relatórios (menos urgentes) acabam competindo pelos mesmos workers.

  • Tuning:

    • Criar duas filas distintas: queue="realtime" e queue="reports".

    • Configurar workers dedicados apenas para a fila realtime.

    • Ajustar prioridade (priority_weight) das tasks de tempo real para garantir execução imediata quando slots sobram.

  • Benefício: As tarefas críticas de streaming nunca ficam presas atrás de relatórios batch, garantindo SLA de tempo real.

3. Treinamento de Modelos de Machine Learning

  • Problema: Treinamentos de ML consomem GPU e longos períodos de execução. Se rodarem junto de tarefas de ingestão, atrasam todo o pipeline.

  • Tuning:

    • Criar um pool “gpu_pool” com apenas 1 ou 2 slots.

    • Direcionar essas tarefas para a fila queue="ml_train", configurando workers em máquinas com GPU.

    • Outras tarefas de pré-processamento continuam em pools/fila padrão (etl_pool, default_queue).

  • Benefício: Evita gargalo e garante que apenas um número controlado de treinamentos rode em paralelo, preservando recursos de GPU e mantendo ingestões estáveis.



 
 
 

Comentários

bottom of page