Prometheus Grafana – Supervision des serveurs

Posté 27/08/2025

Par Yann

16 min lire

Prometheus est un système de surveillance de performance open source qui collecte des données de performance à partir de différentes sources et les stocke dans une base de données en mémoire. Il permet de surveiller l’état et les performances de différents systèmes en temps réel, en collectant des données de métriques telles que la charge de CPU, la mémoire utilisée et les taux d’erreur.
Grafana est un outil de visualisation de données open source qui peut être utilisé avec de nombreuses sources de données différentes, y compris Prometheus. Il permet de créer des graphiques et des tableaux de bord pour visualiser et analyser les données de performance de différents systèmes de manière facile et intuitive.

Monitoring

Cet article est une reproduction du tutoriel Prometheus Grafana – Superviser vos serveurs du 22 août 2025 rédigé par Kévin

Prometheus est un outil qui collecte et stocke des métriques à intervalles réguliers afin de superviser les performances et l’état des systèmes. Grafana est un autre outil qui permet de visualiser et d’analyser ces métriques à travers des tableaux de bord interactifs.

Ajout d’un nouveau serveur monitoring sous la machine virtuelle debian 13 (vm-debian13-02)
- Il héberge la solution de supervision : Prometheus, Grafana etc…
- La solution sera déployée à l’aide de Docker (tutoriel installation) afin de simplifier son implémentation et ses futures mises à jour.
Ajout d’exporters (sortes d’agents) sur les serveurs à superviser
- node_exporter : Met à disposition les métriques système d’un serveur. Il sera installé en tant que service systemd, afin d’éviter l’installation de Docker sur des serveurs n’en ayant pas l’utilité.
- cAdvisor : Met à disposition les métriques des containers. Il sera déployé en tant que container en utilisant l’hôte Docker déjà présent.

Déployer Prometheus et Grafana

Création répertoire monitoring

sudo mkdir /monitoring

Création fichier /monitoring/docker-compose.yml

        
      
services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    command:
      - "--config.file=/etc/prometheus/prometheus.yml"
      - "--web.config.file=/etc/prometheus/web.yml"
      - "--storage.tsdb.retention.time=30d"               # Prometheus data retention period (default: 15d)
      - "--web.external-url=http://ip_or_servername:9090" # Change this value, Prometheus external web URL (default: "")
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - ./prometheus/rules:/etc/prometheus/rules:ro
      - ./prometheus/web.yml:/etc/prometheus/web.yml:ro
      - prometheus-data:/prometheus
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_USER=admin                  # Grafana default admin username
      - GF_SECURITY_ADMIN_PASSWORD=Ch@ngeThisPassw0rd # Change this value, Grafana default admin password
    volumes:
      - grafana-storage:/var/lib/grafana
    restart: unless-stopped

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    ports:
      - "8080:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
    restart: unless-stopped

volumes:
  prometheus-data:
  grafana-storage:

Important :

--storage.tsdb.retention.time : Durée de rétention des données (par défaut : 15 jours).
--web.external-url : Url à laquelle Prometheus sera accessible depuis un navigateur client.
--GF_SECURITY_ADMIN_USER : Utilisateur admin de Grafana.
--GF_SECURITY_ADMIN_PASSWORD : Mot de passe de l’admin de Grafana, à définir

Créer les répertoires de configuration pour Prometheus

sudo mkdir /monitoring/prometheus
sudo mkdir /monitoring/prometheus/rules

Créer un mot de passe pour sécuriser l’API de Prometheus

Installer python3-bcrypt

        
      
sudo apt install -y python3-bcrypt

Générer le hash du mot de passe de l’utilisateur admin de Prometheus :

        
python3 -c \
  "import getpass, bcrypt; pwd=getpass.getpass('Password:'); print(bcrypt.hashpw(pwd.encode(), bcrypt.gensalt()).decode())"

Créer un fichier de configuration pour l’API de Prometheus

sudo nano /monitoring/prometheus/web.yml

Ajouter

basic_auth_users:
    admin: $2b$12$gdLNi3sJ2CU...

Remplacer $2b$12… par le hash du mot de passe généré précédemment.

Créer un fichier pour la configuration générale de Prometheus

Le fichier de configuration de Prometheus contient une liste de jobs. Chaque job contient une liste de targets à cibler.

sudo nano /monitoring/prometheus/prometheus.yml

Ajouter

        
      
global:
  scrape_interval: 15s
  evaluation_interval: 15s

rule_files:
  - "/etc/prometheus/rules/*.yml"

scrape_configs:
  - job_name: 'prometheus'
    basic_auth:
      username: admin
      password: Mot_passe_admin
    static_configs:
      - targets:
        - 'localhost:9090'

  - job_name: 'cadvisor'
    static_configs:
      - targets:
        - 'cadvisor:8080'

password: Mot_passe_admin, le mot de passe de l’admin Prometheus en clair (non haché).

La configuration comporte 2 jobs :

prometheus : Pour récolter les métriques des serveurs Prometheus.
- cadvisor : Pour récolter les métriques des containers sur les serveurs Docker. Le nom de serveur cadvisor fait référence au nom du service de même nom défini dans le fichier docker-compose.yml.

Déployer Prometheus et Grafana

Se déplacer dans le répertoire contenant le fichier docker-compose.yml

cd /monitoring

Lancer le déploiement

docker compose up -d

Vérifier l’état des containers

docker compose ps

L’état de chaque container doit être Up.

NAME         IMAGE                             COMMAND                  SERVICE      CREATED              STATUS                        PORTS
cadvisor     gcr.io/cadvisor/cadvisor:latest   "/usr/bin/cadvisor -…"   cadvisor     About a minute ago   Up About a minute (healthy)   0.0.0.0:8080->8080/tcp, [::]:8080->8080/tcp
grafana      grafana/grafana:latest            "/run.sh"                grafana      About a minute ago   Up About a minute             0.0.0.0:3000->3000/tcp, [::]:3000->3000/tcp
prometheus   prom/prometheus:latest            "/bin/prometheus --c…"   prometheus   About a minute ago   Up About a minute             0.0.0.0:9090->9090/tcp, [::]:9090->9090/tcp

Tester la connexion à l’API Prometheus

# curl -u admin http://ip_or_servername:9090/metrics
curl -u admin http://localhost:9090/metrics

Remarque : -u admin pour s’authentifier avec l’utilisateur admin.

[...]
# HELP prometheus_target_sync_length_seconds Actual interval to sync the scrape pool.
# TYPE prometheus_target_sync_length_seconds summary
prometheus_target_sync_length_seconds{scrape_job="cadvisor",quantile="0.01"} 0.000124615
prometheus_target_sync_length_seconds{scrape_job="cadvisor",quantile="0.05"} 0.000124615
prometheus_target_sync_length_seconds{scrape_job="cadvisor",quantile="0.5"} 0.000124615
prometheus_target_sync_length_seconds{scrape_job="cadvisor",quantile="0.9"} 0.000124615
prometheus_target_sync_length_seconds{scrape_job="cadvisor",quantile="0.99"} 0.000124615
prometheus_target_sync_length_seconds_sum{scrape_job="cadvisor"} 0.000124615
prometheus_target_sync_length_seconds_count{scrape_job="cadvisor"} 1
[...]

Interface Web Prometheus et Grafana

Lancer l’interface web de Prometheus

http://192.168.10.221:9090
Une authentification sera demandée

L’état de tous les jobs doit être UP.

Lancer l’interface web de Grafana
http://192.168.10.221:3000

Se connecter avec l’utilisateur et le mot de passe définis dans le fichier docker-compose.yaml (admin)

La configuration de Grafana se fera plus loin

Déployer node_exporter

Opérations à réaliser sur chaque serveur à superviser.

Installer curl si nécessaire

        
      
sudo apt install -y curl

Télécharger la dernière version de node_exporter

        
      
curl -s https://api.github.com/repos/prometheus/node_exporter/releases/latest \
| grep browser_download_url \
| grep linux-amd64.tar.gz \
| cut -d '"' -f 4 \
| wget -i - -P /tmp

Vérifier le téléchargement

        
      
ls -lah /tmp/node_exporter*

-rw-rw-r-- 1 userx userx 12M 1 avril 17:24 /tmp/node_exporter-1.9.1.linux-amd64.tar.gz

Extraire node_exporter dans le répertoire /usr/local/bin

        
      
sudo tar -xzf /tmp/node_exporter-1.9.1.linux-amd64.tar.gz \
  --wildcards \
  --strip-components=1 \
  -C /usr/local/bin \
  'node_exporter-*/node_exporter'

Vérifier l’extraction de node_exporter

node_exporter --version

Résultat

node_exporter, version 1.9.1 (branch: HEAD, revision: f2ec547b49af53815038a50265aa2adcd1275959)
  build user:       root@7023beaa563a
  build date:       20250401-15:19:01
  go version:       go1.23.7
  platform:         linux/amd64
  tags:             unknown

Créer un utilisateur pour le service node_exporter

Utilisateur node-exp qui lancera le service systemd node_exporter.

        
      
sudo useradd --no-create-home \
  --shell /usr/sbin/nologin \
  --comment "Node Exporter system user" \
  node-exp

Créer le service node_exporter

sudo nano /etc/systemd/system/node_exporter.service

Ajouter

[Unit]
Description=Prometheus Node Exporter
Wants=network-online.target
After=network-online.target

[Service]
User=node-exp
Group=node-exp
Type=simple
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target

On retrouve l’utilisateur créé précédemment ainsi que le groupe du même nom.

Recharger la configuration systemd

sudo systemctl daemon-reload

Démarrer et activer le service node_exporter

        
      
sudo systemctl enable node_exporter --now

Vérifier l’état du service node_exporter

sudo systemctl status node_exporter

Vérifier si enabled

● node_exporter.service - Prometheus Node Exporter
     Loaded: loaded (/etc/systemd/system/node_exporter.service; enabled; preset: enabled)
     Active: active (running) since Wed 2025-08-27 16:20:19 CEST; 42s ago
 Invocation: e2ee727f48a0420ca6a29fcc508f840f
   Main PID: 11160 (node_exporter)
      Tasks: 4 (limit: 9352)
     Memory: 4.9M (peak: 5M)
        CPU: 12ms
     CGroup: /system.slice/node_exporter.service
             └─11160 /usr/local/bin/node_exporter

Vérifier le fonctionnement node_exporter

Appeler le node_exporter en local et à partir du serveur monitoring pour valider son bon fonctionnement.

# curl http://IPouNomServeur:9100/metrics
# paperless
curl http://192.168.10.220:9100/metrics

Résultat

[...]
# TYPE promhttp_metric_handler_errors_total counter
promhttp_metric_handler_errors_total{cause="encoding"} 0
promhttp_metric_handler_errors_total{cause="gathering"} 0
# HELP promhttp_metric_handler_requests_in_flight Current number of scrapes being served.
# TYPE promhttp_metric_handler_requests_in_flight gauge
promhttp_metric_handler_requests_in_flight 1
# HELP promhttp_metric_handler_requests_total Total number of scrapes by HTTP status code.
# TYPE promhttp_metric_handler_requests_total counter
promhttp_metric_handler_requests_total{code="200"} 0
promhttp_metric_handler_requests_total{code="500"} 0
promhttp_metric_handler_requests_total{code="503"} 0

Configurer Prometheus pour récupérer les metriques de node_exporter

Opérations à réaliser sur le serveur monitoring.

sudo nano /monitoring/prometheus/prometheus.yml

Ajouter les configurations des serveurs à surveiller

        
      
  - job_name: 'node_exporter'
    static_configs:
      - targets:
        - 'ip_or_servername1:9100'
        - 'ip_or_servername2:9100'

Remarque : Remplacer le nom du serveur pour chaque targets

Nous avons 2 serveurs avec node-exporter

Debian 13 vmtrix 192.168.10.220
Alpine Linux alpi05 192.168.10.215

        
      
  - job_name: 'node_exporter'
    static_configs:
      - targets:
        - '192.168.10.220:9100'
        - '192.168.10.215:9100'

Procédures d’installation semi auto de node_exporter

Debian

        
      
#!/bin/sh

# Debian: Installation node_explorer
# Copier ce contenu dans un fichier nommé 'node_explorer.sh'
# Rendre exécutable le fichier: 'chmod +x node_explorer.sh'
# Exécution: './node_explorer.sh'
#
# Télécharger la version v1.9.1 de node_exporter
wget -P /tmp https://github.com/prometheus/node_exporter/releases/download/v1.9.1/node_exporter-1.9.1.linux-amd64.tar.gz

# Extraire node_exporter dans le répertoire /usr/local/bin
sudo tar -xzf /tmp/node_exporter-1.9.1.linux-amd64.tar.gz \
  --wildcards \
  --strip-components=1 \
  -C /usr/local/bin \
  'node_exporter-*/node_exporter'

# Utilisateur 'node-exp' qui lancera le service systemd 'node_exporter'
sudo useradd --no-create-home \
  --shell /usr/sbin/nologin \
  --comment "Node Exporter system user" \
  node-exp

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

[Service]
User=node-exp
Group=node-exp
Type=simple
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target
EOF

# Recharger la configuration systemd
sudo systemctl daemon-reload

# Démarrer et activer le service node_exporter
sudo systemctl enable node_exporter --now

Alpine linux

        
      
#!/bin/sh

# Alpine Linux: Installation node_explorer
# Copier ce contenu dans un fichier nommé 'node_explorer.sh'
# Rendre exécutable le fichier: 'chmod +x node_explorer.sh'
# Exécution: './node_explorer.sh'

# Installer l"application
sudo apk add prometheus-node-exporter

# service node_exporter 
sudo tee /etc/init.d/node_exporter << EOF
#!/sbin/openrc-run
name="node_exporter"
description="Metrics"
command="/usr/bin/node_exporter"
command_background=true
pidfile="/run/node_exporter.pid"
EOF

# Rendre exécutable
sudo chmod +x /etc/init.d/node_exporter

# Démarrage au boot
sudo rc-update add node_exporter default

# Lancer le service
sudo service node_exporter start

Redémarrer les containers

Remarque : Opérations à réaliser sur le serveur monitoring

cd /monitoring
docker compose restart

Vérifier nouveau job dans prometheus

Se rendre sur l’interface web de Prometheus à l’adresse http://192.168.10.221:9090 puis Status, target health

L’état de tous les Endpoints du job node_exporter ajouté précédemment doit être UP.

Configuration de Grafana

Ajouter une source de données

Il faut créer et configurer une source de données (Data Source) de type Prometheus pour que Grafana puisse exploiter les métriques récoltées par notre serveur Prometheus.

Connections (1) –> Data sources (2) –> Add Data source, sélectionner Prometheus

Le nom de serveur prometheus dans Prometheus server URL correspond au nom du service de même nom dans le fichier docker-compose.yml

Se rendre à la fin du formulaire puis valider la création de la source de données en cliquant sur Save & test.

Ce message devrait s’afficher indiquant que tout est OK.

Import d’un tableau de bord pour node_exporter

La communauté de Grafana partage des Dashboard (Tableaux de bord) ce qui est très utile pour gagner du temps et pouvoir exploiter rapidement les métriques de Prometheus dans Grafana.
Nous utiliserons le tableau de bord 1860 Node Exporter Full pour visualiser les métriques provenant des nodes_exporter.

Cliquer sur le « + » en haut à droite puis Import dashboard.

Saisir l’id du dashboard à importer puis cliquer sur Load.

Ne pas oublier de sélectionner la source de données, dans notre cas : prometheus.

Les données arrivent progressivement.

Déployer cAdvisor

cAdvisor est un outil open source qui collecte et expose des métriques sur l’utilisation des ressources des containers en temps réel. La solution la plus simple consiste à le déployer en tant que container directement sur l’hôte Docker que l’on souhaite superviser.

cAdvisor a déjà été déployé précédemment sur le serveur monitoring grâce au service de même nom dans le fichier docker-compose.yml.
Nous l’installerons donc sur les autres serveurs docker de notre infrastructure (vm-alpine05, …)

        
      
  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    ports:
      - "8080:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
    restart: unless-stopped

Sur les machines ayant docker installé

Créer un répertoire cadvisor

sudo mkdir -p /monitoring/cadvisor

Créer un fichier docker-compose.yml

sudo nano /monitoring/cadvisor/docker-compose.yml

Ajouter

        
      
services:
  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    ports:
      - "8085:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
    restart: unless-stopped

Modifier le port 8080:8080 côté hôte si 8080 est déjà utilisé.

Déployer cAdvisor

Se placer dans le répertoire contenant le fichier docker-compose.yml :

cd /monitoring/cadvisor

Lancer le déploiement de cadvisor :

# précéder de 'sudo' si docker n'a pas les permissions
docker compose up -d

Vérifier le déploiement de cAdvisor

# précéder de 'sudo' si docker n'a pas les permissions
docker compose ps

Résultat

NAME       IMAGE                             COMMAND                  SERVICE    CREATED              STATUS                        PORTS
cadvisor   gcr.io/cadvisor/cadvisor:latest   "/usr/bin/cadvisor -…"   cadvisor   About a minute ago   Up About a minute (healthy)   0.0.0.0:8085->8080/tcp, [::]:8085->8080/tcp

L’état du container cadvisor doit être UP

Ajouter une nouvelle cible pour le job cadvisor dans Prometheus

Opérations à réaliser sur le serveur monitoring.

sudo nano /monitoring/prometheus/prometheus.yml

Dans notre cas, le job cadvisor a déjà été créé précédemment.
Nous avons donc ajouté une nouvelle cible à targets pour cibler le cadvisor déployé sur vm-alpi05.

Redémarrer les containers

Remarque : Opérations à réaliser sur le serveur monitoring

cd /monitoring
docker compose restart

Tester l’exporter cadvisor

Vérifier l’accès aux metrics de cadvisor en local et depuis le serveur monitoring.

# curl http://IPouNomServeur:8080/metrics
curl http://192.168.10.215:8085/metrics

Vérifier dans l’interface web

Tableau de bord pour cAdvisor dans Grafana

Il existe de nombreux tableaux de bord pour exploiter les métriques provenant de cAdvisor. Nous utiliserons le tableaux de bord 13946 Docker-cAdvisor.

Déployer blackbox_exporter

blackbox_exporter est un outil de Prometheus qui permet de vérifier la disponibilité et la performance de services réseau (HTTP, DNS, TCP, ICMP, etc.) en effectuant des tests externes, comme un “blackbox”, sans accéder directement à l’intérieur des systèmes.

Contrairement aux autres exporters, blackbox_exporter se déploie à un seul endroit et teste les services à distance, sans installation sur les serveurs cibles. Nous l’ajouterons donc en tant que service dans le fichier docker-compose.yml du serveur monitoring.

Ajouter un service blackbox_exporter au fichier docker-compose.yml

Opérations à réaliser sur le serveur monitoring.

sudo nano /monitoring/docker-compose.yml

Ajouter le service

        
      
  blackbox:
    image: quay.io/prometheus/blackbox-exporter:latest
    container_name: blackbox_exporter
    ports:
      - "9115:9115"
    volumes:
      - ./blackbox_exporter:/config
    command:
      - "--config.file=/config/blackbox.yml"
    restart: unless-stopped

Créer d’un répertoire blackbox_exporter

sudo mkdir /monitoring/blackbox_exporter

Créer un fichier de configuration pour blackbox_exporter

sudo nano /monitoring/blackbox_exporter/blackbox.yml

contenu

        
      
modules:
  http_2xx:
    prober: http
    timeout: 5s
    http:
      valid_http_versions: ["HTTP/1.1", "HTTP/2.0"]
      valid_status_codes: []  # Defaults to 2xx
      method: GET
      follow_redirects: true
      fail_if_ssl: false
      fail_if_not_ssl: false
      fail_if_body_matches_regexp:
        - "Could not connect to database"
      #fail_if_body_not_matches_regexp:
      #  - "Download the latest version here"
      tls_config:
        insecure_skip_verify: true
      #preferred_ip_protocol: "ip4" # defaults to "ip6"
      #ip_protocol_fallback: false  # no fallback to "ip6"

Le fichier définit des modules, qui sont des modèles de requêtes réutilisables par Prometheus dans ses jobs.
Par exemple, le module http_2xx effectue une requête GET et évalue son succès selon la configuration : le code de retour doit être 2xx et le corps de la réponse ne doit pas contenir la chaîne Could not connect to database.

Ajouter un job blackbox_exporter dans Prometheus

sudo nano /monitoring/prometheus/prometheus.yml

contenu

        
      
  - job_name: 'blackbox'
    metrics_path: /probe
    params:
      module: [http_2xx]  # Look for a HTTP 200 response.
    static_configs:
      - targets:
        - url1
        - url2
        - url3
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: ip_or_servername:9115 # The blackbox exporter's real hostname:port. 

  - job_name: 'blackbox_exporter'
    static_configs:
      - targets:
        - 'ip_or_servername:9115' # The blackbox exporter's real hostname:port.

Job blackbox  : Teste la disponibilité des services web spécifiés dans targets en utilisant le module http_2xx. Chaque URL est sondée par le Blackbox Exporter central, qui détermine le succès selon le code HTTP et le contenu de la réponse. Il permet de vérifier que les services sont joignables et répondent correctement.
Job blackbox_exporter  : Collecte les métriques opérationnelles du Blackbox Exporter lui-même, comme son état et ses performances internes.

Remarque 1 : Remplacez url1, url2 et url3 par les URLs que vous souhaitez réellement tester. Remarque 2  : Remplacez ip_or_servername par l’adresse IP ou le nom DNS de votre serveur monitoring.

Redéployer la solution de monitoring

        
sudo docker compose down
sudo docker compose up -d

Commande à lancer dans le répertoire contenant le fichier docker-compose.yml. docker compose restart ne suffira pas car nous avons modifier la définition du déploiement.

Les jobs blackbox et blackbox_exporter sont bien UP.

Un statut UP indique que la sonde (probe) a fonctionné correctement, mais ne garantit pas que le service cible est opérationnel. Pour connaître l’état réel du service, il faut consulter la métrique probe_success de la sonde.

Ajouter un tableau de bord pour blackbox_exporter dans Grafana

Il existe de nombreux tableaux de bord pour exploiter les métriques provenant de blackbox_exporter. Nous utiliserons le tableaux de bord 18538 BlackBox Exporter.

Blog, Tutoriel

application

Cet article est sous licence CC BY 4.0 par l'auteur.

Monitoring

Déployer Prometheus et Grafana

Interface Web Prometheus et Grafana

Déployer node_exporter

Configuration de Grafana

Déployer cAdvisor

Déployer blackbox_exporter

Tags tendance