**Contribuisci a migliorare questa pagina**
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
Per contribuire a questa guida per l'utente, scegli il GitHub link **Modifica questa pagina** nel riquadro destro di ogni pagina.
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Scalare le implementazioni dei pod con Horizontal Pod Autoscaler
[Horizontal Pod Autoscaler](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/) di Kubernetes scala automaticamente il numero di pod in un’implementazione, un controller di replica o un set di repliche in base all’utilizzo della CPU di tale risorsa. Ciò consente alle applicazioni di aumentare orizzontalmente le risorse in base all’aumento della domanda, o di ridurle orizzontalmente quando non sono necessarie, liberando così i nodi per altre applicazioni. Quando imposti una percentuale di utilizzo della CPU target, Horizontal Pod Autoscaler aumenta o riduce le risorse dell’applicazione in modo conforme all’obiettivo prefissato.
Horizontal Pod Autoscaler è una risorsa API standard in Kubernetes il cui funzionamento richiede solo l’installazione di una fonte di parametri, (ad esempio Kubernetes Metrics Server), nel cluster Amazon EKS. Non è necessario implementare o installare Horizontal Pod Autoscaler sul cluster per iniziare a dimensionare le applicazioni. Per ulteriori informazioni, consulta [Horizontal Pod Autoscaler](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/) nella documentazione Kubernetes.
Utilizza questo argomento per preparare Horizontal Pod Autoscaler per il cluster Amazon EKS e per verificare che funzioni con un’applicazione di esempio.
**Nota**
Questo argomento si basa su [Horizontal Pod autoscaler walkthrough](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale-walkthrough/) nella documentazione Kubernetes.
+ Il cluster Amazon EKS è già esistente. Se non lo è, consulta [Nozioni di base su Amazon EKS](getting-started.md).
+ Kubernetes Metrics Server è già installato. Per ulteriori informazioni, consulta [Visualizza l’utilizzo delle risorse con Kubernetes Metrics Server](metrics-server.md).
+ Stai utilizzando un client `kubectl` che è [configurato per comunicare con il cluster Amazon EKS](getting-started-console.md#eks-configure-kubectl).
## Esecuzione di un’applicazione di test di Horizontal Pod Autoscaler
In questa sezione implementerai un’applicazione di esempio per verificare il corretto funzionamento di Horizontal Pod Autoscaler.
**Nota**
Questo esempio si basa su [Horizontal Pod autoscaler walkthrough](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale-walkthrough/) nella documentazione Kubernetes.
1. Implementa un’applicazione server Web Apache con il comando seguente.
```
kubectl apply -f https://k8s.io/examples/application/php-apache.yaml
```
Questo pod di server Web Apache ha un limite di CPU di 500 millicpu e serve sulla porta 80.
1. Crea una risorsa Horizontal Pod Autoscaler per l’implementazione di `php-apache`.
```
kubectl autoscale deployment php-apache --cpu-percent=50 --min=1 --max=10
```
Questo comando crea un componente di scalabilità automatica che punta a un utilizzo della CPU del 50% per l’implementazione, con un minimo di un pod e un massimo di dieci pod. Quando il carico medio della CPU è inferiore al 50%, tale componente cerca di ridurre il numero di pod nell’implementazione, fino a un minimo di uno. Quando il carico è maggiore del 50%, il componente di scalabilità automatica cerca di aumentare il numero di pod nell’implementazione, fino a un massimo di dieci. Per ulteriori informazioni, consulta [How does a HorizontalPodAutoscaler work?](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/#how-does-a-horizontalpodautoscaler-work) nella documentazione Kubernetes.
1. Descrivere il componente di scalabilità automatica con il comando seguente per visualizzarne i dettagli.
```
kubectl get hpa
```
Di seguito viene riportato un output di esempio:
```
NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 0%/50% 1 10 1 51s
```
Come si può vedere, il carico attuale della CPU è `0%` perché non è ancora presente il carico sul server. Il conteggio dei pod è già al limite più basso (uno), quindi non può essere ridotto.
1. Crea un carico per il server Web eseguendo un container.
```
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. Per osservare l’incremento dell’implementazione, esegui periodicamente il seguente comando in un terminale separato dal terminale in cui hai eseguito il passaggio precedente.
```
kubectl get hpa php-apache
```
Di seguito viene riportato un output di esempio:
```
NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 250%/50% 1 10 5 4m44s
```
Potrebbe essere necessario più di un minuto per aumentare il numero di repliche. Finché la percentuale effettiva della CPU è superiore alla percentuale di destinazione, il conteggio delle repliche aumenta fino a 10. In questo caso, è `250%`, quindi il numero di `REPLICAS` continua ad aumentare.
**Nota**
Potrebbero essere necessari alcuni minuti prima che il numero di repliche raggiunga il limite massimo. Se, ad esempio, sono necessarie solo 6 repliche affinché il carico della CPU rimanga pari o inferiore al 50%, il carico non verrà dimensionato oltre 6 repliche.
1. Arresta il carico. Nella finestra del terminale in cui si sta generando il carico, arrestare quest’ultimo tenendo premuti i tasti `Ctrl+C`. È possibile guardare il dimensionamento delle repliche nuovamente a 1 eseguendo di nuovo il seguente comando nel terminale corrispondente.
```
kubectl get hpa
```
Di seguito viene riportato un output di esempio:
```
NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 0%/50% 1 10 1 25m
```
**Nota**
Il periodo di tempo di default per il ridimensionamento è di cinque minuti, quindi ci vorrà un po’ di tempo prima di vedere il conteggio delle repliche raggiungere di nuovo 1, anche quando la percentuale corrente della CPU è 0. L’intervallo di tempo è modificabile. Per ulteriori informazioni, consulta [Horizontal Pod Autoscaler](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/) nella documentazione Kubernetes.
1. Al termine dell’esercitazione con l’applicazione di esempio, elimina le risorse `php-apache`.
```
kubectl delete deployment.apps/php-apache service/php-apache horizontalpodautoscaler.autoscaling/php-apache
```