RousselTMLEARNING

Observabilité

SLO basé sur le temps ou sur les événements : comprendre, calculer et choisir (avec l'exemple de Qonto)

Différences entre SLO basé sur le temps (time slices, uptime) et SLO basé sur les événements (bons événements sur total) : définitions, calculs, budget d'erreur, incident chiffré, mise en œuvre avec Prometheus et OpenSLO, pièges, et l'exemple de la page de statut de Qonto.

1. Rappels : SLI, SLO et budget d'erreur #

Le vocabulaire commun aux deux méthodes.

Les notions #

TermeDéfinitionExemple
SLIindicateur mesuré de la qualité de serviceproportion de paiements acceptés en moins de 2 s
SLOobjectif fixé sur ce SLI, sur une fenêtre99,9 % sur 30 jours glissants
SLAengagement contractuel, assorti de pénalités99,5 % par mois, sinon avoir
Budget d'erreurce que l'on s'autorise à rater : 100 % − SLO0,1 % des minutes ou des requêtes
Burn ratevitesse de consommation du budget (1 = le budget dure exactement la fenêtre)14,4 : budget de 30 jours épuisé en 2 jours

Tout repose sur une question simple : qu'est-ce qu'on compte ? Soit des tranches de temps (« combien de minutes le service a-t-il été bon ? »), soit des événements (« combien de requêtes ont été bien servies ? »). C'est toute la différence entre les deux familles de SLO.

À savoir : Pour les bases, voir SLI, SLO et SLA expliqués simplement et Le budget d'erreur.

2. Le SLO basé sur le temps #

Time slices, ou la logique de l'uptime.

Principe #

SLO basé sur le temps

On découpe la fenêtre en tranches (souvent une minute). Pour chaque tranche, on calcule un SLI (taux d'erreur, latence p95, réponse d'une sonde) et on la déclare bonne ou mauvaise selon un seuil. Le SLO porte sur la proportion de bonnes tranches. C'est la logique historique de l'« uptime » et de la plupart des SLA contractuels.

SLI = bonnes minutes / minutes de la fenêtre
minute bonne  ⇔  taux d'erreur de la minute < 5 %  ET  p95 de la minute < 500 ms

30 jours = 43 200 minutes ; SLO 99,9 %  ⇒  budget = 43,2 minutes mauvaises

Le tableau des « neuf » #

SLOBudget sur 30 joursBudget sur 90 joursBudget sur 1 an
99 %7 h 12 min21 h 36 min3 j 15 h 36 min
99,5 %3 h 36 min10 h 48 min1 j 19 h 48 min
99,9 %43 min 12 s2 h 9 min 36 s8 h 45 min 36 s
99,95 %21 min 36 s1 h 4 min 48 s4 h 22 min 48 s
99,99 %4 min 19 s12 min 58 s52 min 34 s

Forces et faiblesses #

ForcesFaiblesses
intuitif : « le service a été en panne 12 minutes »seuil binaire arbitraire : 4,9 % d'erreurs = minute parfaite, 5,1 % = minute perdue
fonctionne avec peu ou pas de trafic (sondes synthétiques)ignore les dégradations partielles sous le seuil, même longues
aligné sur les SLA contractuels exprimés en minutesune minute de nuit pèse autant qu'une minute de pointe
robuste face aux pics de trafic d'un seul clientsensible à la taille des tranches et à la fréquence des sondes

3. Le SLO basé sur les événements #

Request-based, ou la logique de l'expérience utilisateur.

Principe #

SLO basé sur les événements

On compte des événements (requêtes HTTP, paiements, connexions, messages traités) et on classe chacun en bon ou mauvais selon un critère : réussi, et éventuellement assez rapide. Le SLI est le rapport bons / total sur la fenêtre. Le budget d'erreur s'exprime en nombre d'événements ratés.

SLI = événements bons / événements totaux
bon  ⇔  statut ≠ 5xx  ET  durée < 300 ms

30 millions de requêtes par mois ; SLO 99,9 %  ⇒  budget = 30 000 requêtes ratées

Forces et faiblesses #

ForcesFaiblesses
proportionnel au nombre d'utilisateurs touchés : une panne en pointe coûte plus qu'une panne la nuitfaible trafic = bruit : 1 erreur sur 20 requêtes fait chuter le SLI à 95 %
capte les dégradations partielles : 2 % d'erreurs pendant des heures consomment réellement le budgetles requêtes jamais arrivées ne sont pas comptées si l'on mesure côté serveur
pas de seuil arbitraire par trancheune panne la nuit pèse peu, même si elle bloque des clients critiques
burn rate naturel et alertes multi-fenêtres précisessensible aux tentatives répétées (retries) et à la définition d'un événement
À savoir : Google SRE recommande par défaut les SLI à base d'événements (« proportion de bons événements ») pour les services à trafic suffisant, et réserve les tranches de temps aux cas où le trafic est faible ou irrégulier.

4. Le même mois, mesuré des deux façons #

Trois incidents qui racontent deux histoires.

Hypothèses #

  • API de paiement, environ 30 millions de requêtes par mois : 100 requêtes par minute la nuit, 1 000 en journée, 3 000 en pointe.
  • SLO de 99,9 % sur 30 jours : budget de 43,2 minutes (temps) ou de 30 000 requêtes (événements).
  • Côté temps, une minute est mauvaise si plus de 5 % des requêtes échouent.

Résultats #

IncidentTemps : minutes perduesTemps : budgetÉvénements : requêtes ratéesÉvénements : budget
A. Panne totale de 30 min à 3 h du matin3069 %3 00010 %
B. 4 % d'erreurs pendant 10 h en journée00 %24 00080 %
C. Panne totale de 20 min à l'heure de pointe2046 %60 000200 %
Budget d'erreur consommé par incident

Ce que cela montre #

  • Incident A : le SLO temps s'alarme (69 % du budget) pour une panne qui a touché très peu de clients ; le SLO événements la relativise (10 %).
  • Incident B : invisible pour le SLO temps (toujours sous le seuil de 5 %), alors que 24 000 paiements ont échoué. Le SLO événements en fait l'incident majeur du mois.
  • Incident C : le SLO temps le juge moins grave que A ; le SLO événements montre qu'il a, à lui seul, épuisé deux fois le budget.
Bonne Pratique : Aucune des deux mesures n'est « fausse » : elles répondent à des questions différentes. Le temps répond à « combien de temps le service était-il utilisable ? », les événements à « quelle part des utilisateurs a été bien servie ? ».

5. Mettre en œuvre #

Prometheus, OpenSLO, SQL et outils du marché.

Avec Prometheus #

# Événements : SLI = requêtes bonnes / requêtes totales (règles d'enregistrement)
groups:
  - name: slo-paiement
    rules:
      - record: sli:paiement:ratio_rate5m
        expr: |
          sum(rate(http_requests_total{service="paiement", code!~"5.."}[5m]))
          /
          sum(rate(http_requests_total{service="paiement"}[5m]))
      # Burn rate sur 1 h et 5 min : alerte page si le budget de 30 jours brûle 14,4 fois trop vite
      - alert: PaiementBudgetBrule
        expr: |
          (1 - sli:paiement:ratio_rate1h) > (14.4 * 0.001)
          and
          (1 - sli:paiement:ratio_rate5m) > (14.4 * 0.001)
        labels: { severity: page }

# Temps : part des minutes « bonnes » sur 30 jours (sous-requête, résolution 1 min)
avg_over_time(
  (
    (sum(rate(http_requests_total{service="paiement", code=~"5.."}[1m]))
      / sum(rate(http_requests_total{service="paiement"}[1m]))) < bool 0.05
  )[30d:1m]
)

Côté événements, il suffit de deux compteurs. Côté temps, la sous-requête [30d:1m] évalue chaque minute puis fait la moyenne des verdicts (1 ou 0) : coûteuse sur 30 jours, elle se calcule plutôt avec une règle d'enregistrement par minute.

Pour générer règles et alertes automatiquement, voir Sloth et Pyrra.

Avec OpenSLO #

# OpenSLO v1 : la même cible, deux méthodes de budget
apiVersion: openslo/v1
kind: SLO
metadata: { name: paiement-evenements }
spec:
  service: paiement
  budgetingMethod: Occurrences          # basé sur les événements
  objectives:
    - target: 0.999
  timeWindow: [{ duration: 30d, isRolling: true }]
  indicator:
    metadata: { name: paiement-succes }
    spec:
      ratioMetric:
        good:  { metricSource: { type: Prometheus, spec: { query: 'sum(rate(http_requests_total{service="paiement",code!~"5.."}[1m]))' } } }
        total: { metricSource: { type: Prometheus, spec: { query: 'sum(rate(http_requests_total{service="paiement"}[1m]))' } } }
---
# Variante temps : chaque minute est bonne si son ratio dépasse 95 %
#   budgetingMethod: Timeslices
#   objectives: [{ target: 0.999, timeSliceTarget: 0.95, timeSliceWindow: 1m }]

La spécification OpenSLO nomme explicitement les deux méthodes : Occurrences (événements) et Timeslices (temps), avec un seuil par tranche (timeSliceTarget).

En SQL sur les traces #

-- Événements à partir des traces (ClickHouse, table otel_traces) : SLI par jour
SELECT toDate(Timestamp) AS jour,
       countIf(StatusCode != 'Error' AND Duration < 300e6) / count() AS sli
FROM otel_traces
WHERE ServiceName = 'paiement' AND SpanKind = 'Server' AND Timestamp > now() - INTERVAL 30 DAY
GROUP BY jour ORDER BY jour;

-- Temps : part des minutes où le taux d'erreur reste sous 5 %
SELECT avg(taux < 0.05) AS sli_temps FROM (
  SELECT toStartOfMinute(Timestamp) AS m, countIf(StatusCode = 'Error') / count() AS taux
  FROM otel_traces
  WHERE ServiceName = 'paiement' AND SpanKind = 'Server' AND Timestamp > now() - INTERVAL 30 DAY
  GROUP BY m);

Dans les outils #

OutilÉvénementsTemps
Grafana SLOratio de deux requêtesvia une requête de tranches
DatadogSLO « metric-based »SLO « monitor-based » et « time slice »
DynatraceSLO sur ratio de métriques ou de requêtes DQLSLO sur disponibilité synthétique
Nobl9, Sloth, Pyrraoui (méthode par défaut)Nobl9 : oui ; Sloth et Pyrra : orientés événements
Attention : Les libellés et options évoluent : vérifiez la documentation de votre outil, en particulier la façon dont il traite les tranches sans trafic (bonnes, mauvaises ou ignorées).

6. L'exemple de Qonto #

Une page de statut exprimée par parcours client.

Ce que montre la page de statut #

La néobanque Qonto est passée à une approche par événements pour exprimer sa fiabilité. Sa page de statut publique (status.qonto.com) affiche une disponibilité par composant, sur une fenêtre de 90 jours, avec quatre décimales. Les composants correspondent à des parcours clients plutôt qu'à des serveurs :

ComposantDisponibilité affichée (90 jours, relevé de novembre 2026)Lecture en événementsLecture en temps (équivalent)
Authentification99,9969 %≈ 3 échecs sur 100 000 connexions≈ 4 min sur 90 jours
Transactions99,9713 %≈ 29 échecs sur 100 000 opérations≈ 37 min sur 90 jours
Paiements par carte99,9992 %≈ 8 échecs sur 1 million de paiements≈ 1 min sur 90 jours
Virements99,9969 %≈ 3 échecs sur 100 000 virements≈ 4 min sur 90 jours

Les chiffres sont glissants et changent chaque jour ; la colonne « lecture en temps » montre seulement ce que signifierait le même pourcentage s'il était exprimé en minutes.

Pourquoi ce choix est pertinent pour une banque #

  • Chaque événement est un client : un paiement par carte refusé à tort se voit en caisse, quelle que soit l'heure. Compter les paiements ratés traduit directement l'impact client.
  • Les dégradations partielles comptent : 1 % de virements en échec pendant une matinée n'est pas une « panne » au sens de l'uptime, mais c'est un incident pour les clients concernés (incident B de la section 4).
  • Le volume le permet : avec des millions d'opérations, le ratio est stable et précis, d'où l'intérêt de quatre décimales.
  • Parcours plutôt que composants techniques : le client voit « Paiements par carte », pas « cluster Kafka » ; chaque parcours a son propre SLO et son propre budget.
  • Une fenêtre de 90 jours lisse les variations sans masquer les tendances, et correspond à un horizon trimestriel de pilotage.

Ce qu'on peut en retenir pour sa propre page de statut #

  1. Découper par parcours client (se connecter, payer, virer), chacun avec son SLI d'événements.
  2. Mesurer au plus près de l'utilisateur (répartiteur, passerelle, client) pour compter aussi les requêtes qui n'atteignent jamais le service.
  3. Afficher une fenêtre glissante et une précision cohérente avec le volume.
  4. Expliquer publiquement la méthode (ce qu'est un événement « bon ») : la transparence renforce la confiance.
  5. Garder les états UP, DEGRADED, DOWN et MAINTENANCE pour l'instant présent, et le pourcentage pour l'historique.
À savoir : Qonto ne publie pas sur cette page le détail de son calcul (définition d'un événement réussi, point de mesure) : les lectures « ≈ N échecs » ci-dessus sont une conversion arithmétique du pourcentage affiché, pas des chiffres communiqués par Qonto.

7. Choisir, ou combiner #

Selon le trafic, le contrat et la question posée.

Grille de choix #

SituationMéthode conseilléePourquoi
API ou parcours à fort trafic (paiements, recherche, connexion)événementsreflète la part de clients touchés, capte les dégradations partielles
Service à faible trafic (back-office, API B2B peu sollicitée)temps (avec sondes synthétiques)évite qu'une seule erreur fasse chuter le SLI
SLA contractuel en minutestemps pour le SLA, événements pour le pilotage internele contrat impose l'unité
Traitements par lots, tâches planifiéesévénements (exécutions réussies à l'heure)chaque exécution est un événement
Trafic très irrégulier (pics saisonniers)événements, complétés par des sondesles pics comptent davantage, les creux restent surveillés
Où mesurer les événements

Combiner les deux #

  • Événements + sondes : les sondes synthétiques garantissent un trafic minimal, si bien qu'une panne totale la nuit consomme quand même du budget.
  • Seuil de trafic minimal : ne compter une fenêtre que si elle contient assez d'événements, ou agréger sur une fenêtre plus longue.
  • SLO multiples : un SLO d'événements pour la qualité perçue et un SLO de temps pour la disponibilité contractuelle, présentés côte à côte.

8. Pièges courants #

Ce qui fausse un SLO, quelle que soit la méthode.

Les pièges #

PiègeEffetRemède
Mesurer uniquement côté serveurune panne du répartiteur ou du DNS n'est pas comptée (zéro événement)mesurer au répartiteur ou au client, ajouter des sondes
Compter les tentatives répétéesune requête utilisateur devient trois événementscompter l'opération métier, pas l'appel HTTP
Compter les 4xx comme des erreursles erreurs des clients consomment votre budgetexclure les 4xx, sauf 429 et 408 si ce sont vos limites
Seuil de tranche mal choisidégradations invisibles ou alertes excessivesfonder le seuil sur l'historique, le revoir
Maintenances exclues sans règleSLO flatteur, perte de confiancerègle écrite et publique pour les exclusions
SLO global uniqueun gros client en panne disparaît dans la moyenneSLO par parcours, voire par segment de clients
Bonne Pratique : Écrivez la définition du SLI comme un contrat : ce qu'est un événement, ce qui le rend bon, où on le mesure, ce qu'on exclut. C'est ce document, plus que l'outil, qui rend le SLO crédible.

9. À retenir #

Synthèse, commandes et sources.

Synthèse #

SLO basé sur le tempsSLO basé sur les événements
On comptedes tranches de temps bonnesdes événements bons
Budget exprimé enminutesévénements ratés
Question poséecombien de temps le service était-il utilisable ?quelle part des utilisateurs a été bien servie ?
Idéal pourfaible trafic, SLA contractuelsfort trafic, expérience client, pilotage
Angle mortdégradations partielles, poids du traficfaible trafic, requêtes jamais reçues

Commandes à connaître #

Commandes à connaître
  • sum(rate(http_requests_total{code!~"5.."}[5m])) / sum(rate(http_requests_total[5m])) : SLI à base d'événements (PromQL)
  • avg_over_time((… < bool 0.05)[30d:1m]) : SLI à base de tranches de temps (PromQL)
  • (1 - sli:ratio_rate1h) > 14.4 * 0.001 : alerte de burn rate rapide
  • budgetingMethod: Occurrences | Timeslices : choisir la méthode dans OpenSLO
  • sloth generate -i slo.yaml : générer règles et alertes Prometheus

Sources #

Relevé de la page de statut de Qonto effectué en novembre 2026 ; les pourcentages évoluent chaque jour.

Articles liés

Le trilemme de l'observabilité : coût, exhaustivité et performance, et comment les solutions le résolvent

Comprendre le trilemme de l'observabilité (coût, exhaustivité des données, performance des requêtes), ses tro…

Administration et sécurité de Grafana : organisations, équipes, RBAC, comptes de service et authentification

Administrer Grafana en entreprise : organisations, équipes, dossiers, rôles et RBAC, permissions des sources …

Dashboard engineering : visualisations d'état, annotations, panneaux de bibliothèque et navigation

Concevoir des dashboards professionnels : State timeline, Status history, Node graph, annotations, panneaux d…

Pour aller plus loin

Soutenir

♥ SOUTENIR

Soutenez RousselTM Learning

Les formations, articles, TP et attestations restent gratuits et sans publicité intrusive. Une contribution libre, du montant de votre choix, finance l’hébergement, les environnements de TP et l’écriture de nouveaux contenus.

Contribuer avec PayPal Montant libre · carte bancaire ou compte PayPalEn savoir plus
QR code PayPal
Ou scannez ce QR code avec votre téléphone

Merci, chaque contribution compte !