Mes alertes Prometheus envoient trop de spam. Que faire ?

Causes : seuils trop bas, pas de clause for:, pas de regroupement Alertmanager. Solutions : ajuster for: 5m, configurer group_by, ajouter repeat_interval: 4h.

Monitoring réseau PME avec Grafana et Prometheus : tutoriel complet

Lecture : 9 minutes · Niveau : intermédiaire-avancé · Mise à jour : avril 2026

Sans monitoring, vous découvrez les pannes quand vos employés se plaignent. Prometheus + Grafana sont devenus le standard open-source du monitoring moderne. Ce tutoriel installe une stack complète sur un VPS modeste pour surveiller votre infrastructure PME : serveurs, services, sites web, et bien plus.

⚠️ Vérifiez les versions actuelles sur prometheus.io et grafana.com.

Sommaire

Architecture cible
Pré-requis et installation Docker
Stack Docker Compose : Prometheus + Grafana
Premier exporter : Node Exporter (métriques serveur)
Surveiller un site web (Blackbox Exporter)
Dashboards Grafana prêts à l’emploi
Alertes (email, Slack, Telegram)
Sécurisation HTTPS + auth
FAQ

1. Architecture cible

   [Cibles : serveurs, switches, sites web, services]
                       │
                  Exporters (collecteurs sur chaque cible)
                       │
                       ▼
              [Prometheus] (scrape + stocke les métriques)
                       │
                       ▼
              [Grafana] (visualisation, dashboards, alertes)
                       │
                       ▼
              [Alertmanager] (envoie email/Slack/Telegram en cas d'alerte)

Composants

Prometheus : moteur de scraping et base de données time-series
Grafana : interface de visualisation
Alertmanager : routage des alertes
Exporters : un par type de cible (Node Exporter pour serveurs Linux, Blackbox pour sondes HTTP, etc.)

2. Pré-requis et installation Docker

VPS recommandé

2 vCPU, 4 Go RAM minimum (Prometheus consomme de la RAM avec beaucoup de métriques)
50 Go SSD (les métriques s’accumulent — prévoir rétention)
Ubuntu 22.04 ou 24.04

Installation Docker

(Voir n8n auto-hébergé : installation et 5 workflows utiles pour la procédure Docker complète.)

sudo apt update && sudo apt install -y ca-certificates curl gnupg
# ... (suite installation Docker comme dans le tuto n8n)

3. Stack Docker Compose : Prometheus + Grafana

Création du dossier projet

sudo mkdir -p /opt/monitoring && cd /opt/monitoring

`docker-compose.yml`

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    restart: unless-stopped
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=30d'
      - '--web.enable-lifecycle'
    networks:
      - monitoring

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    restart: unless-stopped
    ports:
      - "127.0.0.1:3000:3000"  # accessible via Caddy/Nginx, pas direct
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=GENEREZ_UN_MOT_DE_PASSE_LONG_ICI
    volumes:
      - grafana_data:/var/lib/grafana
    networks:
      - monitoring

  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    restart: unless-stopped
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--path.rootfs=/rootfs'
    networks:
      - monitoring

volumes:
  prometheus_data:
  grafana_data:

networks:
  monitoring:

`prometheus.yml`

global:
  scrape_interval: 30s
  evaluation_interval: 30s

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

  - job_name: 'node-exporter-local'
    static_configs:
      - targets: ['node-exporter:9100']

  # Ajouter ici d'autres serveurs à monitorer (voir section suivante)

Lancement

sudo docker compose up -d
sudo docker compose ps

Grafana accessible sur http://localhost:3000 (admin / votre mot de passe).

4. Premier exporter : Node Exporter (métriques serveur)

Le Node Exporter expose les métriques d’un serveur Linux : CPU, RAM, disque, réseau, charge…

Sur chaque serveur à monitorer (un autre VPS, un serveur local)

# Installation Node Exporter (binaire)
NODE_EXPORTER_VERSION=$(curl -s https://api.github.com/repos/prometheus/node_exporter/releases/latest | grep tag_name | cut -d '"' -f 4 | tr -d 'v')
wget https://github.com/prometheus/node_exporter/releases/download/v${NODE_EXPORTER_VERSION}/node_exporter-${NODE_EXPORTER_VERSION}.linux-amd64.tar.gz
tar xvfz node_exporter-${NODE_EXPORTER_VERSION}.linux-amd64.tar.gz
sudo mv node_exporter-*/node_exporter /usr/local/bin/
sudo useradd -rs /bin/false node_exporter

# Service systemd
sudo tee /etc/systemd/system/node_exporter.service > /dev/null <<EOF
[Unit]
Description=Node Exporter
After=network.target

[Service]
User=node_exporter
Group=node_exporter
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable --now node_exporter
sudo ufw allow from <IP_SERVEUR_PROMETHEUS> to any port 9100

Ajouter cette cible dans Prometheus

Éditer /opt/monitoring/prometheus.yml :

  - job_name: 'serveur-app-1'
    static_configs:
      - targets: ['IP_DU_SERVEUR:9100']

  - job_name: 'serveur-bdd'
    static_configs:
      - targets: ['IP_AUTRE_SERVEUR:9100']

Reload Prometheus sans redémarrer

sudo curl -X POST http://localhost:9090/-/reload

5. Surveiller un site web (Blackbox Exporter)

Pour vérifier qu’un site web répond bien :

Ajouter Blackbox dans `docker-compose.yml`

  blackbox:
    image: prom/blackbox-exporter:latest
    container_name: blackbox
    restart: unless-stopped
    volumes:
      - ./blackbox.yml:/etc/blackbox_exporter/config.yml
    networks:
      - monitoring

`blackbox.yml`

modules:
  http_2xx:
    prober: http
    timeout: 10s
    http:
      preferred_ip_protocol: "ip4"
      valid_status_codes: [200]

Dans `prometheus.yml`

  - job_name: 'blackbox-http'
    metrics_path: /probe
    params:
      module: [http_2xx]
    static_configs:
      - targets:
        - https://votre-pme.sn
        - https://votre-shop.sn
        - https://votre-app.com/api/health
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: blackbox:9115

Recharger Prometheus. Vous verrez désormais le statut de vos sites web.

6. Dashboards Grafana prêts à l’emploi

Grafana dispose d’une bibliothèque de dashboards prêts à importer.

Étapes

Grafana → Connections → Data Sources → Add data source → Prometheus
URL : http://prometheus:9090
Save & Test
Dashboards → New → Import
Entrer un ID depuis grafana.com/grafana/dashboards

Dashboards utiles à importer

Node Exporter Full : monitoring complet serveur Linux
Blackbox Exporter : status sites web et endpoints
Docker Containers : monitoring conteneurs Docker
NGINX/Caddy : trafic reverse proxy

Chaque dashboard a un ID que vous trouvez sur la page Grafana. L’import prend 30 secondes.

7. Alertes (email, Slack, Telegram)

Ajouter Alertmanager

  alertmanager:
    image: prom/alertmanager:latest
    container_name: alertmanager
    restart: unless-stopped
    volumes:
      - ./alertmanager.yml:/etc/alertmanager/alertmanager.yml
    networks:
      - monitoring

`alertmanager.yml` (exemple Slack)

route:
  receiver: 'slack'

receivers:
  - name: 'slack'
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/VOTRE_WEBHOOK_SLACK'
        channel: '#alertes'
        title: '{{ .GroupLabels.alertname }}'
        text: '{{ range .Alerts }}{{ .Annotations.description }}{{ end }}'

Ajouter Alertmanager à Prometheus (`prometheus.yml`)

alerting:
  alertmanagers:
    - static_configs:
        - targets: ['alertmanager:9093']

rule_files:
  - 'alerts.yml'

`alerts.yml` — règles d’alerte

groups:
  - name: serveurs
    rules:
      - alert: ServeurDown
        expr: up == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Serveur {{ $labels.instance }} hors ligne"
          description: "Serveur {{ $labels.instance }} ne répond plus depuis 2 minutes."

      - alert: DisqueRempli
        expr: 100 - ((node_filesystem_avail_bytes * 100) / node_filesystem_size_bytes) > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Disque {{ $labels.instance }} > 85%"
          description: "Disque {{ $labels.mountpoint }} sur {{ $labels.instance }} est rempli à {{ $value }}%."

      - alert: SiteWebDown
        expr: probe_success == 0
        for: 3m
        labels:
          severity: critical
        annotations:
          summary: "Site {{ $labels.instance }} inaccessible"

Reload Prometheus. Les alertes s’enverront vers Slack en cas de dépassement.

8. Sécurisation HTTPS + auth

Reverse proxy Caddy

Ajouter Caddy au stack pour HTTPS automatique sur Grafana :

  caddy:
    image: caddy:latest
    container_name: caddy
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - caddy_data:/data
    networks:
      - monitoring

volumes:
  caddy_data:

`Caddyfile`

grafana.votre-pme.sn {
    reverse_proxy grafana:3000
}

(Configurer le DNS grafana.votre-pme.sn vers l’IP du VPS.)

Bonnes pratiques sécurité

2FA Grafana : activer dans Configuration → Users
Authentification SSO si vous avez Workspace ou autre IdP
Pas d’exposition Prometheus directe sur Internet (uniquement via Grafana)
Rate limiting sur Caddy si exposé largement

9. FAQ

Combien d’espace disque pour Prometheus avec X serveurs monitored ?

Très variable selon le nombre de métriques et la rétention. Ordre de grandeur : 1-3 Go par mois pour 5-10 serveurs monitorés en métriques système standard. Avec rétention 30 jours : prévoir 5-15 Go.

Quelle alternative à Prometheus si je veux plus simple ?

Uptime Kuma : surveillance disponibilité services, interface très simple
Netdata : métriques en temps réel par machine, dashboards prêts
Zabbix : suite complète mais plus lourde
InfluxDB + Telegraf + Grafana : alternative time-series

Pour démarrer ultra-simple sur la disponibilité : Uptime Kuma. Pour aller loin : Prometheus.

Mes alertes envoient trop de spam. Que faire ?

Causes : (1) seuils trop bas ; (2) pas de for: clause (alerte au moindre flap) ; (3) pas de regroupement dans Alertmanager. Solutions : ajuster for: 5m, configurer group_by dans Alertmanager, ajouter repeat_interval: 4h.

Puis-je utiliser Grafana Cloud (offre managée) ?

Oui. Grafana Cloud propose un plan gratuit limité, et payant au-delà. Vérifier les conditions actuelles. Avantage : pas d’infra à gérer. Inconvénient : dépendance à un fournisseur, données chez lui.

Comment monitorer un site WordPress / WooCommerce ?

Compléments utiles : (1) Blackbox Exporter pour disponibilité ; (2) Apache/NGINX exporter pour trafic ; (3) MySQL/MariaDB exporter pour DB ; (4) plugin WP Crontrol pour vérifier les cron WP.

Combien de temps pour avoir un setup utilisable ?

Compter 2-4 heures pour un développeur autodidacte qui découvre Prometheus, 30 min une fois familier. Les premiers dashboards utiles sont disponibles dès le premier soir d’installation.