Kubernetes deployment : tout savoir sur les déploiements Kubernetes

La création d’un déploiement Kubernetes réussi est essentielle pour une gestion efficace des applications de conteneurs. Dans ce tutoriel, vous aurez un aperçu des étapes de base et des meilleures pratiques pour concevoir un déploiement robuste dans un environnement Kubernetes.

Kubernetes deployment : définition

Un déploiement Kubernetes (en anglais Kubernetes deployment) est un concept essentiel au sein de la plateforme Kubernetes, qui simplifie le déploiement et la gestion des applications dans les conteneurs. Ce mécanisme de contrôle agit comme un intermédiaire entre la configuration et son exécution effective dans le cluster Kubernetes. Vous définissez l’état souhaité de vos applications, y compris les détails de la réplication, les images des conteneurs et les paramètres de configuration.

Le déploiement Kubernetes se charge ensuite du provisionnement automatisé, organise les conteneurs en pods Kubernetes et les distribue aux ressources disponibles dans le cluster. De plus, il permet les rolling updates (mises à jour continues) afin d’effectuer des mises à jour par étapes et de minimiser les temps d’arrêt. Les fonctions de mise à l’échelle automatique (autoscaling) garantissent un ajustement dynamique du nombre d’instances en cours d’exécution en fonction de la charge actuelle.

Conseil

Avec Managed Kubernetes de IONOS, vous profitez des avantages de l’orchestration de conteneurs sans avoir à vous soucier des tâches administratives fastidieuses comme la surveillance, les mises à jour et les routines de maintenance. Grâce au service de gestion gratuit de IONOS Cloud, vous augmentez votre productivité et économisez de précieuses ressources.

La création d’un déploiement Kubernetes peut se baser sur deux méthodes :

  • La méthode impérative
  • La méthode déclarative

Kubernetes deployment : créer un déploiement avec la méthode impérative

Avec la méthode impérative, vous spécifiez des commandes afin d’effectuer directement les actions souhaitées. Il peut s’agir de créer des ressources, comme des pods et des services, ou de mettre à jour des configurations. La méthode impérative est adaptée aux besoins situationnels ou expérimentaux.

La commande suivante crée un déploiement Kubernetes nommé nginx-deployment et le configure pour déployer un serveur Web Nginx dans un conteneur à partir de l’image officielle de Nginx sur le port 80.

$ kubectl create deployment nginx-deployment –image=nginx --port=80
shell

Même si l’approche impérative est rapide à mettre en œuvre, elle présente quelques inconvénients. Les étapes de la méthode impérative sont directement liées à la situation actuelle, ce qui peut rendre les actions difficiles à répéter. Cela signifie que la réexécution de la même commande peut ne pas toujours produire le même état, en particulier si la situation de départ a changé.

Kubernetes deployment : créer un déploiement avec la méthode déclarative

Contrairement à la méthode impérative, la méthode déclarative adopte une approche plus abstraite. Vous définissez l’état souhaité de l’application dans un fichier de configuration, et Kubernetes s’assure que le cluster correspond à cet état. Dans ce cas, vous décrivez ce qui doit être réalisé, et Kubernetes se charge de l’implémentation et du maintien de cet état.

Étape 1 : créer un fichier de configuration YAML

Tout d’abord, nous ouvrons un éditeur de texte et créons le fichier YAML nginx-deployment.yaml afin de définir la configuration pour le déploiement de Kubernetes :

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

Dans la section spec, nous définissons la configuration souhaitée. Avec replicas: 3, nous indiquons que le déploiement doit créer trois réplications (pods) de l’application. La section selector définit comment les pods sont sélectionnés, app=nginx servant ici de critère de sélection. Le template est le modèle pour les pods à créer, y compris les étiquettes. A l’intérieur de containers, on configure le conteneur nginx-container qui utilise l’image de Nginx et écoute sur le port 80.

Étape 2 : appliquer la configuration

Exécutez la commande suivante sur la ligne de commande pour appliquer la configuration au cluster :

kubectl apply -f nginx-deployment.yaml
shell

L’option -f indique le chemin d’accès au fichier YAML ou JSON qui contient la configuration pour les ressources Kubernetes.

Étape 3 : vérifier le statut du déploiement

Cette commande permet de vérifier le succès de la création du déploiement et le statut des pods.

kubectl get deployments nginx-deployment
shell

La sortie nous indique :

NAME                   READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment       3/3     3            3           2m
shell
  • READY : reflète le nombre de pods actuellement en cours d’exécution par rapport au nombre souhaité.
  • UP-TO-DATE : indique le nombre de pods mis à jour avec la dernière configuration.
  • AVAILABLE : liste le nombre de pods qui sont disponibles et qui peuvent accepter des demandes.
  • AGE : précise depuis combien de temps le déploiement est en cours.

Étape 4 : afficher des informations supplémentaires

La commande suivante permet d’obtenir des informations détaillées sur votre déploiement Kubernetes, les stratégies utilisées, les réplications actuelles et souhaitées ainsi que les étiquettes des sélecteurs.

kubectl describe deployment nginx-deployment
shell

La sortie est la suivante :

Name:                   nginx-deployment
Namespace:              default
CreationTimestamp:      Thu, 22 Feb 2024 12:34:56 +0000
Labels:                 <none>
Annotations:            deployment.kubernetes.io/revision: 1
Selector:               app=nginx
Replicas:               3 desired | 3 updated | 3 total | 3 available | 0 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
shell

La stratégie de mise à jour est configurée comme rolling update, avec un maximum de 25 % d’indisponibilité et une augmentation jusqu’à 25 % de pods supplémentaires pendant une mise à jour.

Étape 5 : mise à l’échelle du déploiement

Pour ajuster le nombre de pods dans un déploiement Kubernetes, utilisez la commande kubectl scale.

kubectl scale deployment nginx-deployment --replicas=2
shell

Après l’exécution de cette commande, Kubernetes mettra à jour le déploiement et s’assurera que le nombre souhaité de réplications est présent. Dans notre exemple, nous réduisons le nombre de pods en cours d’exécution à 2.

Kubernetes deployment : les différentes stratégies

Les stratégies de déploiement dans Kubernetes définissent la manière dont les modifications d’une application sont implémentées dans un cluster.

  • Rolling deployment (standard) : la stratégie rolling est la méthode standard pour les déploiements dans Kubernetes. Dans ce cas, les nouveaux pods sont déployés progressivement, tandis que les anciens pods sont supprimés au fur et à mesure. Cela permet une disponibilité continue pendant le processus de mise à jour.
  • Recreate deployment : avec cette stratégie, tous les pods existants sont d’abord supprimés, puis les pods mis à jour sont démarrés. Cette méthode peut entraîner une interruption temporaire des services, car aucun pod n’est disponible pendant le processus de recréation.
  • Blue/green deployment : ici, deux ensembles de pods (blue et green) sont créés, l’un représentant la version actuelle de l’application et l’autre la nouvelle version. En attribuant des étiquettes spécifiques à ces pods, le trafic peut être redirigé de manière transparente entre les deux versions. Cela permet de passer rapidement d’une version à l’autre et d’effectuer facilement des rollbacks (retours en arrière).

Kubernetes Deployment Rollback

Si une erreur se produit dans la dernière version de votre application, il est crucial d’effectuer un rollback le plus rapidement possible. Dans Kubernetes, vous pouvez initier le processus de rollback en contrôlant l’historique des révisions de votre déploiement et en revenant à une version précédente si nécessaire.

Contrôler l’historique des révisions

Pour afficher l’historique des révisions de votre déploiement, utilisez la commande suivante :

kubectl rollout history deployment/nginx-deployment
shell

Retour à l’état précédent

Cette commande effectue un retour à la révision précédente, considérée comme stable :

kubectl rollout undo deployment/nginx-deployment
shell

Retourner à une version spécifique

Si vous souhaitez revenir à une révision spécifique, spécifiez la commande suivante et le numéro de révision souhaité :

kubectl rollout undo deployment/nginx-deployment --to-revision=1
shell
Conseil

Si vous débutez avec Kubernetes, nous vous recommandons de consulter notre tutoriel Kubernetes.

Managed Kubernetes de IONOS Cloud
Orchestrez vos charges de travail en toute sécurité

Managed Kubernetes est la plateforme idéale pour des applications de conteneurs performantes et hautement évolutives.

Cet article vous a-t-il été utile ?