Hvordan håndterer du fejl og mislykkede meddelelser i Kafka?

Question

Accepted Answer

Håndtering af **fejl og mislykkede meddelelser** er vigtig for pålidelige Kafka-consumere — det handler om at beslutte hvad der skal ske når behandling af en meddelelse fejler (retry, skip, eller rute til en **dead letter queue**). Korrekt fejlhåndtering forhindrer datatab og fastlåste consumere.

## Problemet: behandlingsfejl

```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.
```

## Fejlhåndteringsstrategier

```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)
```

## Praktiske overvejelser

```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)
```

## Hvorfor det betyder noget

At forstå hvordan man håndterer fejl og mislykkede meddelelser er værdifuldt fordi **korrekt fejlhåndtering er essentiel for pålidelige Kafka-consumere**, så det er vigtig praktisk viden.

Når en consumer ikke kan behandle en meddelelse, forårsager naiv håndtering problemer: blokering ved retry for evigt får consumeren **stuck på en "poison" meddelelse** (kan ikke gøre fremskridt), stille skipping forårsager **datatab**, og crash fører til genbehandling og bliver stuck igen — så en bevidst fejlhåndteringsstrategi er nødvendig.

At forstå **strategierne** — **retry med grænser** (retry af forbigående fejl med backoff men begrænsning af retries for at undgå at retry for evigt på permanente fejl), **dead letter queue (DLQ)** mønsteret (efter retries fejler, send meddelelsen til en separat DLQ topic så consumeren kan gøre fremskridt i stedet for at blive stuck, med DLQ inspiceret og genbehandlet senere — standardmåden at håndtere ubehandlelige meddelelser, undgå både blokering og tab), skelnen mellem forbigående (retry) vs permanente (DLQ) fejl, og idempotent behandling (for sikre retries) — er den vigtige praktiske viden til at bygge pålidelige consumere.

**DLQ mønsteret** er især standardløsningen på poison-message problemet, som lader consumere fortsætte med at gøre fremskridt mens mislykkede meddelelser bevares til senere håndtering.

At forstå de **praktiske overvejelser** — ikke lade en dårlig meddelelse blokere partitionen (brug DLQ til at gøre fremskridt), logging og alerts på fejl og DLQ meddelelser (synlighed), manuel offset commits for kontrol, og overvågning af DLQ (da en voksende DLQ signalerer problemer) — afspejler robust fejlhåndtering.

Korrekt fejlhåndtering forhindrer de rigtige problemer med stuck consumere (blokering) og datatab (stille skipping) som naiv håndtering forårsager.

Fordi korrekt fejlhåndtering (retries med grænser, dead letter queues, skelnen mellem fejltyper, idempotens) er essentiel for pålidelige Kafka-consumere — undgår stuck consumere og datatab — og DLQ mønsteret er standardløsningen, og fordi at forstå disse strategier er vigtig praktisk viden, er det værdifuldt at forstå hvordan man håndterer fejl og mislykkede meddelelser i Kafka — praktisk relevant viden, essentiel for pålidelige consumere, centreret omkring dead-letter-queue mønsteret til håndtering af ubehandlelige meddelelser uden blokering eller datatab, og vigtig for at bygge robuste Kafka-consumere der håndterer uundgåelige behandlingsfejl med elegance.