Prometheus et Grafana sur Debian — installation, configuration et dashboards pratiques

La supervision est une composante fondamentale de toute infrastructure Linux sérieuse. Savoir ce qui se passe sur vos serveurs en temps réel — charge CPU, utilisation mémoire, I/O disque, latence réseau — vous permet d’anticiper les incidents avant qu’ils n’impactent les utilisateurs. Prometheus et Grafana forment depuis plusieurs années le duo de référence dans l’écosystème open source pour la collecte de métriques et leur visualisation.

Prometheus est un système de monitoring pull-based : il interroge régulièrement des exporters qui exposent des métriques au format texte sur une URL HTTP. Le Node Exporter, maintenu par le projet Prometheus, expose les métriques système d’une machine Linux (CPU, mémoire, disque, réseau). Grafana se connecte ensuite à Prometheus comme source de données et permet de créer des tableaux de bord interactifs.

Ce guide couvre l’installation complète de Prometheus 3.11.3 et Grafana 13.0.1 sur Debian 12 (Bookworm), la configuration du Node Exporter 1.11.1 pour la collecte de métriques système, et la mise en place de dashboards prêts à l’emploi. Toutes les étapes utilisent des services systemd pour une gestion propre et un démarrage automatique.

Architecture et prérequis

La stack de supervision se compose de trois éléments :

• Prometheus (port 9090) : base de données de séries temporelles et moteur de scraping
• Node Exporter (port 9100) : collecte les métriques système de la machine locale
• Grafana (port 3000) : interface de visualisation et de dashboarding

Prérequis :

• Debian 12 (Bookworm) avec accès root ou sudo
• Au moins 1 Go de RAM et 10 Go d’espace disque disponible
• Accès à Internet pour télécharger les binaires

Installation de Prometheus

Création de l’utilisateur système

Prometheus ne doit pas tourner en root. On crée un utilisateur dédié sans shell ni répertoire home :

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

On crée ensuite les répertoires nécessaires :

sudo mkdir /etc/prometheus /var/lib/prometheus
sudo chown prometheus:prometheus /etc/prometheus /var/lib/prometheus

Téléchargement et installation des binaires

La version stable actuelle est 3.11.3 (sortie le 27 avril 2026). On télécharge les binaires depuis le dépôt officiel GitHub :

# Téléchargement de l'archive
cd /tmp
wget https://github.com/prometheus/prometheus/releases/download/v3.11.3/prometheus-3.11.3.linux-amd64.tar.gz

# Vérification du checksum (recommandé)
wget https://github.com/prometheus/prometheus/releases/download/v3.11.3/sha256sums.txt
sha256sum --check --ignore-missing sha256sums.txt

# Extraction
tar xvf prometheus-3.11.3.linux-amd64.tar.gz
cd prometheus-3.11.3.linux-amd64/

# Copie des binaires
sudo cp prometheus promtool /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/prometheus /usr/local/bin/promtool

# Copie des fichiers de configuration
sudo cp -r consoles/ console_libraries/ /etc/prometheus/
sudo chown -R prometheus:prometheus /etc/prometheus/consoles /etc/prometheus/console_libraries

Fichier de configuration prometheus.yml

On crée la configuration minimale qui scrape Prometheus lui-même et le Node Exporter local :

sudo tee /etc/prometheus/prometheus.yml << 'EOF'
global:
  scrape_interval: 15s       # Fréquence de collecte des métriques
  evaluation_interval: 15s   # Fréquence d'évaluation des règles d'alerte

rule_files: []               # Fichiers de règles d'alerte (à compléter)

scrape_configs:
  # Prometheus se monitore lui-même
  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]

  # Node Exporter — métriques système
  - job_name: "node_exporter"
    static_configs:
      - targets: ["localhost:9100"]
EOF

sudo chown prometheus:prometheus /etc/prometheus/prometheus.yml

Service systemd pour Prometheus

sudo tee /etc/systemd/system/prometheus.service << 'EOF'
[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 
    --storage.tsdb.retention.time=30d 
    --web.console.templates=/etc/prometheus/consoles 
    --web.console.libraries=/etc/prometheus/console_libraries 
    --web.listen-address=127.0.0.1:9090
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

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

Sécurité : L’option --web.listen-address=127.0.0.1:9090 restreint l’écoute à localhost. Prometheus n’intègre pas d’authentification native — ne jamais l’exposer directement sur une interface publique.

Installation du Node Exporter

Le Node Exporter collecte les métriques système (CPU, mémoire, disque, réseau, filesystem…). La version actuelle est 1.11.1. Si vous souhaitez comparer avec d’autres approches d’observabilité bas niveau, lisez notre article sur eBPF et bpftrace qui couvre le traçage kernel en temps réel.

# Création de l'utilisateur dédié
sudo useradd --no-create-home --shell /bin/false node_exporter

# Téléchargement
cd /tmp
wget https://github.com/prometheus/node_exporter/releases/download/v1.11.1/node_exporter-1.11.1.linux-amd64.tar.gz
tar xvf node_exporter-1.11.1.linux-amd64.tar.gz

# Installation du binaire
sudo cp node_exporter-1.11.1.linux-amd64/node_exporter /usr/local/bin/
sudo chown node_exporter:node_exporter /usr/local/bin/node_exporter

Service systemd avec les collecteurs systemd et processes activés :

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_exporter
Group=node_exporter
Type=simple
ExecStart=/usr/local/bin/node_exporter 
    --collector.systemd 
    --collector.processes
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable --now node_exporter

# Vérification — doit retourner des métriques au format texte
curl -s http://localhost:9100/metrics | head -20

Installation de Grafana

Grafana 13.0.1 est disponible via le dépôt APT officiel de Grafana Labs. C’est la méthode recommandée car elle permet les mises à jour automatiques via apt-get upgrade.

# Dépendances
sudo apt-get install -y apt-transport-https wget gnupg

# Import de la clé GPG du dépôt Grafana
sudo mkdir -p /etc/apt/keyrings
sudo wget -O /etc/apt/keyrings/grafana.asc https://apt.grafana.com/gpg-full.key
sudo chmod 644 /etc/apt/keyrings/grafana.asc

# Ajout du dépôt stable
echo "deb [signed-by=/etc/apt/keyrings/grafana.asc] https://apt.grafana.com stable main" 
  | sudo tee /etc/apt/sources.list.d/grafana.list

# Installation de Grafana OSS
sudo apt-get update
sudo apt-get install -y grafana

# Activation et démarrage
sudo systemctl daemon-reload
sudo systemctl enable --now grafana-server
sudo systemctl status grafana-server

Grafana écoute par défaut sur le port 3000. Accédez à http://<IP_SERVEUR>:3000 depuis votre navigateur. Les identifiants par défaut sont admin / admin — Grafana impose un changement de mot de passe à la première connexion.

Configuration des dashboards Grafana

Ajout de Prometheus comme source de données

Depuis l’interface Grafana :

1. Menu latéral → Connections → Data sources
2. Cliquer Add new data source → choisir Prometheus
3. URL : http://localhost:9090
4. Scrape interval : 15s (doit correspondre au scrape_interval dans prometheus.yml)
5. Cliquer Save & test — un message vert confirme la connexion

Import du dashboard Node Exporter Full

La communauté Grafana maintient un dashboard complet pour Node Exporter (ID 1860) qui affiche CPU, mémoire, swap, disque, réseau et système de fichiers :

1. Menu latéral → Dashboards → New → Import
2. Entrer l’ID 1860 dans le champ « Import via grafana.com » → Load
3. Sélectionner la datasource Prometheus créée précédemment
4. Cliquer Import

Le dashboard s’affiche immédiatement avec des métriques organisées par catégorie. Pour surveiller plusieurs machines, ajoutez les cibles dans prometheus.yml :

# Ajout de plusieurs hôtes dans /etc/prometheus/prometheus.yml
scrape_configs:
  - job_name: "node_exporter"
    static_configs:
      - targets:
          - "localhost:9100"
          - "192.168.1.10:9100"   # serveur-web-1
          - "192.168.1.11:9100"   # serveur-db-1

# Rechargement à chaud (sans redémarrage)
sudo kill -HUP $(pidof prometheus)
# ou via l'API HTTP
curl -X POST http://localhost:9090/-/reload

Requêtes PromQL essentielles

PromQL est le langage de requête de Prometheus. Ces expressions s’utilisent directement dans Grafana pour créer des panneaux personnalisés :

# Charge CPU globale en pourcentage (moyenne sur 5 minutes)
100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

# Mémoire disponible en octets
node_memory_MemAvailable_bytes

# Utilisation disque en pourcentage (hors tmpfs)
(node_filesystem_size_bytes{fstype!="tmpfs"} - node_filesystem_free_bytes{fstype!="tmpfs"})
  / node_filesystem_size_bytes{fstype!="tmpfs"} * 100

# Bande passante réseau entrante (octets/s)
rate(node_network_receive_bytes_total[5m])

# Nombre de processus en cours d'exécution
node_procs_running

Sécurisation et bonnes pratiques

Isolation réseau avec nftables

Prometheus et Node Exporter ne proposent pas d’authentification native. Restreignez leur accès au niveau du pare-feu — consultez notre guide sur nftables et iptables pour la gestion complète des règles.

# Bloquer l'accès externe aux ports Prometheus et Node Exporter
sudo nft add rule inet filter input tcp dport { 9090, 9100 } ip saddr != 127.0.0.1 drop

# Autoriser uniquement une IP de supervision spécifique (ex: serveur Grafana distant)
sudo nft add rule inet filter input tcp dport { 9090, 9100 } ip saddr 192.168.1.50 accept
sudo nft add rule inet filter input tcp dport { 9090, 9100 } drop

Reverse proxy Nginx pour Grafana

Pour exposer Grafana depuis Internet avec HTTPS, utilisez un reverse proxy :

# /etc/nginx/sites-available/grafana
server {
    listen 443 ssl;
    server_name grafana.exemple.com;

    ssl_certificate     /etc/letsencrypt/live/grafana.exemple.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/grafana.exemple.com/privkey.pem;

    location / {
        proxy_pass         http://127.0.0.1:3000;
        proxy_set_header   Host $host;
        proxy_set_header   X-Real-IP $remote_addr;
        proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header   X-Forwarded-Proto $scheme;
    }
}

Gestion de la rétention des données

Par défaut, Prometheus conserve 15 jours de données. Le paramètre --storage.tsdb.retention.time=30d dans le service systemd étend cette rétention. Surveillez l’espace disque :

# Taille occupée par les données Prometheus
du -sh /var/lib/prometheus/

# Statistiques TSDB via l'API
curl -s http://localhost:9090/api/v1/status/tsdb | python3 -m json.tool

# Mise à jour de Grafana (via APT)
sudo apt-get update && sudo apt-get upgrade grafana

# Mise à jour de Prometheus (binaire manuel)
sudo systemctl stop prometheus
# → remplacer /usr/local/bin/prometheus par la nouvelle version
sudo systemctl start prometheus
prometheus --version

À lire également

• Supervision avec Zabbix 7.0 LTS sur Debian/Ubuntu — une alternative éprouvée à Prometheus, plus adaptée aux environnements hétérogènes avec agents natifs.
• Centralisation logs avec ELK Stack — Elasticsearch, Kibana, Filebeat — complétez votre stack d’observabilité avec la gestion centralisée des logs applicatifs.
• eBPF sur Linux : observabilité et traçage kernel avec bpftrace et BCC — pour une observabilité au niveau noyau, en complément de Prometheus.
• Surveillance et diagnostic d’un serveur Linux avec vmstat, iotop et htop — les outils CLI pour le diagnostic rapide, avant ou en complément d’un dashboard Grafana.

Références

• Documentation officielle Prometheus — Getting Started
• Documentation officielle Grafana — Installation sur Debian/Ubuntu
• GitHub — Prometheus Node Exporter
• Grafana Dashboards — Node Exporter Full (ID 1860)
• Documentation PromQL — Querying basics