Aller au contenu

Lab 06 : Exploitation, Observabilité & Reverse Debugging

Objectifs Pédagogiques :

  • Lire les logs d'une application (kubectl logs en direct, multi-pods, conteneur précédent) et la chronologie des événements.
  • Ouvrir un shell dans un conteneur avec kubectl exec pour observer la configuration et le réseau vus du pod.
  • Appliquer une méthode de dépannage, du général au détail, sur 3 incidents classiques : CrashLoopBackOff, OOMKilled et Service sans réponse.
  • Surveiller la santé des nœuds avec Node Problem Detector et isoler un nœud malade (kubectl cordon / drain).
  • Mesurer la consommation avec Metrics Server (kubectl top) et centraliser métriques et logs avec Prometheus, Fluent Bit, Loki et Grafana.
  • Situer cette pile par rapport aux services managés des clouds, dont StackDriver (aujourd'hui Google Cloud Observability).

📌 Note Compatibilité OS :
Les commandes kubectl de cet atelier sont rigoureusement identiques sous Windows (PowerShell), Linux (Ubuntu) et macOS (Terminal).

🖥️ Environnement : le cluster 3 nœuds (1 control plane + 2 workers) du Lab 00. Node Problem Detector surveille les workers et l'étape 12 isole l'un d'eux : réalisez ce lab sur ce cluster, piloté au choix : * Option A (Recommandée - Confort DevOps Local) : depuis votre machine locale, avec votre kubectl et votre kubeconfig.
* Option B (PC d'entreprise verrouillé) : en SSH sur k8s-control : l'outillage et les manifests sont pré-installés dans ~/labs/.

🛟 Secours : Minikube sur votre poste (session AWS indisponible), piloté forcément depuis votre poste comme en Option A. Remplacez k8s-worker-1 par minikube ; avec un seul nœud, l'étape 12 (drain) laisse les pods applicatifs en Pending jusqu'au uncordon. Pour ouvrir Grafana (étape 16), utilisez minikube service grafana -n monitoring --url.

🗂️ Namespace de travail : campus-dev. Ce lab est indépendant des autres : son étape 0 recrée campus-dev à neuf et y installe tout ce dont il a besoin. Vous pouvez le réaliser sans avoir fait les labs précédents, ou le recommencer à tout moment.


Contexte Métier

Le Campus Summer Portal est en production. Un administrateur passe l'essentiel de son temps à répondre à trois questions : que raconte l'application ? (logs), le nœud est-il sain ? (état), combien consomme-t-elle ? (métriques). On commence toujours par kubectl, puis on outille : historique, alertes, tableaux de bord.

Question Outils de base Outils de supervision
Logs : que raconte-t-il ? kubectl logs, kubectl exec Fluent Bit + Loki
État : le nœud est-il sain ? kubectl describe node, événements Node Problem Detector
Métriques : combien consomme-t-il ? kubectl top (Metrics Server) Prometheus + Grafana

Étape 0 : Préparer l'environnement

Le dossier starter/ du lab installe l'application complète :

Fichier Contenu
01-config.yaml Le ConfigMap campus-config (paramètres non sensibles de l'API).
02-postgres.yaml Le PVC pvc-postgres, la base PostgreSQL persistante et son Service postgres.
03-backend.yaml L'API campus-backend (2 réplicas, configuration lue dans le ConfigMap et le Secret) et son Service campus-backend.
04-frontend.yaml Le frontend et son Service NodePort campus-frontend-svc (port 30088).

Les identifiants de la base ne sont pas versionnés dans le starter : vous créez le Secret campus-db-credentials par une commande, comme au Lab 05.

Repartez d'un namespace campus-dev vide, puis appliquez le starter. Depuis la racine du dépôt (Option A) ou depuis ~ sur k8s-control (Option B : mettez d'abord le dépôt à jour avec git -C ~/formation pull, puis remplacez labs/ par ~/labs/) :

kubectl delete namespace campus-dev --ignore-not-found   # ⚠️ supprime tout le contenu de campus-dev
kubectl create namespace campus-dev
kubectl config set-context --current --namespace=campus-dev
kubectl create secret generic campus-db-credentials --from-literal=POSTGRES_DB=campus --from-literal=POSTGRES_USER=campus --from-literal='POSTGRES_PASSWORD=CampusSecret2026!'
kubectl apply -f labs/06-exploitation-debugging/starter/
kubectl rollout status deployment/campus-postgres --timeout=180s
kubectl rollout status deployment/campus-backend --timeout=300s

La suppression du namespace peut prendre jusqu'à une minute. Spring Boot met ensuite 20 secondes à 2 minutes à démarrer.

Placez-vous ensuite dans le dossier du lab, qui contient les manifests npd/ et monitoring/ utilisés plus loin : cd labs/06-exploitation-debugging (Option A) ou cd ~/labs/06-exploitation-debugging (Option B).


Analyser les logs

  1. Lire et suivre les logs. Affichez les 20 dernières lignes du backend, puis suivez les nouvelles en direct (Ctrl + C pour quitter) :

    kubectl logs -f deployment/campus-backend --tail=20
    

  2. Lire les logs de tous les pods d'une étiquette. Avec plusieurs réplicas, --prefix indique de quel pod vient chaque ligne :

    kubectl logs -l app=campus-backend --prefix --tail=5
    
    D'autres options utiles : --previous lit le conteneur précédent, celui qui a planté (étape 6), et -c <conteneur> choisit un conteneur précis dans un pod qui en a plusieurs.

  3. Lire la chronologie des événements du namespace (placements, téléchargements d'images, redémarrages, erreurs) :

    kubectl get events --sort-by=.metadata.creationTimestamp
    

💡 Les logs d'un pod meurent avec lui. En production, on les centralise : c'est le rôle de Fluent Bit et Loki (étape 15).


Entrer dans un conteneur avec kubectl exec

  1. Ouvrir un shell dans le backend. -it demande un terminal interactif ; tout ce qui suit -- s'exécute dans le conteneur :
    kubectl exec -it deployment/campus-backend -- sh
    

Depuis ce shell, vérifiez ce que voit l'application :

# La configuration reçue (variables injectées par le ConfigMap et le Secret)
env | grep SPRING

# Le réseau vu du pod : le nom du Service postgres se résout
getent hosts postgres

# L'API répond de l'intérieur du pod
curl -s http://localhost:8080/actuator/health

exit
L'image du backend ne contient pas nslookup : getent hosts interroge le même DNS. Remarquez aussi que SPRING_DATASOURCE_PASSWORD s'affiche en clair : toute personne autorisée à faire exec lit les Secrets du conteneur (le Lab 07 restreint ces droits avec le RBAC).

⚠️ exec sert à observer, pas à corriger. Toute modification faite dans le conteneur disparaît au prochain redémarrage du pod : on corrige le manifest, jamais le conteneur en direct. Si l'image ne contient pas de shell (image distroless), kubectl debug ajoute un conteneur outillé au pod.


Dépanner avec méthode : du général au détail

Face à un incident, suivez toujours le même ordre :

Étape Commande Ce que vous cherchez
1. Voir kubectl get pods -o wide STATUS, RESTARTS, NODE
2. Comprendre kubectl describe pod <pod> Les Events : placement, image, Last State
3. Lire kubectl logs <pod> --previous L'erreur de l'application
4. Entrer kubectl exec -it <pod> -- sh La configuration et le réseau vus du pod
5. Élargir kubectl describe node, kubectl top Le nœud, les ressources
  1. Incident A, provoquer un CrashLoopBackOff. Lancez un conteneur qui s'arrête en erreur 3 secondes après son démarrage, puis observez-le (Ctrl + C pour quitter) :

    kubectl run crash-app --image=busybox:1.36 --restart=Always -- sh -c "echo Initialisation du service... ; sleep 3 ; echo Erreur fatale code 42 ; exit 42"
    kubectl get pod crash-app -w
    
    Le pod passe de Running à Error, puis à CrashLoopBackOff, et la colonne RESTARTS augmente. Le délai entre deux tentatives double à chaque échec (10 s, 20 s, 40 s… jusqu'à 5 minutes).

  2. Incident A, diagnostiquer. Comprenez, puis lisez :

    kubectl describe pod crash-app | grep -A 4 "Last State"
    kubectl logs crash-app --previous
    kubectl delete pod crash-app
    
    Last State: Terminated indique Exit Code: 42 : un code différent de 0 signifie que le processus s'est arrêté sur une erreur. logs --previous affiche le message du conteneur qui a planté : Erreur fatale code 42.

  3. Incident B, provoquer un OOMKilled. Lancez un conteneur limité à 50 Mi de mémoire, qui tente d'en allouer 150 Mo :

    kubectl apply -f - << 'EOF'
    apiVersion: v1
    kind: Pod
    metadata:
      name: oom-victim
    spec:
      containers:
      - name: mem-eater
        image: polinux/stress:1.0.4
        resources:
          requests:
            memory: "32Mi"
          limits:
            memory: "50Mi"
        command: ["stress"]
        args: ["--vm", "1", "--vm-bytes", "150M", "--vm-hang", "1"]
    EOF
    kubectl get pod oom-victim -w
    
    Le statut passe à OOMKilled, puis à CrashLoopBackOff : le conteneur est relancé et retué à chaque tentative. Ctrl + C pour quitter.

  4. Incident B, diagnostiquer :

    kubectl describe pod oom-victim | grep -A 4 "Last State"
    kubectl delete pod oom-victim
    
    Reason: OOMKilled : le noyau Linux a tué le processus, qui dépassait sa limite limits.memory. La correction : augmenter la limite, ou réduire la consommation de l'application.

  5. Incident C, un Service sans réponse. Un collègue a créé un Service campus-api pour le backend. Créez-le, puis interrogez-le depuis un pod de test :

    kubectl create service clusterip campus-api --tcp=8080:8080
    kubectl run test-api --image=curlimages/curl:8.11.1 --rm -i --restart=Never -- curl -s -m 5 http://campus-api:8080/actuator/health
    
    Aucune réponse : kubectl affiche pod campus-dev/test-api terminated (Error) (curl n'a pas pu se connecter). Le Service existe pourtant, et son nom se résout : il ne transmet simplement rien.

  6. Incident C, diagnostiquer et corriger. Appliquez le réflexe « Service muet ? get endpoints », puis comparez le sélecteur du Service et les labels des pods :

    kubectl get endpoints campus-api
    kubectl describe service campus-api | grep Selector
    kubectl get pods -l app=campus-backend --show-labels
    
    La liste des Endpoints est vide : kubectl create service a mis le sélecteur app=campus-api, alors que les pods portent app=campus-backend. Corrigez le sélecteur, puis vérifiez :
    kubectl set selector service campus-api app=campus-backend
    kubectl get endpoints campus-api
    kubectl run test-api --image=curlimages/curl:8.11.1 --rm -i --restart=Never -- curl -s -m 5 http://campus-api:8080/actuator/health
    kubectl delete service campus-api
    
    Les Endpoints listent maintenant les pods backend, et l'API répond {"status":"UP"…}.


Surveiller la santé des nœuds : Node Problem Detector

Le kubelet ne signale que ses propres problèmes : mémoire, disque plein, réseau. Une panne du noyau, un système de fichiers passé en lecture seule ou un runtime figé passent inaperçus : le nœud reste Ready et continue de recevoir des pods. Node Problem Detector (NPD), un DaemonSet (un pod par nœud), lit les journaux du noyau et rend ces pannes visibles dans Kubernetes, sous forme de conditions du nœud et d'événements. NPD détecte et signale ; c'est l'administrateur (ou un outil) qui isole le nœud.

  1. Déployer NPD et lire les conditions d'un nœud :

    kubectl apply -f npd/npd.yaml
    kubectl rollout status daemonset/node-problem-detector -n kube-system
    kubectl get pods -n kube-system -l app=node-problem-detector -o wide
    kubectl describe node k8s-worker-1 | grep -A 12 "Conditions:"
    
    Un pod NPD par worker (il ne tourne pas sur k8s-control, protégé par sa taint). Les conditions KernelDeadlock et ReadonlyFilesystem, ajoutées par NPD, sont à False. Si elles n'apparaissent pas encore, relancez la dernière commande quelques secondes plus tard.

  2. Simuler une panne du noyau sur k8s-worker-1, puis isoler le nœud. Un pod privilégié, placé directement sur ce nœud, écrit dans le journal du noyau le message d'erreur que surveille NPD :

    kubectl apply -f - << 'EOF'
    apiVersion: v1
    kind: Pod
    metadata:
      name: inject-kernel-err
    spec:
      nodeName: k8s-worker-1
      restartPolicy: Never
      containers:
      - name: inject
        image: busybox:1.36
        securityContext:
          privileged: true
        command: ["sh", "-c", "echo '<3>kernel: BUG: unable to handle kernel NULL pointer dereference at 0000000000000000' > /dev/kmsg"]
    EOF
    
    Attendez une dizaine de secondes, puis constatez la détection :
    kubectl describe node k8s-worker-1 | grep KernelDeadlock
    kubectl get events -A --field-selector reason=KernelDeadlock
    
    La condition KernelDeadlock est passée à True, et NPD a émis un événement. Isolez le nœud : cordon interdit tout nouveau pod, drain déplace ceux qui y tournent.
    kubectl delete pod inject-kernel-err
    kubectl cordon k8s-worker-1
    kubectl drain k8s-worker-1 --ignore-daemonsets --delete-emptydir-data
    kubectl get nodes
    kubectl get pods -o wide
    
    Le nœud est Ready,SchedulingDisabled, et les pods backend et frontend sont recréés sur k8s-worker-2. Si campus-postgres tournait sur k8s-worker-1, il reste Pending : son volume local-path est sur le disque de ce nœud (voir le Lab 05).

    ⚠️ Un pod privilégié a tous les pouvoirs sur le nœud : il n'est utilisé ici que pour la simulation. Le Lab 07 apprend à l'interdire.

  3. Remettre le nœud en service :

    kubectl uncordon k8s-worker-1
    kubectl get nodes
    kubectl get pods -o wide
    
    Si campus-postgres était resté Pending, il redémarre sur k8s-worker-1 avec ses données ; les pods backend, qui redémarraient en boucle faute de base, reviennent à Running dans la minute. La condition KernelDeadlock=True reste affichée quelques minutes : NPD ne la retire qu'à son redémarrage, une fois l'erreur sortie de sa fenêtre d'analyse (5 minutes).


Mesurer et centraliser : Metrics Server, Prometheus, Loki, Grafana

Outil Rôle
Metrics Server La consommation instantanée, en mémoire, sans historique : alimente kubectl top (et l'autoscaling). Pas installé par défaut avec kubeadm.
Prometheus Collecte et stocke les métriques (nœuds, pods, kubelet) : historique, alertes.
Fluent Bit + Loki Fluent Bit (un pod par nœud) lit les logs de tous les conteneurs ; Loki les stocke et les indexe.
Grafana Tableaux de bord et recherche dans les métriques (Prometheus) et les logs (Loki).
  1. Déployer la pile de supervision (namespace monitoring, sauf Metrics Server qui s'installe dans kube-system), puis mesurer la consommation :

    kubectl apply -f monitoring/
    kubectl get pods -n monitoring
    kubectl get pods -n kube-system -l k8s-app=metrics-server
    
    Quand tous les pods sont Running (30 à 60 secondes), attendez encore une minute la première mesure, puis :
    kubectl top nodes
    kubectl top pods
    
    CPU en millicores (m), mémoire en Mi. top montre la consommation réelle : c'est elle qu'on compare aux requests déclarées dans les manifests (Lab 07). Si la commande répond metrics not available yet, patientez encore un peu.

  2. Produire des logs à centraliser. Fluent Bit ne collecte que les lignes écrites après son démarrage. Redémarrez le backend pour en produire :

    kubectl rollout restart deployment/campus-backend
    kubectl rollout status deployment/campus-backend
    

  3. Explorer logs et métriques dans Grafana. Ouvrez http://<IP_PUBLIQUE_WORKER>:30300 (Service NodePort de Grafana) et connectez-vous avec admin / admin2026. Les sources Prometheus et Loki sont déjà configurées. Dans le menu Explore :

    • source Loki, requête {app="campus-backend"} : les logs Spring Boot de tous les pods backend, même ceux qui n'existent plus ;
    • source Prometheus, requête sum(container_memory_working_set_bytes{namespace="campus-dev", container!=""}) by (pod) : la courbe mémoire de chaque pod.

    Si le port 30300 est filtré par votre réseau d'entreprise (Option A) : kubectl port-forward svc/grafana 3000:3000 -n monitoring, puis http://localhost:3000.

☁️ Et dans le cloud ? Sur un cluster managé, on n'installe généralement pas cette pile : le fournisseur la propose en service géré. Chez Google, ce service s'appelait StackDriver, aujourd'hui Google Cloud Observability (Cloud Logging, Cloud Monitoring) ; chez AWS, CloudWatch Container Insights ; chez Azure, Azure Monitor. Les concepts sont les mêmes : collecte des logs sur chaque nœud, métriques du kubelet, tableaux de bord.


Critères de Validation (Checklist)

  • Vous savez lire les logs d'un pod en direct, ceux de tous les pods d'une étiquette (--prefix) et ceux du conteneur précédent (--previous).
  • Vous avez vérifié avec kubectl exec la configuration (env) et le réseau (getent hosts postgres) vus du pod backend.
  • Vous avez diagnostiqué CrashLoopBackOff (Exit Code), OOMKilled (Reason) et un Service sans réponse (Endpoints vides), en suivant la méthode get → describe → logs → exec → nœud.
  • Vous avez déployé Node Problem Detector, constaté la condition KernelDeadlock=True et isolé le nœud avec cordon et drain, puis l'avez remis en service.
  • kubectl top nodes et kubectl top pods affichent la consommation (Metrics Server).
  • Vous avez retrouvé les logs du backend (Loki) et sa consommation mémoire (Prometheus) dans Grafana.
  • Vous savez citer l'équivalent managé de cette pile chez Google (StackDriver, aujourd'hui Google Cloud Observability), AWS et Azure.