Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 5: Probes und Lebenszyklus

Ziel: Kubernetes weiß, wann api und web bereit und wann sie kaputt sind, und ein Rollout unter Last kostet keine einzige Anfrage. · Dauer: ca. 75 min · Voraussetzung: Tag 4

Briefing

  • startupProbe: Läuft zuerst, bis sie einmal klappt. Solange sie läuft, ruhen die anderen beiden. Scheitert sie zu oft: Neustart.
  • readinessProbe: Scheitert sie, gilt der Pod in der EndpointSlice als nicht bereit (Tag 3) – kein Verkehr, aber kein Neustart.
  • livenessProbe: Scheitert sie, startet das Kubelet den Container neu.
  • Beim Beenden: Pod verlässt die Endpoints, gleichzeitig läuft preStop, danach kommt SIGTERM, nach der Grace Period SIGKILL.
 kubectl delete pod ──► Endpoints raus ─┐
                    └─► preStop sleep 5 ┴─► SIGTERM ─► "shutdown complete"
 |◄──────────── terminationGracePeriodSeconds: 30 ─────────────►| SIGKILL

Drill 1: Rollout ohne Probes

Tagesstart:

source ~/k8s-lab/setup/env.sh
mkdir -p ~/k8s-lab/tag05 && cd ~/k8s-lab/tag05
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag04/notes/." .

Last erzeugt curl selbst: [1-1000] in der URL macht daraus 1000 Anfragen nacheinander, --rate 25/s verteilt sie auf 40 Sekunden. -w schreibt je Anfrage den HTTP-Code (000 = keine Antwort), sort | uniq -c zählt sie. & schickt das Ganze in den Hintergrund:

curl -s -m 2 --rate 25/s -o /dev/null -w '%{http_code}\n' \
  'localhost:30080/api/notes?n=[1-1000]' | sort | uniq -c > load.txt &
sleep 2; kubectl rollout restart deploy/api deploy/web >/dev/null
wait; cat load.txt

Erwartet (Zahlen weichen bei dir ab):

     14 000
    984 200
      2 500

Ein Teil der Anfragen geht schief, obwohl maxUnavailable: 0 gilt. Ohne Probe gilt ein Pod als bereit, sobald sein Prozess läuft, und ein alter Pod bekommt noch Verkehr, während er schon beendet wird.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Drei Probes für api

Die vollständige api.yaml liegt im Begleitcode. Neu sind diese Zeilen im Container und terminationGracePeriodSeconds im Pod:

# k8s/api.yaml (Ausschnitt) – Stand Ende Tag 5
    spec:
      terminationGracePeriodSeconds: 30
      containers:
        - name: api
          # … image, env, ports wie an Tag 4 …
          startupProbe:
            httpGet:
              path: /healthz
              port: 8080
            periodSeconds: 1
            failureThreshold: 30
          readinessProbe:
            httpGet:
              path: /healthz
              port: 8080
            periodSeconds: 5
          livenessProbe:
            httpGet:
              path: /version
              port: 8080
            periodSeconds: 10
            failureThreshold: 3
          lifecycle:
            preStop:
              sleep:
                seconds: 5

web bekommt readinessProbe (alle 5 s) und livenessProbe (alle 10 s), beide auf /healthz Port 3000. worker bleibt ohne Probe – er hat keinen HTTP-Port.

Feld Standard Bedeutung
periodSeconds 10 Abstand zwischen zwei Prüfungen
failureThreshold 3 so viele Fehlschläge in Folge, dann greift die Probe
timeoutSeconds 1 Höchstdauer einer Prüfung
initialDelaySeconds 0 Wartezeit vor der ersten Prüfung

Die startupProbe gibt api also bis zu 30 × 1 s zum Hochfahren und prüft dabei jede Sekunde – schnell bereit, ohne Liveness-Neustarts bei einem langsamen Start.

cp "$LAB/code/tag05/notes/k8s/"{api,web}.yaml k8s/
kubectl apply --dry-run=server -f k8s/ | grep configured
kubectl apply -f k8s/ | grep configured
kubectl rollout status deploy/api >/dev/null
kubectl rollout status deploy/web >/dev/null
kubectl describe pod -l app.kubernetes.io/name=api \
  | grep -E '^\s+(Liveness|Readiness|Startup):' | sort -u

Erwartet (gekürzt):

deployment.apps/api configured (server dry run)
deployment.apps/web configured (server dry run)
deployment.apps/api configured
deployment.apps/web configured
    Liveness:       http-get http://:8080/version … period=10s … failureThreshold=3
    Readiness:      http-get http://:8080/healthz … period=5s … failureThreshold=3
    Startup:        http-get http://:8080/healthz … period=1s … failureThreshold=30

lifecycle.preStop.sleep ist eine eingebaute Aktion des Kubelets – das Image braucht kein sleep-Programm. Für notes-api aus scratch ist das entscheidend: exec: [sleep, "5"] würde dort scheitern.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Readiness – raus aus den Endpoints

Spiel eine fehlerhafte Version ein, deren Readiness nie klappt:

kubectl patch deploy api --type json -p '[{"op":"replace",
  "path":"/spec/template/spec/containers/0/readinessProbe/httpGet/path",
  "value":"/gibtsnicht"}]'
sleep 25
kubectl get pods -l app.kubernetes.io/name=api
kubectl rollout status deploy/api --timeout 5s; echo "Exit: $?"

Erwartet (gekürzt, Namen, IPs und Zeiten weichen bei dir ab):

deployment.apps/api patched
NAME                   READY   STATUS    RESTARTS   AGE
api-55996cd6b-4gfjv    0/1     Running   0          25s
api-65f8d67cdc-4pnkk   1/1     Running   0          3m46s
api-65f8d67cdc-sr5n6   1/1     Running   0          3m55s
api-65f8d67cdc-vp6q8   1/1     Running   0          3m50s
Waiting for deployment "api" rollout to finish: 1 out of 3 new replicas have been…
error: timed out waiting for the condition
Exit: 1

Der neue Pod läuft, ist aber nie 1/1. Wegen maxUnavailable: 0 baut das Deployment keinen alten ab. Wer bekommt Verkehr?

kubectl get endpointslice -l kubernetes.io/service-name=api -o jsonpath=\
'{range .items[*].endpoints[*]}{.targetRef.name}  ready={.conditions.ready}{"\n"}{end}'
kubectl get events --field-selector reason=Unhealthy \
  -o custom-columns=COUNT:.count,MESSAGE:.message
curl -s -o /dev/null -w '%{http_code}\n' localhost:30080/api/notes

Erwartet (gekürzt):

api-65f8d67cdc-sr5n6  ready=true
api-65f8d67cdc-vp6q8  ready=true
api-65f8d67cdc-4pnkk  ready=true
api-55996cd6b-4gfjv  ready=false
COUNT   MESSAGE
8       Readiness probe failed: HTTP probe failed with statuscode: 404
200

Die EndpointSlice führt den Pod, aber als ready=false – kube-proxy schickt ihm nichts. Die App merkt vom kaputten Rollout nichts. Reparatur mit der Datei:

kubectl apply -f k8s/api.yaml && kubectl rollout status deploy/api

Erwartet (gekürzt):

deployment.apps/api configured
service/api unchanged
deployment "api" successfully rolled out

Fortschritt speichern? Kostenlos registrieren

Drill 4: Liveness – Neustart bis CrashLoopBackOff

Jetzt ist die Liveness kaputt, die Readiness gesund:

kubectl patch deploy api --type json -p '[{"op":"replace",
  "path":"/spec/template/spec/containers/0/livenessProbe/httpGet/path",
  "value":"/gibtsnicht"}]'
kubectl rollout status deploy/api
for i in 1 2 3 4 5; do sleep 30; kubectl get pods -l app.kubernetes.io/name=api \
  --no-headers; echo; done

Erwartet (gekürzt):

deployment "api" successfully rolled out
api-6c57777c8d-f2d7z   1/1   Running   1 (1s ago)   36s
api-6c57777c8d-rbcbj   1/1   Running   0            33s
api-6c57777c8d-rsh5b   1/1   Running   1 (4s ago)   40s
…
api-6c57777c8d-f2d7z   0/1   Running   4 (2s ago)    2m7s
api-6c57777c8d-rbcbj   1/1   Running   3 (29s ago)   2m4s
api-6c57777c8d-rsh5b   1/1   Running   4 (5s ago)    2m11s

api-6c57777c8d-f2d7z   0/1   CrashLoopBackOff   4 (2s ago)    2m37s
api-6c57777c8d-rbcbj   1/1   Running            4 (29s ago)   2m34s
api-6c57777c8d-rsh5b   0/1   CrashLoopBackOff   4 (5s ago)    2m41s

Der Rollout war erfolgreich – Readiness klappte, mehr prüft er nicht. Danach startet das Kubelet jeden Container nach drei Fehlschlägen (30 s) neu, und vor jedem weiteren Start wartet es länger (exponentieller Backoff). In dieser Wartezeit steht CrashLoopBackOff. Was sagen Events und der letzte Lauf?

p=$(kubectl get pod -l app.kubernetes.io/name=api -o name | head -1)
kubectl describe $p | sed -n '/^Events/,$p' | grep -E 'Unhealthy|Killing|BackOff'
kubectl describe $p | grep -A3 'Last State'
kubectl logs $p --previous | tail -2

Erwartet (gekürzt):

  Warning  Unhealthy  38s (x15 over 2m58s)  kubelet  … Liveness probe failed: HTTP pro…
  Normal   Killing    38s (x5 over 2m38s)   kubelet  … Container api failed liveness…
  Warning  BackOff    31s (x3 over 33s)     kubelet  … Back-off restarting failed co…
    Last State:     Terminated
      Reason:       Completed
      Exit Code:    0
time=… level=INFO msg="signal received, shutting down"
time=… level=INFO msg="shutdown complete"

Exit 0 und ein sauberes shutdown complete: Die Anwendung war gesund, die Probe falsch. Mit --previous liest du die Logs des vorigen Containers – nach einem Neustart der wichtigste Schalter von kubectl logs. Reparatur:

kubectl apply -f k8s/api.yaml && kubectl rollout status deploy/api >/dev/null
kubectl get pods -l app.kubernetes.io/name=api

Erwartet (gekürzt):

deployment.apps/api configured
service/api unchanged
NAME                   READY   STATUS        RESTARTS      AGE
api-65f8d67cdc-jmbzt   1/1     Running       0             4s
api-65f8d67cdc-tzlst   1/1     Running       0             9s
api-65f8d67cdc-xgnvq   1/1     Running       0             7s
api-6c57777c8d-f2d7z   1/1     Terminating   5 (59s ago)   3m34s
…

Fortschritt speichern? Kostenlos registrieren

Drill 5: Warum Liveness auf /version

kubectl exec deploy/web -- wget -qO- http://api:8080/healthz
kubectl exec deploy/web -- wget -qO- http://api:8080/version

Erwartet:

ok
0.2.0

Heute liefern beide Pfade dasselbe Signal. Ab Tag 7 pingt /healthz die Datenbank. Läge die Liveness auf /healthz, würde ein Postgres-Neustart alle api-Pods neu starten lassen – obwohl sie gesund sind und nach dem Neustart ohnehin wieder nur auf die Datenbank warten. Die Readiness auf /healthz ist dagegen genau richtig: Ohne Datenbank kein Verkehr. Faustregel: Liveness prüft nur den Prozess selbst, nie seine Abhängigkeiten. Den Beweis führst du an Tag 7.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Graceful Shutdown

Lösch einen api-Pod und lies dabei sein Log mit:

p=$(kubectl get pod -l app.kubernetes.io/name=api \
  -o jsonpath='{.items[0].metadata.name}')
kubectl logs -f "$p" --since 1s &
sleep 1; date -u +%T; kubectl delete pod "$p" --wait=false
sleep 1
f='{range .items[*].endpoints[*]}{.targetRef.name} ready={.conditions.ready}'
f+=' terminating={.conditions.terminating}{"\n"}{end}'
kubectl get endpointslice -l kubernetes.io/service-name=api -o jsonpath="$f"
kubectl wait --for=delete pod/"$p" --timeout 60s; date -u +%T
wait

Erwartet (gekürzt):

14:47:58
pod "api-65f8d67cdc-jmbzt" deleted from notes namespace
api-65f8d67cdc-tzlst ready=true terminating=false
api-65f8d67cdc-xgnvq ready=true terminating=false
api-65f8d67cdc-jmbzt ready=false terminating=true
time=2026-10-30T14:48:03.749Z level=INFO msg="signal received, shutting down"
time=2026-10-30T14:48:03.749Z level=INFO msg="shutdown complete"
pod/api-65f8d67cdc-jmbzt condition met
14:48:05

Nach einer Sekunde ist der Pod terminating und nicht mehr ready – raus aus dem Verkehr. SIGTERM kommt erst fünf Sekunden nach dem Löschen: Das ist preStop: sleep. Die Pause gibt kube-proxy auf allen Nodes Zeit, die Regeln nachzuziehen, bevor der Prozess aufhört anzunehmen. notes-api beendet sich dann in Millisekunden. Bräuchte sie länger als 30 s (Grace Period, inklusive preStop), käme SIGKILL.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Rollout unter Last

Dieselbe Messung wie in Drill 1, jetzt für api:

curl -s -m 2 --rate 25/s -o /dev/null -w '%{http_code}\n' \
  'localhost:30080/api/notes?n=[1-1500]' | sort | uniq -c > load.txt &
sleep 2; kubectl rollout restart deploy/api >/dev/null
kubectl rollout status deploy/api >/dev/null
wait; cat load.txt

Erwartet (Zahlen weichen ab):

   1500 200

Keine einzige Anfrage verloren. Startup- und Readiness-Probe sorgen dafür, dass ein neuer Pod erst Verkehr bekommt, wenn er antwortet. preStop sorgt dafür, dass ein alter erst aufhört, wenn ihn niemand mehr anspricht. 1 500 Anfragen in einer Minute bedienen dabei abwechselnd drei Repliken.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

kubectl describe deploy api | grep -E 'Startup|Readiness|Liveness'

Erwartet: Startup und Readiness auf /healthz, Liveness auf /version.

    Liveness:   http-get http://:8080/version delay=0s timeout=1s period=10s …
    Readiness:  http-get http://:8080/healthz delay=0s timeout=1s period=5s …
    Startup:    http-get http://:8080/healthz delay=0s timeout=1s period=1s …
kubectl get deploy api -o yaml | grep -A2 'preStop:'

Erwartet: Vor dem Stopp wartet die api 5 Sekunden.

          preStop:
            sleep:
              seconds: 5
kubectl describe deploy web | grep -E 'Readiness|Liveness'

Erwartet: web prüft /healthz auf Port 3000.

    Liveness:   http-get http://:3000/healthz delay=0s timeout=1s period=10s …
    Readiness:  http-get http://:3000/healthz delay=0s timeout=1s period=5s …
kubectl get pods

Erwartet: alle 1/1, RESTARTS überall 0.

NAME                      READY   STATUS    RESTARTS   AGE
api-9d94fd76d-kk26s       1/1     Running   0          17s
api-9d94fd76d-rl5mf       1/1     Running   0          15s
api-9d94fd76d-txtrv       1/1     Running   0          12s
web-d746f7494-5pc5d       1/1     Running   0          16s
web-d746f7494-n2d2t       1/1     Running   0          9s
worker-866cd96f77-hhprl   1/1     Running   0          39s
kubectl exec deploy/web -- wget -qO- http://api:8080/version

Erwartet: Die api antwortet.

0.2.0

Challenge

Miss mit der curl-Last aus Drill 1 einen rollout restart von web. Gehen Anfragen verloren? Gib web vorübergehend dasselbe preStop wie api und miss noch einmal. Stell danach den Stand aus dem Begleitcode wieder her.

Hinweis: web nimmt die Anfragen vom NodePort direkt an – was in Drill 6 für api galt, gilt hier genauso.

Lösung

curl -s -m 2 --rate 25/s -o /dev/null -w '%{http_code}\n' \
  'localhost:30080/api/notes?n=[1-1000]' | sort | uniq -c > load.txt &
sleep 2; kubectl rollout restart deploy/web >/dev/null
kubectl rollout status deploy/web >/dev/null; wait; cat load.txt

Erwartet (Zahlen weichen ab):

   1000 200

In diesem Lauf ging nichts verloren: Ein schneller Rechner zieht die Regeln schneller nach, als die alten web-Pods enden. Auf einem ausgelasteten Mac siehst du hier oft einige 000. Ergänze in k8s/web.yaml unter der livenessProbe (gleiche Einrückung):

          lifecycle:
            preStop:
              sleep:
                seconds: 5
kubectl apply -f k8s/web.yaml && kubectl rollout status deploy/web >/dev/null
curl -s -m 2 --rate 25/s -o /dev/null -w '%{http_code}\n' \
  'localhost:30080/api/notes?n=[1-1000]' | sort | uniq -c > load.txt &
sleep 2; kubectl rollout restart deploy/web >/dev/null
kubectl rollout status deploy/web >/dev/null; wait; cat load.txt

Erwartet (Zahlen weichen ab):

deployment.apps/web configured
service/web unchanged
   1000 200

Mit preStop hat der alte Pod fünf Sekunden Vorlauf; auch auf einem ausgelasteten Rechner bleiben höchstens vereinzelte 000. Zurück auf den Stand des Begleitcodes:

cp "$LAB/code/tag05/notes/k8s/web.yaml" k8s/
kubectl apply -f k8s/web.yaml && kubectl rollout status deploy/web

Achtung: Ändere so etwas über die Datei, nicht per kubectl patch … "op":"add". kubectl apply entfernt nur Felder, die es selbst gesetzt hat (gemerkt in last-applied-configuration). Ein per Patch hinzugefügtes lifecycle überlebt jedes spätere apply, und kubectl diff zeigt nichts an.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Liveness-Probes sind die häufigste Ursache für selbst gemachte Ausfälle. Nie auf Abhängigkeiten prüfen, Timeouts großzügig wählen; im Zweifel nur Readiness.
  • minReadySeconds und progressDeadlineSeconds im Deployment machen Rollouts vorsichtiger und lassen sie sauber scheitern; Argo Rollouts oder Flagger ergänzen Canary-Analysen.
  • PodDisruptionBudgets schützen Repliken bei Node-Wartung (Drain, Tag 14) – Probes allein reichen dafür nicht.
  • Anwendungen sollten nach SIGTERM laufende Anfragen fertig bedienen und Verbindungen schließen. Die Grace Period muss preStop plus diese Zeit abdecken.
  • Hinter Ingress-Controllern und Cloud-Load-Balancern dauert die Endpoint-Propagation oft länger als 5 s – preStop entsprechend wählen.