Monitoring : Prometheus & Grafana

Observabilité · PromQL · Dashboards · prom-client · Alerting

Bootcode IWA-S04 — DevOps, Semaine 4, Jour 2

Objectifs de la leçon

1. L'observabilité

Les 3 piliers : métriques, logs, traces — et leur rôle respectif

2. L'architecture Prometheus

Le modèle pull-based : Prometheus vient chercher tes métriques

3. PromQL

Interroger les séries temporelles : rate, histogram_quantile, filtres

4. Dashboards Grafana

Panels, datasource Prometheus, visualisation en temps réel

5. Instrumenter + alerter

prom-client dans Node.js, node_exporter pour le système, alertes Grafana

Plan du cours

1

L'observabilité : les 3 piliers

Métriques, logs, traces — pourquoi tu ne sais pas que ton app est down

2

Prometheus : pull & types de métriques

Counter, gauge, histogram, summary

3

PromQL

Requêtes de base pour interroger les métriques

4

Grafana + node_exporter

Dashboards, alertes, métriques système

5

Live coding

Instrumenter une app Node.js + dashboard Grafana live

Les 3 piliers de l'observabilité

Sans monitoring, tu découvres que ton app est down… quand les utilisateurs se plaignent.

📊 Métriques

Des nombres agrégés : req/s, latence p99, taux d'erreur, CPU. Cheap à stocker, idéales pour dashboards et alertes.

→ QUE quelque chose ne va pas

📜 Logs

Des événements détaillés horodatés : qui a fait quoi, quelle erreur, quelle stack trace. Verbeux mais précieux.

→ POURQUOI ça ne va pas

🔍 Traces

Le chemin d'une requête à travers les services : où le temps est passé, quel appel a échoué.

→ OÙ le problème se situe

Aujourd'hui : les métriques. Demain : les logs.

Prometheus : le modèle pull

Pull, pas push

Tes apps exposent /metrics. Prometheus vient les scraper toutes les N secondes selon sa config — pas l'inverse.

Séries temporelles

Chaque métrique = nom + labels + valeur datée : http_requests_total{status="200",path="/api"}

Rétention

15 jours par défaut — configurable via --storage.tsdb.retention.time.

Les 4 types de métriques

Counter

Ne fait que monter : requêtes totales, erreurs totales. Jamais de reset manuel.

Gauge

Monte ET descend : mémoire utilisée, connexions actives, température.

Histogram

Répartition en buckets : latences → permet le calcul des percentiles (p99).

Summary

Comme l'histogram mais quantiles calculés côté client.

PromQL en pratique

# requêtes par seconde (moyenne sur 5 min)

rate(http_requests_total[5m])

# latence p99

histogram_quantile(0.99,

  rate(http_request_duration_seconds_bucket[5m]))

# taux d'erreur 5xx en %

rate(http_requests_total{status=~"5.."}[5m])

  / rate(http_requests_total[5m]) * 100

# CPU utilisé (node_exporter)

100 - (avg(rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

# RAM utilisée en %

(1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100

rate() sur les counters

Un counter ne fait que croître — rate() donne la vitesse par seconde. C'est LA fonction de base.

Filtres par labels

{status=~"5.."} regex, {mode="idle"} exact — les labels font toute la puissance de PromQL.

Instrumenter Node.js avec prom-client

// src/metrics.ts

import client from 'prom-client';

client.collectDefaultMetrics();

export const httpRequests = new client.Counter({

  name: 'http_requests_total',

  help: 'Total des requêtes HTTP',

  labelNames: ['method', 'path', 'status'],

});

// dans Express — le endpoint obligatoire :

app.get('/metrics', async (req, res) => {

  res.set('Content-Type', client.register.contentType);

  res.end(await client.register.metrics());

});

❌ Oublier /metrics

Pas d'endpoint → Prometheus ne peut rien scraper. L'erreur la plus fréquente.

✅ Labels = dimensions

method, path, status — permet de filtrer et regrouper dans PromQL sans créer une métrique par cas.

Le stack complet en docker-compose

# prometheus.yml

scrape_configs:

  - job_name: 'app'

    static_configs:

      - targets: ['app:3000']

  - job_name: 'node'

    static_configs:

      - targets: ['node_exporter:9100']

# docker-compose.monitoring.yml

prometheus:  # prom/prometheus → :9090

grafana:     # grafana/grafana   → :3001

node_exporter: # prom/node-exporter → :9100

:9090 — Prometheus

L'explorateur : tester les requêtes PromQL, vérifier que toutes les targets sont UP.

:3001 — Grafana

admin/admin au premier login, datasource = Prometheus, puis les dashboards.

node_exporter

Métriques système prêtes à l'emploi : CPU, RAM, disque, réseau — aucun code à écrire.

Les 4 signaux dorés + alertes

⏱️

Latence

p99 < 2s

🚦

Trafic

req/seconde

🔥

Erreurs

5xx < 5%

📈

Saturation

CPU/RAM < 80%

Un dashboard efficace = 4 à 6 panels max couvrant ces 4 signaux. Pas un mur de courbes illisible.

🔔 Erreurs > 5% pendant 2 min

Alerte critique — réaction immédiate

🔔 Latence p99 > 2s pendant 5 min

Dégradation utilisateur

🔔 CPU > 80% pendant 5 min

Saturation imminente

Le for: (durée) évite les alertes sur des pics instantanés — une bonne alerte déclenche sur une vraie tendance.

Pièges courants

❌ Counter vs gauge confondus

Counter = toujours croissant (utiliser rate()). Gauge = fluctue (valeur directe). rate() sur une gauge n'a pas de sens.

❌ /metrics non exposé

Prometheus affiche target DOWN — l'app doit exposer l'endpoint et il doit être joignable depuis le conteneur Prometheus.

❌ Dashboard trop complexe

30 panels = rien de lisible. Commencer par les 4 signaux dorés, itérer ensuite.

❌ Oublier la rétention

15 jours par défaut. Pour garder l'historique long terme : retention.time ou remote write (Thanos, Mimir).

Exercice E4.2 — ~4h

Monitoring complet : Prometheus + Grafana + Node.js

Collecte Prometheus, dashboards Grafana, node_exporter et métriques custom pour Bootcode Hub.

Dashboard à créer (6 panels)

  • 📊 Requêtes/sec : rate(http_requests_total[5m])
  • ⏱️ Latence p99 : histogram_quantile(0.99, ...)
  • 🔥 Taux d'erreurs 5xx en %
  • 🖥️ CPU, 🧠 RAM, 💾 Disque via node_exporter

Checklist

  • ✅ Prometheus :9090, toutes les targets UP
  • ✅ Grafana :3001, datasource configurée
  • ✅ /metrics exposé avec métriques custom
  • ✅ ≥ 4 panels, ≥ 2 alertes
  • ✅ PromQL fonctionne dans l'explorateur
  • ✅ Un seul docker compose up pour tout

À retenir !

👁️ Observabilité = 3 piliers

Métriques (QUE), logs (POURQUOI), traces (OÙ). Aujourd'hui : les métriques.

🎣 Prometheus scrape

Mode pull : il vient chercher /metrics. Ton app n'envoie rien — elle expose.

📊 4 signaux dorés

Latence, trafic, erreurs, saturation — suffisent pour un premier dashboard.

🔔 Une alerte = une action

Seuil + durée (for). Si tu ne fais rien quand elle sonne, supprime-la.