Orquestração de Pipelines de Dados: ETL, Idempotência e Agendamento em Infraestrutura
Fundamentos de infra para pipelines de dados: batch e streaming, DAGs e orquestradores, idempotência, backfill, e por que um job de dados não é um cron qualquer.
Neste artigo
Todo sistema que cresce acaba precisando mover dados de um lugar para outro: do banco transacional para o data warehouse, dos logs de aplicação para a plataforma de analytics, de uma API de terceiro para uma tabela interna, de eventos brutos para métricas agregadas. No começo, isso costuma nascer como um script solitário disparado por um cron às três da manhã. Ele funciona por algumas semanas, até o dia em que a fonte fica indisponível por dez minutos, o script morre no meio, ninguém percebe, e o relatório da diretoria aparece com metade dos números. A partir daí, alguém descobre que mover dados de forma confiável é um problema de infraestrutura por si só — e não um detalhe que se resolve com uma linha no crontab.
Este guia trata de pipelines de dados sob a ótica de quem opera infraestrutura, não de quem faz ciência de dados. A pergunta não é "qual modelo treinar" nem "qual gráfico mostrar", e sim: como garantir que os dados cheguem, na ordem certa, no horário certo, de forma reprodutível, observável e recuperável quando algo falha — que, em produção, é sempre uma questão de quando, não de se. Os conceitos aqui valem tanto para um pipeline modesto de uma tabela quanto para uma malha com centenas de tarefas interdependentes.
Vamos percorrer o que é ETL e ELT, a diferença entre processamento em lote e em fluxo contínuo, por que orquestradores existem e o que é um DAG, e então mergulhar no conceito que sustenta tudo isso na prática: idempotência. Ela é o que separa um pipeline que você pode reprocessar sem medo de um que estraga os dados toda vez que alguém aperta "rodar de novo".
ETL e ELT: extrair, transformar, carregar
Um pipeline de dados, no seu formato clássico, tem três etapas resumidas na sigla ETL: extrair (ler os dados da origem — um banco, uma API, arquivos, uma fila de eventos), transformar (limpar, converter tipos, deduplicar, juntar com outras fontes, aplicar regras de negócio) e carregar (escrever o resultado no destino, tipicamente um data warehouse ou um data lake). O nome descreve a ordem em que as etapas acontecem, e essa ordem tem consequências arquiteturais importantes.
No ETL tradicional, a transformação acontece antes da carga, em geral num servidor de processamento intermediário. Os dados chegam crus da origem, passam por uma máquina que roda a lógica de transformação, e só a versão já tratada é gravada no destino. Esse modelo fazia todo o sentido quando o armazenamento no data warehouse era caro e o compute do warehouse era limitado: você não queria despejar terabytes de dados brutos num sistema caro, então filtrava e agregava antes de entrar.
O ELT inverte as duas últimas letras e a lógica: extrair, carregar, transformar. Você despeja os dados brutos no destino primeiro, sem quase nenhum tratamento, e faz a transformação depois, usando o poder de processamento do próprio warehouse. Esse modelo ganhou tração com a chegada dos data warehouses modernos em nuvem, que separam armazenamento de computação, cobram armazenamento a preços baixíssimos e escalam o compute sob demanda. Se guardar o dado bruto é barato e o warehouse processa SQL sobre bilhões de linhas com facilidade, por que manter um servidor de transformação à parte?
O ELT trouxe vantagens concretas para a infra. Os dados brutos ficam preservados no destino, então quando alguém descobre um bug na lógica de transformação, dá para recalcular a partir do dado original sem reextrair da fonte — que pode nem estar mais disponível. A transformação vira código versionado (frequentemente SQL) que roda dentro do warehouse, mais fácil de testar e auditar do que scripts espalhados por servidores intermediários. E a extração fica burra de propósito: sua única responsabilidade é copiar bytes fielmente, o que a torna mais simples e mais confiável. A escolha entre ETL e ELT não é ideológica; depende de custo de compute no destino, de restrições de conformidade (às vezes você não pode carregar dado sensível cru) e do volume envolvido.
Batch versus streaming: latência contra throughput
A segunda grande decisão de arquitetura é temporal: os dados são processados em lotes periódicos ou em fluxo contínuo?
No processamento em lote (batch), o pipeline acorda de tempos em tempos — de hora em hora, uma vez por dia, a cada quinze minutos — e processa tudo o que se acumulou desde a última execução. Ele opera sobre janelas de tempo bem definidas: "todos os pedidos de ontem", "os eventos das últimas duas horas". Batch é simples de raciocinar, fácil de reprocessar e ótimo em throughput: quando você processa milhões de registros de uma vez, aproveita bem o hardware e amortiza o custo fixo de subir o job. A contrapartida é a latência: o dado das 8h01 só será processado quando a próxima janela rodar.
No streaming, os dados são processados evento a evento (ou em micro-lotes de poucos segundos) assim que chegam. A latência despenca — o resultado reflete o que aconteceu há segundos — ao custo de complexidade operacional muito maior. Você precisa de infraestrutura que fique de pé o tempo todo consumindo de um broker de mensagens, lidar com eventos fora de ordem, gerenciar estado entre eventos e definir janelas móveis sobre um fluxo que nunca termina. Streaming brilha em detecção de fraude, monitoramento em tempo real, personalização ao vivo — casos em que dado de cinco minutos atrás já é dado velho.
A regra prática é começar por batch e só migrar para streaming a parte do sistema que comprovadamente precisa de baixa latência. Muita gente paga o custo do streaming para entregar um relatório que ninguém olha antes das nove da manhã. Um meio-termo comum é o processamento incremental: em vez de reprocessar a base inteira a cada execução, o pipeline processa apenas o que mudou desde a última rodada — os registros novos ou alterados. Isso mantém a simplicidade do batch com uma fração do custo, desde que você tenha como identificar o delta de forma confiável (um carimbo de tempo de atualização, um número de sequência, um log de mudanças).
Por que um job de dados não é um cron qualquer
Aqui está o cerne da mudança de mentalidade. Um cron dispara um comando num horário e pronto — essa é toda a sua inteligência. Ele não sabe nada sobre o que o comando faz, se deu certo, se dependia de outra coisa ter terminado antes, nem o que fazer quando falha. Para um pipeline de dados sério, isso é insuficiente em várias dimensões ao mesmo tempo.
- Dependências entre etapas. Carregar a tabela de faturamento depende de a tabela de pedidos já estar pronta, que por sua vez depende da extração ter terminado. Um cron não expressa "só rode B quando A terminar com sucesso"; ele apenas dispara A às 3h e B às 3h30 e torce para A caber em trinta minutos. No dia em que A demora quarenta, B roda sobre dados incompletos e ninguém é avisado.
- Ordem e reprocessamento. Quando você precisa rodar o pipeline de novo para uma data específica — porque a fonte corrigiu dados de três dias atrás — o cron não tem esse conceito. Ele só conhece "agora". Não existe "rode como se fosse terça-feira passada".
- Observabilidade. Um cron manda a saída para um e-mail que ninguém lê ou para
/dev/null. Não há histórico de execuções, duração, taxa de sucesso, nem visão de qual etapa travou. Quando o dado vem errado, você não tem onde olhar. - Retries e alertas. Falhas transitórias — a fonte piscou, a rede caiu por um segundo — são a norma em sistemas distribuídos. O cron não tem retry com espera progressiva, não distingue erro transitório de erro permanente, e não alerta ninguém. Ele falha em silêncio, que é o pior modo de falhar.
O cron isolado, em resumo, falha caladamente e não entende dependência. Ele é um gatilho de relógio, não um gerente de trabalho. Pipelines de dados precisam de algo que saiba o que deve rodar, em que ordem, o que fazer quando falha e como contar essa história depois. É para isso que existem os orquestradores.
Orquestradores e o conceito de DAG
Um orquestrador de dados é o sistema que sabe o formato do seu pipeline como um todo e gerencia sua execução. A abstração central que quase todos usam é o DAG — sigla em inglês para grafo acíclico dirigido. Traduzindo o nome: cada tarefa do pipeline é um nó do grafo; cada dependência entre tarefas é uma aresta dirigida ("esta tarefa vem depois daquela"); e "acíclico" significa que não há ciclos — nenhuma tarefa pode, direta ou indiretamente, depender de si mesma. Se pudesse, o pipeline nunca teria por onde começar.
O DAG é uma forma precisa de expressar exatamente o que o cron não expressava: a extração aponta para a limpeza, que aponta para a agregação, que aponta para a carga; duas extrações independentes podem rodar em paralelo porque não há aresta entre elas; a carga final só dispara quando todas as suas dependências terminaram com sucesso. O orquestrador lê esse grafo e decide, a cada instante, quais tarefas estão prontas para rodar (as que têm todas as dependências satisfeitas) e quais ainda esperam.
Por dentro, orquestradores como Airflow, Dagster e Prefect (para citar os exemplos mais discutidos, aqui de forma conceitual) compartilham uma anatomia parecida. Há um scheduler, que examina os DAGs, sabe seus horários e dependências e decide o que deve rodar agora. Há um executor, que efetivamente coloca as tarefas para rodar — em processos locais, em contêineres, em um pool de workers, em pods do Kubernetes. E há um banco de metadados, que guarda o histórico: cada execução de cada tarefa, seu estado (sucesso, falha, rodando, esperando), duração, tentativas, logs. Esse banco de metadados é o que dá observabilidade e o que permite ao orquestrador saber, ao ser reiniciado, o que já rodou e o que falta.
Vale distinguir o horário lógico do horário real. Quando um DAG "das 6h de terça" roda, a data que ele processa é terça, mesmo que a execução física tenha começado às 6h05 por causa de fila. Essa separação entre o período que o job representa e o momento em que ele efetivamente executa é o que torna possível reprocessar o passado — e é a base do backfill que veremos adiante.
Idempotência: a propriedade que sustenta tudo
Se há um único conceito para levar deste guia, é este. Idempotência é a propriedade de uma operação poder ser executada múltiplas vezes produzindo sempre o mesmo resultado final. Rodar a tarefa uma vez ou cinco vezes deixa o destino no mesmo estado. Parece um detalhe teórico, mas é o alicerce de todo pipeline confiável — porque, em produção, tarefas serão reexecutadas, você querendo ou não.
Pense por que. Retries reexecutam tarefas que falharam no meio — talvez depois de já terem escrito parte dos dados. Backfills reexecutam datas inteiras que já haviam rodado. Um deploy com problema faz você rerodar a última janela. Um worker morre e o orquestrador reagenda a tarefa que ele estava tocando. Em todos esses casos, se a tarefa não for idempotente, a reexecução corrompe os dados: duplica linhas, soma valores duas vezes, gera relatórios inflados. Uma tarefa que faz INSERT cego dos pedidos de ontem, rodada duas vezes, insere os pedidos de ontem duas vezes. A garantia que você quer é que reprocessar seja seguro — sempre.
Os padrões para alcançar idempotência são bem estabelecidos:
- Upsert / merge. Em vez de
INSERT, use uma operação que insere se a chave não existe e atualiza se existe (MERGE,INSERT ... ON CONFLICT). Rodar de novo sobre as mesmas chaves reescreve os mesmos valores, sem duplicar. - Partição por data e delete-insert. Organize a tabela de destino em partições por data. A tarefa de um dia primeiro apaga a partição daquele dia e depois insere o resultado recalculado. Rodar duas vezes apaga e reinsere: o estado final é idêntico. É um dos padrões mais robustos e usados, porque isola totalmente cada janela.
- Chaves determinísticas. Gere identificadores derivados do conteúdo (um hash das colunas que definem unicidade), não valores aleatórios ou sequenciais gerados na hora. Assim, o mesmo registro de entrada sempre produz a mesma chave de saída, e a deduplicação funciona entre execuções.
Por trás disso há a distinção entre exactly-once e at-least-once. Garantir que cada registro seja processado exatamente uma vez de ponta a ponta, em um sistema distribuído com falhas, é extremamente difícil e às vezes impossível na prática. A estratégia realista é entregar pelo menos uma vez — aceitar que pode haver reentrega e duplicata no caminho — e tornar o processamento idempotente, de modo que a duplicata não cause dano. Ou seja: você não tenta impedir a repetição; você a torna inofensiva. Essa é a filosofia madura de engenharia de dados. Não confie em nunca rodar duas vezes; projete para que rodar duas vezes não importe.
Backfill e reprocessamento histórico
Backfill é rodar o pipeline para datas passadas. Você lançou uma nova métrica hoje e quer preenchê-la com os últimos dois anos de dados históricos. Ou descobriu um bug na transformação que corrompeu um mês de tabelas e precisa recalcular esse mês inteiro. Ou a fonte reprocessou dados antigos e mandou correções. Em todos os casos, você precisa executar a lógica do pipeline "como se fosse" cada um daqueles dias.
O particionamento por data é o que torna o backfill viável e seguro. Se cada dia é uma partição independente e a tarefa de cada dia é idempotente (apaga-e-reinsere a partição), você simplesmente dispara a execução para o intervalo de datas desejado — os orquestradores oferecem exatamente esse comando — e cada dia é recalculado isoladamente, em paralelo, sem interferir nos vizinhos. Você pode até rerodar só os três dias que deram problema, sem tocar no resto.
O perigo mora no backfill não idempotente. Se a tarefa acumula em vez de substituir — soma sobre o que já estava lá, ou insere sem apagar antes — então cada backfill piora a corrupção que deveria corrigir. Você roda o mês de novo para consertar, e agora tem dados em dobro. Este é o cenário mais clássico de estrago em pipelines, e ele é inteiramente evitável projetando cada tarefa para ser idempotente desde o primeiro dia. A pergunta que todo autor de pipeline deve responder antes de subir qualquer coisa é: "o que acontece se isto rodar duas vezes para a mesma data?". Se a resposta não for "nada de errado", o desenho está incompleto.
Qualidade de dados e contratos
Um pipeline que move dados errados de forma confiável só distribui erro com eficiência. Por isso, checagens de qualidade de dados fazem parte do pipeline, não são um extra opcional. A ideia é falhar cedo: validar os dados na entrada e no meio do processo, e parar (ou desviar) antes de propagar lixo para o destino, onde ele contamina relatórios e decisões.
As validações típicas cobrem várias dimensões. Schema: as colunas esperadas existem, com os tipos esperados? A fonte não renomeou nem removeu um campo silenciosamente? Volume: o número de linhas está dentro da faixa histórica? Uma tabela que sempre tem cerca de um milhão de registros e hoje veio com mil é um sinal quase certo de extração truncada. Nulos e domínios: campos obrigatórios estão preenchidos? Valores estão dentro dos conjuntos permitidos (um status que só pode ser um de cinco valores)? Chaves supostamente únicas são de fato únicas?
Isso conecta com a noção de contratos de dados: um acordo explícito entre quem produz o dado e quem consome, sobre o schema, os tipos, as garantias de qualidade e a semântica dos campos. Quando o produtor rompe o contrato — muda um tipo, remove um campo —, a checagem detecta e falha alto, em vez de deixar a mudança escorrer despercebida pipeline abaixo até quebrar um dashboard três semanas depois. Falhar cedo e ruidosamente é sempre melhor do que corromper silenciosamente.
A infraestrutura por baixo
Do ponto de vista de quem opera, um orquestrador levanta perguntas de infra concretas. Onde as tarefas rodam? No executor local do orquestrador (simples, mas não escala), em um pool de workers dedicados, ou — cada vez mais comum — em pods efêmeros do Kubernetes, um por tarefa, que sobem, executam e morrem. O executor Kubernetes permite autoscaling dos workers: em uma janela de pico com dezenas de tarefas, o cluster cresce; fora dela, encolhe para quase nada, o que controla custo.
Isolamento de dependências é outro ponto sensível. Tarefas diferentes precisam de bibliotecas e versões diferentes, às vezes conflitantes. Rodar cada tarefa em seu próprio contêiner, com sua própria imagem, resolve o inferno de dependências que atormenta ambientes compartilhados. Segredos das fontes — credenciais de bancos, tokens de APIs — nunca ficam no código do DAG nem em variáveis expostas; vivem em um gerenciador de segredos e são injetados no runtime da tarefa, com o mesmo rigor de qualquer outro serviço de produção.
Há ainda o custo de compute, que em ELT sobre warehouse em nuvem pode escalar rápido e silenciosamente — uma transformação mal escrita que varre a base inteira a cada quinze minutos vira uma fatura desagradável. E há a linhagem (lineage): saber, para cada tabela ou coluna do destino, de quais fontes ela deriva e por quais transformações passou. Linhagem, somada à observabilidade do banco de metadados, é o que permite responder rápido a "por que este número está errado?" e "se eu mudar esta fonte, o que quebra?". Sem isso, cada incidente vira uma escavação arqueológica.
Armadilhas comuns
Alguns erros aparecem repetidamente e vale reconhecê-los antes de cair neles.
- Acoplamento temporal. Confiar que a tarefa A sempre termina antes de B começar só porque você as agendou com trinta minutos de intervalo. É o pecado original do cron. Expresse a dependência de verdade no DAG; não a deixe implícita no relógio.
- Tarefas que assumem estado. Um job que depende de algum arquivo ter sido deixado pela execução anterior, ou de uma variável global, quebra assim que roda fora de ordem ou em paralelo. Cada tarefa deve ser autocontida: recebe suas entradas explicitamente e produz suas saídas sem contar com resíduos de execuções passadas.
- Timezone e relógio. Misturar horários locais e UTC, ignorar horário de verão, ou assumir que a data do job é a data do calendário de quem está olhando. Padronize tudo em UTC internamente e seja explícito sobre a qual período cada execução se refere.
- Dados que chegam atrasados (late-arriving). Eventos de um dia que só chegam à fonte no dia seguinte. Se seu pipeline processa "ontem" e nunca mais volta a olhar, esses dados atrasados ficam para sempre de fora. O particionamento por data com reprocessamento idempotente resolve: você pode rerodar a partição de anteontem quando os dados atrasados enfim chegarem.
- Pipeline sem monitoramento. O erro que engloba todos os outros. Sem alertas de falha, sem métricas de duração e volume, sem checagem de qualidade, você só descobre que o pipeline quebrou quando alguém do negócio reclama de um número — que é tarde demais.
Por onde começar
Se você está montando o primeiro pipeline de verdade, comece pequeno e correto em vez de grande e frágil. Adote batch antes de sonhar com streaming; a esmagadora maioria dos casos vive perfeitamente feliz com uma janela de hora ou de dia. Escolha um orquestrador e modele o fluxo como um DAG explícito, com cada dependência declarada — nunca implícita no horário de agendamento. Torne cada tarefa idempotente desde a primeira linha, preferindo o padrão de partição por data com delete-insert, e teste isso rodando a mesma data duas vezes e conferindo que o resultado não mudou.
Prefira ELT quando o destino for um warehouse moderno: carregue o cru, preserve-o, e transforme com SQL versionado no destino, o que lhe dá reprocessamento livre a partir do dado original. Coloque checagens de qualidade na entrada e falhe cedo diante de schema quebrado, volume anômalo ou nulos indevidos. Instrumente tudo: alertas de falha que chegam a um humano, métricas de duração e volume, e o histórico do banco de metadados sempre à mão. E projete pensando no backfill desde o início — porque o dia em que você vai precisar reprocessar o passado não é uma hipótese, é uma certeza adiada.
No fim, um bom pipeline de dados se parece menos com um script esperto e mais com um serviço de produção bem-comportado: previsível, observável, recuperável e chato no melhor sentido da palavra. A diferença entre esse serviço e o script das três da manhã que ninguém entende não é a linguagem nem a ferramenta — é o rigor com que você tratou dependência, idempotência e observabilidade desde o começo.