Tag 10: SLOs, Alerting und On-Call
Ziel: Du definierst ein SLO für die LLM-API, alarmierst per Multi-Window-Multi-Burn-Rate, beweist die Regeln mit Unit-Tests, routest Alerts nach Schwere und Mandant und lieferst ein Runbook dazu. · Dauer: ca. 150 min · Voraussetzung: Tag 8
Briefing
- SLI = gemessener Anteil guter Ereignisse, SLO = Ziel dafür über ein Zeitfenster, Fehlerbudget = 1 − SLO.
- Alarmiert wird nicht auf „Fehlerquote > X”, sondern darauf, wie schnell das Budget verbrennt (Burn Rate).
- Page nur, wenn ein Mensch jetzt handeln muss. Alles andere wird Ticket.
- Jeder Alert hat ein Runbook (
runbook_url), jede Regel einen Unit-Test.
Burn Rate 14.4 ─┐ 1h UND 5m ──► page ─┐
Burn Rate 6 ──┤ 6h UND 30m ──► page ├─► Alertmanager ─► pager / csm-acme
Burn Rate 3 ──┤ 1d UND 2h ──► ticket │ (Inhibit: page schluckt ticket)
Burn Rate 1 ──┘ 3d UND 6h ──► ticket ─┘ └► ticket
Drill 1: SLIs für eine LLM-API wählen
| SLI | Gut | Gezählt | Quelle |
|---|---|---|---|
| Verfügbarkeit | kein 5xx | alle außer 4xx | gateway_requests_total |
| Latenz (e2e) | Antwort ≤ 10 s | erfolgreiche Anfragen | …_duration_seconds_bucket{le="10"} |
| TTFT (Streaming) | erstes Token ≤ 1 s | alle Anfragen | vllm:time_to_first_token_seconds |
| Durchsatz (optional) | ≥ N Tokens/s | pro Mandant | gateway_tokens_total |
Warum 4xx raus? 401 (falscher Key) und 429 (Mandant über seinem
Limit) sind Client-Verhalten. Zählen sie mit, kann ein Kunde mit
falschem Key dein Budget verbrennen. Achtung: llmctl slo
aus Tag 3 teilt durch alle Anfragen – mit vielen 429
sieht es dort besser aus, als es ist.
mkdir -p ~/sre-lab/tag10 && cd ~/sre-lab/tag10
OBS=~/sre-lab/code/observability
kubectl -n monitoring port-forward svc/kps-kube-prometheus-stack-prometheus \
9090:9090 >/dev/null 2>&1 &
pq() {
curl -s localhost:9090/api/v1/query --data-urlencode "query=$1" | jq -r \
'.data.result[] | "\(.metric | del(.__name__) | tostring) \(.value[1]
| tonumber * 1000 | round / 1000)"'
}
pq 'sum by (tenant) (rate(gateway_request_duration_seconds_bucket{le="10"}[1h]))
/ sum by (tenant) (rate(gateway_request_duration_seconds_count[1h]))'Erwartet (gekürzt, kann je nach Version abweichen):
{"tenant":"acme"} 1
{"tenant":"globex"} 1
Für Non-Streaming hängt die e2e-Latenz an der Antwortlänge. Beim Streaming mit vLLM ist TTFT das bessere Latenz-SLI – das Gateway misst es nicht.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Fehlerbudget rechnen
cat > budget.py <<'EOF'
"""Fehlerbudget und Burn Rates für SLO 99,5 % über 28 Tage."""
slo, days = 0.995, 28
budget = 1 - slo
period_h = days * 24
print(f"Budget: {budget:.3%} = {budget * period_h * 60:.0f} min Ausfall "
f"in {days} Tagen")
print(f"bei 10 req/s: {budget * 10 * period_h * 3600:,.0f} fehlerhafte Anfragen")
print("Burn Fenster Schwelle Budget leer nach Verbrauch im Fenster")
for burn, win_h in [(14.4, 1), (6, 6), (3, 24), (1, 72)]:
empty_h = period_h / burn
used = burn * win_h / period_h
print(f"{burn:>4}x {win_h:>5} h {burn * budget:>8.2%} {empty_h / 24:>9.1f} Tage"
f" {used:>12.1%}")
EOF
python3 budget.pyErwartet:
Budget: 0.500% = 202 min Ausfall in 28 Tagen
bei 10 req/s: 120,960 fehlerhafte Anfragen
Burn Fenster Schwelle Budget leer nach Verbrauch im Fenster
14.4x 1 h 7.20% 1.9 Tage 2.1%
6x 6 h 3.00% 4.7 Tage 5.4%
3x 24 h 1.50% 9.3 Tage 10.7%
1x 72 h 0.50% 28.0 Tage 10.7%
Die Faktoren 14,4/6/3/1 stammen aus dem Google SRE Workbook (Kapitel „Alerting on SLOs”) und sind für 30 Tage gerechnet: 2 %, 5 % und 10 % Budget. Für 28 Tage ergibt dieselbe Rechnung 13,44/5,6/2,8/0,93 – Drill 7 zeigt das an Sloth. Beides ist vertretbar, wichtig ist, dass Team und Kunde dieselbe Zahl kennen.
Fortschritt speichern? Kostenlos registrieren
Drill 3: SLO-Regeln – Recording und Burn-Rate-Alerts
sed -n '1,13p' $OBS/rules/llm-gateway-slo.rules.yaml
docker run --rm -v $OBS/rules:/r -w /r --entrypoint promtool \
prom/prometheus:v3.15.0 check rules llm-gateway-slo.rules.yamlErwartet:
# Tag 10: SLO "Verfügbarkeit 99,5 % / 28 Tage" für das llm-gateway, pro Mandant.
# SLI = Anteil 5xx an allen Anfragen ohne 4xx (401/429 sind Fehler des Clients).
# Fehlerbudget = 1 - 0.995 = 0.005. Burn Rate 1 = Budget ist nach 28 Tagen leer.
groups:
- name: llm-gateway.slo.recording
interval: 30s
rules:
- record: tenant:slo_errors:ratio_rate5m
expr: |
(sum by (tenant) (rate(gateway_requests_total{code=~"5.."}[5m]))
or sum by (tenant) (rate(gateway_requests_total[5m])) * 0)
/ sum by (tenant) (rate(gateway_requests_total{code!~"4.."}[5m]))
- record: tenant:slo_errors:ratio_rate30m
Checking llm-gateway-slo.rules.yaml
SUCCESS: 7 rules found
Warum or … * 0? Ein Mandant ohne einen einzigen 5xx hat
keine 5xx-Zeitreihe. Ohne Trick fehlt seine Quote ganz (Tag 8, Drill 4)
– Dashboards zeigen Lücken statt 0. Sieben Fenster (5m bis 3d) werden
einmal vorberechnet, sonst rechnet jede Alert-Auswertung 3 Tage Rohdaten
neu.
Die Alerts bauen auf diesen Fenstern auf:
sed -n '4,22p' $OBS/rules/llm-gateway-alerts.rules.yamlErwartet:
- name: llm-gateway.slo.alerts
rules:
- alert: LLMGatewayHighErrorRate
expr: |
tenant:slo_errors:ratio_rate1h > (14.4 * 0.005)
and tenant:slo_errors:ratio_rate5m > (14.4 * 0.005)
for: 2m
labels: { severity: page, long_window: 1h }
annotations: &page
summary: "llm-gateway: hohe 5xx-Quote für Mandant {{ $labels.tenant }}"
description: >-
{{ $value | humanizePercentage }} Fehler. Bei diesem Tempo ist das
28-Tage-Fehlerbudget in wenigen Tagen aufgebraucht.
runbook_url: >-
https://runbooks.example.com/llm-gateway/LLMGatewayHighErrorRate
dashboard_url: https://grafana.example.com/d/llm-gateway
- alert: LLMGatewayHighErrorRate
expr: |
tenant:slo_errors:ratio_rate6h > (6 * 0.005)
Warum zwei Fenster? Das lange Fenster (1h) sorgt für Signifikanz, das
kurze (5m) dafür, dass der Alert nach der Behebung schnell wieder
auflöst. Die Datei enthält außerdem
LLMGatewayErrorBudgetBurn (3x/1x, Ticket),
LLMGatewayDown und LLMGatewayHighLatency (p95
> 20 s, Ticket). &page/*page ist ein
YAML-Anker: beide Page-Regeln teilen dieselben Annotations.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Regeln mit promtool unit-testen
Die Testdatei füttert drei Mandanten mit synthetischen Countern: acme 12,5 % Fehler (schneller Burn), globex 2 % (langsamer Burn), initech 0 %.
sed -n '10,21p' $OBS/rules/llm-gateway.test.yaml
grep -c 'eval_time' $OBS/rules/llm-gateway.test.yaml
docker run --rm -v $OBS/rules:/r -w /r --entrypoint promtool \
prom/prometheus:v3.15.0 test rules llm-gateway.test.yamlErwartet:
# acme: 7 rps ok, 1 rps 5xx, 2 rps 429 -> SLI-Fehlerquote 1/8 = 12,5 %
- series: 'gateway_requests_total{tenant="acme",code="200"}'
values: '0+420x240'
- series: 'gateway_requests_total{tenant="acme",code="502"}'
values: '0+60x240'
- series: 'gateway_requests_total{tenant="acme",code="429"}'
values: '0+120x240'
- series: 'gateway_ratelimited_total{tenant="acme"}'
values: '0+120x240'
# globex: 2 % Fehler -> langsamer Burn (nur Ticket)
- series: 'gateway_requests_total{tenant="globex",code="200"}'
values: '0+588x240'
10
SUCCESS
Zehn Prüfungen: sechs Recording-Rule-Werte, vier Alert-Zeitpunkte
(feuert, Ticket statt Page, for noch nicht erfüllt, Gateway
down). '0+420x240' heißt: Start 0, pro Intervall (1m) +420,
240 Mal. Jetzt absichtlich kaputt machen – Schwelle des 1h-Fensters um
Faktor 10 falsch:
cp $OBS/rules/*.yaml .
sed -i.bak 's/ratio_rate1h > (14.4 \* 0.005)/ratio_rate1h > (14.4 * 0.05)/' \
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 -v '^$' | head -4
docker run --rm -v $PWD:/r -w /r --entrypoint promtool \
prom/prometheus:v3.15.0 test rules llm-gateway.test.yaml >/dev/null 2>&1
echo "exit=$?"Erwartet (gekürzt: danach folgen exp mit beiden
Page-Alerts und got nur mit dem 6h-Alert):
FAILED:
alertname: LLMGatewayHighErrorRate, time: 30m,
exp:[
0:
exit=1
Genau diesen Fehler (Faktor 10 im Budget) findet kein Review
zuverlässig – der Test schon. In CI: promtool check rules
und promtool test rules bei jedem Merge.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Regeln und Routing ausrollen
mk_rule() { # Regeldatei -> PrometheusRule-Objekt (wie Tag 8)
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-slo $OBS/rules/llm-gateway-slo.rules.yaml | kubectl apply -f -
mk_rule llm-gateway-alerts $OBS/rules/llm-gateway-alerts.rules.yaml \
| kubectl apply -f -
am() { docker run --rm -v $OBS/alertmanager:/c --entrypoint amtool \
prom/alertmanager:v0.34.1 "$@"; }
am check-config /c/alertmanager.yaml | head -1
am config routes show --config.file=/c/alertmanager.yaml
for l in "severity=page tenant=acme" "severity=ticket tenant=acme" \
"severity=page tenant=globex" "severity=ticket tenant=globex"; do
printf '%-30s -> ' "$l"; am config routes test --config.file=/c/alertmanager.yaml $l
doneErwartet (amtool live, kubectl
gekürzt):
prometheusrule.monitoring.coreos.com/llm-gateway-slo created
prometheusrule.monitoring.coreos.com/llm-gateway-alerts created
Checking '/c/alertmanager.yaml' SUCCESS
Routing tree:
.
└── default-route receiver: ticket
├── {alertname="Watchdog"} receiver: deadmans-switch
├── {alertname="InfoInhibitor"} receiver: null
├── {tenant="acme"} continue: true receiver: csm-acme
├── {severity="page"} receiver: pager
└── default-route receiver: ticket
severity=page tenant=acme -> csm-acme,pager
severity=ticket tenant=acme -> csm-acme,ticket
severity=page tenant=globex -> pager
severity=ticket tenant=globex -> ticket
Warum die leere Route am Ende? Hat eine Route mit
continue: true gepasst, fällt Alertmanager nicht mehr auf
den Root-Receiver zurück. Ohne Catch-all bekäme ein acme-Ticket nur das
CSM-Team zu sehen. Inhibition: Ein Page unterdrückt das Ticket desselben
Mandanten, LLMGatewayDown soll alle anderen Gateway-Alerts
unterdrücken – ob equal: [namespace] dafür wirklich greift,
prüfst du in Tag 15, Drill 5.
Jetzt einen Lab-Empfänger starten und die Config per Helm einspielen:
cat > sink.py <<'EOF'
import http.server, json
class H(http.server.BaseHTTPRequestHandler):
def do_POST(self):
body = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
for a in body["alerts"]:
print(self.path, a["status"], a["labels"].get("alertname"),
a["labels"].get("tenant", "-"), flush=True)
self.send_response(200)
self.end_headers()
http.server.HTTPServer(("", 8080), H).serve_forever()
EOF
kubectl -n monitoring run alert-sink --image=python:3.13-alpine --port=8080 \
--command -- python -u -c "$(cat sink.py)"
kubectl -n monitoring expose pod alert-sink --port=8080
helm upgrade kps prometheus-community/kube-prometheus-stack --version 92.2.0 \
-n monitoring -f $OBS/helm/kps-values.yaml \
-f $OBS/helm/grafana-datasources.yaml -f $OBS/helm/alertmanager-values.yaml --waitalertmanager-values.yaml ist
alertmanager.yaml, eingerückt unter
alertmanager.config. Das Chart hängt selbst
templates: [/etc/alertmanager/config/*.tmpl] an.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Alerts auslösen, unterdrücken, stummschalten
kubectl -n monitoring port-forward svc/kps-kube-prometheus-stack-alertmanager \
9093:9093 >/dev/null 2>&1 &
amk() { # amtool im Alertmanager-Pod gegen die laufende Instanz
kubectl -n monitoring exec alertmanager-kps-kube-prometheus-stack-alertmanager-0 \
-c alertmanager -- amtool --alertmanager.url=http://localhost:9093 "$@"
}
amk alert add alertname=LLMGatewayHighErrorRate severity=page tenant=acme
amk alert add alertname=LLMGatewayErrorBudgetBurn severity=ticket tenant=acme
amk alert add alertname=LLMGatewayHighErrorRate severity=page tenant=globex
amk alert add alertname=LLMGatewayErrorBudgetBurn severity=ticket tenant=initech
sleep 40
kubectl -n monitoring logs alert-sink | grep '^/'
amk alert query --inhibitedErwartet (live gegen Alertmanager 0.34.1):
/page firing LLMGatewayHighErrorRate acme
/csm-acme firing LLMGatewayHighErrorRate acme
/page firing LLMGatewayHighErrorRate globex
/ticket firing LLMGatewayErrorBudgetBurn initech
/heartbeat firing Watchdog -
Alertname Starts At Summary State
LLMGatewayErrorBudgetBurn 2026-10-09 16:38:58 UTC suppressed
Das acme-Ticket ist inhibiert, weil acme schon pagt. Wartung bei globex? Silence mit Ticket-Nummer und Ablaufzeit:
ID=$(amk silence add alertname=LLMGatewayErrorBudgetBurn tenant=globex \
--duration=2h --author=thomas --comment="Wartung globex, Ticket OPS-123")
amk silence query -o json \
| jq -r '.[] | "\(.id[0:8]) \(.endsAt) \(.createdBy): \(.comment)"'
amk silence expire $ID
amk silence query -q | wc -lErwartet (live, ID und Zeit weichen ab):
9101b457 2026-10-09T19:21:04.331Z thomas: Wartung globex, Ticket OPS-123
0
Der echte Test: Modellserver weg, Last drauf, warten. Nach etwa 3–7 min feuert der 1h/5m-Alert:
kubectl -n llm-system scale deploy/ollama --replicas=0 # Variante A, Tag 7
LLMCTL_API_KEY=lab-key-acme llmctl load -n 300 -c 2 >/dev/null
pq 'ALERTS{alertname="LLMGatewayHighErrorRate", alertstate="firing"}'
kubectl -n llm-system scale deploy/ollama --replicas=1Erwartet (gekürzt, kann je nach Version abweichen):
{"alertname":"LLMGatewayHighErrorRate","alertstate":"firing","long_window":"1h",
"severity":"page","tenant":"acme"} 1
Fortschritt speichern? Kostenlos registrieren
Drill 7: Runbook schreiben, SLO-Generatoren kennen
Vorlage: Bedeutung · Auswirkung · Diagnose (je Schritt Befehl +
Erwartung) · Abhilfe · Eskalation · Nachbereitung. Das Runbook liegt im
Git neben den Regeln, die runbook_url zeigt darauf.
mkdir -p runbooks && cat > runbooks/LLMGatewayHighErrorRate.md <<'EOF'
# Runbook: LLMGatewayHighErrorRate
Severity: page | Owner: Plattform-SRE | SLO: 99,5 % Verfügbarkeit / 28 Tage
Dashboard: https://grafana.example.com/d/llm-gateway
## Bedeutung
Die 5xx-Quote eines Mandanten verbrennt das Fehlerbudget mindestens 14,4-fach (1h)
oder 6-fach (6h). Label `tenant` = betroffener Mandant.
## Auswirkung
Kunden des Mandanten bekommen 502/503/504 auf /v1/chat/completions.
## Diagnose
1. Ein oder alle Mandanten? pq 'tenant:slo_errors:ratio_rate5m'
Alle betroffen -> Gateway/Modellserver. Einer -> Mandanten-Last, Quota.
2. Welche Codes? pq 'sum by (code) (rate(gateway_requests_total{code=~"5.."}[5m]))'
502 = Modellserver nicht erreichbar, 503 = überlastet, 504 = Timeout.
3. Pods und Endpoints: kubectl -n llm-system get pods,endpoints -o wide
Erwartet: alle Running/Ready, Endpoints für Gateway und Modellserver.
4. Letzte Änderung? kubectl -n llm-system rollout history deploy/llm-gateway
und Deploy-Markierung im Dashboard.
5. Logs -> Trace (Grafana Explore, Loki):
{app="llm-gateway"} | json | status >= 500 -> "Trace öffnen" -> roter Span?
6. Modellserver: OOMKilled? GPU-Speicher (DCGM_FI_DEV_FB_USED),
Warteschlange (vllm:num_requests_waiting).
## Abhilfe
- Deploy schuld: kubectl -n llm-system rollout undo deploy/llm-gateway
- Überlast: Modellserver skalieren, RATE_LIMIT_RPS des lauten Mandanten senken
- Pod hängt: kubectl -n llm-system delete pod <pod> (Controller startet neu)
- Prüfen: pq 'tenant:slo_errors:ratio_rate5m' fällt unter 0.072
## Eskalation
- Nach 15 min ohne Besserung: Incident ausrufen (Tag 11), Incident Commander holen.
- Premium-Kunde (acme): CSM ist über die Route csm-acme schon informiert.
## Nachbereitung
- Silences nur mit Ticket-ID und Ablaufzeit.
- SEV1/SEV2: Post-Mortem (Tag 11). Dieses Runbook im selben PR anpassen.
EOF
grep -c '^## ' runbooks/LLMGatewayHighErrorRate.mdErwartet:
6
Sloth und Pyrra erzeugen dieselben Regeln aus einer kurzen SLO-Spezifikation. Mit Sloth (Container, keine Installation):
cat > sloth.yaml <<'EOF'
version: "prometheus/v1"
service: "llm-gateway"
slos:
- name: "availability"
objective: 99.5
sli:
events:
error_query: >-
sum by (tenant) (rate(gateway_requests_total{code=~"5.."}[{{.window}}]))
total_query: >-
sum by (tenant) (rate(gateway_requests_total{code!~"4.."}[{{.window}}]))
alerting:
name: LLMGatewaySLOBurn
page_alert: { labels: { severity: page } }
ticket_alert: { labels: { severity: ticket } }
EOF
docker run --rm -v $PWD:/s ghcr.io/slok/sloth:v0.16.0 generate -i /s/sloth.yaml \
--default-slo-period=28d 2>/dev/null > sloth-rules.yaml
grep -c 'record:' sloth-rules.yaml
grep -oE '> \([0-9.]+ \* 0.005\)' sloth-rules.yaml | sort -uErwartet:
15
> (0.9333333333333333 * 0.005)
> (13.44 * 0.005)
> (2.8000000000000003 * 0.005)
> (5.6000000000000005 * 0.005)
Gleiche Fenster wie bei dir, Faktoren exakt für 28 Tage. Pyrra macht
dasselbe als Kubernetes-Operator (CRD
ServiceLevelObjective) mit eigener UI. Handgeschrieben
verstehst du die Regeln – generiert skalieren sie über hunderte
Services.
Fortschritt speichern? Kostenlos registrieren
Drill 8: On-Call-Hygiene
pq 'sort_desc(sum by (alertname, severity)
(count_over_time(ALERTS{alertstate="firing"}[7d])) * 15 / 60)'
cat > handover.txt <<'EOF'
Übergabe On-Call <Datum> von <Name> an <Name>
Offene Incidents: <ID, Status, nächster Schritt>
Aktive Silences: <amtool silence query> (alle mit Ticket + Ablauf?)
Laute Alerts (7 Tage): <Top 3 aus der Abfrage oben> -> Ticket zum Fixen/Löschen
Toil diese Woche: <manuelle Handgriffe, Minuten> -> Automatisierungs-Ticket
Fehlerbudget: <pq 'tenant:slo_errors:ratio_rate1d' je Mandant>
EOFErwartet (gekürzt, kann je nach Version abweichen):
{"alertname":"Watchdog","severity":"none"} 10080
{"alertname":"LLMGatewayHighErrorRate","severity":"page"} 37.5
{"alertname":"KubePodCrashLooping","severity":"warning"} 12
Der Wert ist die Feuerdauer in Minuten (Auswertung alle 15 s). Regeln für die wöchentliche Alert-Review: Jeder Page muss eine Handlung ausgelöst haben, sonst wird er Ticket oder gelöscht. Ziel nach Google SRE: höchstens zwei Incidents pro 12-h-Schicht, Toil unter 50 % der Arbeitszeit.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
OBS=~/sre-lab/code/observability
check "promtool-Tests grün" "docker run --rm -v $OBS/rules:/r -w /r \
--entrypoint promtool prom/prometheus:v3.15.0 test rules llm-gateway.test.yaml"
check "Alertmanager-Config gültig" "docker run --rm -v $OBS/alertmanager:/c \
--entrypoint amtool prom/alertmanager:v0.34.1 check-config /c/alertmanager.yaml"
check "SLO-Regeln geladen" "curl -s localhost:9090/api/v1/rules \
| jq -e '[.data.groups[].name] | index(\"llm-gateway.slo.alerts\")'"
check "Recording Rule liefert" "curl -s localhost:9090/api/v1/query \
--data-urlencode 'query=tenant:slo_errors:ratio_rate1h' \
| jq -e '.data.result | length > 0'"
check "Alertmanager erreichbar" "curl -sf localhost:9093/-/ready"
check "Runbook vollständig" \
"[ \$(grep -c '^## ' ~/sre-lab/tag10/runbooks/LLMGatewayHighErrorRate.md) -eq 6 ]"Challenge
Beweise per Unit-Test, dass globex bei konstant 2 % Fehlern nach 10 Stunden kein Page, aber ein Ticket bekommt.
Hinweis: Eigene Testdatei mit nur globex-Serien;
exp_alerts: [] prüft, dass ein Alert nicht feuert.
Lösung
cat > globex.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: 'gateway_requests_total{tenant="globex",code="200"}'
values: '0+588x600'
- series: 'gateway_requests_total{tenant="globex",code="500"}'
values: '0+12x600'
alert_rule_test:
- eval_time: 10h
alertname: LLMGatewayHighErrorRate
exp_alerts: []
- eval_time: 10h
alertname: LLMGatewayErrorBudgetBurn
exp_alerts:
- exp_labels: { severity: ticket, tenant: globex }
exp_annotations:
summary: "llm-gateway: Fehlerbudget von globex schmilzt"
runbook_url: >-
https://runbooks.example.com/llm-gateway/LLMGatewayErrorBudgetBurn
EOF
cp $OBS/rules/*.rules.yaml .
docker run --rm -v $PWD:/r -w /r --entrypoint promtool \
prom/prometheus:v3.15.0 test rules globex.test.yamlFortschritt speichern? Kostenlos registrieren
Interview-Notiz
- Typische Frage: „Wie würdest du Alerting für unsere Inference-API aufsetzen?” – SLIs aus Kundensicht (Verfügbarkeit ohne 4xx, TTFT), SLO mit dem Produkt abstimmen, Burn-Rate-Alerts, Page nur bei schnellem Burn.
- Knackig: „Ich alarmiere auf Symptome beim Kunden, nicht auf Ursachen wie CPU – Ursachen stehen im Runbook.”
- Rechne live: 99,5 % über 28 Tage sind 202 Minuten; Burn Rate 14,4 leert das Budget in knapp zwei Tagen.
- Brücke aus deiner Praxis: Bei regulierten Kunden mit Vault/OpenBao hast du Betriebsdokumentation und Notfallhandbücher geschrieben – Runbooks mit „Befehl + erwartetes Ergebnis” sind dieselbe Disziplin.
- Regeln sind Code:
promtool test rulesin CI, Alert-Review jede Woche, jeder Page braucht eine Handlung.
Enterprise-Notiz
- SLOs pro Kunde vertraglich (SLA meist lockerer als das interne SLO), Fehlerbudget-Bericht monatlich an Kunde und Produkt.
- Echtes Paging über PagerDuty, Opsgenie oder Grafana IRM; Alertmanager im HA-Cluster (3 Replikas, Gossip).
- Dead Man’s Switch: Der
Watchdog-Alert muss extern ankommen (z. B. Healthchecks.io), sonst merkt niemand, dass Alerting selbst ausgefallen ist. - On-prem beim Kunden: oft deren Alertmanager oder ITSM (ServiceNow). Liefere Regeln, Routing-Vorschlag und Runbooks im Chart mit.
- Follow-the-Sun-Rotation über EMEA/US, klare Eskalationsstufen und Ruhezeiten nach Nacht-Pages.