0Pricing
Kubernetes Basics · Lektion

Health Checks: Liveness- und Readiness-Probes

Konfigurieren Sie Liveness- und Readiness-Probes, um sicherzustellen, dass Ihre Anwendungen fehlerfrei und bereit zur Verarbeitung von Datenverkehr sind.

Health Checks: Liveness- und Readiness-Probes ist eine kostenlose Kubernetes Basics-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Kubernetes Basics-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kubernetes Basics-Kurs umfasst insgesamt 4 Lektionen.

Anwendungen gesund halten

Woher weiß Kubernetes, ob Ihre Anwendung tatsächlich funktioniert? Es reicht nicht aus, dass ein Container lediglich läuft; er muss gesund und bereit sein, Datenverkehr zu bedienen.

Kubernetes verwendet spezielle Prüfungen, sogenannte Probes, um Ihre Anwendungen zu überwachen. Diese Probes tragen dazu bei, dass Ihre Benutzer stets einen zuverlässigen Dienst erhalten.

Was sind Liveness-Probes?

Eine Liveness-Probe prüft, ob Ihre Anwendung noch aktiv ist und reagiert. Wenn eine Liveness-Probe fehlschlägt, geht Kubernetes davon aus, dass Ihr Container fehlerhaft ist, und startet ihn neu.

Stellen Sie sich das wie einen Herzschlagmonitor vor: Wenn das Herz stehen bleibt, ist ein Neustart erforderlich! So können Deadlocks oder Abstürze der Anwendung behoben werden.

Grundlagen der Liveness-Probes

Sie können Liveness-Probes mit verschiedenen Methoden konfigurieren:

  • HTTP GET: Sendet eine HTTP-Anfrage an einen angegebenen Pfad.
  • TCP-Socket: Prüft, ob eine TCP-Verbindung zu einem Port geöffnet werden kann.
  • Exec-Befehl: Führt einen Befehl innerhalb des Containers aus.

Für Webanwendungen ist HTTP GET sehr verbreitet. Der folgende Ausschnitt zeigt, wie Sie eine solche Probe im YAML eines Pods definieren würden:

livenessProbe:
  httpGet:
    path: /healthz
    port: 8080
  initialDelaySeconds: 5
  periodSeconds: 5

Liveness-Probe in Aktion

Diese Python-Flask-Anwendung simuliert einen fehlerhaften Zustand, indem sie nach zwei Anfragen an /healthz abstürzt. Die Kubernetes-Probe erkennt dies und startet den Container neu.

Speichern Sie dies zunächst als app.py:

from flask import Flask, Response
import os
import time

app = Flask(__name__)
request_count = 0

@app.route('/healthz')
def health_check():
    global request_count
    request_count += 1
    if request_count > 2:
        print("Liveness probe failing! Exiting...")
        os._exit(1) # Simulate a crash
    print(f"Liveness probe successful (count: {request_count})")
    return Response("OK", status=200)

@app.route('/')
def home():
    return "Hello from the Liveness Probe Demo!"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080)

Liveness-Probe ausführen

Sehen wir uns nun an, wie Kubernetes die Liveness-Probe verwendet. Wenn Sie dies mit dem folgenden YAML bereitstellen, startet Kubernetes den Pod neu, sobald die Gesundheitsprüfung fehlschlägt:

apiVersion: v1
kind: Pod
metadata:
  name: liveness-demo
spec:
  containers:
  - name: liveness-container
    image: python:3.9-slim-buster
    command: ["python", "app.py"]
    ports:
    - containerPort: 8080
    livenessProbe:
      httpGet:
        path: /healthz
        port: 8080
      initialDelaySeconds: 5
      periodSeconds: 5
      failureThreshold: 1
    volumeMounts:
    - name: app-volume
      mountPath: /app
  volumes:
  - name: app-volume
    configMap:
      name: liveness-app-config

# (You'd need a ConfigMap for app.py, omitted for brevity)

Nach der Bereitstellung schlägt die dritte Prüfung nach zwei erfolgreichen Prüfungen fehl, und Kubernetes startet den Container neu.

Was sind Readiness-Probes?

Eine Readiness-Probe prüft, ob Ihre Anwendung bereit ist, Datenverkehr zu bedienen. Wenn eine Readiness-Probe fehlschlägt, sendet Kubernetes keinen Datenverkehr mehr an diesen Pod, startet ihn jedoch nicht neu.

Das ist während des Starts (z. B. beim Warten auf eine Datenbankverbindung) oder beim kontrollierten Herunterfahren besonders wichtig. Denken Sie an die Frage: „Ist das Geschäft für Kunden geöffnet?“

Grundlagen der Readiness-Probes

Readiness-Probes werden ähnlich wie Liveness-Probes mit HTTP GET, TCP-Socket oder Exec-Befehlen konfiguriert. Der entscheidende Unterschied liegt in ihrer Wirkung:

  • Liveness: Startet den Container bei einem Fehler neu.
  • Readiness: Entfernt den Pod bei einem Fehler aus den Service-Endpunkten (kein Datenverkehr).

Hier ist ein Ausschnitt für eine Readiness-Probe:

readinessProbe:
  httpGet:
    path: /ready
    port: 8080
  initialDelaySeconds: 10
  periodSeconds: 5

Readiness-Probe in Aktion

Diese Flask-Anwendung simuliert eine Anwendung, deren Initialisierung einige Zeit dauert (z. B. beim Herstellen einer Datenbankverbindung). Sie meldet erst nach 5 Sekunden den Status „bereit“.

Speichern Sie dies als ready_app.py:

from flask import Flask, Response
import time

app = Flask(__name__)
start_time = time.time()
READY_AFTER_SECONDS = 5

@app.route('/ready')
def readiness_check():
    if time.time() - start_time > READY_AFTER_SECONDS:
        print("Readiness probe successful: App is ready!")
        return Response("READY", status=200)
    else:
        print("Readiness probe failing: App not ready yet...")
        return Response("NOT READY", status=503)

@app.route('/')
def home():
    return "Hello from the Readiness Probe Demo!"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080)

Readiness-Probe ausführen

Wenn dieser Pod mit dieser YAML-Datei bereitgestellt wird, empfängt er während der ersten initialDelaySeconds plus der Zeit, die /ready benötigt, um 200 OK zurückzugeben, keinen Datenverkehr.

apiVersion: v1
kind: Pod
metadata:
  name: readiness-demo
spec:
  containers:
  - name: readiness-container
    image: python:3.9-slim-buster
    command: ["python", "ready_app.py"]
    ports:
    - containerPort: 8080
    readinessProbe:
      httpGet:
        path: /ready
        port: 8080
      initialDelaySeconds: 10
      periodSeconds: 3
    volumeMounts:
    - name: app-volume
      mountPath: /app
  volumes:
  - name: app-volume
    configMap:
      name: readiness-app-config

# (You'd need a ConfigMap for ready_app.py, omitted for brevity)

So wird sichergestellt, dass Datenverkehr nur an tatsächlich bereite Instanzen gesendet wird.

Liveness- und Readiness-Probes

Es ist wichtig, beide Probes korrekt einzusetzen:

  • Liveness-Probe: Sie erkennt, ob Ihre Anwendung abgestürzt ist oder sich in einem nicht wiederherstellbaren Zustand befindet. Bei einem Fehlschlag startet Kubernetes den Container neu.
  • Readiness-Probe: Sie erkennt, ob Ihre Anwendung bereit ist, Anfragen anzunehmen und zu verarbeiten. Bei einem Fehlschlag sendet Kubernetes keinen Datenverkehr mehr an den Pod.

Sie erfüllen unterschiedliche, sich jedoch ergänzende Aufgaben, damit Ihre Anwendungen robust bleiben.

Verständnis überprüfen

Welche der folgenden Aussagen zu Liveness- und Readiness-Probes sind RICHTIG?

Probes: Die wichtigsten Erkenntnisse

In dieser Lektion haben Sie Liveness- und Readiness-Probes in Kubernetes kennengelernt. Diese Zustandsprüfungen sind entscheidend für die Zuverlässigkeit und Verfügbarkeit Ihrer Anwendungen:

  • Liveness-Probes erkennen fehlerhafte Container und lösen Neustarts aus.
  • Readiness-Probes steuern, wann ein Pod bereit ist, Netzwerkdatenverkehr zu empfangen.

Durch ihren effektiven Einsatz bleiben Ihre Anwendungen stets reaktionsfähig und widerstandsfähig gegenüber Problemen.

Häufig gestellte Fragen

Ist die Lektion „Health Checks: Liveness- und Readiness-Probes“ kostenlos?

Ja — der vollständige Text von „Health Checks: Liveness- und Readiness-Probes“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kubernetes Basics-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kubernetes Basics-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Health Checks: Liveness- und Readiness-Probes“?

Konfigurieren Sie Liveness- und Readiness-Probes, um sicherzustellen, dass Ihre Anwendungen fehlerfrei und bereit zur Verarbeitung von Datenverkehr sind. Du übst Kubernetes Basics mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Kubernetes Basics zu starten?

Keine Vorkenntnisse erforderlich. Kubernetes Basics auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Health Checks: Liveness- und Readiness-Probes“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Kubernetes Basics-Lektion Code schreiben und ausführen?

Ja. Jede Kubernetes Basics-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Logging mit kubectl logs
  2. Metriken mit Prometheus und Grafana
  3. Health Checks: Liveness- und Readiness-Probes
  4. Verteiltes Tracing und Events
← Zurück zu Kubernetes Basics