Utilisation du HorizontalPodAutoscaler dans Kubernetes

Introduction

HorizontalPodAutoscaler est une fonctionnalité de Kubernetes qui vous permet de mettre à l'échelle automatiquement le nombre de pods dans un déploiement en fonction de l'utilisation des ressources. Dans ce laboratoire (lab), nous apprendrons à utiliser HorizontalPodAutoscaler pour mettre à l'échelle automatiquement notre déploiement.

Démarrer le cluster Minikube

Avant de créer des ressources, vous avez besoin d'un cluster Kubernetes en cours d'exécution. Minikube est un environnement Kubernetes léger qui s'exécute sur votre machine locale.

Accédez à votre répertoire de travail :

Ouvrez le terminal et accédez au dossier de projet par défaut :
```
cd /home/labex/project
```
Démarrez Minikube :

Démarrez Minikube pour initialiser un cluster Kubernetes :
```
minikube start
```
- Cette commande configure un cluster Kubernetes mono - noeud sur votre machine locale.
- Minikube peut prendre quelques minutes à démarrer en fonction des performances de votre système.
Vérifiez que Minikube est en cours d'exécution :

Vérifiez l'état du cluster Minikube :
```
minikube status
```
- Recherchez des composants tels que kubelet et apiserver listés comme Running (en cours d'exécution).
- Si le cluster n'est pas en cours d'exécution, relancez la commande minikube start.

Si vous rencontrez des problèmes lors du démarrage de Minikube, utilisez minikube delete pour réinitialiser l'environnement si nécessaire.

Créer un déploiement

Tout d'abord, nous devons créer un déploiement auquel nous appliquerons le HorizontalPodAutoscaler.

Créez un fichier de déploiement nommé deployment.yaml avec le contenu suivant :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hpa-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: hpa-demo
  template:
    metadata:
      labels:
        app: hpa-demo
    spec:
      containers:
        - name: hpa-demo
          image: nginx
          resources:
            limits:
              cpu: "1"
              memory: 512Mi
            requests:
              cpu: "0.5"
              memory: 256Mi
---
apiVersion: v1
kind: Service
metadata:
  name: hpa-demo
spec:
  selector:
    app: hpa-demo
  ports:
    - name: http
      port: 80
      targetPort: 80

Ce déploiement spécifie une seule réplique d'un conteneur Nginx avec des limites et des demandes de ressources pour le CPU et la mémoire.

Créez le déploiement :

kubectl apply -f deployment.yaml

Créer un HorizontalPodAutoscaler

Maintenant que nous avons un déploiement, nous pouvons créer un HorizontalPodAutoscaler pour mettre à l'échelle automatiquement le déploiement.

Créez un fichier HorizontalPodAutoscaler nommé hpa.yaml avec le contenu suivant :

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: hpa-demo
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: hpa-demo
  minReplicas: 1
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          averageUtilization: 1
          type: Utilization

Ce HorizontalPodAutoscaler spécifie que nous voulons mettre à l'échelle le déploiement hpa-demo pour qu'il ait entre 1 et 10 répliques, et que nous visons une utilisation moyenne du CPU de 50 %.

Créez le HorizontalPodAutoscaler :

kubectl apply -f hpa.yaml

Tester le HorizontalPodAutoscaler

Maintenant que nous avons un HorizontalPodAutoscaler, nous pouvons le tester en générant une charge sur le déploiement.

Activez le metrics-server

minikube addons enable metrics-server

Créez un pod de génération de charge :

kubectl run -i --tty load-generator --image=busybox /bin/sh

Dans le pod de génération de charge, exécutez la commande suivante pour générer une charge sur le déploiement :

while true; do wget -q -O- http://hpa-demo; done

Ouvrez un autre terminal et vérifiez l'état du HorizontalPodAutoscaler :

kubectl get hpa

Vous pouvez voir que le nombre de copies de hpa-demo a été augmenté à 10. Vous pouvez vérifier le nombre de répliques avec la commande suivante.

kubectl get pods -l app=hpa-demo

Arrêtez la génération de charge en tapant ctrl+c dans le pod de génération de charge.

Résumé

Dans ce laboratoire, nous avons appris à utiliser le HorizontalPodAutoscaler pour mettre à l'échelle automatiquement un déploiement en fonction de l'utilisation des ressources. Nous avons créé un déploiement, un HorizontalPodAutoscaler et l'avons testé en générant une charge sur le déploiement. Nous avons également vu comment le HorizontalPodAutoscaler mettait à l'échelle le déploiement en réponse à l'augmentation de la charge.