Skip to content

About

Indicium Ciclo Preparatório

Topics

Resources

Stars

1 star

Watchers

0 watching

Forks

Repository files navigation

🚀 Pipeline ETL com Apache Airflow & Docker

Documentação completa do processo de construção de um pipeline ETL para migrar a tabela customers do source_db para o target_db usando Apache Airflow orquestrado via Astro CLI.


📋 Sumário


Visão Geral

O objetivo do projeto é construir um pipeline ETL que:

  1. Extrai a tabela customers do banco source_db
  2. Salva os dados localmente em um arquivo CSV
  3. Carrega os dados no banco target_db
  4. Valida a integridade da carga comparando contagens

Tecnologias

Tecnologia Finalidade
Apache Airflow (Astro CLI) Orquestração do pipeline
Docker / Docker Compose Containerização dos serviços
PostgreSQL 12 Bancos de origem e destino
Python + psycopg2 Conexão com os bancos
pandas Leitura e escrita do CSV

Arquitetura do Pipeline

extract_customers → save_customers_locally → load_customers_to_target → validate_load
Task O que faz
extract_customers Conecta no source_db, lê a tabela customers e salva como CSV
save_customers_locally Valida que o arquivo CSV foi criado e contém dados
load_customers_to_target Lê o CSV e insere os dados no target_db
validate_load Compara contagem de linhas entre CSV e target_db

Estrutura do Projeto

desafio_pratico_fundamentos_DE/
├── dags/
│   ├── customers_etl.py       # DAG principal
│   └── customers.csv          # Arquivo gerado pela DAG
├── docker-compose.yml         # source_db e target_db
├── Dockerfile
├── airflow_settings.yaml
├── northwind.sql              # Dados iniciais do source_db
├── requirements.txt
└── tmp/

Como Executar

⚠️ Importante: O Airflow deve ser iniciado antes do docker-compose, pois o docker-compose depende da rede criada pelo Airflow.

1. Inicie o Airflow

astro dev start

2. Suba os bancos de dados

docker-compose up -d

3. Conecte os bancos à rede do Airflow

docker network connect desafio-pratico-fundamentos-de_f4c7d3_airflow \
    desafio_pratico_fundamentos_de-source_db-1

docker network connect desafio-pratico-fundamentos-de_f4c7d3_airflow \
    desafio_pratico_fundamentos_de-target_db-1

4. Execute a DAG

Acesse http://localhost:8080, encontre a DAG customers_etl_pipeline e clique em Acionar.

5. Verifique o resultado

docker exec -it desafio_pratico_fundamentos_de-target_db-1 \
    psql -U postgres -d target_db -c "SELECT COUNT(*) FROM customers;"

Resultado esperado: 91 registros.


Código da DAG

from airflow import DAG
from airflow.operators.python import PythonOperator
from datetime import datetime
import psycopg2
import pandas as pd
import os

SOURCE_DB = {
    "host": "source_db",
    "database": "source_db",
    "user": "postgres",
    "password": "postgres",
    "port": 5432
}

TARGET_DB = {
    "host": "target_db",
    "database": "target_db",
    "user": "postgres",
    "password": "postgres",
    "port": 5432
}

LOCAL_FILE = "/usr/local/airflow/dags/customers.csv"

def extract_customers():
    conn = psycopg2.connect(**SOURCE_DB)
    df = pd.read_sql("SELECT * FROM customers", conn)
    conn.close()
    df.to_csv(LOCAL_FILE, index=False)
    print(f"✅ {len(df)} registros extraídos")

def save_customers_locally():
    if not os.path.exists(LOCAL_FILE):
        raise FileNotFoundError(f"Arquivo {LOCAL_FILE} não encontrado!")
    df = pd.read_csv(LOCAL_FILE)
    print(f"✅ Arquivo validado: {len(df)} linhas")

def load_customers_to_target():
    df = pd.read_csv(LOCAL_FILE)
    conn = psycopg2.connect(**TARGET_DB)
    cursor = conn.cursor()
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS customers (
            id SERIAL PRIMARY KEY,
            name VARCHAR(255),
            email VARCHAR(255),
            created_at TIMESTAMP
        )
    """)
    for _, row in df.iterrows():
        cursor.execute(
            "INSERT INTO customers (name, email, created_at) VALUES (%s, %s, %s)",
            (row.get("name"), row.get("email"), row.get("created_at"))
        )
    conn.commit()
    conn.close()
    print(f"✅ {len(df)} registros carregados no target_db")

def validate_load():
    source_df = pd.read_csv(LOCAL_FILE)
    conn = psycopg2.connect(**TARGET_DB)
    target_df = pd.read_sql("SELECT * FROM customers", conn)
    conn.close()
    assert len(target_df) >= len(source_df), "❌ Contagem divergente!"
    print(f"✅ Validação OK: {len(target_df)} registros no target_db")

with DAG(
    dag_id="customers_etl_pipeline",
    schedule="@daily",
    start_date=datetime(2024, 1, 1),
    catchup=False,
    tags=["etl", "customers"],
) as dag:
    t1 = PythonOperator(task_id="extract_customers", python_callable=extract_customers)
    t2 = PythonOperator(task_id="save_customers_locally", python_callable=save_customers_locally)
    t3 = PythonOperator(task_id="load_customers_to_target", python_callable=load_customers_to_target)
    t4 = PythonOperator(task_id="validate_load", python_callable=validate_load)

    t1 >> t2 >> t3 >> t4

Erros Encontrados e Soluções

❌ Erro 1 — ImportError: cannot import name 'days_ago'

days_ago foi removido nas versões recentes do Airflow.

# ❌ Errado
from airflow.utils.dates import days_ago
start_date=days_ago(1),

# ✅ Correto
from datetime import datetime
start_date=datetime(2024, 1, 1),

❌ Erro 2 — TypeError: unexpected keyword argument 'schedule_interval'

O parâmetro foi renomeado nas versões novas do Airflow.

# ❌ Errado
schedule_interval="@daily",

# ✅ Correto
schedule="@daily",

❌ Erro 3 — Connection refused no localhost

Dentro de um container Docker, localhost aponta para o próprio container, não para outros serviços.

# ❌ Errado
"host": "localhost",

# ✅ Correto
"host": "source_db",  # nome do serviço no docker-compose

❌ Erro 4 — could not translate host name 'source_db'

Os containers estavam em redes Docker diferentes e não se enxergavam.

  • Bancos estavam na rede: desafio_pratico_fundamentos_de_default
  • Airflow estava na rede: desafio-pratico-fundamentos-de_f4c7d3_airflow

Solução: adicionar os bancos à rede do Airflow via docker-compose.yml:

services:
  source_db:
    ...
    networks:
      - airflow_net
  target_db:
    ...
    networks:
      - airflow_net

networks:
  airflow_net:
    name: desafio-pratico-fundamentos-de_f4c7d3_airflow
    external: true

❌ Erro 5 — password authentication failed for user 'user'

As credenciais no código usavam valores genéricos ao invés das credenciais reais.

# ❌ Errado
"user": "user",
"password": "password",

# ✅ Correto (conforme docker-compose.yml)
"user": "postgres",
"password": "postgres",

❌ Erro 6 — CSV salvo dentro do container, não aparecia na máquina

O caminho /tmp no Windows era redirecionado para C:/Users/.../AppData/Local/Temp e não estava mapeado para o Airflow.

# ❌ Errado
LOCAL_FILE = "/tmp/customers.csv"

# ✅ Correto — usa a pasta dags/ que já tem volume mapeado
LOCAL_FILE = "/usr/local/airflow/dags/customers.csv"

❌ Erro 7 — network declared as external, but could not be found

Ao reiniciar o computador, a rede do Airflow não existia mais porque o Airflow não tinha sido iniciado ainda.

Solução: sempre iniciar o Airflow antes do docker-compose.

# Ordem correta
astro dev start       # 1. cria a rede
docker-compose up -d  # 2. sobe os bancos

Lições Aprendidas

Airflow

  • Parâmetros como days_ago e schedule_interval foram descontinuados — sempre verifique a versão instalada
  • O Airflow detecta mudanças na pasta dags/ automaticamente em ~30 segundos, sem precisar reiniciar
  • O painel de Erros de Importação é o primeiro lugar a verificar quando uma DAG não aparece

Docker

  • localhost dentro de um container nunca aponta para outros serviços — use o nome do serviço
  • Serviços em docker-compose diferentes ficam em redes separadas por padrão
  • Volumes precisam ser mapeados no container correto — mapear no source_db não adianta se quem grava é o Airflow

Boas práticas

  • Nunca colocar credenciais diretamente no código — usar as Connections do Airflow (Admin > Connections)
  • Sempre ler o log completo da task que falhou, não apenas a mensagem resumida
  • Documentar a ordem de inicialização quando há dependências entre serviços

===========================

Essa foi uma atividade prática para exploração do tema.

A proposta é servir como uma prática complementar de como funciona a construção de uma pipeline de ETL com Apache Airflow e PostgreSQL.

About

Indicium Ciclo Preparatório

Topics

Resources

Stars

1 star

Watchers

0 watching

Forks

Releases

Packages

Used by

Contributors

Languages