Utilizzo di Kubernetes Horizontal Pod Autoscaler

Scopri come utilizzare Kubernetes Horizontal Pod Autoscaler per ridimensionare automaticamente il numero di pod su un cluster creato utilizzando Kubernetes Engine (OKE).

È possibile utilizzare l'Autoscaler pod orizzontale Kubernetes per ridimensionare automaticamente il numero di pod in una distribuzione, in un controller di replica, in un set di repliche o in un set con conservazione dello stato, in base all'utilizzo della CPU o della memoria di tale risorsa o su altre metriche. Horizontal Pod Autoscaler può aiutare le applicazioni a scalare per soddisfare l'aumento della domanda o a scalare quando le risorse non sono più necessarie. È possibile impostare una percentuale della metrica di destinazione per il ridimensionamento automatico pod orizzontale da soddisfare quando si ridimensionano le applicazioni. Per ulteriori informazioni, vedere Horizontal Pod Autoscaler nella documentazione su Kubernetes.

Horizontal Pod Autoscaler è una risorsa API standard in Kubernetes che richiede l'installazione di un'origine delle metriche, come il server delle metriche Kubernetes, nel cluster. Per ulteriori informazioni, vedere Distribuzione del server delle metriche Kubernetes in un cluster.

Note su Horizontal Pod Autoscaler

Tenere presente quanto riportato di seguito.

Il server delle metriche Kubernetes supporta solo il ridimensionamento in base all'utilizzo della CPU e della memoria. Altre implementazioni dell'API delle metriche Kubernetes supportano il ridimensionamento in base a metriche personalizzate. Fare riferimento alla documentazione Kubernetes per un elenco di implementazioni alternative (vedere Implementazioni) e per ulteriori informazioni sulla scalabilità in base a metriche personalizzate (vedere Ridimensionamento automatico su più metriche e metriche personalizzate).
È possibile ridimensionare le applicazioni manualmente aggiornando i file manifesto, senza utilizzare Horizontal Pod Autoscaler.
È possibile utilizzare Kubernetes Horizontal Pod Autoscaler con pool di nodi gestiti e pool di nodi virtuali.

Utilizzo di Horizontal Pod Autoscaler

Le istruzioni riportate di seguito si basano sull'argomento Horizontal Pod Autoscaler Walkthrough nella documentazione di Kubernetes. Descrivono come:

Verificare che il server delle metriche Kubernetes sia stato installato in un cluster.
Distribuire un server Web php-apache di esempio.
Creare una risorsa Autoscaler pod orizzontale che verrà ridimensionata in base all'utilizzo della CPU.
Avviare la generazione di un carico di esempio.
Visualizzare l'operazione di scala in azione.
Arrestare la generazione del carico di esempio.
Pulire, rimuovendo il server Web php-apache e l'Autoscaler Pod orizzontale.

Passo 1: verificare l'installazione del server delle metriche Kubernetes

Se non è già stato fatto, attenersi alla procedura per impostare il file di configurazione kubeconfig del cluster e (se necessario) impostare la variabile di ambiente KUBECONFIG in modo che punti al file. Si noti che è necessario impostare il proprio file kubeconfig. Non è possibile accedere a un cluster utilizzando un file kubeconfig impostato da un altro utente. Vedere Impostazione dell'accesso al cluster.
Verificare che il server delle metriche Kubernetes sia stato distribuito correttamente sul cluster ed è disponibile immettendo:
```
kubectl -n kube-system get deployment/metrics-server
```
Se il comando restituisce un errore `Not Found`, è necessario distribuire il server delle metriche Kubernetes nel cluster prima di continuare. Vedere Distribuzione del server metriche Kubernetes in un cluster.

Passo 2: distribuire un'applicazione di esempio

Distribuire una semplice applicazione server Web Apache immettendo:

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

L'output del comando precedente conferma la distribuzione:

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

Pod del server Web Apache creato dal file manifesto:

Ha un limite di CPU di 500 m, che garantisce che il contenitore non utilizzi mai più di 500 millicore o 1/2 di un core.
Dispone di una richiesta di CPU di 200 m, che consente al contenitore di utilizzare 200 millicore di risorse CPU o 1/5 di una memoria centrale.

Passo 3: Creare una risorsa Autoscaler Pod orizzontale

Creare una risorsa Autoscaler pod orizzontale per mantenere un minimo di 1 e un massimo di 10 repliche e un utilizzo medio della CPU del 50%, immettendo:
```
kubectl autoscale deployment php-apache --cpu-percent=50 --min=1 --max=10
```
L'output del comando precedente conferma la creazione di Horizontal Pod Autoscaler.
```
horizontalpodautoscaler.autoscaling/php-apache autoscaled
```
Il comando crea un Autoscaler Pod orizzontale per la distribuzione del server Web Apache che:
- Gestisce un minimo di 1 e un massimo di 10 repliche dei pod creati in precedenza controllati dalla distribuzione del server Web Apache.
- Aumenta e riduce il numero di repliche della distribuzione per mantenere un utilizzo medio della CPU del 50% in tutti i pod.
Se l'utilizzo medio della CPU è inferiore al 50%, Horizontal Pod Autoscaler cerca di ridurre al minimo il numero di pod nella distribuzione (in questo caso, 1). Se l'utilizzo medio della CPU supera il 50%, Horizontal Pod Autoscaler cerca di aumentare al massimo il numero di pod nella distribuzione (in questo caso, 10). Per ulteriori informazioni, vedere Come funziona Horizontal Pod Autoscaler? nella documentazione su Kubernetes.

Per ulteriori informazioni sul comando kubectl autoscale, vedere autoscale nella documentazione di Kubernetes.
Dopo un minuto, confermare lo stato corrente di Horizontal Pod Autoscaler immettendo:
```
kubectl get hpa
```
L'output del comando precedente mostra lo stato corrente:
```
NAME       REFERENCE             TARGETS MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 0%/50%  1       10      1        10s
```
La colonna TARGETS mostra l'utilizzo medio della CPU in tutti i pod controllati dalla distribuzione del server Web Apache. Poiché al server non viene inviata alcuna richiesta, l'esempio riportato sopra mostra l'utilizzo corrente della CPU è dello 0%, rispetto all'utilizzo della destinazione del 50%. Si noti che potrebbero essere visualizzati numeri diversi, a seconda del tempo di attesa prima di eseguire il comando.

Passo 4: Avvia generazione carico campione

Eseguire un contenitore con un'immagine busybox per creare un carico per il server Web Apache immettendo:
```
kubectl run -it --rm load-generator --image=busybox /bin/sh
```
Generare un carico per il server Web Apache che causerà lo scale out della distribuzione da parte di Horizontal Pod Autoscaler immettendo:
```
while true; do wget -q -O- http://php-apache; done
```

Passo 5: visualizzare l'operazione di scala

Dopo un minuto, aprire una nuova finestra del terminale e confermare lo stato corrente del Pod Autoscaler orizzontale immettendo:
```
kubectl get hpa
```
L'output del comando precedente mostra lo stato corrente:
```
NAME       REFERENCE             TARGETS  MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 250%/50% 1       10      1        1m
```
Nell'esempio precedente, è possibile vedere che l'utilizzo corrente della CPU è aumentato al 250%, rispetto all'utilizzo di destinazione del 50%. Si noti che potrebbero essere visualizzati numeri diversi, a seconda del tempo di attesa prima di eseguire il comando.

Per raggiungere l'obiettivo di utilizzo del 50%, Horizontal Pod Autoscaler dovrà aumentare il numero di repliche per scalare la distribuzione.
Dopo alcuni minuti, visualizzare l'aumento del numero di repliche immettendo nuovamente:
```
kubectl get hpa
```
L'output del comando precedente mostra lo stato corrente:
```
NAME       REFERENCE             TARGETS  MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 50%/50%  1       10      5        5m
```
Nell'esempio precedente, è possibile vedere che Horizontal Pod Autoscaler ha ridimensionato la distribuzione a 5 repliche e il target di utilizzo del 50% è stato raggiunto. Si noti che potrebbero essere visualizzati numeri diversi, a seconda del tempo di attesa prima di eseguire il comando.
Verificare che sia stato eseguito lo scale out della distribuzione immettendo:
```
kubectl get deployment php-apache
```
L'output del comando precedente mostra lo stato corrente:
```
NAME       READY UP-TO-DATE AVAILABLE AGE
php-apache 5/5   5          5         5m
```
Si noti che potrebbero essere visualizzati numeri diversi, a seconda del tempo di attesa prima di eseguire il comando.

Passo 6: Arresta generazione carico campione

Nella finestra del terminale in cui è stato creato il contenitore con l'immagine di busybox e generato il carico per il server Web Apache:
1. Terminare la generazione del carico premendo Ctrl+C
2. Chiudere il prompt dei comandi immettendo:
```
exit
```
  L'output del comando precedente conferma che la sessione è terminata:
```
Session ended, resume using 'kubectl attach load-generator -c load-generator -i -t' command when the pod is running
pod "load-generator" deleted
```
Dopo un minuto, confermare lo stato corrente di Horizontal Pod Autoscaler immettendo:
```
kubectl get hpa
```
L'output del comando precedente mostra lo stato corrente:
```
NAME       REFERENCE             TARGETS MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 0%/50%  1       10      5        10m
```
Nell'esempio precedente, è possibile vedere che l'utilizzo corrente della CPU è stato ridotto allo 0%, rispetto all'utilizzo di destinazione del 50%. Tuttavia, ci sono ancora 5 repliche nella distribuzione. Si noti che potrebbero essere visualizzati numeri diversi, a seconda del tempo di attesa prima di eseguire il comando.
Dopo alcuni minuti, visualizzare il numero ridotto di repliche immettendo nuovamente:
```
kubectl get hpa
```
L'output del comando precedente mostra lo stato corrente:
```
NAME       REFERENCE             TARGETS  MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 0%/50%   1       10      1        15m
```
Nell'esempio precedente, è possibile vedere che Horizontal Pod Autoscaler ha ridimensionato la distribuzione a 1 replica.

Tenere presente che il conteggio delle repliche richiederà tempo per ridurlo a 1. Cinque minuti è il periodo di tempo predefinito per lo scale-in. Si noti che potrebbero essere visualizzati numeri diversi, a seconda del tempo di attesa prima di eseguire il comando.
Verificare che sia stato eseguito lo scale in della distribuzione immettendo:
```
kubectl get deployment php-apache
```
L'output del comando precedente mostra lo stato corrente:
```
NAME       READY UP-TO-DATE AVAILABLE AGE
php-apache 1/1   1          1         15m
```
Si noti che potrebbero essere visualizzati numeri diversi, a seconda del tempo di attesa prima di eseguire il comando.

Passo 7: eseguire il cleanup

Eliminare Horizontal Pod Autoscaler immettendo:
```
kubectl delete horizontalpodautoscaler.autoscaling/php-apache
```
Si noti che quando si elimina un pod Autoscaler orizzontale, il numero di repliche rimane lo stesso. Una distribuzione non torna automaticamente allo stato che aveva prima della creazione del Pod Autoscaler orizzontale.

Eliminare la distribuzione del server Web Apache immettendo:

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

Documentazione di Oracle Cloud Infrastructure