03 — Grafana : dashboards et visualisation

Dans le module précédent, vous avez appris à extraire des métriques de Prometheus avec PromQL. C’est puissant, mais l’interface de Prometheus est… spartiate. Une seule requête, pas de persistance, pas de visualisations riches.

Grafana transforme vos données Prometheus en dashboards exploitables par toute votre équipe. Vous allez apprendre non seulement à créer des dashboards, mais surtout à le faire de la bonne façon — avec des variables, des templates, et du provisioning as code pour une approche GitOps.

Durée estimée

60 minutes

Ce que vous allez apprendre

À la fin de ce module, vous saurez :

1. Installer Grafana sur Kubernetes avec Helm
2. Connecter Prometheus comme datasource
3. Importer des dashboards communautaires (le plus rapide pour démarrer)
4. Créer vos propres dashboards panel par panel
5. Utiliser les variables pour des dashboards dynamiques et réutilisables
6. Provisionner dashboards et datasources as code (GitOps)

Prérequis

1. Prometheus est installé et fonctionne

   kubectl get pods -n observability | grep -E 'prometheus-server|kube-state-metrics|node-exporter'

   Ce que vous devez voir : les pods prometheus-server, kube-state-metrics et node-exporter en status Running.

   Si ce n’est pas le cas, retournez au module 02.

2. Vous êtes dans le répertoire du lab

   cd ~/lab-observability

3. Le repo Helm Grafana est ajouté

   helm repo list | grep grafana

   Si ce n’est pas le cas :

   helm repo add grafana https://grafana.github.io/helm-charts
   helm repo update

Comprendre Grafana

Qu’est-ce que Grafana ?

Grafana est un outil de visualisation et d’exploration de données. Il ne stocke pas les métriques — il se connecte à des datasources (Prometheus, Loki, MySQL, Elasticsearch…) et affiche leurs données.

Analogie : Si Prometheus est l’entrepôt où vous stockez vos marchandises (les métriques), Grafana est la vitrine où vous les exposez pour que tout le monde puisse les voir et les comprendre.

Concepts clés

Avant d’installer, comprenons la terminologie :

Concept	Description	Exemple
Datasource	Source de données externe	Prometheus, Loki, MySQL
Dashboard	Collection de visualisations sur un thème	”Santé du service checkout”
Panel	Une visualisation individuelle	Graphe de latence, jauge CPU
Query	Requête vers la datasource	PromQL, LogQL, SQL
Variable	Paramètre dynamique dans un dashboard	Dropdown pour choisir un service
Annotation	Marqueur d’événement sur les graphes	Déploiement, incident

Glissez pour voir

Architecture

Installer Grafana

1. Examinez la configuration Helm

   Avant d’installer, regardons les options importantes :

   cat 03-grafana/helm-values/grafana.yaml

   Points clés de la configuration :

   # Identifiants admin
   adminUser: admin
   adminPassword: admin   # À changer en production !
   
   # Accès externe via NodePort
   service:
     type: NodePort
     nodePort: 30030
   
   # Datasource Prometheus pré-configurée
   datasources:
     datasources.yaml:
       apiVersion: 1
       datasources:
         - name: Prometheus
           type: prometheus
           url: http://prometheus-server.observability.svc.cluster.local:80
           isDefault: true
   
   # Dashboards pré-importés
   dashboardProviders:
     # ...

   Cette configuration :

   • Crée un utilisateur admin avec mot de passe admin
   • Expose Grafana sur le port 30030
   • Pré-configure la connexion à Prometheus
   • Peut importer des dashboards automatiquement

   Sécurité en production

   Le mot de passe admin/admin convient pour ce lab. En production :

   • Utilisez un Secret Kubernetes pour les credentials
   • Configurez un Ingress avec authentification (OAuth2, OIDC)
   • Activez le RBAC Grafana pour limiter les accès

2. Installez Grafana

   helm upgrade --install grafana grafana/grafana \
     -n observability \
     -f 03-grafana/helm-values/grafana.yaml \
     --wait

   Warning deprecated

   Vous verrez un warning this chart is deprecated. Ignorez-le pour ce lab. Le chart grafana/grafana reste fonctionnel et est le plus simple pour apprendre. En production, Grafana recommande grafana-operator pour une gestion GitOps native Kubernetes.

   Ce que vous devez voir :

   Release "grafana" does not exist. Installing it now.
   coalesce.go:237: warning: skipped value for ...
   NAME: grafana
   LAST DEPLOYED: ...
   NAMESPACE: observability
   STATUS: deployed

3. Vérifiez le déploiement

   kubectl get pods -n observability -l app.kubernetes.io/name=grafana

   Ce que vous devez voir :

   NAME                       READY   STATUS    RESTARTS   AGE
   grafana-xxxxxxxxxx-xxxxx   1/1     Running   0          1m

4. Récupérez le mot de passe admin (si vous n’utilisez pas les values du lab)

   kubectl get secret grafana -n observability \
     -o jsonpath="{.data.admin-password}" | base64 -d ; echo

   Avec notre configuration, c’est simplement admin.

5. Accédez à Grafana

   Méthode 1 — NodePort (recommandée pour Minikube) :

   minikube service grafana -n observability --url

   Copiez l’URL affichée et ouvrez-la dans votre navigateur.

   Méthode 2 — Port-forward :

   kubectl port-forward svc/grafana 3000:80 -n observability

   Ouvrez http://localhost:3000

6. Connectez-vous

   • Username : admin
   • Password : admin (ou celui récupéré à l’étape 4)

   Grafana vous demandera peut-être de changer le mot de passe. Pour ce lab, vous pouvez le garder ou en mettre un autre que vous retiendrez.

Vous êtes maintenant dans Grafana ! Vous devriez voir la page d’accueil avec le menu à gauche.

Faire le tour de l’interface

Avant de créer des dashboards, familiarisons-nous avec l’interface.

Le menu principal (barre latérale gauche)

Icône	Menu	Description
🏠	Home	Page d’accueil
🔍	Explore	Requêtes ad-hoc (comme l’interface Prometheus)
📊	Dashboards	Vos tableaux de bord
⚡	Alerting	Gestion des alertes (module 04)
🔌	Connections	Configuration des datasources
⚙️	Administration	Utilisateurs, organisations, paramètres

Glissez pour voir

Vérifier la connexion à Prometheus

1. Allez dans Connections → Data sources (ou cliquez sur l’icône engrenage)

2. Vous devriez voir Prometheus dans la liste

3. Cliquez dessus pour voir la configuration

4. Descendez et cliquez sur Test

   Ce que vous devez voir : Un message vert “Data source is working”.

Si la datasource n’existe pas ou ne fonctionne pas, nous allons la configurer manuellement.

Configurer Prometheus manuellement (si nécessaire)

1. Connections → Data sources → Add data source

2. Cherchez et cliquez sur Prometheus

3. Configuration :

   Champ	Valeur
   Name	Prometheus
   URL	http://prometheus-server.observability.svc.cluster.local:80
   Access	Server (default)

   Glissez pour voir

   Pourquoi cette URL ?

   prometheus-server est le nom du service Kubernetes créé par Helm. .observability.svc.cluster.local est le suffixe DNS complet dans le cluster.

4. Laissez les autres options par défaut

5. Cliquez sur Save & test

   Ce que vous devez voir : “Data source is working”

Explore — tester des requêtes

L’onglet Explore (icône boussole) est l’équivalent Grafana de l’interface Graph de Prometheus, mais en mieux.

1. Cliquez sur Explore dans le menu

2. Vérifiez que Prometheus est sélectionné en haut

3. Dans le champ de requête, entrez :

   up

4. Cliquez sur Run query (ou appuyez sur Shift+Enter)

   Ce que vous devez voir : Tous les targets Prometheus avec leur état (1 = UP, 0 = DOWN).

5. Basculez entre les vues Table et Graph (boutons en haut à droite des résultats)

Explore vs Dashboard : Explore est pour l’exploration ad-hoc — vous cherchez, testez, affinez. Une fois que vous trouvez une requête utile, vous l’ajoutez à un dashboard pour la garder.

Importer un dashboard existant

Avant de créer vos propres dashboards, importons-en un de la communauté. C’est le moyen le plus rapide d’avoir quelque chose d’utile.

Importer “Node Exporter Full”

Ce dashboard affiche les métriques système (CPU, RAM, disque, réseau) collectées par Node Exporter.

1. Dashboards → New → Import

2. Dans le champ “Import via grafana.com”, entrez l’ID : 1860

3. Cliquez sur Load

   Ce que vous voyez : Les détails du dashboard (nom, description, auteur).

4. Configuration :

   Champ	Valeur
   Name	Gardez le nom par défaut ou personnalisez
   Folder	General ou créez un dossier “Infrastructure”
   Prometheus	Sélectionnez votre datasource Prometheus

   Glissez pour voir

5. Cliquez sur Import

Vous êtes maintenant dans le dashboard ! Scrollez pour voir tous les panels : CPU, mémoire, réseau, disque, etc.

D'où viennent ces dashboards ?

Grafana.com héberge une bibliothèque de milliers de dashboards partagés par la communauté. Chaque dashboard a un ID unique que vous pouvez utiliser pour l’importer.

Parcourez : https://grafana.com/grafana/dashboards/

Dashboards recommandés à importer

Importez ces dashboards pour avoir une base solide :

ID	Nom	Ce qu’il montre	Compatibilité
1860	Node Exporter Full	CPU, RAM, disque, réseau des nodes	✅ Fonctionne avec notre stack
13332	kube-state-metrics	Pods, deployments, services K8s	⚠️ Certains panels peuvent être vides

Glissez pour voir

Dashboards communautaires et compatibilité

Certains dashboards populaires (315, 7249, 12740…) sont conçus pour kube-prometheus-stack (Prometheus Operator) et utilisent des labels/métriques différents de notre stack prometheus-community/prometheus.

Si vous importez un dashboard et voyez beaucoup de “No data” :

1. Vérifiez les métriques attendues dans Explore
2. Adaptez les requêtes aux labels de votre installation

Exercice : Importez le dashboard 1860 (Node Exporter Full). Il est très compatible avec notre installation. Explorez-le pendant quelques minutes.

Créer votre premier dashboard

Maintenant, créons un dashboard personnalisé pour surveiller l’infrastructure Kubernetes.

Métriques disponibles

Grâce à l’OpenTelemetry Collector installé dans le module 01, vous avez accès aux métriques de l’application OTel Demo préfixées par otel_ (ex: otel_http_server_duration_seconds_count, otel_http_client_duration_seconds_bucket). Vous pouvez les combiner avec les métriques système (node_*, container_*) et Kubernetes (kube_*).

Créer le dashboard vide

Objectif de ce dashboard

Nous allons créer un dashboard de monitoring de Prometheus lui-même (self-monitoring). C’est un excellent exercice pour apprendre les bases car les métriques prometheus_* sont toujours disponibles.

Dans un prochain exercice, vous pourrez créer un dashboard pour les métriques OTel (otel_*).

1. Dashboards → New → New Dashboard

2. Vous voyez une page vide avec le message “Start your new dashboard by adding a visualization”

3. Avant d’ajouter des panels, sauvegardez le dashboard :

   • Cliquez sur l’icône 💾 (save) en haut à droite
   • Dashboard name : Prometheus - Self-monitoring
   • Folder : Créez un nouveau dossier Infrastructure
   • Save

Maintenant nous avons un dashboard vide sauvegardé. Ajoutons des panels.

Panel 1 : Requêtes par seconde (Stat)

Ce premier panel affichera le nombre total de requêtes HTTP sur l’API Prometheus.

1. Cliquez sur Add visualization

2. Sélectionnez Prometheus comme datasource

3. Requête — dans le champ Query, entrez :

   sum(rate(prometheus_http_requests_total[5m]))

   Cliquez sur Run queries pour prévisualiser.

   Ce que vous devez voir : Une valeur numérique (ex: 0.5) représentant les requêtes/s.

4. Configuration du panel — dans la sidebar à droite :

   Section	Paramètre	Valeur
   Title		Requêtes totales /s
   Visualization		Sélectionnez Stat (en haut de la sidebar)
   Standard options → Unit		requests/sec (reqps)
   Standard options → Decimals		1
   Stat styles → Color mode		Value
   Stat styles → Orientation		Horizontal

   Glissez pour voir

5. Thresholds (optionnel mais recommandé) :

   • Cliquez sur Thresholds
   • Par défaut, les valeurs sont vertes
   • Ajoutez un seuil : 10 → Orange
   • Ajoutez un seuil : 50 → Rouge

   Cela colore le panel en fonction de la charge.

6. Cliquez sur Apply (en haut à droite)

Votre premier panel est créé ! Vous le voyez maintenant dans le dashboard.

Panel 2 : Requêtes par handler (Time series)

1. Cliquez sur Add → Visualization

2. Requête :

   sum by (handler) (rate(prometheus_http_requests_total[5m]))

   Ce que vous voyez : Plusieurs séries, une par handler Prometheus.

3. Configuration :

   Section	Paramètre	Valeur
   Title		Requêtes par handler
   Visualization		Time series (déjà sélectionné par défaut)
   Standard options → Unit		requests/sec (reqps)
   Legend	Mode	Table
   Legend	Placement	Bottom
   Legend	Values	Cochez Last, Max

   Glissez pour voir

4. Apply

Panel 3 : Latence P99 API Prometheus (Time series)

1. Add → Visualization

2. Requête :

   histogram_quantile(0.99,
     sum by (handler, le) (
       rate(prometheus_http_request_duration_seconds_bucket[5m])
     )
   )

3. Configuration :

   Section	Paramètre	Valeur
   Title		Latence P99 par handler
   Standard options → Unit		seconds (s)
   Standard options → Decimals		3

   Glissez pour voir

4. Apply

Panel 4 : Taux d’erreur (Gauge)

1. Add → Visualization

2. Requête :

   sum(rate(prometheus_http_requests_total{code=~"5.."}[5m]))
   /
   sum(rate(prometheus_http_requests_total[5m]))
   * 100

   Pas de données ?

   Si vous n’avez pas d’erreurs 5xx, le résultat sera vide ou 0. C’est normal — c’est même bien !

3. Configuration :

   Section	Paramètre	Valeur
   Title		Taux d'erreur HTTP 5xx
   Visualization		Gauge
   Standard options → Unit		Percent (0-100)
   Standard options → Min		0
   Standard options → Max		100

   Glissez pour voir

4. Thresholds :

   • Base (vert) : 0
   • Orange : 0.5 (0.5% d’erreurs)
   • Rouge : 1 (1% d’erreurs)

5. Apply

Panel 5 : Targets UP (Stat)

1. Add → Visualization

2. Requête :

   count(up == 1)

3. Configuration :

   Section	Paramètre	Valeur
   Title		Targets UP
   Visualization		Stat
   Stat styles → Color mode		Background
   Thresholds	Base	Vert
   Thresholds		Ajoutez : 5 → Orange (alerte si moins de 5 targets)

   Glissez pour voir

4. Apply

Panel 6 : Distribution par code HTTP (Pie chart)

1. Add → Visualization

2. Requête :

   sum by (code) (rate(prometheus_http_requests_total[5m]))

3. Configuration :

   Section	Paramètre	Valeur
   Title		Codes HTTP
   Visualization		Pie chart
   Pie chart → Labels		Cochez Name et Percent

   Glissez pour voir

4. Apply

Organiser les panels

Maintenant que vous avez 6 panels, organisons-les :

1. Déplacez les panels en cliquant-glissant leur barre de titre

2. Redimensionnez en tirant le coin inférieur droit

3. Layout suggéré (en grille 24 colonnes) :

   ┌────────────────────────────────────────────────┐
   │ Requêtes/s  │  Taux erreur  │  Targets UP      │
   │   (Stat)    │    (Gauge)    │    (Stat)        │ ← Petits panels en haut
   ├────────────────────────────────────────────────┤
   │                Requêtes par handler             │
   │                  (Time series)                 │ ← Large panel au milieu
   ├────────────────────────────┬───────────────────┤
   │      Latence P99           │   Codes HTTP      │
   │     (Time series)          │   (Pie chart)     │ ← Pannels moyens en bas
   └────────────────────────────┴───────────────────┘

4. Sauvegardez : 💾 → Save

Les variables — rendre le dashboard dynamique

Notre dashboard affiche toute l’application otel-demo. Mais que faire si vous voulez voir un seul service ? Ou tous les services sauf un ?

Les variables permettent d’ajouter des filtres dynamiques.

Créer une variable “service”

1. Ouvrez les paramètres du dashboard : icône ⚙️ en haut à droite

2. Allez dans Variables → Add variable

3. Configuration :

   Paramètre	Valeur	Explication
   Name	handler	Nom utilisé dans les requêtes
   Label	Handler	Texte affiché dans le dropdown
   Type	Query	La variable vient d’une requête
   Data source	Prometheus
   Query	Voir ci-dessous

   Glissez pour voir

   Query :

   label_values(prometheus_http_requests_total, handler)

   Cette requête extrait toutes les valeurs uniques du label handler.

4. Options supplémentaires :

   Paramètre	Valeur	Pourquoi
   Multi-value	✓ Coché	Permet de sélectionner plusieurs handlers
   Include All option	✓ Coché	Ajoute “All” pour voir tous les handlers
   Custom all value	.*	Regex qui matche tout

   Glissez pour voir

5. Cliquez sur Apply

6. Vérifiez : en bas de la page, vous voyez la liste des handlers découverts.

7. Run (en haut à droite) puis Save dashboard

Retournez sur le dashboard. Vous voyez maintenant un dropdown “Handler” en haut.

Utiliser la variable dans les panels

La variable existe, mais les panels ne l’utilisent pas encore. Modifions-les.

1. Éditez le panel “Requêtes par handler” : cliquez sur le titre → Edit

2. Modifiez la requête :

   Avant :

   sum by (handler) (rate(prometheus_http_requests_total[5m]))

   Après (ajoutez le filtre handler=~"$handler") :

   sum by (handler) (rate(prometheus_http_requests_total{handler=~"$handler"}[5m]))

3. Exécutez la requête pour vérifier qu’elle fonctionne

4. Apply

5. Répétez pour les autres panels qui affichent des données par handler

Syntaxe des variables

• $service : valeur simple (ex: frontend)
• ${service} : idem, utile si suivi de texte
• $service avec Multi-value : devient frontend|checkout|cart (regex)
• C’est pourquoi on utilise =~ (match regex) et pas = (égalité)

Variables les plus utiles

Variable	Type	Query	Usage
service	Query	label_values(otel_http_server_duration_seconds_count, service_name)	Filtrer par service OTel
namespace	Query	label_values(kube_pod_info, namespace)	Filtrer par namespace
node	Query	label_values(node_uname_info, nodename)	Filtrer par node
interval	Interval	1m,5m,15m,30m,1h	Ajuster la fenêtre de rate()

Glissez pour voir

Découvrir les labels disponibles

Les labels OTel peuvent varier selon la version du Collector et les transformations appliquées. Avant de créer une variable, vérifiez les labels disponibles dans Explore :

# Lister les métriques OTel
topk(20, count by (__name__) ({__name__=~"otel_.*"}))

# Vérifier les labels d'une métrique
count by (service_name) (otel_http_server_duration_seconds_count)

Si service_name n’existe pas, essayez service, job, k8s_namespace_name, etc.

Variable “interval” (bonus)

Cette variable permet de changer la fenêtre de temps dans rate().

1. Dashboard settings → Variables → Add variable

2. Configuration :

   Paramètre	Valeur
   Name	interval
   Type	Interval
   Values	1m,5m,15m,30m,1h
   Auto option	✓ Coché
   Step count	30

   Glissez pour voir

3. Apply et Save dashboard

Dans vos requêtes, remplacez [5m] par [$interval] :

rate(prometheus_http_requests_total{...}[$interval])

Maintenant vous pouvez zoomer/dézoomer la granularité depuis le dashboard.

Provisioning as code — la méthode GitOps

Jusqu’ici, nous avons créé des dashboards manuellement dans l’interface. C’est bien pour expérimenter, mais en production :

• Que se passe-t-il si quelqu’un supprime accidentellement un dashboard ?
• Comment versionner les changements ?
• Comment déployer les mêmes dashboards sur plusieurs environnements ?

Le provisioning résout ces problèmes : les datasources et dashboards sont définis en fichiers YAML/JSON et chargés automatiquement au démarrage de Grafana.

Exporter un dashboard en JSON

1. Ouvrez votre dashboard “Prometheus - Self-monitoring”

2. Cliquez sur l’icône Share (rectangle avec flèche) en haut

3. Onglet Export

4. Cochez Export for sharing externally (optionnel, nettoie les IDs spécifiques)

5. Cliquez sur Save to file

   Le fichier JSON est téléchargé.

6. Sauvegardez ce fichier dans le repo du lab :

   mv ~/Downloads/prometheus-self-monitoring-*.json ~/lab-observability/03-grafana/dashboards/prometheus-self-monitoring.json

Structure du provisioning

Le provisioning utilise deux types de fichiers :

03-grafana/
├── helm-values/
│   └── grafana.yaml              # Configuration Helm
├── dashboards/
│   └── otel-demo.json            # Dashboard exporté
└── provisioning/                  # Optionnel, structure alternative
    ├── datasources/
    │   └── prometheus.yaml
    └── dashboards/
        └── provider.yaml

Provisionner des datasources

Dans notre configuration Helm, les datasources sont déjà provisionnées :

# Dans grafana.yaml
datasources:
  datasources.yaml:
    apiVersion: 1
    datasources:
      - name: Prometheus
        type: prometheus
        url: http://prometheus-server.observability.svc.cluster.local
        access: proxy
        isDefault: true
        editable: false   # Empêche les modifications manuelles

Pourquoi editable: false ?

• Empêche quelqu’un de modifier la datasource par accident
• Force les modifications à passer par le code (revue, historique)
• Garantit la cohérence entre environnements

Provisionner des dashboards

Ajoutons notre dashboard exporté à la configuration Helm.

Deux approches de provisioning

Approche	Avantages	Inconvénients
ConfigMap manuel (kubectl create configmap)	Rapide pour tester	Pas déclaratif, doit être recréé manuellement
100% Helm (chart parent / Kustomize)	GitOps complet	Plus complexe à setup

Glissez pour voir

Pour ce lab, nous utilisons l’approche ConfigMap + Helm values — rapide et suffisante pour apprendre. En production, préférez tout gérer via Helm ou un outil GitOps (ArgoCD, Flux).

1. Créez un ConfigMap avec le dashboard :

   kubectl create configmap grafana-dashboard-prometheus-self \
     --from-file=prometheus-self-monitoring.json=03-grafana/dashboards/prometheus-self-monitoring.json \
     -n observability

   Mise à jour du ConfigMap

   Un ConfigMap créé manuellement n’est pas mis à jour automatiquement si le fichier JSON change. Pour appliquer des modifications :

   kubectl create configmap grafana-dashboard-prometheus-self \
     --from-file=prometheus-self-monitoring.json=03-grafana/dashboards/prometheus-self-monitoring.json \
     -n observability --dry-run=client -o yaml | kubectl apply -f -

2. Modifiez les values Helm pour charger le ConfigMap :

   Éditez 03-grafana/helm-values/grafana.yaml et ajoutez :

   dashboardProviders:
     dashboardproviders.yaml:
       apiVersion: 1
       providers:
         - name: 'default'
           orgId: 1
           folder: 'Provisioned'
           type: file
           disableDeletion: true      # Empêche la suppression via l'UI
           updateIntervalSeconds: 30   # Recharge toutes les 30s
           options:
             path: /var/lib/grafana/dashboards/default
   
   dashboardsConfigMaps:
     default: "grafana-dashboard-prometheus-self"

3. Appliquez les changements :

   helm upgrade grafana grafana/grafana \
     -n observability \
     -f 03-grafana/helm-values/grafana.yaml

4. Vérifiez : dans Grafana, le dashboard apparaît dans le dossier “Provisioned” avec une icône indiquant qu’il ne peut pas être modifié.

Dashboards provisionnés = lecture seule

Les dashboards provisionnés ne peuvent pas être modifiés via l’interface. Si vous voulez les modifier :

1. Faites les changements dans le JSON
2. Mettez à jour le ConfigMap
3. Grafana les recharge automatiquement (d’après updateIntervalSeconds)

C’est intentionnel : cela force le workflow GitOps.

Bonnes pratiques dashboards

Un dashboard = une question

Ne créez pas de “méga-dashboards” avec 50 panels. Créez des dashboards focalisés :

❌ Évitez	✅ Préférez
”Dashboard général"	"Performance du service Checkout"
"Toutes les métriques"	"SLIs de l’application"
"Monitoring"	"Capacité du cluster”

Glissez pour voir

Conventions de nommage

Élément	Convention	Exemple
Dashboard	[Domaine] Sujet	[OTel Demo] Checkout, [Infra] Nodes
Folder	Par équipe ou domaine	Applications, Infrastructure, SRE
Panel	Action + métrique	”Requêtes par seconde”, “Latence P99”
Variable	lowercase_snake_case	service, namespace, time_range

Glissez pour voir

Limiter les séries par panel

Trop de séries = panel illisible et lent. Utilisez topk() :

# ❌ Potentiellement 100+ séries
sum by (service_name) (rate(otel_http_server_duration_seconds_count[5m]))

# ✅ Top 10 seulement
topk(10, sum by (service_name) (rate(otel_http_server_duration_seconds_count[5m])))

Thresholds cohérents

Définissez les mêmes seuils partout pour éviter la confusion :

Métrique	🟢 OK	🟠 Warning	🔴 Critical
Latence P99	< 100ms	< 500ms	> 500ms
Taux d’erreur	< 0.1%	< 1%	> 1%
CPU	< 70%	< 85%	> 85%
Mémoire	< 80%	< 90%	> 90%

Glissez pour voir

Dépannage Grafana

”No data” sur un panel

Causes possibles et solutions :

Cause	Diagnostic	Solution
Datasource non configurée	Connections → Data sources → Test	Configurer l’URL correcte
Requête incorrecte	Testez dans Explore	Corrigez la syntaxe PromQL
Time range trop restreint	Regardez le time picker	Élargissez à “Last 1 hour”
Métriques inexistantes	Testez {__name__=~".*keyword.*"}	Vérifiez que les métriques existent

Glissez pour voir

Dashboard lent

Solutions :

1. Réduisez le time range : 24h au lieu de 7d
2. Utilisez $__rate_interval au lieu de 5m (la variable s’adapte au time range)
3. Limitez les séries avec topk(10, ...)
4. Créez des recording rules dans Prometheus pour pré-calculer

Variables qui ne chargent pas

Diagnostic :

1. Dashboard settings → Variables → Votre variable
2. Vérifiez la requête en bas (les valeurs trouvées)
3. Si vide : la requête ne retourne rien

Solution : Testez la requête label_values(...) dans Explore pour vérifier qu’elle fonctionne.

Validation finale

1. Grafana est accessible et connecté à Prometheus

   Allez dans Connections → Data sources → Prometheus → Test : “Data source is working”

2. Vous avez importé au moins un dashboard communautaire

   Dashboards → vous voyez “Node Exporter Full” ou similaire

3. Vous avez créé votre propre dashboard

   Dashboards → “Prometheus - Self-monitoring” existe avec 6+ panels

4. Les variables fonctionnent

   Le dropdown “Handler” filtre bien les données

5. Vous savez exporter un dashboard en JSON

   Le fichier existe dans 03-grafana/dashboards/

6. Grafana est opérationnel (vérification technique)

   # Service accessible
   kubectl get svc -n observability grafana
   
   # Pas d'erreurs dans les logs
   kubectl logs -n observability -l app.kubernetes.io/name=grafana --tail=20 | grep -i error

   Si la deuxième commande ne retourne rien, c’est bon signe !

Ce que vous avez appris

1. Grafana se connecte à des datasources (Prometheus) et visualise leurs données
2. Importer un dashboard est le moyen le plus rapide de démarrer
3. Les panels ont différents types : Time series, Stat, Gauge, Pie chart…
4. Les variables rendent les dashboards dynamiques et réutilisables
5. Le provisioning permet de gérer les dashboards as code (GitOps)

Prochaine étape

Vous avez des dashboards. Mais personne ne regarde les dashboards 24/7. Dans le prochain module, nous configurons l’alerting pour être notifié automatiquement quand quelque chose ne va pas.

04 — Alerting → Configurer l'alerting avec Alertmanager et les notifications.

×

📖 Voir la documentation →