Kubernetes Performance: Horizontal Pod Autoscaling (HPA)

Introdução

Manter o desempenho de aplicações em um cluster Kubernetes é um desafio crucial para administradores e desenvolvedores. Uma das abordagens mais eficientes para gerenciar esse desempenho é ajustar dinamicamente os recursos das aplicações conforme a demanda. O Horizontal Pod Autoscaling (HPA) é uma funcionalidade do Kubernetes projetada para escalonar automaticamente o número de Pods com base em métricas como uso de CPU, memória ou métricas personalizadas.

Este capítulo aborda os conceitos, configuração e uso prático do HPA. Também discutiremos casos de uso e ofereceremos exercícios para fortalecer o aprendizado.

Conceitos Básicos

Horizontal Pod Autoscaler (HPA)

O HPA ajusta automaticamente o número de Pods em um Deployment, ReplicaSet ou StatefulSet com base em métricas observadas. Ele monitora continuamente o estado da aplicação e escala os Pods para cima (mais Pods) ou para baixo (menos Pods), dependendo do uso dos recursos.

Métricas Comuns para o HPA

1. Uso de CPU:

   • O HPA pode monitorar a porcentagem de utilização da CPU nos Pods e escalonar quando o valor observado ultrapassa ou fica abaixo de um limite predefinido.

2. Uso de Memória:

   • Similar à CPU, a memória usada pelos Pods pode ser monitorada e usada como base para escalonamento.

3. Métricas Personalizadas:

   • Métricas específicas da aplicação, como latência, número de requisições por segundo ou outros indicadores de desempenho, podem ser configuradas usando o Prometheus Adapter ou ferramentas semelhantes para integrar métricas ao Kubernetes.

Diferença entre HPA e VPA

• Horizontal Pod Autoscaler (HPA):

  • Escalona o número de Pods.
  • É ideal para workloads distribuídas que podem ser divididas em vários Pods para lidar com altas demandas.
  • Evita downtime, pois o escalonamento horizontal geralmente não causa reinicialização dos Pods existentes.

• Vertical Pod Autoscaler (VPA):

  • Ajusta os recursos (CPU e memória) alocados a cada Pod individual.
  • Indicado para workloads que não podem ser divididas em múltiplos Pods, como bancos de dados monolíticos.
  • Pode causar reinicializações frequentes dos Pods quando aplica novas configurações, o que pode impactar a disponibilidade da aplicação.

A escolha entre HPA e VPA depende dos requisitos da aplicação e do ambiente. Em muitos casos, ambas as soluções podem ser usadas em conjunto para otimizar o desempenho e a utilização de recursos.

Configurando o HPA

1. Pré-requisitos

• Cluster Kubernetes configurado (v1.18 ou superior).
• kubectl configurado para acessar o cluster.
• O Metric Server instalado no cluster para fornecer as métricas necessárias ao HPA. (Use o comando kubectl get apiservices para verificar se o Metric Server está ativo.)

Instalando o Metric Server (se não estiver instalado):

kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

2. Criando um Deployment de exemplo

Vamos criar um Deployment simples com uma aplicação de exemplo que responde a requisições HTTP:

Arquivo YAML do Deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: php-apache
  labels:
    app: php-apache
spec:
  replicas: 1
  selector:
    matchLabels:
      app: php-apache
  template:
    metadata:
      labels:
        app: php-apache
    spec:
      containers:
      - name: php-apache
        image: k8s.gcr.io/hpa-example
        ports:
        - containerPort: 80
        resources:
          requests:
            cpu: 200m
          limits:
            cpu: 500m

Aplicando o Deployment:

kubectl apply -f deployment.yaml

3. Criando o HPA

Vamos configurar o HPA para ajustar o número de Pods com base no uso de CPU.

Arquivo YAML do HPA:

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

Aplicando o HPA:

kubectl apply -f hpa.yaml

Demonstração Prática

1. Gerar carga na aplicação: Use o seguinte comando para simular tráfego e aumentar o uso de CPU:

   kubectl run -i --tty load-generator --image=busybox -- /bin/sh -c "while true; do wget -q -O- http://php-apache.default.svc.cluster.local; done"
   

2. Monitorar o HPA: Verifique o comportamento do HPA:

   kubectl get hpa
   

3. Verificar os Pods: Observe o número de Pods sendo ajustado:

   kubectl get pods
   

Casos de Uso

• E-commerce: Escalonamento automático de serviços durante eventos de alta demanda, como Black Friday.
• Streaming de vídeo: Ajustar recursos com base no número de usuários conectados.
• Sistemas SaaS: Garantir alta disponibilidade e desempenho em métricas de uso dinâmico.

Exercícios Práticos

1. Configuração de HPA com métricas personalizadas:

   • Use o Prometheus Adapter para configurar métricas personalizadas no HPA.

2. Análise de logs e métricas:

   • Use o Grafana para monitorar o comportamento do HPA e entender como as métricas influenciam o escalonamento.

3. Teste de limites:

   • Configure o HPA para um limite máximo de 5 Pods e teste como a aplicação se comporta sob carga.

Conclusão

O Horizontal Pod Autoscaler é uma ferramenta essencial para administrar workloads dinâmicas no Kubernetes. Ele permite que clusters mantenham a performance e a escalabilidade, economizando recursos e garantindo uma experiência consistente para os usuários finais.

Pratique os exercícios deste capítulo para dominar o uso do HPA e esteja preparado para implementar soluções robustas e escaláveis em ambientes Kubernetes.