Implémentation des SLOs

Framework pour définir et implémenter des Service Level Indicators (SLIs), Service Level Objectives (SLOs) et error budgets.

Objectif

Implémenter des cibles de fiabilité mesurables en utilisant les SLIs, SLOs et error budgets pour équilibrer fiabilité et vélocité d'innovation.

Quand utiliser

• Définir les cibles de fiabilité du service
• Mesurer la fiabilité perçue par l'utilisateur
• Implémenter des error budgets
• Créer des alertes basées sur les SLOs
• Suivre les objectifs de fiabilité

Hiérarchie SLI/SLO/SLA

SLA (Service Level Agreement)
  ↓ Contrat avec les clients
SLO (Service Level Objective)
  ↓ Cible de fiabilité interne
SLI (Service Level Indicator)
  ↓ Mesure réelle

Définir les SLIs

Types courants de SLI

1. SLI de disponibilité

# Requêtes réussies / Requêtes totales
sum(rate(http_requests_total{status!~"5.."}[28d]))
/
sum(rate(http_requests_total[28d]))

2. SLI de latence

# Requêtes sous le seuil de latence / Requêtes totales
sum(rate(http_request_duration_seconds_bucket{le="0.5"}[28d]))
/
sum(rate(http_request_duration_seconds_count[28d]))

3. SLI de durabilité

# Écritures réussies / Écritures totales
sum(storage_writes_successful_total)
/
sum(storage_writes_total)

Référence : Voir references/slo-definitions.md

Définir les cibles SLO

Exemples de SLO de disponibilité

Choisir des SLOs appropriés

À considérer :

• Attentes des utilisateurs
• Exigences métier
• Performance actuelle
• Coût de la fiabilité
• Benchmarks des concurrents

Exemples de SLOs :

slos:
  - name: api_availability
    target: 99.9
    window: 28d
    sli: |
      sum(rate(http_requests_total{status!~"5.."}[28d]))
      /
      sum(rate(http_requests_total[28d]))

  - name: api_latency_p95
    target: 99
    window: 28d
    sli: |
      sum(rate(http_request_duration_seconds_bucket{le="0.5"}[28d]))
      /
      sum(rate(http_request_duration_seconds_count[28d]))

Calcul de l'error budget

Formule de l'error budget

Error Budget = 1 - Cible SLO

Exemple :

• SLO : 99,9% de disponibilité
• Error Budget : 0,1% = 43,2 minutes/mois
• Erreur actuelle : 0,05% = 21,6 minutes/mois
• Budget restant : 50%

Politique de l'error budget

error_budget_policy:
  - remaining_budget: 100%
    action: Vélocité de développement normale
  - remaining_budget: 50%
    action: Envisager de repousser les changements risqués
  - remaining_budget: 10%
    action: Geler les changements non critiques
  - remaining_budget: 0%
    action: Gel des fonctionnalités, focus sur la fiabilité

Référence : Voir references/error-budget.md

Implémentation des SLOs

Règles d'enregistrement Prometheus

# Règles d'enregistrement SLI
groups:
  - name: sli_rules
    interval: 30s
    rules:
      # SLI de disponibilité
      - record: sli:http_availability:ratio
        expr: |
          sum(rate(http_requests_total{status!~"5.."}[28d]))
          /
          sum(rate(http_requests_total[28d]))

      # SLI de latence (requêtes < 500ms)
      - record: sli:http_latency:ratio
        expr: |
          sum(rate(http_request_duration_seconds_bucket{le="0.5"}[28d]))
          /
          sum(rate(http_request_duration_seconds_count[28d]))

  - name: slo_rules
    interval: 5m
    rules:
      # Conformité SLO (1 = SLO respecté, 0 = SLO violé)
      - record: slo:http_availability:compliance
        expr: sli:http_availability:ratio >= bool 0.999

      - record: slo:http_latency:compliance
        expr: sli:http_latency:ratio >= bool 0.99

      # Error budget restant (pourcentage)
      - record: slo:http_availability:error_budget_remaining
        expr: |
          (sli:http_availability:ratio - 0.999) / (1 - 0.999) * 100

      # Taux de consommation de l'error budget
      - record: slo:http_availability:burn_rate_5m
        expr: |
          (1 - (
            sum(rate(http_requests_total{status!~"5.."}[5m]))
            /
            sum(rate(http_requests_total[5m]))
          )) / (1 - 0.999)

Règles d'alerte SLO

groups:
  - name: slo_alerts
    interval: 1m
    rules:
      # Consommation rapide : taux 14,4x, fenêtre 1 heure
      # Consomme 2% de l'error budget en 1 heure
      - alert: SLOErrorBudgetBurnFast
        expr: |
          slo:http_availability:burn_rate_1h > 14.4
          and
          slo:http_availability:burn_rate_5m > 14.4
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Consommation rapide de l'error budget détectée"
          description: "Error budget consommé au taux de {{ $value }}x"

      # Consommation lente : taux 6x, fenêtre 6 heures
      # Consomme 5% de l'error budget en 6 heures
      - alert: SLOErrorBudgetBurnSlow
        expr: |
          slo:http_availability:burn_rate_6h > 6
          and
          slo:http_availability:burn_rate_30m > 6
        for: 15m
        labels:
          severity: warning
        annotations:
          summary: "Consommation lente de l'error budget détectée"
          description: "Error budget consommé au taux de {{ $value }}x"

      # Error budget épuisé
      - alert: SLOErrorBudgetExhausted
        expr: slo:http_availability:error_budget_remaining < 0
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Error budget SLO épuisé"
          description: "Error budget restant : {{ $value }}%"

Tableau de bord SLO

Structure du tableau de bord Grafana :

┌────────────────────────────────────┐
│ Conformité SLO (Actuelle)          │
│ ✓ 99,95% (Cible : 99,9%)          │
├────────────────────────────────────┤
│ Error Budget restant : 65%         │
│ ████████░░ 65%                     │
├────────────────────────────────────┤
│ Tendance SLI (28 jours)            │
│ [Graphique de série temporelle]    │
├────────────────────────────────────┤
│ Analyse du taux de consommation    │
│ [Taux par fenêtre temporelle]      │
└────────────────────────────────────┘

Exemples de requêtes :

# Conformité SLO actuelle
sli:http_availability:ratio * 100

# Error budget restant
slo:http_availability:error_budget_remaining

# Jours avant épuisement de l'error budget (au taux actuel)
(slo:http_availability:error_budget_remaining / 100)
*
28
/
(1 - sli:http_availability:ratio) * (1 - 0.999)

Alertes sur taux de consommation multi-fenêtres

# La combinaison de fenêtres courtes et longues réduit les faux positifs
rules:
  - alert: SLOBurnRateHigh
    expr: |
      (
        slo:http_availability:burn_rate_1h > 14.4
        and
        slo:http_availability:burn_rate_5m > 14.4
      )
      or
      (
        slo:http_availability:burn_rate_6h > 6
        and
        slo:http_availability:burn_rate_30m > 6
      )
    labels:
      severity: critical

Processus d'examen des SLOs

Examen hebdomadaire

• Conformité SLO actuelle
• État de l'error budget
• Analyse de tendance
• Impact des incidents

Examen mensuel

• Réalisation des SLOs
• Utilisation de l'error budget
• Postmortems d'incidents
• Ajustements des SLOs

Examen trimestriel

• Pertinence des SLOs
• Ajustement des cibles
• Améliorations de processus
• Améliorations des outils

Bonnes pratiques

1. Commencer par les services orientés utilisateur
2. Utiliser plusieurs SLIs (disponibilité, latence, etc.)
3. Définir des SLOs réalistes (ne pas viser 100%)
4. Implémenter des alertes multi-fenêtres pour réduire le bruit
5. Suivre l'error budget de façon cohérente
6. Examiner régulièrement les SLOs
7. Documenter les décisions relatives aux SLOs
8. Aligner avec les objectifs métier
9. Automatiser le reporting des SLOs
10. Utiliser les SLOs pour la priorisation

Compétences associées

• prometheus-configuration - Pour la collecte de métriques
• grafana-dashboards - Pour la visualisation des SLOs