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
/notesgelingen, 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./healthzund/metricswü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.yamlErwartet:
prometheusrule.monitoring.coreos.com/notes-api-slo created
0.005ist 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-apiErwartet (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=NotesSloFastBurnErwartet (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-apiErwartet (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=NotesSloFastBurnErwartet (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 prometheusruleErwartet:
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.