Surveiller le CPU, la RAM et le réseau de vos serveurs auto-hébergés avec Prometheus et Grafana sur Ubuntu Server

Quiconque gère seulement deux ou trois serveurs auto-hébergés — un NAS, un VPS pour ses projets personnels, un petit homelab avec deux ou trois machines — finit par se poser la même question : comment savoir si un nœud est sur le point de manquer de RAM, si le CPU est sous forte charge, ou si le trafic réseau connaît un pic anormal, sans devoir s'y connecter manuellement à chaque fois ? La réponse la plus répandue dans le monde open source repose sur un duo d'outils devenu un standard de facto : Prometheus pour la collecte des métriques et Grafana pour les afficher dans des tableaux de bord clairs et personnalisables.

Dans ce guide, nous allons mettre en place un cluster de supervision léger sur Ubuntu Server, conçu pour surveiller le CPU, la RAM et le trafic réseau de plusieurs nœuds auto-hébergés, avec un impact minimal sur les ressources des machines surveillées. Nul besoin d'être un administrateur système expérimenté : chaque étape est expliquée avec les concepts de base qui s'y rattachent.

Pourquoi surveiller ses serveurs auto-hébergés

Quiconque héberge ses propres services — un site web, un serveur de messagerie, un NAS, une instance Nextcloud ou un petit cluster pour des projets personnels — découvre souvent les problèmes seulement lorsque le service est déjà inaccessible : disque plein, mémoire épuisée par un processus qui fuit, interface réseau saturée de trafic. Un système de supervision permet de :

• Repérer les signaux à l'avance : une utilisation de la RAM qui augmente constamment pendant plusieurs jours avant un plantage, par exemple, est visible sur un graphique bien avant que cela ne devienne un problème.
• Comprendre les causes des ralentissements : si un site répond lentement, un graphique historique du CPU et des I/O réseau aide à déterminer si la cause est un pic de charge ou autre chose.
• Planifier les mises à niveau : observer l'utilisation des ressources dans le temps est le moyen le plus simple de savoir quand il faut vraiment plus de RAM ou de bande passante, au lieu de se fier à une simple impression.
• Recevoir des alertes : une fois les métriques collectées, il est possible de configurer des alertes automatiques (par exemple via Alertmanager, l'outil compagnon de Prometheus) lorsqu'un seuil est dépassé.

Les outils : Prometheus, Node Exporter et Grafana

Avant d'installer quoi que ce soit, il est utile de comprendre le rôle de chaque composant, car la pile est constituée de trois éléments distincts qui travaillent ensemble :

• Prometheus est une base de données de séries temporelles spécialisée dans la collecte de métriques. Contrairement à de nombreux systèmes de supervision plus anciens, Prometheus fonctionne en mode « pull » : à intervalles réguliers, c'est lui qui interroge les machines surveillées pour demander les données les plus récentes, plutôt que d'attendre que ces machines les lui envoient.
• Node Exporter est un petit programme à installer sur chaque machine à surveiller. Son rôle est d'exposer les métriques système (utilisation du CPU, de la RAM, du disque, des interfaces réseau, etc.) dans un format que Prometheus peut lire, via une simple page web interne sur le port 9100.
• Grafana constitue la couche visuelle : il se connecte à Prometheus comme « source de données » et permet de construire des tableaux de bord avec graphiques, seuils colorés, alertes visuelles et bien plus, sans écrire de code.

En pratique : Node Exporter collecte les données brutes sur chaque nœud, Prometheus les récupère périodiquement et les stocke, et Grafana les lit depuis Prometheus pour les afficher.

Prérequis et architecture du cluster léger

Pour ce guide, nous partons d'une architecture simple mais réaliste pour un homelab ou un petit ensemble de VPS :

• Un nœud « central » sous Ubuntu Server (la version 24.04 LTS convient très bien, encore la plus répandue dans de nombreux homelabs, de même que la version plus récente 26.04 LTS), sur lequel nous installerons Prometheus et Grafana. 1 vCPU et 1-2 Go de RAM suffisent pour surveiller une dizaine de nœuds avec des métriques de base.
• Un ou plusieurs nœuds « à surveiller » (éventuellement le nœud central lui-même), sur chacun desquels on installera uniquement Node Exporter, un processus extrêmement léger (quelques Mo de RAM).
• Un accès SSH avec les droits sudo sur toutes les machines concernées.

Le grand avantage de ce duo est justement sa légèreté : à la différence de solutions plus lourdes basées sur des agents complexes ou des bases de données relationnelles, Prometheus et Node Exporter sont écrits en Go, compilés en binaires uniques sans dépendance à installer, et conçus pour consommer très peu de ressources même sur du matériel modeste (un Raspberry Pi ou un VPS bon marché fonctionne parfaitement).

Étape 1 : installer Prometheus sur le nœud central

Connectons-nous en SSH au nœud central et créons d'abord un utilisateur système dédié, afin que Prometheus ne s'exécute pas avec les privilèges root :

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

Téléchargeons ensuite la dernière version stable de Prometheus (la série 3.x au moment de la rédaction) depuis la page officielle de téléchargement. Il est recommandé de toujours vérifier la version la plus récente disponible sur prometheus.io/download avant de poursuivre :

cd /tmp
wget https://github.com/prometheus/prometheus/releases/download/v3.15.1/prometheus-3.15.1.linux-amd64.tar.gz
tar xvf prometheus-3.15.1.linux-amd64.tar.gz
cd prometheus-3.15.1.linux-amd64

sudo cp prometheus promtool /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/prometheus /usr/local/bin/promtool

sudo cp -r consoles/ console_libraries/ /etc/prometheus/
sudo chown -R prometheus:prometheus /etc/prometheus/consoles /etc/prometheus/console_libraries

Étape 2 : créer le service systemd de Prometheus

Pour que Prometheus démarre automatiquement au démarrage du serveur et soit géré par systemd (le composant d'Ubuntu chargé de démarrer et de superviser les services en arrière-plan), créons un fichier d'unité :

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

avec le contenu suivant :

[Unit]
Description=Prometheus Monitoring System
Wants=network-online.target
After=network-online.target

[Service]
Type=simple
User=prometheus
Group=prometheus
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 \
  --web.listen-address=0.0.0.0:9090
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

Créons également un fichier prometheus.yml minimal pour commencer (nous le compléterons à l'étape 4) :

sudo nano /etc/prometheus/prometheus.yml

global:
  scrape_interval: 15s
  evaluation_interval: 15s

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

Puis démarrons et activons le service :

sudo chown prometheus:prometheus /etc/prometheus/prometheus.yml
sudo systemctl daemon-reload
sudo systemctl enable --now prometheus

Vérifions qu'il est actif avec sudo systemctl status prometheus : il devrait afficher active (running) en vert. À ce stade, l'interface web de Prometheus est déjà accessible sur http://IP-DU-NŒUD-CENTRAL:9090.

Étape 3 : installer Node Exporter sur chaque nœud à surveiller

Cette étape doit être répétée sur chaque nœud que l'on souhaite surveiller (y compris le nœud central, si l'on veut aussi surveiller ses propres ressources). Créons un utilisateur dédié et installons le binaire :

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

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

Créons aussi le service systemd pour Node Exporter :

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

[Unit]
Description=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
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

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

Node Exporter expose désormais les métriques brutes sur le port 9100 : on peut le vérifier avec curl http://localhost:9100/metrics, qui devrait renvoyer des centaines de lignes de données sur le CPU, la mémoire, les systèmes de fichiers et les interfaces réseau.

Étape 4 : configurer Prometheus pour collecter les métriques de tous les nœuds

Retournons sur le nœud central et mettons à jour /etc/prometheus/prometheus.yml en ajoutant un « job » pour chaque nœud à surveiller, avec son adresse IP et le port 9100 de Node Exporter :

global:
  scrape_interval: 15s
  evaluation_interval: 15s

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

  - job_name: "node_exporter"
    static_configs:
      - targets:
          - "localhost:9100"
          - "192.168.1.11:9100"
          - "192.168.1.12:9100"

Après chaque modification de ce fichier, il est conseillé de vérifier sa syntaxe avec promtool check config /etc/prometheus/prometheus.yml, puis de recharger la configuration sans redémarrer le service :

sudo systemctl reload prometheus

Depuis l'interface de Prometheus (http://IP-DU-NŒUD-CENTRAL:9090/targets), on peut vérifier que tous les nœuds apparaissent avec le statut UP : c'est le signe que Prometheus les interroge avec succès.

Étape 5 : ouvrir les ports nécessaires dans le pare-feu

Si ufw (le pare-feu par défaut d'Ubuntu) est actif sur les nœuds, il faut ouvrir les ports nécessaires. Sur le nœud central, pour permettre l'accès à l'interface de Prometheus puis, plus tard, à celle de Grafana :

sudo ufw allow 9090/tcp
sudo ufw allow 3000/tcp

Sur chaque nœud surveillé, en revanche, le port 9100 de Node Exporter ne doit être ouvert que vers l'adresse IP du nœud central, et non vers tout Internet, afin de ne pas exposer les métriques système à n'importe qui :

sudo ufw allow from 192.168.1.10 to any port 9100 proto tcp

(en remplaçant 192.168.1.10 par l'IP réelle du nœud central).

Étape 6 : installer Grafana

Grafana s'installe plus facilement via le dépôt APT officiel, ce qui simplifie les futures mises à jour avec apt upgrade. Sur le nœud central :

sudo apt-get install -y apt-transport-https wget gnupg

sudo mkdir -p /etc/apt/keyrings
sudo wget -q -O /etc/apt/keyrings/grafana.asc https://apt.grafana.com/gpg-full.key
sudo chmod 644 /etc/apt/keyrings/grafana.asc

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

sudo apt-get update
sudo apt-get install -y grafana

Démarrons et activons le service :

sudo systemctl daemon-reload
sudo systemctl enable --now grafana-server

Grafana est désormais accessible sur http://IP-DU-NŒUD-CENTRAL:3000. Les identifiants par défaut lors de la première connexion sont admin / admin : Grafana demandera immédiatement de changer le mot de passe, ce qu'il faut toujours faire, surtout si le serveur est exposé sur Internet.

Étape 7 : connecter Grafana à Prometheus

Une fois dans l'interface de Grafana :

• Dans le menu latéral, allons sur Connections > Data sources et choisissons Add data source.
• Sélectionnons Prometheus dans la liste.
• Dans le champ URL, saisissons http://localhost:9090 (puisque Prometheus tourne sur la même machine ; s'il était ailleurs, il faudrait utiliser son adresse IP).
• Cliquons sur Save & test : si tout est correctement configuré, un message de connexion réussie apparaîtra.

Étape 8 : importer un tableau de bord prêt à l'emploi pour le CPU, la RAM et le trafic réseau

Il n'est pas nécessaire de construire les graphiques de zéro : la communauté Grafana partage des tableaux de bord déjà prêts et gratuits. Le plus utilisé pour Node Exporter est le tableau de bord « Node Exporter Full » (ID 1860), qui affiche dans un seul panneau le CPU, la RAM, l'espace disque, les I/O et le trafic réseau de chaque nœud surveillé.

Pour l'importer :

• Dans le menu latéral, Dashboards > New > Import.
• Dans le champ « Import via grafana.com », saisissons 1860 et cliquons sur Load.
• Sélectionnons comme source de données celle de Prometheus que nous venons de créer, puis cliquons sur Import.

En quelques secondes, le tableau de bord se remplit avec les données réelles de tous les nœuds surveillés, avec la possibilité de choisir le nœud à afficher depuis un menu déroulant en haut de l'écran.

Conseils pour une supervision sûre et durable

• N'exposez jamais Prometheus et Node Exporter directement sur Internet. Ni l'un ni l'autre ne dispose, par défaut, d'un système d'authentification : gardez-les sur un réseau privé (LAN, VPN comme WireGuard ou Tailscale) ou derrière un reverse proxy avec authentification.
• Placez Grafana derrière HTTPS s'il est accessible depuis Internet, par exemple avec un reverse proxy Nginx et un certificat Let's Encrypt.
• Définissez une durée de rétention des données raisonnable. Par défaut, Prometheus conserve les données pendant 15 jours ; sur un homelab avec peu d'espace disque, il peut être utile de la réduire avec l'option --storage.tsdb.retention.time, ou de l'augmenter si l'on dispose de plus d'espace.
• Envisagez Alertmanager pour recevoir des notifications automatiques (e-mail, Telegram, etc.) lorsqu'une métrique dépasse un seuil critique, au lieu de devoir vérifier les tableaux de bord manuellement.
• Mettez régulièrement à jour Prometheus et Node Exporter : étant de simples binaires, la mise à jour consiste simplement à répéter les étapes de téléchargement et de remplacement du fichier, tandis que Grafana se met à jour avec apt upgrade une fois le dépôt configuré.

Conclusion

Avec quelques commandes seulement et un impact minimal sur les ressources, Prometheus, Node Exporter et Grafana permettent de mettre en place un système de supervision professionnel, même pour un simple homelab ou un petit ensemble de serveurs personnels. Une fois à l'aise avec cette pile, il est facile de l'étendre avec de nouveaux jobs de scraping (par exemple pour surveiller des services applicatifs, pas seulement le matériel), de nouveaux tableaux de bord communautaires et des alertes automatiques via Alertmanager.

Sources officielles

• Prometheus — Monitoring Linux host metrics with the Node Exporter
• Prometheus — page officielle des téléchargements
• Grafana — installation sur Debian/Ubuntu (documentation officielle)
• Grafana — tableau de bord communautaire « Node Exporter Full » (ID 1860)