ARCHITECTURE DE SURVEILLANCE PROMETHEUS + GRAFANA Cibles node_exporter :9100 cAdvisor :8080 scrape Prometheus TSDB Storage PromQL Engine Alert Rules :9090 alertes Alertmanager :9093 requete Grafana Dashboards Panels & Graphs Alert Contacts :3000 voir Navigateur Tableaux de bord en direct & Alertes

Savoir ce qui se passe sur vos serveurs n’est pas optionnel — c’est essentiel. Que vous geriez un seul VPS ou une flotte de machines de production, la visibilite en temps reel sur l’utilisation du CPU, la consommation de memoire, les E/S disque et le trafic reseau est ce qui separe la gestion proactive de l’infrastructure de la lutte contre les incendies. Prometheus et Grafana forment ensemble la pile de surveillance open source la plus largement adoptee dans l’industrie, alimentant l’observabilite dans les organisations des startups aux grandes entreprises.

Ce guide vous accompagne a travers le processus complet : installer Prometheus et node_exporter pour collecter les metriques systeme, configurer Grafana pour la visualisation, ecrire des requetes PromQL, configurer les alertes avec Alertmanager et surveiller les conteneurs Docker avec cAdvisor. A la fin, vous aurez une pile de surveillance entierement fonctionnelle tournant sur Ubuntu.

Prerequis

Avant de commencer, assurez-vous d’avoir :

  • Un serveur sous Ubuntu 22.04 ou 24.04 (edition bureau ou serveur)
  • Un acces au terminal avec les privileges sudo
  • Au moins 2 Go de RAM et 20 Go d’espace disque libre
  • Les ports 9090 (Prometheus), 9100 (node_exporter), 3000 (Grafana) et 9093 (Alertmanager) disponibles
  • Une familiarite de base avec la ligne de commande Linux et la syntaxe YAML
  • Docker installe (optionnel, pour la section cAdvisor) — consultez notre guide d’installation de Docker

Note : Toutes les commandes de ce guide sont pour Ubuntu sur l’architecture amd64. Si vous utilisez ARM64, ajustez les URLs de telechargement pour utiliser les variantes de binaires linux-arm64.

Que sont Prometheus et Grafana ?

Prometheus est un ensemble d’outils de surveillance et d’alerte systeme open source, construit a l’origine chez SoundCloud en 2012. Il collecte des metriques en interrogeant des endpoints HTTP a intervalles reguliers, les stocke dans une base de donnees de series temporelles (TSDB) et fournit un puissant langage de requete appele PromQL pour l’analyse. Prometheus suit un modele pull — il va activement chercher les metriques sur vos serveurs plutot que d’attendre que les donnees soient envoyees.

Grafana est une plateforme d’analyse et de visualisation interactive open source. Elle se connecte a des sources de donnees comme Prometheus, Elasticsearch, InfluxDB et PostgreSQL pour afficher des tableaux de bord en temps reel avec des graphiques, des tableaux, des cartes thermiques et des alertes. Grafana ne stocke pas les donnees lui-meme ; il interroge la source de donnees sous-jacente a la demande.

Ensemble, ils forment un pipeline de surveillance complet :

  1. Les exportateurs (comme node_exporter) exposent des metriques sur des endpoints HTTP
  2. Prometheus collecte et stocke ces metriques
  3. Grafana interroge Prometheus et affiche les donnees visuellement
  4. Alertmanager gere les notifications lorsque les metriques depassent les seuils definis

Vue d’Ensemble de l’Architecture de Surveillance

Comprendre le flux de donnees est essentiel avant de deployer la pile :

┌─────────────────┐     scrape      ┌──────────────┐     query     ┌──────────────┐
│  node_exporter  │────────────────>│  Prometheus   │<─────────────│   Grafana    │
│  :9100          │  /metrics       │  :9090        │              │   :3000      │
└─────────────────┘                 │              │              │              │
                                    │  TSDB        │              │  Dashboards  │
┌─────────────────┐     scrape      │  PromQL      │              │  Panels      │
│  cAdvisor       │────────────────>│  Alert Rules  │              │  Alerts      │
│  :8080          │  /metrics       │              │              └──────────────┘
└─────────────────┘                 └──────┬───────┘
                                           │ fire alerts
                                    ┌──────▼───────┐
                                    │ Alertmanager  │──> Email / Slack / PagerDuty
                                    │ :9093         │
                                    └──────────────┘

Prometheus utilise un modele pull : il envoie periodiquement des requetes HTTP GET aux cibles configurees (exportateurs) pour recuperer les dernieres metriques. Chaque exportateur expose un endpoint /metrics qui renvoie les donnees au format d’exposition Prometheus. Cette architecture signifie que les cibles n’ont pas besoin de connaitre Prometheus — elles servent simplement leurs metriques lorsqu’elles sont interrogees.

Installation de Prometheus

Commencez par creer un utilisateur systeme dedie et les repertoires necessaires :

sudo useradd --no-create-home --shell /bin/false prometheus
sudo mkdir -p /etc/prometheus /var/lib/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus

Telechargez la derniere version de Prometheus (consultez prometheus.io/download pour la version actuelle) :

cd /tmp
wget https://github.com/prometheus/prometheus/releases/download/v2.53.0/prometheus-2.53.0.linux-amd64.tar.gz
tar xvf prometheus-2.53.0.linux-amd64.tar.gz
cd prometheus-2.53.0.linux-amd64

Copiez les binaires et les fichiers de configuration :

sudo cp prometheus promtool /usr/local/bin/
sudo cp -r consoles console_libraries /etc/prometheus/
sudo cp prometheus.yml /etc/prometheus/
sudo chown -R prometheus:prometheus /etc/prometheus

Verifiez l’installation :

prometheus --version

Vous devriez voir une sortie affichant la version, la date de compilation et la version de Go.

Configuration de Prometheus

Le fichier de configuration principal est /etc/prometheus/prometheus.yml. Ce fichier YAML definit les parametres globaux, les intervalles de scrape et les endpoints cibles.

Creez une configuration propre :

sudo nano /etc/prometheus/prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s
  scrape_timeout: 10s

alerting:
  alertmanagers:
    - static_configs:
        - targets:
            - localhost:9093

rule_files:
  - "alert_rules.yml"

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

  - job_name: "node"
    static_configs:
      - targets: ["localhost:9100"]

Parametres cles de configuration :

  • scrape_interval : La frequence a laquelle Prometheus interroge les cibles (15 secondes est la valeur recommandee par defaut)
  • evaluation_interval : La frequence a laquelle Prometheus evalue les regles d’alertes
  • scrape_timeout : Temps maximum d’attente pour une reponse de scrape avant de marquer la cible comme hors service
  • job_name : Un label applique a toutes les metriques collectees depuis les cibles de ce groupe
  • static_configs : Une liste d’endpoints cibles a interroger

Creez un fichier de service systemd pour Prometheus :

sudo nano /etc/systemd/system/prometheus.service
[Unit]
Description=Prometheus Monitoring System
Wants=network-online.target
After=network-online.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/prometheus \
  --config.file=/etc/prometheus/prometheus.yml \
  --storage.tsdb.path=/var/lib/prometheus/ \
  --web.console.templates=/etc/prometheus/consoles \
  --web.console.libraries=/etc/prometheus/console_libraries \
  --storage.tsdb.retention.time=30d \
  --web.enable-lifecycle
ExecReload=/bin/kill -HUP $MAINPID
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target

Activez et demarrez Prometheus :

sudo systemctl daemon-reload
sudo systemctl enable prometheus
sudo systemctl start prometheus
sudo systemctl status prometheus

Prometheus devrait maintenant fonctionner et etre accessible a http://ip-de-votre-serveur:9090.

Installation et Configuration de node_exporter

node_exporter est l’exportateur Prometheus standard pour les metriques materiel et systeme d’exploitation. Il expose des statistiques CPU, memoire, disque, systeme de fichiers et reseau sur le port 9100.

Creez un utilisateur dedie et telechargez node_exporter :

sudo useradd --no-create-home --shell /bin/false node_exporter

cd /tmp
wget https://github.com/prometheus/node_exporter/releases/download/v1.8.1/node_exporter-1.8.1.linux-amd64.tar.gz
tar xvf node_exporter-1.8.1.linux-amd64.tar.gz
sudo cp node_exporter-1.8.1.linux-amd64/node_exporter /usr/local/bin/
sudo chown node_exporter:node_exporter /usr/local/bin/node_exporter

Creez le service systemd :

sudo nano /etc/systemd/system/node_exporter.service
[Unit]
Description=Prometheus Node Exporter
Wants=network-online.target
After=network-online.target

[Service]
User=node_exporter
Group=node_exporter
Type=simple
ExecStart=/usr/local/bin/node_exporter \
  --collector.systemd \
  --collector.processes
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target

Activez et demarrez node_exporter :

sudo systemctl daemon-reload
sudo systemctl enable node_exporter
sudo systemctl start node_exporter

Verifiez que les metriques sont exposees :

curl -s http://localhost:9100/metrics | head -20

Vous devriez voir des lignes commencant par # HELP et # TYPE suivies de noms de metriques et de valeurs. Confirmez que Prometheus collecte les metriques de node_exporter en naviguant vers http://ip-de-votre-serveur:9090/targets — le job node devrait afficher un statut UP.

Installation de Grafana

Ajoutez le depot APT officiel de Grafana :

sudo apt-get install -y apt-transport-https software-properties-common wget
sudo mkdir -p /etc/apt/keyrings/

wget -q -O - https://apt.grafana.com/gpg.key | gpg --dearmor | sudo tee /etc/apt/keyrings/grafana.gpg > /dev/null

echo "deb [signed-by=/etc/apt/keyrings/grafana.gpg] https://apt.grafana.com stable main" | sudo tee /etc/apt/sources.list.d/grafana.list

Installez et demarrez Grafana :

sudo apt-get update
sudo apt-get install grafana -y
sudo systemctl daemon-reload
sudo systemctl enable grafana-server
sudo systemctl start grafana-server

Verifiez que Grafana fonctionne :

sudo systemctl status grafana-server

Grafana est maintenant accessible a http://ip-de-votre-serveur:3000. Les identifiants par defaut sont admin / admin. Vous serez invite a changer le mot de passe lors de la premiere connexion.

Securite : Changez immediatement le mot de passe administrateur par defaut. En production, configurez Grafana derriere un proxy inverse avec HTTPS.

Creation de votre Premier Tableau de Bord

Apres vous etre connecte a Grafana, ajoutez Prometheus comme source de donnees :

  1. Naviguez vers Connections > Data Sources > Add data source
  2. Selectionnez Prometheus
  3. Definissez l’URL sur http://localhost:9090
  4. Cliquez sur Save & Test — vous devriez voir “Successfully queried the Prometheus API”

Importez le tableau de bord largement utilise Node Exporter Full :

  1. Naviguez vers Dashboards > New > Import
  2. Entrez l’ID du tableau de bord 1860 (Node Exporter Full par rfmoz)
  3. Selectionnez votre source de donnees Prometheus
  4. Cliquez sur Import

Ce tableau de bord fournit des panneaux complets pour l’utilisation CPU, l’utilisation memoire, les E/S disque, le trafic reseau, l’utilisation du systeme de fichiers et la charge systeme — le tout sans ecrire une seule requete.

Pour creer un panneau personnalise :

  1. Cliquez sur Add > Visualization dans n’importe quel tableau de bord
  2. Dans l’editeur de requetes, entrez une expression PromQL telle que :
100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)
  1. Cela calcule le pourcentage d’utilisation globale du CPU
  2. Configurez le titre du panneau, la legende, les seuils et le format d’unite
  3. Cliquez sur Apply pour sauvegarder le panneau

Bases de PromQL

PromQL (Prometheus Query Language) est un langage de requete fonctionnel qui vous permet de selectionner, agreger et transformer des donnees de series temporelles. Comprendre PromQL est essentiel pour construire des tableaux de bord et des regles d’alerte utiles.

Les vecteurs instantanes retournent la valeur la plus recente pour chaque serie temporelle :

node_memory_MemAvailable_bytes

Les vecteurs d’intervalle retournent des valeurs sur une fenetre temporelle :

node_cpu_seconds_total[5m]

rate() calcule le taux moyen d’augmentation par seconde (essentiel pour les compteurs) :

rate(node_cpu_seconds_total{mode="idle"}[5m])

Les operateurs d’agregation combinent plusieurs series temporelles :

# Utilisation moyenne du CPU sur tous les coeurs
avg without(cpu) (rate(node_cpu_seconds_total{mode="idle"}[5m]))

# Memoire totale sur toutes les instances
sum by(instance) (node_memory_MemTotal_bytes)

# Top 5 des instances par utilisation CPU
topk(5, 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100))

Les operations mathematiques permettent de combiner des metriques :

# Pourcentage d'utilisation de la memoire
(1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100

# Pourcentage d'utilisation du disque
(1 - node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}) * 100

Le filtrage par labels utilise des accolades :

# Filtrer par instance specifique
node_cpu_seconds_total{instance="server1:9100", mode!="idle"}

# Correspondance regex
node_filesystem_avail_bytes{mountpoint=~"/|/home"}

Configuration des Regles d’Alertes

Prometheus evalue les regles d’alertes a l’evaluation_interval defini dans la configuration globale. Lorsqu’une condition de regle est remplie, Prometheus declenche une alerte vers Alertmanager, qui gere la deduplication, le regroupement et le routage vers les canaux de notification.

Creez un fichier de regles d’alerte :

sudo nano /etc/prometheus/alert_rules.yml
groups:
  - name: system_alerts
    rules:
      - alert: HighCPUUsage
        expr: 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Utilisation CPU elevee sur {{ $labels.instance }}"
          description: "L'utilisation CPU est superieure a 85% depuis plus de 5 minutes (valeur actuelle : {{ $value }}%)"

      - alert: HighMemoryUsage
        expr: (1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100 > 90
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Utilisation memoire elevee sur {{ $labels.instance }}"
          description: "L'utilisation memoire est superieure a 90% depuis plus de 5 minutes (valeur actuelle : {{ $value }}%)"

      - alert: DiskSpaceLow
        expr: (1 - node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}) * 100 > 85
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "Espace disque faible sur {{ $labels.instance }}"
          description: "L'utilisation du systeme de fichiers racine est superieure a 85% (valeur actuelle : {{ $value }}%)"

      - alert: InstanceDown
        expr: up == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "L'instance {{ $labels.instance }} est hors service"
          description: "{{ $labels.instance }} du job {{ $labels.job }} est hors service depuis plus de 2 minutes."

Validez le fichier de regles :

promtool check rules /etc/prometheus/alert_rules.yml

Maintenant installez Alertmanager :

cd /tmp
wget https://github.com/prometheus/alertmanager/releases/download/v0.27.0/alertmanager-0.27.0.linux-amd64.tar.gz
tar xvf alertmanager-0.27.0.linux-amd64.tar.gz

sudo useradd --no-create-home --shell /bin/false alertmanager
sudo mkdir -p /etc/alertmanager /var/lib/alertmanager
sudo cp alertmanager-0.27.0.linux-amd64/alertmanager /usr/local/bin/
sudo cp alertmanager-0.27.0.linux-amd64/amtool /usr/local/bin/
sudo chown alertmanager:alertmanager /usr/local/bin/alertmanager /usr/local/bin/amtool

Configurez Alertmanager :

sudo nano /etc/alertmanager/alertmanager.yml
global:
  resolve_timeout: 5m

route:
  group_by: ['alertname', 'severity']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 4h
  receiver: 'email-notifications'

receivers:
  - name: 'email-notifications'
    email_configs:
      - to: 'admin@example.com'
        from: 'alertmanager@example.com'
        smarthost: 'smtp.example.com:587'
        auth_username: 'alertmanager@example.com'
        auth_password: 'your-app-password'
        require_tls: true

  - name: 'slack-notifications'
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/YOUR/WEBHOOK/URL'
        channel: '#alerts'
        send_resolved: true
        title: '{{ .GroupLabels.alertname }}'
        text: '{{ range .Alerts }}{{ .Annotations.description }}{{ end }}'

Creez le service systemd d’Alertmanager :

sudo nano /etc/systemd/system/alertmanager.service
[Unit]
Description=Prometheus Alertmanager
Wants=network-online.target
After=network-online.target

[Service]
User=alertmanager
Group=alertmanager
Type=simple
ExecStart=/usr/local/bin/alertmanager \
  --config.file=/etc/alertmanager/alertmanager.yml \
  --storage.path=/var/lib/alertmanager/
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target
sudo systemctl daemon-reload
sudo systemctl enable alertmanager
sudo systemctl start alertmanager

Rechargez Prometheus pour prendre en compte les nouvelles regles d’alerte :

sudo systemctl restart prometheus

Verifiez vos alertes sur http://ip-de-votre-serveur:9090/alerts et consultez Alertmanager sur http://ip-de-votre-serveur:9093.

Surveillance des Conteneurs Docker avec cAdvisor

cAdvisor (Container Advisor) fournit des metriques d’utilisation des ressources et de performance au niveau des conteneurs. Il s’execute lui-meme comme un conteneur Docker et expose des metriques au format Prometheus.

Demarrez cAdvisor :

docker run -d \
  --name=cadvisor \
  --restart=always \
  --volume=/:/rootfs:ro \
  --volume=/var/run:/var/run:ro \
  --volume=/sys:/sys:ro \
  --volume=/var/lib/docker/:/var/lib/docker:ro \
  --volume=/dev/disk/:/dev/disk:ro \
  --publish=8080:8080 \
  --privileged \
  --device=/dev/kmsg \
  gcr.io/cadvisor/cadvisor:v0.49.1

Ajoutez cAdvisor comme cible de scrape Prometheus dans /etc/prometheus/prometheus.yml :

  - job_name: "cadvisor"
    static_configs:
      - targets: ["localhost:8080"]

Rechargez Prometheus :

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

Requetes PromQL utiles pour cAdvisor :

# Utilisation CPU du conteneur
rate(container_cpu_usage_seconds_total{name!=""}[5m])

# Utilisation memoire du conteneur
container_memory_usage_bytes{name!=""}

# Octets recus par le reseau du conteneur
rate(container_network_receive_bytes_total{name!=""}[5m])

# Utilisation du systeme de fichiers du conteneur
container_fs_usage_bytes{name!=""}

Importez le tableau de bord Grafana avec l’ID 14282 (cAdvisor Exporter) pour des panneaux de surveillance de conteneurs preconstruits.

Reference des Requetes PromQL Utiles

RequeteDescription
upVerifier si les cibles sont accessibles (1 = actif, 0 = hors service)
rate(node_cpu_seconds_total{mode="idle"}[5m])Taux d’inactivite CPU par coeur
node_memory_MemAvailable_bytes / 1024 / 1024Memoire disponible en Mo
(1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100Pourcentage d’utilisation memoire
rate(node_disk_read_bytes_total[5m])Debit de lecture disque
rate(node_disk_written_bytes_total[5m])Debit d’ecriture disque
rate(node_network_receive_bytes_total[5m])Trafic reseau entrant
rate(node_network_transmit_bytes_total[5m])Trafic reseau sortant
node_filesystem_avail_bytes{mountpoint="/"}Espace disque disponible sur la racine
node_load1 / node_load5 / node_load15Moyennes de charge systeme
rate(node_cpu_seconds_total{mode="iowait"}[5m])Pourcentage d’attente E/S
node_time_seconds - node_boot_time_secondsTemps de fonctionnement du systeme en secondes
count(node_cpu_seconds_total{mode="idle"})Nombre de coeurs CPU
rate(container_cpu_usage_seconds_total{name!=""}[5m])Utilisation CPU du conteneur

Depannage

Prometheus ne demarre pas :

Verifiez la syntaxe de la configuration :

promtool check config /etc/prometheus/prometheus.yml

Verifiez les journaux du service :

sudo journalctl -u prometheus -f --no-pager

Les problemes courants incluent des erreurs d’indentation YAML, des intervalles de scrape invalides et des problemes de permissions sur /var/lib/prometheus.

La cible apparait comme DOWN dans Prometheus :

Verifiez que l’exportateur fonctionne :

sudo systemctl status node_exporter
curl -v http://localhost:9100/metrics

Verifiez le pare-feu :

sudo ufw status
sudo ufw allow 9100/tcp

Grafana ne peut pas se connecter a Prometheus :

Assurez-vous que Prometheus ecoute sur la bonne adresse. Si Grafana et Prometheus sont sur le meme serveur, utilisez http://localhost:9090. Verifiez la connectivite :

curl http://localhost:9090/api/v1/query?query=up

Pas de donnees dans les panneaux Grafana :

Verifiez le selecteur de plage temporelle dans le tableau de bord. La valeur par defaut peut etre en dehors de votre fenetre de retention de donnees. Confirmez egalement que la source de donnees Prometheus est selectionnee dans l’editeur de requetes du panneau.

Utilisation memoire elevee par Prometheus :

Reduisez le nombre de series temporelles en limitant les exportateurs ou en ajoutant des regles de reetiquetage de metriques. Verifiez la memoire actuelle et le nombre de series :

curl http://localhost:9090/api/v1/status/tsdb

Envisagez de reduire le temps de retention :

--storage.tsdb.retention.time=15d

Alertmanager n’envoie pas de notifications :

Testez la configuration d’Alertmanager :

amtool check-config /etc/alertmanager/alertmanager.yml

Envoyez une alerte de test :

amtool alert add alertname=TestAlert severity=critical --alertmanager.url=http://localhost:9093

Resume

Vous disposez maintenant d’une pile de surveillance complete fonctionnant sur votre serveur : Prometheus collectant les metriques de node_exporter et cAdvisor, Grafana affichant des tableaux de bord en temps reel, et Alertmanager delivrant des notifications quand les choses tournent mal. Cette configuration vous donne une visibilite approfondie sur la sante du systeme, les performances des conteneurs et l’utilisation des ressources.

Points cles de ce guide :

  • Prometheus collecte des metriques aupres des cibles a intervalles reguliers et les stocke dans une base de donnees de series temporelles
  • node_exporter fournit des metriques au niveau systeme (CPU, memoire, disque, reseau)
  • Grafana visualise les metriques avec des tableaux de bord et des panneaux personnalisables
  • PromQL est le langage de requete pour selectionner, filtrer et agreger les metriques
  • Alertmanager route les alertes vers email, Slack, PagerDuty ou d’autres canaux de notification
  • cAdvisor expose des metriques de ressources au niveau des conteneurs pour les environnements Docker

Pour la base sur laquelle cette pile de surveillance fonctionne, assurez-vous que votre serveur est correctement securise en suivant notre liste de verification de securite des serveurs Linux. Si vous n’avez pas encore configure Docker pour la section cAdvisor, suivez notre guide d’installation de Docker sur Ubuntu.

A mesure que votre infrastructure grandit, explorez la federation Prometheus pour les configurations multi-serveurs, Grafana Loki pour l’agregation de logs, et Thanos ou Cortex pour le stockage a long terme et la haute disponibilite.