Observabilité · PromQL · Dashboards · prom-client · Alerting
Bootcode IWA-S04 — DevOps, Semaine 4, Jour 2
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
L'observabilité : les 3 piliers
Métriques, logs, traces — pourquoi tu ne sais pas que ton app est down
Prometheus : pull & types de métriques
Counter, gauge, histogram, summary
PromQL
Requêtes de base pour interroger les métriques
Grafana + node_exporter
Dashboards, alertes, métriques système
Live coding
Instrumenter une app Node.js + dashboard Grafana live
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.
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.
# 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.
// 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.
# 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.
⏱️
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.
❌ 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
Collecte Prometheus, dashboards Grafana, node_exporter et métriques custom pour Bootcode Hub.
Dashboard à créer (6 panels)
rate(http_requests_total[5m])histogram_quantile(0.99, ...)Checklist
docker compose up pour tout👁️ 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.