1. Présentation

Pourquoi une stack de supervision dédiée au cluster ?

Un cluster Kubernetes génère une quantité importante de métriques : état des pods, consommation CPU/RAM par namespace, santé des nœuds, disponibilité des déploiements… Ces métriques ne sont pas visibles dans une stack Docker classique.

kube-prometheus est la solution officielle de la communauté Prometheus pour superviser un cluster Kubernetes. Elle déploie tous les composants nécessaires via des manifests YAML, sans Helm.

Composants installés

Composant Rôle
Prometheus Collecte les métriques du cluster et des nœuds
kube-state-metrics Expose l'état des objets K8s (pods, deployments, services, PVC…)
node-exporter Métriques système de chaque nœud (CPU, RAM, disque)
Alertmanager Routage et envoi des alertes (email, Slack…)
Grafana Dashboards préconfigurés pour Kubernetes

Tout s'installe dans le namespace monitoring, créé automatiquement.

2. Prérequis

  • Cluster Kubernetes opérationnel (k3s, kubeadm, EKS, GKE, AKS…)
  • kubectl installé et configuré sur ta machine (kubectl get nodes doit répondre)
  • git installé

Vérifier que kubectl est fonctionnel

kubectl get nodes
# NAME          STATUS   ROLES           AGE   VERSION
# k8s-master    Ready    control-plane   10d   v1.28.0
# k8s-worker1   Ready    <none>          10d   v1.28.0

3. Installation de kube-prometheus

Cloner le repo officiel

git clone https://github.com/prometheus-operator/kube-prometheus.git
cd kube-prometheus

Le repo contient déjà tous les manifests YAML prêts à l'emploi dans le dossier manifests/.

Installer en deux étapes

# Étape 1 — CRDs et namespace monitoring (obligatoire en premier)
kubectl apply --server-side -f manifests/setup/

# Attendre que les CRDs soient prêts
kubectl wait 
  --for condition=Established 
  --all CustomResourceDefinition 
  --namespace=monitoring

# Étape 2 — Stack complète (Prometheus, Grafana, Alertmanager, exporters)
kubectl apply -f manifests/

--server-side est requis pour l'étape setup car les CRDs sont trop volumineux pour un apply client-side classique.

Vérifier que tout est Running

kubectl get pods -n monitoring
# NAME                                   READY   STATUS
# prometheus-k8s-0                       2/2     Running
# prometheus-k8s-1                       2/2     Running  ← 2 réplicas par défaut
# alertmanager-main-0                    2/2     Running
# grafana-xxx                            1/1     Running
# kube-state-metrics-xxx                 3/3     Running
# node-exporter-xxx                      2/2     Running  ← un pod par nœud
# prometheus-operator-xxx                2/2     Running
# blackbox-exporter-xxx                  2/2     Running

# Vérifier aussi les services exposés
kubectl get svc -n monitoring

4. Accéder à Grafana

Accès temporaire (port-forward)

kubectl port-forward -n monitoring svc/grafana 3000:3000
# → http://localhost:3000
# Login : admin / admin

Le port-forward fonctionne uniquement pendant que la commande tourne. Couper avec Ctrl+C.

Accès permanent via NodePort

Sans Ingress Controller, la solution la plus simple est d'exposer Grafana via un NodePort — le service devient accessible directement sur l'IP d'un nœud du cluster.

# grafana-nodeport.yml
apiVersion: v1
kind: Service
metadata:
  name: grafana-nodeport
  namespace: monitoring
spec:
  type: NodePort
  selector:
    app.kubernetes.io/name: grafana
  ports:
    - port: 3000
      targetPort: 3000
      nodePort: 30300   # port accessible sur chaque nœud (range 30000-32767)

kubectl apply -f grafana-nodeport.yml

# Récupérer l'IP d'un nœud
kubectl get nodes -o wide
# → http://<IP_NOEUD>:30300

Le NodePort est accessible sur chaque nœud du cluster, pas seulement sur le master.

5. Accéder à Prometheus et Alertmanager

# Prometheus
kubectl port-forward -n monitoring svc/prometheus-k8s 9090:9090
# → http://localhost:9090

# Alertmanager
kubectl port-forward -n monitoring svc/alertmanager-main 9093:9093
# → http://localhost:9093

6. Dashboards Grafana pour Kubernetes

Dans Grafana → Dashboards → Import → entrer l'ID :

ID Dashboard Utilisation
7249 Kubernetes Cluster Monitoring Vue globale du cluster
315 Kubernetes Cluster (générale) CPU, RAM, pods par nœud
6417 Kubernetes Pods Détail par pod
1860 Node Exporter Full Métriques système des nœuds

Les dashboards sont aussi déjà préconfigurés dans Grafana après l'installation de kube-prometheus. Aller dans Dashboards → Browse → Kubernetes.

7. Métriques PromQL utiles

État du cluster

# Nœuds non Ready
kube_node_status_condition{condition="Ready", status!="true"}

# Pods non Running (hors Completed)
kube_pod_status_phase{phase!="Running", phase!="Succeeded"}

# Pods en erreur (CrashLoopBackOff, OOMKilled…)
kube_pod_container_status_waiting_reason{reason=~"CrashLoopBackOff|OOMKilled|Error"}

CPU et RAM

# CPU utilisé par namespace
sum(rate(container_cpu_usage_seconds_total{container!=""}[5m])) by (namespace)

# RAM utilisée par pod
sum(container_memory_working_set_bytes{container!=""}) by (pod, namespace)

# RAM utilisée vs limite définie
container_memory_working_set_bytes / container_spec_memory_limit_bytes

Déploiements et réplicas

# Réplicas disponibles vs souhaités
kube_deployment_status_replicas_available / kube_deployment_spec_replicas

# Déploiements avec réplicas insuffisants
kube_deployment_status_replicas_available < kube_deployment_spec_replicas

Réseau

# Trafic réseau entrant par pod (Mo/s)
rate(container_network_receive_bytes_total[5m]) / 1024 / 1024

# Trafic réseau sortant par pod (Mo/s)
rate(container_network_transmit_bytes_total[5m]) / 1024 / 1024

8. Alertes préconfigurées

kube-prometheus installe automatiquement des règles d'alerte couvrant :

Alerte Déclenchement
KubeNodeNotReady Nœud non Ready depuis > 15 min
KubePodCrashLooping Pod en CrashLoopBackOff
KubeDeploymentReplicasMismatch Réplicas insuffisants
KubeMemoryOvercommit RAM demandée > RAM disponible
KubeCPUOvercommit CPU demandé > CPU disponible
PrometheusTargetMissing Une cible de scrape a disparu

Voir toutes les règles :

kubectl get prometheusrule -n monitoring

Configurer les notifications (email, Slack…)

Modifier le secret Alertmanager :

# Extraire la config actuelle
kubectl get secret alertmanager-main -n monitoring -o jsonpath='{.data.alertmanager.yaml}' | base64 -d > alertmanager.yml

# Éditer alertmanager.yml avec ta config email/Slack
# Puis appliquer
kubectl create secret generic alertmanager-main 
  --from-file=alertmanager.yaml=alertmanager.yml 
  --namespace monitoring 
  --dry-run=client -o yaml | kubectl apply -f -

Exemple de config email (Mailjet) dans alertmanager.yml :

global:
  smtp_smarthost: "in-v3.mailjet.com:587"
  smtp_from: "alertes@mondomaine.com"
  smtp_auth_username: "MAILJET_API_KEY"
  smtp_auth_password: "MAILJET_SECRET_KEY"
  smtp_require_tls: true

route:
  receiver: "equipe-si"
  group_by: ["alertname", "namespace"]

receivers:
  - name: "equipe-si"
    email_configs:
      - to: "si@mondomaine.com"
        send_resolved: true

9. Mettre à jour la stack

cd kube-prometheus
git pull

# Mettre à jour les CRDs
kubectl apply --server-side -f manifests/setup/

# Mettre à jour la stack
kubectl apply -f manifests/

kubectl apply est idempotent : seuls les composants modifiés sont mis à jour, les autres ne bougent pas.

10. Désinstaller

cd kube-prometheus
kubectl delete -f manifests/
kubectl delete -f manifests/setup/

Récapitulatif — Ordre de mise en place

Étape Action Commande
1 Vérifier kubectl kubectl get nodes
2 Cloner kube-prometheus git clone https://github.com/prometheus-operator/kube-prometheus.git
3 Installer CRDs kubectl apply --server-side -f manifests/setup/
4 Installer la stack kubectl apply -f manifests/
5 Vérifier les pods kubectl get pods -n monitoring
6 Accéder à Grafana kubectl port-forward -n monitoring svc/grafana 3000:3000
7 Importer dashboards ID 7249, 315, 6417, 1860
8 Configurer les alertes Modifier le secret alertmanager-main