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.shGelä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 ollamaAuf 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/versionErwartet (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 1Erwartet (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_LENGTHoderNUM_PARALLEList eine Sizing-Frage (Tag 5). - Drop-ins addieren sich, der alphabetisch letzte gewinnt.
DropInPathsundsystemctl catzeigen 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 2Erwartet:
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 2Zeitlimit: 15 min
Symptome:
./load.sh acme 40 2Erwartet (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 2Erwartet (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 tag11Lessons:
- 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 -1Erwartet:
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 3Zeitlimit: 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-gatewayErwartet (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 -1Ein 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}'
echoErwartet (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 -1Dauerhaft: 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.yamlLä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}'; echoErwartet:
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=120sErwartet:
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 4Zeitlimit: 10 min
Symptome:
sleep 120
kubectl -n llm-system get pods -l app.kubernetes.io/name=slow-modelErwartet (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}'; echoErwartet (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 bereitErwartet (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. Recreateplus kaputtes Upgrade ist ein Totalausfall. Mit freier GPU lieberRollingUpdatemitmaxUnavailable: 0oder 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
doneZeitlimit: 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 -lErwartet (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.yamlErwartet (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}'; echoErwartet (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 denWatchdogals 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 -enddateErwartet (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 -briefnennt 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 7Zeitlimit: 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*' opensslErwartet (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.txtErwartet:
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 -1Szenario: 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 8Zeitlimit: 15 min
Symptome: Kundenticket „Upgrade hängt, ein Pod startet nicht”:
kubectl -n llm-system get pods -l app.kubernetes.io/component=gatewayErwartet (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 .architectureErwartet (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=gatewayDauerhaft: 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 10mErwartet (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.shErwartet:
✔ 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.txtErwartet (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.