# 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](https://www.ionos.fr/digitalguide/serveur/configuration/kubernetes-pod/) 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](https://cloud.ionos.fr/managed/kubernetes "Hébergement de Kubernetes géré - créez votre prochain cluster (ionos.fr)") 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.

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

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 :

```yaml
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
```

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 :

```shell
kubectl apply -f nginx-deployment.yaml
```

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.

```shell
kubectl get deployments nginx-deployment
```

La sortie nous indique :

```shell
NAME                   READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment       3/3     3            3           2m
```

- **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.

```shell
kubectl describe deployment nginx-deployment
```

La sortie est la suivante :

```shell
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
```

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`.

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

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 :

```shell
kubectl rollout history deployment/nginx-deployment
```

### Retour à l’état précédent

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

```shell
kubectl rollout undo deployment/nginx-deployment
```

### 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é :

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

Conseil Si vous débutez avec Kubernetes, nous vous recommandons de consulter notre [tutoriel Kubernetes](https://www.ionos.fr/digitalguide/serveur/configuration/tutoriel-kubernetes/).


This is a markdown version of: [https://www.ionos.fr/digitalguide/serveur/configuration/kubernetes-deployment/](https://www.ionos.fr/digitalguide/serveur/configuration/kubernetes-deployment/) for AI/LLM consumption.