📊 Grafana – Dashboards, Monitoring & Observabilité

Qu'est-ce que Grafana ?

Grafana est une plateforme open-source d'analyse et de visualisation de métriques. C'est l'outil de *facto* pour créer des dashboards de monitoring complexes et interactifs.

Sa force principale est d'être "agnostique" : il peut se connecter à des dizaines de sources de données (Data Sources) différentes et les agréger sur un seul dashboard.

Les 3 piliers de l'Observabilité

Grafana est au centre de l'observabilité moderne :

• MÉTRIQUES (Metrics) : (Le "Quoi" - ex: CPU à 80%). Source : Prometheus, InfluxDB.
• LOGS (Logs) : (Le "Pourquoi" - ex: "Error: DB timeout"). Source : Loki, Elasticsearch.
• TRACES (Tracing) : (Le "Où" - ex: "Le timeout vient de l'API /auth"). Source : Tempo, Jaeger.

Grafana vs. Kibana

C'est une confusion fréquente.

Les 3 Blocs de Grafana

1. Data Source (Source de Données) : La "base de données" où sont stockées les métriques ou les logs (ex: Prometheus, Loki, PostgreSQL...). Grafana *ne stocke* aucune donnée.
2. Panel (Panneau) : L'unité de visualisation. C'est un graphique (ex: "Time series", "Stat", "Gauge"). Un panel est lié à une ou plusieurs requêtes sur une Data Source.
3. Dashboard (Tableau de bord) : Une collection de Panels, organisés en lignes et colonnes. C'est ce que l'utilisateur consulte.

Schéma de flux

+-----------------+
| Prometheus      |--+
| (Metrics)       |  |
+-----------------+  | (1. Data Sources)
| Loki (Logs)     |--+
+-----------------+  |
| Postgres (SQL)  |--+
+-----------------+  |
                   |
                   ▼
+------------------------------------+
| Serveur GRAFANA (Frontend + Backend) |
| (Stocke Dashboards, Gère les Users)  |
|                                    |
| +--------------------------------+ |
| | Dashboard: "Mon App"           | |
| | +----------+ +----------+     | |
| | | Panel 1  | | Panel 2  |     | | (2. Panels)
| | | (Query A)  | | (Query B)  |     | |
| | +----------+ +----------+     | |
| +--------------------------------+ |
+------------------------------------+
                   |
                   ▼
+------------------------------------+
| Utilisateur (Navigateur Web)       |
+------------------------------------+

grafana.ini

Le fichier de configuration principal.
Emplacement : /etc/grafana/grafana.ini (Linux) ou /usr/share/grafana/conf/defaults.ini (Docker).

Toute modification nécessite un redémarrage (sudo systemctl restart grafana-server).

Exemples (grafana.ini)

[server]
# Port HTTP
http_port = 3000

# Adresse d'écoute
http_addr = 0.0.0.0

# URL racine (si derrière reverse proxy)
# root_url = https://grafana.ideolab.com

[security]
# Mot de passe 'admin' (obsolète, à changer au 1er login)
;admin_user = admin
;admin_password = admin

# Autoriser l'intégration (iframe)
allow_embedding = true

[auth.anonymous]
# Autoriser les dashboards publics
enabled = true
org_name = IDEO-Lab Public
org_role = Viewer

Variables d'Environnement (Docker)

Pour Docker, il est plus simple de configurer via des variables d'environnement GF_.

Format : GF_[SECTION]_[CLE] (majuscules).

docker run -d -p 3000:3000 \
  -e "GF_SECURITY_ADMIN_USER=admin_ideo" \
  -e "GF_SECURITY_ADMIN_PASSWORD=mon_pass_secret" \
  -e "GF_AUTH_ANONYMOUS_ENABLED=true" \
  grafana/grafana-oss

Les Panels Incontournables

Un dashboard est un assemblage de panels, organisés en "Rows" (Lignes).

L'éditeur de requête

C'est le cœur du Panel. C'est ici que l'on écrit la requête (ex: PromQL) pour récupérer les données.

Éléments clés :

• Data source : (Choisir "Prometheus-Prod").
• Query Editor (A) : La zone de texte pour la requête.
• Legend : Formatage de la légende (ex: {{}}job}}}}).
• Min step : Intervalle de "scrape" (ex: 15s).
• Options : Type de graphe, style...

PromQL : Les requêtes de base

PromQL (Prometheus Query Language) est un langage fonctionnel pour les séries temporelles.

% 1. Métrique simple (Gauge)
# CPU (en %) par instance (job 'node')
node_cpu_usage_percentage{job="node"}

% 2. Taux de requêtes (Counter -> Gauge)
# (Le "Hello World" de PromQL)
# Requêtes/sec, moyennées sur 5 min
rate(http_requests_total[5m])

% 3. Agrégation (sum)
# Total des req/sec, groupées par 'job' (API)
sum(rate(http_requests_total[5m])) by (job)

% 4. Top 5
# Top 5 des processus utilisant le plus de RAM
topk(5, process_resident_memory_bytes)

Alerting (Post-Grafana 8)

Grafana intègre un système d'alerting complet (basé sur le moteur de Prometheus Alertmanager).

Flux de travail :

1. Contact Points (Où) : Définir les "cibles" (Email, Slack, Teams, PagerDuty...).
2. Notification Policies (Quand) : Définir "comment" router (ex: les "critical" vont sur PagerDuty, les "info" sur Slack).
3. Alert Rules (Quoi) : Définir la condition (ex: "CPU > 80% pendant 5 min").

Créer une "Alert Rule"

La méthode la plus simple est de créer une règle depuis un Panel :

1. Créer un Panel (ex: CPU)
2. Clic Droit -> Edit
3. Onglet "Alert" -> "Create alert rule from this panel"
4. (Grafana copie la requête A)
5. Ajouter une requête "B" (Reduce)
   - Input: A
   - Mode: "Reduce" -> "Last" (dernière valeur)
6. Ajouter une requête "C" (Threshold)
   - Input: B
   - Condition: "IS ABOVE 80"
7. Définir le "Folder" et le "Group"
8. Définir "For" (Durée) -> "5m"
   (L'alerte ne se déclenche que si C est VRAI pendant 5 min)

La Stack "GLT" (Grafana/Loki/Tempo)

Grafana Labs pousse sa propre stack d'observabilité (alternative à ELK) :

1. Prometheus (ou Mimir) - Metrics

Prometheus (standard CNCF) reste le roi des métriques.

2. Loki - Logs

"Prometheus, but for logs". Loki est un système d'agrégation de logs. Il ne fait pas d'indexation full-text (comme Elastic). Il n'indexe que les *labels* (métadonnées : job, app, level).
Avantage : Extrêmement léger et peu coûteux.
Requête (LogQL) : {job="api"} |= "error"

3. Tempo - Traces

Un système de "Distributed Tracing" (comme Jaeger). Il suit une requête à travers plusieurs microservices.

Le "Workflow" d'Observabilité

La puissance de Grafana est de lier ces sources :

1. [Dashboard "Metrics" (Prometheus)]
   (CPU élevé, Taux d'erreur 500 en hausse)
   |
   | (Clic sur le graphe -> "Voir les logs liés")
   |
   ▼
2. [Dashboard "Logs" (Loki)]
   (Filtre auto: {job="api", status="500"})
   (Log: "Error: TraceID=abc123 ...")
   |
   | (Clic sur le TraceID)
   |
   ▼
3. [Dashboard "Traces" (Tempo)]
   (Affiche la cascade de la requête "abc123")
   - API-Gateway (5ms)
     - AuthService (10ms)
     - DB-Service (500ms) <-- (Le coupable !)

Types de Métriques

• Gauge : (Valeur instantanée : RAM, CPU).
• Counter : (Compteur qui n'augmente jamais : req_total, errors_total). Doit *toujours* être utilisé avec rate().

Fonctions Clés (Counters)

# Req/sec (moyenne sur 5m)
rate(http_requests_total[5m])

# Augmentation (sur 1h)
increase(http_requests_total[1h])

Agrégation (sum, avg)

# Total des req/sec, par job et path
sum(rate(http_requests_total[5m])) by (job, path)

# CPU moyen par instance
avg(node_cpu_usage_percentage) by (instance)

# Top 5 des process par RAM
topk(5, process_resident_memory_bytes)

# 95ème centile (Histogrammes)
histogram_quantile(0.95, 
  sum(rate(http_request_duration_seconds_bucket[5m])) by (le)
)