Usando HorizontalPodAutoscaler no Kubernetes

Introdução

O HorizontalPodAutoscaler (HPA) é um recurso do Kubernetes que permite escalar automaticamente o número de pods em um deployment com base na utilização de recursos. Neste laboratório, aprenderemos como usar o HorizontalPodAutoscaler para escalar automaticamente nosso deployment.

Iniciar o Cluster Minikube

Antes de criar recursos, você precisa de um cluster Kubernetes em execução. Minikube é um ambiente Kubernetes leve que roda em sua máquina local.

1. Navegue para o seu diretório de trabalho:

   Abra o terminal e navegue até a pasta do projeto padrão:

   cd /home/labex/project

2. Iniciar o Minikube:

   Inicie o Minikube para inicializar um cluster Kubernetes:

   minikube start

   • Este comando configura um cluster Kubernetes de nó único em sua máquina local.
   • O Minikube pode levar alguns minutos para iniciar, dependendo do desempenho do seu sistema.

3. Verifique se o Minikube está em execução:

   Verifique o status do cluster Minikube:

   minikube status

   • Procure por componentes como kubelet e apiserver listados como Running (Em execução).
   • Se o cluster não estiver em execução, execute novamente minikube start.

Se você encontrar problemas ao iniciar o Minikube. Use minikube delete para redefinir o ambiente, se necessário.

Criar um Deployment

Primeiro, precisamos criar um deployment ao qual aplicaremos o HorizontalPodAutoscaler.

1. Crie um arquivo de deployment chamado deployment.yaml com o seguinte conteúdo:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hpa-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: hpa-demo
  template:
    metadata:
      labels:
        app: hpa-demo
    spec:
      containers:
        - name: hpa-demo
          image: nginx
          resources:
            limits:
              cpu: "1"
              memory: 512Mi
            requests:
              cpu: "0.5"
              memory: 256Mi
---
apiVersion: v1
kind: Service
metadata:
  name: hpa-demo
spec:
  selector:
    app: hpa-demo
  ports:
    - name: http
      port: 80
      targetPort: 80

Este deployment especifica uma única réplica de um container Nginx com limites e requests de recursos para CPU e memória.

2. Crie o deployment:

kubectl apply -f deployment.yaml

Criar um HorizontalPodAutoscaler

Agora que temos um deployment, podemos criar um HorizontalPodAutoscaler para escalar automaticamente o deployment.

1. Crie um arquivo HorizontalPodAutoscaler chamado hpa.yaml com o seguinte conteúdo:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: hpa-demo
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: hpa-demo
  minReplicas: 1
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          averageUtilization: 1
          type: Utilization

Este HorizontalPodAutoscaler especifica que queremos escalar o deployment hpa-demo para ter entre 1 e 10 réplicas, e que queremos ter como alvo uma utilização média de CPU de 50%.

2. Crie o HorizontalPodAutoscaler:

kubectl apply -f hpa.yaml

Testar o HorizontalPodAutoscaler

Agora que temos um HorizontalPodAutoscaler, podemos testá-lo gerando carga no deployment.

1. Habilite o metrice-server:

minikube addons enable metrics-server

2. Crie um pod de geração de carga:

kubectl run -i --tty load-generator --image=busybox /bin/sh

3. No pod de geração de carga, execute o seguinte comando para gerar carga no deployment:

while true; do wget -q -O- http://hpa-demo; done

4. Abra outro terminal e verifique o status do HorizontalPodAutoscaler:

kubectl get hpa

Você pode ver que o número de cópias de hpa-demo foi estendido para 10. Você pode verificar o número de réplicas com o seguinte comando.

kubectl get pods -l app=hpa-demo

5. Pare a geração de carga digitando ctrl+c no pod de geração de carga.

Resumo

Neste laboratório, aprendemos como usar o HorizontalPodAutoscaler para escalar automaticamente um deployment com base na utilização de recursos. Criamos um deployment, criamos um HorizontalPodAutoscaler e o testamos gerando carga no deployment. Também vimos como o HorizontalPodAutoscaler escalou o deployment em resposta ao aumento da carga.