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,90no número35.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.
| Estratégia | Como funciona | Rodar de novo... |
|---|---|---|
| Append (acrescentar) | INSERT de tudo, sempre | Duplica as linhas |
| Upsert | Insere se a chave é nova; atualiza se já existe | Deixa igual, e aplica correções |
| Sobrescrever o período | DELETE do dia processado, depois INSERT do dia | Deixa 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.
| Completa (full) | Incremental | |
|---|---|---|
| Bom para | Tabelas pequenas, como a lista de lojas | Tabelas que crescem todo dia, como pedidos |
| Simplicidade | Alta: apaga e recarrega | Média: precisa lembrar onde parou |
| Custo | Cresce com o tamanho da tabela | Cresce 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)- Linha 1: A marca vem da execução anterior, guardada numa tabela de controle. Tudo até esse instante já foi carregado.
- 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.
- Linha 3: Carrega com upsert: 18 e 19 são inseridos, o 7 é atualizado. Se fosse append, o pedido 7 apareceria duas vezes.
- Linha 4: Só depois da carga dar certo, a marca avança para o maior
atualizado_emcarregado. - 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_emmaior 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
- 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.
- API da loja → Pipeline: 200 OK: 100 pedidos. Primeira página recebida. O pipeline guarda e pede a seguinte.
- Pipeline → API da loja: GET /pedidos?pagina=2. Segundo pedido, logo em seguida.
- API da loja → Pipeline: 429 Too Many Requests. Passou do limite por minuto. Não é um defeito nos dados: é só esperar.
- 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.
- Pipeline → API da loja: GET pagina=2 (de novo). Segunda tentativa da mesma página.
- API da loja → Pipeline: 200 OK: 37 pedidos (fim). Última página: não há próxima. A extração terminou com 137 pedidos.
- 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 Unavailabledurante manutenção- A coluna
valorsumiu do arquivo de origem 401: o token de acesso à API foi revogado400: 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 deERROR. - 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.
- Salve o arquivo original numa pasta
bruto/e nunca altere esse arquivo - Escreva as funções
extrair,transformarecarregar, rejeitando linhas inválidas com um motivo - Grave numa tabela com chave primária usando
INSERT ... ON CONFLICT - Rode a carga duas vezes seguidas e confirme com
SELECT COUNT(*)que nada duplicou - Simule uma falha no meio (por exemplo, um
raisedepois de metade das linhas), rode de novo e confira que o resultado final está correto - Registre com
loggingo período, as linhas lidas, rejeitadas e gravadas em cada execução