Cas pratique : Grafana appliqué au réel
Prometheus, node_exporter et Grafana provisionnés en YAML sur trois VPS réels. Cinq requêtes PromQL, quatre règles d'alerte versionnées et les cinq pièges qui coûtent cher.
Trois VPS, un blog, une API et deux boutiques : pendant six mois j'ai diagnostiqué mes pannes en lisant des journalctl à la main. Le jour où un disque s'est rempli à 3 h du matin sans que rien ne m'alerte, j'ai installé Grafana pour de bon. Voici la stack exacte, les requêtes qui servent et les réglages que j'aurais aimé connaître avant.
Le scénario : trois machines, zéro visibilité
Mon parc réel : un orchestrateur qui fait tourner les conteneurs, un serveur de déploiement avec Mailcow, et un Raspberry Pi qui sert de bac à sable. Trois sources, deux systèmes d'exploitation, aucune métrique historisée.
Le besoin tient en quatre questions : quelle machine sature, quel disque se remplit, quel service est tombé, et depuis quand. Grafana répond aux quatre, à condition de lui donner des séries temporelles propres. Un Grafana sans base de métriques reste une coquille vide.
L'architecture que je retiens : Prometheus scrape chaque machine toutes les 30 secondes, Grafana lit Prometheus, node_exporter expose les métriques système. Trois briques, un seul point d'entrée HTTP.
Monter la stack en un fichier compose
Je refusais d'ajouter un orchestrateur pour trois conteneurs. Un docker-compose.yml de 40 lignes suffit, et il tient dans Git à côté du reste de l'infra.
services:
prometheus:
image: prom/prometheus:v3.2.1
command:
- --config.file=/etc/prometheus/prometheus.yml
- --storage.tsdb.retention.time=15d
volumes:
- ./prometheus.yml:/etc/prometheus/prometheus.yml:ro
- prom-data:/prometheus
ports: ["127.0.0.1:9090:9090"]
restart: unless-stopped
node:
image: prom/node-exporter:v1.9.1
pid: host
command: ["--path.rootfs=/host"]
volumes:
- /:/host:ro,rslave
restart: unless-stopped
grafana:
image: grafana/grafana:11.6.0
environment:
GF_SECURITY_ADMIN_PASSWORD__FILE: /run/secrets/grafana_admin
GF_USERS_ALLOW_SIGN_UP: "false"
GF_ANALYTICS_REPORTING_ENABLED: "false"
volumes:
- grafana-data:/var/lib/grafana
- ./provisioning:/etc/grafana/provisioning:ro
- ./dashboards:/var/lib/grafana/dashboards:ro
ports: ["127.0.0.1:3000:3000"]
restart: unless-stopped
volumes:
prom-data:
grafana-data:Deux détails qui évitent des ennuis. Les ports écoutent sur 127.0.0.1 : Grafana et Prometheus passent par le reverse proxy, jamais en direct sur Internet. Et le mot de passe admin vient d'un fichier monté, pas d'une variable d'environnement visible dans docker inspect.
Côté Prometheus, la configuration tient en un fichier. Chaque cible porte un label instance qui servira de variable dans les dashboards.
global:
scrape_interval: 30s
evaluation_interval: 30s
scrape_configs:
- job_name: node
static_configs:
- targets: ["orchestrator:9100"]
labels: {instance: "vps-orchestrator"}
- targets: ["deploy:9100"]
labels: {instance: "vps-deploy"}
- targets: ["raspi:9100"]
labels: {instance: "raspi"}Provisionner plutôt que cliquer
Un dashboard construit à la souris est un dashboard qui meurt avec le conteneur. Grafana accepte trois fichiers YAML de provisionnement, lus au démarrage : sources de données, fournisseurs de dashboards, règles d'alerte.
# provisioning/datasources/prometheus.yml
apiVersion: 1
datasources:
- name: Prometheus
uid: prometheus
type: prometheus
access: proxy
url: http://prometheus:9090
isDefault: true
editable: false
jsonData:
timeInterval: 30sLe champ uid est la clé de tout le reste : les dashboards versionnés y font référence, donc l'ordre de déploiement n'a plus d'importance. Le fournisseur de dashboards pointe vers un dossier monté, où je dépose mes JSON exportés.
# provisioning/dashboards/default.yml
apiVersion: 1
providers:
- name: infra
orgId: 1
folder: Infra
type: file
disableDeletion: true
allowUiUpdates: false
options:
path: /var/lib/grafana/dashboardsallowUiUpdates: false est volontaire. Si quelqu'un modifie un panneau dans l'interface, le changement disparaît au prochain redémarrage. C'est brutal, mais c'est la seule façon de garantir que Git reste la vérité. La procédure complète est documentée dans la doc officielle du provisionnement.
Les cinq requêtes PromQL qui font 90 % du travail
J'ai testé une trentaine de panneaux avant de supprimer les vingt-cinq inutiles. Ces cinq requêtes couvrent les pannes que j'ai réellement rencontrées.
| Panneau | Requête | Ce qu'elle révèle |
|---|---|---|
| CPU occupé | 100 - avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[$__rate_interval])) * 100 |
Un pic à 95 % sur 10 minutes, pas une pointe de 3 secondes |
| RAM disponible | 100 * node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes |
Sous 15 %, le kernel commence à tuer des processus |
| Disque racine | 100 - 100 * node_filesystem_avail_bytes{mountpoint="/",fstype!~"tmpfs|overlay"} / node_filesystem_size_bytes{mountpoint="/"} |
La métrique qui m'aurait évité la panne de 3 h du matin |
| Cible morte | up == 0 |
Prometheus ne joint plus l'exporter, donc la machine ou le service a un problème |
| Charge normalisée | node_load1 / count without(cpu, mode) (node_cpu_seconds_total{mode="idle"}) |
Au-delà de 1, la file d'attente dépasse le nombre de cœurs |
La variable $__rate_interval mérite un mot. Elle est calculée par Grafana à partir du pas d'échantillonnage du panneau et de l'intervalle de scrape, avec un minimum de quatre points. Écrire [5m] en dur fonctionne jusqu'au jour où tu zoomes sur dix minutes et obtiens des trous.
Sur les compteurs, rate() doit toujours s'appliquer avant toute agrégation. sum(rate(...)) est correct, rate(sum(...)) produit des aberrations, surtout après un redémarrage qui remet le compteur à zéro. Les bases de PromQL sont bien expliquées dans la documentation de requêtage, notamment la gestion des compteurs qui repartent de zéro.
Un dashboard qui survit au temps
Mon premier dashboard affichait quatorze courbes sur un même graphique. Personne ne l'a jamais lu, moi compris. La règle que j'applique maintenant : un écran, quatre questions, une seule échelle par axe.
Variables et unités
Une variable instance construite avec label_values(up, instance) permet de filtrer les trois machines sans dupliquer le dashboard. Côté unités, déclarer percent (0-100) sur les panneaux CPU et RAM change tout : l'axe s'adapte et le survol affiche la valeur exacte au lieu d'un 4.2k.
Pour l'historique long, deux réglages comptent. Le Min step évite d'interroger Prometheus avec un pas trop fin sur une plage de sept jours, et la retention de 15 jours en local couvre largement le besoin d'un parc de cette taille. Au-delà, j'exporte vers un stockage objet plutôt que de garder tout en RAM.
Grafana a une doc dédiée aux bonnes pratiques de dashboarding, et une recommandation m'a fait gagner du temps : documenter chaque panneau avec une description. Un an plus tard, « mémoire disponible » ne veut plus dire grand-chose sans préciser qu'on inclut le cache.
Alerter sans noyer l'équipe
Une alerte qui se déclenche trois fois par jour finit ignorée. J'ai donc coupé tout ce qui n'appelait pas une action immédiate, et je n'ai gardé que quatre règles : disque au-dessus de 85 %, RAM sous 10 %, cible injoignable depuis 5 minutes, certificat TLS à moins de 14 jours de l'expiration.
# provisioning/alerting/rules.yml
apiVersion: 1
groups:
- orgId: 1
name: infra-vps
folder: Alertes infra
interval: 1m
rules:
- uid: vps-disque-plein
title: Disque racine au-dessus de 85 pourcent
condition: C
for: 5m
noDataState: OK
execErrState: Error
labels:
severite: warning
annotations:
summary: "{{ $labels.instance }} : disque a {{ $values.B }} %"
data:
- refId: A
relativeTimeRange: {from: 600, to: 0}
datasourceUid: prometheus
model:
expr: 100 - 100 * node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}
instant: false
range: true
- refId: B
datasourceUid: __expr__
model:
type: reduce
expression: A
reducer: last
- refId: C
datasourceUid: __expr__
model:
type: threshold
expression: B
conditions:
- evaluator: {type: gt, params: [85]}Trois champs font la différence entre une alerte utile et du bruit. for: 5m exige que la condition tienne cinq minutes avant d'envoyer quoi que ce soit. noDataState: OK évite le faux positif quand Prometheus redémarre. Et la laisse de groupe, réglée à 30 secondes, regroupe plusieurs instances en un seul message.
Le point de contact reste volontairement simple : un webhook vers mon canal d'alerting, pas de mail. Les règles d'alerte versionnées sont décrites dans la documentation alerting, y compris le format des valeurs dans les annotations.
Les cinq pièges que j'ai payés
| Piège | Symptôme | Correctif |
|---|---|---|
rate() sur un gauge |
Valeurs négatives ou absurdes sur la RAM | Utiliser delta() ou la valeur brute ; rate() ne s'applique qu'aux compteurs |
| Dashboard importé sans lecture | Le Node Exporter Full (ID 1860) charge 40 panneaux dont 12 utiles | Copier les requêtes qui servent, jeter le reste |
| Secrets en variables d'environnement | Mot de passe visible dans docker inspect |
Suffixe __FILE et fichier monté en lecture seule |
Provisionnement sans uid fixe |
Panneaux vides après un redéploiement | Déclarer uid dans la source et dans les JSON |
Alertes sans noDataState |
Notification « No data » à chaque redémarrage de Prometheus | noDataState: OK sauf pour les seuils critiques |
Le piège du rate() sur gauge est le plus vicieux, parce qu'il ne plante rien. Le panneau affiche une courbe plausible, et tu prends une décision sur une métrique qui n'a aucun sens.
Ce que je garde, ce que je jette
Je garde Prometheus plus Grafana pour tout parc inférieur à dix machines. L'empreinte est dérisoire : 180 Mo de RAM pour Prometheus avec quinze jours de rétention, 250 Mo pour Grafana sur mon orchestrateur. Aucun service managé ne bat ce rapport valeur/prix à cette échelle.
Je jette les dashboards communautaires importés en un clic. Ils sont pensés pour des parcs de centaines de nœuds et noient un parc de trois machines sous du bruit. Je jette aussi Loki tant que mes logs tiennent dans journald : ajouter une brique de logs sans requête de recherche récurrente, c'est de la dette d'exploitation.
Grafana Cloud reste pertinent dès que tu n'as plus envie de gérer Prometheus toi-même, mais le passage coûte un compte, une carte et une facturation à la série active. Pour trois VPS, je préfère le fichier compose et le backup du volume.
Un dernier point d'architecture : la supervision ne doit pas vivre sur la machine surveillée. Mon Grafana tourne sur l'orchestrateur, mais si celui-ci tombe, plus rien n'alerte. La parade tient en une ligne de cron qui ping l'endpoint de santé toutes les cinq minutes depuis l'extérieur. C'est rustique, et ça a déjà sauvé deux incidents.
Si tu veux le cadre théorique derrière ces choix, l'article sur ce que l'observabilité change vraiment pose le cadre, et celui sur OpenTelemetry explique pourquoi les traces ne remplacent pas les métriques.
FAQ
Faut-il Grafana Cloud pour trois VPS ?
Non, sauf si tu veux déléguer la rétention. Le compose ci-dessus tourne sur 512 Mo de RAM alloués et demande une heure d'installation. Grafana Cloud devient rentable quand tu dépasses une cinquantaine de séries actives ou que tu n'as plus personne pour maintenir Prometheus.
Prometheus ou VictoriaMetrics ?
Prometheus suffit jusqu'à environ un million de séries actives. VictoriaMetrics devient intéressant pour une rétention de plusieurs mois ou une ingestion massive, au prix d'une compatibilité PromQL partielle et d'un débogage moins documenté.
Comment sauvegarder les dashboards ?
Le JSON exporté dans Git, jamais le volume Docker seul. Le volume contient la base SQLite de Grafana, utile pour les utilisateurs et les annotations, mais les dashboards doivent pouvoir être reconstruits depuis le dépôt en une commande.
Grafana peut-il surveiller les conteneurs, pas seulement les VPS ?
Oui, avec cAdvisor en sidecar. Je l'ai retiré : sur trois machines, les métriques système suffisaient à expliquer les incidents, et cAdvisor multipliait le nombre de séries par cinq sans changer mes décisions.