Créer des dashboards Grafana performants pour le monitoring Kubernetes

TL;DR : Ce guide vous montre comment créer des dashboards Grafana efficaces pour le monitoring Kubernetes en 6 étapes : installation de Grafana, connexion à Prometheus, création de visualisations pour le cluster et les pods, configuration des alertes et optimisation des performances. Vous obtiendrez des tableaux de bord opérationnels en moins de 2 heures.

Pour approfondir ces compétences, découvrez la formation LFD459 Kubernetes pour les développeurs d'applications.

---

Pourquoi créer des dashboards Grafana pour Kubernetes ?

Grafana visualisation métriques Kubernetes est devenue la norme dans l'industrie. Selon Grafana Labs, 75% des organisations utilisant Kubernetes adoptent Prometheus et Grafana pour leur monitoring. Cette combinaison offre une visibilité complète sur la santé de vos clusters.

« Kubernetes is no longer experimental but foundational. Soon, it will be essential to AI as well. » — Chris Aniszczyk, CNCF State of Cloud Native 2026

Un dashboard bien conçu permet de :

• Détecter les anomalies avant qu'elles n'impactent la production
• Réduire le MTTR (Mean Time To Recovery) de 40 à 60%
• Corréler les métriques entre infrastructure et applications

À retenir : Sans dashboards adaptés, vous surveillez sans comprendre. Grafana transforme les métriques brutes en insights actionnables.

---

Prérequis

Avant de commencer, vérifiez ces éléments :

Vérifiez votre cluster :

kubectl get nodes
# Résultat attendu :
# NAME      STATUS   ROLES           AGE   VERSION
# master    Ready    control-plane   30d   v1.29.2
# worker1   Ready    <none>          30d   v1.29.2
# worker2   Ready    <none>          30d   v1.29.2

Si Prometheus n'est pas installé, consultez notre guide Déployer la stack kube-prometheus complète en environnement de production.

---

Étape 1 : Installer Grafana sur Kubernetes avec Helm

1.1 Ajouter le repository Helm Grafana

Exécutez ces commandes pour configurer Helm :

helm repo add grafana https://grafana.github.io/helm-charts
helm repo update
# Résultat attendu :
# "grafana" has been added to your repositories
# Hang tight while we grab the latest from your chart repositories...
# ...Successfully got an update from the "grafana" chart repository

1.2 Créer le namespace monitoring

kubectl create namespace monitoring --dry-run=client -o yaml | kubectl apply -f -
# Résultat attendu :
# namespace/monitoring created (ou unchanged si existant)

1.3 Déployer Grafana avec une configuration optimisée

Créez le fichier values.yaml :

# grafana-values.yaml
persistence:
  enabled: true
  size: 10Gi

adminPassword: "VotreMotDePasseSecurise123!"

datasources:
  datasources.yaml:
    apiVersion: 1
    datasources:
    - name: Prometheus
      type: prometheus
      url: http://prometheus-server.monitoring.svc.cluster.local
      access: proxy
      isDefault: true

dashboardProviders:
  dashboardproviders.yaml:
    apiVersion: 1
    providers:
    - name: 'default'
      folder: ''
      type: file
      disableDeletion: false
      editable: true
      options:
        path: /var/lib/grafana/dashboards/default

resources:
  requests:
    cpu: 100m
    memory: 256Mi
  limits:
    cpu: 500m
    memory: 512Mi

Installez Grafana :

helm install grafana grafana/grafana \
  --namespace monitoring \
  --values grafana-values.yaml \
  --version 7.3.0
# Résultat attendu :
# NAME: grafana
# NAMESPACE: monitoring
# STATUS: deployed
# REVISION: 1

1.4 Vérifier le déploiement

kubectl get pods -n monitoring -l app.kubernetes.io/name=grafana
# Résultat attendu :
# NAME                       READY   STATUS    RESTARTS   AGE
# grafana-7d5b6b8f4c-x2kj9   1/1     Running   0          2m

À retenir : La persistence est essentielle. Sans PVC, vos dashboards disparaissent au redémarrage du pod.

---

Étape 2 : Configurer la source de données Prometheus

2.1 Accéder à l'interface Grafana

Exposez Grafana temporairement :

kubectl port-forward svc/grafana -n monitoring 3000:80 &
# Résultat attendu :
# Forwarding from 127.0.0.1:3000 -> 3000

Accédez à http://localhost:3000 avec les identifiants :

• User : admin
• Password : VotreMotDePasseSecurise123!

2.2 Vérifier la connexion Prometheus

Si vous avez utilisé le values.yaml ci-dessus, Prometheus est déjà configuré. Vérifiez la connexion :

1. Allez dans Configuration → Data Sources
2. Cliquez sur Prometheus
3. Cliquez sur Test

# Résultat attendu :
# ✓ Data source is working

Si la connexion échoue, vérifiez l'URL du service Prometheus :

kubectl get svc -n monitoring | grep prometheus
# Résultat attendu :
# prometheus-server   ClusterIP   10.96.45.123   <none>   80/TCP   30d

Pour les équipes préparant la certification CKAD, la maîtrise de ces interconnexions est couverte dans la formation LFD459 Kubernetes pour les développeurs d'applications.

---

Étape 3 : Créer un dashboard de vue globale du cluster

3.1 Créer un nouveau dashboard

1. Cliquez sur + → New Dashboard
2. Cliquez sur Add visualization
3. Sélectionnez Prometheus comme source

3.2 Ajouter le panneau CPU cluster

Configurez la requête PromQL :

sum(rate(container_cpu_usage_seconds_total{namespace!="kube-system"}[5m])) by (namespace)

Paramètres du panneau :

3.3 Ajouter le panneau mémoire cluster

sum(container_memory_working_set_bytes{namespace!="kube-system"}) by (namespace) / 1024 / 1024 / 1024

Configuration :

• Title : Mémoire par namespace (GiB)
• Unit : gibibytes

3.4 Ajouter les pods par état

sum(kube_pod_status_phase) by (phase)

Créez une stat panel avec ces valeurs :

# Configuration panel
Visualization: Stat
Calculation: Last
Color mode: Value
Graph mode: None
Text mode: Value and name

Selon le rapport CNCF 2025, 82% des utilisateurs de conteneurs exécutent Kubernetes en production, ce qui rend ce type de monitoring indispensable.

À retenir : Commencez toujours par une vue globale avant de descendre au niveau pod. Cette approche top-down accélère le diagnostic.

---

Étape 4 : Créer un dashboard de monitoring des pods

4.1 Dashboard avec variables dynamiques

Ajoutez des variables pour filtrer dynamiquement :

1. Allez dans Dashboard Settings → Variables
2. Créez la variable namespace :

Name: namespace
Type: Query
Data source: Prometheus
Query: label_values(kube_pod_info, namespace)
Refresh: On dashboard load

1. Créez la variable pod :

Name: pod
Type: Query
Query: label_values(kube_pod_info{namespace="$namespace"}, pod)
Refresh: On time range change

4.2 Panneau CPU par pod

sum(rate(container_cpu_usage_seconds_total{namespace="$namespace", pod="$pod"}[5m])) by (container)

4.3 Panneau mémoire par pod

sum(container_memory_working_set_bytes{namespace="$namespace", pod="$pod"}) by (container) / 1024 / 1024

4.4 Panneau network I/O

# Bytes reçus
sum(rate(container_network_receive_bytes_total{namespace="$namespace", pod="$pod"}[5m]))

# Bytes transmis
sum(rate(container_network_transmit_bytes_total{namespace="$namespace", pod="$pod"}[5m]))

Utilisez un graphique avec deux séries :

• Receive bytes : couleur verte
• Transmit bytes : couleur bleue

Pour diagnostiquer les problèmes de pods, consultez Déboguer un pod en CrashLoopBackOff sur Kubernetes.

---

Étape 5 : Configurer les alertes Grafana

5.1 Créer une règle d'alerte CPU

1. Éditez un panneau CPU
2. Allez dans l'onglet Alert
3. Cliquez sur Create alert rule

Configuration de l'alerte :

Alert name: High CPU Usage
Evaluate every: 1m
For: 5m
Condition: WHEN avg() OF query(A, 5m, now) IS ABOVE 80

5.2 Configurer un contact point

# Exemple de configuration Slack webhook
kubectl create secret generic grafana-slack-webhook \
  --from-literal=url='https://hooks.slack.com/services/XXX/YYY/ZZZ' \
  -n monitoring

Dans Grafana :

1. Alerting → Contact points → New contact point
2. Type : Slack
3. Webhook URL : $(SLACK_WEBHOOK_URL)

5.3 Vérifier les alertes configurées

kubectl exec -it $(kubectl get pods -n monitoring -l app.kubernetes.io/name=grafana -o jsonpath='{.items[0].metadata.name}') \
  -n monitoring -- grafana-cli admin stats
# Résultat attendu :
# Active alerts: 3
# Dashboard count: 5

« Don't let your knowledge remain theoretical — set up a real Kubernetes environment to solidify your skills. » — TealHQ Kubernetes DevOps Guide

---

Étape 6 : Optimiser les performances des dashboards

6.1 Réduire la cardinalité des requêtes

Mauvaise pratique :

# ❌ Cardinalité explosive
container_cpu_usage_seconds_total

Bonne pratique :

# ✓ Agrégation immédiate
sum by (namespace, pod) (rate(container_cpu_usage_seconds_total[5m]))

6.2 Configurer le caching

Ajoutez ces paramètres au values.yaml :

grafana.ini:
  dataproxy:
    timeout: 30
    keep_alive_seconds: 30
  caching:
    backend: database

6.3 Définir des intervalles de rafraîchissement adaptés

Configurez dans Dashboard Settings :

Auto-refresh: 30s
Time range: Last 6 hours

Pour une approche complète du Monitoring et dépannage Kubernetes, explorez nos autres guides pratiques.

---

Dépannage des problèmes courants

Dashboard ne charge pas les données

Vérifiez la connectivité Prometheus :

kubectl exec -it $(kubectl get pods -n monitoring -l app.kubernetes.io/name=grafana -o jsonpath='{.items[0].metadata.name}') \
  -n monitoring -- wget -qO- http://prometheus-server.monitoring.svc.cluster.local/api/v1/status/runtimeinfo
# Résultat attendu :
# {"status":"success","data":{...}}

Requêtes PromQL trop lentes

Analysez avec :

# Vérifiez la cardinalité
count by (__name__)({__name__=~".+"})

Si une métrique dépasse 100 000 séries, ajoutez des filtres :

# Filtrez par namespace
sum(rate(container_cpu_usage_seconds_total{namespace=~"prod|staging"}[5m]))

Grafana pod en CrashLoopBackOff

kubectl logs -n monitoring -l app.kubernetes.io/name=grafana --tail=50
# Cherchez les erreurs de permission ou de PVC

Solution fréquente :

kubectl delete pvc grafana -n monitoring
helm upgrade grafana grafana/grafana -n monitoring --values grafana-values.yaml

Consultez le guide complet Déboguer un pod en CrashLoopBackOff pour les cas plus complexes.

---

Dashboards communautaires recommandés

Importez ces dashboards depuis Grafana.com :

Importez via CLI :

curl -s https://grafana.com/api/dashboards/315/revisions/latest/download \
  | kubectl exec -i $(kubectl get pods -n monitoring -l app.kubernetes.io/name=grafana -o jsonpath='{.items[0].metadata.name}') \
  -n monitoring -- grafana-cli admin import-dashboard

Pour maîtriser l'ensemble de la stack d'observabilité, consultez notre guide Guide complet : installer et configurer Prometheus sur Kubernetes.

---

Passez à l'action : formez-vous au monitoring Kubernetes

Créer des dashboards Grafana performants pour le monitoring Kubernetes est une compétence essentielle pour tout ingénieur infrastructure ou développeur Cloud-Native. Avec 82% des organisations utilisant Kubernetes en production (CNCF 2025), cette expertise vous positionne sur un marché où le salaire moyen atteint 152 640 $/an (Ruby On Remote).

« Demand and salaries for highly-skilled and qualified tech talent are fiercer than ever, and certifications present a clear pathway for IT professionals to further their careers. » — Hired CTO via Splunk

Formations recommandées :

• LFS458 Administration Kubernetes : Maîtrisez l'administration complète des clusters Kubernetes (4 jours, préparation CKA)
• LFD459 Kubernetes pour les développeurs d'applications : Développez et déployez des applications conteneurisées (3 jours, préparation CKAD)
• Kubernetes, les fondamentaux : Découvrez les concepts essentiels en une journée

Explorez nos autres ressources :

• Formation Kubernetes : Guide Complet
• Déploiement et mise en production Kubernetes
• Formation Monitoring et dépannage Kubernetes pour Le CTO. Pour approfondir, consultez notre formation Monitoring et dépannage Kubernetes entreprise Le DRH utilisant la formation pour la stratégie talents.

Contactez nos conseillers pour planifier votre montée en compétences sur Kubernetes.