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.

Cas pratique : Grafana appliqué au réel

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: 30s

Le 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/dashboards

allowUiUpdates: 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.

PanneauRequêteCe 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ègeSymptômeCorrectif
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.