SLO et error budgets : des alertes burn rate utiles pour l'astreinte
SLI, error budget, burn rate multi-fenêtres et recording rules Prometheus : la méthode du SRE Workbook pour une astreinte qui sonne moins, à bon escient.
Une astreinte qui reçoit des dizaines d'alertes par nuit n'en traite aucune correctement. Elle acquitte, se rendort, et le jour où l'alerte compte vraiment, elle passe dans le lot. Le passage aux SLO est avant tout un exercice de suppression : on n'alerte plus sur ce qui pourrait poser problème, mais sur ce que les utilisateurs subissent réellement, et seulement quand ils le subissent assez pour menacer l'objectif.
Le principe tient en une phrase, la mise en œuvre beaucoup moins. Un SLI mal défini, une expression PromQL qui ne mesure pas ce que l'on croit ou des fenêtres de calcul mal choisies suffisent à reconstruire un alerting Prometheus « orienté SLO » aussi bruyant que l'ancien.
Choisir un SLI qui parle aux utilisateurs
Un SLI est un ratio : les événements bons rapportés aux événements valides. Pour une API, nous partons presque toujours de deux SLI distincts, la disponibilité (part des requêtes qui ne se terminent pas en erreur serveur) et la latence (part des requêtes servies sous un seuil, 300 ms par exemple). On peut les fusionner en un seul indicateur, « requêtes réussies en moins de 300 ms », très lisible pour le métier. Nous préférons les garder séparés pour l'alerting : quand la page tombe, l'astreinte sait immédiatement si elle cherche une panne ou une lenteur.
Le choix des événements valides est une décision, pas un détail d'implémentation. Nous excluons en général les 4xx, qui traduisent une erreur du client, sauf celles que le service provoque lui-même : un 429 renvoyé parce que le service sature est une indisponibilité pour celui qui le reçoit. Les health checks et le trafic synthétique sortent aussi du dénominateur, sinon ils diluent le ratio et masquent les dégradations réelles.
Le point de mesure a ses propres compromis. Le load balancer voit les requêtes que l'application n'a jamais reçues, par exemple quand tous les pods sont tombés, ce qui est précisément le cas où les métriques applicatives se taisent. L'application connaît en revanche la route et la nature de l'erreur. La mesure côté client reste la plus fidèle à l'expérience réelle, mais aussi la plus difficile à fiabiliser. Nous retenons le point le plus proche de l'utilisateur dont la qualité de mesure est maîtrisée, et c'est souvent le load balancer.
La latence ajoute une contrainte que l'on découvre trop tard. Avec un histogramme Prometheus classique, la part des requêtes servies sous 300 ms n'est exacte que si une borne de bucket existe précisément à 0,3 s ; sinon, la valeur est estimée par interpolation, comme le rappelle la documentation Prometheus sur les histogrammes. Or ni les buckets par défaut du client Go (0,25 puis 0,5 s) ni ceux que les conventions sémantiques OpenTelemetry recommandent pour http.server.request.duration ne contiennent 0,3. Il faut donc ajouter cette borne dans l'instrumentation, ou aligner le seuil du SLO sur une borne existante. Une fois la borne en place, le ratio de requêtes trop lentes s'écrit simplement :
1 - (
sum(rate(http_request_duration_seconds_bucket{job="api",le="0.3"}[1h]))
/
sum(rate(http_request_duration_seconds_count{job="api"}[1h]))
)
Ce que signifie un burn rate de 14,4
Un SLO de 99,9 % sur 30 jours glissants laisse un error budget de 0,1 % des requêtes, soit l'équivalent d'environ 43 minutes d'indisponibilité totale sur la période. Le burn rate mesure la vitesse à laquelle ce budget se consomme, relativement au SLO. À 1, le budget est exactement épuisé au bout des 30 jours ; à 14,4, il disparaît en 50 heures.
La relation utile est la suivante : budget consommé = burn rate × durée de la fenêtre / période du SLO. Un burn rate de 14,4 maintenu pendant une heure consomme donc 14,4 × 1 / 720, soit 2 % du budget mensuel. Un burn rate de 6 pendant six heures en consomme 5 %. Ces deux situations justifient une page : si rien ne change, le budget du mois sera épuisé en deux jours dans le premier cas, en cinq dans le second.
Côté PromQL, le seuil se déduit directement. Le taux d'erreur observé doit dépasser burn rate × (1 − SLO), soit 14.4 * 0.001 pour un SLO à 99,9 %. L'expression que l'on rencontre souvent comme point de départ, un ratio rate() des 5xx sur l'ensemble des requêtes sur une heure, comparé à ce seuil, est juste dans son calcul. Elle a deux défauts. Elle ne mesure que la disponibilité, alors que le SLI annoncé porte aussi sur la latence. Et surtout, elle repose sur une fenêtre unique.
Pourquoi une seule fenêtre ne suffit pas
Une fenêtre longue seule donne une bonne précision, mais un temps de réinitialisation médiocre : une fois l'incident corrigé, le ratio calculé sur la dernière heure reste au-dessus du seuil pendant de longues minutes, et l'alerte continue de sonner alors que tout est rentré dans l'ordre. Une fenêtre courte seule fait l'inverse, et réveille l'astreinte pour un pic de cinq minutes qui n'entame presque pas le budget.
Le chapitre Alerting on SLOs du SRE Workbook résout ce compromis avec des alertes multi-fenêtres et multi-burn-rates. Chaque niveau combine une fenêtre longue, qui prouve que la consommation de budget est significative, et une fenêtre courte, qui prouve qu'elle est toujours en cours. Le Workbook recommande une fenêtre courte égale à 1/12 de la fenêtre longue. Pour un SLO à 99,9 %, il propose trois niveaux :
- 2 % du budget consommé : fenêtre longue de 1 h, courte de 5 min, burn rate 14,4, page
- 5 % du budget consommé : fenêtre longue de 6 h, courte de 30 min, burn rate 6, page
- 10 % du budget consommé : fenêtre longue de 3 jours, courte de 6 h, burn rate 1, ticket
Le ticket du Workbook ajoute un niveau intermédiaire, un burn rate de 3 sur 24 h avec une fenêtre courte de 2 h, qui représente lui aussi 10 % du budget. Ces valeurs sont un point de départ raisonnable, pas un dogme : elles supposent un SLO sur 30 jours, et un SLO plus strict ou une période différente imposent de refaire le calcul.
La tentation d'ajouter un for: 10m sur une alerte mono-fenêtre pour la calmer est fréquente. Le Workbook l'écarte, et nous aussi : la durée ne dépend pas de la gravité, si bien qu'une panne totale attend aussi longtemps qu'une dégradation légère. Elle se réinitialise en outre dès que le ratio repasse un instant sous le seuil, de sorte qu'un SLI qui oscille autour de l'objectif peut ne jamais alerter.
Des recording rules plutôt que des requêtes brutes
Évaluer rate() sur trois jours à chaque cycle d'évaluation coûte cher en mémoire et en lectures, ce que le Workbook signale aussi pour les fenêtres longues. Nous précalculons donc les ratios avec des recording rules, nommées selon la convention level:metric:operations de la documentation Prometheus. Celle-ci rappelle une règle souvent violée : pour agréger un ratio, on somme numérateur et dénominateur séparément avant de diviser, jamais l'inverse.
groups:
- name: slo-api-ratios
rules:
- record: job:slo_errors_per_request:ratio_rate5m
expr: |
sum by (job) (rate(http_requests_total{job="api",code=~"5.."}[5m]))
/
sum by (job) (rate(http_requests_total{job="api"}[5m]))
- record: job:slo_errors_per_request:ratio_rate30m
expr: |
sum by (job) (rate(http_requests_total{job="api",code=~"5.."}[30m]))
/
sum by (job) (rate(http_requests_total{job="api"}[30m]))
- record: job:slo_errors_per_request:ratio_rate1h
expr: |
sum by (job) (rate(http_requests_total{job="api",code=~"5.."}[1h]))
/
sum by (job) (rate(http_requests_total{job="api"}[1h]))
- record: job:slo_errors_per_request:ratio_rate6h
expr: |
sum by (job) (rate(http_requests_total{job="api",code=~"5.."}[6h]))
/
sum by (job) (rate(http_requests_total{job="api"}[6h]))
Les fenêtres de 2 h, 24 h et 3 jours du niveau ticket suivent exactement le même modèle. L'alerte de page combine ensuite les deux premiers niveaux. Le and exige que fenêtre longue et fenêtre courte dépassent ensemble le seuil, le or déclenche dès que l'un des deux niveaux est atteint :
groups:
- name: slo-api-alerts
rules:
- alert: ApiErrorBudgetBurn
expr: |
(
job:slo_errors_per_request:ratio_rate1h{job="api"} > (14.4 * 0.001)
and
job:slo_errors_per_request:ratio_rate5m{job="api"} > (14.4 * 0.001)
)
or
(
job:slo_errors_per_request:ratio_rate6h{job="api"} > (6 * 0.001)
and
job:slo_errors_per_request:ratio_rate30m{job="api"} > (6 * 0.001)
)
labels:
severity: page
annotations:
summary: "L'API consomme son error budget trop vite"
runbook_url: "https://runbooks.example.internal/api/error-budget"
Le même schéma s'applique au SLI de latence, avec un second jeu de recording rules construit sur l'expression des requêtes lentes vue plus haut.
Les services à faible trafic
La méthode suppose un volume suffisant. Sur un service qui reçoit une requête par minute, une seule erreur représente près de 1,7 % des requêtes de l'heure, au-dessus du seuil de 1,44 % du premier niveau, et 20 % de celles des cinq dernières minutes : la page tombe pour un événement isolé. Le Workbook propose quatre réponses : générer du trafic synthétique, regrouper plusieurs petits services sous un même SLO, modifier le service ou l'infrastructure (des tentatives côté client, par exemple) pour qu'une erreur ponctuelle n'atteigne pas l'utilisateur, ou abaisser le SLO et allonger les fenêtres. Aucune n'est gratuite. Le trafic synthétique, en particulier, mesure le chemin que l'on a choisi de tester, pas celui des utilisateurs, et doit donc rester hors du dénominateur des SLI réels.
Ce que nous supprimons, et ce que nous gardons
Une fois les alertes burn rate en place, le tri de l'existant devient possible, et c'est là que l'astreinte gagne réellement en qualité de vie.
- Les alertes CPU ou mémoire sans impact utilisateur démontré : elles deviennent des tableaux de bord ou des tickets
- Les alertes dupliquées entre plusieurs outils, qui réveillent deux fois pour le même incident
- Les alertes sans runbook : on écrit le runbook, ou on supprime l'alerte
Supprimer les alertes sur les causes ne veut pas dire les supprimer toutes. Certaines défaillances sont invisibles dans le SLI jusqu'au moment où elles deviennent brutales : un disque qui se remplit, un certificat qui expire, une file d'attente qui grossit. Ces signaux annoncent une consommation de budget future et méritent une alerte, en général sous forme de ticket, avec une échéance claire plutôt qu'une page à trois heures du matin.
Reste la partie la moins technique et la plus déterminante : décider à l'avance de ce qui se passe quand le budget est épuisé. Sans politique d'error budget acceptée par le produit (gel des mises en production non correctives, priorité donnée à la fiabilité), le SLO reste un chiffre sur un tableau de bord, et l'alerte burn rate une page de plus.
Need help with this topic?
Our engineers can audit your context and propose a concrete action plan.