Zum Inhalt springen
Trainingslager IT-Trainingslager

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 tag20 die App notes: web (nginx) leitet /api/ an notes-api weiter, notes-api speichert in postgres (local-path-Volume). Davor Traefik mit dem Host notes.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 cp1 aus – 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=… oder deploy/….
  • 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.updatedReplicas

Heil 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=180s

Erwartet (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.updatedReplicas

Erwartet:

{"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-api

Zeitziel: 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 -3

Erwartet (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 -1

Erwartet:

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.updatedReplicas

Erwartet:

[{"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 -l

Erwartet:

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.updatedReplicas

Erwartet:

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-api

Zeitziel: 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 mpol

Erwartet:

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.updatedReplicas

Erwartet:

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-api

Zeitziel: 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 networkpolicy

Erwartet:

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.updatedReplicas

Erwartet:

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 ingressclass

Erwartet:

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.updatedReplicas

Erwartet:

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-0

Zeitziel: 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 86

Erwartet:

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.updatedReplicas

Erwartet:

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/web

Zeitziel: 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 pruefer

Erwartet:

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.updatedReplicas

Erwartet:

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-120

Zeitziel: 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 nodes

Erwartet:

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 %1

Hinweis: 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 -l

Erwartet:

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 nodes

Erwartet: drei Knoten Ready, keiner SchedulingDisabled.

# auf cp1
kubectl get mpol,vpol --no-headers 2>&1; kubectl get validatingwebhookconfigurations \
  -o name | grep -c -v kyverno

Erwartet: 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: FailedCreate durch 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 mpol bzw. 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 maxSurge planen und mit Alarm auf FailedCreate.
  • 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: 0 oder minAvailable gleich der Replikazahl blockiert jede Wartung.