Como você trata erros e mensagens falhadas no Kafka?

Question

Accepted Answer

Tratar **erros e mensagens falhadas** é importante para consumidores Kafka confiáveis — decidir o que fazer quando o processamento de uma mensagem falha (retentar, pular ou rotear para uma **fila de letras mortas**). O tratamento adequado de erros previne perda de dados e consumidores travados.

## O problema: falhas de processamento

```text
When a consumer fails to PROCESS a message (bad data, downstream failure, bug):
  → BLOCKING retry forever → the consumer gets STUCK on a "poison" message (can't progress)
  → skipping silently → data LOSS (the message is lost)
  → crashing → consumer restarts, reprocesses, may get stuck again
→ need a deliberate error-handling strategy.
```

## Estratégias de tratamento de erros

```text
✓ RETRY (with limits) → retry transient failures (with backoff); but LIMIT retries (don't
  retry forever on a permanent failure)
✓ DEAD LETTER QUEUE (DLQ) → after retries fail, send the message to a separate DLQ TOPIC →
  the consumer moves on (not stuck); the DLQ is inspected/reprocessed later
  → the standard way to handle messages that can't be processed (avoids blocking + loss)
✓ Distinguish TRANSIENT (retry) vs PERMANENT (DLQ/skip) failures
✓ IDEMPOTENT processing → safe retries/reprocessing (at-least-once → duplicates)
```

## Considerações práticas

```text
✓ Don't let one bad message BLOCK the partition (move it aside via DLQ → keep progressing)
✓ LOG/ALERT on errors and DLQ messages (visibility — don't lose track of failures)
✓ Manual offset commit → control exactly what's marked processed
✓ Monitor DLQ → failed messages need attention (a growing DLQ signals problems)
```

## Por que isso importa

Compreender como tratar erros e mensagens falhadas é valioso porque **o tratamento adequado de erros é essencial para consumidores Kafka confiáveis**, então é um conhecimento prático importante.

Quando um consumidor falha ao processar uma mensagem, o tratamento ingênuo causa problemas: retentativas de bloqueio infinito deixam o consumidor **travado em uma mensagem "envenenada"** (impossível de progredir), pular silenciosamente causa **perda de dados**, e falhar leva a reprocessamento e ficar preso novamente — então uma estratégia deliberada de tratamento de erros é necessária.

Compreender as **estratégias** — **retentativas com limites** (retentar falhas transitórias com backoff mas limitar retentativas para evitar retentar para sempre em falhas permanentes), o padrão de **fila de letras mortas (DLQ)** (após falhas de retentativa, enviar a mensagem para um tópico DLQ separado para que o consumidor prossiga em vez de ficar preso, com o DLQ inspecionado e reprocessado depois — a forma padrão de tratar mensagens não processáveis, evitando bloqueio e perda), distinguir falhas transitórias (retentar) vs permanentes (DLQ), e processamento idempotente (para retentativas seguras) — é o conhecimento prático chave para construir consumidores confiáveis.

O padrão de **DLQ** em particular é a solução padrão para o problema de mensagens envenenadas, permitindo que consumidores continuem progredindo enquanto preservam mensagens falhadas para tratamento posterior.

Compreender as **considerações práticas** — não deixar uma mensagem ruim bloquear a partição (usando DLQ para continuar progredindo), registrar e alertar sobre erros e mensagens de DLQ (visibilidade), commits de offset manuais para controle, e monitorar o DLQ (já que um DLQ crescente sinaliza problemas) — reflete tratamento robusto de erros.

O tratamento adequado de erros previne os problemas reais de consumidores travados (bloqueio) e perda de dados (pulo silencioso) que o tratamento ingênuo causa.

Como o tratamento adequado de erros (retentativas com limites, filas de letras mortas, distinguir tipos de falha, idempotência) é essencial para consumidores Kafka confiáveis — prevenindo consumidores travados e perda de dados — e o padrão DLQ é a solução padrão, e como compreender essas estratégias é conhecimento prático importante, compreender como tratar erros e mensagens falhadas no Kafka é conhecimento valioso e praticamente relevante — essencial para consumidores confiáveis, centrado no padrão de fila de letras mortas para tratar mensagens não processáveis sem bloqueio ou perda de dados, e importante para construir consumidores Kafka robustos que lidam com as falhas inevitáveis de processamento com elegância.