Utilisation du HPA (Horizontal Pod Autoscaler) de Kubernetes

Découvrez comment utiliser le HPA de Kubernetes pour ajuster automatiquement le nombre de pods dans une grappe que vous avez créée à l'aide de Kubernetes Engine (OKE).

Vous pouvez utiliser le HPA de Kubernetes pour ajuster automatiquement le nombre de pods d'un déploiement, un contrôleur de réplication, un jeu de répliques ou un StatefulSet, en fonction de l'utilisation de l'UC ou de la mémoire de cette ressource, ou d'autres mesures. Le HPA peut aider les applications à évoluer horizontalement pour répondre à une demande accrue, ou verticalement lorsque des ressources ne sont plus nécessaires. Vous pouvez définir un pourcentage de mesure cible pour le HPA, à atteindre lors de l'ajustement des applications. Pour plus d'informations, voir Horizontal Pod Autoscaler dans la documentation sur Kubernetes.

Le HPA est une ressource d'API standard de Kubernetes, qui nécessite l'installation d'une source de mesures, telle que le serveur de mesures Kubernetes, dans la grappe. Pour plus d'informations, voir Déploiement du serveur de mesures Kubernetes sur une grappe.

Notes sur le HPA (Horizontal Pod Autoscaler)

Notez ce qui suit :

Le serveur de mesures Kubernetes prend uniquement en charge l'ajustement en fonction de l'utilisation de l'UC et de la mémoire. D'autres implémentations de l'API de mesures Kubernetes prennent en charge l'ajustement en fonction de mesures personnalisées. Consultez la documentation sur Kubernetes pour obtenir une liste d'autres mises en oeuvre (voir Implementations) et des informations supplémentaires sur l'ajustement basé sur des mesures personnalisées (voir Autoscaling on multiple metrics and custom metrics).
Vous pouvez ajuster les applications manuellement en mettant à jour les fichiers manifestes, sans utiliser le HPA.
Vous pouvez utiliser le HPA de Kubernetes avec les groupes de noeuds gérés et les groupes de noeuds virtuels.

Utilisation du HPA (Horizontal Pod Autoscaler)

Les instructions ci-dessous sont basées sur la rubrique Horizontal Pod Autoscaler Walkthrough de la documentation sur Kubernetes. Elles décrivent comment :

Vérifiez que le serveur de mesures Kubernetes a été installé dans une grappe.
Déployez un exemple de serveur Web php-apache.
Créez une ressource HPA pour effectuer l'ajustement en fonction de l'utilisation de l'UC.
Lancez la génération d'un exemple de charge.
Consultez l'opération d'ajustement en action.
Arrêtez la génération de l'exemple de charge.
Procédez au nettoyage, en supprimant le serveur Web php-apache et le HPA.

Étape 1 : Vérifier l'installation du serveur de mesures Kubernetes

Si vous ne l'avez pas encore fait, suivez les étapes pour configurer le fichier de configuration kubeconfig de la grappe et (s'il y a lieu) définissez la variable d'environnement KUBECONFIG pour qu'elle pointe vers le fichier. Notez que vous devez configurer votre propre fichier kubeconfig. Vous ne pouvez pas accéder à une grappe à l'aide d'un fichier kubeconfig configuré par un autre utilisateur. Voir Configuration de l'accès aux grappes.
Vérifiez que le serveur de mesures Kubernetes a été déployé dans la grappe et qu'il est disponible en entrant :
```
kubectl -n kube-system get deployment/metrics-server
```
Si la commande retourne une erreur indiquant que le serveur est introuvable, vous devez déployer le serveur de mesures Kubernetes dans la grappe avant de continuer. Voir Déploiement du serveur de mesures Kubernetes sur une grappe.

Étape 2 : Déployer un exemple d'application

Déployez une application de serveur Web Apache simple en entrant :

kubectl apply -f https://k8s.io/examples/application/php-apache.yaml

La sortie de la commande ci-dessus confirme le déploiement :

deployment.apps/php-apache created
service/php-apache created

Le pod de serveur Web Apache créé à partir du fichier manifeste :

A une limite de 500M UC, ce qui garantit que le conteneur n'utilisera jamais plus de 500 millicoeurs, ou 1/2 noyau.
Possède une marge de tolérance de 200M demandes d'UC, ce qui permet au conteneur d'utiliser 200 millicoeurs de ressources d'UC, ou 1/5 de coeur.

Étape 3 : Créer une ressource HPA

Créez une ressource HPA pour maintenir un minimum de 1 réplique et un maximum de 10 répliques, et une utilisation moyenne de l'UC de 50 %, en entrant :
```
kubectl autoscale deployment php-apache --cpu-percent=50 --min=1 --max=10
```
La sortie de la commande ci-dessus confirme que le HPA a été créé.
```
horizontalpodautoscaler.autoscaling/php-apache autoscaled
```
Cette commande crée un HPA pour le déploiement de serveur Web Apache qui :
- Maintient un minimum de 1 réplique et un maximum de 10 répliques des pods précédemment créés contrôlés par le déploiement du serveur Web Apache.
- Augmente et diminue le nombre de répliques du déploiement pour maintenir une utilisation moyenne de l'UC de 50 % sur toutes les pods.
Si l'utilisation moyenne de l'UC est inférieure à 50 %, le HPA tente de réduire au minimum le nombre de pods dans le déploiement (dans ce cas, 1). Si l'utilisation moyenne de l'UC dépasse 50 %, le HPA tente d'augmenter le nombre de pods dans le déploiement au maximum (dans ce cas, 10). Pour plus d'informations, voir How does the Horizontal Pod Autoscaler work? dans la documentation sur Kubernetes.

Pour plus d'informations sur la commande kubectl autoscale, voir autoscale dans la documentation sur Kubernetes.
Après une minute, vérifiez le statut courant du HPA en entrant :
```
kubectl get hpa
```
La sortie de la commande ci-dessus indique l'état courant :
```
NAME       REFERENCE             TARGETS MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 0%/50%  1       10      1        10s
```
La colonne TARGETS affiche l'utilisation moyenne de l'UC sur tous les pods contrôlés par le déploiement du serveur Web Apache. Comme aucune demande n'est envoyée au serveur, l'exemple ci-dessus montre que l'utilisation courante de l'UC est de 0 %, par rapport à l'utilisation cible de 50 %. Notez que vous pouvez voir différents nombres, selon le délai d'attente avant l'exécution de la commande.

Étape 4 : Démarrer la génération de l'exemple de charge

Exécutez un conteneur avec une image busybox pour créer une charge pour le serveur Web Apache en entrant :
```
kubectl run -it --rm load-generator --image=busybox /bin/sh
```
Générez une charge pour le serveur Web Apache. Le HPA fera alors évoluer horizontalement le déploiement par le HPA. Pour ce faire, entrez :
```
while true; do wget -q -O- http://php-apache; done
```

Étape 5 : Consulter l'opération d'ajustement

Après une minute, ouvrez une nouvelle fenêtre de terminal et vérifiez le statut courant du HPA en entrant :
```
kubectl get hpa
```
La sortie de la commande ci-dessus indique l'état courant :
```
NAME       REFERENCE             TARGETS  MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 250%/50% 1       10      1        1m
```
Dans l'exemple ci-dessus, vous pouvez voir que l'utilisation courante de l'UC est passée à 250 %, par rapport à l'utilisation cible de 50 %. Notez que vous pouvez voir différents nombres, selon le délai d'attente avant l'exécution de la commande.

Pour atteindre l'objectif d'utilisation de 50 %, le HPA doit augmenter le nombre de répliques pour assurer l'évolutivité horizontale du déploiement.
Attendez encore quelques minutes et affichez le nombre augmenté de répliques en entrant à nouveau :
```
kubectl get hpa
```
La sortie de la commande ci-dessus indique l'état courant :
```
NAME       REFERENCE             TARGETS  MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 50%/50%  1       10      5        5m
```
Dans l'exemple ci-dessus, vous pouvez voir que le HPA a redimensionné le déploiement à 5 répliques, et que la cible d'utilisation de 50 % a été atteinte. Notez que vous pouvez voir différents nombres, selon le délai d'attente avant l'exécution de la commande.
Vérifiez que le déploiement a évolué horizontalement en entrant :
```
kubectl get deployment php-apache
```
La sortie de la commande ci-dessus indique l'état courant :
```
NAME       READY UP-TO-DATE AVAILABLE AGE
php-apache 5/5   5          5         5m
```
Notez que vous pouvez voir différents nombres, selon le délai d'attente avant l'exécution de la commande.

Étape 6 : Arrêter la génération de l'exemple de charge

Dans la fenêtre de terminal où vous avez créé le conteneur avec l'image busybox et généré la charge pour le serveur Web Apache :
1. Mettez fin à la génération de la charge en appuyant sur Ctrl+C
2. Fermez l'invite de commande en entrant :
```
exit
```
  La sortie de la commande ci-dessus confirme que la session a pris fin :
```
Session ended, resume using 'kubectl attach load-generator -c load-generator -i -t' command when the pod is running
pod "load-generator" deleted
```
Après une minute, vérifiez le statut courant du HPA en entrant :
```
kubectl get hpa
```
La sortie de la commande ci-dessus indique l'état courant :
```
NAME       REFERENCE             TARGETS MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 0%/50%  1       10      5        10m
```
Dans l'exemple ci-dessus, vous pouvez voir que l'utilisation courante de l'UC est passée à 0 %, par rapport à l'utilisation cible de 50 %. Toutefois, il y a encore 5 répliques dans le déploiement. Notez que vous pouvez voir différents nombres, selon le délai d'attente avant l'exécution de la commande.
Attendez encore quelques minutes et affichez le nombre réduit de répliques en entrant à nouveau :
```
kubectl get hpa
```
La sortie de la commande ci-dessus indique l'état courant :
```
NAME       REFERENCE             TARGETS  MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 0%/50%   1       10      1        15m
```
Dans l'exemple ci-dessus, vous pouvez voir que le HPA a redimensionné le déploiement à 1 réplique.

Sachez qu'il faut du temps pour que le nombre de répliques passe à 1. Le délai par défaut pour assurer l'évolutivité verticale est de 5 minutes. Notez que vous pouvez voir différents nombres, selon le délai d'attente avant l'exécution de la commande.
Vérifiez que le déploiement a évolué verticalement en entrant :
```
kubectl get deployment php-apache
```
La sortie de la commande ci-dessus indique l'état courant :
```
NAME       READY UP-TO-DATE AVAILABLE AGE
php-apache 1/1   1          1         15m
```
Notez que vous pouvez voir différents nombres, selon le délai d'attente avant l'exécution de la commande.

Étape 7 : Nettoyer

Supprimez le HPA en entrant :
```
kubectl delete horizontalpodautoscaler.autoscaling/php-apache
```
Notez que lorsque vous supprimez un HPA, le nombre de répliques ne change pas. Un déploiement ne revient pas automatiquement à son état antérieur à la création du HPA.

Supprimez le déploiement du serveur Web Apache en entrant :

kubectl delete deployment.apps/php-apache service/php-apache

Documentation sur Oracle Cloud Infrastructure