Alerter et gérer les incidents
Une bonne alerte réveille quelqu'un uniquement quand des utilisateurs souffrent ou vont souffrir, et lui dit quoi faire. Le Well-Architected Framework en tire trois recommandations : prioriser les alertes pour éviter la fatigue (pilier fiabilité), outiller la réponse — rôles, runbooks, gestion centralisée, automatisation (pilier excellence opérationnelle, Manage incidents and problems) — et conduire des postmortems sans recherche de coupable. Dans Cloud Monitoring, une règle d'alerte porte des conditions, des canaux de notification et une documentation ; quand une condition est remplie, elle ouvre une alerte. Le branchement des canaux vers Slack, PagerDuty ou Jira est traité côté DevOps dans Notifications et tickets.
Sur quoi alerter
| Condition | Type Cloud Monitoring | Usage | Notification |
|---|---|---|---|
| Consommation du budget d'erreur | Seuil sur select_slo_burn_rate |
Symptôme utilisateur, calculé sur le SLO (Observer) | Page |
| Taux d'erreur ou latence | Seuil ou requête PromQL (ratio 5xx / total, p99) | Symptôme, sans SLO défini | Page si le seuil reflète l'impact |
| Saturation à venir | Prévision (forecast) sur une jauge : disque, quota | Cause, avec plusieurs heures de marge | Ticket |
| Absence de données | Metric-absence : pas de point pendant la fenêtre (24 h au plus) | Job batch qui n'a pas tourné, agent arrêté, pipeline muet | Ticket ou page |
| Message de journal | Alerte basée sur les journaux (log match) | Événement rare et grave : accès refusé en boucle, corruption | Selon l'événement |
| Nouvelle erreur | Notification Error Reporting | Exception inconnue après une livraison | Ticket |
| Disponibilité externe | Vérification de disponibilité | Site ou API injoignable depuis plusieurs régions | Page |
Le livre SRE de Google résume la règle : on appelle un humain sur les symptômes ; les causes (CPU, mémoire, nombre de pods) vont dans les tableaux de bord et, au pire, dans un ticket. Une alerte qui n'appelle aucune action n'a pas lieu d'être.
Alertes multi-fenêtres sur le taux de consommation
Le taux de consommation (burn rate) rapporte le taux d'erreur observé au taux qui épuiserait exactement le budget en fin de période : 1 signifie « pile dans l'objectif », 14,4 signifie « budget de 30 jours épuisé en deux jours ». Le SRE Workbook (Alerting on SLOs) propose, pour un SLO de 99,9 % sur 30 jours :
| Gravité | Fenêtre longue | Fenêtre courte | Seuil | Budget consommé |
|---|---|---|---|---|
| Page | 1 heure | 5 minutes | 14,4 | 2 % |
| Page | 6 heures | 30 minutes | 6 | 5 % |
| Ticket | 3 jours | 6 heures | 1 | 10 % |
La fenêtre longue garantit que l'événement est significatif ; la fenêtre courte, fixée au douzième de la longue, fait retomber l'alerte quelques minutes après la fin du problème. Dans Cloud Monitoring, chaque fenêtre est une condition de la même règle, combinées par AND. La période d'examen (lookback) de select_slo_burn_rate est limitée à 24 heures : la ligne « 3 jours » se remplace par la recommandation de Google pour la consommation lente, un seuil de 2 sur 24 heures, en ticket.
import pulumi
import pulumi_gcp as gcp
config = pulumi.Config()
astreinte = config.require("canalAstreinte") # projects/PROJECT_ID/notificationChannels/ID
tickets = config.require("canalTickets")
service = gcp.monitoring.CustomService("boutique", service_id="boutique", display_name="Boutique")
def requetes(code: str) -> str:
return ('metric.type="loadbalancing.googleapis.com/https/request_count" '
'resource.type="https_lb_rule" resource.label."url_map_name"="boutique-lb" '
f'metric.label."response_code_class"{code}')
slo = gcp.monitoring.Slo("disponibilite",
service=service.service_id,
slo_id="disponibilite-30j",
display_name="99,9 % de requêtes sans 5xx sur 30 jours",
goal=0.999,
rolling_period_days=30,
request_based_sli={"good_total_ratio": {
"total_service_filter": requetes('!="400"'), # les 4xx ne comptent pas
"bad_service_filter": requetes('="500"'),
}})
def burn(fenetre: str, seuil: float) -> dict:
return {"display_name": f"Burn rate > {seuil} sur {fenetre}",
"condition_threshold": {
"filter": slo.name.apply(lambda n: f'select_slo_burn_rate("{n}", "{fenetre}")'),
"comparison": "COMPARISON_GT",
"threshold_value": seuil,
"duration": "0s"}}
gcp.monitoring.AlertPolicy("burn-rapide",
display_name="Boutique : budget d'erreur consommé vite",
combiner="AND", # fenêtre longue ET fenêtre courte
conditions=[burn("1h", 14.4), burn("5m", 14.4)],
severity="CRITICAL",
notification_channels=[astreinte],
alert_strategy={"auto_close": "1800s"},
documentation={
"subject": "[P1] Boutique : 2 % du budget mensuel consommé en une heure",
"mime_type": "text/markdown",
"content": "Impact : erreurs 5xx sur la boutique.\n\n1. Vérifier Service Health.\n"
"2. Dernier déploiement ? Revenir à la révision précédente.\n3. Sinon, escalader.",
"links": [{"display_name": "Runbook", "url": "https://wiki.example.com/runbooks/boutique"}]})
gcp.monitoring.AlertPolicy("burn-lent",
display_name="Boutique : budget d'erreur consommé lentement",
combiner="OR",
conditions=[burn("24h", 2)],
severity="WARNING",
notification_channels=[tickets])
Les 4xx sont exclus du total parce qu'ils signalent une faute du client. Une règle créée par l'API, donc par Pulumi, notifie aussi à la fermeture de l'alerte ; créée dans la console, elle ne le fait que si l'option est cochée.
Canaux et routage
- Une règle notifie tous ses canaux (16 au plus) : on ne peut pas réserver une notification à un sous-ensemble. Le routage se fait donc par règle : une règle « page » vers PagerDuty ou l'application mobile, une règle « ticket » vers Pub/Sub et la fonction qui crée le ticket Jira.
- Gravité : le champ
severity(CRITICAL,ERROR,WARNING) et les étiquettes utilisateur de la règle voyagent dans la notification ; l'outil d'astreinte ou la fonction de routage s'en servent pour choisir l'escalade. - Rappels :
renotify_intervalrenvoie une notification tant que l'alerte reste ouverte. Acquitter l'alerte n'arrête pas ces rappels ; seule une mise en sourdine ou la désactivation de la règle le fait. - Redondance : Slack, PagerDuty, webhooks et application mobile passent par le même service de Google ; doubler un canal critique par un e-mail ou un canal Pub/Sub.
Cycle de vie d'une alerte
La console parle d'alertes (commande préversion gcloud beta monitoring alerts list) ; la charge utile des notifications webhook et Pub/Sub garde un objet incident.
- Ouverte : la condition est remplie, ou aucune donnée ne dit le contraire. Une seule alerte ouverte par série temporelle, au plus 1 000 par règle.
- Acquittée : quelqu'un a pris l'alerte en main ; le marquer dès le début de l'analyse.
- Fermée : la condition n'est plus remplie, quelqu'un l'a fermée, ou la durée de fermeture automatique (auto-close, 7 jours par défaut, 30 minutes au minimum) s'est écoulée sans observation.
- Mise en sourdine (snooze) : suspend une règle pendant une maintenance et ferme ses alertes ouvertes. Préférable à la désactivation : une règle réactivée réévalue aussitôt sa fenêtre et peut s'ouvrir immédiatement.
La page de détail d'une alerte affiche le graphique de la condition, les journaux de la ressource, les alertes liées et la documentation de la règle. Ne pas modifier la règle pendant l'enquête : Cloud Monitoring jette alors les données précalculées et l'historique de l'alerte.
Runbook, astreinte et postmortem
Runbook. La documentation de la règle part dans chaque notification : un sujet (255 caractères), un corps en Markdown réduit (titres, listes, gras, liens), des variables (${policy.display_name}, ${resource.label.KEY}, ${metric.label.KEY}) et jusqu'à trois liens par l'API. Le pilier excellence opérationnelle y met les étapes de tri, d'investigation, de communication et d'escalade, les outils et les contacts, relus à chaque postmortem.
Astreinte. Rôles définis avant l'incident (responsable de l'incident, communicant, enquêteurs, experts), chemins d'escalade, outil de gestion d'incidents centralisé (PagerDuty, Jira Service Management, GoAlert), base de connaissances des problèmes connus, et remédiations automatisées par une fonction Cloud Run déclenchée par Pub/Sub (retour arrière, bascule de trafic).
Côté Google : Service Health. Personalized Service Health liste les incidents Google Cloud qui touchent les produits et les régions d'un projet ou d'une organisation, par un tableau de bord, une API (servicehealth.googleapis.com) et des journaux servicehealth.googleapis.com/activity sur lesquels poser une alerte basée sur les journaux. Google le présente comme un signal de corroboration : filtrer sur la pertinence Impacted ou Related et les produits critiques plutôt que d'appeler l'astreinte à chaque événement. Si Personalized Service Health est lui-même inaccessible, le runbook renvoie vers la page publique status.cloud.google.com et son flux RSS.
Postmortem. Le pilier fiabilité (Conduct thorough postmortems) fixe les critères avant l'incident : indisponibilité visible au-delà d'un seuil, perte de données, intervention de l'astreinte (retour arrière, bascule), temps de résolution trop long, panne découverte à la main faute de supervision. Le document suit cinq étapes — créer, établir les faits, analyser les causes, planifier, exécuter — et reste sans reproche : il vise les processus et les outils, pas les personnes. Il se partage largement, et ses actions se limitent à ce que la probabilité de récidive justifie.
Pièges
- Fatigue d'alerte. Seuils sur des causes, une règle par VM, alertes sans action : l'astreinte finit par tout ignorer. Une condition non agrégée ouvre une alerte par série temporelle ; agréger par service dans la condition.
- Battement (flapping). Une fenêtre de réévaluation (retest window,
durationdans l'API) trop courte ouvre et ferme la même alerte en boucle : elle repart de zéro à chaque mesure conforme. Allonger la fenêtre, ou passer aux alertes multi-fenêtres. - Absence non surveillée. Une condition de seuil ne se déclenche pas quand la métrique cesse d'arriver : un job arrêté paraît sain. Ajouter une condition d'absence, ou régler
evaluation_missing_datapour traiter l'absence comme une violation. - Alerte qui ne se ferme jamais. Une métrique qui ne renvoie rien en l'absence d'erreur, au lieu d'un zéro, laisse l'alerte ouverte jusqu'à l'auto-close. Faire produire une valeur nulle, ou utiliser une valeur par défaut en PromQL.
- Faible trafic. La nuit, trois erreurs sur vingt requêtes suffisent à franchir un seuil de burn rate : relever le seuil, allonger la fenêtre, ou ajouter du trafic synthétique par une vérification de disponibilité.
- Alertes sur journaux.
notification_rate_limitest obligatoire ; une règle ouvre au plus 20 alertes et envoie au plus 20 notifications par jour. Au-delà, passer par une métrique basée sur les journaux et une condition de seuil. - Délais. La plupart des métriques Google Cloud n'apparaissent qu'une minute après la mesure, et l'évaluation ajoute jusqu'à cinq minutes et demie, avant même la fenêtre de réévaluation. Une alerte ne remplace pas une protection automatique.
Alternatives en logiciel libre
- Prometheus et Alertmanager (Apache 2.0) : règles d'alerte en PromQL, puis regroupement, inhibition, mise en sourdine et routage par étiquettes vers Slack, PagerDuty ou un webhook ; le routage par arbre d'étiquettes y est plus fin que celui d'une règle Cloud Monitoring.
- GoAlert (Apache 2.0) : plannings d'astreinte, rotations, escalades et acquittement par SMS ou appel ; l'équivalent libre d'un outil d'astreinte commercial, alimenté par webhook.
- Sloth (Apache 2.0) : génère à partir d'une déclaration de SLO les règles Prometheus d'enregistrement et les alertes multi-fenêtres, multi-seuils du SRE Workbook.
- Pyrra (Apache 2.0) : même génération de règles de burn rate, avec une interface de suivi du budget d'erreur et des ressources Kubernetes.
- OpenSLO (Apache 2.0) : spécification YAML neutre pour décrire SLI, SLO et politiques d'alerte, lue par plusieurs outils ; utile pour ne pas lier la définition des objectifs à un fournisseur.