Wie funktionieren Docker-Gesundheitsprüfungen und warum sind sie wichtig?

Question

Accepted Answer

Eine **Gesundheitsprüfung** (Health Check) teilt Docker (oder einem Orchestrator) mit, wie man bestimmt, ob die Anwendung eines Containers tatsächlich **funktioniert**, nicht nur läuft. Der Prozess eines Containers kann aktiv sein, während die Anwendung defekt ist (hängt fest, kann seine Datenbank nicht erreichen) — Gesundheitsprüfungen erkennen dies, damit die Plattform reagieren kann.

## Definieren einer Gesundheitsprüfung

```dockerfile
# in a Dockerfile
HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD curl -f http://localhost:3000/health || exit 1
# → Docker runs this command periodically; exit 0 = healthy, non-zero = unhealthy
```

```yaml
# in docker-compose.yml
healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
  interval: 30s
  timeout: 3s
  retries: 3
  start_period: 10s    # grace period on startup before failures count
```

Docker führt die Gesundheitsprüfungs-Befehl regelmäßig aus; der Status des Containers wird basierend auf dem Ergebnis `healthy` oder `unhealthy` (sichtbar in `docker ps`).

## Läuft vs. gesund (die entscheidende Unterscheidung)

```text
RUNNING → the container's process is alive (but the APP might be hung/broken)
HEALTHY → the health check confirms the app actually WORKS (responds correctly)
→ A container can be RUNNING but NOT HEALTHY (e.g. the app deadlocked, lost its DB).
  Without a health check, the platform only knows "running" — and keeps sending traffic
  to a broken container.
```

## Warum Gesundheitsprüfungen operativ wichtig sind

```text
✓ ORCHESTRATORS use them: restart unhealthy containers; route traffic only to healthy ones
✓ Compose depends_on: condition: service_healthy → wait for real readiness
✓ LIVENESS (is it alive? restart if not) vs READINESS (ready for traffic? hold traffic if not)
  → Kubernetes uses liveness + readiness probes (the same concept, more granular)
✓ Prevents serving requests from broken-but-running containers
```

## Warum es wichtig ist

Das Verständnis von Docker-Gesundheitsprüfungen ist wichtig für das **Betreiben zuverlässiger containerisierter Anwendungen** und ist daher wertvolles operatives Wissen.

Die entscheidende Erkenntnis ist die Unterscheidung zwischen **Laufen und Gesund**: Der Prozess eines Containers kann **am Leben sein, während die Anwendung tatsächlich defekt ist** (hängt fest, Deadlock, kann ihre Datenbank nicht erreichen) — und ohne Gesundheitsprüfung weiß die Plattform nur, dass der Container "läuft" und wird **weiterhin Traffic zu einem defekten Container routen**, was zu Ausfällen führt.

Gesundheitsprüfungen lösen dies, indem sie definieren, wie man überprüft, dass die Anwendung **tatsächlich funktioniert** (z.B. durch Aufrufen eines `/health`-Endpunkts), damit der Status des Containers die echte Gesundheit widerspiegelt, nicht nur die Prozesslivität.

Dies ist **operativ wichtig**, weil Orchestratoren und Tools darauf reagieren: Sie **starten ungesunde Container neu** (automatische Wiederherstellung von Festsetzungen/Deadlocks) und **routen Traffic nur an gesunde** (vermeiden das Senden von Anfragen an defekte Instanzen), und Compose's `depends_on: condition: service_healthy` nutzt Gesundheitsprüfungen, um auf echte Bereitschaft zu warten (löst Startverzögerungen).

Das Verständnis der verwandten Unterscheidung zwischen **Liviness und Readiness** (ist es am Leben und sollte neu gestartet werden, vs. ist es bereit, Traffic zu empfangen) ist wichtig, da **Kubernetes Liveness- und Readiness-Probes nutzt**, die auf diesem gleichen Konzept aufbauen — daher überträgt sich das Verständnis von Docker-Gesundheitsprüfungen direkt auf orchestrierte Umgebungen.

Da zuverlässiger Betrieb erfordert, zwischen "läuft" und "funktioniert tatsächlich" zu unterscheiden und auf defekte-aber-laufende Container zu reagieren (sie neu zu starten, Traffic einzubehalten), und da Gesundheitsprüfungen der Mechanismus sind, der dies ermöglicht — genutzt von Orchestratoren für Self-Healing und Traffic-Routing — ist das Verständnis von Docker-Gesundheitsprüfungen wertvolles, praktisch wichtiges Wissen für zuverlässigen Containerbetrieb, eine Schlüsselpraktik für Produktionsresilienz, die das häufige Problem verhindert, dass defekte Container stillschweigend weiterhin Traffic erhalten, und ein Konzept, das grundlegend dafür ist, wie Orchestratoren die Anwendungsgesundheit aufrechterhalten.