Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 15: Wettkampf – Desaster-Drills

Ziel: Acht Störungen aus allen Trainingstagen unter Zeitdruck eingrenzen, mitigieren, dauerhaft beheben und dokumentieren · Dauer: ca. 240 min · Voraussetzung: Tag 1–14

Briefing

  • Pro Drill: Störung auslösen (besser: von jemandem auslösen lassen), Stoppuhr starten, Lösung nicht lesen. Stoppuhr stoppt, wenn die Verifikation grün ist.
  • Reihenfolge wie im Incident (Tag 11): Impact messen, mitigieren, Ursache belegen, dauerhaft beheben, eine Zeile Lessons ins Runbook.
  • Jede Hypothese bekommt einen Befehl, der sie widerlegen kann. Kein Raten.
  • Laut denken, auf Englisch. Genau das prüft ein Live-Debugging-Interview (Anhang C).
  • Zeitlimit gerissen: weiterlösen, aber als „nicht geschafft” werten.
 Kunde ─► llm-gateway ─────────► Modellserver ─────────► VM / Kernel
  D6 TLS   D2 Noisy Neighbor      D4 startupProbe         D1 OOM-Kill
           D3 NetworkPolicy       D8 Air-Gap-Upgrade
 Monitoring: D5 Alarmsturm + Blindflug          Security: D7 CVE am Freitag

Drill 1: Modellserver stirbt beim Laden (VM, Tag 1 + 5)

Einmalig vorab auf dem Laptop – Stoppuhr und Punkteliste für alle Drills:

mkdir -p ~/sre-lab/tag15 && cd ~/sre-lab/tag15
cat > uhr.sh <<'EOF'
#!/usr/bin/env bash
# uhr.sh start|stop <drill> – Stoppuhr, Ergebnis landet in score.txt
set -euo pipefail
cd "$(dirname "$0")"
d=${2:?Drill-Nummer}
case ${1:?start|stop} in
  start) date +%s > ".start-$d"; echo "Drill $d läuft seit $(date -u +%H:%M:%S) UTC" ;;
  stop)  s=$(< ".start-$d"); m=$(( ($(date +%s) - s + 59) / 60 ))
         echo "drill$d ${m}min" | tee -a score.txt ;;
  *)     echo "Usage: $0 start|stop <drill>" >&2; exit 2 ;;
esac
EOF
chmod +x uhr.sh

Gelände: llm-vm mit Ollama und Override aus Tag 5 (MemoryMax=6G, OLLAMA_NUM_PARALLEL=2, Kontext 4096), Modell ministral-3:3b.

Szenario: Ein Kunde will „lange Dokumente”. Ein Kollege setzt per Drop-in 32k Kontext – und senkt „zur Sicherheit” gleich das Speicherlimit. Auf der VM:

sudo tee /etc/systemd/system/ollama.service.d/zz-drill.conf >/dev/null <<'EOF'
[Service]
Environment="OLLAMA_CONTEXT_LENGTH=32768"
Environment="OLLAMA_NUM_PARALLEL=1"
MemoryMax=3G
EOF
sudo systemctl daemon-reload && sudo systemctl restart ollama

Auf dem Laptop: ~/sre-lab/tag15/uhr.sh start 1

Zeitlimit: 15 min

Symptome:

Q='{"model":"ministral-3:3b","messages":[{"role":"user","content":"Sag ok."}]}'
curl -s -m 120 http://127.0.0.1:11434/v1/chat/completions -d "$Q" \
  -w '\nHTTP %{http_code}\n'; echo "curl exit=$?"
curl -s http://127.0.0.1:11434/api/version

Erwartet (nicht live getestet, Text je nach Ollama-Version):

{"error":{"message":"model runner has unexpectedly stopped, ...","type":"api_error"}}
HTTP 500
curl exit=0
{"version":"0.40.2"}

Statt HTTP 500 ist auch eine leere Antwort (curl exit 52) möglich, wenn systemd den Dienst schneller beendet, als Ollama antworten kann. /api/version ist trotzdem grün.

Diagnose-Pfad:

systemctl show ollama -p NRestarts -p MemoryMax -p DropInPaths
journalctl -u ollama --since -10min --no-pager -o cat \
  | grep -iE 'oom|killed|memory' | tail -4
CG=/sys/fs/cgroup/system.slice/ollama.service
grep -E '^(max|oom_kill) ' $CG/memory.events
systemctl cat ollama | grep -E '^# /|MemoryMax|CONTEXT|PARALLEL'
python3 ~/sre-lab/tag05/sizing.py 3.85 q4_k_m 26 8 128 32768 1

Erwartet (gekürzt, nicht live getestet; sizing.py live):

NRestarts=2
MemoryMax=3221225472
DropInPaths=/etc/systemd/system/ollama.service.d/override.conf /etc/.../zz-drill.conf
ollama.service: A process of this unit has been killed by the OOM killer.
ollama.service: Failed with result 'oom-kill'.
max 412
oom_kill 2
# /etc/systemd/system/ollama.service.d/zz-drill.conf
MemoryMax=3G
Gewichte     2.2 GiB (q4_k_m)
KV-Cache     3.2 GiB (104 KiB/Token × 32768 × 1)
Summe        5.4 GiB + ~10 % Overhead

Die Kette: Health-Check grün, weil Ollama Modelle erst bei der ersten Anfrage lädt. Der Runner-Prozess reserviert den KV-Cache (anonymer Speicher, ohne Swap nicht zurückholbar) und reißt MemoryMax. Der Kernel tötet ihn, systemd beendet wegen OOMPolicy=stop (Default) den ganzen Dienst, Restart=always startet ihn neu – bis zur nächsten Anfrage. Kennt deine Ollama-Version das cgroup-Limit, lehnt sie stattdessen sofort mit „model requires more system memory” ab. Gleiche Ursache, gleicher Fix.

Lösung:

sudo rm /etc/systemd/system/ollama.service.d/zz-drill.conf
sudo systemctl daemon-reload && sudo systemctl restart ollama
curl -s -m 120 http://127.0.0.1:11434/v1/chat/completions -d "$Q" \
  | jq -r '.choices[0].message.content'

Erwartet (Text variiert):

OK

Braucht der Kunde wirklich 32k: Sizing zuerst (5,4 GiB plus 10–20 % passt nicht in 3 GiB und knapp in 6 GiB), dann größere VM, KV-Cache quantisieren (OLLAMA_KV_CACHE_TYPE=q8_0 mit OLLAMA_FLASH_ATTENTION=1) oder 32k nur für ein eigenes Modell per Modelfile statt global. Alarm dafür (node-exporter aus Tag 8):

increase(node_vmstat_oom_kill{host="llm-vm"}[10m]) > 0

Lessons:

  • Grüner Health-Check, rote Chats: Ein Probe, das kein Modell anfasst, beweist nur, dass der Prozess lebt.
  • KV-Cache wächst linear mit Kontext × Parallelität. Jede Änderung an OLLAMA_CONTEXT_LENGTH oder NUM_PARALLEL ist eine Sizing-Frage (Tag 5).
  • Drop-ins addieren sich, der alphabetisch letzte gewinnt. DropInPaths und systemctl cat zeigen den Übeltäter in Sekunden.

Stoppuhr: ~/sre-lab/tag15/uhr.sh stop 1

Fortschritt speichern? Kostenlos registrieren

Drill 2: Ein Batch-Job verdrängt alle anderen (Tag 4, 7, 11)

Gelände: Laptop mit Docker, Skripte aus ~/sre-lab/tag11, Image llm-gateway:dev. Der Fake-Modellserver hat 4 Slots à 0,5 s, also Kapazität für etwa 8 Anfragen pro Sekunde.

cd ~/sre-lab/tag11
docker network create tag11 2>/dev/null
docker run -d --name fake-llm --network tag11 \
  -v "$PWD/fake_upstream.py:/app.py:ro" python:3.13-alpine python -u /app.py
./gw-start.sh
./load.sh acme 20 2

Erwartet:

gw: rps=5 burst=10 ready=ok
== acme: 20 200
p50=0.50s p95=0.51s

Szenario: Die HPA hat das Gateway auf zwei Replikas skaliert. Danach startet globex seinen Batch – ein höflicher Client, der Retry-After respektiert:

docker run -d --name gw2 --network tag11 -p 8081:8080 \
  -e UPSTREAM_URL=http://fake-llm:11434 \
  -e TENANT_KEYS="acme:lab-key-acme,globex:lab-key-globex" llm-gateway:dev
cat > batch.sh <<'EOF'
#!/usr/bin/env bash
# batch.sh [sekunden] – globex-Batch: 20 Worker je Gateway-Replica (Lab-Key)
end=$((SECONDS + ${1:-120}))
worker() {
  while [ "$SECONDS" -lt "$end" ]; do
    code=$(curl -s -o /dev/null -m 10 -w '%{http_code}' \
      -H 'Authorization: Bearer lab-key-globex' -H 'Content-Type: application/json' \
      -d '{"model":"mistral-fake","messages":[{"role":"user","content":"batch"}]}' \
      "localhost:$1/v1/chat/completions")
    echo "$code"
    case $code in 429|000) sleep 1 ;; esac  # Retry-After bzw. Pause bei Fehler
  done
}
for port in 8080 8081; do
  for _ in $(seq 20); do worker "$port" & done
done > globex-batch.txt
wait
EOF
chmod +x batch.sh
./batch.sh 600 > /dev/null 2>&1 &
~/sre-lab/tag15/uhr.sh start 2

Zeitlimit: 15 min

Symptome:

./load.sh acme 40 2

Erwartet (live getestet, Werte schwanken):

== acme: 35 200 5 503
p50=2.49s p95=2.49s

acme hat nichts geändert, die Latenz ist fünfmal so hoch, jede achte Anfrage scheitert.

Diagnose-Pfad:

for p in 8080 8081; do
  echo "== Replica :$p"; ./impact.sh <(curl -s localhost:$p/metrics)
done
docker ps --filter name=gw --format '{{.Names}} {{.Ports}}'

Erwartet (gekürzt, live getestet):

== Replica :8080
globex  total=746  5xx=74   429=470  err=9.9%
acme    total=40   5xx=5    429=0    err=12.5%
== Replica :8081
globex  total=762  5xx=77   429=479  err=10.1%
gw2 0.0.0.0:8081->8080/tcp
gw 0.0.0.0:8080->8080/tcp

Jede Replica lässt globex 5 req/s durch, zusammen 10. Dazu kommen 4 req/s von acme: 14 gegen eine Kapazität von 8. Die 503 kommen vom Modellserver („server busy”), nicht vom Gateway. In Kubernetes beantwortest du dieselben Fragen per PromQL:

count(up{job="llm-gateway"})
sum by (tenant) (rate(gateway_requests_total{code="200"}[5m]))

Lösung: Mitigation – das effektive Limit von globex senken. Im Lab: Replica weg. In Kubernetes: RATE_LIMIT_RPS auf Ziel ÷ Replikas setzen oder maxReplicas deckeln.

docker rm -f gw2
sleep 3; ./load.sh acme 40 2

Erwartet (live getestet):

gw2
== acme: 40 200
p50=0.51s p95=1.00s

Das p95 bleibt erhöht, solange der Batch läuft (5 + 4 = 9 > 8, wie in Tag 11). Dauerhaft: globales In-flight-Limit vor dem Modellserver (Tag 11, AI-1), Limits pro Mandant und in Tokens statt Requests, Batch-Verkehr in eine eigene Queue mit niedriger Priorität. Aufräumen:

pkill -f batch.sh; docker rm -f gw fake-llm; docker network rm tag11

Lessons:

  • Ein Rate-Limit im Pod-Speicher skaliert mit jeder Replica – die HPA ändert dein SLA.
  • Die Summe aller Mandantenlimits muss unter der Kapazität bleiben, sonst ist „fair” nur Glück.
  • Das erste Symptom eines Noisy Neighbors ist Latenz, nicht Fehler.

Stoppuhr: ~/sre-lab/tag15/uhr.sh stop 2

Fortschritt speichern? Kostenlos registrieren

Drill 3: Compliance-Policy kappt das Gateway (Tag 6, 7)

Gelände: kind sre-lab mit Tag 6 und 7: Gateway (2 Replikas) in llm-system, Modellserver als Service ollama, Client-Pods in den Tenant-Namespaces. Hast du in Tag 12 aufgeräumt (tofu destroy), stelle erst die Mandanten wieder her: tofu -chdir=$HOME/sre-lab/tag12/tofu-tenant apply und kubectl apply -f ~/sre-lab/tag06/testpods.yaml. Eine Testfunktion mit HTTP-Code:

cd ~/sre-lab/tag15
export MODEL=ministral-3:3b
ask() { kubectl -n "$1" exec client -- curl -s -m 30 -w '\nHTTP %{http_code}\n' \
  http://llm-gateway.llm-system:8080/v1/chat/completions \
  -H "Authorization: Bearer $2" -H 'Content-Type: application/json' \
  -d '{"model":"'"$MODEL"'","messages":[{"role":"user","content":"Sag ok."}]}'; }
ask tenant-acme lab-key-acme | tail -1

Erwartet:

HTTP 200

Szenario: Ticket „Default-Deny auch für Egress in llm-system”. Ein Kollege rollt aus:

kubectl apply -f - <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-egress
  namespace: llm-system
spec:
  podSelector: {}
  policyTypes: [Egress]
EOF
~/sre-lab/tag15/uhr.sh start 3

Zeitlimit: 10 min

Symptome:

ask tenant-acme lab-key-acme | tail -1
sleep 30
ask tenant-acme lab-key-acme; echo "exit=$?"
kubectl -n llm-system get pods -l app.kubernetes.io/name=llm-gateway

Erwartet (gekürzt, nicht live getestet, kann je nach Version abweichen):

HTTP 502

HTTP 000
command terminated with exit code 7
exit=7
NAME                           READY   STATUS    RESTARTS   AGE
llm-gateway-5c8d7f9b6d-4xk2p   0/1     Running   0          2h
llm-gateway-5c8d7f9b6d-q9z7m   0/1     Running   0          2h

Erst 502 („upstream unavailable”), nach etwa 10 s sind alle Gateways nicht mehr ready, der Service hat keine Endpoints, und kube-proxy lehnt Verbindungen sofort ab (curl 7).

Diagnose-Pfad:

kubectl -n llm-system describe pods -l app.kubernetes.io/name=llm-gateway \
  | grep -E 'Readiness probe failed' | tail -1
kubectl -n llm-system get endpointslice -l kubernetes.io/service-name=llm-gateway \
  -o jsonpath='{.items[*].endpoints[*].conditions.ready}'; echo
kubectl -n llm-system logs deploy/llm-gateway --tail=50 | grep '"upstream"' | tail -1

Ein Ephemeral Container teilt das Netz des Gateway-Pods und damit auch dessen Policies. Erst DNS, dann direkt die ClusterIP – so trennst du „DNS kaputt” von „Egress zu”:

GW=$(kubectl -n llm-system get pod -l app.kubernetes.io/name=llm-gateway -o name \
  | head -1)
dbg() { kubectl -n llm-system debug "$GW" --image=curlimages/curl:8.22.0 \
  --target=gateway -q --attach -- "$@"; }
dbg nslookup ollama.llm-system.svc.cluster.local
OLLAMA_SVC=$(kubectl -n llm-system get svc ollama -o jsonpath='{.spec.clusterIP}')
dbg curl -s -m 3 "http://$OLLAMA_SVC:11434/api/version"; echo "exit=$?"
kubectl -n llm-system get netpol
kubectl -n llm-system get netpol default-deny-egress \
  -o jsonpath='{.metadata.creationTimestamp} {.metadata.managedFields[*].manager}'
echo

Erwartet (gekürzt, nicht live getestet):

  Warning  Unhealthy  ...  Readiness probe failed: HTTP probe failed with
  statuscode: 503
false false
{"time":"...","level":"ERROR","msg":"upstream","err":"dial tcp: lookup
 ollama.llm-system.svc.cluster.local on 10.96.0.10:53: ... i/o timeout"}
;; connection timed out; no servers could be reached
exit=28
NAME                           POD-SELECTOR                             AGE
allow-scrape-from-monitoring   app.kubernetes.io/name=llm-gateway       2d
default-deny-egress            <none>                                   4m
default-deny-ingress           <none>                                   2d
gateway-from-tenants           app.kubernetes.io/name=llm-gateway       2d
ollama-from-gateway            app.kubernetes.io/name=ollama            2d
2026-10-09T18:02:11Z kubectl-client-side-apply

DNS und direkte IP scheitern: Egress ist zu, nicht nur DNS. NetworkPolicies erzeugen keine Events – das jüngste AGE und managedFields sind deine Spur, im echten Cluster dazu das API-Audit-Log.

Lösung: Mitigation zuerst – die neue Policy zurücknehmen und prüfen:

kubectl -n llm-system delete netpol default-deny-egress
kubectl -n llm-system rollout status deploy/llm-gateway --timeout=60s
ask tenant-acme lab-key-acme | tail -1

Dauerhaft: Default-Deny behalten, aber erst die Allowlist ausrollen, dann den Deny.

cat > netpol-egress-llm-system.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-dns-egress
  namespace: llm-system
spec:
  podSelector: {}
  policyTypes: [Egress]
  egress:
    - to:
        - namespaceSelector:
            matchLabels: {kubernetes.io/metadata.name: kube-system}
          podSelector:
            matchLabels: {k8s-app: kube-dns}
      ports:
        - {protocol: UDP, port: 53}
        - {protocol: TCP, port: 53}
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: gateway-egress
  namespace: llm-system
spec:
  podSelector:
    matchLabels: {app.kubernetes.io/name: llm-gateway}
  policyTypes: [Egress]
  egress:
    - to:                                  # Modellserver im Cluster (Variante A)
        - podSelector:
            matchLabels: {app.kubernetes.io/name: ollama}
      ports:
        - {protocol: TCP, port: 11434}
    - to:                                  # OTLP zum Collector (Tag 9)
        - namespaceSelector:
            matchLabels: {kubernetes.io/metadata.name: monitoring}
      ports:
        - {protocol: TCP, port: 4318}
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: pull-job-egress
  namespace: llm-system
spec:
  podSelector:
    matchLabels: {job-name: ollama-pull}
  policyTypes: [Egress]
  egress:
    - to:
        - podSelector:
            matchLabels: {app.kubernetes.io/name: ollama}
      ports:
        - {protocol: TCP, port: 11434}
EOF
kubectl apply -f netpol-egress-llm-system.yaml

Läuft der Modellserver außerhalb (Variante B, Tag 7), ergänzt du in gateway-egress ein Ziel - ipBlock: {cidr: <OLLAMA_IP>/32} mit Port 11434. Ollama im Cluster braucht für pull zusätzlich Egress auf 443 – oder, besser, gar keinen (Air-Gap, Tag 14).

kubectl apply -f - <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-egress
  namespace: llm-system
spec:
  podSelector: {}
  policyTypes: [Egress]
EOF
sleep 15
ask tenant-acme lab-key-acme | tail -1
kubectl -n llm-system get pods -l app.kubernetes.io/name=llm-gateway \
  -o jsonpath='{.items[*].status.containerStatuses[0].ready}'; echo

Erwartet:

HTTP 200
true true

Lessons:

  • Egress-Deny trifft zuerst DNS. Jede Default-Deny-Änderung braucht vorher die Allowlist und danach die Gegenproben aus Tag 6 – automatisiert in CI.
  • Readiness mit Upstream-Check macht aus einem Netzproblem „keine Endpoints”. Das ist schnell sichtbar, aber ein Totalausfall – kenne den Trade-off.
  • Policies sind additiv: Reparieren heißt Allow ergänzen, nicht Deny löschen. Löschen ist nur die Mitigation.

Stoppuhr: ~/sre-lab/tag15/uhr.sh stop 3

Fortschritt speichern? Kostenlos registrieren

Drill 4: Modell-Upgrade endet in CrashLoopBackOff (Tag 1, 7)

Gelände: kind, Namespace llm-system. slow-model spielt einen vLLM-Server: /health antwortet erst, wenn die Gewichte geladen sind.

cd ~/sre-lab/tag15
cat > slow-model.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: slow-model
  namespace: llm-system
  labels: {app.kubernetes.io/name: slow-model}
spec:
  replicas: 1
  strategy: {type: Recreate}              # wie ollama.yaml: RWO-PVC
  selector:
    matchLabels: {app.kubernetes.io/name: slow-model}
  template:
    metadata:
      labels: {app.kubernetes.io/name: slow-model}
    spec:
      automountServiceAccountToken: false
      terminationGracePeriodSeconds: 10
      containers:
        - name: model
          image: python:3.13-alpine
          env:
            - {name: MODEL, value: ministral-3-8b}
            - {name: LOAD_SECONDS, value: "15"}
          command: [python, -u, -c]
          args:
            - |
              import http.server, os, time
              print(f"lade {os.environ['MODEL']} ...", flush=True)
              time.sleep(int(os.environ["LOAD_SECONDS"]))   # Gewichte laden
              class H(http.server.BaseHTTPRequestHandler):
                  def do_GET(self):
                      self.send_response(200); self.end_headers()
                      self.wfile.write(b"ok\n")
              print("bereit", flush=True)
              http.server.HTTPServer(("", 8000), H).serve_forever()
          ports: [{name: http, containerPort: 8000}]
          startupProbe:
            httpGet: {path: /health, port: http}
            periodSeconds: 5
            failureThreshold: 6           # Budget: 5 s x 6 = 30 s
          readinessProbe:
            httpGet: {path: /health, port: http}
            periodSeconds: 10
          resources:
            requests: {cpu: 50m, memory: 32Mi}
            limits: {memory: 64Mi}
EOF
kubectl apply -f slow-model.yaml
kubectl -n llm-system rollout status deploy/slow-model --timeout=120s

Erwartet:

deployment.apps/slow-model created
deployment "slow-model" successfully rolled out

Szenario: Upgrade auf das größere Modell. Es lädt 60 s statt 15 s:

kubectl -n llm-system set env deploy/slow-model MODEL=ministral-3-14b LOAD_SECONDS=60
~/sre-lab/tag15/uhr.sh start 4

Zeitlimit: 10 min

Symptome:

sleep 120
kubectl -n llm-system get pods -l app.kubernetes.io/name=slow-model

Erwartet (gekürzt, nicht live getestet):

NAME                          READY   STATUS             RESTARTS      AGE
slow-model-7d9c6b5f4-8kq2t    0/1     CrashLoopBackOff   2 (15s ago)   2m

Der alte Pod ist weg (Recreate), der neue wird nie ready: Totalausfall.

Diagnose-Pfad:

P=$(kubectl -n llm-system get pod -l app.kubernetes.io/name=slow-model -o name)
kubectl -n llm-system describe "$P" \
  | grep -E 'Startup probe failed|failed startup probe|Back-off' | tail -3
kubectl -n llm-system logs "$P" --previous
kubectl -n llm-system get "$P" \
  -o jsonpath='{.status.containerStatuses[0].lastState.terminated.exitCode}'; echo
kubectl -n llm-system get deploy slow-model \
  -o jsonpath='{.spec.template.spec.containers[0].startupProbe}'; echo

Erwartet (gekürzt, nicht live getestet):

Warning  Unhealthy  ...  Startup probe failed: Get "http://10.244.2.9:8000/health":
  dial tcp 10.244.2.9:8000: connect: connection refused
Normal   Killing    ...  Container model failed startup probe, will be restarted
Warning  BackOff    ...  Back-off restarting failed container model in pod ...
lade ministral-3-14b ...
137
{"failureThreshold":6,"httpGet":{"path":"/health","port":"http","scheme":"HTTP"},
 "periodSeconds":5,"successThreshold":1,"timeoutSeconds":1}

Rechnung: 5 s × 6 = 30 s Budget gegen 60 s Ladezeit. Im Log fehlt „bereit”. Warum 137 statt 143? Python läuft als PID 1 ohne SIGTERM-Handler, und der Kernel ignoriert für PID 1 Signale ohne Handler (Tag 1). Nach terminationGracePeriodSeconds folgt SIGKILL – im Lab mit docker stop nachgeprüft: Exit 137 nach Ablauf der Frist.

Lösung: Mitigation – alte Version zurück, dann Probe-Budget fixen und erneut upgraden:

kubectl -n llm-system rollout undo deploy/slow-model
kubectl -n llm-system rollout status deploy/slow-model --timeout=120s
kubectl -n llm-system patch deploy slow-model --type=json -p '[{"op":"replace",
  "path":"/spec/template/spec/containers/0/startupProbe/failureThreshold",
  "value":24}]'
kubectl -n llm-system set env deploy/slow-model MODEL=ministral-3-14b LOAD_SECONDS=60
kubectl -n llm-system rollout status deploy/slow-model --timeout=180s
kubectl -n llm-system logs deploy/slow-model | grep bereit

Erwartet (gekürzt):

deployment.apps/slow-model rolled back
deployment "slow-model" successfully rolled out
deployment.apps/slow-model patched
deployment.apps/slow-model env updated
deployment "slow-model" successfully rolled out
bereit

24 × 5 s = 120 s, also das Doppelte der gemessenen Ladezeit. Aufräumen: kubectl -n llm-system delete deploy slow-model.

Lessons:

  • Startup-Budget = periodSeconds × failureThreshold ≥ 2 × gemessene Ladezeit des größten Modells bei kaltem Cache. Ladezeit pro Modellversion messen und dokumentieren.
  • Recreate plus kaputtes Upgrade ist ein Totalausfall. Mit freier GPU lieber RollingUpdate mit maxUnavailable: 0 oder Blue/Green pro Modellversion.
  • PID 1 braucht Signal-Handling (exec, tini, eigener Handler) – sonst kein Drain.

Stoppuhr: ~/sre-lab/tag15/uhr.sh stop 4

Fortschritt speichern? Kostenlos registrieren

Drill 5: Alarmsturm und Blindflug (Tag 8, 10)

Gelände: kube-prometheus-stack, Regeln und Alertmanager-Config aus Tag 8 und 10, alert-sink in monitoring, Port-Forward auf Prometheus (9090). Hilfsfunktionen wie in Tag 10:

cd ~/sre-lab/tag15
OBS=~/sre-lab/code/observability
amk() {
  kubectl -n monitoring exec alertmanager-kps-kube-prometheus-stack-alertmanager-0 \
    -c alertmanager -- amtool --alertmanager.url=http://localhost:9093 "$@"
}
pq() {
  curl -s localhost:9090/api/v1/query --data-urlencode "query=$1" | jq -r \
    '.data.result[] | "\(.metric | del(.__name__) | tostring) \(.value[1])"'
}

Szenario Runde A – 03:12 Uhr, der Pager hört nicht auf. Das Gateway wird nicht mehr gescrapt, gleichzeitig brennen alle Mandanten. Das Runbook verspricht: LLMGatewayDown unterdrückt alle anderen Gateway-Alerts.

~/sre-lab/tag15/uhr.sh start 5
amk alert add alertname=LLMGatewayDown severity=page namespace=llm-system \
  job=llm-gateway instance=10.244.1.7:8080
for t in acme globex initech; do
  amk alert add alertname=LLMGatewayHighErrorRate severity=page long_window=1h \
    tenant=$t
done

Zeitlimit: 20 min für beide Runden

Symptome:

sleep 40
kubectl -n monitoring logs alert-sink --since=2m | grep '^/page'
amk alert query --inhibited | tail -n +2 | wc -l

Erwartet (gekürzt, nicht live getestet):

/page firing LLMGatewayDown -
/page firing LLMGatewayHighErrorRate acme
/page firing LLMGatewayHighErrorRate globex
/page firing LLMGatewayHighErrorRate initech
       0

Vier Pages statt einer, nichts inhibiert.

Diagnose-Pfad:

grep -A2 'LLMGatewayDown"\]' $OBS/alertmanager/alertmanager.yaml
amk alert query -o json \
  | jq -c '.[] | .labels | {alertname, tenant, namespace}'
pq 'tenant:slo_errors:ratio_rate1h'

Erwartet (gekürzt):

  - source_matchers: [alertname = "LLMGatewayDown"]
    target_matchers: [alertname =~ "LLMGateway.+", alertname != "LLMGatewayDown"]
    equal: [namespace]
{"alertname":"LLMGatewayDown","tenant":null,"namespace":"llm-system"}
{"alertname":"LLMGatewayHighErrorRate","tenant":"acme","namespace":null}
...
{"tenant":"acme"} 0

equal: [namespace] verlangt denselben Wert bei Quelle und Ziel. Ein fehlendes Label zählt als leerer String – und sum by (tenant) in den Recording Rules wirft namespace weg. Die Inhibition kann nie greifen.

Lösung Runde A: Das Label statisch an alle Gateway-Alerts außer LLMGatewayDown hängen (das bekommt namespace vom Scrape-Target), Tests anpassen, testen, ausrollen:

mkdir -p rules && cp $OBS/rules/*.yaml rules/ && cd rules
yq -i '(.groups[].rules[] | select(.alert != "LLMGatewayDown")
  | .labels.namespace) = "llm-system"' llm-gateway-alerts.rules.yaml
docker run --rm -v $PWD:/r -w /r --entrypoint promtool \
  prom/prometheus:v3.15.0 test rules llm-gateway.test.yaml 2>&1 | grep -m1 FAILED
sed -i.bak -E 's/(exp_labels: \{ severity: (page|ticket),)/\1 namespace: llm-system,/' \
  llm-gateway.test.yaml
docker run --rm -v $PWD:/r -w /r --entrypoint promtool \
  prom/prometheus:v3.15.0 test rules llm-gateway.test.yaml

Erwartet (live getestet):

  FAILED:
  SUCCESS

Der erste Lauf scheitert, weil die alten Tests die Labels exakt prüfen – genau so soll es sein. yq formatiert die Datei dabei leicht um (Flow-Maps, gefaltete Strings). Ausrollen und mit Alerts prüfen, die jetzt namespace tragen:

mk_rule() {
  printf 'apiVersion: monitoring.coreos.com/v1\nkind: PrometheusRule\n'
  printf 'metadata:\n  name: %s\n  namespace: monitoring\nspec:\n' "$1"
  sed -e '/^#/d' -e 's/^/  /' "$2"
}
mk_rule llm-gateway-alerts llm-gateway-alerts.rules.yaml | kubectl apply -f -
for t in acme globex; do
  amk alert add alertname=LLMGatewayHighErrorRate severity=page long_window=6h \
    tenant=$t namespace=llm-system
done
sleep 40; amk alert query --inhibited | tail -n +2 | wc -l
cd ..

Erwartet (nicht live getestet):

prometheusrule.monitoring.coreos.com/llm-gateway-alerts configured
       2

Szenario Runde B – Blindflug. Ein Kollege benennt beim Aufräumen den Service-Port um:

kubectl -n llm-system patch svc llm-gateway --type=json \
  -p '[{"op":"replace","path":"/spec/ports/0/name","value":"web"}]'

Symptome: Kunden merken nichts (ask tenant-acme lab-key-acme aus Drill 3 liefert 200). Nach ein bis zwei Minuten sind Dashboards leer – und kein Alert feuert.

Diagnose-Pfad:

sleep 120
pq 'up{job="llm-gateway"}'
pq 'count(tenant:gateway_requests:rate5m)'
curl -s localhost:9090/api/v1/targets | jq -r '.data.activeTargets[]
  | select(.labels.job=="llm-gateway") | .health' | sort | uniq -c
kubectl -n llm-system get svc llm-gateway -o jsonpath='{.spec.ports[0].name}'; echo
kubectl -n llm-system get servicemonitor llm-gateway \
  -o jsonpath='{.spec.endpoints[0].port}'; echo

Erwartet (gekürzt, nicht live getestet):

web
http

Drei leere Ergebnisse, dann die Ursache: Der ServiceMonitor sucht den Port-Namen http. LLMGatewayDown prüft up == 0 – aber up ist nicht 0, es existiert gar nicht mehr. Ohne Daten rechnen auch die Burn-Rate-Regeln nichts: Das ganze SLO-Alerting ist taub.

Lösung Runde B:

kubectl -n llm-system patch svc llm-gateway --type=json \
  -p '[{"op":"replace","path":"/spec/ports/0/name","value":"http"}]'
cd rules
cat >> llm-gateway-alerts.rules.yaml <<'EOF'
      - alert: LLMGatewayTargetMissing
        expr: absent(up{job="llm-gateway"})
        for: 10m
        labels: { severity: page, namespace: llm-system }
        annotations:
          summary: "llm-gateway: kein Scrape-Target – Monitoring ist blind"
          runbook_url: >-
            https://runbooks.example.com/llm-gateway/LLMGatewayTargetMissing
EOF
cat > blind.test.yaml <<'EOF'
rule_files:
  - llm-gateway-recording.rules.yaml
  - llm-gateway-slo.rules.yaml
  - llm-gateway-alerts.rules.yaml
evaluation_interval: 30s
tests:
  - interval: 1m
    input_series:
      - series: 'up{job="llm-gateway",instance="10.244.1.7:8080"}'
        values: '1x10'          # 10 min gescrapt, dann ist das Target weg
    alert_rule_test:
      - eval_time: 15m
        alertname: LLMGatewayDown
        exp_alerts: []          # up ist nicht 0, sondern verschwunden
      - eval_time: 25m
        alertname: LLMGatewayTargetMissing
        exp_alerts:
          - exp_labels: { severity: page, namespace: llm-system, job: llm-gateway }
            exp_annotations:
              summary: "llm-gateway: kein Scrape-Target – Monitoring ist blind"
              runbook_url: >-
                https://runbooks.example.com/llm-gateway/LLMGatewayTargetMissing
EOF
docker run --rm -v $PWD:/r -w /r --entrypoint promtool \
  prom/prometheus:v3.15.0 test rules llm-gateway.test.yaml blind.test.yaml
mk_rule llm-gateway-alerts llm-gateway-alerts.rules.yaml | kubectl apply -f -
cd ..

Erwartet (promtool live getestet):

service/llm-gateway patched
  SUCCESS

  SUCCESS
prometheusrule.monitoring.coreos.com/llm-gateway-alerts configured

Der Test beweist beides: LLMGatewayDown bleibt bei verschwundenem Target stumm, LLMGatewayTargetMissing feuert. Die Einrückung passt, weil auch yq sechs Leerzeichen vor - alert schreibt – prüfe das mit grep -n 'alert:', bevor du anhängst. Liest promtool im Container noch die alte Datei, warte ein paar Sekunden: Die Dateifreigabe mancher Docker-VMs synchronisiert mit Verzögerung.

Lessons:

  • Inhibition und Routing sind Code: equal-Labels müssen auf beiden Seiten existieren. Ein Unit-Test pro Inhibit-Regel (amtool mit synthetischen Alerts) gehört in CI.
  • „Kein Alarm” heißt nicht „alles gut”. Für jedes kritische Target ein absent()-Alert und den Watchdog als Dead Man’s Switch (Tag 10).
  • Port-Namen sind API: ServiceMonitors hängen am Namen, nicht an der Nummer (Tag 8).

Stoppuhr: ~/sre-lab/tag15/uhr.sh stop 5

Fortschritt speichern? Kostenlos registrieren

Drill 6: Zertifikat abgelaufen (Tag 2)

Gelände: llm-vm. Ein TLS-Endpunkt wie in Tag 2, diesmal mit eigener Lab-CA (getestet mit OpenSSL 3.5). Auf der VM:

pkill -f 's_server -accept 8443' 2>/dev/null   # Server aus Tag 2 beenden
mkdir -p ~/tag15/tls && cd ~/tag15/tls
openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:P-256 -nodes \
  -keyout ca.key -out ca.crt -days 365 -subj "/CN=lab-ca" 2>/dev/null
openssl req -newkey ec -pkeyopt ec_paramgen_curve:P-256 -nodes \
  -keyout llm.key -out llm.csr -subj "/CN=llm-vm.lab" 2>/dev/null
echo "subjectAltName=DNS:llm-vm.lab,DNS:localhost,IP:127.0.0.1" > san.ext
openssl x509 -req -in llm.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
  -days 90 -extfile san.ext -out llm.crt 2>/dev/null
openssl s_server -accept 8443 -cert llm.crt -key llm.key -www -quiet \
  >/dev/null 2>&1 &
sleep 1
curl -s --cacert ca.crt https://localhost:8443/ -o /dev/null -w '%{http_code}\n'

Erwartet:

200

Szenario: 90 Tage später, Samstag 06:00. -days 0 stellt ein Zertifikat aus, das im Moment der Ausstellung abläuft:

openssl x509 -req -in llm.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
  -days 0 -extfile san.ext -out llm.crt 2>/dev/null
pkill -f 's_server -accept 8443'; sleep 1
openssl s_server -accept 8443 -cert llm.crt -key llm.key -www -quiet \
  >/dev/null 2>&1 &

Auf dem Laptop: ~/sre-lab/tag15/uhr.sh start 6

Zeitlimit: 10 min

Symptome:

sleep 2; curl -sS --cacert ca.crt https://localhost:8443/ -o /dev/null
echo "curl exit=$?"

Erwartet (live getestet):

curl: (60) SSL certificate problem: certificate has expired
More details here: https://curl.se/docs/sslcerts.html
...
curl exit=60

Python-Clients wie llmctl melden dasselbe als CERTIFICATE_VERIFY_FAILED – im Ticket des Kunden steht dann meist nur „SSL-Fehler”.

Diagnose-Pfad:

echo | openssl s_client -brief -connect 127.0.0.1:8443 -CAfile ca.crt 2>&1 \
  | grep -iE 'verif|Protocol'
echo | openssl s_client -connect 127.0.0.1:8443 2>/dev/null \
  | openssl x509 -noout -subject -issuer -enddate
openssl verify -CAfile ca.crt llm.crt
openssl x509 -in ca.crt -noout -enddate

Erwartet (live getestet, Datum variiert):

verify error:num=10:certificate has expired
Protocol version: TLSv1.3
Verification error: certificate has expired
subject=CN=llm-vm.lab
issuer=CN=lab-ca
notAfter=Oct  9 17:43:11 2026 GMT
CN=llm-vm.lab
error 10 at 0 depth lookup: certificate has expired
error llm.crt: verification failed
notAfter=Oct  9 17:43:00 2027 GMT

Das Leaf-Zertifikat ist abgelaufen, die CA nicht. Immer beides prüfen: Eine abgelaufene Zwischen-CA sieht für Clients genauso aus.

Lösung:

openssl x509 -req -in llm.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
  -days 90 -extfile san.ext -out llm.crt 2>/dev/null
pkill -f 's_server -accept 8443'; sleep 1
openssl s_server -accept 8443 -cert llm.crt -key llm.key -www -quiet \
  >/dev/null 2>&1 &
sleep 1
curl -s --cacert ca.crt https://localhost:8443/ -o /dev/null -w '%{http_code}\n'
openssl x509 -in llm.crt -noout -checkend $((30*86400)) && echo "✔ noch 30 Tage"

Erwartet:

200
Certificate will not expire
✔ noch 30 Tage

Dauerhaft: Ablauf von außen überwachen, so wie der Client es sieht – etwa mit dem Prometheus Blackbox Exporter und probe_ssl_earliest_cert_expiry - time() < 14 * 86400 als Ticket-Alert. Rotation automatisieren: cert-manager im Cluster, OpenBao-PKI mit kurzer TTL plus Agent auf VMs.

Lessons:

  • Zertifikate laufen nachts und am Wochenende ab. Der Alarm muss Wochen vorher kommen und die ganze Kette prüfen (Leaf, Zwischen-CA, CA).
  • Exit 60 heißt „Vertrauen fehlt” – abgelaufen, falsche CA oder Name nicht im SAN. s_client -brief nennt den genauen Grund.
  • Kurze Laufzeiten sind sicherer, aber nur mit Automatisierung. Manuelle 90-Tage-Zertifikate sind ein geplanter Incident.

Stoppuhr: ~/sre-lab/tag15/uhr.sh stop 6

Fortschritt speichern? Kostenlos registrieren

Drill 7: Kritische CVE am Freitagnachmittag (Tag 12, 13, 14)

Gelände: SBOM aus Tag 13 (~/sre-lab/tag13/sbom.spdx.json), Bundle aus Tag 14 (~/sre-lab/tag14/bundle/images/ollama_0.40.2.tar), llm-vm, Ansible-Inventar aus Tag 12. Der TLS-Endpunkt aus Drill 6 läuft noch (sonst wie dort neu starten).

Szenario: Diese Nachricht kommt um 15:30 im Security-Kanal an (CVE und Versionen sind für die Übung erfunden):

CVE-2026-31337 (fiktiv): Remote Code Execution in OpenSSL über präparierte
TLS-Handshakes. CVSS 9.8, seit heute in CISA KEV. Betroffen: libssl3 bis 3.0.13.
Ubuntu-Fix: libssl3t64 3.0.13-0ubuntu3.9 (fiktiv). Sind wir betroffen?
Antwort mit Plan bis 17:00.
~/sre-lab/tag15/uhr.sh start 7

Zeitlimit: 30 min (Antwort an Security inklusive)

Symptome: Keine – genau das macht CVE-Response schwer. Das Ergebnis ist eine Entscheidung mit Belegen.

Diagnose-Pfad:

Schritt 1, Inventur: Welche Artefakte enthalten das Paket?

cd ~/sre-lab/tag15
jq -r '.packages[] | select(.name|test("ssl")) | "\(.name) \(.versionInfo)"' \
  ~/sre-lab/tag13/sbom.spdx.json | grep . || echo "llm-gateway: kein libssl"
syft scan -q "oci-archive:$HOME/sre-lab/tag14/bundle/images/ollama_0.40.2.tar" \
  -o json | jq -r '.artifacts[] | select(.name|test("^(libssl|openssl)"))
  | "ollama-image: \(.name) \(.version)"'
multipass exec llm-vm -- dpkg-query -W -f '${Package} ${Version}\n' 'libssl*' openssl

Erwartet (gekürzt, Versionen hängen vom Image- und Paketstand ab):

llm-gateway: kein libssl
ollama-image: libssl3t64 3.0.13-0ubuntu3.5
ollama-image: openssl 3.0.13-0ubuntu3.5
libssl3t64 3.0.13-0ubuntu3.5
openssl 3.0.13-0ubuntu3.5

Schritt 2, Erreichbarkeit: Lädt ein laufender Prozess die Bibliothek, und hängt er am Netz?

multipass exec llm-vm -- sudo bash -c '
  for p in $(pgrep -x ollama) $(pgrep -f "[s]_server -accept"); do
    printf "%-8s %-10s libssl-maps=%s\n" "$p" "$(ps -o comm= -p "$p")" \
      "$(grep -c libssl "/proc/$p/maps")"
  done'
multipass exec llm-vm -- sudo ss -tlnp | grep -E ':8443|:11434'

Erwartet (gekürzt, nicht live getestet):

2412     ollama     libssl-maps=0
3110     openssl    libssl-maps=5
LISTEN 0  4096  127.0.0.1:11434  0.0.0.0:*  users:(("ollama",pid=2412,fd=3))
LISTEN 0  128   0.0.0.0:8443     0.0.0.0:*  users:(("openssl",pid=3110,fd=4))

Ollama ist ein Go-Binary mit eigenem TLS (crypto/tls): Paket vorhanden, nicht geladen. Der TLS-Endpunkt aus Drill 6 lädt libssl und lauscht auf allen Interfaces.

Schritt 3, Entscheidung:

Artefakt Befund Entscheidung
llm-gateway (distroless) kein libssl not affected, VEX dokumentieren
ollama-Image (Air-Gap-Kunden) vorhanden, nicht geladen Rebuild, nächstes Bundle
llm-vm, TLS-Endpunkt :8443 geladen, im Netz, KEV heute patchen und neu starten

Lösung: VM jetzt patchen – per Ansible, damit es für alle VMs gleich läuft:

cd ~/sre-lab/tag12/ansible-llm-vm
ansible llm_vms -i inventory/hosts.ini -b -m ansible.builtin.apt \
  -a 'name=libssl3t64,openssl state=latest update_cache=true'
multipass exec llm-vm -- sudo bash -c \
  'grep -l "libssl.*(deleted)" /proc/[0-9]*/maps 2>/dev/null | cut -d/ -f3'

Prozesse, die noch die alte, gelöschte Bibliothek gemappt haben, zeigt die zweite Zeile. Sie müssen neu starten – ein Paket-Update allein schließt keine Lücke im laufenden Prozess (Ubuntu: sudo needrestart -r l listet dasselbe). Für den TLS-Endpunkt: Server aus Drill 6 neu starten.

Das Ollama-Image baust du nicht selbst. Bis der Hersteller nachzieht, hilft ein abgeleitetes Image, das dann gescannt, signiert und ins nächste Bundle gelegt wird (Tag 13, 14):

FROM ollama/ollama:0.40.2
RUN apt-get update \
 && apt-get install -y --only-upgrade libssl3t64 openssl \
 && rm -rf /var/lib/apt/lists/*

Antwort an Security und Advisory für On-Prem-Kunden (Englisch, in advisory.txt):

cat > ~/sre-lab/tag15/advisory.txt <<'EOF'
Security Advisory LLMPLAT-2026-004 – CVE-2026-31337 (OpenSSL), exercise
Status: investigated 2026-10-09 16:40 UTC.
Affected: model server VMs installed with our Ansible role (OS package libssl3t64).
Not affected: llm-gateway image (static Go binary, no OpenSSL). The Ollama
container image contains the package, but the server process does not load it.
Fix: VMs patched and services restarted (16:35 UTC). Container bundle 0.2.1 with
updated base packages will ship by 2026-10-13.
Action for on-prem customers: run "apt-get install --only-upgrade libssl3t64
openssl" on model server VMs and restart services, or apply bundle 0.2.1.
Exploitation: listed in CISA KEV. No evidence of exploitation in our logs.
EOF
grep -c . ~/sre-lab/tag15/advisory.txt

Erwartet:

10

Lessons:

  • SBOMs pro Release machen aus „Sind wir betroffen?” eine Abfrage statt einer Schatzsuche – auch für Images, die längst beim Kunden laufen.
  • Vorhanden ≠ geladen ≠ erreichbar. Die Freitagsentscheidung hängt an KEV, Exposition und Erreichbarkeit, nicht an der Uhrzeit.
  • Nach einem Library-Patch neu starten. OS-Pakete (Ansible) und Images (Rebuild) sind zwei getrennte Wege mit getrennten Fristen.

Stoppuhr: ~/sre-lab/tag15/uhr.sh stop 7

Fortschritt speichern? Kostenlos registrieren

Drill 8: Air-Gap-Upgrade bleibt hängen (Tag 14)

Gelände: Tag 14: kind mit kunde-registry, Release llm in llm-system mit values-lab-kind.yaml.

cd ~/sre-lab/tag14
R=127.0.0.1:5050
C=~/sre-lab/code/llm-platform-chart
helm history llm -n llm-system | tail -1

Szenario: Der Kunde spielt den CVE-Fix ein. Die Values-Änderung kam per Mail, das Bundle war das alte:

helm upgrade llm oci://$R/charts/llm-platform --version 0.1.0 --plain-http \
  -n llm-system -f "$C/examples/values-lab-kind.yaml" --set gateway.image.tag=1.8.1
~/sre-lab/tag15/uhr.sh start 8

Zeitlimit: 15 min

Symptome: Kundenticket „Upgrade hängt, ein Pod startet nicht”:

kubectl -n llm-system get pods -l app.kubernetes.io/component=gateway

Erwartet (gekürzt, nicht live getestet):

NAME                                       READY   STATUS             RESTARTS   AGE
llm-llm-platform-gateway-6d9f7c8b5-x2k4p   1/1     Running            0          2d
llm-llm-platform-gateway-7b4c9d6f8-m3n5q   0/1     ImagePullBackOff   0          3m

Der alte Pod läuft weiter: Bei einer Replica rundet RollingUpdate (25 %) maxUnavailable auf 0 ab. Kein Ausfall, aber auch kein Fix.

Diagnose-Pfad:

kubectl -n llm-system describe pod -l app.kubernetes.io/component=gateway \
  | grep -E 'Failed to pull|Back-off pulling' | tail -2
crane ls --insecure $R/llm-gateway
helm get values llm -n llm-system
helm history llm -n llm-system | tail -2
crane config --insecure $R/llm-gateway:dev | jq -r .architecture

Erwartet (gekürzt, nicht live getestet):

Warning  Failed  ...  Failed to pull image "kunde-registry:5000/llm-gateway:1.8.1":
  ... failed to resolve reference "kunde-registry:5000/llm-gateway:1.8.1": ... not found
Normal   BackOff ...  Back-off pulling image "kunde-registry:5000/llm-gateway:1.8.1"
dev
USER-SUPPLIED VALUES:
...
gateway:
  image:
    tag: 1.8.1
...
3   deployed   llm-platform-0.1.0   0.1.0   Upgrade complete
arm64

Das Tag fehlt in der Registry. Helm meldet trotzdem „deployed”, weil ohne --wait niemand auf Readiness gewartet hat. Die letzte Zeile beantwortet die zweite typische Frage beim Kunden: Passt die Architektur des Images zu den Nodes?

Lösung: Mitigation – zurück auf die letzte gute Revision:

helm rollback llm -n llm-system --wait --timeout 5m
kubectl -n llm-system get pods -l app.kubernetes.io/component=gateway

Dauerhaft: Das fehlende Image über die Datenschleuse liefern, Preflight mit den neuen Values, dann Upgrade mit automatischem Rückweg. Im Lab spielt das gepatchte Image aus Tag 13 die Version 1.8.1:

docker tag llm-gateway:dev-jwt llm-gateway:1.8.1
docker save llm-gateway:1.8.1 -o bundle/images/llm-gateway_1.8.1.tar
skopeo copy -q --dest-tls-verify=false \
  docker-archive:bundle/images/llm-gateway_1.8.1.tar docker://$R/llm-gateway:1.8.1
helm template llm oci://$R/charts/llm-platform --version 0.1.0 --plain-http \
  -f "$C/examples/values-lab-kind.yaml" --set gateway.image.tag=1.8.1 2>/dev/null \
  | awk '$1=="image:"{print $2}' | sort -u | sed "s|kunde-registry:5000|$R|" \
  | while read -r img; do
      crane digest --insecure "$img" >/dev/null 2>&1 && echo "✔ $img" || echo "✘ $img"
    done
helm upgrade llm oci://$R/charts/llm-platform --version 0.1.0 --plain-http \
  -n llm-system -f "$C/examples/values-lab-kind.yaml" --set gateway.image.tag=1.8.1 \
  --rollback-on-failure --timeout 10m

Erwartet (gekürzt, nicht live getestet):

✔ 127.0.0.1:5050/llm-gateway:1.8.1
✔ 127.0.0.1:5050/models/ministral-3:3b-q4km
✔ 127.0.0.1:5050/ollama/ollama:0.40.2
Release "llm" has been upgraded. Happy Helming!

Fehlt llm-gateway:dev-jwt (Tag 13 übersprungen), nimm docker tag llm-gateway:dev. Danach SHA256SUMS des Bundles neu erzeugen (Tag 14, Drill 5).

Lessons:

  • Preflight gehört vor jedes Upgrade, nicht nur vor die Erstinstallation – und zwar mit genau den Values, die der Kunde einspielt.
  • Values und Bundle kommen aus einem Release-Artefakt. Eine Values-Änderung per Mail ist ein Bundle ohne Packzettel.
  • Beim Kunden immer --rollback-on-failure (früher --atomic). Ohne Warten auf Readiness meldet Helm Erfolg für ein Deployment, das nie startet.

Stoppuhr: ~/sre-lab/tag15/uhr.sh stop 8

Fortschritt speichern? Kostenlos registrieren

Bewertung

Drill Zeitlimit Punkte geschafft
1 OOM-Kill beim Laden 15 min 10 [ ]
2 Noisy Neighbor 15 min 10 [ ]
3 Egress-Policy 10 min 10 [ ]
4 startupProbe und CrashLoop 10 min 10 [ ]
5 Alarmsturm und Blindflug 20 min 15 [ ]
6 Zertifikat abgelaufen 10 min 10 [ ]
7 CVE am Freitag 30 min 20 [ ]
8 Air-Gap-Upgrade 15 min 15 [ ]
Summe 125 min 100

Punkte nur bei Lösung in der Zeit und einer Zeile Lessons im Runbook. Ab 70 Punkten und 6 von 8 Drills in der Zeit bist du bereit für die Rufbereitschaft. Wähle danach einen Drill und schreibe dafür ein vollständiges Post-Mortem nach der Vorlage aus Tag 11 – das ist deine Arbeitsprobe für das Interview.

Kontrollpunkt

Nach allen Drills muss das Gelände wieder grün sein. Hast du für Drill 8 die Tag-7-Workloads entfernt, spiele ~/sre-lab/tag07/gateway.yaml vorher wieder ein.

cat > ~/sre-lab/tag15/check.sh <<'EOF'
#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
cd ~/sre-lab/tag15 || exit 1
DROPIN=/etc/systemd/system/ollama.service.d/zz-drill.conf
check "D1 kein Drill-Drop-in" "! multipass exec llm-vm -- test -e $DROPIN"
check "D1 Ollama aktiv" "multipass exec llm-vm -- systemctl is-active ollama"
check "D2 keine zweite Gateway-Replica" \
  "! docker ps --format '{{.Names}}' | grep -qx gw2"
check "D3 Egress-Allowlist da" \
  "kubectl -n llm-system get netpol allow-dns-egress gateway-egress"
check "D3 Gateway 2+ ready" '[ "$(kubectl -n llm-system get deploy llm-gateway \
  -o jsonpath="{.status.readyReplicas}")" -ge 2 ]'
check "D4 slow-model aufgeräumt" "! kubectl -n llm-system get deploy slow-model"
check "D5 Regel-Tests grün" "docker run --rm -v $PWD/rules:/r -w /r \
  --entrypoint promtool prom/prometheus:v3.15.0 \
  test rules llm-gateway.test.yaml blind.test.yaml"
check "D5 Service-Port heißt http" '[ "$(kubectl -n llm-system get svc \
  llm-gateway -o jsonpath="{.spec.ports[0].name}")" = http ]'
check "D6 Zertifikat 30 Tage gültig" "multipass exec llm-vm -- openssl x509 \
  -in /home/ubuntu/tag15/tls/llm.crt -noout -checkend 2592000"
check "D7 Advisory mit Fix" "grep -q '^Fix:' advisory.txt"
check "D8 Release deployed" "helm status llm -n llm-system | grep -q 'deployed'"
check "mind. 6 Drills gewertet" '[ "$(wc -l < score.txt)" -ge 6 ]'
EOF
bash ~/sre-lab/tag15/check.sh

Erwartet:

✔ D1 kein Drill-Drop-in
✔ D1 Ollama aktiv
✔ D2 keine zweite Gateway-Replica
✔ D3 Egress-Allowlist da
✔ D3 Gateway 2+ ready
✔ D4 slow-model aufgeräumt
✔ D5 Regel-Tests grün
✔ D5 Service-Port heißt http
✔ D6 Zertifikat 30 Tage gültig
✔ D7 Advisory mit Fix
✔ D8 Release deployed
✔ mind. 6 Drills gewertet

Challenge

Jemand hat globex „nur kurz” zwei GPUs freigegeben – per kubectl, an OpenTofu vorbei (Tag 12). Finde die Drift mit einem Befehl, entscheide, ob sie zurückgedreht oder in den Code übernommen wird, und beweise danach mit Exit-Code 0, dass Code und Cluster wieder übereinstimmen.

kubectl -n tenant-globex patch quota tenant-quota --type=merge \
  -p '{"spec":{"hard":{"requests.nvidia.com/gpu":"2"}}}'

Hinweis: tofu plan -detailed-exitcode liefert 2 bei Drift; „übernehmen” heißt terraform.tfvars ändern, nicht den State bearbeiten.

Lösung

cd ~/sre-lab/tag12/tofu-tenant
tofu plan -no-color -detailed-exitcode > drift.txt; echo "Exit-Code: $?"
grep -E '^  # |nvidia|^Plan:' drift.txt

Erwartet (gekürzt, nicht live getestet):

Exit-Code: 2
  # module.tenant["globex"].kubernetes_resource_quota_v1.this will be updated in-place
          ~ "requests.nvidia.com/gpu" = "2" -> "0"
Plan: 0 to add, 1 to change, 0 to destroy.

Weg A – kein genehmigter Change: Code gewinnt.

tofu apply -auto-approve -no-color | grep 'Apply complete'
tofu plan -detailed-exitcode >/dev/null; echo "Exit-Code: $?"

Erwartet:

Apply complete! Resources: 0 added, 1 changed, 0 destroyed.
Exit-Code: 0

Weg B – der Change ist genehmigt: in den Code übernehmen, per Merge-Request. Danach ist der Plan ohne Apply leer, denn der Cluster hat den Wert schon.

old='globex = { team_group = "team-globex" }'
new='globex = { team_group = "team-globex", gpu_quota = 2 }'
sed -i.bak "s/$old/$new/" terraform.tfvars
grep globex terraform.tfvars
tofu plan -detailed-exitcode >/dev/null; echo "Exit-Code: $?"

Erwartet (sed live getestet; Plan nach erneutem kubectl patch aus der Aufgabe):

  globex = { team_group = "team-globex", gpu_quota = 2 }
Exit-Code: 0

Wichtig ist nicht der Weg, sondern dass jemand ihn bewusst wählt und im Ticket festhält. Der nächtliche plan -detailed-exitcode aus Tag 12 hätte die Drift am nächsten Morgen gemeldet.

Fortschritt speichern? Kostenlos registrieren

Interview-Notiz

  • Typische Frage: „Tell me about a time you debugged a production issue under pressure.” Struktur: Impact, Mitigation, Hypothesen mit Belegen, Fix, Follow-up – mit Zahlen und Zeiten. Ein Drill aus diesem Kapitel ist ein guter Übungsfall dafür.
  • Knackig: „I mitigate first, then I debug. And every hypothesis gets a command that can prove it wrong.”
  • Im Live-Debugging zählt der Weg: Symptom präzisieren, Scope klären, letzte Änderung suchen, von außen nach innen arbeiten, vor jedem Befehl sagen, was du erwartest (Anhang C).
  • Brücke aus deiner Praxis: Ausfallszenarien für Vault/OpenBao bei regulierten Kunden – Raft-Quorum, Auto-Unseal, abgelaufene Zertifikate. «Konkretes Beispiel mit Zahlen einsetzen.»
  • Gegenfrage: „How do you run game days, and do customers with on-prem deployments take part?”

Enterprise-Notiz

  • Game Days mit Kunden: Szenarien, Zeitfenster, Abbruchkriterien und Rückweg vorher schriftlich vereinbaren. Nie unangekündigt auf geteilten GPU-Clustern.
  • Regulierte Kunden müssen Resilienz nachweisen (z. B. DORA im Finanzsektor, NIS2). Drill-Protokolle mit Zeiten und Lessons sind dafür direkt verwendbar.
  • Chaos-Werkzeuge wie Chaos Mesh oder LitmusChaos erst in Staging, mit begrenztem Blast Radius und Kill-Switch.
  • Pro Drill MTTD und MTTR messen und über die Zeit vergleichen. Jede gerissene Zeit wird ein Runbook- oder Automatisierungs-Ticket.
  • CVE- und Security-Drills als Tabletop mit Security, Legal und Comms üben: Meldefristen (CRA 24 h, DSGVO 72 h) laufen ab Kenntnis, nicht ab Fix.