MemoriaGCP

tekio.org

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.

urgent différable critère atteint actions correctives Règle d'alerte condition franchie Alerte ouverte notification Acquittée runbook suivi Fermée condition levée Page PagerDuty, mobile Ticket Pub/Sub, Jira Postmortem sans reproche
Cycle de vie d'une alerte, de la règle au postmortem

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_interval renvoie 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, duration dans 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_data pour 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_limit est 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.