DevOpsFacile
AccueilParcours de formationCertificationsModulesCheat SheetÀ Propos
DevOpsFacile

Une plateforme d'apprentissage complète pour maîtriser les pratiques DevOps modernes, du débutant à l'expert.

contact@devopsfacile.fr

Formation

  • Parcours de formation
  • Modules

Informations

  • À Propos
  • Conditions d'utilisation
  • Confidentialité
  • Mentions légales

© 2026 DevOps Facile. Tous droits réservés.

Fait avec pour la communauté DevOps

ModulesKubernetes en production : Deployments, Ingress et Secrets04 - Configurer les probes et les resource limits

Détails

  • 25 minutes
  • Avancé

Objectifs

  • Configurer livenessProbe et readinessProbe
  • Définir les resource requests et limits
  • Observer le comportement OOMKilled
  • Monitorer la consommation avec kubectl top
Module Kubernetes en production : Deployments, Ingress et Secrets

Exercice 04 : Configurer les probes et les resource limits

🎯 Objectifs

À la fin de cet exercice, vous serez capable de :

  • ✅ Configurer livenessProbe (redémarrer si mort) et readinessProbe (trafic si prêt)
  • ✅ Utiliser httpGet, exec et tcpSocket comme mécanismes de probe
  • ✅ Définir les resources.requests et resources.limits
  • ✅ Observer et comprendre l'erreur OOMKilled

Durée estimée : 25 minutes

Difficulté : ⭐⭐⭐⭐☆ (Avancé)

Prérequis : minikube démarré avec metrics-server, maîtrise des Deployments


📖 Contexte

Sans probes, Kubernetes considère un pod comme opérationnel dès que le processus démarre - même si l'application n'est pas encore prête à répondre. Sans resource limits, un conteneur peut monopoliser toute la mémoire du noeud. Ces deux mécanismes sont indispensables en production.


📋 Énoncé

Vous allez configurer une application avec des probes HTTP et des limites de ressources, observer le redémarrage automatique quand la liveness probe échoue, et comprendre le comportement OOMKilled.

Résultat attendu :

  • Probes configurées avec des paramètres adaptés
  • Gestion correcte des ressources

🧭 Déroulement de l'exercice

Tâche 1 : Configurer une livenessProbe httpGet

Déployez un pod nginx avec une livenessProbe qui interroge GET / sur le port 80 toutes les 10 secondes.

Indice : livenessProbe.httpGet.path et .port, avec initialDelaySeconds: 5 pour laisser nginx démarrer.

Vérification : kubectl describe pod nginx-probe → section Liveness affiche la configuration.


Tâche 2 : Observer le redémarrage automatique

Modifiez la probe pour cibler un endpoint qui n'existe pas (/inexistant), appliquez, et observez les redémarrages.

Indice : kubectl get pods -w affiche le compteur RESTARTS augmenter.

Vérification : Après quelques secondes, RESTARTS passe à 1, 2, 3... Le pod entre en CrashLoopBackOff.


Tâche 3 : Configurer une readinessProbe avec exec

Configurez une readinessProbe de type exec qui vérifie l'existence d'un fichier /tmp/ready.

Indice : readinessProbe.exec.command: ["test", "-f", "/tmp/ready"]

Vérification : Sans le fichier, le pod est Running mais 0/1 READY. Créez /tmp/ready dans le pod → il passe à 1/1 READY.


Tâche 4 : Définir requests et limits

Ajoutez des ressources : requests.memory: 64Mi, requests.cpu: 100m et limits.memory: 128Mi, limits.cpu: 200m.

Indice : 100m = 100 millicores = 0.1 CPU. Mi = mebibytes.

Vérification : kubectl describe pod nginx-resources affiche les requests et limits dans la section Containers.


Tâche 5 : Observer OOMKilled

Déployez le pod memory-hog.yaml (fourni en solution) qui consomme plus de mémoire que sa limite.

Indice : kubectl get pods affichera OOMKilled dans la colonne STATUS puis le pod redémarrera.

Vérification : kubectl describe pod memory-hog → section Last State affiche OOMKilled.


🗂️ Mini-Projet : Deployment production-ready

yaml
# production-deploy.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: production-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: production-app
  template:
    metadata:
      labels:
        app: production-app
    spec:
      containers:
        - name: nginx
          image: nginx:1.25
          ports:
            - containerPort: 80
          resources:
            requests:
              memory: "64Mi"
              cpu: "100m"
            limits:
              memory: "128Mi"
              cpu: "200m"
          livenessProbe:
            httpGet:
              path: /
              port: 80
            initialDelaySeconds: 10
            periodSeconds: 15
            failureThreshold: 3
          readinessProbe:
            httpGet:
              path: /
              port: 80
            initialDelaySeconds: 5
            periodSeconds: 10
            successThreshold: 1

Checkpoints :

  • kubectl get pods affiche 2/2 READY pour les deux réplicas
  • kubectl describe pod <pod> affiche les probes et les resources configurées
  • kubectl top pods affiche la consommation CPU et mémoire (nécessite metrics-server)
  • Modifier la liveness vers /bad → les pods redémarrent, les anciens gardent le trafic
  • kubectl describe pod <pod-oomkilled> montre OOMKilled dans Last State

Retour au module

Sur cette page

  • 🎯 Objectifs
  • 📖 Contexte
  • 📋 Énoncé
  • 🧭 Déroulement de l'exercice
  • Tâche 1 : Configurer une livenessProbe httpGet
  • Tâche 2 : Observer le redémarrage automatique
  • Tâche 3 : Configurer une readinessProbe avec exec
  • Tâche 4 : Définir requests et limits
  • Tâche 5 : Observer OOMKilled
  • 🗂️ Mini-Projet : Deployment production-ready