Mettre à jour et effectuer un rollback d'applications

Introduction

Dans ce laboratoire, vous apprendrez à mettre à jour et à annuler les mises à jour d'applications déployées sur un cluster Kubernetes. Vous commencerez par configurer un cluster Kubernetes local en utilisant Minikube, puis déployerez une application NGINX exemple. Ensuite, vous mettez à jour l'image de l'application et vérifiez que la mise à jour a réussi. Pour simuler des échecs de mise à jour, vous diagnostiquerez les problèmes, puis annulerez la mise à jour pour revenir à une version stable. Enfin, vous ajusterez la stratégie de mise à jour progressive dans le fichier YAML de déploiement.

Démarrer le cluster Kubernetes

Dans cette étape, vous apprendrez à démarrer et à vérifier un cluster Kubernetes local en utilisant Minikube. C'est une étape cruciale pour configurer votre environnement de développement Kubernetes.

Tout d'abord, assurez-vous d'être dans le répertoire du projet :

cd ~/project

Démarrez le cluster Minikube :

minikube start

Exemple de sortie :

😄  minikube v1.29.0 on Ubuntu 22.04
✨  Automatically selected the docker driver
📌  Using Docker driver with root permissions
🔥  Creating kubernetes in kubernetes cluster
🔄  Restarting existing kubernetes cluster
🐳  Preparing Kubernetes v1.26.1 on Docker 20.10.23...
🚀  Launching Kubernetes...
🌟  Enabling addons: storage-provisioner, default-storageclass
🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace

Vérifiez l'état du cluster :

minikube status

Exemple de sortie :

minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured

Vérifiez les nœuds du cluster :

kubectl get nodes

Exemple de sortie :

NAME       STATUS   ROLES           AGE   VERSION
minikube   Ready    control-plane   1m    v1.26.1

Points clés de cette étape :

minikube start crée un cluster Kubernetes local à un seul nœud
Le cluster utilise Docker comme pilote (driver) par défaut
Kubernetes v1.26.1 est automatiquement configuré
minikube status et kubectl get nodes confirment la disponibilité du cluster

Déployer une application exemple

Dans cette étape, vous apprendrez à créer et à déployer une application web simple en utilisant un déploiement (Deployment) Kubernetes. Nous utiliserons une image NGINX comme application exemple pour démontrer le processus de déploiement.

Tout d'abord, accédez au répertoire du projet :

cd ~/project
mkdir -p k8s-manifests
cd k8s-manifests

Créez un nouveau manifeste de déploiement pour une application web :

nano nginx-deployment.yaml

Ajoutez le contenu suivant au fichier :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
  labels:
    app: web
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: nginx
          image: nginx:1.23.3-alpine
          ports:
            - containerPort: 80

Enregistrez le fichier et quittez l'éditeur nano.

Déployez l'application en utilisant kubectl :

kubectl apply -f nginx-deployment.yaml

Exemple de sortie :

deployment.apps/web-app created

Vérifiez le déploiement :

kubectl get deployments

Exemple de sortie :

NAME      READY   UP-TO-DATE   AVAILABLE   AGE
web-app   3/3     3            3           30s

Vérifiez les pods créés :

kubectl get pods -l app=web

Exemple de sortie :

NAME                      READY   STATUS    RESTARTS   AGE
web-app-xxx-yyy           1/1     Running   0          45s
web-app-xxx-zzz           1/1     Running   0          45s
web-app-xxx-www           1/1     Running   0          45s

Points clés de ce déploiement :

Nous avons créé un déploiement (Deployment) avec 3 replicas d'un serveur web NGINX
Nous avons utilisé une version spécifique et stable de NGINX (1.23.3-alpine)
Nous avons exposé le port 80 du conteneur
Nous avons utilisé des étiquettes (labels) pour identifier et gérer les pods

Mettre à jour l'image de l'application dans le fichier YAML de déploiement

Dans cette étape, vous apprendrez à mettre à jour l'image de conteneur dans un déploiement (Deployment) Kubernetes, simulant un scénario de mise à niveau d'application dans le monde réel.

Tout d'abord, assurez-vous d'être dans le bon répertoire :

cd ~/project/k8s-manifests

Ouvrez le manifeste de déploiement existant :

nano nginx-deployment.yaml

Mettez à jour l'image de nginx:1.23.3-alpine vers une version plus récente :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
  labels:
    app: web
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: nginx
          image: nginx:1.24.0-alpine
          ports:
            - containerPort: 80

Appliquez le déploiement mis à jour :

kubectl apply -f nginx-deployment.yaml

Exemple de sortie :

deployment.apps/web-app configured

Suivez le processus de mise à jour du déploiement :

kubectl rollout status deployment web-app

Exemple de sortie :

Waiting for deployment "web-app" to roll out...
Waiting for deployment spec update to be applied...
Waiting for available replicas to reach desired number...
deployment "web-app" successfully rolled out

Vérifiez la nouvelle version de l'image :

kubectl get pods -l app=web -o jsonpath='{.items[*].spec.containers[0].image}'

Exemple de sortie :

nginx:1.24.0-alpine nginx:1.24.0-alpine nginx:1.24.0-alpine

Points clés concernant les mises à jour d'image :

Utilisez kubectl apply pour mettre à jour les déploiements
Kubernetes effectue une mise à jour progressive (rolling update) par défaut
Les pods sont remplacés progressivement pour maintenir la disponibilité de l'application
Le processus de mise à jour garantit un déploiement sans temps d'arrêt

Vérifier la mise à jour réussie

Dans cette étape, vous apprendrez à vérifier que la mise à jour de votre déploiement Kubernetes s'est bien déroulée en examinant les versions des pods, leur statut et d'autres détails du déploiement.

Tout d'abord, liste les pods avec des informations détaillées :

kubectl get pods -l app=web -o wide

Exemple de sortie :

NAME                      READY   STATUS    RESTARTS   AGE   IP           NODE       NOMINATED NODE   READINESS GATES
web-app-xxx-yyy           1/1     Running   0          3m    10.244.0.5   minikube   <none>           <none>
web-app-xxx-zzz           1/1     Running   0          3m    10.244.0.6   minikube   <none>           <none>
web-app-xxx-www           1/1     Running   0          3m    10.244.0.7   minikube   <none>           <none>

Vérifiez les versions spécifiques des images des pods :

kubectl get pods -l app=web -o jsonpath='{range.items[*]}{.metadata.name}{"\t"}{.spec.containers[0].image}{"\n"}{end}'

Exemple de sortie :

web-app-xxx-yyy    nginx:1.24.0-alpine
web-app-xxx-zzz    nginx:1.24.0-alpine
web-app-xxx-www    nginx:1.24.0-alpine

Décrivons le déploiement pour obtenir des informations plus détaillées :

kubectl describe deployment web-app

Exemple de sortie :

Name:                   web-app
Namespace:              default
CreationTimestamp:      [current timestamp]
Labels:                 app=web
Annotations:            deployment.kubernetes.io/revision: 2
Replicas:               3 desired | 3 updated | 3 total | 3 available | 0 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Pod Template:
  Labels:  app=web
  Containers:
   nginx:
    Image:        nginx:1.24.0-alpine
    Port:         80/TCP
    Host Port:    0/TCP
    Environment:  <none>
    Mounts:       <none>
Conditions:
  Type           Status  Reason
  ----           ------  ------
  Available      True    MinimumReplicasAvailable
  Progressing    True    NewReplicaSetAvailable

Vérifiez l'historique des déploiements :

kubectl rollout history deployment web-app

Exemple de sortie :

REVISION  CHANGE-CAUSE
1         <none>
2         <none>

Points clés de la vérification :

Tous les pods exécutent la nouvelle version de l'image.
Le déploiement dispose de 3 replicas disponibles.
La stratégie de déploiement garantit des mises à jour sans temps d'arrêt.
La révision du déploiement a été incrémentée.

Simuler et diagnostiquer les échecs de mise à jour

Dans cette étape, vous apprendrez à diagnostiquer les éventuels échecs de mise à jour de déploiement en simulant une mise à jour d'image problématique et en utilisant les outils de diagnostic de Kubernetes.

Tout d'abord, accédez au répertoire du projet :

cd ~/project/k8s-manifests

Créez un manifeste de déploiement avec une image invalide :

nano problematic-deployment.yaml

Ajoutez le contenu suivant :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: troubleshoot-app
  labels:
    app: troubleshoot
spec:
  replicas: 3
  selector:
    matchLabels:
      app: troubleshoot
  template:
    metadata:
      labels:
        app: troubleshoot
    spec:
      containers:
        - name: nginx
          image: nginx:non-existent-tag
          ports:
            - containerPort: 80

Appliquez le déploiement problématique :

kubectl apply -f problematic-deployment.yaml

Exemple de sortie :

deployment.apps/troubleshoot-app created

Vérifiez l'état du déploiement :

kubectl rollout status deployment troubleshoot-app

Exemple de sortie :

Waiting for deployment "troubleshoot-app" to roll out...

Appuyez sur Ctrl+C pour quitter l'affichage de l'état du déploiement.

Vérifiez les événements et l'état des pods :

kubectl get pods -l app=troubleshoot

Exemple de sortie :

NAME                              READY   STATUS             RESTARTS   AGE
troubleshoot-app-6b8986c555-gcjj9   0/1     ImagePullBackOff   0          2m56s
troubleshoot-app-6b8986c555-p29dp   0/1     ImagePullBackOff   0          2m56s
troubleshoot-app-6b8986c555-vpv5q   0/1     ImagePullBackOff   0          2m56s

Examinez les détails et les journaux des pods :

## Remplacez 'xxx-yyy' par le nom réel de votre pod
POD_NAME=$(kubectl get pods -l app=troubleshoot -o jsonpath='{.items[0].metadata.name}')
kubectl describe pod $POD_NAME
kubectl logs $POD_NAME

Vous verrez l'état du pod et les journaux indiquant l'échec du téléchargement de l'image.

Failed to pull image "nginx:non-existent-tag"

Résolvez le problème en corrigeant l'image :

nano problematic-deployment.yaml

Mettez à jour l'image avec une étiquette (tag) valide :

image: nginx:1.24.0-alpine

Réappliquez le déploiement corrigé :

kubectl apply -f problematic-deployment.yaml

Vérifiez à nouveau l'état des pods :

kubectl get pods -l app=troubleshoot

Exemple de sortie :

NAME                                READY   STATUS    RESTARTS   AGE
troubleshoot-app-5dc9b58d57-bvqbr   1/1     Running   0          5s
troubleshoot-app-5dc9b58d57-tdksb   1/1     Running   0          8s
troubleshoot-app-5dc9b58d57-xdq5n   1/1     Running   0          6s

Points clés pour le diagnostic des échecs :

Utilisez kubectl describe pour afficher les événements de déploiement et de pod.
Vérifiez l'état des pods pour détecter un ImagePullBackOff ou d'autres états d'erreur.
Examinez les journaux des pods pour obtenir des informations d'erreur détaillées.
Vérifiez la disponibilité de l'image et la validité de l'étiquette (tag).

Effectuer un rollback vers une version stable

Dans cette étape, vous apprendrez à effectuer un rollback (retour en arrière) d'un déploiement Kubernetes vers une version stable précédente en utilisant la commande kubectl rollout undo.

Tout d'abord, accédez au répertoire du projet :

cd ~/project/k8s-manifests

Vérifiez l'historique des déploiements de l'application web :

kubectl rollout history deployment web-app

Exemple de sortie :

REVISION  CHANGE-CAUSE
1         <none>
2         <none>

Vérifiez les détails du déploiement actuel :

kubectl describe deployment web-app | grep Image

Exemple de sortie :

    Image:        nginx:1.24.0-alpine

Effectuez le rollback vers la révision précédente :

kubectl rollout undo deployment web-app

Exemple de sortie :

deployment.apps/web-app rolled back

Vérifiez le rollback :

kubectl rollout status deployment web-app

Exemple de sortie :

Waiting for deployment "web-app" to roll out...
deployment "web-app" successfully rolled out

Vérifiez la version de l'image mise à jour :

kubectl get pods -l app=web -o jsonpath='{range.items[*]}{.metadata.name}{"\t"}{.spec.containers[0].image}{"\n"}{end}'

Exemple de sortie :

web-app-xxx-yyy    nginx:1.23.3-alpine
web-app-xxx-zzz    nginx:1.23.3-alpine
web-app-xxx-www    nginx:1.23.3-alpine

Confirmez l'historique des déploiements :

kubectl rollout history deployment web-app

Exemple de sortie :

REVISION  CHANGE-CAUSE
2         <none>
3         <none>

Points clés concernant le rollback :

La commande kubectl rollout undo permet de revenir à la révision de déploiement précédente.
Kubernetes conserve un historique des modifications de déploiement.
Le rollback est effectué sans temps d'arrêt.
Le rollback crée une nouvelle révision dans l'historique.

Ajuster la stratégie de mise à jour progressive dans le fichier YAML de déploiement

Dans cette étape, vous apprendrez à personnaliser la stratégie de mise à jour progressive (rolling update) dans un déploiement (Deployment) Kubernetes pour contrôler la manière dont les applications sont mises à jour et mises à l'échelle.

Tout d'abord, accédez au répertoire du projet :

cd ~/project/k8s-manifests

Créez un nouveau manifeste de déploiement avec une stratégie de mise à jour progressive personnalisée :

nano custom-rollout-deployment.yaml

Ajoutez le contenu suivant :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app-custom-rollout
  labels:
    app: web
spec:
  replicas: 5
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 2
      maxSurge: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: nginx
          image: nginx:1.24.0-alpine
          ports:
            - containerPort: 80

Appliquez le déploiement :

kubectl apply -f custom-rollout-deployment.yaml

Exemple de sortie :

deployment.apps/web-app-custom-rollout created

Vérifiez l'état du déploiement :

kubectl rollout status deployment web-app-custom-rollout

Exemple de sortie :

Waiting for deployment "web-app-custom-rollout" to roll out...
deployment "web-app-custom-rollout" successfully rolled out

Décrivons le déploiement pour confirmer la stratégie :

kubectl describe deployment web-app-custom-rollout

L'exemple de sortie inclura :

StrategyType:           RollingUpdate
RollingUpdateStrategy:  2 max unavailable, 3 max surge

Mettez à jour l'image pour déclencher une mise à jour progressive :

kubectl set image deployment/web-app-custom-rollout nginx=nginx:1.25.0-alpine

Surveillez le processus de mise à jour :

kubectl rollout status deployment web-app-custom-rollout

Points clés concernant la stratégie de mise à jour progressive :

maxUnavailable : Nombre maximum de pods qui peuvent être indisponibles pendant la mise à jour.
maxSurge : Nombre maximum de pods qui peuvent être créés au-dessus du nombre souhaité.
Aide à contrôler la vitesse de mise à jour et la disponibilité de l'application.
Permet d'ajuster finement le comportement du déploiement.

Résumé

Dans ce laboratoire, vous avez appris à démarrer et à vérifier un cluster Kubernetes local en utilisant Minikube, ce qui est une étape cruciale pour la configuration de votre environnement de développement Kubernetes. Vous avez également appris à créer et à déployer une application web simple en utilisant un déploiement (Deployment) Kubernetes, en utilisant une image NGINX comme application exemple. Le processus de déploiement a consisté à créer un fichier manifeste de déploiement et à l'appliquer au cluster.

Après avoir déployé la version initiale de l'application, vous avez appris à mettre à jour l'image de l'application dans le fichier YAML de déploiement, à vérifier la réussite de la mise à jour, à simuler et à diagnostiquer les échecs de mise à jour, à effectuer un rollback (retour en arrière) vers une version stable et à ajuster la stratégie de mise à jour progressive dans le fichier YAML de déploiement.