Zum Inhalt springen
Trainingslager IT-Trainingslager

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

Erwartet:

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

Erwartet:

# 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.yaml

Erwartet:

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

Erwartet:

      # 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
done

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

alertmanager-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 --inhibited

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

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

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

Erwartet:

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

Erwartet:

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

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

Fortschritt 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 rules in 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.