Horizontal Pod Autoscaler (HPA) - Kubernetes

Mise à jour : 17/03/2025

Dans un environnement Kubernetes, il est essentiel d’adapter dynamiquement les ressources pour garantir la performance des applications tout en optimisant les coûts. L’Horizontal Pod Autoscaler (HPA) automatise ce processus en ajustant le nombre de pods en fonction de l’utilisation des ressources, comme la CPU ou la mémoire. Grâce au HPA, vos applications peuvent évoluer de manière fluide face aux variations de charge, sans intervention manuelle. Voyons ensemble comment il fonctionne et comment l’implémenter efficacement.

Comment fonctionne l’Horizontal Pod Autoscaler (HPA) ?

L’Horizontal Pod Autoscaler (HPA) fonctionne en surveillant en continu les métriques des pods et en ajustant dynamiquement leur nombre pour maintenir un niveau optimal d’utilisation des ressources. Grâce à cette approche, Kubernetes peut adapter automatiquement la capacité des applications en fonction de la charge, sans intervention manuelle.

Le HPA utilise un contrôleur intégré qui récupère périodiquement les métriques des pods (comme l’utilisation de la CPU ou de la mémoire) à partir du Metrics Server. Ensuite, il compare ces valeurs aux seuils définis dans la configuration du HPA et ajuste le nombre de réplicas en conséquence.

Le processus suit ces étapes :

Collecte des métriques
- Le Metrics Server récupère les données d’utilisation des ressources pour chaque pod.
- Ces métriques sont ensuite accessibles via l’API Kubernetes.
Calcul du nombre de pods requis
- Kubernetes compare les valeurs actuelles des métriques aux objectifs d’utilisation définis dans la configuration du HPA.
- Une formule d’ajustement est utilisée pour déterminer si le nombre de pods doit être augmenté ou réduit.
Application des changements
- Si l’utilisation des ressources est supérieure au seuil défini, Kubernetes ajoute des pods.
- Si l’utilisation est inférieure, Kubernetes réduit le nombre de pods pour économiser les ressources.

Voici un exemple de formule utilisée par Kubernetes pour ajuster le nombre de pods en fonction de la charge CPU :

Exemple concret

Imaginons un déploiement Kubernetes avec un HPA configuré pour maintenir une utilisation moyenne de CPU à 50 %.

Si un pod consomme 80 % de CPU et que nous avons 2 pods, l’algorithme recommandera d’augmenter le nombre de pods pour réduire la charge.
Si la consommation CPU tombe à 30 %, alors le HPA pourra décider de réduire le nombre de pods pour économiser des ressources.

Interaction avec le Metrics Server

Le Metrics Server est un composant essentiel pour le HPA. Il collecte les métriques en temps réel et les rend accessibles via l’API Kubernetes. Sans lui, le HPA ne pourra pas récupérer les données nécessaires pour prendre des décisions.

Limitations du HPA

Le HPA est un outil puissant, mais il présente certaines limites :

Il dépend du Metrics Server, qui ne collecte que certaines métriques par défaut (CPU et mémoire).
Il ne peut pas prendre en compte d’autres paramètres comme la latence ou le trafic réseau (sauf en utilisant des métriques personnalisées).
Il ne peut pas ajuster la taille des pods, seulement leur nombre. Pour cela, il faut utiliser le Vertical Pod Autoscaler (VPA).

Grâce à ce mécanisme, l’Horizontal Pod Autoscaler assure une mise à l’échelle dynamique et efficace des applications Kubernetes, garantissant une utilisation optimale des ressources.

Mise en œuvre de l’Horizontal Pod Autoscaler (HPA)

Après avoir compris le fonctionnement du HPA, voyons maintenant comment le configurer et le déployer dans un cluster Kubernetes. Nous allons parcourir les étapes essentielles, de la préparation du cluster à la mise en place d’un HPA sur un déploiement existant.

1. Vérifier l’installation du Metrics Server

Le HPA dépend du Metrics Server pour récupérer les métriques des pods. Avant de commencer, il est essentiel de vérifier que ce composant est bien installé dans votre cluster.

Utilisez la commande suivante pour voir si le Metrics Server est en cours d’exécution :

kubectl get deployment -n kube-system | grep metrics-server

Si vous ne voyez aucun résultat, vous pouvez l’installer avec :

kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

Une fois installé, assurez-vous qu’il fonctionne correctement :

kubectl top pods -A

Si vous voyez des valeurs de consommation CPU et mémoire pour vos pods, le Metrics Server est bien opérationnel.

2. Définir les ressources des pods

Le HPA fonctionne en ajustant le nombre de pods en fonction de leur utilisation des ressources. Pour cela, chaque pod doit avoir des requêtes et des limites de CPU et de mémoire définies dans son manifeste.

Exemple de configuration d’un Deployment avec des limites et des requêtes CPU/Mémoire :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx
        resources:
          requests:
            cpu: "100m"
          limits:
            cpu: "200m"
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: NodePort

3. Déployer un HPA pour l’auto-scaling des pods

Une fois le Metrics Server opérationnel et les ressources bien définies, nous pouvons créer un Horizontal Pod Autoscaler.

a) Créer un HPA basé sur l’utilisation CPU

Nous allons déployer un HPA qui ajuste automatiquement le nombre de pods pour maintenir une utilisation moyenne du CPU à 50 %.

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

Appliquez cette configuration avec :

kubectl apply -f mon-hpa.yaml

Cela signifie que Kubernetes augmentera le nombre de pods si l’utilisation moyenne du CPU dépasse 50 % et réduira le nombre de pods si l’utilisation est inférieure.

b) Vérifier le HPA en action

Une fois déployé, on peut voir l’état du HPA avec :

kubectl get hpa

Vous verrez une sortie similaire à :

NAME        REFERENCE              TARGETS   MINPODS   MAXPODS   REPLICAS   AGE
mon-hpa   Deployment/nginx-deployment   cpu: 0%/50%   1         10        1          2m2s

Attendez quelques minutes pour que le HPA commence à ajuster le nombre de pods en fonction de la charge. Lorsque vous exécutez à nouveau kubectl get hpa, vous verrez les métriques CPU et le nombre de pods ajustés en conséquence.

4. Tester la mise à l’échelle automatique

Pour vérifier si le HPA fonctionne correctement, on peut générer artificiellement une charge CPU. Nous allons utiliser ab (Apache Benchmark) pour simuler des requêtes HTTP.

sudo apt update
sudo apt install apache2-utils

Avant de commencer, il nous faut récupérer l’adresse IP et le Port du service nginx-service :

minikube service nginx-service --url

http://192.168.39.218:31671

On peut ensuite lancer un load generator avec ab pour simuler une charge CPU :

ab -n 1000000 -c 100 http://192.168.39.218:31671/

Après quelques minutes, exécutez :

kubectl get hpa -w
mon-hpa   Deployment/nginx-deployment   cpu: 78%/50%   1         10        2          12m

Vous devriez voir une augmentation du nombre de pods pour absorber la charge.

Pour vérifier le pourcentage d’utilisation CPU des pods, utilisez k9S:

┌────────────────────────────────────────────── Pods(default)[4] ──────────────────────────────────────────────┐
│ NAME↑                             PF READY STATUS   RESTARTS CPU MEM %CPU/R %CPU/L %MEM/R %MEM/L IP          │
│ nginx-deployment-66f5cbd4b-6cckn  ●  1/1   Running         0   0   0      0      0    n/a    n/a 10.244.0.38 │
│ nginx-deployment-66f5cbd4b-79x9g  ●  1/1   Running         0 170   3    170     85    n/a    n/a 10.244.0.36 │
│ nginx-deployment-66f5cbd4b-g72zk  ●  1/1   Running         0   0   0      0      0    n/a    n/a 10.244.0.37 │
│ nginx-deployment-66f5cbd4b-jnfnn  ●  1/1   Running         0 167   3    167     83    n/a    n/a 10.244.0.35 │

Là, deux nouveaux pods ont été créés pour absorber la charge CPU. Pour arrêter le test, utilisez Ctrl+C.

Vérifiez que le HPA réduit le nombre de pods lorsque la charge diminue. Il faut attendre quelques minutes pour que le scaling se fasse.

NAME      REFERENCE                     TARGETS       MINPODS   MAXPODS   REPLICAS   AGE
mon-hpa   Deployment/nginx-deployment   cpu: 0%/50%   1         10        7          19m

Utilisation de plusieurs métriques avec l’Horizontal Pod Autoscaler

Par défaut, l’Horizontal Pod Autoscaler (HPA) utilise l’utilisation moyenne du CPU comme critère principal pour ajuster le nombre de pods. Cependant, il est possible d’intégrer plusieurs métriques, comme la mémoire ou des métriques personnalisées, pour affiner les décisions de mise à l’échelle.

1. Liste des métriques disponibles avec le Metrics Server

Le Metrics Server est l’outil principal utilisé par Kubernetes pour collecter les métriques des pods et des nœuds. Pour voir les métriques disponibles, nous pouvons utiliser les commandes suivantes :

kubectl top pods

NAME                      CPU(cores)   MEMORY(bytes)
nginx-deployment-abc123   150m         50Mi
nginx-deployment-xyz456   180m         60Mi

On observe ici l’utilisation actuelle de la CPU et de la mémoire.

2. Définir un HPA basé sur plusieurs métriques

Nous allons maintenant créer un HPA qui utilise à la fois la CPU et la mémoire pour prendre ses décisions de mise à l’échelle.

Création d’un fichier `hpa-multi.yaml` :

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: nginx-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: nginx-deployment
  minReplicas: 1
  maxReplicas: 5
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 50
    - type: Resource
      resource:
        name: memory
        target:
          type: Utilization
          averageUtilization: 70

Dans cet exemple :

Le HPA maintient l’utilisation moyenne de CPU à 50%.
Il ajuste également le nombre de pods si la mémoire dépasse 70%.

Appliquer cette configuration :

kubectl apply -f hpa-multi.yaml

Vérifier que le HPA a bien été créé :

kubectl get hpa

NAME      REFERENCE                     TARGETS                              MINPODS   MAXPODS   REPLICAS   AGE
mon-hpa   Deployment/nginx-deployment   cpu: 0%/50%, memory: <unknown>/70%   1         10        1          23m

Conclusion

Dans ce guide, nous avons exploré l’Horizontal Pod Autoscaler (HPA), un outil essentiel pour optimiser les ressources Kubernetes en fonction de la charge des applications. Grâce à sa capacité à adapter dynamiquement le nombre de pods, le HPA permet de garantir des performances optimales tout en économisant les ressources.

Dans un prochain guide, nous verrons comment personnaliser le HPA pour intégrer des métriques personnalisées et ajuster les paramètres de mise à l’échelle en fonction des besoins spécifiques de vos applications.