Alertes Prometheus Alertmanager sur votre téléphone : routage par gravité, regroupement et résolutions discrètes

Prometheus sait très bien repérer qu’un problème survient. Faire parvenir l’information à une personne, c’est le rôle d’Alertmanager, et dans beaucoup d’installations, l’alerte finit dans un dossier de courriels ou un canal Slack que personne ne lit à 3 h du matin.
Alertmanager n’a pas d’application push propre, mais il dispose d’un récepteur webhook générique, et c’est tout ce qu’il faut pour recevoir les alertes sur votre téléphone. Ce guide le configure avec un routage par gravité : les alertes critical arrivent en mode bruyant, les avertissements arrivent comme des notifications normales, et les « résolues » arrivent discrètement. Tout a été testé avec Alertmanager 0.34.2 et Prometheus 3.15.1 sous Docker. Les charges utiles ont été capturées puis exécutées avec le code de template de Pocket Alert.
Ce dont vous avez besoin
- Alertmanager 0.31 ou plus récent pour la configuration complète. Les versions antérieures sont traitées plus bas.
- L’application Pocket Alert sur votre iPhone ou Android, et une clé API depuis Clés API.
- Une offre payante pour la configuration à trois webhooks, car l’offre gratuite inclut un seul webhook. Une version à un seul webhook se trouve vers la fin.
Ce qu’Alertmanager envoie
Alertmanager n’envoie pas une requête par alerte. Il regroupe les alertes selon les labels de group_by et envoie une notification par groupe : une requête POST avec un corps JSON fixe, "version": "4". Quand deux serveurs tombent avec group_by: ['alertname'], une seule requête part. La voici, légèrement raccourcie :
{
"receiver": "pocketalert-critical",
"status": "firing",
"alerts": [
{
"status": "firing",
"labels": {"alertname": "InstanceDown", "instance": "web-1:9100", "job": "node", "severity": "critical"},
"annotations": {"summary": "web-1:9100 is down"},
"startsAt": "2026-10-31T16:17:04.374Z",
"generatorURL": "http://prometheus.example.com:9090/graph?g0.expr=up%7Bjob%3D%22node%22%7D+%3D%3D+0&g0.tab=1"
},
{
"status": "firing",
"labels": {"alertname": "InstanceDown", "instance": "web-2:9100", "job": "node", "severity": "critical"},
"annotations": {"summary": "web-2:9100 is down"}
}
],
"notification_reason": "first notification",
"groupLabels": {"alertname": "InstanceDown"},
"commonLabels": {"alertname": "InstanceDown", "job": "node", "severity": "critical"},
"commonAnnotations": {},
"routeLabels": {},
"externalURL": "http://alertmanager.example.com:9093",
"version": "4",
"groupKey": "{}/{severity=\"critical\"}:{alertname=\"InstanceDown\"}",
"truncatedAlerts": 0
}
Quatre éléments de cette charge utile déterminent la configuration :
- Une notification push par groupe. Les alertes individuelles se trouvent dans le tableau
alerts, donc le modèle de message doit savoir travailler avec un tableau. commonAnnotationsest souvent vide. Il ne contient que les annotations identiques sur toutes les alertes du groupe. Un résumé qui mentionne l’instance est différent sur chaque alerte, donc il n’apparaît jamais ici.statusappartient au groupe. Il vautresolvedseulement quand toutes les alertes du groupe sont résolues. Quand un serveur se rétablit alors qu’un autre est toujours en panne, le statut restefiringet l’alerte rétablie est listée à l’intérieur avec son propre"status": "resolved".- Il n’existe pas de champ
levelau niveau racine, alors que c’est là qu’un webhook Pocket Alert cherche la priorité. La priorité vient donc du niveau par défaut du webhook, et c’est pourquoi ce guide utilise un webhook par niveau sonore.
Étape 1 : créer les webhooks Pocket Alert
| Webhook | default_level | Reçoit |
|---|---|---|
| Prometheus critique | 2 (critique) | Les groupes en alerte avec severity="critical" |
| Prometheus avertissement | 0 (par défaut) | Tous les autres groupes en alerte |
| Prometheus résolu | -1 (faible) | Les groupes dont toutes les alertes sont résolues |
Les boutons ne peuvent être définis que par l’API. Créez donc les trois webhooks avec un seul script :
PA_KEY='your-api-key'
FIRING='%groupLabels.alertname%: %alerts.#(status=="firing")#|#% firing
%alerts.#(status=="firing").annotations.summary%
Firing: %alerts.#(status=="firing")#.labels.instance%'
RESOLVED='Resolved: %groupLabels.alertname% (%commonLabels.severity%)
%alerts.#.labels.instance%'
BUTTONS='[{"type":"view","label":"Alertmanager","value":"%externalURL%"}]'
create_webhook() {
jq -n --arg name "$1" --argjson level "$2" --arg message "$3" --arg actions "$4" \
'{name: $name, default_level: $level, message: $message, actions: $actions}' |
curl -sS https://api.pocketalert.app/v1/webhooks \
-H "Token: $PA_KEY" \
-H 'Content-Type: application/json' \
--data-binary @- |
jq -r '"\(.name): https://p4a.me/wh/\(.url)"'
}
create_webhook 'Prometheus critical' 2 "$FIRING" "$BUTTONS"
create_webhook 'Prometheus warning' 0 "$FIRING" "$BUTTONS"
create_webhook 'Prometheus resolved' -1 "$RESOLVED" ''
Il affiche trois URL de réception. Conservez le slug à la fin de chacune : vous collerez ces slugs dans alertmanager.yml.
Les espaces réservés %...% sont des chemins GJSON, et GJSON sait interroger les tableaux :
alerts.#(status=="firing")#|#compte les alertes du groupe qui sont encore en cours.alerts.#(status=="firing").annotations.summaryest le résumé de la première alerte en cours.alerts.#(status=="firing")#.labels.instanceliste les instances de toutes les alertes en cours. Le résultat s’affiche sous forme de tableau JSON, comme["web-1:9100","web-2:9100"], car il n’existe pas de fonction de concaténation.
Un chemin inexistant s’affiche comme une chaîne vide. Un mauvais chemin produit donc une ligne vide, et non une alerte perdue. Pocket Alert intitule chaque notification de webhook Webhook <name>, donc le titre affiche « Webhook Prometheus critique » et le nom de l’alerte figure sur la première ligne du message. critical nécessite une offre payante, ce que cette configuration exige de toute façon pour les trois webhooks. Sur iPhone, la notification passe outre l’interrupteur silencieux et le mode Ne pas déranger ; sur Android, elle prend le contrôle de l’écran. Utilisez plutôt 1 (élevé) si vous ne voulez pas que les alertes contournent le mode Ne pas déranger.
Étape 2 : alertmanager.yml
Remplacez les trois espaces réservés *_SLUG par vos slugs :
route:
receiver: pocketalert-warning
group_by: ['alertname']
group_wait: 30s
group_interval: 5m
repeat_interval: 4h
routes:
- matchers: ['severity="critical"']
receiver: pocketalert-critical
group_wait: 10s
repeat_interval: 1h
- matchers: ['severity="info"']
receiver: blackhole
receivers:
- name: pocketalert-critical
webhook_configs:
- url: 'https://p4a.me/wh/{{ if eq .Status "resolved" }}RESOLVED_SLUG{{ else }}CRITICAL_SLUG{{ end }}'
send_resolved: true
max_alerts: 20
- name: pocketalert-warning
webhook_configs:
- url: 'https://p4a.me/wh/{{ if eq .Status "resolved" }}RESOLVED_SLUG{{ else }}WARNING_SLUG{{ end }}'
send_resolved: true
max_alerts: 20
- name: blackhole
inhibit_rules:
- source_matchers: ['severity="critical"']
target_matchers: ['severity="warning"']
equal: ['alertname', 'instance', 'mountpoint']
Fonctionnement des différentes parties :
- Routage par gravité.
severity="critical"va vers le récepteur bruyant,infoest écarté, et tout le reste, y compris les alertes sans labelseverity, passe au récepteur d’avertissement. - L’URL détermine le webhook. Depuis la version 0.31.0, l’
urld’un webhook est un template. Un groupe dont le statut estresolvedpart vers le webhook discret, et tout le reste part vers le webhook propre au récepteur.send_resolvedvaut déjàtruepar défaut pour les webhooks ; il est écrit explicitement pour que personne ne le désactive sans s’en rendre compte. max_alerts: 20limite le nombre d’alertes incluses dans une requête. Lors du test, 25 serveurs sont tombés en même temps. Cela a produit une seule notification indiquant « 20 firing », avectruncatedAlerts: 5dans la charge utile.- Inhibition. Quand l’alerte critique
DiskSpaceLowse déclenche pour un système de fichiers, l’avertissement pour le mêmealertname, la mêmeinstanceet le mêmemountpointest mis en sourdine.amtool alert query --inhibitedl’affiche commesuppressed.
Vérifiez la configuration et le routage avant de recharger :
amtool check-config alertmanager.yml
amtool config routes test --config.file=alertmanager.yml severity=critical alertname=Test
La seconde commande affiche pocketalert-critical.
Démarrez Alertmanager avec --web.external-url défini sur l’adresse que vous pouvez ouvrir depuis votre téléphone. Sans cette option, externalURL vaut seulement le nom d’hôte. Sous Docker, cela donnait http://de48ea5ffc29:9093, ce qui rendait le bouton inutilisable.
Vérifiez d’abord votre version
alertmanager --version doit indiquer 0.31 ou plus récent pour que l’URL templatée fonctionne. La version 0.30.1 accepte exactement cette configuration, et amtool check-config affiche SUCCESS, mais elle n’effectue pas le rendu du template. Elle a envoyé la requête vers /wh/%7B%7B%20if%20eq%20.Status..., qui ne correspond à aucun webhook. Sur les versions antérieures, donnez à chaque récepteur l’URL simple de son propre webhook. Les notifications de résolution arrivent alors au niveau de ce webhook.
Étape 3 : règles avec un label de gravité
Le routage ci-dessus ne fonctionne que si vos règles définissent severity. Voici deux exemples (d’autres idées de surveillance figurent sur la page surveillance de serveurs), avec DiskSpaceLow à deux seuils pour que la règle d’inhibition ait un rôle à jouer :
groups:
- name: node
rules:
- alert: InstanceDown
expr: up{job="node"} == 0
for: 2m
labels:
severity: critical
annotations:
summary: '{{ $labels.instance }} is down'
- alert: DiskSpaceLow
expr: node_filesystem_avail_bytes{fstype!~"tmpfs|overlay"} / node_filesystem_size_bytes * 100 < 15
for: 10m
labels:
severity: warning
annotations:
summary: '{{ $labels.instance }} {{ $labels.mountpoint }} has {{ printf "%.0f" $value }}% free'
- alert: DiskSpaceLow
expr: node_filesystem_avail_bytes{fstype!~"tmpfs|overlay"} / node_filesystem_size_bytes * 100 < 5
for: 5m
labels:
severity: critical
annotations:
summary: '{{ $labels.instance }} {{ $labels.mountpoint }} has {{ printf "%.0f" $value }}% free'
promtool check rules rules.yml valide le fichier. Indiquez à Prometheus le fichier et l’adresse d’Alertmanager dans prometheus.yml :
rule_files: [rules.yml]
alerting:
alertmanagers:
- static_configs:
- targets: ['alertmanager:9093']
Tester avec amtool
Déclenchez une alerte de test, attendez group_wait (10 secondes sur la route critique), puis résolvez-la :
amtool --alertmanager.url=http://localhost:9093 alert add alertname=PocketAlertTest severity=critical instance=test:9100 \
--annotation='summary="Test alert from amtool"'
amtool --alertmanager.url=http://localhost:9093 alert add alertname=PocketAlertTest severity=critical instance=test:9100 \
--annotation='summary="Test alert from amtool"' --end="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
Conservez les guillemets doubles internes dans l’annotation, sinon amtool signale qu’il est revenu à son ancien analyseur. La notification push de résolution arrive au prochain cycle de group_interval, qui peut prendre jusqu’à 5 minutes avec cette configuration.
Ce qui arrive sur votre téléphone
Voici les messages que Pocket Alert affiche à partir des charges utiles réelles du test, où Prometheus a vu web-1 et web-2 tomber puis revenir :
Webhook Prometheus critical
InstanceDown: 2 firing
web-1:9100 is down
Firing: ["web-1:9100","web-2:9100"]
Quand web-1 se rétablit, Alertmanager envoie une mise à jour au prochain group_interval. Le groupe est toujours en alerte, donc la notification part vers le webhook critique :
Webhook Prometheus critical
InstanceDown: 1 firing
web-2:9100 is down
Firing: ["web-2:9100"]
Quand les deux sont revenus, une notification push à faible priorité arrive :
Webhook Prometheus resolved
Resolved: InstanceDown (critical)
["web-1:9100","web-2:9100"]
Minuteurs : éviter les rafales de notifications
| Réglage | Ce qu’il fait | Ici |
|---|---|---|
group_wait | Durée d’attente d’un nouveau groupe avant la première notification push, pour laisser arriver d’autres alertes | 30s, 10s pour critical |
group_interval | Intervalle minimal entre deux notifications push pour un groupe dont les alertes ont changé | 5m |
repeat_interval | Rappel pour un groupe encore en alerte et inchangé | 4h, 1h pour critical |
Un groupe peut envoyer au plus une notification push par group_interval, donc une alerte instable coûte jusqu’à 12 notifications par heure avec 5m. Une panne qui dure une journée coûte 24 rappels avec un repeat_interval de 1h. Le regroupement fait l’essentiel du travail : la panne d’un commutateur qui fait tomber 40 serveurs ne produit qu’une notification push, et non 40. N’utilisez pas group_by: ['...'], qui regroupe par tous les labels et revient à une notification par alerte. Les offres ont des limites quotidiennes de messages (Starter est à 1 000 par jour), et chaque requête vers un webhook qui produit un message compte dans cette limite.
Boutons : Alertmanager et Grafana
Le template BUTTONS ci-dessus ajoute un bouton « Alertmanager ». Vous pouvez ajouter jusqu’à trois boutons d’action. Celui-ci ouvre un tableau de bord Grafana pour la première instance en alerte :
BUTTONS='[{"type":"view","label":"Alertmanager","value":"%externalURL%"},{"type":"view","label":"Grafana","value":"https://grafana.example.com/d/YOUR_DASHBOARD?var-instance=%alerts.#(status=="firing").labels.instance%"}]'
Les guillemets non échappés à l’intérieur de l’espace réservé semblent incorrects, mais ils fonctionnent : Pocket Alert remplace d’abord les espaces réservés, puis analyse le JSON.
Attention aux valeurs vides. Un bouton dont la value est vide est retiré de cette notification ; les autres boutons et le message arrivent quand même. %alerts.0.generatorURL% (le lien vers le graphique Prometheus) est une bonne cible pour les alertes venant de Prometheus, mais les alertes envoyées avec amtool n’ont pas d’URL de générateur et n’affichent donc pas ce bouton. Les boutons d’action sont une fonctionnalité payante.
Alertmanager 0.32+ : appeler directement l’API
Les anciens guides affirment qu’Alertmanager ne peut pas modifier le corps d’un webhook. Cela a changé avec la version 0.32.0, qui ajoute une option payload à webhook_configs. Associée à http_config.http_headers, qui peut envoyer un en-tête Token, elle permet à Alertmanager d’envoyer directement un POST vers https://api.pocketalert.app/v1/messages avec son propre titre et son propre niveau.
Il y a un piège. Alertmanager interprète chaque valeur rendue comme du YAML. Lors du test, une charge utile champ par champ avec message: '{{ range .Alerts }}{{ .Annotations.summary }}...' a transformé le résumé web-1:9100: / has 12% free en l’objet {"web-1:9100": "/ has 12% free"}. L’API rejette cela avec un 400. Alertmanager ne réessaie pas immédiatement une erreur 4xx ; il renvoie le même corps invalide à chaque group_interval, si bien que l’alerte n’arrive jamais.
Construire le corps entier avec dict et toJson évite le problème :
receivers:
- name: pocketalert-api
webhook_configs:
- url: https://api.pocketalert.app/v1/messages
http_config:
http_headers:
Token:
files: [/etc/alertmanager/pocketalert.key]
payload: >-
{{ $msg := "" }}{{ range .Alerts }}{{ $msg = printf "%s%s: %s\n" $msg .Status .Annotations.summary }}{{ end }}
{{ $level := "default" }}{{ if eq .Status "resolved" }}{{ $level = "low" }}{{ else if eq .CommonLabels.severity "critical" }}{{ $level = "critical" }}{{ end }}
{{ dict "title" (printf "[%s] %s" (toUpper .Status) .GroupLabels.alertname) "message" $msg "level" $level | toJson }}
Avec un résumé contenant deux-points et guillemets, la requête envoyée était :
{"level":"critical","message":"firing: web-1:9100: / has 4% free, \"quoted\"\nfiring: web-2:9100 / has 3% free\n","title":"[FIRING] DiskSpaceLow"}
La version résolue est arrivée avec "level":"low".
Alors, lequel choisir ? L’API directe fournit un vrai titre et un niveau pour chaque notification, le tout depuis un seul récepteur et sans webhook. Le webhook n’exige aucune clé API dans Alertmanager et fonctionne sur toutes les versions (la variante à URL simple). Un mauvais chemin s’affiche comme une ligne vide au lieu d’une requête rejetée, et chaque requête apparaît dans l’historique des webhooks. La documentation d’Alertmanager qualifie payload d’option « à vos risques et périls », donc testez-la avec amtool avant de vous y fier.
Avec l’offre gratuite
L’offre gratuite comprend un webhook, 50 messages par jour, aucun bouton, et critical est livré comme high. Créez un webhook avec default_level: 1, placez son URL simple dans un seul récepteur et supprimez les routes par gravité. Les notifications de résolution arrivent alors aussi en high, sauf si vous définissez send_resolved: false. Avec Alertmanager 0.32+, la configuration d’API directe ci-dessus convient mieux à l’offre gratuite, car elle ne nécessite aucun webhook et définit le niveau de chaque notification.
Si rien n’arrive
- Consultez le journal d’Alertmanager. Un envoi échoué journalise
Notify for alerts failedavec le code de statut. Un404signifie un mauvais slug, ou une URL templatée sur une version antérieure à 0.31. - Ouvrez l’historique des webhooks dans Pocket Alert. Si la requête y figure, le problème vient du template. Sinon, Alertmanager ne l’a jamais envoyée.
- Les lignes vides signifient qu’un chemin ne correspond pas à la charge utile. Les noms de champs sont sensibles à la casse.
- Un
%placé juste avant un espace réservé doit être doublé. Un%suivi d’une espace est un texte ordinaire, doncCPU over 90% on %groupLabels.alertname%fonctionne. Écrivez%%lorsque le%touche d’autres caractères, comme dans%commonLabels.usage%%%. - Utilisez le testeur de webhook pour capturer ce qu’Alertmanager envoie réellement avant d’écrire vos templates.
FAQ
Est-ce que cela fonctionne avec kube-prometheus-stack ?
Oui. Le récepteur est une configuration Alertmanager ordinaire ; il s’ajoute à la configuration Alertmanager du chart comme n’importe quel autre récepteur. Vérifiez quelle version d’Alertmanager le chart déploie avant d’utiliser l’URL templatée ou payload. Consultez alertes Kubernetes pour la partie cluster.
J’utilise l’alerting de Grafana et non Alertmanager. Qu’est-ce qui change ?
Grafana envoie son propre format de webhook. Consultez le guide Grafana.
Créez un compte gratuit, exécutez le script, collez les trois slugs dans alertmanager.yml, et la prochaine alerte InstanceDown arrivera sur votre téléphone.