Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 12: SLOs und Burn-Rate-Alarme

Ziel: Ein Service Level Objective für notes-api, ein Fehlerbudget, das du ausrechnen kannst, und Alarme, die nach Verbrauch des Budgets auslösen statt nach festen Schwellen. · Dauer: ca. 75 min · Voraussetzung: Tag 11

Briefing

  • Ein SLI (Service Level Indicator) misst, was Nutzer spüren – etwa den Anteil erfolgreicher Anfragen. Ein SLO (Objective) ist das Ziel dafür: „99,5 Prozent der Anfragen an /notes gelingen, gemessen über 30 Tage.“
  • Die fehlenden 0,5 Prozent sind das Fehlerbudget. Von 1000 Anfragen dürfen fünf scheitern, ohne dass das Ziel reißt. Das Budget darf verbraucht werden – für Deployments, Experimente, Pech.
  • Die Burn Rate sagt, wie schnell das Budget schmilzt. Burn Rate 1 heißt: Am Ende der 30 Tage ist es genau aufgebraucht. Burn Rate 14,4 heißt: In zwei Tagen ist es weg.
  • Gute SLO-Alarme prüfen zwei Fenster gleichzeitig: ein langes, damit ein kurzer Schluckauf nicht weckt, und ein kurzes, damit der Alarm endet, sobald das Problem vorbei ist.
 Fehlerquote ──► ÷ 0,005 (Budget) ──► Burn Rate
                                       > 14,4 in 1 h und 5 min  ──► critical (Pager)
                                       > 6    in 6 h und 30 min ──► warning  (Ticket)

Drill 1: Das SLI

promtool query instant http://localhost:30090 '
  sum(rate(notes_http_requests_total{path="/notes",code=~"5.."}[5m]))
    / sum(rate(notes_http_requests_total{path="/notes"}[5m]))'

Erwartet: keine Ausgabe. Steht dort eine kleine Zahl, wirken die Fehler aus der Challenge von Tag 11 noch nach – warte fünf Minuten und frag noch einmal.

Ohne Fehler gibt es keine Zeitreihe mit code=~"5..". Die Summe über nichts ist nichts, und nichts geteilt durch etwas bleibt nichts. Für ein SLI ist das falsch – es soll 0 heißen. or vector(0) setzt eine 0 ein, wenn die linke Seite leer ist:

promtool query instant http://localhost:30090 '
  (sum(rate(notes_http_requests_total{path="/notes",code=~"5.."}[5m])) or vector(0))
    / sum(rate(notes_http_requests_total{path="/notes"}[5m]))'

Erwartet:

{} => 0 @[...]
  • path="/notes": Das SLO gilt für das, was Nutzer aufrufen. /healthz und /metrics würden die Quote schönrechnen.
  • Gezählt werden nur Serverfehler. Ein 401 ohne API-Key ist kein Versagen von notes-api, sondern ein Fehler des Aufrufers.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Regeln für alle Fenster

Die Burn-Rate-Alarme brauchen die Fehlerquote über vier Zeiträume. Jeder bekommt eine Recording Rule, die Alarme bauen darauf auf:

cd ~/obs-lab
cat > notes-slo.yaml <<'EOF'
apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: notes-api-slo
  namespace: app
spec:
  groups:
    - name: notes-api.slo
      interval: 30s
      rules:
        - record: notes:sli_errors:ratio_rate5m
          expr: |
            (sum(rate(notes_http_requests_total{path="/notes",code=~"5.."}[5m]))
               or vector(0))
              / sum(rate(notes_http_requests_total{path="/notes"}[5m]))
        - record: notes:sli_errors:ratio_rate30m
          expr: |
            (sum(rate(notes_http_requests_total{path="/notes",code=~"5.."}[30m]))
               or vector(0))
              / sum(rate(notes_http_requests_total{path="/notes"}[30m]))
        - record: notes:sli_errors:ratio_rate1h
          expr: |
            (sum(rate(notes_http_requests_total{path="/notes",code=~"5.."}[1h]))
               or vector(0))
              / sum(rate(notes_http_requests_total{path="/notes"}[1h]))
        - record: notes:sli_errors:ratio_rate6h
          expr: |
            (sum(rate(notes_http_requests_total{path="/notes",code=~"5.."}[6h]))
               or vector(0))
              / sum(rate(notes_http_requests_total{path="/notes"}[6h]))
        - alert: NotesSloFastBurn
          expr: |
            notes:sli_errors:ratio_rate1h > (14.4 * 0.005)
              and notes:sli_errors:ratio_rate5m > (14.4 * 0.005)
          for: 2m
          labels:
            severity: critical
            namespace: app
          annotations:
            summary: "notes-api verbrennt das Fehlerbudget 14-mal zu schnell"
        - alert: NotesSloSlowBurn
          expr: |
            notes:sli_errors:ratio_rate6h > (6 * 0.005)
              and notes:sli_errors:ratio_rate30m > (6 * 0.005)
          for: 15m
          labels:
            severity: warning
            namespace: app
          annotations:
            summary: "notes-api verbrennt das Fehlerbudget 6-mal zu schnell"
EOF
kubectl apply -f notes-slo.yaml

Erwartet:

prometheusrule.monitoring.coreos.com/notes-api-slo created
  • 0.005 ist das Fehlerbudget eines SLO von 99,5 Prozent. 14.4 * 0.005 = 7,2 Prozent Fehlerquote – bei diesem Tempo wären 2 Prozent des Monatsbudgets in einer Stunde weg.
  • FastBurn fängt Ausfälle: Fehlerquote über 7,2 Prozent in der letzten Stunde und in den letzten fünf Minuten. Das kurze Fenster lässt den Alarm schnell erlöschen, wenn das Problem behoben ist.
  • SlowBurn fängt schleichenden Verschleiß: über 3 Prozent in sechs Stunden und in 30 Minuten. Das geht in ein Ticket, nicht an den Pager.
  • Die Faktoren 14,4 und 6 stammen aus dem SRE Workbook von Google, Kapitel „Alerting on SLOs“. Sie sind ein bewährter Startpunkt, kein Naturgesetz.

Nach zwei Minuten:

promtool query instant http://localhost:30090 '{__name__=~"notes:sli_errors:.*"}'

Erwartet (die Reihenfolge wechselt):

notes:sli_errors:ratio_rate5m => 0 @[...]
notes:sli_errors:ratio_rate30m => 0.013521214149718465 @[...]
notes:sli_errors:ratio_rate1h => 0.013521214149718465 @[...]
notes:sli_errors:ratio_rate6h => 0.013521214149718465 @[...]

Die langen Fenster sind nicht 0: Sie erinnern sich an die Störungen aus Tag 11. Dass 30 Minuten, eine und sechs Stunden denselben Wert zeigen, liegt an Tag 11: Das Upgrade dort hat Prometheus neu gestartet, und ohne PersistentVolume beginnt seine Erinnerung erst da. Alle drei Fenster sehen dieselben Daten.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Burn Rate und Restbudget

Die aktuelle Burn Rate über eine Stunde:

promtool query instant http://localhost:30090 'notes:sli_errors:ratio_rate1h / 0.005'

Erwartet (ungefähr):

{} => 2.704242829943693 @[...]

Über 1: In diesem Tempo wäre das Budget nach elf Tagen weg (30 ÷ 2,7). Ohne die Übungsstörungen läge der Wert bei 0.

Wie viel vom Budget ist übrig? Ein echtes SLO rechnet über 30 Tage. Prometheus behält im Lab nur drei, darum hier das Budget eines Tages:

promtool query instant http://localhost:30090 '
  1 - ((sum(increase(notes_http_requests_total{path="/notes",code=~"5.."}[1d]))
          or vector(0))
         / sum(increase(notes_http_requests_total{path="/notes"}[1d]))) / 0.005'

Erwartet (ungefähr):

{} => -1.5555480108446664 @[...]

Negativ: Das Tagesbudget ist überzogen. Kein Wunder – seit dem Neustart von Prometheus an Tag 11 hast du Fehler mit Absicht erzeugt. Im Betrieb wäre das der Moment, neue Features zurückzustellen und in Stabilität zu investieren. Genau dafür gibt es das Budget: als Zahl, über die Teams entscheiden können.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Ein Ausfall

Alle Anfragen an /notes scheitern:

kubectl -n app set env deploy/notes-api NOTES_ERROR_RATE=1
kubectl -n app rollout status deploy/notes-api

Erwartet (letzte Zeile):

deployment "notes-api" successfully rolled out

Beobachte die Burn Rate über beide Fenster des FastBurn-Alarms. Nach zwei Minuten:

promtool query instant http://localhost:30090 'notes:sli_errors:ratio_rate5m / 0.005'
promtool query instant http://localhost:30090 'notes:sli_errors:ratio_rate1h / 0.005'

Erwartet (die Zahlen wachsen mit jeder Minute):

{} => 76.11279107372314 @[...]
{} => 36.850068908800594 @[...]

Das kurze Fenster strebt auf 200 zu (100 Prozent Fehler ÷ 0,5 Prozent Budget), das lange holt langsam auf. Sobald beide über 14,4 liegen, beginnt for: 2m. Wie schnell das lange Fenster die Schwelle reißt, hängt davon ab, wie viele fehlerfreie Daten es aus der letzten Stunde hat – bei einer vollen Stunde ohne Fehler nach gut vier Minuten.

amtool alert query alertname=NotesSloFastBurn

Erwartet (nach drei bis acht Minuten):

Alertname         Starts At                Summary...
NotesSloFastBurn  2026-11-05 09:55:50 UTC  notes-api verbrennt das Fehlerbudget 14-ma...

Ein Totalausfall weckt nach wenigen Minuten jemanden. Eine Fehlerquote von 2 Prozent löst FastBurn nie aus – sie verbraucht das Budget nur viermal zu schnell. Dafür ist SlowBurn da.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Entwarnung

kubectl -n app set env deploy/notes-api NOTES_ERROR_RATE-
kubectl -n app rollout status deploy/notes-api

Erwartet (letzte Zeile):

deployment "notes-api" successfully rolled out

Das lange Fenster bleibt noch eine Weile über 14,4, aber das kurze fällt nach fünf Minuten unter die Schwelle. Weil beide Bedingungen gelten müssen, erlischt der Alarm:

amtool alert query alertname=NotesSloFastBurn

Erwartet (nach etwa fünf Minuten): nur die Kopfzeile.

Das ist der Grund für zwei Fenster. Mit nur dem langen würde der Alarm noch eine Stunde nach der Reparatur feuern.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

kubectl -n app get prometheusrule

Erwartet:

NAME                AGE
notes-api-alerts    102m
notes-api-records   104m
notes-api-slo       26m
notes-api-slow      85m
promtool query instant http://localhost:30090 'count({__name__=~"notes:sli_errors:.*"})'

Erwartet:

{} => 4 @[...]

Vier Fenster, je eine Zeitreihe.

Challenge

Formuliere ein zweites SLI für die Antwortzeit: den Anteil der Anfragen an GET /notes, die in höchstens 250 ms beantwortet werden. Wie hoch ist er gerade?

Hinweis: Das Histogramm hat einen Bucket le="0.25". _count ist die Gesamtzahl.

Lösung

promtool query instant http://localhost:30090 '
  sum(rate(notes_http_request_duration_seconds_bucket{
        method="GET",path="/notes",le="0.25"}[1h]))
    / sum(rate(notes_http_request_duration_seconds_count{
        method="GET",path="/notes"}[1h]))'

Erwartet (ungefähr):

{} => 0.9736396162752308 @[...]

97 Prozent der Anfragen der letzten Stunde waren schnell genug. Die übrigen drei Prozent stammen aus Drill 3 von Tag 11 mit NOTES_DELAY=400ms. Weil der Bucket genau bei 250 ms liegt, ist dieses SLI exakt – kein Schätzen wie bei histogram_quantile. SLO-Grenzen für Latenz legt man darum auf eine Bucket-Grenze.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • SLOs als Code: Sloth und Pyrra erzeugen aus wenigen Zeilen YAML alle Recording Rules und Burn-Rate-Alarme dieses Kapitels. Pyrra bringt eine Oberfläche mit, die Restbudgets zeigt.
  • Das Ziel kommt vom Nutzer: 99,5, 99,9 oder 99,99 Prozent ist eine Geschäftsentscheidung, keine technische. Jede Neun mehr kostet ein Vielfaches. Ein SLO, das nie reißt, ist zu niedrig – oder es misst das Falsche.
  • Budget-Richtlinie: Ein SLO wirkt erst mit einer Vereinbarung, was bei verbrauchtem Budget passiert: Deploy-Stopp, Arbeit an Stabilität, Rückblick. Ohne sie ist es nur eine weitere Kurve.