Pipelines batch

Como trazer dados de uma fonte, tratar e carregar num destino todo dia, sem duplicar, sem perder nada e se recuperando de falhas.

Cerca de 16 min · Revisado em

Ao final, você vai conseguir

  • Diferenciar as etapas de extrair, transformar e carregar, e as abordagens ETL e ELT
  • Escrever um pipeline em Python que separa registros válidos de rejeitados
  • Gravar dados de forma idempotente com INSERT ... ON CONFLICT
  • Explicar carga completa e incremental com marca d’água, e quando salvar a marca
  • Distinguir falhas passageiras de permanentes e ler um log de execução

O painel de vendas que a gerente abre às 8h, o relatório de vacinação do SUS e a lista de “pedidos de novo” do iFood dependem de dados que alguém trouxe de um lugar, arrumou e guardou em outro, todo dia, sem ninguém apertar botão. Esse trabalho é um pipeline. Construir um que não duplica, não perde dados e se recupera sozinho de falhas é a habilidade central de quem trabalha com engenharia de dados.

Da fonte à tabela: extrair, transformar, carregar

Um pipeline de dados é exatamente isso: um programa que pega dados de uma fonte (um arquivo, uma API, outro banco), corrige e organiza, e grava num destino onde outras pessoas consultam. Quando ele processa um lote de dados de tempos em tempos, como “todos os pedidos de ontem”, chamamos de pipeline batch (lote).

Extrair (Extract)
Buscar os dados na origem: baixar um CSV, chamar uma API página por página, ler uma tabela de outro sistema.
Transformar (Transform)
Converter tipos, padronizar textos, remover duplicados, rejeitar o que está inválido, calcular totais.
Carregar (Load)
Gravar o resultado no destino, normalmente uma tabela num banco ou data warehouse, para ser consultada.

Em que etapa do pipeline cada tarefa acontece?

Extrair · Transformar · Carregar

  • Baixar o CSV de vendas do servidor da loja
  • Chamar a API de pedidos página por página
  • Converter o texto 35,90 no número 35.9
  • Remover linhas repetidas
  • Padronizar o CEP para 8 dígitos sem traço
  • Gravar o resultado na tabela vendas_diarias

A ordem das letras muda o desenho. No ETL, você transforma antes de carregar: só o dado limpo chega ao destino. No ELT, você carrega o dado bruto primeiro e transforma depois, dentro do próprio banco, com SQL. Bancos analíticos modernos são rápidos o bastante para isso, e o ELT virou o padrão.

Sua equipe quer guardar os pedidos exatamente como vieram da API e decidir as regras de limpeza depois, com SQL, dentro do banco analítico. Que abordagem é essa?

  • ELT: carregar primeiro, transformar depois
  • ETL: transformar primeiro, carregar depois
  • Nenhuma: sem transformar, não é pipeline

Seu primeiro pipeline em Python

Na aula de Python para dados você leu CSV e separou valores inválidos. Agora vamos organizar isso como pipeline: três funções, uma para cada etapa, cada uma recebendo a saída da anterior. Funções pequenas são fáceis de testar e de rodar de novo.

Um detalhe importante está na função carregar: em vez de uma lista, o destino é um dicionário cuja chave é o id do pedido. Gravar o mesmo pedido duas vezes apenas substitui o anterior. Guarde essa ideia, ela volta na próxima seção.

Pipeline de pedidos da padaria

Complete transformar: rejeite pedidos com valor vazio ou negativo (guarde o id e o motivo em rejeitados) e converta o valor dos válidos para número com float. Rode e leia o resumo.

import csv
import io

ARQUIVO = """id,cliente,valor,data
1,Ana,35.90,2026-10-01
2,Bruno,,2026-10-01
3,Carla,120.00,2026-10-02
3,Carla,120.00,2026-10-02
4,Davi,-10,2026-10-02
5,Elis,58.50,2026-10-03
"""


def extrair(texto):
    return list(csv.DictReader(io.StringIO(texto)))


def transformar(linhas):
    validos = []
    rejeitados = []
    for linha in linhas:
        # TODO: se o valor estiver vazio ou for negativo,
        # guarde (id, motivo) em rejeitados e pule a linha.
        # Nos válidos, converta linha["valor"] com float().
        validos.append(linha)
    return validos, rejeitados


def carregar(linhas, destino):
    for linha in linhas:
        destino[linha["id"]] = linha  # chave = id: repetir substitui
    return destino


tabela = {}
brutos = extrair(ARQUIVO)
validos, rejeitados = transformar(brutos)
carregar(validos, tabela)

print(f"Lidos: {len(brutos)} | Válidos: {len(validos)} | Rejeitados: {len(rejeitados)}")
print(f"Pedidos na tabela: {len(tabela)}")
print("Rejeições:", rejeitados)
  • Os pedidos 2 (vazio) e 4 (negativo) foram rejeitados
  • Os valores válidos viraram números
  • A tabela tem 3 pedidos, sem o repetido
  • O total carregado é 214.40
O arquivo tinha 6 linhas, 4 passaram na validação, mas a tabela ficou com 3 pedidos. Para onde foi o quarto?

O pedido 3 veio repetido no arquivo. Como a tabela usa o id como chave, a segunda cópia substituiu a primeira em vez de criar outra linha. Fontes reais mandam duplicados o tempo todo; a chave é o que protege o destino.

Rodar duas vezes sem duplicar

Pipelines rodam de novo o tempo todo: uma nova tentativa automática depois de uma falha, alguém que executa à mão para conferir, um reprocessamento de um mês inteiro. Se cada execução acrescenta linhas sem olhar o que já existe, o faturamento do dia aparece em dobro no painel. Por isso a regra de ouro: toda carga precisa ser idempotente.

Três jeitos de gravar no destino
EstratégiaComo funcionaRodar de novo...
Append (acrescentar)INSERT de tudo, sempreDuplica as linhas
UpsertInsere se a chave é nova; atualiza se já existeDeixa igual, e aplica correções
Sobrescrever o períodoDELETE do dia processado, depois INSERT do diaDeixa igual: o dia é refeito inteiro

O upsert depende de uma chave: a coluna (ou conjunto de colunas) que identifica cada linha de forma única. Em vendas por loja e dia, a chave é o par (loja, dia). No SQLite e no PostgreSQL, o upsert se escreve com INSERT ... ON CONFLICT.

Upsert da carga diária

Rode a consulta como está e leia o erro: o par (loja, dia) já existe. Depois acrescente WHERE true e ON CONFLICT (loja, dia) DO UPDATE SET para atualizar total e carregado_em com os valores novos (excluded.total, excluded.carregado_em).

INSERT INTO vendas_diarias (loja, dia, total, carregado_em)
SELECT loja, dia, total, '2026-10-03 03:00'
FROM staging_vendas;

SELECT * FROM vendas_diarias ORDER BY loja;
  • A tabela tem as 3 lojas, sem linhas repetidas
  • O total corrigido do Centro (1610.50) foi aplicado
  • A consulta final mostra a tabela atualizada
  • Rodar a carga de novo não muda nada

Um pipeline faz INSERT de todos os pedidos de ontem, sem chave. Ele falhou na metade e a nova tentativa automática rodou do começo. O que acontece?

  • Os pedidos gravados antes da falha aparecem duas vezes
  • O banco percebe sozinho e ignora os repetidos
  • Nada, porque a primeira execução falhou e foi desfeita

Carga completa ou incremental

Existem duas formas de decidir o que extrair. Na carga completa (full), você traz a tabela inteira toda vez e substitui o destino. Na carga incremental, você traz só o que é novo ou mudou desde a última execução.

Quando usar cada uma
Completa (full)Incremental
Bom paraTabelas pequenas, como a lista de lojasTabelas que crescem todo dia, como pedidos
SimplicidadeAlta: apaga e recarregaMédia: precisa lembrar onde parou
CustoCresce com o tamanho da tabelaCresce com o volume do dia

Para saber onde parou, o pipeline guarda uma marca d’água (watermark): o maior valor de uma coluna como atualizado_em que ele já carregou. Na próxima execução, pede só as linhas com atualizado_em maior que a marca.

Uma execução incremental, passo a passo

marca = "2026-10-02 23:00"
novos = [p for p in fonte if p["atualizado_em"] > marca]
carregar(novos)
marca = max(p["atualizado_em"] for p in novos)
print(len(novos), "novos; marca agora", marca)
  1. Linha 1: A marca vem da execução anterior, guardada numa tabela de controle. Tudo até esse instante já foi carregado.
  2. Linha 2: Filtra só o que mudou depois da marca. Repare no pedido 7: ele é antigo, mas foi editado (o status virou “entregue”), então volta.
  3. Linha 3: Carrega com upsert: 18 e 19 são inseridos, o 7 é atualizado. Se fosse append, o pedido 7 apareceria duas vezes.
  4. Linha 4: Só depois da carga dar certo, a marca avança para o maior atualizado_em carregado.
  5. Linha 5: O log registra quantas linhas entraram e a nova marca. Amanhã o filtro começa daqui. Saída: 3 novos; marca agora 2026-10-03 22:41

Um colega move a linha que salva a nova marca para antes de carregar(novos). Num dia, a carga falha no meio. O que acontece na execução seguinte?

  • Os pedidos daquele lote nunca mais são carregados
  • Os pedidos daquele lote são carregados duas vezes
  • Nada muda, porque a ordem dessas linhas não importa

Coloque em ordem uma execução incremental segura.

  • Ler a última marca d’água na tabela de controle
  • Extrair da fonte as linhas com atualizado_em maior que a marca (menos a janela de segurança)
  • Validar e transformar as linhas extraídas
  • Gravar no destino com upsert
  • Salvar a nova marca d’água

Quando dá errado: falhas, retries e logs

Fontes reais falham. APIs devolvem dados em páginas (100 pedidos por vez) e limitam quantos pedidos você pode fazer por minuto. Quando você passa do limite, a resposta é 429 Too Many Requests. Um bom pipeline espera e tenta de novo, o que se chama retry.

Extraindo pedidos de uma API com paginação e limite

  1. Pipeline → API da loja: GET /pedidos?pagina=1. A API não manda tudo de uma vez: entrega uma página e avisa se há próxima.
  2. API da loja → Pipeline: 200 OK: 100 pedidos. Primeira página recebida. O pipeline guarda e pede a seguinte.
  3. Pipeline → API da loja: GET /pedidos?pagina=2. Segundo pedido, logo em seguida.
  4. API da loja → Pipeline: 429 Too Many Requests. Passou do limite por minuto. Não é um defeito nos dados: é só esperar.
  5. Pipeline → Pipeline: Espera 2s, depois 4s…. Cada nova tentativa espera o dobro da anterior (backoff exponencial), até um número máximo de tentativas. Assim o pipeline não martela a API.
  6. Pipeline → API da loja: GET pagina=2 (de novo). Segunda tentativa da mesma página.
  7. API da loja → Pipeline: 200 OK: 37 pedidos (fim). Última página: não há próxima. A extração terminou com 137 pedidos.
  8. Pipeline → Banco: Upsert de 137 pedidos. Só agora os dados vão para o banco, de forma idempotente.

Para cada falha, vale a pena tentar de novo automaticamente?

Passageira: tentar de novo · Permanente: precisa de correção

  • 429 Too Many Requests
  • Tempo esgotado na conexão (timeout)
  • 503 Service Unavailable durante manutenção
  • A coluna valor sumiu do arquivo de origem
  • 401: o token de acesso à API foi revogado
  • 400: a data foi enviada num formato que a API não aceita

Quando algo dá errado às 3h da manhã, ninguém está olhando. O que sobra é o log: as mensagens que o pipeline escreve enquanto roda. Em Python, use o módulo logging em vez de print, porque ele registra horário e nível de gravidade.

O log de uma execução que se recuperou sozinha

2026-10-03 03:00:02 INFO run=2026-10-02 etapa=extrair paginas=2 linhas=137
2026-10-03 03:00:04 WARNING etapa=extrair pagina=2 status=429 tentativa=1 espera=2s
2026-10-03 03:00:08 INFO run=2026-10-02 etapa=transformar validas=131 rejeitadas=6
2026-10-03 03:00:09 INFO run=2026-10-02 etapa=carregar inseridas=120 atualizadas=11
  • Horário: Quando cada coisa aconteceu. Comparando horários você descobre qual etapa demorou.
  • Nível: INFO é rotina; WARNING é algo estranho mas contornado; ERROR é falha. Alertas costumam disparar só a partir de ERROR.
  • Período processado: Qual dia de dados esta execução carregou. Sem isso, você não sabe o que reprocessar.
  • Retry registrado: O problema foi contornado, mas fica anotado. Se isso aparecer todo dia, talvez seja hora de pedir menos por minuto.
  • Contagens: O dado mais útil de um log. Se num dia as rejeições pulam de 6 para 6.000, a fonte mudou alguma coisa.
  • Resultado da carga: Separar inseridas de atualizadas mostra se o upsert está funcionando como você espera.

Um bug fez a carga do dia 2026-10-05 gravar valores errados. O bug já foi corrigido. Qual a melhor forma de consertar os dados?

  • Reprocessar só o dia 5, recarregando aquele período de forma idempotente
  • Apagar a tabela inteira e esperar a carga de amanhã
  • Corrigir os números à mão direto no banco
  • Rodar a carga completa de todo o histórico

Fechamento

  • Um pipeline batch extrai dados de uma fonte, transforma e carrega num destino, em lotes e em horários definidos; no ELT, o bruto é carregado antes da transformação.
  • Guardar a camada bruta separada da tratada permite refazer transformações sem pedir os dados de novo.
  • Toda carga deve ser idempotente: com upsert por chave ou sobrescrevendo o período, rodar duas vezes dá o mesmo resultado.
  • Na carga incremental, a marca d’água registra até onde já foi carregado e só avança depois que a carga deu certo.
  • Falhas passageiras pedem retry com espera crescente; permanentes pedem alerta. Logs com período e contagens tornam tudo isso investigável.

Uma carga que aguenta rodar duas vezes

Escolha um conjunto de dados público pequeno, como um CSV do portal dados.gov.br, e construa um pipeline batch no seu computador usando Python e SQLite ou DuckDB.

  1. Salve o arquivo original numa pasta bruto/ e nunca altere esse arquivo
  2. Escreva as funções extrair, transformar e carregar, rejeitando linhas inválidas com um motivo
  3. Grave numa tabela com chave primária usando INSERT ... ON CONFLICT
  4. Rode a carga duas vezes seguidas e confirme com SELECT COUNT(*) que nada duplicou
  5. Simule uma falha no meio (por exemplo, um raise depois de metade das linhas), rode de novo e confira que o resultado final está correto
  6. Registre com logging o período, as linhas lidas, rejeitadas e gravadas em cada execução

Referências

Cursos relacionados