Comment surveiller Kubernetes avec Grafana et Prometheus

Surveillance Kubernetes avec Grafana & Prometheus : Guide Pas à Pas

Surveillance Kubernetes avec Grafana & Prometheus : Guide Pas à Pas

Kubernetes est devenu la couche fondamentale pour le déploiement d'applications modernes, mais sa nature dynamique et distribuée rend une observabilité complète indispensable à la réussite opérationnelle. Vous devez comprendre la santé de vos nœuds, les performances de vos pods et l'état de votre cluster pour garantir la fiabilité et éviter des temps d'arrêt coûteux. Ce guide vous offre un parcours définitif et étape par étape pour maîtriser comment surveiller Kubernetes avec Grafana et Prometheus, transformant des métriques brutes en informations exploitables pour gérer proactivement votre infrastructure.

Ce Que Vous Allez Apprendre

À la fin de ce guide, vous saurez déployer une stack de surveillance complète et prête pour la production sur votre cluster Kubernetes en utilisant la référence du secteur, kube-prometheus-stack. Vous pourrez connecter Grafana à Prometheus, importer des tableaux de bord préconstruits pour une visibilité immédiate, et repartir avec un plan clair pour personnaliser les alertes et visualisations selon vos besoins spécifiques. Le point essentiel à retenir est que le chart Helm kube-prometheus-stack est la méthode la plus rapide et la plus fiable pour une surveillance Kubernetes complète.

La Stack de Surveillance Standard du Secteur pour Kubernetes

La combinaison de Prometheus et Grafana est la référence absolue pour la surveillance Kubernetes. Selon les données du secteur, environ 75 % des organisations utilisant Kubernetes adoptent Prometheus et Grafana pour leurs besoins d'observabilité. Ce n'est pas une simple tendance, c'est un témoignage de la puissance et de la flexibilité de cette boîte à outils open source.

• Prometheus est un projet diplômé de la Cloud Native Computing Foundation (CNCF), conçu pour la fiabilité et l'évolutivité. Il fonctionne en récupérant des métriques depuis diverses cibles (comme vos pods d'application ou les nœuds Kubernetes) à intervalles réguliers et en les stockant dans une base de données de séries temporelles. Vous pouvez ensuite interroger ces données avec PromQL (Prometheus Query Language), un langage puissant et flexible pour agréger et analyser les métriques.
• Grafana est la couche de visualisation. Il s'intègre parfaitement à Prometheus, transformant les données brutes récupérées en tableaux de bord et graphiques en temps réel. Cette représentation visuelle facilite grandement la détection des tendances, l'identification des anomalies et le diagnostic des problèmes de performance en un coup d'œil. Grafana peut également servir d'interface unifiée pour d'autres sources de données, mais pour Kubernetes, Prometheus est son partenaire le plus crucial.

Prérequis pour Votre Configuration

Avant de commencer, assurez-vous d'avoir installé et configuré les outils suivants. Ce guide suppose que vous disposez d'un cluster Kubernetes fonctionnel, qu'il s'agisse d'un environnement de développement local comme Minikube ou d'un cluster de production dans le cloud.

• Un Cluster Kubernetes en Fonctionnement : Vous avez besoin d'un cluster pour déployer la stack de surveillance. Pour les tests locaux, Minikube ou Kind fonctionnent parfaitement.
• Helm : Le gestionnaire de paquets Kubernetes est essentiel pour déployer kube-prometheus-stack. Assurez-vous d'avoir Helm v3.2+ installé sur votre machine locale.
• kubectl : L'outil en ligne de commande Kubernetes doit être configuré pour communiquer avec votre cluster.

Déploiement Pas à Pas : Utilisation de kube-prometheus-stack

La méthode la plus efficace et recommandée pour déployer Prometheus et Grafana pour la surveillance Kubernetes est d'utiliser le chart Helm kube-prometheus-stack. Ce chart est maintenu par la communauté Prometheus et regroupe tous les composants nécessaires dans un seul paquet facile à gérer. Il inclut :

• Prometheus Operator : Gère les instances Prometheus et Alertmanager.
• Prometheus : Le serveur de métriques principal.
• Alertmanager : Gère les alertes envoyées par Prometheus.
• Grafana : La plateforme de visualisation.
• Node Exporter : Collecte les métriques au niveau des nœuds (CPU, mémoire, disque) de vos nœuds Kubernetes.
• kube-state-metrics : Génère des métriques sur l'état des objets Kubernetes comme les pods, les déploiements et les services.

1. Ajouter le Dépôt Helm de la Communauté Prometheus

Ajoutez d'abord le dépôt Helm officiel et mettez-le à jour pour obtenir les dernières versions du chart.

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

2. Installer la Stack

Vous pouvez installer la stack avec une seule commande Helm, en la personnalisant avec divers paramètres. Cet exemple crée un namespace monitoring et active le stockage persistant pour les données Prometheus et Grafana.

helm install prometheus prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  --create-namespace \
  --set grafana.service.type=NodePort \
  --set grafana.service.nodePort=30094 \
  --set grafana.adminPassword=admin \
  --set prometheus.prometheusSpec.storageSpec.volumeClaimTemplate.spec.accessModes=["ReadWriteOnce"] \
  --set prometheus.prometheusSpec.storageSpec.volumeClaimTemplate.spec.resources.requests.storage=50Gi \
  --set prometheus.prometheusSpec.retention=30d

• grafana.adminPassword=admin : Définit le mot de passe administrateur pour Grafana. À modifier en production.
• --set grafana.service.type=NodePort : Expose Grafana en dehors du cluster via un NodePort pour un accès facile.
• prometheus.prometheusSpec.retention=30d : Définit la période de rétention des données Prometheus à 30 jours, essentielle pour l'analyse des tendances à long terme.

3. Vérifier l'Installation

Vérifiez que tous les pods dans le namespace monitoring sont en cours d'exécution.

kubectl get pods -n monitoring

La sortie doit afficher plusieurs pods avec un statut Running, incluant ceux pour Grafana, Prometheus, Alertmanager, node-exporter et kube-state-metrics.

Connecter Grafana à Votre Source de Données Prometheus

Le chart Helm kube-prometheus-stack configure souvent Prometheus comme source de données dans Grafana automatiquement. Cependant, il est préférable de vérifier la connexion.

Accéder à l'Interface Grafana

Pour accéder à l'interface web Grafana, vous pouvez utiliser le port-forwarding pour les tests locaux ou exposer le service avec un LoadBalancer ou un Ingress pour la production.

Option A : Port-Forwarding (Pour un Accès Local Rapide)

C'est la méthode la plus simple pour accéder temporairement à votre tableau de bord.

kubectl port-forward -n monitoring svc/prometheus-grafana 3000:80

Ouvrez maintenant votre navigateur et allez sur http://localhost:3000.

⚠️ Important : Le port-forwarding ne convient que pour les tests locaux et le développement. Pour une configuration permanente en production, exposez Grafana avec un Service de type LoadBalancer ou un Ingress Controller.

Option B : LoadBalancer (Recommandé pour les Environnements Cloud)

Si vous utilisez un fournisseur cloud comme UpCloud, AWS ou GCP, vous pouvez simplement modifier le service Grafana pour utiliser un LoadBalancer.

kubectl patch svc prometheus-grafana -n monitoring -p '{"spec": {"type": "LoadBalancer"}}'

Ensuite, récupérez l'adresse IP externe :

kubectl get svc -n monitoring prometheus-grafana

Accédez à Grafana à l'adresse http://<EXTERNAL-IP>:80.

Se Connecter

Utilisez les identifiants par défaut pour vous connecter :

• Nom d'utilisateur : admin
• Mot de passe : Le mot de passe défini lors de l'installation (par exemple, admin ou prom-operator).

Une fois connecté, naviguez vers Configuration > Data Sources pour confirmer qu'une source de données Prometheus existe et fonctionne. Cliquez dessus et utilisez le bouton Test pour vérifier la connectivité.

Créer des Tableaux de Bord : Du Préconstruit au Personnalisé

Avec Grafana connecté à Prometheus, vous pouvez commencer à visualiser vos métriques Kubernetes. Le moyen le plus rapide d'obtenir des informations précieuses est d'importer des tableaux de bord préconstruits de la communauté Grafana.

Importer des Tableaux de Bord Préconstruits

Grafana propose une vaste bibliothèque de tableaux de bord communautaires que vous pouvez importer en utilisant leurs identifiants uniques.

1. Survolez l'icône + dans la barre latérale et sélectionnez Import.
2. Saisissez un ID de tableau de bord dans le champ "Find and import dashboards". Deux tableaux de bord fortement recommandés sont :
   • 1860 : Node Exporter Full – fournit des métriques détaillées sur les nœuds de votre cluster, incluant CPU, mémoire, disque et réseau.
   • 8588 : Kubernetes Deployment Statefulset Daemonset – offre une vue de vos charges de travail Kubernetes.
3. Cliquez sur Load, puis sélectionnez votre source de données Prometheus et cliquez sur Import.

Ces tableaux de bord vous donneront une vue complète et immédiate de la santé de votre cluster sans écrire de requêtes PromQL.

Créer des Tableaux de Bord Personnalisés avec PromQL

Bien que les tableaux de bord préconstruits soient un excellent point de départ, vous aurez souvent besoin de créer des vues personnalisées adaptées à vos applications spécifiques. C'est là que PromQL entre en jeu.

Pour créer un nouveau tableau de bord, cliquez sur l'icône + et sélectionnez New Dashboard. Ensuite, cliquez sur Add visualization et choisissez votre source de données Prometheus.

Voici quelques requêtes PromQL essentielles pour la surveillance Kubernetes :

• Utilisation CPU par Pod :

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

• Utilisation Mémoire par Pod :

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

• Statut des Pods par Phase :

  sum(kube_pod_status_phase) by (phase)

  Cette requête est parfaite pour un panneau Stat, vous permettant de voir en un coup d'œil si tous vos pods sont en cours d'exécution.

Configurer les Alertes et Notifications

La surveillance n'est que la moitié de la bataille ; vous devez également être notifié en cas de problème. C'est le rôle d'Alertmanager, inclus dans kube-prometheus-stack.

Mettre en Place des Règles d'Alerte

Vous pouvez configurer Alertmanager pour envoyer des notifications vers divers canaux, comme Slack, email ou PagerDuty. Une configuration courante et efficace consiste à envoyer les alertes vers un canal Slack dédié.

1. Créez d'abord un webhook entrant dans votre espace de travail Slack.
2. Ensuite, modifiez la configuration d'Alertmanager. Vous pouvez le faire en fournissant un fichier values.yaml personnalisé lors d'une mise à niveau Helm ou en éditant directement le secret.
3. Mettez à jour la section alertmanager dans votre fichier values.yaml avec une route et un récepteur pointant vers l'URL de votre webhook Slack :

alertmanager:
  config:
    route:
      receiver: 'slack-notifications'
      group_wait: 30s
      group_interval: 5m
      repeat_interval: 1h
    receivers:
      - name: 'slack-notifications'
        slack_configs:
          - api_url: 'https://hooks.slack.com/services/your/webhook/url'
            send_resolved: true
            title: '{{ .CommonLabels.alertname }} ({{ .Status | toUpper }})'
            text: >-
              {{ range .Alerts }}
              *Alert:* {{ .Labels.alertname }}
              *Severity:* {{ if .Labels.severity }}{{ .Labels.severity }}{{ else }}n/a{{ end }}
              *Summary:* {{ if .Annotations.summary }}{{ .Annotations.summary }}{{ else }}n/a{{ end }}
              *Description:* {{ if .Annotations.description }}{{ .Annotations.description }}{{ else }}n/a{{ end }}
              {{- end }}

Après avoir appliqué ces modifications avec un helm upgrade, les alertes seront envoyées à votre canal Slack.

Bonnes Pratiques pour la Surveillance en Production

Pour garantir que votre stack de surveillance soit robuste et évolutive dans un environnement de production, suivez ces bonnes pratiques clés.

• Configurer le Stockage Persistant : Lors du déploiement en production, activez toujours le stockage persistant pour Prometheus et Grafana. Cela garantit que vos données de métriques et configurations de tableaux de bord survivent aux redémarrages de pods et aux mises à niveau du cluster. Dans kube-prometheus-stack, cela est contrôlé par les paramètres persistence et storageSpec dans le chart Helm.
• Optimiser les Performances des Requêtes : Les requêtes à haute cardinalité peuvent ralentir vos tableaux de bord et Prometheus lui-même. Pour maintenir les performances, agrégez toujours vos requêtes PromQL à la source. Par exemple, au lieu d'interroger container_cpu_usage_seconds_total, agrégez-la par namespace : sum by (namespace) (rate(container_cpu_usage_seconds_total[5m])). Cela réduit la quantité de données que Grafana doit traiter.
• Définir des Périodes de Rétention Appropriées : La période de rétention par défaut de Prometheus est de 15 jours. Ajustez-la selon vos besoins. Une période de rétention plus longue (par exemple, 30 à 60 jours) est utile pour l'analyse des tendances à long terme, mais nécessitera plus d'espace de stockage.
• Gérer la Configuration en Tant que Code : À mesure que vos besoins de surveillance évoluent, vous personnaliserez probablement les tableaux de bord et les règles d'alerte. Exportez vos tableaux de bord au format JSON et stockez-les dans un système de contrôle de version (par exemple, Git) avec vos règles d'alerte. Cette pratique, connue sous le nom de GitOps, rend votre configuration de surveillance reproductible et auditable.
• Ajuster les Intervalles de Récupération : L'intervalle de récupération par défaut pour Prometheus est de 30 secondes. Pour les métriques critiques à haute vélocité, vous pouvez récupérer plus souvent, mais sachez que cela augmente la charge sur Prometheus et le serveur API de votre cluster. Vous pouvez personnaliser ces intervalles dans les valeurs Helm.

Questions Fréquemment Posées

1. Quelle est la méthode la plus simple pour surveiller Kubernetes avec Grafana et Prometheus ? La méthode la plus simple et recommandée est d'utiliser le chart Helm kube-prometheus-stack. Il regroupe Prometheus, Grafana, Alertmanager, node-exporter et kube-state-metrics en un seul paquet, et vous pouvez le déployer avec seulement quelques commandes.

2. Est-il nécessaire d'utiliser kube-state-metrics pour surveiller Kubernetes ? Oui, kube-state-metrics est un composant critique qui génère des métriques sur l'état de vos objets Kubernetes, comme le nombre de pods prêts ou le statut d'un déploiement. Sans lui, vous n'auriez pas de visibilité sur la santé de vos ressources Kubernetes de plus haut niveau.

3. Comment puis-je accélérer le chargement de mes tableaux de bord Kubernetes ? Les tableaux de bord lents sont souvent causés par des requêtes PromQL inefficaces. Une solution clé est d'agréger vos requêtes pour réduire la cardinalité. Par exemple, au lieu d'afficher des données pour chaque pod, résumez-les au niveau du namespace avec des requêtes comme sum by (namespace) (rate(...)).

4. Quelle est la meilleure façon de recevoir des alertes de ma surveillance Kubernetes ? Prometheus fonctionne avec Alertmanager, qui peut envoyer des notifications vers divers canaux. Une méthode populaire et simple consiste à configurer Alertmanager pour envoyer des alertes vers un canal Slack via un webhook entrant. Cela fournit des notifications en temps réel et exploitables.

5. Dois-je installer manuellement Node Exporter sur chaque nœud ? Non. Lorsque vous déployez le chart Helm kube-prometheus-stack, il déploie automatiquement un DaemonSet Node Exporter. Cela garantit qu'un pod Node Exporter s'exécute sur chaque nœud de votre cluster, permettant à Prometheus de collecter des métriques au niveau des nœuds comme l'utilisation du CPU, de la mémoire et du disque sans aucune intervention manuelle.

Sources

1. UpCloud Global. (2025). Monitoring on UpCloud with Prometheus: Part 3.
2. Ubuntu Documentation. (2026). How to use Prometheus with Canonical Kubernetes.
3. Sfeir Institute. (2026). Create Effective Grafana Dashboards for Kubernetes Monitoring.
4. Ory. (2025). Monitoring.
5. GitHub - AkramGalal. (2025). deploying-prometheus-grafana-K8s-using-helm.
6. Go Packages. (2025). kube-prometheus.
7. GitHub - dotdc. (2026). grafana-dashboards-kubernetes.
8. Scaleway. (2025). Kubernetes Kapsule cluster monitoring with Prometheus & Grafana.
9. Mirantis. (2025). How to Set Up Prometheus & Grafana in K8s with Alertmanager & Slack Alerts.
10. Microsoft Learn. (2025). Using ConfigMap to customize Prometheus metric collection in Azure Monitor.
11. GitHub - Rurutia1027. (2025). Hands-on-Lab.K8s-Monitoring.

— Editorial Team