**Aidez à améliorer cette page**
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
Pour contribuer à ce guide de l'utilisateur, cliquez sur le GitHub lien **Modifier cette page sur** qui se trouve dans le volet droit de chaque page.
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Déployez des pods à l’échelle avec Horizontal Pod Autoscaler
Kubernetes [Horizontal Pod Autoscaler](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/) met automatiquement à l’échelle le nombre de pods dans un déploiement, un contrôleur de réplication ou un ensemble de réplicas en fonction de l’utilisation du CPU de cette ressource. Cela peut permettre à vos applications de monter en puissance pour répondre à une demande accrue ou de baisser en puissance lorsque les ressources ne sont pas nécessaires, libérant ainsi vos nœuds pour d'autres applications. Lorsque vous définissez un pourcentage cible d'utilisation du processeur, Horizontal Pod Autoscaler met à l'échelle votre application pour essayer d'atteindre cet objectif.
Horizontal Pod Autoscaler est une ressource API standard dans Kubernetes qui nécessite simplement qu'une source de métriques (telle que le serveur de métriques Kubernetes) soit installée sur votre cluster Amazon EKS pour fonctionner. Vous n'avez pas besoin de déployer ou d'installer Horizontal Pod Autoscaler sur votre cluster pour mettre vos applications à l'échelle. Pour plus d'informations, consultez [Horizontal Pod Autoscaler](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/) dans la documentation Kubernetes.
Utilisez cette rubrique pour préparer Horizontal Pod Autoscaler pour votre cluster Amazon EKS et pour vérifier qu'il fonctionne avec un exemple d'application.
**Note**
Cette rubrique est basée sur la [démonstration Horizontal Pod Autoscaler](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale-walkthrough/) de la documentation Kubernetes.
+ Vous disposez d'un cluster Amazon EKS existant. Si ce n’est pas le cas, consultez [Mise en route avec Amazon EKS](getting-started.md).
+ Le serveur de métriques Kubernetes est installé. Pour de plus amples informations, consultez [Afficher l’utilisation des ressources avec le serveur de métriques Kubernetes](metrics-server.md).
+ Vous utilisez un client `kubectl` qui est [configuré pour communiquer avec votre cluster Amazon EKS](getting-started-console.md#eks-configure-kubectl).
## Exécution d'une application de test du Horizontal Pod Autoscaler
Dans cette section, vous déployez un exemple d'application pour vérifier que Horizontal Pod Autoscale) fonctionne.
**Note**
Cet exemple est basé sur la [démonstration Horizontal Pod Autoscaler](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale-walkthrough/) de la documentation Kubernetes.
1. Déployez une application simple de serveur web Apache avec la commande suivante.
```
kubectl apply -f https://k8s.io/examples/application/php-apache.yaml
```
Ce pod de serveur web Apache est limité à 500 millicpu par processeur et fonctionne sur le port 80.
1. Créez une ressource Horizontal Pod Autoscaler pour le déploiement `php-apache`.
```
kubectl autoscale deployment php-apache --cpu-percent=50 --min=1 --max=10
```
Cette commande crée un autoscaler qui vise une utilisation de 50 % du CPU pour le déploiement, avec un minimum d’un pod et un maximum de dix pods. Lorsque la charge moyenne du processeur est inférieure à 50 %, l’autoscaler tente de réduire le nombre de pods dans le déploiement, jusqu’à un minimum d’un. Lorsque la charge est supérieure à 50 %, l’autoscaler essaie d’augmenter le nombre de pods dans le déploiement, jusqu’à un maximum de dix. Pour plus d’informations, consultez la section [« Comment fonctionne HorizontalPodAutoscaler ? »](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/#how-does-a-horizontalpodautoscaler-work) dans la documentation Kubernetes.
1. Décrivez l'autoscaler avec la commande suivante pour en afficher les détails.
```
kubectl get hpa
```
L'exemple qui suit illustre un résultat.
```
NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 0%/50% 1 10 1 51s
```
Comme vous pouvez le voir, la charge CPU actuelle est `0%`, car le serveur n’est pas encore sollicité. Le nombre de pods est déjà à sa limite inférieure (un), il ne peut donc pas être augmenté.
1. Créez une charge pour le serveur web en exécutant un conteneur .
```
kubectl run -i \
--tty load-generator \
--rm --image=busybox \
--restart=Never \
-- /bin/sh -c "while sleep 0.01; do wget -q -O- http://php-apache; done"
```
1. Pour observer l'augmentation du déploiement, exécutez régulièrement la commande suivante dans un terminal distinct de celui dans lequel vous avez exécuté l'étape précédente.
```
kubectl get hpa php-apache
```
L'exemple qui suit illustre un résultat.
```
NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 250%/50% 1 10 5 4m44s
```
L'augmentation du nombre de réplicas peut prendre plus d'une minute. Tant que le pourcentage de CPU réel est supérieur au pourcentage cible, le nombre de réplicas augmente jusqu'à 10. Dans ce cas, c’est `250%`, donc le nombre de `REPLICAS` continue d’augmenter.
**Note**
L'atteinte du nombre de réplicas maximum peut prendre un certain temps. Si, par exemple, seules six réplicas sont nécessaires pour que la charge CPU reste inférieure ou égale à 50 %, alors la charge ne dépassera pas six réplicas.
1. Arrêtez la charge. Dans la fenêtre de terminal dans laquelle vous générez la charge, arrêtez la charge en maintenant les touches `Ctrl+C` enfoncées. Vous pouvez voir les réplicas revenir à 1 en exécutant à nouveau la commande suivante dans le terminal dans lequel vous observez la mise à l’échelle horizontale.
```
kubectl get hpa
```
L'exemple qui suit illustre un résultat.
```
NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 0%/50% 1 10 1 25m
```
**Note**
Le délai par défaut pour la réduction d'échelle est de cinq minutes. Par conséquent, un certain temps s'écoule avant de voir le nombre de réplicas atteindre à nouveau 1, même si le pourcentage de CPU actuel est de 0 %. Le délai est modifiable. Pour plus d'informations, consultez [Horizontal Pod Autoscaler](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/) dans la documentation Kubernetes.
1. Lorsque vous avez terminé de tester votre exemple d'application, supprimez les ressources `php-apache`.
```
kubectl delete deployment.apps/php-apache service/php-apache horizontalpodautoscaler.autoscaling/php-apache
```