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.txtErwartet (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: 5web 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 -uErwartet (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/notesErwartet (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/apiErwartet (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; doneErwartet (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 -2Erwartet (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=apiErwartet (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/versionErwartet:
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
waitErwartet (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.txtErwartet (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 podsErwartet: 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/versionErwartet: 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.txtErwartet (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: 5kubectl 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.txtErwartet (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/webAchtung: Ändere so etwas über die Datei, nicht per
kubectl patch … "op":"add".kubectl applyentfernt nur Felder, die es selbst gesetzt hat (gemerkt inlast-applied-configuration). Ein per Patch hinzugefügteslifecycleüberlebt jedes spätereapply, undkubectl diffzeigt 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.
minReadySecondsundprogressDeadlineSecondsim 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.