Mettre à l'échelle le Déploiement (`kubectl scale deployment ... --replicas=X` ou via le manifeste)

Introduction à la mise à l'échelle (scaling) dans Kubernetes

L'un des avantages majeurs de Kubernetes est sa capacité à ajuster dynamiquement le nombre d'instances (Pods) d'une application en fonction des besoins. Ce processus est appelé "mise à l'échelle" ou "scaling". Il permet de répondre à une augmentation de la charge de travail (scale-up) en ajoutant des Pods, ou d'optimiser l'utilisation des ressources en réduisant leur nombre lorsque la demande diminue (scale-down).

Pour notre Déploiement Nginx, qui exécute actuellement un nombre défini de réplicas (par exemple, 2 suite à notre exercice initial ou à la mise à jour), nous allons explorer comment modifier ce nombre. Kubernetes propose principalement deux approches pour cela : une commande directe et impérative (`kubectl scale`) et la modification déclarative du manifeste du Déploiement.

Mise à l'échelle impérative avec `kubectl scale`

La méthode la plus rapide pour changer le nombre de réplicas d'un Déploiement est d'utiliser la commande `kubectl scale`. Cette approche est dite impérative car vous donnez un ordre direct à Kubernetes ("mets ce déploiement à X réplicas maintenant").

La syntaxe est simple :

kubectl scale deployment  --replicas=

Par exemple, pour augmenter le nombre de Pods de notre `nginx-deployment` à 3, nous exécuterions :

kubectl scale deployment nginx-deployment --replicas=3

Après l'exécution, Kubernetes (via le contrôleur de Déploiement) ajustera immédiatement le nombre de Pods pour atteindre l'objectif de 3. Si vous aviez 2 Pods, il en créera un nouveau. Si vous aviez 5 Pods, il en terminerait 2. La sortie confirmera l'action :

deployment.apps/nginx-deployment scaled

Cette méthode est pratique pour des ajustements rapides ou des tests. Cependant, son inconvénient majeur est qu'elle ne met pas à jour votre fichier manifeste `nginx-deployment.yaml`. Si vous réappliquiez le fichier YAML original (qui spécifie peut-être `replicas: 2`), Kubernetes reviendrait à 2 réplicas, annulant votre scaling manuel.

Mise à l'échelle déclarative via le manifeste YAML

L'approche déclarative, cohérente avec la philosophie de Kubernetes et les bonnes pratiques (notamment GitOps), consiste à modifier directement le fichier manifeste YAML pour spécifier le nouveau nombre de réplicas désiré.

Ouvrez à nouveau votre fichier `nginx-deployment.yaml`. Localisez la ligne `replicas:` sous la section `spec:`. Modifiez la valeur pour indiquer le nouveau nombre souhaité. Par exemple, pour passer à 4 réplicas :

# ... (autres sections du YAML)
spec:
  replicas: 4 # <-- Modifier cette valeur
  selector:
    matchLabels:
      app: nginx
# ... (reste du template)

Sauvegardez le fichier. Ensuite, appliquez cette modification au cluster comme nous l'avons fait précédemment :

kubectl apply -f nginx-deployment.yaml

Comme avec la mise à jour d'image, `kubectl apply` détectera le changement dans le champ `replicas` et demandera au contrôleur de Déploiement d'ajuster le nombre de Pods pour correspondre à la nouvelle valeur (4 dans cet exemple). La sortie sera similaire :

deployment.apps/nginx-deployment configured

L'avantage principal de cette méthode est que votre fichier manifeste YAML reste la source de vérité unique décrivant l'état désiré de votre application. Il est versionné et peut être réappliqué à tout moment pour garantir que le cluster reflète bien la configuration voulue.

Vérification de la mise à l'échelle

Quelle que soit la méthode utilisée (`kubectl scale` ou modification du manifeste), il est essentiel de vérifier que l'opération a réussi. Vous pouvez utiliser les mêmes commandes que lors de la vérification du déploiement initial.

Pour vérifier l'état du Déploiement et le nombre de réplicas prêts :

kubectl get deployment nginx-deployment

La colonne `READY` devrait maintenant indiquer le nouveau nombre de réplicas sur le total désiré (par exemple, `3/3` ou `4/4`).

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   3/3     3            3           10m # Si scale à 3
# ou
# NAME               READY   UP-TO-DATE   AVAILABLE   AGE
# nginx-deployment   4/4     4            4           10m # Si scale à 4

Pour voir les Pods individuels et confirmer que leur nombre correspond bien au scaling effectué :

kubectl get pods -l app=nginx

Vous devriez maintenant lister exactement le nombre de Pods spécifié (`3` ou `4` dans nos exemples), tous idéalement en état `Running`.

Maîtriser ces deux méthodes de scaling vous donne la flexibilité d'ajuster rapidement la capacité de vos applications sur Kubernetes, en choisissant l'approche (impérative ou déclarative) la plus adaptée à votre contexte et à vos processus de gestion de configuration.