Comment configurer Alertmanager en 2026 (Guide débutant)

Introduction

Alertmanager est le composant clé de l'écosystème Prometheus pour la gestion intelligente des alertes. Contrairement à un simple relais d'alertes, il déduplique, groupe et route les notifications vers divers récepteurs comme Slack, email ou PagerDuty, évitant les bombardements inutiles lors d'incidents. En 2026, avec la montée des infrastructures cloud-native, maîtriser Alertmanager est essentiel pour tout DevOps ou SRE débutant.

Ce tutoriel vous guide pas à pas pour une installation complète via Docker Compose, incluant Prometheus pour générer des alertes réelles. Vous apprendrez à configurer des routes YAML, à accéder à l'interface web intuitive et à tester un receiver webhook simple. À la fin, vous aurez un setup production-ready, scalable et bookmarkable. Imaginez : une alerte CPU haute déclenche un message Slack groupé – c'est ce pouvoir concret que nous débloquons ici. (128 mots)

Prérequis

Docker et Docker Compose installés (version 20+ recommandée)
Connaissances de base en YAML et Prometheus (concepts simples expliqués)
Un terminal (bash/zsh)
Port 9090, 9093 et 3000 libres sur localhost
Optionnel : compte Slack pour tester les webhooks

Créer la structure du projet

setup.sh

mkdir alertmanager-tutorial
cd alertmanager-tutorial
git init
mkdir -p prometheus/config
mkdir -p alertmanager/config
touch docker-compose.yml
 touch prometheus/config/prometheus.yml
touch prometheus/config/rules.yml
touch alertmanager/config/alertmanager.yml
echo "Projet Alertmanager prêt !"

Ce script bash initialise un dossier projet structuré avec les répertoires nécessaires pour Prometheus et Alertmanager. Il crée tous les fichiers YAML vides, prêts pour la configuration. Évitez les pièges en utilisant des chemins absolus si vous êtes en dehors d'un workspace Git.

Configurer Docker Compose

Docker Compose orchestre Prometheus, Alertmanager et un exporter de métriques (node-exporter) pour simuler des données réelles. Cela évite les installations natives complexes, rendant le setup portable et reproductible.

Fichier docker-compose.yml

docker-compose.yml

version: '3.8'
services:
  prometheus:
    image: prom/prometheus:v2.54.0
    volumes:
      - ./prometheus/config:/etc/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/etc/prometheus/console_libraries'
      - '--web.console.templates=/etc/prometheus/consoles'
    ports:
      - "9090:9090"
    restart: always

  alertmanager:
    image: prom/alertmanager:v0.27.0
    volumes:
      - ./alertmanager/config:/etc/alertmanager
    command:
      - '--config.file=/etc/alertmanager/alertmanager.yml'
      - '--storage.path=/alertmanager'
    ports:
      - "9093:9093"
    restart: always

  node_exporter:
    image: prom/node-exporter:v1.8.2
    ports:
      - "9100:9100"
    restart: always

Ce docker-compose.yml lance trois services : Prometheus (port 9090), Alertmanager (9093) et node-exporter pour des métriques CPU/mémoire. Les volumes montent vos configs YAML personnalisées. Piège courant : oubliez les guillemets sur les commands longues, causant des parse errors.

Configuration Prometheus de base

prometheus/config/prometheus.yml

global:
  scrape_interval: 15s

rule_files:
  - "rules.yml"

alerting:
  alertmanagers:
    - static_configs:
        - targets:
            - alertmanager:9093

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
  - job_name: 'node'
    static_configs:
      - targets: ['node_exporter:9100']

Prometheus scrape les métriques toutes les 15s et forwarde les alertes vers Alertmanager sur le port interne 9093. La section alerting est cruciale : sans elle, pas de routing. Vérifiez toujours les targets pour éviter les connexions refusées en cluster.

Démarrer les services

Exécutez maintenant docker compose up -d dans le dossier projet. Vérifiez les logs avec docker compose logs -f. Accédez à Prometheus sur http://localhost:9090 et Alertmanager sur http://localhost:9093. L'UI d'Alertmanager affiche déjà les silences et configurations en temps réel.

Règle d'alerte CPU haute

prometheus/config/rules.yml

groups:
- name: example
  rules:
  - alert: HighCPUUsage
    expr: 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
    for: 1m
    labels:
      severity: warning
    annotations:
      summary: "CPU usage élevée sur {{ $labels.instance }}"
      description: "CPU > 80% pendant plus de 1 minute."

Cette règle déclenche une alerte si le CPU dépasse 80% pendant 1 minute, avec labels et annotations pour le routing. Rechargez Prometheus via l'UI (Status > Rules) après modification. Analogie : comme un garde qui attend confirmation avant d'appeler les renforts.

Configuration Alertmanager basique

alertmanager/config/alertmanager.yml

global:
  smtp_smarthost: 'localhost:1025'
  smtp_from: 'alertmanager@example.com'

route:
  group_by: ['alertname', 'cluster']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 1h
  receiver: 'default'

receivers:
- name: 'default'
  webhook_configs:
  - url: 'http://httpbin.org/post'

inhibit_rules:
- source_match:
    severity: 'critical'
  target_match:
    severity: 'warning'
  equal: ['alertname', 'cluster', 'service']

Alertmanager groupe les alertes par nom et cluster, attend 30s avant envoi, et route vers un webhook test (httpbin). Les inhibitions évitent les doublons. Redémarrez le container après édition : docker compose restart alertmanager. Piège : identation YAML stricte !

Tester l'alerte

Générer du CPU élevé : docker run --rm -it --cpus=0.8 ubuntu:22.04 stress --cpu 8 --timeout 300s en arrière-plan. Surveillez Prometheus > Graph > requête CPU, puis Alertmanager UI > Alerts. Vous verrez l'alerte groupée !

Ajouter un receiver Slack

alertmanager/config/alertmanager-slack.yml

route:
  receiver: slack
  group_by: ['alertname']

receivers:
- name: slack
  slack_configs:
  - api_url: 'https://hooks.slack.com/services/VOTRE/WEBHOOK'
    channel: '#alerts'
    text: "{{ range .Alerts }}[{{ .Status | toUpper }}{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{ end }}] {{ .AnnotatedInstance }} {{ .Annotations.summary }}{{ end }}"
    send_resolved: true

Remplacez alertmanager.yml par ce snippet pour Slack (obtenez api_url via Slack App). Il formate les messages avec statut et résumé. Testé : alertes résolues s'envoient aussi. Intégrez en prod avec secrets via Docker secrets.

Bonnes pratiques

Group_by stratégique : Groupez par cluster/service pour réduire le bruit (évitez 'instance' seul).
Repeat_interval progressif : 1h pour warning, 5min pour critical – adaptez aux SLAs.
Utilisez l'UI pour silences : Silenciez manuellement via localhost:9093/#/silences au lieu de configs statiques.
Monitoring d'Alertmanager : Ajoutez-le à Prometheus avec scrape_config job_name: 'alertmanager'.
HA setup : Scalez avec plusieurs replicas et Consul pour discovery en prod.

Erreurs courantes à éviter

YAML mal indenté : Alertmanager refuse de démarrer – validez avec yamllint ou IDE.
Ports conflituels : Vérifiez netstat -tuln | grep 9093 avant up.
Pas de rules_files : Alertes muettes – rechargez Prometheus UI après édition.
Targets erronés : En Docker, utilisez noms services (alertmanager:9093), pas localhost.

Pour aller plus loin

Docs officiels : Prometheus Alertmanager
Avancé : Intégrez Grafana pour dashboards alertes.
Formations expertes : Découvrez nos formations Learni sur le monitoring pour Kubernetes + Prometheus en prod.
Repo GitHub exemple : Forkez ce tuto pour vos labs.

Comment configurer Alertmanager en 2026