Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 11: Incident Response und Post-Mortem

Ziel: Einen echten Incident am Gateway auslösen, nach Rollen abarbeiten, mit Kunden kommunizieren und ein blameless Post-Mortem mit Action Items schreiben. · Dauer: ca. 150 min · Voraussetzung: Tag 10

Briefing

  • Erst mitigieren, dann verstehen. Rollback, Limit oder Failover kommen vor der Ursachensuche.
  • Vier Rollen: Der Incident Commander (IC) entscheidet und koordiniert, tippt aber nicht. Der Ops Lead arbeitet am System. Comms schreibt Status-Page und Kunden-Updates. Der Scribe führt die Timeline.
  • Alles kommt mit UTC-Zeitstempel in ein Dokument. Kunden-Updates gehen in festen Abständen raus, auch wenn es nichts Neues gibt.
  • Post-Mortems sind blameless: Du fragst nach Systemen und Prozessen, nie nach Schuldigen.
Detect -> Triage/Declare -> Mitigate -> Resolve -> Post-Mortem -> Action Items
  |           |               |           |            |              |
 Alert     SEV + IC      Rollback/Limit  Monitoring   blameless    Owner + Due

Drill 1: Gelände – Fake-Modellserver mit vier Slots

Der Fake-Server verhält sich wie eine GPU mit 4 parallelen Generierungen. Jede Antwort dauert 0,5 s, die Kapazität liegt also bei etwa 8 Anfragen pro Sekunde. Wer länger als 2 s auf einen Slot wartet, bekommt 503 server busy.

mkdir -p ~/sre-lab/tag11 && cd ~/sre-lab/tag11
cat > fake_upstream.py <<'EOF'
"""Fake-Modellserver für Tag 11: OpenAI-kompatibel, begrenzte Slots wie eine GPU."""
import json
import os
import threading
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

SLOTS = int(os.environ.get("SLOTS", "4"))           # parallele Generierungen
DELAY = float(os.environ.get("DELAY", "0.5"))       # Sekunden pro Antwort
QUEUE_WAIT = float(os.environ.get("QUEUE_WAIT", "2"))  # max. Wartezeit auf Slot
sem = threading.BoundedSemaphore(SLOTS)


class Handler(BaseHTTPRequestHandler):
    def send(self, code, obj):
        body = json.dumps(obj).encode()
        self.send_response(code)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

    def do_GET(self):
        if self.path == "/v1/models":
            return self.send(200, {"data": [{"id": "mistral-fake"}]})
        self.send(404, {"error": "not found"})

    def do_POST(self):
        self.rfile.read(int(self.headers.get("Content-Length", 0)))
        if not sem.acquire(timeout=QUEUE_WAIT):
            return self.send(503, {"error": "server busy"})
        try:
            time.sleep(DELAY)
        finally:
            sem.release()
        self.send(200, {
            "choices": [{"message": {"role": "assistant", "content": "ok"}}],
            "usage": {"prompt_tokens": 12, "completion_tokens": 30},
        })

    def log_message(self, *args):
        pass


ThreadingHTTPServer(("0.0.0.0", 11434), Handler).serve_forever()
EOF
docker network create tag11
docker run -d --name fake-llm --network tag11 \
  -v "$PWD/fake_upstream.py:/app.py:ro" python:3.13-alpine python -u /app.py

Das Start-Skript sichert vor jedem Neustart die Logs des alten Containers. Ohne diese Sicherung wären die Beweise nach dem Rollback weg.

cat > gw-start.sh <<'EOF'
#!/usr/bin/env bash
# Startet das Gateway neu (Lab-Keys!). Sichert vorher die Logs des alten Containers.
if docker inspect gw >/dev/null 2>&1; then
  docker logs gw > "gw-$(date -u +%H%M%S).log" 2>&1
  docker rm -f gw >/dev/null                   # harter Neustart, schnell
fi
docker run -d --name gw --network tag11 -p 8080:8080 \
  -e UPSTREAM_URL=http://fake-llm:11434 \
  -e TENANT_KEYS="acme:lab-key-acme,globex:lab-key-globex" \
  -e RATE_LIMIT_RPS="${RPS:-5}" -e RATE_LIMIT_BURST="${BURST:-10}" \
  llm-gateway:dev >/dev/null
sleep 1
echo "gw: rps=${RPS:-5} burst=${BURST:-10} ready=$(curl -s localhost:8080/readyz)"
EOF
cat > load.sh <<'EOF'
#!/usr/bin/env bash
# load.sh <tenant> <anzahl> <parallel> -> Statuscodes und p50/p95 in Sekunden
T=$1; N=${2:-20}; P=${3:-2}
seq "$N" | xargs -P "$P" -I{} curl -s -o /dev/null -m 10 \
  -w '%{http_code} %{time_total}\n' \
  -H "Authorization: Bearer lab-key-$T" -H 'Content-Type: application/json' \
  -d '{"model":"mistral-fake","messages":[{"role":"user","content":"hi"}]}' \
  localhost:8080/v1/chat/completions > "load-$T.txt"
echo "== $T: $(awk '{print $1}' "load-$T.txt" | sort | uniq -c | xargs)"
sort -n -k2 "load-$T.txt" | LC_ALL=C awk '{a[NR]=$2} END {
  printf "p50=%.2fs p95=%.2fs\n", a[int(NR*0.5)], a[int(NR*0.95)] }'
EOF
chmod +x gw-start.sh load.sh
./gw-start.sh
./load.sh acme 20 2

Erwartet:

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

Warum? Das ist deine Baseline. Ohne „normal” erkennst du „kaputt” nicht. acme schickt 2 parallele Anfragen, das sind etwa 4 pro Sekunde und damit weniger als das Limit von 5.

Tipp: Mit llmctl load aus Tag 3 bekommst du dieselben Zahlen plus p99. load.sh reicht hier und braucht nur curl.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Rollen, Severity und Timeline-Werkzeug

Lege die Severity fest, bevor der Pager klingelt. Im Zweifel stufst du höher ein und später wieder herunter.

SEV Kriterium Beispiel Reaktion
SEV1 Alle Mandanten down, Datenleck, Sicherheitsvorfall API liefert nur 5xx Sofort-Page, IC Pflicht, Status-Page ≤ 15 min, Updates 30 min
SEV2 Ein Mandant stark betroffen oder SLO-Burn kritisch acme 50 % Fehler Page, IC Pflicht, Status-Page ≤ 30 min, Updates 60 min
SEV3 Spürbar langsamer, SLO hält noch p95 doppelt so hoch Ticket mit Priorität, Fix im Arbeitstag
SEV4 Kein Kundenimpact Dashboard-Panel leer Ticket, Backlog

Der Scribe braucht ein Werkzeug, das in 2 Sekunden einen Eintrag schreibt. tl hängt eine Tabellenzeile mit UTC-Zeit an incident.md an.

cat > tl <<'EOF'
#!/usr/bin/env bash
# tl "Text" -> hängt eine Zeile mit UTC-Zeit und Autor an die Timeline an
f=${INCIDENT_FILE:-incident.md}
[ $# -gt 0 ] || { echo "usage: tl <text>" >&2; exit 1; }
msg=${*//|/\\|}                       # Pipe würde die Tabelle zerbrechen
printf '| %s | %s | %s |\n' "$(date -u +%H:%M:%S)" "${WHO:-$USER}" "$msg" >> "$f"
tail -1 "$f"
EOF
chmod +x tl
cat > incident.md <<'EOF'
# INC-2026-1009-01: acme bekommt 503 vom Gateway

- Severity: SEV2 · Status: investigating
- IC: thomas · Ops Lead: thomas · Comms: thomas · Scribe: tl

## Timeline (UTC)

| Zeit | Wer | Ereignis |
|---|---|---|
EOF
export WHO=thomas PATH="$PWD:$PATH"
tl "Timeline angelegt"

Erwartet (Zeit variiert):

| 16:24:30 | thomas | Timeline angelegt |

Warum? Eine Timeline, die du erst nach dem Incident aus dem Gedächtnis schreibst, ist falsch. Im Lab spielst du alle vier Rollen. In echt trennst du IC und Ops Lead immer, sobald zwei Leute da sind.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Störung auslösen, erkennen, einstufen

Der Change CHG-4711 hebt das Rate-Limit an, „damit der Batch-Job von globex schneller durchläuft”. Danach startet globex den Batch mit 40 parallelen Anfragen.

RPS=50 BURST=100 ./gw-start.sh
tl "CHG-4711 live: RPS 5->50, BURST 10->100 (globex-Batch)"
./load.sh globex 600 40 > globex.out 2>&1 &     # Batch läuft ca. 60 s
sleep 3
./load.sh acme 20 2                              # Probe aus Sicht von acme

Erwartet (die Fehlerquote schwankt je nach Timing zwischen 40 und 80 %):

gw: rps=50 burst=100 ready=ok
| 16:24:49 | thomas | CHG-4711 live: RPS 5->50, BURST 10->100 (globex-Batch) |
== acme: 10 200 10 503
p50=2.02s p95=2.50s

acme hat nichts geändert und bekommt trotzdem 50 % Fehler, und die Latenz hat sich vervierfacht. Jetzt eingrenzen: welcher Mandant, welcher Code, was hat sich geändert?

cat > impact.sh <<'EOF'
#!/usr/bin/env bash
# impact.sh [metrics-datei] -> Anfragen, 5xx, 429 und Fehlerquote pro Mandant
if [ -n "$1" ]; then cat "$1"; else curl -s localhost:8080/metrics; fi |
LC_ALL=C awk -F'[{}" ]+' '/^gateway_requests_total\{/ {
  code=$3; t=$5; n=$NF; all[t]+=n
  if (code ~ /^5/) err[t]+=n; if (code == 429) rl[t]+=n }
  END { for (t in all) printf "%-7s total=%-4d 5xx=%-4d 429=%-4d err=%.1f%%\n",
        t, all[t], err[t], rl[t], 100*err[t]/all[t] }'
EOF
chmod +x impact.sh
./impact.sh
docker logs gw 2>&1 | jq -r 'select(.status>=500) | "\(.tenant) \(.status)"' \
  | sort | uniq -c
docker inspect gw --format '{{range .Config.Env}}{{println .}}{{end}}' | grep RATE
tl "acme ~50% 503, p50 2s (Baseline 0.5s), globex auch 503. SEV2, IC thomas"

Erwartet (gekürzt, Zahlen schwanken):

globex  total=444  5xx=254  429=0    err=57.2%
acme    total=20   5xx=10   429=0    err=50.0%
  10 acme 503
 254 globex 503
RATE_LIMIT_RPS=50
RATE_LIMIT_BURST=100

Warum? Die 503 kommen vom Modellserver („server busy”) und werden durchgereicht. Vereinzelte 502 bei globex sind möglich: Dann läuft der Verbindungs-Backlog des Fake-Servers über. Kein Mandant hat 429 bekommen, das Gateway hat also alles durchgelassen. grep RATE statt der ganzen Env-Liste ist Absicht: TENANT_KEYS gehört nicht in Chat oder Ticket.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Mitigation zuerst – Beweise sichern, Rollback, verifizieren

Der IC entscheidet: CHG-4711 zurückrollen. Die Ursache ist noch nicht bewiesen, aber der Rollback ist billig und reversibel. Vorher sicherst du die Metriken in einer Sekunde.

curl -s localhost:8080/metrics > metrics-incident.txt
tl "IC: Rollback CHG-4711 (RPS 50->5). Metriken gesichert"
./gw-start.sh                                    # Defaults: RPS=5, BURST=10
tl "Rollback fertig"
./load.sh acme 20 2
tl "Verifikation: acme 20/20 200, p50 0.5s. Status: monitoring"

Erwartet:

gw: rps=5 burst=10 ready=ok
== acme: 20 200
p50=0.58s p95=1.83s

Das p95 ist noch erhöht, solange der Batch läuft: globex darf jetzt 5 req/s, acme schickt 4 req/s. Zusammen sind das 9 req/s, und das ist schon mehr als die 8 req/s Kapazität. Merk dir das für das Post-Mortem.

wait; cat globex.out                             # Batch-Ergebnis von globex
ls gw-*.log metrics-incident.txt

Erwartet (gekürzt):

== globex: 144 000 198 200 8 502 250 503
p50=2.07s p95=3.17s
gw-163218.log  gw-163253.log  metrics-incident.txt

Warum? Die 000 sind Verbindungsabbrüche während des Neustarts. Ein Rollback per Container-Neustart hat eine Lücke. In Kubernetes macht das ein Rolling Update (Tag 7) ohne diese Lücke. Nach dem Rollback bekommt globex 429 statt 503. Das Gateway schützt die gemeinsame Kapazität wieder.

Achtung: Erst wenn die Mitigation wirkt, fängst du mit der Ursachenanalyse an. Der häufigste Fehler im Incident: 40 Minuten Debugging bei laufendem Schaden.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Kundenkommunikation – Status-Page und Updates

Kunden sind international, deshalb schreibst du Englisch. Bereite die Vorlagen vor dem Incident vor. Comms füllt im Ernstfall nur noch die Lücken.

cat > comms.md <<'EOF'
## Initial (within 30 min of declaring SEV2)
[Investigating] Elevated error rates on the Chat Completions API
We are seeing elevated error rates (HTTP 503) and increased latency for some
customers using the Chat Completions API since 14:05 UTC. Our engineers are
investigating. Next update by 15:00 UTC or earlier.

## Update
[Identified] Elevated error rates on the Chat Completions API
We identified a configuration change that allowed excessive load on a shared
model server. We rolled back the change at 14:29 UTC. Error rates are back to
normal and we are monitoring. Next update by 15:30 UTC.

## Resolved
[Resolved] Elevated error rates on the Chat Completions API
Between 14:05 and 14:29 UTC, about 50% of Chat Completions requests for affected
customers failed with HTTP 503, and median latency rose from 0.5 s to 2.0 s.
The cause was a configuration change, which we rolled back. No data was lost or
exposed. Requests that failed can be retried safely. A post-incident report
will follow within 5 business days.
EOF
grep -c '^\[' comms.md
tl "Comms: Initial-Update auf Status-Page veröffentlicht"

Erwartet:

3

Regeln für Kunden-Updates:

  • Was der Kunde merkt (Symptom, seit wann, welche API), nicht was intern kaputt ist.
  • Immer eine Zeit für das nächste Update nennen und einhalten.
  • Keine Spekulation über Ursachen, keine Namen von anderen Kunden („a shared model server”, nicht „globex”).
  • Im Resolved-Update: Zeitraum, Ausmaß in Zahlen, Datenverlust ja/nein, Retry sicher ja/nein.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Das blameless Post-Mortem

Ein Post-Mortem beantwortet: Was ist passiert? Wie schlimm war es? Warum konnte es passieren? Was ändern wir? Die Zahlen unten stammen aus deiner Simulation. Die Zeiten sind auf eine echte Produktionsdauer (24 Minuten) gestreckt.

cat > postmortem.md <<'EOF'
# Post-Mortem INC-2026-1009-01: 503 errors on Chat Completions

- Status: final · Severity: SEV2 · Date: 2026-10-08
- Authors: Thomas Zachmann · Reviewers: platform team
- Blameless: this document describes systems and processes, not people.

## Summary
A rate-limit change (CHG-4711) let one tenant's batch job send more traffic than the
shared model server can serve. The model server rejected the excess with HTTP 503,
which hit all tenants on that server. A rollback ended the impact after 24 minutes.

## Impact
- Duration: 14:05 to 14:29 UTC (24 min).
- Tenant acme: 50.0% of requests failed (HTTP 503), about 1,870 of 3,740.
- Tenant acme: median latency 0.51 s -> 2.02 s, p95 2.50 s.
- Tenant globex: 57.2% of batch requests failed (HTTP 503).
- Error budget acme (99.5% / 28 days): 5.5% used in this incident.
- No data loss, no data exposure between tenants.

## Detection
The burn-rate alert LLMGatewayHighErrorRate (Day 10) fired at 14:11 UTC, 6 minutes
after impact started. No customer reported the issue before the status page update.
EOF
cat >> postmortem.md <<'EOF'

## Timeline (UTC)
| Time | Event |
|---|---|
| 14:02 | CHG-4711 deployed: RATE_LIMIT_RPS 5 -> 50, BURST 10 -> 100 |
| 14:05 | globex batch job starts with 40 parallel requests. Impact starts |
| 14:11 | LLMGatewayHighErrorRate fires, on-call acknowledges |
| 14:14 | SEV2 declared, IC assigned, incident channel opened |
| 14:19 | Initial status page update |
| 14:24 | Correlation with CHG-4711 found via container config |
| 14:27 | IC decides rollback of CHG-4711 |
| 14:29 | Rollback complete, acme error rate 0%. Impact ends |
| 14:49 | Status page update: identified, monitoring |
| 15:05 | Resolved after 30 min clean monitoring |

## Root cause and contributing factors
Root cause: the gateway's only admission control is a per-tenant rate limit. Nothing
limits the total traffic to the shared model server (4 slots, about 8 req/s).
CHG-4711 allowed one tenant 50 req/s, six times the total capacity.

Contributing factors:
- The change process has no capacity check for limit changes.
- RATE_LIMIT_RPS applies to all tenants. The change meant for globex raised every
  tenant's limit.
- The gateway passes upstream 503 through without Retry-After.
- Deployments are not marked in Grafana. Correlating the change took 10 minutes.
- The lab-style rollback (restart) dropped 152 in-flight globex requests.
EOF
cat >> postmortem.md <<'EOF'

## What went well
- The burn-rate alert detected the impact within 6 minutes.
- The rollback was a one-line config change and took 2 minutes.
- Logs and metrics were saved before the rollback.

## What went badly
- Nobody load-tested the new limit against the model server capacity.
- The first status page update came 14 minutes after the alert.

## Where we got lucky
- The batch job ran during low traffic. At peak, all tenants would have hit 503.

## Action items
| ID | Action | Owner / Prio | Due / Status |
|---|---|---|---|
| AI-1 | Gateway: global in-flight limit | thomas / P1 | 2026-10-22 / open |
| AI-2 | Per-tenant rate limits | thomas / P1 | 2026-10-22 / open |
| AI-3 | CI check: sum of limits <= capacity | platform / P2 | 2026-11-05 / open |
| AI-4 | Deploy annotations in Grafana (Day 8) | obs / P2 | 2026-10-15 / done |
| AI-5 | Status page template prefilled from alert | sre / P3 | 2026-11-30 / open |
EOF
wc -l postmortem.md

Erwartet:

      70 postmortem.md

Warum? „Root cause” plus „Contributing factors” ist ehrlicher als eine einzige Ursache. Der Abschnitt „Where we got lucky” zeigt Risiken, die diesmal nicht eingetreten sind.

Fortschritt speichern? Kostenlos registrieren

Drill 7: 5 Whys gegen Contributing Factors

5 Whys erzwingt eine einzige Kette. Das ist gut für den Einstieg, aber gefährlich:

Warum 503 für acme?          Modellserver voll.
Warum voll?                  globex schickte 40 parallele Anfragen.
Warum kam das durch?         Rate-Limit war 50 statt 5.
Warum 50?                    CHG-4711.
Warum ging CHG-4711 durch?   Kein Kapazitäts-Check im Change-Prozess.

Die Kette endet beim Change-Prozess. Hättest du bei „Warum 50?” mit „Person X hat sich vertan” aufgehört, wäre das Ergebnis Schuld statt Lernen. Gleich gefährlich ist, was die Kette weglässt: Das globale RATE_LIMIT_RPS, das fehlende 503-Retry-After und die fehlenden Deploy-Marker kommen in einer einzigen Kette nicht vor. Deshalb nimmst du im Post-Mortem die Liste der Contributing Factors. Jeder Faktor hat ein Action Item oder eine bewusste Entscheidung „akzeptiert, weil …“.

Prüfe dein Post-Mortem auf Schuld-Sprache und auf fehlende Zahlen:

grep -niwE 'should have|careless|mistake|blame|human error' postmortem.md \
  && echo "✘ Schuld-Sprache gefunden" || echo "✔ keine Schuld-Sprache"
grep -cE '[0-9]+(\.[0-9]+)?( ?%| s| min| req/s)' postmortem.md

Erwartet:

✔ keine Schuld-Sprache
15

Warum? „Human error” ist nie eine Root Cause, sondern ein Symptom: Das System hat den Fehler zugelassen. Die Zahl zeigt, wie viele Zeilen Messwerte enthalten. Ein Post-Mortem ohne Zahlen ist eine Meinung.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Action Items verfolgen und Review-Meeting

Action Items ohne Owner und Datum werden nie erledigt. Dieses Skript listet offene und überfällige Items, zum Beispiel für das wöchentliche Ops-Review.

cat > ai-status.sh <<'EOF'
#!/usr/bin/env bash
# ai-status.sh <postmortem.md> [stichtag YYYY-MM-DD] -> offene/überfällige Items
today=${2:-$(date -u +%F)}
LC_ALL=C awk -F' *\\| *' -v today="$today" '$2 ~ /^AI-[0-9]+$/ {
  split($5, d, " / "); due=d[1]; st=d[2]
  if (st == "done") { done++; next }
  open++; flag = (due < today) ? "OVERDUE" : "open"
  printf "%-7s %-5s %-11s %s\n", flag, $2, due, $3 }
  END { printf "open=%d done=%d\n", open, done }' "$1"
EOF
chmod +x ai-status.sh
./ai-status.sh postmortem.md
./ai-status.sh postmortem.md 2026-10-30

Erwartet:

open    AI-1  2026-10-22  Gateway: global in-flight limit
open    AI-2  2026-10-22  Per-tenant rate limits
open    AI-3  2026-11-05  CI check: sum of limits <= capacity
open    AI-5  2026-11-30  Status page template prefilled from alert
open=4 done=1
OVERDUE AI-1  2026-10-22  Gateway: global in-flight limit
OVERDUE AI-2  2026-10-22  Per-tenant rate limits
open    AI-3  2026-11-05  CI check: sum of limits <= capacity
open    AI-5  2026-11-30  Status page template prefilled from alert
open=4 done=1

In echt stehen Action Items im Ticketsystem (Jira, GitLab Issues), und das Post-Mortem verlinkt sie. Die Tabelle ist nur der Index.

Review-Meeting (45 min, innerhalb von 5 Arbeitstagen):

  • 5 min: Autor liest Summary und Impact vor. Alle haben das Dokument vorher gelesen.
  • 15 min: Timeline durchgehen. Wo haben wir Zeit verloren (hier: 14 min bis zur Status-Page, 10 min bis zur Korrelation)?
  • 15 min: Contributing Factors und Action Items. Jedes Item bekommt Owner, Priorität, Datum.
  • 10 min: Was lernen andere Teams daraus? Danach das Post-Mortem breit teilen.
  • Moderation durch jemanden, der nicht am Incident beteiligt war.

Schreibregeln für Runbooks und Post-Mortems:

  • Kurze Sätze im Aktiv: „Rolle CHG-4711 zurück”, nicht „Es sollte zurückgerollt werden”.
  • Zahlen statt Adjektive: „50 % 503 für 24 min”, nicht „viele Fehler”.
  • Zeiten immer in UTC, Befehle zum Kopieren, und der erwartete Output gehört dazu.
  • Summary zuerst. Wer nur 3 Sätze liest, muss trotzdem Bescheid wissen.
  • Ein Runbook-Schritt ist eine Aktion plus ein Prüfbefehl.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

cd ~/sre-lab/tag11
[ "$(grep -c '^| [0-9][0-9]:' incident.md)" -ge 5 ] \
  && echo "✔ Timeline mit ≥ 5 Einträgen" || echo "✘ Timeline zu kurz"
for s in Summary Impact Timeline 'Root cause' 'Action items'; do
  grep -q "^## $s" postmortem.md && echo "✔ PM: $s" || echo "✘ PM: $s fehlt"
done
awk -F' *\\| *' '$2 ~ /^AI-/ && ($4 !~ / \/ P[1-3]$/ || $5 !~ /^20[0-9-]+ \//)' \
  postmortem.md | grep -q . && echo "✘ Action Item ohne Owner/Due" \
  || echo "✔ alle Action Items mit Owner, Prio, Due"
./load.sh acme 20 2 | grep -q '== acme: 20 200' \
  && echo "✔ acme wieder gesund" || echo "✘ acme hat noch Fehler"

Erwartet:

✔ Timeline mit ≥ 5 Einträgen
✔ PM: Summary
✔ PM: Impact
✔ PM: Timeline
✔ PM: Root cause
✔ PM: Action items
✔ alle Action Items mit Owner, Prio, Due
✔ acme wieder gesund

Challenge

Stoppe den Modellserver (docker stop fake-llm). Arbeite den Incident in einer zweiten Datei incident-2.md ab: Symptom messen, SEV festlegen, Initial-Update schreiben, mitigieren, verifizieren. Am Ende hat die Timeline mindestens 5 Einträge.

Hinweis: INCIDENT_FILE lenkt tl auf eine andere Datei, und /readyz sagt dir, ob das Gateway den Upstream noch erreicht.

Lösung

cd ~/sre-lab/tag11
export INCIDENT_FILE=incident-2.md
printf '# INC-2026-1009-02: Modellserver down\n\n| Zeit | Wer | Ereignis |\n' \
  > incident-2.md
printf '|---|---|---|\n' >> incident-2.md
docker stop fake-llm
./load.sh acme 10 2; curl -s localhost:8080/readyz
tl "acme 100% 502, readyz: upstream not ready. SEV1 (alle Mandanten), IC thomas"
tl "Comms: Initial-Update 'Chat Completions API unavailable' veröffentlicht"
docker start fake-llm
until curl -sf localhost:8080/readyz; do sleep 1; done
tl "Mitigation: fake-llm neu gestartet, readyz ok"
./load.sh acme 10 2
tl "Verifikation: acme 10/10 200. Status: monitoring"
tl "Resolved (im Lab ohne die üblichen 30 min Monitoring)"
grep -c '^| [0-9]' incident-2.md

Erwartet:

== acme: 10 502
p50=0.08s p95=0.52s
upstream not ready
...
ok
== acme: 10 200
p50=0.54s p95=0.55s
5

Warum 502 statt 503? Der Server ist weg, die Verbindung scheitert, und der ErrorHandler im Gateway antwortet mit 502. SEV1, weil jeder Mandant betroffen ist.

Aufräumen:

docker rm -f gw fake-llm && docker network rm tag11

Fortschritt speichern? Kostenlos registrieren

Interview-Notiz

  • Typische Frage: „Walk me through an incident you led.” Antworte in der Reihenfolge Detect, Mitigate, Communicate, Learn, mit Zahlen (Dauer, Fehlerquote, Kunden).
  • Knackige Antwort zu Prioritäten: „Mitigation before root cause. I’ll roll back a suspicious change even before I can prove it caused the issue, if rollback is cheap.”
  • Blameless erklärst du so: „If one person’s mistake can cause an outage, the system allowed it. The action item fixes the system.”
  • Brücke aus deiner Praxis: ein Vault/OpenBao-Ausfall (Seal, Raft-Quorum, abgelaufene Tokens), bei dem viele Teams gleichzeitig betroffen waren, und wie du Kommunikation und Fix getrennt hast.
  • Zeige Schreibstärke: Biete an, ein anonymisiertes Post-Mortem oder Runbook als Arbeitsprobe mitzubringen.

Enterprise-Notiz

  • Beim Kunden on-prem hast du oft keinen Zugang zu den Systemen. Das Runbook muss so geschrieben sein, dass der Kunde selbst Diagnose-Befehle ausführt und dir den Output schickt (Support-Bundle, Tag 14).
  • Verträge legen Reaktionszeiten pro Severity fest. Deine SEV-Matrix muss zu den SLA-Klauseln passen, sonst streitest du nach dem Incident über Definitionen.
  • Bei Security-Incidents (Datenleck zwischen Mandanten) gelten Meldefristen, z. B. 72 h nach DSGVO Art. 33 und NIS2. Legal und DPO gehören dann sofort in den Kanal.
  • Post-Mortems für Kunden sind eine eigene, gekürzte Fassung: ohne interne Namen, ohne Namen anderer Kunden, mit klaren Zusagen.
  • Werkzeuge: incident.io, PagerDuty, Grafana IRM oder FireHydrant erzeugen Kanal, Rollen und Timeline automatisch. Die Prinzipien aus diesem Kapitel bleiben gleich.