Comment effectuer des déploiements Canary sur Kubernetes

Présentation

Tester une nouvelle fonctionnalité ou une mise à niveau en production est un processus stressant. Vous souhaitez déployer des modifications fréquemment, mais sans affecter l'expérience utilisateur. Pour minimiser les temps d'arrêt pendant cette phase, configurez des déploiements Canary pour rationaliser la transition.

Vous pouvez utiliser les déploiements Canary sur n'importe quelle infrastructure. C'est donc l'une des stratégies de déploiement de Kubernetes.

Découvrez ce que sont les déploiements Canary, comment ils fonctionnent et comment effectuer un déploiement Canary sur Kubernetes.

Prérequis

Accès à une ligne de commande/terminal
Docker installé sur le système
Kubernetes ou Minikube
Un outil de ligne de commande kubectl entièrement configuré sur votre machine locale

Qu'est-ce qu'un déploiement Canary ?

Un déploiement Canary est une version mise à niveau d'un déploiement existant, avec tout le code d'application et les dépendances requis. Il est utilisé pour tester de nouvelles fonctionnalités et mises à niveau afin de voir comment elles gèrent l'environnement de production.

Lorsque vous ajoutez le déploiement Canary à un cluster Kubernetes, il est géré par un service via des sélecteurs et libellés . Le service achemine le trafic vers les pods qui ont l'étiquette spécifiée. Cela vous permet d'ajouter ou de supprimer facilement des déploiements.

La quantité de trafic que le canari reçoit correspond au nombre de pods qu'il fait tourner. Dans la plupart des cas, vous commencez par acheminer un plus petit pourcentage de trafic vers le canari et augmentez le nombre au fil du temps.

Une fois les deux déploiements configurés, vous surveillez le comportement Canary pour voir si des problèmes surviennent. Une fois que vous êtes satisfait de la façon dont il gère les demandes, vous pouvez mettre à niveau tous les déploiements vers la dernière version.

Configuration du déploiement Canary sur Kubernetes

Les étapes ci-dessous vous montrent comment configurer un déploiement Canary. Pour cet article, nous avons créé un cluster Kubernetes simple de pods Nginx avec une page HTML statique de base de deux phrases. Les versions du déploiement varient en fonction du contenu qu'elles affichent sur la page Web.

Le processus de configuration de votre déploiement Canary diffère selon l'application que vous exécutez.

Étape 1 :Extraire l'image Docker

La première étape consiste à extraire ou à créer l'image des conteneurs de votre cluster Kubernetes. Puisque nous construisons des conteneurs Nginx dans cet exemple, nous utilisons l'image Nginx disponible sur Docker Hub.

1. Téléchargez l'image avec :

docker pull nginx

2. Vérifiez que vous l'avez en listant toutes les images locales :

docker image ls

Étape 2 :Créer le déploiement Kubernetes

1. Créez la définition de déploiement à l'aide d'un fichier yaml. Utilisez un éditeur de texte de votre choix et donnez un nom au fichier. Nous allons nommer le fichier nginx-deployment.yaml et créez-le avec Nano :

nano nginx-deployment.yaml

2. Ajoutez le contenu suivant au fichier :

apiVersion: apps/v1
kind: Deployment
metadata:
 name: nginx
spec:
 selector:
  matchLabels:
   app: nginx
 replicas: 3
 template:
  metadata:
   labels:
    app: nginx
    version: "1.0"
  spec:
   containers:
    - name: nginx
      image: nginx:alpine
      resources:
      limits:
       memory: "128Mi"
       cpu: "50m"
      ports:
      - containerPort: 80
      volumeMounts:
      - mountPath: /usr/share/nginx/html
        name: index.html
      volumes:
      - name: index.html
        hostPath:
          path: /Users/sofija/Documents/nginx/v1

Nous avons créé 3 répliques de pods Nginx pour le cluster Kubernetes. Tous les pods portent le libellé version: "1.0 ". De plus, ils ont un volume hôte contenant le index.html monté sur le conteneur. L'exemple de fichier HTML composé de :

<html>
<h1>Hello World!</h1>
<p>This is version 1</p>
</html>

3. Enregistrez et quittez le fichier.

4. Créez le déploiement en exécutant :

k apply -f nginx-deployment.yaml

5. Vérifiez si vous avez réussi à déployer les pods avec :

k get pods -o wide

La sortie doit afficher trois pods Nginx en cours d'exécution .

Étape 3 :Créer le service

L'étape suivante consiste à créer une définition de service pour le cluster Kubernetes. Le service acheminera les demandes vers les pods spécifiés.

1. Créez un nouveau yaml fichier avec :

nano nginx-deployment.service.yaml

2. Ajoutez ensuite le contenu suivant :

apiVersion: v1
kind: Service
metadata:
 name: nginx-service
spec:
 type: LoadBalancer
selector:
 app: nginx
 version: "1.0"
ports:
- port: 8888
  targetPort: 80

Le fichier yaml spécifie le type de service – LoadBalancer . Il demande au service d'équilibrer les charges de travail entre les pods avec les étiquettes app: nginx et version: "1.0" . Le pod doit avoir les deux étiquettes pour faire partie du service.

3. Enregistrez et quittez le fichier de service.

4. Maintenant, créez le service :

kubectl apply -f nginx-deployment.service.yaml

Étape 4 :Vérifier la première version du cluster

Pour vérifier que le service est en cours d'exécution, ouvrez un navigateur Web et accédez à l'adresse IP et au numéro de port définis dans le fichier de service.

Pour voir l'adresse IP externe du service, utilisez la commande :

kubectl get service

Si vous exécutez Kubernetes localement , utilisez localhost comme IP.

Étant donné que l'exemple de cluster que nous avons créé s'exécute localement sur le port 8888, l'URL est :

http://localhost:8888

Le navigateur doit afficher un Hello World message de la version 1 .

Étape 5 :Créer un déploiement Canary

Avec la version 1 de l'application en place, vous déployez la version 2 , le déploiement canari.

1. Commencez par créer le yaml fichier pour le déploiement Canary. Exécutez la commande :

nano nginx-canary-deployment.yaml

2. Ajoutez le contenu suivant au fichier :

apiVersion: apps/v1
kind: Deployment
metadata:
 name: nginx-canary-deployment
spec:
 selector:
  matchLabels:
   app: nginx
 replicas: 3
 template:
  metadata:
   labels:
    app: nginx
    version: "2.0"
  spec:
   containers:
    - name: nginx
      image: nginx:alpine
      resources:
      limits:
       memory: "128Mi"
       cpu: "50m"
      ports:
      - containerPort: 80
      volumeMounts:
      - mountPath: /usr/share/nginx/html
        name: index.html
      volumes:
      - name: index.html
        hostPath:
          path: /Users/sofija/Documents/nginx/v2

Le contenu du fichier de déploiement Canary diffère par trois paramètres importants :

Le nom dans les métadonnées est nginx-canary-deployment .
Il porte le libellé version: “2.0” .
Il est lié à un fichier html index.html qui se compose de :

<html>
<h1>Hello World!</h1>
<p>This is version 2</p>
</html>

3. Enregistrez et quittez le fichier.

4. Créez le déploiement Canary avec la commande :

k apply -f nginx-canary-deployment.yaml

5. Vérifiez que vous avez correctement déployé les trois pods supplémentaires :

k get pods -o wide

La sortie doit afficher les pods de déploiement Nginx Canary , ainsi que les pods Nginx d'origine .

Étape 6 :Exécuter le déploiement Canary

Ouvrez un navigateur Web et accédez à la même adresse IP qu'à l'étape 4. Vous remarquerez qu'il n'y a aucun changement sur la page Web. En effet, le fichier de service est configuré pour équilibrer la charge uniquement des pods avec l'étiquette version: "1.0" .

Pour tester les pods mis à jour, vous devez modifier le fichier de service et rediriger une partie du trafic vers la version: “2.0” .

1. Pour ce faire, ouvrez le yaml fichier avec :

nano nginx-deployment.service.yaml

2. Recherchez et supprimez la ligne version: "1.0" . Le fichier doit inclure les éléments suivants :

apiVersion: v1
kind: Service
metadata:
 name: nginx-service
spec:
 type: LoadBalancer
selector:
 app: nginx
ports:
- port: 8888
  targetPort: 80

3. Enregistrez les modifications et quittez le fichier.

4. Créez le service mis à jour avec la commande :

k apply -f nginx-deployment.service.yml

5. Le trafic est désormais réparti entre les pods version 1 et version 2. Si vous actualisez la page Web plusieurs fois, vous voyez des résultats différents selon l'endroit où le service redirige votre demande.

Étape 7 :Surveillez le comportement des canaris

Avec les deux déploiements en cours d'exécution, surveillez le comportement du nouveau déploiement. En fonction des résultats, vous pouvez annuler le déploiement ou effectuer une mise à niveau vers la version la plus récente.

Annuler le déploiement de Canary

Si vous remarquez que Canary ne fonctionne pas comme prévu, vous pouvez annuler le déploiement et supprimer les pods mis à niveau avec :

kubectl delete deployment.apps/nginx-canary-deployment

Le service continue d'équilibrer la charge du trafic vers les pods initiaux (version 1).

Déployer le déploiement mis à niveau

Si vous concluez que le déploiement Canary fonctionne comme prévu, vous pouvez acheminer tout le trafic entrant vers la version mise à niveau. Il existe trois façons de procéder :

1. Mettez à niveau la première version en modifiant l'image Docker et en créant un nouveau déploiement. Ensuite, supprimez les canaris avec :

kubectl delete deployment.apps/nginx-canary-deployment

2. Vous pouvez conserver les pods mis à niveau et supprimer ceux avec la version 1 étiquette :

kubectl delete deployment.apps/nginx

3. Alternativement, vous pouvez même modifier le service.yaml fichier et ajoutez la version spécificateur au selector étiqueter. Cela indique à l'équilibreur de charge de n'acheminer le trafic que vers la version 2 gousses.