Usando o Kubernetes Horizontal Pod Autoscaler

Descubra como usar o Kubernetes Horizontal Pod Autoscaler para dimensionar automaticamente o número de pods em um cluster que você criou usando o Kubernetes Engine (OKE).

Você pode usar o Kubernetes Horizontal Pod Autoscaler para dimensionar automaticamente o número de pods em implantação, controlador de replicação, conjunto de réplicas ou conjunto com monitoramento de estado, com base na utilização de memória ou CPU desse recurso ou em outras métricas. O Horizontal Pod Autoscaler pode ajudar na ampliação dos aplicativos a fim de atender ao aumento da demanda, ou na redução, quando os recursos não são mais necessários. Você pode definir um percentual de métrica alvo para o Horizontal Pod Autoscaler para atender ao dimensionamento dos aplicativos. Para obter mais informações, consulte Horizontal Pod Autoscaler na documentação do Kubernetes.

O Horizontal Pod Autoscaler é um recurso de API padrão no Kubernetes que exige a instalação de uma origem de métricas, como o Kubernetes Metrics Server, no cluster. Para obter mais informações, consulte Implantando o Kubernetes Metrics Server em um Cluster.

Observações sobre o Horizontal Pod Autoscaler

Observe o seguinte:

O Kubernetes Metrics Server só suporta dimensionamento com base na utilização de CPU e memória. Outras implementações da API de Métricas do Kubernetes suportam dimensionamento com base em métricas personalizadas. Consulte a documentação do Kubernetes para obter uma lista de implementações alternativas (consulte Implementações) e para obter mais informações sobre dimensionamento com base em métricas personalizadas (consulte Dimensionamento Automático em várias métricas e métricas personalizadas).
Você pode dimensionar os aplicativos manualmente atualizando os arquivos de manifesto, sem usar o Horizontal Pod Autoscaler.
Você pode usar o Kubernetes Horizontal Pod Autoscaler com pools de nós gerenciados e pools de nós virtuais.

Como Trabalhar com o Horizontal Pod Autoscaler

As instruções a seguir são baseadas no tópico Apresentação do Horizontal Pod Autoscaler na documentação do Kubernetes. Elas descrevem como:

Verificar se o Kubernetes Metrics Server foi instalado em um cluster.
Implantar um servidor Web php-apache de amostra.
Criar um recurso do Horizontal Pod Autoscaler que será dimensionado com base na utilização da CPU.
Iniciar a geração de uma carga de amostra.
Exibir a operação de dimensionamento em ação.
Interromper a geração da carga de amostra.
Limpar, removendo o servidor Web php-apache e o Horizontal Pod Autoscaler.

Etapa 1: Verificar a Instalação do Kubernetes Metrics Server

Se você ainda não tiver feito isso, siga as etapas para configurar o arquivo de configuração kubeconfig do cluster e (se necessário) defina a variável de ambiente KUBECONFIG para apontar para o arquivo. Observe que você deve configurar seu próprio arquivo kubeconfig. Não é possível acessar um cluster usando um arquivo kubeconfig que outro usuário tenha configurado. Consulte Configurando o Acesso ao Cluster.
Confirme se o Kubernetes Metrics Server foi implantado com sucesso no cluster e se está disponível digitando:
```
kubectl -n kube-system get deployment/metrics-server
```
Se o comando retornar um erro `Not Found`, implante o Kubernetes Metrics Server no cluster antes de continuar. Consulte Implantando o Kubernetes Metrics Server em um Cluster.

Etapa 2: Implantar um Aplicativo de Amostra

Implante um aplicativo de servidor Web Apache simples digitando:

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

A saída do comando acima confirma a implantação:

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

O pod do servidor Web Apache que é criado com base no arquivo de manifesto:

Tem um limite de 500m de CPU, que garante que o contêiner nunca use mais de 500 milinúcleos ou 1/2 de um núcleo.
Tem uma permissão de solicitação de CPU de 200m, que permite que o contêiner use 200 milinúcleos de recursos de CPU ou 1/5 de um núcleo.

Etapa 3: Criar um Recurso do Horizontal Pod Autoscaler

Crie um recurso do Horizontal Pod Autoscaler para manter no mínimo 1 e no máximo 10 réplicas e uma utilização média de CPU de 50%, digitando:
```
kubectl autoscale deployment php-apache --cpu-percent=50 --min=1 --max=10
```
A saída do comando anterior confirma que o Horizontal Pod Autoscaler foi criado.
```
horizontalpodautoscaler.autoscaling/php-apache autoscaled
```
O comando cria um Horizontal Pod Autoscaler para a implantação do servidor Web Apache que:
- Mantém no mínimo 1 e no máximo 10 réplicas dos pods criados anteriormente controlados pela implantação do servidor Web Apache.
- Aumenta e diminui o número de réplicas da implantação para manter uma utilização média de CPU de 50% entre todos os pods.
Se a utilização média de CPU ficar abaixo de 50%, o Horizontal Pod Autoscaler tentará reduzir o número de pods na implantação ao mínimo (nesse caso, 1). Se a utilização média de CPU ficar acima de 50%, o Horizontal Pod Autoscaler tentará aumentar o número de pods na implantação ao máximo (nesse caso, 10). Para obter mais informações, consulte Como o Horizontal Pod Autoscaler funciona? na documentação do Kubernetes.

Para obter mais informações sobre o comando kubectl autoscale, consulte dimensionamento automático na documentação do Kubernetes.
Após um minuto, confirme o status atual do Horizontal Pod Autoscaler digitando:
```
kubectl get hpa
```
A saída do comando acima mostra o status atual:
```
NAME       REFERENCE             TARGETS MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 0%/50%  1       10      1        10s
```
A coluna TARGETS mostra a utilização média de CPU entre todos os pods controlados pela implantação do servidor Web Apache. Como nenhuma solicitação está sendo enviada ao servidor, o exemplo anterior mostra que a utilização atual de CPU é 0%, em comparação com a utilização alvo de 50%. Observe que você pode ver números diferentes, dependendo de quanto tempo aguarda antes de executar o comando.

Etapa 4: Iniciar Geração de Carga de Amostra

Execute um contêiner com uma imagem busybox para criar uma carga para o servidor Web Apache digitando:
```
kubectl run -it --rm load-generator --image=busybox /bin/sh
```
Gere uma carga para o servidor Web Apache que fará com que o Horizontal Pod Autoscaler amplie a implantação digitando:
```
while true; do wget -q -O- http://php-apache; done
```

Etapa 5: Exibir a Operação de Dimensionamento

Depois de um minuto, abra uma nova janela de terminal e confirme o status atual do Horizontal Pod Autoscaler digitando:
```
kubectl get hpa
```
A saída do comando acima mostra o status atual:
```
NAME       REFERENCE             TARGETS  MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 250%/50% 1       10      1        1m
```
No exemplo anterior, você pode ver que a utilização atual de CPU aumentou para 250%, em comparação com a utilização alvo de 50%. Observe que você pode ver números diferentes, dependendo de quanto tempo aguarda antes de executar o comando.

Para atingir o alvo de utilização de 50%, o Horizontal Pod Autoscaler terá de aumentar o número de réplicas para ampliar a implantação.
Depois de mais alguns minutos, visualize o aumento do número de réplicas digitando novamente:
```
kubectl get hpa
```
A saída do comando acima mostra o status atual:
```
NAME       REFERENCE             TARGETS  MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 50%/50%  1       10      5        5m
```
No exemplo anterior, você pode ver que o Horizontal Pod Autoscaler redimensionou a implantação para 5 réplicas, e o alvo de utilização de 50% foi alcançado. Observe que você pode ver números diferentes, dependendo de quanto tempo aguarda antes de executar o comando.
Verifique se a implantação foi ampliada digitando:
```
kubectl get deployment php-apache
```
A saída do comando acima mostra o status atual:
```
NAME       READY UP-TO-DATE AVAILABLE AGE
php-apache 5/5   5          5         5m
```
Observe que você pode ver números diferentes, dependendo de quanto tempo aguarda antes de executar o comando.

Etapa 6: Interromper Geração de Carga de Amostra

Na janela do terminal em que você criou o contêiner com a imagem busybox e gerou a carga para o servidor Web Apache:
1. Encerre a geração de carga pressionando Ctrl+C
2. Feche o prompt de comando digitando:
```
exit
```
  A saída do comando acima confirma que a sessão foi encerrada:
```
Session ended, resume using 'kubectl attach load-generator -c load-generator -i -t' command when the pod is running
pod "load-generator" deleted
```
Após um minuto, confirme o status atual do Horizontal Pod Autoscaler digitando:
```
kubectl get hpa
```
A saída do comando acima mostra o status atual:
```
NAME       REFERENCE             TARGETS MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 0%/50%  1       10      5        10m
```
No exemplo anterior, você pode ver que a utilização atual da CPU foi reduzida para 0%, em comparação com a utilização alvo de 50%. No entanto, ainda há 5 réplicas na implantação. Observe que você pode ver números diferentes, dependendo de quanto tempo aguarda antes de executar o comando.
Após alguns minutos, veja o número reduzido de réplicas digitando novamente:
```
kubectl get hpa
```
A saída do comando acima mostra o status atual:
```
NAME       REFERENCE             TARGETS  MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 0%/50%   1       10      1        15m
```
No exemplo anterior, você pode ver que o Horizontal Pod Autoscaler redimensionou a implantação para 1 réplica.

Lembre-se de que levará tempo para que a contagem de réplicas seja reduzida para 1. Cinco minutos é o período padrão para a redução. Observe que você pode ver números diferentes, dependendo de quanto tempo aguarda antes de executar o comando.
Verifique se a implantação foi reduzida digitando:
```
kubectl get deployment php-apache
```
A saída do comando acima mostra o status atual:
```
NAME       READY UP-TO-DATE AVAILABLE AGE
php-apache 1/1   1          1         15m
```
Observe que você pode ver números diferentes, dependendo de quanto tempo aguarda antes de executar o comando.

Etapa 7: Limpar

Exclua o Horizontal Pod Autoscaler digitando:
```
kubectl delete horizontalpodautoscaler.autoscaling/php-apache
```
Observe que quando você exclui um Horizontal Pod Autoscaler, o número de réplicas permanece o mesmo. Uma implantação não é revertida automaticamente para o estado anterior à criação do Horizontal Pod Autoscaler.

Exclua a implantação do servidor Web Apache digitando:

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

Documentação do Oracle Cloud Infrastructure