Tag 20: Wettkampf – der kaputte Cluster
Ziel: Du findest und behebst in acht Runden eingebaute Fehler quer durch das Buch – gegen die Uhr, mit Nachweis vorher und nachher. · Dauer: ca. 120 min · Voraussetzung: Tag 0–19
Briefing
- Du baust in
tag20die Appnotes:web(nginx) leitet/api/annotes-apiweiter,notes-apispeichert inpostgres(local-path-Volume). Davor Traefik mit dem Hostnotes.tag20.lab. - Acht Runden, alle Schichten: Quota, Service, Admission, Netz, Ingress, Storage, Webhook, Knoten. Die Runden bauen aufeinander auf: der Reihe nach spielen.
- Werkzeuge: alles aus dem Buch –
get,describe,events,logs, k9s,get --raw, Knoten per SSH. - Jede Runde endet mit der Messung: kaputt vorher, heil nachher.
curl ──> Traefik (Host notes.tag20.lab) ──> web ──/api/──> notes-api ──> postgres
(PVC)
Runde Symptom Zeitziel
1 Neue Version von notes-api kommt nicht an 4 min
2 503 auf alles 3 min
3 Rollout hängt, Pod startet nicht 5 min
4 notes-api startet nach Neustart nicht 5 min
5 404 page not found 3 min
6 Anfragen hängen, postgres Pending 5 min
7 web lässt sich nicht neu ausrollen 4 min
8 Wartung: Drain hängt 4 min
Spielregeln
- Pro Runde führt der Schiedsrichter die
Schiedsrichter-Befehle auf
cp1aus – ein Kollege oder du selbst, ohne hinzusehen: Block kopieren, in ein zweites Terminal einfügen, Fenster schließen. Dann die Uhr starten. - Ursache finden, beheben, mit der Messung beweisen. Erst dann Uhr stoppen.
- Repariere die Ursache, nicht das Symptom: Wer den Namespace neu baut, Policies, Quota oder PDB löscht, statt sie zu korrigieren, Kyverno abschaltet oder die Datenbank neu anlegt, bekommt null Punkte. Die Notiz „Wettkampf“ muss am Ende noch in der Datenbank stehen.
- Den Hinweis erst lesen, wenn das Zeitziel abgelaufen ist.
- Pod-Namen und Hashes in den Ausgaben sind bei dir andere; Befehle
arbeiten deshalb mit
-l app=…oderdeploy/…. - Das Ziel jeder Runde ist derselbe saubere Endzustand. Der Befehl dafür heißt im Folgenden kurz Messung:
# auf cp1
U='--resolve notes.tag20.lab:80:172.16.0.126 http://notes.tag20.lab'
curl -s -m 10 $U/api/notes; echo
kubectl -n tag20 get deploy,sts -o custom-columns=NAME:.metadata.name,\
READY:.status.readyReplicas,AKTUELL:.status.updatedReplicasHeil heißt: die Notiz Wettkampf als JSON, alle Pods
bereit und auf dem neuesten Stand (READY gleich
AKTUELL: 2 für notes-api und web,
1 für postgres). Direkt nach einem Rollout antwortet nginx
ein paar Sekunden lang mit 502 – deshalb steht in den Lösungen vor der
Messung ein kurzes sleep.
Spielfeld
Die App ist dieselbe wie im Linkerd- und im CKAD-Buch, hier mit Volume aus local-path (Tag 10) und Ingress über Traefik (Tag 9). Die Werte sind Laborwerte.
# auf cp1
mkdir -p ~/debug/tag20 && cd ~/debug/tag20
kubectl create namespace tag20
kubectl -n tag20 create secret generic notes-db \
--from-literal=password=lab-db-123 \
--from-literal=url='postgres://notes:lab-db-123@postgres:5432/notes?sslmode=disable'
kubectl -n tag20 create secret generic notes-api-key --from-literal=key=lab-key-123
cat > postgres.yaml <<'EOF'
apiVersion: apps/v1
kind: StatefulSet
metadata: {name: postgres, namespace: tag20}
spec:
serviceName: postgres
replicas: 1
selector: {matchLabels: {app: postgres}}
template:
metadata: {labels: {app: postgres}}
spec:
containers:
- name: postgres
image: docker.io/library/postgres:18.7-alpine
env:
- {name: POSTGRES_USER, value: notes}
- {name: POSTGRES_DB, value: notes}
- name: POSTGRES_PASSWORD
valueFrom: {secretKeyRef: {name: notes-db, key: password}}
- {name: PGDATA, value: /var/lib/postgresql/data/pgdata}
ports: [{containerPort: 5432, name: postgres}]
readinessProbe:
exec: {command: [pg_isready, -U, notes, -d, notes]}
volumeMounts: [{name: data, mountPath: /var/lib/postgresql/data}]
volumeClaimTemplates:
- metadata: {name: data}
spec:
storageClassName: local-path
accessModes: [ReadWriteOnce]
resources: {requests: {storage: 1Gi}}
---
apiVersion: v1
kind: Service
metadata: {name: postgres, namespace: tag20}
spec:
selector: {app: postgres}
ports: [{port: 5432, targetPort: postgres, name: postgres}]
EOF
cat > notes-api.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: notes-api, namespace: tag20}
spec:
replicas: 2
selector: {matchLabels: {app: notes-api}}
template:
metadata: {labels: {app: notes-api}}
spec:
initContainers:
- name: migrate
image: ghcr.io/thomaszachmann/notes-api:0.7.1
args: [migrate]
env:
- name: NOTES_DB_URL
valueFrom: {secretKeyRef: {name: notes-db, key: url}}
containers:
- name: notes-api
image: ghcr.io/thomaszachmann/notes-api:0.7.1
ports: [{containerPort: 8080, name: http}]
env:
- name: NOTES_DB_URL
valueFrom: {secretKeyRef: {name: notes-db, key: url}}
- name: NOTES_API_KEY
valueFrom: {secretKeyRef: {name: notes-api-key, key: key}}
readinessProbe:
httpGet: {path: /healthz, port: http}
---
apiVersion: v1
kind: Service
metadata: {name: notes-api, namespace: tag20}
spec:
selector: {app: notes-api}
ports: [{port: 80, targetPort: http, name: http}]
EOF
cat > web.yaml <<'EOF'
apiVersion: v1
kind: ConfigMap
metadata: {name: web-conf, namespace: tag20}
data:
default.conf: |
server {
listen 8080;
location = / { default_type text/plain; return 200 "notes web\n"; }
location /api/ {
proxy_set_header X-API-Key lab-key-123;
proxy_pass http://notes-api.tag20.svc.cluster.local/;
}
}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: web, namespace: tag20}
spec:
replicas: 2
selector: {matchLabels: {app: web}}
template:
metadata: {labels: {app: web}}
spec:
containers:
- name: web
image: docker.io/nginxinc/nginx-unprivileged:1.31.7-alpine
ports: [{containerPort: 8080, name: http}]
readinessProbe:
httpGet: {path: /, port: http}
volumeMounts: [{name: conf, mountPath: /etc/nginx/conf.d}]
volumes: [{name: conf, configMap: {name: web-conf}}]
---
apiVersion: v1
kind: Service
metadata: {name: web, namespace: tag20}
spec:
selector: {app: web}
ports: [{port: 80, targetPort: http, name: http}]
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata: {name: notes, namespace: tag20}
spec:
ingressClassName: traefik
rules:
- host: notes.tag20.lab
http:
paths:
- path: /
pathType: Prefix
backend: {service: {name: web, port: {number: 80}}}
EOF
kubectl apply -f postgres.yaml -f notes-api.yaml -f web.yaml
kubectl -n tag20 rollout status statefulset/postgres --timeout=180s
kubectl -n tag20 rollout status deploy/notes-api --timeout=180s | tail -1
kubectl -n tag20 rollout status deploy/web --timeout=180sErwartet (gekürzt):
namespace/tag20 created
secret/notes-db created
secret/notes-api-key created
statefulset.apps/postgres created
...
ingress.networking.k8s.io/notes created
Waiting for 1 pods to be ready...
partitioned roll out complete: 1 new pods have been updated...
deployment "notes-api" successfully rolled out
deployment "web" successfully rolled out
Eine Notiz anlegen, dann die erste Messung:
# auf cp1
U='--resolve notes.tag20.lab:80:172.16.0.126 http://notes.tag20.lab'
curl -s -m 10 $U/api/notes -d '{"text":"Wettkampf"}'; echo
curl -s -m 10 $U/api/notes; echo
kubectl -n tag20 get deploy,sts -o custom-columns=NAME:.metadata.name,\
READY:.status.readyReplicas,AKTUELL:.status.updatedReplicasErwartet:
{"id":"44bc0f3b-35e8-4563-b6d2-b2d36c6f921b","text":"Wettkampf"}
[{"id":"44bc0f3b-35e8-4563-b6d2-b2d36c6f921b","text":"Wettkampf"}]
NAME READY AKTUELL
notes-api 2 2
web 2 2
postgres 1 1
Das ist das gesunde Spielfeld. Die Manifeste in
~/debug/tag20 sind der Sollzustand – der Vergleich mit dem
Live-Objekt ist erlaubt und oft der schnellste Weg.
Runde 1: Die neue Version
Lage: Das Team hat notes-api neu
ausgerollt. Die Pipeline wartet seit Minuten auf
rollout status.
Schiedsrichter-Befehle:
# auf cp1
kubectl -n tag20 create quota grenze --hard=pods=5
kubectl -n tag20 rollout restart deploy/notes-apiZeitziel: 4 min
Hinweis: Der neue Pod fehlt nicht wegen des Pods – frag das ReplicaSet.
Lösung Runde 1
# auf cp1
sleep 20
kubectl -n tag20 rollout status deploy/notes-api --timeout=5s
kubectl -n tag20 get rs -l app=notes-api
kubectl -n tag20 events --types=Warning | grep FailedCreate | tail -1 | cut -c1-260 \
| fold -w 86
kubectl -n tag20 describe quota grenze | tail -3Erwartet (Zeile umbrochen):
Waiting for deployment "notes-api" rollout to finish: 0 out of 2 new replicas have been
updated...
error: timed out waiting for the condition
NAME DESIRED CURRENT READY AGE
notes-api-6c5f9d64bc 1 0 0 25s
notes-api-6d87674cb5 2 2 2 73s
6s (x4 over 24s) Warning FailedCreate ReplicaSet/notes-api-6c5f9d64bc (combin
ed from similar events): Error creating: pods "notes-api-6c5f9d64bc-8bxpv" is forbidde
n: exceeded quota: grenze, requested: pods=1, used: pods=5, limited: pods=5
Resource Used Hard
-------- ---- ----
pods 5 5
Die Quota erlaubt genau so viele Pods, wie laufen. Ein Rollout
braucht kurzzeitig einen Pod mehr (maxSurge), und den lehnt
die Quota am ReplicaSet ab (Tag 3). Die Quota bleibt – nur mit Luft für
Rollouts:
# auf cp1
kubectl -n tag20 patch resourcequota grenze -p '{"spec":{"hard":{"pods":"8"}}}'
kubectl -n tag20 rollout status deploy/notes-api --timeout=120s | tail -1Erwartet:
resourcequota/grenze patched
deployment "notes-api" successfully rolled out
Messung (Befehle aus den Spielregeln):
# auf cp1
sleep 5
curl -s -m 10 $U/api/notes; echo
kubectl -n tag20 get deploy,sts -o custom-columns=NAME:.metadata.name,\
READY:.status.readyReplicas,AKTUELL:.status.updatedReplicasErwartet:
[{"id":"44bc0f3b-35e8-4563-b6d2-b2d36c6f921b","text":"Wettkampf"}]
NAME READY AKTUELL
notes-api 2 2
web 2 2
postgres 1 1
Fortschritt speichern? Kostenlos registrieren
Runde 2: 503
Lage: „Ich habe nur die Labels vereinheitlicht.“ Seitdem antwortet die Seite mit 503 – auch die Startseite.
Schiedsrichter-Befehle:
# auf cp1
kubectl -n tag20 patch service web -p '{"spec":{"selector":{"app":"wbe"}}}'Zeitziel: 3 min
Hinweis: Wer liefert die 503 – nginx oder Traefik? Und wohin will Traefik?
Lösung Runde 2
# auf cp1
sleep 10
curl -s -m 10 -w ' %{http_code}\n' $U/
kubectl -n tag20 get endpointslices -l kubernetes.io/service-name=web
kubectl -n tag20 get svc web -o jsonpath='{.spec.selector}{"\n"}'
kubectl -n tag20 get pods -l app=web --no-headers | wc -lErwartet:
no available server
503
NAME ADDRESSTYPE PORTS ENDPOINTS AGE
web-hbj62 IPv4 <unset> <unset> 113s
{"app":"wbe"}
2
no available server ist die Antwort von Traefik selbst:
Der Service hat keine Endpoints, weil sein Selektor auf keinen Pod passt
(Tag 7). Zurück auf den Sollwert aus web.yaml:
# auf cp1
kubectl -n tag20 patch service web -p '{"spec":{"selector":{"app":"web"}}}'
sleep 3
curl -s -m 10 $U/api/notes; echo
kubectl -n tag20 get deploy,sts -o custom-columns=NAME:.metadata.name,\
READY:.status.readyReplicas,AKTUELL:.status.updatedReplicasErwartet:
service/web patched
[{"id":"44bc0f3b-35e8-4563-b6d2-b2d36c6f921b","text":"Wettkampf"}]
NAME READY AKTUELL
notes-api 2 2
web 2 2
postgres 1 1
Fortschritt speichern? Kostenlos registrieren
Runde 3: Die vereinheitlichte Policy
Lage: Das Plattform-Team hat eine Kyverno-Policy
„zur Vereinheitlichung der API-Keys“ ausgerollt. Danach wurde
notes-api neu gestartet – und hängt.
Schiedsrichter-Befehle:
# auf cp1
cat > /tmp/mpol.yaml <<'EOF'
apiVersion: policies.kyverno.io/v1
kind: MutatingPolicy
metadata: {name: api-key-vereinheitlichen}
spec:
matchConstraints:
namespaceSelector:
matchLabels: {kubernetes.io/metadata.name: tag20}
objectSelector:
matchLabels: {app: notes-api}
resourceRules:
- apiGroups: [""]
apiVersions: [v1]
operations: [CREATE]
resources: [pods]
mutations:
- patchType: JSONPatch
jsonPatch:
expression: >-
[JSONPatch{op: "replace",
path: "/spec/containers/0/env/1/valueFrom/secretKeyRef/key",
value: "api-key"}]
EOF
kubectl apply -f /tmp/mpol.yaml && rm /tmp/mpol.yaml
sleep 5
kubectl -n tag20 rollout restart deploy/notes-apiZeitziel: 5 min
Hinweis: Vergleiche das Pod-Template im Deployment mit dem Pod, der hängt.
Lösung Runde 3
# auf cp1
sleep 30
kubectl -n tag20 get pods -l app=notes-api
kubectl -n tag20 events --types=Warning | grep -m1 "couldn't find key" \
| grep -o 'Error:.*'
J='{.spec.template.spec.containers[0].env[1].valueFrom.secretKeyRef}{"\n"}'
kubectl -n tag20 get deploy notes-api -o jsonpath="$J"
P=$(kubectl -n tag20 get pods -l app=notes-api --no-headers | grep -v Running \
| awk '{print $1}')
kubectl -n tag20 get pod $P \
-o jsonpath='{.spec.containers[0].env[1].valueFrom.secretKeyRef}{"\n"}'
kubectl get mpolErwartet:
NAME READY STATUS RESTARTS AGE
notes-api-67f8dc996-6m9fz 0/1 CreateContainerConfigError 0 30s
notes-api-6c5f9d64bc-5p7k7 1/1 Running 0 64s
notes-api-6c5f9d64bc-ffm7k 1/1 Running 0 60s
Error: couldn't find key api-key in Secret tag20/notes-api-key
{"key":"key","name":"notes-api-key"}
{"key":"api-key","name":"notes-api-key"}
NAME AGE READY
api-key-vereinheitlichen 37s true
CreateContainerConfigError mit fehlendem Schlüssel (Tag
4) – aber das Deployment verlangt den richtigen Schlüssel
key. Den falschen hat der Pod erst bei der Anlage bekommen:
Mutation durch Kyverno (Tag 12). Das Manifest sieht deshalb sauber aus,
nur das Live-Objekt nicht. Die Policy ist die Ursache; sie verlangt
einen Schlüssel, den das Secret nicht hat. Weg damit (oder mit dem
Plattform-Team korrigieren), dann den hängenden Pod neu erzeugen
lassen:
# auf cp1
kubectl delete mpol api-key-vereinheitlichen
kubectl -n tag20 delete pod $P
kubectl -n tag20 rollout status deploy/notes-api --timeout=120s | tail -1
sleep 5
curl -s -m 10 $U/api/notes; echo
kubectl -n tag20 get deploy,sts -o custom-columns=NAME:.metadata.name,\
READY:.status.readyReplicas,AKTUELL:.status.updatedReplicasErwartet:
mutatingpolicy.policies.kyverno.io "api-key-vereinheitlichen" deleted
pod "notes-api-67f8dc996-6m9fz" deleted from tag20 namespace
deployment "notes-api" successfully rolled out
[{"id":"44bc0f3b-35e8-4563-b6d2-b2d36c6f921b","text":"Wettkampf"}]
NAME READY AKTUELL
notes-api 2 2
web 2 2
postgres 1 1
Fortschritt speichern? Kostenlos registrieren
Runde 4: Nur die Datenbank
Lage: Die Security hat notes-api „auf
das Nötigste“ eingeschränkt. Läuft doch. Erst nach dem nächsten Neustart
ruft jemand an.
Schiedsrichter-Befehle:
# auf cp1
cat > /tmp/np.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: {name: nur-datenbank, namespace: tag20}
spec:
podSelector: {matchLabels: {app: notes-api}}
policyTypes: [Egress]
egress:
- to:
- podSelector: {matchLabels: {app: postgres}}
ports: [{port: 5432, protocol: TCP}]
EOF
kubectl apply -f /tmp/np.yaml && rm /tmp/np.yaml
kubectl -n tag20 rollout restart deploy/notes-apiZeitziel: 5 min
Hinweis: Lies das Log des Init-Containers – welche Adresse will er erreichen?
Lösung Runde 4
# auf cp1
sleep 40
kubectl -n tag20 get pods -l app=notes-api
P=$(kubectl -n tag20 get pods -l app=notes-api --no-headers | grep Init \
| awk '{print $1}')
kubectl -n tag20 logs $P -c migrate --tail 1 | cut -c1-260 | fold -w 86
kubectl -n tag20 get networkpolicyErwartet:
NAME READY STATUS RESTARTS AGE
notes-api-6464cd5898-gl95n 0/1 Init:Error 2 (32s ago) 40s
notes-api-67f8dc996-7vfx7 1/1 Running 0 50s
notes-api-67f8dc996-ljg6g 1/1 Running 0 54s
time=2026-11-20T14:13:35.067Z level=ERROR msg="database unreachable" source=env err="f
ailed to connect to `user=notes database=notes`: hostname resolving error: lookup post
gres on 10.43.0.10:53: dial udp 10.43.0.10:53: i/o timeout"
NAME POD-SELECTOR AGE
nur-datenbank app=notes-api 42s
Die Datenbank ist erlaubt, aber nicht der Weg zu ihrem
Namen: 10.43.0.10:53 ist CoreDNS (Tag 8).
Die alten Pods liefen weiter, weil ihre Verbindungen schon standen –
erst ein Neustart muss neu auflösen. Die Policy bleibt, sie bekommt nur
DNS dazu:
# auf cp1
cat > np-fix.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: {name: nur-datenbank, namespace: tag20}
spec:
podSelector: {matchLabels: {app: notes-api}}
policyTypes: [Egress]
egress:
- to:
- podSelector: {matchLabels: {app: postgres}}
ports: [{port: 5432, protocol: TCP}]
- to:
- namespaceSelector:
matchLabels: {kubernetes.io/metadata.name: kube-system}
podSelector: {matchLabels: {k8s-app: kube-dns}}
ports: [{port: 53, protocol: UDP}, {port: 53, protocol: TCP}]
EOF
kubectl apply -f np-fix.yaml
kubectl -n tag20 rollout status deploy/notes-api --timeout=180s | tail -1
sleep 5
curl -s -m 10 $U/api/notes; echo
kubectl -n tag20 get deploy,sts -o custom-columns=NAME:.metadata.name,\
READY:.status.readyReplicas,AKTUELL:.status.updatedReplicasErwartet:
networkpolicy.networking.k8s.io/nur-datenbank configured
deployment "notes-api" successfully rolled out
[{"id":"44bc0f3b-35e8-4563-b6d2-b2d36c6f921b","text":"Wettkampf"}]
NAME READY AKTUELL
notes-api 2 2
web 2 2
postgres 1 1
Der Init-Container steckt im Backoff (Tag 5); bis er es erneut versucht, vergeht bis zu einer Minute.
Fortschritt speichern? Kostenlos registrieren
Runde 5: 404
Lage: „Wir ziehen bald auf ingress-nginx um, ich habe das Ingress schon mal umgestellt.“
Schiedsrichter-Befehle:
# auf cp1
kubectl -n tag20 patch ingress notes --type=merge \
-p '{"spec":{"ingressClassName":"nginx"}}'Zeitziel: 3 min
Hinweis: Welche IngressClasses gibt es im Cluster?
Lösung Runde 5
# auf cp1
sleep 5
curl -s -m 10 -w ' %{http_code}\n' $U/api/notes
kubectl -n tag20 get ingress notes
kubectl get ingressclassErwartet:
404 page not found
404
NAME CLASS HOSTS ADDRESS PORTS AGE
notes nginx notes.tag20.lab 80 4m6s
NAME CONTROLLER PARAMETERS AGE
traefik (default) traefik.io/ingress-controller <none> 7h41m
404 page not found ist Traefiks Antwort für „keine
Route“: Ein Ingress mit fremder Klasse ignoriert er schweigend, ohne
Event (Tag 9). Einen Controller für nginx gibt es
nicht:
# auf cp1
kubectl -n tag20 patch ingress notes --type=merge \
-p '{"spec":{"ingressClassName":"traefik"}}'
sleep 5
curl -s -m 10 $U/api/notes; echo
kubectl -n tag20 get deploy,sts -o custom-columns=NAME:.metadata.name,\
READY:.status.readyReplicas,AKTUELL:.status.updatedReplicasErwartet:
ingress.networking.k8s.io/notes patched
[{"id":"44bc0f3b-35e8-4563-b6d2-b2d36c6f921b","text":"Wettkampf"}]
NAME READY AKTUELL
notes-api 2 2
web 2 2
postgres 1 1
Fortschritt speichern? Kostenlos registrieren
Runde 6: Die Datenbank zieht um
Lage: „Postgres soll auf den Knoten mit der
schnelleren Platte.“ Seitdem hängen Anfragen an notes bis
zum Timeout. Der Schiedsrichter nimmt einen Worker, auf dem Postgres
gerade nicht läuft.
Schiedsrichter-Befehle:
# auf cp1
N=$(kubectl -n tag20 get pod postgres-0 -o jsonpath='{.spec.nodeName}')
A=$(kubectl get nodes -o name | cut -d/ -f2 | grep -v -x -e cp1 -e $N | head -1)
kubectl -n tag20 patch statefulset postgres \
-p '{"spec":{"template":{"spec":{"nodeSelector":{"kubernetes.io/hostname":"'$A'"}}}}}'
kubectl -n tag20 delete pod postgres-0Zeitziel: 5 min
Hinweis: Wo liegt das Volume? Und ersetzt ein StatefulSet einen Pod, der nie startet, von selbst?
Lösung Runde 6
# auf cp1
sleep 20
kubectl -n tag20 get pod postgres-0
kubectl -n tag20 events --for pod/postgres-0 | tail -1 | cut -c1-260 | fold -w 86
kubectl -n tag20 get pod postgres-0 -o jsonpath='{.spec.nodeSelector}{"\n"}'
PV=$(kubectl -n tag20 get pvc data-postgres-0 -o jsonpath='{.spec.volumeName}')
kubectl get pv $PV -o jsonpath='{.spec.nodeAffinity.required}{"\n"}' | fold -w 86Erwartet:
NAME READY STATUS RESTARTS AGE
postgres-0 0/1 Pending 0 20s
20s (x2 over 20s) Warning FailedScheduling Pod/postgres-0 0/3 nodes are av
ailable: 1 node(s) didn't match PersistentVolume's node affinity, 2 node(s) didn't mat
ch Pod's node affinity/selector. preemption: 0/3 nodes are available: 3 Preemption is
no
{"kubernetes.io/hostname":"worker2"}
{"nodeSelectorTerms":[{"matchExpressions":[{"key":"kubernetes.io/hostname","operator":
"In","values":["worker1"]}]}]}
Das local-path-Volume liegt auf einem bestimmten Knoten und zieht
nicht mit (Tag 10); der nodeSelector zeigt auf einen
anderen. notes-api wartet auf die Datenbank, nginx gibt
nach 60 Sekunden mit 504 auf. Erst den Selektor entfernen – und dann den
hängenden Pod löschen: Ein StatefulSet ersetzt einen Pod mit altem
Template nicht, solange der nie bereit war (die Kubernetes-Doku nennt
das „forced rollback“).
# auf cp1
kubectl -n tag20 patch statefulset postgres --type=json \
-p '[{"op":"remove","path":"/spec/template/spec/nodeSelector"}]'
kubectl -n tag20 delete pod postgres-0
kubectl -n tag20 rollout status statefulset/postgres --timeout=120s | tail -1
sleep 15
curl -s -m 10 $U/api/notes; echo
kubectl -n tag20 get deploy,sts -o custom-columns=NAME:.metadata.name,\
READY:.status.readyReplicas,AKTUELL:.status.updatedReplicasErwartet:
statefulset.apps/postgres patched
pod "postgres-0" deleted from tag20 namespace
partitioned roll out complete: 1 new pods have been updated...
[{"id":"44bc0f3b-35e8-4563-b6d2-b2d36c6f921b","text":"Wettkampf"}]
NAME READY AKTUELL
notes-api 2 2
web 2 2
postgres 1 1
Die Notiz ist noch da – die Daten lagen die ganze Zeit sicher auf dem alten Knoten.
Fortschritt speichern? Kostenlos registrieren
Runde 7: Der Prüfer
Lage: Ein Hersteller-Tool wurde „testweise“
installiert und wieder entfernt. Jetzt soll web eine neue
Konfiguration bekommen, aber es entsteht kein neuer Pod.
Schiedsrichter-Befehle:
# auf cp1
cat > /tmp/wh.yaml <<'EOF'
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingWebhookConfiguration
metadata: {name: tag20-pruefer}
webhooks:
- name: pruefer.tag20.lab
admissionReviewVersions: [v1]
sideEffects: None
failurePolicy: Fail
namespaceSelector:
matchLabels: {kubernetes.io/metadata.name: tag20}
rules:
- apiGroups: [""]
apiVersions: [v1]
operations: [CREATE]
resources: [pods]
clientConfig:
service: {name: pruefer, namespace: tag20, path: /validate}
EOF
kubectl apply -f /tmp/wh.yaml && rm /tmp/wh.yaml
kubectl -n tag20 rollout restart deploy/webZeitziel: 4 min
Hinweis: Internal error occurred heißt:
Die Ablehnung kam nicht vom API-Server selbst.
Lösung Runde 7
# auf cp1
sleep 15
kubectl -n tag20 get deploy web
kubectl -n tag20 events --types=Warning | grep -m1 'failed calling webhook' \
| cut -c1-280 | fold -w 86
kubectl get validatingwebhookconfigurations -o name | grep -v kyverno
kubectl -n tag20 get svc prueferErwartet:
NAME READY UP-TO-DATE AVAILABLE AGE
web 2/2 0 2 5m12s
5s (x12 over 15s) Warning FailedCreate ReplicaSet/web-5489c7bf58
Error creating: Internal error occurred: failed calling webhook "pruefer.tag20.lab":
failed to call webhook: Post "https://pruefer.tag20.svc:443/validate?timeout=10s": ser
vice "pruefer" not fou
validatingwebhookconfiguration.admissionregistration.k8s.io/tag20-pruefer
Error from server (NotFound): services "pruefer" not found
Ein Webhook ohne Service, failurePolicy: Fail, gültig
für jeden Pod in tag20 (Tag 16). Das Tool ist weg, seine
Konfiguration nicht – also gehört auch sie weg:
# auf cp1
kubectl delete validatingwebhookconfiguration tag20-pruefer
kubectl -n tag20 rollout status deploy/web --timeout=120s | tail -1
sleep 5
curl -s -m 10 $U/api/notes; echo
kubectl -n tag20 get deploy,sts -o custom-columns=NAME:.metadata.name,\
READY:.status.readyReplicas,AKTUELL:.status.updatedReplicasErwartet:
validatingwebhookconfiguration.admissionregistration.k8s.io "tag20-pruefer" deleted
deployment "web" successfully rolled out
[{"id":"44bc0f3b-35e8-4563-b6d2-b2d36c6f921b","text":"Wettkampf"}]
NAME READY AKTUELL
notes-api 2 2
web 2 2
postgres 1 1
Fortschritt speichern? Kostenlos registrieren
Runde 8: Wartungsfenster
Lage: Ein Worker soll gepatcht werden. Der
Schiedsrichter nimmt den Worker ohne Postgres und startet den Drain mit
40 Sekunden Frist. Danach bist du dran: Der Knoten soll leer werden,
notes dabei erreichbar bleiben, und am Ende ist der Knoten
wieder im Dienst.
Schiedsrichter-Befehle:
# auf cp1
cat > /tmp/pdb.yaml <<'EOF'
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata: {name: notes-pdb, namespace: tag20}
spec:
maxUnavailable: 0
selector:
matchExpressions:
- {key: app, operator: In, values: [web, notes-api]}
EOF
kubectl apply -f /tmp/pdb.yaml && rm /tmp/pdb.yaml
P=$(kubectl -n tag20 get pod postgres-0 -o jsonpath='{.spec.nodeName}')
W=$(kubectl get nodes -o name | cut -d/ -f2 | grep -v -x -e cp1 -e $P | head -1)
echo "Wartung: $W"
kubectl drain $W --ignore-daemonsets --delete-emptydir-data --timeout=40s 2>&1 \
| tail -1 | cut -c1-120Zeitziel: 4 min
Hinweis: ALLOWED DISRUPTIONS.
Lösung Runde 8
W ist der Knoten, den der Schiedsrichter genannt hat –
hier mit derselben Regel ermittelt:
# auf cp1
P=$(kubectl -n tag20 get pod postgres-0 -o jsonpath='{.spec.nodeName}')
W=$(kubectl get nodes -o name | cut -d/ -f2 | grep -v -x -e cp1 -e $P | head -1)
echo $W
kubectl get nodes
kubectl -n tag20 get pdb
kubectl -n tag20 get pods -l 'app in (web,notes-api)' -o wide | awk '{print $1, $7}'Erwartet:
worker2
NAME STATUS ROLES AGE VERSION
cp1 Ready control-plane,etcd 7h45m v1.37.2+rke2r1
worker1 Ready <none> 7h42m v1.37.2+rke2r1
worker2 Ready,SchedulingDisabled <none> 7h41m v1.37.2+rke2r1
NAME MIN AVAILABLE MAX UNAVAILABLE ALLOWED DISRUPTIONS AGE
notes-pdb N/A 0 0 42s
NAME NODE
notes-api-6464cd5898-gl95n worker1
notes-api-6464cd5898-sjj98 worker2
web-5489c7bf58-9gncl worker2
web-5489c7bf58-vjtlf worker1
Ein PDB mit maxUnavailable: 0 verbietet jede freiwillige
Eviction – der Drain wartet für immer (Tag 14). Bei zwei Replikas darf
einer gehen:
# auf cp1
kubectl -n tag20 patch pdb notes-pdb --type=merge -p '{"spec":{"maxUnavailable":1}}'
kubectl drain $W --ignore-daemonsets --delete-emptydir-data --timeout=120s \
2>&1 | tail -1
kubectl uncordon $W
kubectl -n tag20 rollout status deploy/notes-api --timeout=120s | tail -1
kubectl -n tag20 rollout status deploy/web --timeout=120s | tail -1
sleep 5
curl -s -m 10 $U/api/notes; echo
kubectl -n tag20 get deploy,sts -o custom-columns=NAME:.metadata.name,\
READY:.status.readyReplicas,AKTUELL:.status.updatedReplicas
kubectl get nodesErwartet:
poddisruptionbudget.policy/notes-pdb patched
node/worker2 drained
node/worker2 uncordoned
deployment "notes-api" successfully rolled out
deployment "web" successfully rolled out
[{"id":"44bc0f3b-35e8-4563-b6d2-b2d36c6f921b","text":"Wettkampf"}]
NAME READY AKTUELL
notes-api 2 2
web 2 2
postgres 1 1
NAME STATUS ROLES AGE VERSION
cp1 Ready control-plane,etcd 7h45m v1.37.2+rke2r1
worker1 Ready <none> 7h42m v1.37.2+rke2r1
worker2 Ready <none> 7h41m v1.37.2+rke2r1
Fortschritt speichern? Kostenlos registrieren
Wertung
| Runde | Fehler | Zeitziel | Punkte |
|---|---|---|---|
| 1 | Quota ohne Luft für maxSurge |
4 min | 2 |
| 2 | Service-Selektor wbe |
3 min | 2 |
| 3 | MutatingPolicy setzt falschen Secret-Schlüssel | 5 min | 3 |
| 4 | Egress-Policy ohne DNS | 5 min | 2 |
| 5 | ingressClassName: nginx |
3 min | 1 |
| 6 | nodeSelector gegen local-path-Volume, Pod hängt |
5 min | 3 |
| 7 | verwaister Webhook mit failurePolicy: Fail |
4 min | 2 |
| 8 | PDB maxUnavailable: 0, Knoten nicht wieder
freigegeben |
4 min | 3 |
Volle Punkte nur innerhalb des Zeitziels, ohne Hinweis
und mit Messung; sonst die Hälfte (abrunden). Null
Punkte für Symptom-Fixes: Quota oder PDB löschen, Policy statt DNS-Regel
entfernen, Kyverno herunterfahren, PVC oder Namespace neu anlegen. In
Runde 8 gibt es einen Punkt Abzug, wenn der Knoten am Ende noch
SchedulingDisabled ist. Gesamtzeitziel: 33 min, Maximum: 18
Punkte.
| Punkte | Einschätzung |
|---|---|
| 15–18 | bereit für die Abschlussprüfung (Anhang B) |
| 10–14 | gut; die Tage der verpassten Runden wiederholen |
| 0–9 | Tag 3, 7, 8, 10, 12 und 14 noch einmal durcharbeiten |
Challenge
Bonusrunde ohne Punkte: Ein Kollege hat für notes ein
Helm-Chart info angefangen, die Pipeline wurde mitten im
Upgrade abgebrochen. Bring den Release wieder in einen Zustand, in dem
helm upgrade funktioniert – ohne die Release-Secrets
anzufassen.
Schiedsrichter-Befehle:
# auf cp1
cd ~/debug/tag20
helm create info >/dev/null
helm install info ./info -n tag20 --wait --timeout 2m | grep STATUS
helm upgrade info ./info -n tag20 --set image.tag=gibtsnicht --wait --timeout 5m &
sleep 5
kill -9 %1Hinweis: Tag 17, Drill 3.
Lösung
# auf cp1
helm upgrade info ./info -n tag20 2>&1 | tail -1
helm -n tag20 history info -o json | jq -r '.[] | "\(.revision) \(.status)"'
helm -n tag20 rollback info 1 2>&1 | tail -1
helm upgrade info ./info -n tag20 --wait | grep -E 'STATUS|REVISION'Erwartet:
Error: UPGRADE FAILED: another operation (install/upgrade/rollback) is in progress
1 deployed
2 pending-upgrade
Rollback was a success! Happy Helming!
STATUS: deployed
REVISION: 4
pending-upgrade blockiert jedes weitere Upgrade;
rollback auf die letzte gute Revision löst die Sperre.
Fortschritt speichern? Kostenlos registrieren
Aufräumen
# auf cp1
helm uninstall info -n tag20
kubectl delete namespace tag20
kubectl get pv --no-headers | wc -lErwartet:
release "info" uninstalled
namespace "tag20" deleted
No resources found
0
Mit dem Namespace verschwindet der PVC, und local-path löscht das
Volume (reclaimPolicy: Delete).
Kontrollpunkt
# auf cp1
kubectl get nodesErwartet: drei Knoten Ready, keiner
SchedulingDisabled.
# auf cp1
kubectl get mpol,vpol --no-headers 2>&1; kubectl get validatingwebhookconfigurations \
-o name | grep -c -v kyvernoErwartet: No resources found und
0 – keine Reste aus Runde 3 und 7.
Interview-Notiz
- Ein Rollout hängt ohne Fehler am Pod – wo schaust du? Am
ReplicaSet:
FailedCreatedurch Quota, Admission-Webhook oder Pod Security steht dort, nicht am Deployment. - Das Manifest ist richtig, der Pod trotzdem falsch?
Mutierende Admission (Kyverno, Webhooks): Live-Objekt mit dem Manifest
vergleichen,
kubectl get mpolbzw.mutatingwebhookconfigurations. - Warum startet ein StatefulSet-Pod nach dem Fix nicht neu? Ein nie bereiter Pod mit altem Template wird nicht automatisch ersetzt – löschen, dann greift das neue Template.
Enterprise-Notiz
- Game Days wie diesen regelmäßig mit dem Bereitschaftsteam spielen; aus den Lösungen werden Runbooks.
- Quotas immer mit Reserve für
maxSurgeplanen und mit Alarm aufFailedCreate. - Mutierende Policies nur mit Review und Testlauf
(
kyverno test, Tag 12) ausrollen; die Policy-Reports beobachten. - Jedes Tool, das Webhooks installiert, gehört in eine Inventarliste mit Besitzer; verwaiste Webhook-Konfigurationen per Policy oder Alarm finden.
- PDBs gehören in die Code-Review:
maxUnavailable: 0oderminAvailablegleich der Replikazahl blockiert jede Wartung.