Zum Inhalt springen

SLOs, SLIs und Error Budgets: ein praktischer Leitfaden

Service Level Objectives machen vage Ziele messbar: SLIs definieren, SLOs festlegen und Error Budgets nutzen, um Tempo und Stabilität zu wägen.

3 Min. Lesezeit
Diagramm der Error-Budget-Burn-Rate, das das verbleibende Budget über ein 30-Tage-Fenster zeigt

Die Aussage "der Dienst sollte zuverlässig sein" ist nicht umsetzbar. Zuverlässig für wen? Wie zuverlässig? Was passiert, wenn die Zuverlässigkeit nachlässt? Service Level Objectives (SLOs) beantworten diese Fragen mit Zahlen. Sie legen fest, wie viel Unzuverlässigkeit akzeptabel ist, und schaffen so eine messbare Vereinbarung zwischen deinem Team und deinen Nutzern.

Die drei Konzepte

Service Level Indicator (SLI) — eine quantitative Messung des Verhaltens eines Dienstes. "Wie viel Prozent der Anfragen werden innerhalb von 500 ms erfolgreich abgeschlossen?"

Service Level Objective (SLO) — ein Zielbereich für einen SLI. "99,9 % der Anfragen sollen innerhalb von 500 ms erfolgreich abgeschlossen werden, gemessen über ein gleitendes 30-Tage-Fenster."

Error Budget — das Gegenstück zu einem SLO. Liegt dein SLO bei 99,9 %, beträgt dein Error Budget 0,1 % — das entspricht 43 Minuten tolerierbarer Ausfallzeit pro 30 Tage.

tstypescript
// Calculate error budget remaining
interface SLOConfig {
  target: number;       // e.g., 0.999 (99.9%)
  windowDays: number;   // e.g., 30
}
 
interface SLIMetrics {
  totalRequests: number;
  successfulRequests: number;
}
 
function calculateErrorBudget(config: SLOConfig, metrics: SLIMetrics) {
  const currentSLI = metrics.successfulRequests / metrics.totalRequests;
  const allowedFailureRate = 1 - config.target;
  const allowedFailures = Math.floor(metrics.totalRequests * allowedFailureRate);
  const actualFailures = metrics.totalRequests - metrics.successfulRequests;
  const budgetRemaining = allowedFailures - actualFailures;
  const budgetPercentUsed = (actualFailures / allowedFailures) * 100;
 
  return {
    currentSLI: (currentSLI * 100).toFixed(3) + "%",
    allowedFailures,
    actualFailures,
    budgetRemaining,
    budgetPercentUsed: budgetPercentUsed.toFixed(1) + "%",
    withinBudget: budgetRemaining >= 0,
  };
}

Die richtigen SLIs auswählen

Nicht jede Metrik ist ein guter SLI. Gute SLIs korrelieren direkt mit der Nutzererfahrung.

ymlyaml
# ❌ Infrastructure metrics as SLIs — don't reflect user experience
slis:
  - name: "CPU utilization"
    target: "below 70%"
  - name: "Memory usage"
    target: "below 80%"
  # CPU can be at 90% while users are perfectly happy
 
# ✅ User-facing metrics as SLIs
slis:
  - name: "Availability"
    description: "Proportion of requests that return non-5xx responses"
    good_event: "response.status_code < 500"
    total_event: "all requests"
    target: 99.9%
    window: 30d
 
  - name: "Latency"
    description: "Proportion of requests served within 500ms"
    good_event: "response.duration_ms <= 500"
    total_event: "all requests"
    target: 95%
    window: 30d
 
  - name: "Correctness"
    description: "Proportion of responses that pass data validation"
    good_event: "response.body passes schema validation"
    total_event: "all successful requests"
    target: 99.99%
    window: 30d

SLO-Monitoring implementieren

Prometheus und Grafana eignen sich gut für das SLO-Tracking. Definiere Recording Rules, die SLI-Werte vorab berechnen, und richte Alerts ein, die auslösen, wenn die Burn Rate des Error Budgets zu hoch ist.

ymlyaml
# Prometheus recording rules for SLI computation
groups:
  - name: sli-recording
    interval: 1m
    rules:
      # Availability SLI - ratio of successful requests
      - record: sli:availability:ratio_rate5m
        expr: |
          sum(rate(http_requests_total{status_code!~"5.."}[5m]))
          /
          sum(rate(http_requests_total[5m]))
 
      # Latency SLI - ratio of fast requests
      - record: sli:latency:ratio_rate5m
        expr: |
          sum(rate(http_request_duration_seconds_bucket{le="0.5"}[5m]))
          /
          sum(rate(http_request_duration_seconds_count[5m]))
 
  - name: slo-alerts
    rules:
      # Alert when error budget burn rate is too high
      # Burns through 5% of monthly budget in 1 hour
      - alert: SLOBudgetBurnHigh
        expr: |
          (
            1 - sli:availability:ratio_rate5m
          ) > (14.4 * (1 - 0.999))
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "High error budget burn rate - paging on-call"

Error-Budget-Richtlinien

Das Error Budget entfaltet erst dann seinen Sinn, wenn sein Aufbrauchen tatsächlich Konsequenzen hat. Definiere eine Richtlinie, auf die sich das Team einigt, bevor Incidents auftreten.

markdownmarkdown
## Error Budget Policy
 
### When budget is healthy (>50% remaining):
- Ship features at normal velocity
- Run chaos engineering experiments
- Perform infrastructure migrations
 
### When budget is concerning (25-50% remaining):
- Reduce deployment frequency
- Increase testing requirements for changes
- Review recent incidents for patterns
 
### When budget is critical (<25% remaining):
- Feature freeze — only reliability improvements and critical fixes
- All engineering effort focused on error reduction
- Post-incident reviews required for every budget-consuming event
 
### When budget is exhausted (0% remaining):
- Complete deployment freeze
- Roll back any recent changes that correlate with budget consumption
- Leadership review of reliability roadmap

Multi-Window-Burn-Rate-Alerts

Ein Alert mit nur einem Zeitfenster ist entweder zu langsam (langes Fenster) oder zu störanfällig (kurzes Fenster). Multi-Window-Alerts kombinieren beide Ansätze für eine schnelle Erkennung bei wenigen Falsch-Positiven.

ymlyaml
# Fast burn: consuming budget 14.4x faster than sustainable
# Detected in 1 hour, confirmed over 5 minutes
- alert: SLOBudgetBurnFast
  expr: |
    (
      (1 - sli:availability:ratio_rate1h) > 14.4 * 0.001
    )
    and
    (
      (1 - sli:availability:ratio_rate5m) > 14.4 * 0.001
    )
  labels:
    severity: critical
 
# Slow burn: consuming budget 3x faster than sustainable
# Detected over 6 hours, confirmed over 30 minutes
- alert: SLOBudgetBurnSlow
  expr: |
    (
      (1 - sli:availability:ratio_rate6h) > 3 * 0.001
    )
    and
    (
      (1 - sli:availability:ratio_rate30m) > 3 * 0.001
    )
  labels:
    severity: warning

Die wichtigsten Erkenntnisse

  1. SLIs messen die vom Nutzer wahrgenommene Qualität — wähle Metriken, die mit der tatsächlichen Nutzererfahrung korrelieren, nicht mit dem Zustand der Infrastruktur
  2. SLOs setzen explizite Zuverlässigkeitsziele — "99,9 % über 30 Tage" ist umsetzbar, "zuverlässig sein" nicht
  3. Error Budgets balancieren Zuverlässigkeit und Geschwindigkeit — sie geben Teams die Erlaubnis, schnell auszuliefern, solange die Zuverlässigkeit stimmt
  4. Budget-Richtlinien vor Incidents festlegen — einigt euch auf die Konsequenzen für ein aufgebrauchtes Budget, solange alle noch ruhig sind
  5. Multi-Window-Burn-Rate-Alerts einsetzen — sie erkennen sowohl schnelle Incidents als auch langsame Verschlechterungen, ohne viele Falsch-Positive zu erzeugen
  6. Mit ein oder zwei SLIs beginnen — Verfügbarkeit und Latenz decken die meisten nutzerorientierten Dienste ab; weitere nur bei Bedarf ergänzen
Wilfredo Rujel

Wilfredo Rujel

Full-Stack-Softwareentwickler

Diesen Beitrag teilenX