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

> Envoyez les alertes Prometheus Alertmanager sur iPhone et Android sous forme de notifications push. Une notification par groupe d’alertes, alertes critiques bruyantes, avertissements normaux, résolutions discrètes. Un alertmanager.yml testé, des exemples de règles et le cas où l’option payload d’Alertmanager 0.32 est le meilleur choix.

*29.10.2026*

<!-- source: https://pocketalert.app/fr/blog/prometheus-alertmanager-notifications -->

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](/get-app), et une clé API depuis [Clés API](/account/apikeys).
- 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 :

```json
{
  "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.
- **`commonAnnotations` est 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.
- **`status` appartient au groupe.** Il vaut `resolved` seulement 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 reste `firing` et l’alerte rétablie est listée à l’intérieur avec son propre `"status": "resolved"`.
- **Il n’existe pas de champ `level` au 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

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Webhook</th><th><code>default_level</code></th><th>Reçoit</th></tr></thead>
<tbody>
<tr><th>Prometheus critique</th><td><code>2</code> (critique)</td><td>Les groupes en alerte avec <code>severity="critical"</code></td></tr>
<tr><th>Prometheus avertissement</th><td><code>0</code> (par défaut)</td><td>Tous les autres groupes en alerte</td></tr>
<tr><th>Prometheus résolu</th><td><code>-1</code> (faible)</td><td>Les groupes dont toutes les alertes sont résolues</td></tr>
</tbody>
</table>
</div>

Les boutons ne peuvent être définis que par l’API. Créez donc les trois webhooks avec un seul script :

```bash
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](https://info.pocketalert.app/api/webhooks/settings), et GJSON sait interroger les tableaux :

- `alerts.#(status=="firing")#|#` compte les alertes du groupe qui sont encore en cours.
- `alerts.#(status=="firing").annotations.summary` est le résumé de la première alerte en cours.
- `alerts.#(status=="firing")#.labels.instance` liste 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 :

```yaml
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, `info` est écarté, et tout le reste, y compris les alertes sans label `severity`, passe au récepteur d’avertissement.
- **L’URL détermine le webhook.** Depuis la version 0.31.0, l’`url` d’un webhook est un template. Un groupe dont le statut est `resolved` part vers le webhook discret, et tout le reste part vers le webhook propre au récepteur. `send_resolved` vaut déjà `true` par défaut pour les webhooks ; il est écrit explicitement pour que personne ne le désactive sans s’en rendre compte.
- **`max_alerts: 20`** limite 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 », avec `truncatedAlerts: 5` dans la charge utile.
- **Inhibition.** Quand l’alerte critique `DiskSpaceLow` se déclenche pour un système de fichiers, l’avertissement pour le même `alertname`, la même `instance` et le même `mountpoint` est mis en sourdine. `amtool alert query --inhibited` l’affiche comme `suppressed`.

Vérifiez la configuration et le routage avant de recharger :

```bash
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](/use-cases/server-monitoring)), avec `DiskSpaceLow` à deux seuils pour que la règle d’inhibition ait un rôle à jouer :

```yaml
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` :

```yaml
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 :

```bash
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 :

```text
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 :

```text
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 :

```text
Webhook Prometheus resolved
Resolved: InstanceDown (critical)
["web-1:9100","web-2:9100"]
```

## Minuteurs : éviter les rafales de notifications

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Réglage</th><th>Ce qu’il fait</th><th>Ici</th></tr></thead>
<tbody>
<tr><th><code>group_wait</code></th><td>Durée d’attente d’un nouveau groupe avant la première notification push, pour laisser arriver d’autres alertes</td><td>30s, 10s pour critical</td></tr>
<tr><th><code>group_interval</code></th><td>Intervalle minimal entre deux notifications push pour un groupe dont les alertes ont changé</td><td>5m</td></tr>
<tr><th><code>repeat_interval</code></th><td>Rappel pour un groupe encore en alerte et inchangé</td><td>4h, 1h pour critical</td></tr>
</tbody>
</table>
</div>

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](https://info.pocketalert.app/features/daily-limits) (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](/features/action-buttons). Celui-ci ouvre un tableau de bord Grafana pour la première instance en alerte :

```bash
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 :

```yaml
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 :

```json
{"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](/features/webhook-history). 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 failed` avec le code de statut. Un `404` signifie 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, donc `CPU over 90% on %groupLabels.alertname%` fonctionne. Écrivez `%%` lorsque le `%` touche d’autres caractères, comme dans `%commonLabels.usage%%%`.
- **Utilisez le [testeur de webhook](/tools/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](/use-cases/kubernetes-alerts) 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](/blog/how-to-integrate-grafana-into-pocketalert).

[Créez un compte gratuit](/signup), exécutez le script, collez les trois slugs dans `alertmanager.yml`, et la prochaine alerte `InstanceDown` arrivera sur votre téléphone.
