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 Intermédiaire : Deployments, Services et Volumes01 - Deployments : scaling et mise à jour d'application

Détails

  • 30 minutes
  • Intermédiaire

Objectifs

  • Créer un Deployment et comprendre sa relation avec les ReplicaSets
  • Scaler horizontalement une application
  • Mettre à jour une image Docker via kubectl set image
  • Effectuer un rollback vers une version précédente
Module Kubernetes Intermédiaire : Deployments, Services et Volumes

Exercice 01 : Deployments - scaling et mise à jour d'application

🎯 Objectifs

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

  • ✅ Créer un Deployment avec plusieurs réplicas
  • ✅ Observer la relation Deployment → ReplicaSet → Pods
  • ✅ Scaler une application manuellement avec kubectl scale
  • ✅ Mettre à jour l'image d'un Deployment et observer le rolling update
  • ✅ Annuler une mise à jour problématique avec kubectl rollout undo

Durée estimée : 30 minutes

Difficulté : ⭐⭐☆☆☆ (Intermédiaire)

Prérequis : Module Kubernetes Débutant complété, minikube démarré


📖 Contexte

Un Pod seul ne se redémarre pas si le nœud tombe. Un Deployment est le contrôleur qui garantit qu'un nombre cible de pods identiques tourne en permanence. Il gère également les mises à jour : au lieu de couper tous les pods d'un coup (downtime), il remplace les pods progressivement (rolling update), garantissant une disponibilité continue.


📋 Énoncé

Déployez une application web, scalez-la, mettez-la à jour puis effectuez un rollback.


🧭 Déroulement de l'exercice

Tâche 1 : Créer le Deployment

bash
# Vérifier que minikube est démarré
minikube status

# Créer le namespace de travail
kubectl create namespace intermediaire
bash
cat > nginx-deployment.yaml << 'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-app
  namespace: intermediaire
  labels:
    app: nginx-app
    version: "1.0"
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx-app
  template:
    metadata:
      labels:
        app: nginx-app
        version: "1.0"
    spec:
      containers:
        - name: nginx
          image: nginx:1.26
          ports:
            - containerPort: 80
          resources:
            requests:
              cpu: 50m
              memory: 64Mi
            limits:
              cpu: 200m
              memory: 128Mi
EOF

kubectl apply -f nginx-deployment.yaml

Vérification :

bash
# Le Deployment doit être "Available: 2/2"
kubectl get deployment nginx-app -n intermediaire

# Observer la hiérarchie : Deployment → ReplicaSet → Pods
kubectl get all -n intermediaire

# Détail du Deployment
kubectl describe deployment nginx-app -n intermediaire

Tâche 2 : Observer la hiérarchie

bash
# Lister les ReplicaSets (créés automatiquement par le Deployment)
kubectl get replicasets -n intermediaire

# Lister les Pods avec leurs labels
kubectl get pods -n intermediaire --show-labels

# Voir les événements (scheduler, pulling de l'image, start)
kubectl get events -n intermediaire --sort-by='.lastTimestamp'

Indice : Le ReplicaSet a un nom comme nginx-app-7d8f5c9b4. C'est le Deployment qui crée le ReplicaSet, et le ReplicaSet qui crée les Pods. Lors d'une mise à jour, un nouveau ReplicaSet est créé et l'ancien est conservé (pour permettre le rollback).


Tâche 3 : Scaler l'application

bash
# Passer de 2 à 4 réplicas
kubectl scale deployment nginx-app --replicas=4 -n intermediaire

# Observer en temps réel
kubectl get pods -n intermediaire -w
# Ctrl+C pour arrêter

# Vérifier que 4 pods tournent
kubectl get deployment nginx-app -n intermediaire

Testez la résilience : supprimez un pod manuellement et observez qu'il est recréé.

bash
# Obtenir le nom d'un pod
POD=$(kubectl get pods -n intermediaire -l app=nginx-app -o jsonpath='{.items[0].metadata.name}')
echo "Pod à supprimer : $POD"

# Supprimer ce pod
kubectl delete pod "$POD" -n intermediaire

# Le Deployment recrée immédiatement un nouveau pod
kubectl get pods -n intermediaire -w

Vérification : Après suppression, un nouveau pod apparaît et le total revient à 4.


Tâche 4 : Mettre à jour l'image

bash
# Voir l'image actuelle
kubectl get deployment nginx-app -n intermediaire -o jsonpath='{.spec.template.spec.containers[0].image}'

# Mettre à jour vers nginx:1.27
kubectl set image deployment/nginx-app nginx=nginx:1.27 -n intermediaire

# Observer le rolling update en temps réel
kubectl rollout status deployment/nginx-app -n intermediaire

# Voir les ReplicaSets : l'ancien et le nouveau coexistent pendant la transition
kubectl get replicasets -n intermediaire

Indice : Par défaut, la stratégie de rolling update remplace les pods 1 par 1 (maxSurge: 25%, maxUnavailable: 25%). Avec 4 réplicas, Kubernetes crée 1 nouveau pod, attend qu'il soit Ready, puis supprime 1 ancien pod, et ainsi de suite.

Vérification : kubectl rollout status affiche "successfully rolled out".


Tâche 5 : Rollback

bash
# Voir l'historique des déploiements
kubectl rollout history deployment/nginx-app -n intermediaire

# Simuler un problème : déployer une image inexistante
kubectl set image deployment/nginx-app nginx=nginx:99.99.99 -n intermediaire

# Observer l'échec (ImagePullBackOff)
kubectl get pods -n intermediaire -w
kubectl describe pod -l app=nginx-app -n intermediaire | grep -A5 "Events"

# Rollback vers la version précédente
kubectl rollout undo deployment/nginx-app -n intermediaire

# Vérifier que les pods sont de nouveau Running
kubectl get pods -n intermediaire
kubectl get deployment nginx-app -n intermediaire

✅ Vérification du résultat

  • kubectl get deployment nginx-app -n intermediaire affiche READY 4/4
  • La suppression d'un pod est suivie d'une recréation automatique
  • kubectl rollout status confirme la mise à jour vers nginx:1.27
  • Le rollback ramène l'image à nginx:1.26

💡 À retenir

Un Deployment est la ressource standard pour déployer des applications sans état (stateless) dans Kubernetes. La hiérarchie est :

Deployment (contrôle) → ReplicaSet (maintient les réplicas) → Pods (conteneurs)

3 commandes de mise à jour indispensables :

bash
kubectl set image deployment/mon-app container=image:tag
kubectl rollout status deployment/mon-app  # Surveiller
kubectl rollout undo deployment/mon-app    # Annuler si problème

✨ Solution Complète

bash
# Création et scaling
kubectl apply -f nginx-deployment.yaml
kubectl scale deployment nginx-app --replicas=4 -n intermediaire

# Mise à jour
kubectl set image deployment/nginx-app nginx=nginx:1.27 -n intermediaire
kubectl rollout status deployment/nginx-app -n intermediaire

# Rollback
kubectl rollout undo deployment/nginx-app -n intermediaire
Retour au module

Sur cette page

  • 🎯 Objectifs
  • 📖 Contexte
  • 📋 Énoncé
  • 🧭 Déroulement de l'exercice
  • Tâche 1 : Créer le Deployment
  • Tâche 2 : Observer la hiérarchie
  • Tâche 3 : Scaler l'application
  • Tâche 4 : Mettre à jour l'image
  • Tâche 5 : Rollback
  • ✅ Vérification du résultat
  • 💡 À retenir
  • ✨ Solution Complète