Pular para o conteúdo

Diagrama de autoscaling do Kubernetes: HPA, VPA, KEDA, Cluster Autoscaler e Karpenter

Os loops de autoscaling do Kubernetes em um diagrama: o que HPA, VPA, KEDA, Cluster Autoscaler e Karpenter observam, com que frequência agem e como evitar que briguem.

· Fundador e desenvolvedor

Publicado em

Uma fila orders alimenta o KEDA, que escala um Deployment worker. O metrics-server alimenta um HPA que escala um Deployment api e um VPA que define seus requests de memória. Um pod Pending vai para o Cluster Autoscaler ou o Karpenter, que chamam a API da nuvem, e um novo nó entra.

O tráfego dobra às 9:00. Em cerca de 30 segundos, o HorizontalPodAutoscaler pede mais seis réplicas da API. Quatro iniciam; duas ficam Pending, porque nenhum nó tem espaço para os requests de CPU delas. O autoscaler de nós pede uma máquina à nuvem, e as duas últimas iniciam depois que ela dá boot e entra no cluster.

Aquela manhã rodou em vários loops de controle, cada um com sua própria entrada e seu próprio relógio. Bem ajustados, ninguém os percebe. Com requests errados, ou dois autoscalers em desacordo, você acaba com pods despejados em loop ou nós que nunca reduzem.

Este post cobre cada loop com seus padrões atuais (Kubernetes 1.37), os pontos onde os loops brigam e um diagrama que mostra todos eles.

Os loops de autoscaling em resumo

Loop Altera Observa Período padrão
HorizontalPodAutoscaler (HPA) Número de réplicas Métricas resource, custom e external 15 s
VerticalPodAutoscaler (VPA) Requests de CPU e memória Histórico de uso 1 min
KEDA Número de réplicas, até zero Fontes de eventos como o tamanho de uma fila Polling a cada 30 s
Cluster Autoscaler Tamanho do grupo de nós Pods não agendáveis Varredura a cada 10 s
Karpenter Nós individuais Pods não agendáveis, custo dos nós Lotes de 1 a 10 s

Os pods conectam as camadas, e os requests são a moeda: o scheduler e os dois autoscalers de nós decidem com base na CPU e na memória solicitadas, não no uso real, como a documentação do Kubernetes sobre autoscaling de nós ressalta.

HPA: réplicas a partir de métricas

O controlador do HPA roda no kube-controller-manager e recalcula a cada 15 segundos. CPU e memória vêm de metrics.k8s.io, servido pelo metrics-server, que consulta cada kubelet a cada 15 segundos. Essa API ficou estável como v1 no Kubernetes 1.37, mas o HPA ainda lê v1beta1. Outras métricas chegam por adaptadores para o seu pipeline de métricas: custom.metrics.k8s.io para valores como requisições por segundo, external.metrics.k8s.io para valores fora do cluster, como uma fila na nuvem. A referência do HPA documenta a fórmula:

desiredReplicas = ceil(currentReplicas × currentMetricValue / desiredMetricValue)

Com 4 réplicas a 90% de CPU e uma meta de 60%, o HPA pede ceil(4 × 90 / 60) = 6. A 64%, ele não faz nada: a razão de 1,07 está dentro da tolerância padrão de 10%. A utilização é relativa aos requests, então um container sem request de CPU deixa o HPA sem condições de agir sobre CPU. Com várias métricas, vence o maior resultado.

Configuração Padrão
Período de sincronização 15 s
Tolerância 10%; um campo por HPA é estável desde a 1.37
Estabilização do scale-down 300 s, usando a maior recomendação dessa janela
Limite do scale-up 100% ou 4 pods por 15 s, o que for maior
Período de inicialização da CPU 5 min; a CPU de pods ainda não prontos é ignorada

O scale-to-zero está em beta e habilitado por padrão na 1.37: com uma métrica object ou external você pode definir minReplicas: 0, como explica o anúncio da versão. CPU e memória não conseguem acordar uma carga de trabalho a partir de zero, porque são medidas em pods em execução.

spec:
  minReplicas: 3
  maxReplicas: 30
  metrics:
  - type: Resource
    resource:
      name: cpu
      target: {type: Utilization, averageUtilization: 60}
  behavior:
    scaleUp:
      tolerance: 0.05
    scaleDown:
      stabilizationWindowSeconds: 300

VPA: requests a partir do histórico de uso

O VPA é um complemento do projeto Kubernetes autoscaler, cuja linha de versões atual é a 1.8. Ele tem três componentes:

  1. O recommender calcula uma meta, um limite inferior e um limite superior por container a cada minuto. A memória acompanha os picos de 8 dias; o histórico de CPU perde metade do peso a cada 24 horas.
  2. O updater verifica os pods a cada minuto e despeja ou redimensiona os que estão fora dos limites, respeitando os PodDisruptionBudgets.
  3. O admission controller, um mutating webhook, grava os requests recomendados nos novos pods.
Modo de atualização Efeito
Off Apenas recomendações
Initial Requests definidos apenas na criação do pod
Recreate Pods despejados e recriados
InPlaceOrRecreate Redimensionados no lugar, despejados se falhar
InPlace Redimensionados apenas no lugar; alfa no VPA 1.7
Auto Alias obsoleto de Recreate

O redimensionamento de pods no lugar é estável desde o Kubernetes 1.35, e o InPlaceOrRecreate está em disponibilidade geral desde o VPA 1.6. O updater ainda despeja quando um redimensionamento é inviável ou fica adiado por mais de cinco minutos. Rode Off por uma semana e compare as recomendações com seus requests antes de habilitar as atualizações. O VPA ainda não oferece suporte a cargas de trabalho com resources no nível do pod; a referência do VPA cobre o resto.

Cluster Autoscaler vs Karpenter

Ambos reagem a pods que o scheduler marcou como não agendáveis, e ambos simulam o agendamento com requests, não com o uso dos nós.

O Cluster Autoscaler aumenta grupos de nós que você define com antecedência, como os Auto Scaling groups da AWS. A cada 10 segundos ele testa os pods não agendáveis em um nó modelo de cada grupo, escolhe um grupo com um expander (least-waste por padrão) e pede à nuvem que o aumente; a FAQ dele mira menos de 30 segundos para isso em clusters com menos de 100 nós. Um nó cujos pods solicitam menos de 50% da CPU e da memória alocáveis, e que poderiam ir para outro lugar, é removido após 10 minutos. PodDisruptionBudgets restritivos, armazenamento local e pods anotados com safe-to-evict: "false" impedem isso.

O Karpenter não tem grupos de nós. Um NodePool define restrições como famílias de instâncias, zonas e limites; um NodeClass guarda as configurações da nuvem. O Karpenter agrupa os pods pendentes por 1 a 10 segundos, faz o bin-packing deles e lança instâncias diretamente, na AWS oferecendo ao EC2 Fleet até 60 tipos de instância. A documentação de disrupção dele cobre a remoção: a consolidação exclui ou substitui nós subutilizados (WhenEmptyOrUnderutilized por padrão), nós com drift são substituídos, e budgets limitam ambos a 10% dos nós de um NodePool por padrão. Os nós também expiram após 720 horas.

Cluster Autoscaler Karpenter
Unidade de escalonamento Grupos de nós predefinidos Nós individuais, escolhidos por lote
Tipos de instância Fixos por grupo Qualquer tipo que o NodePool permita
Remoção de nós Menos de 50% solicitado por 10 minutos Consolidação e drift dentro de budgets, mais expiração
Provedores de nuvem Muitos Menos, entre eles AWS e Azure

No momento da escrita (novembro de 2026), o EKS Auto Mode é construído sobre o Karpenter, o AKS node auto-provisioning executa o Karpenter para você, e o GKE gerencia o próprio cluster autoscaler. Rode um autoscaler de nós por conjunto de nós; o guia de migração do Karpenter reduz o Cluster Autoscaler a zero réplicas.

KEDA: filas e scale-to-zero

O KEDA, um projeto CNCF graduated, adiciona escalonamento orientado a eventos com mais de 70 scalers: lag de consumidores nas partições do Kafka, tamanho de fila do RabbitMQ ou SQS, consultas do Prometheus, cron. Um ScaledObject aponta para um Deployment. O operador do KEDA cuida sozinho de 0 para 1 e da volta, fazendo polling a cada 30 segundos e escalando a zero após um cooldown de 300 segundos. De 1 a N ele gerencia um HPA e o alimenta pela API de external metrics, como descreve a referência do ScaledObject.

apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: worker
spec:
  scaleTargetRef:
    name: worker
  minReplicaCount: 0
  maxReplicaCount: 50
  triggers:
  - type: rabbitmq
    metadata:
      queueName: orders
      mode: QueueLength
      value: "20"
      hostFromEnv: RABBITMQ_HOST

O scale-to-zero custa um cold start, o que combina com uma fila durável. HTTP precisa de uma camada de buffer, porque os Services não seguram requisições enquanto nenhum pod está pronto. Com o scale-to-zero do HPA em beta, um HPA sobre uma métrica external agora pode chegar a zero sozinho, mas o KEDA ainda traz os scalers, a autenticação de triggers e os ScaledJobs para trabalho em lote. O diagrama de arquitetura orientada a eventos mostra as filas ao redor desses workers.

Como os loops interagem e onde brigam

  • HPA e VPA na mesma métrica. O VPA aumenta os requests de CPU, a utilização cai, o HPA remove réplicas, os pods restantes trabalham mais quentes, e o VPA aumenta os requests de novo. Combine um HPA em CPU com um VPA limitado à memória (controlledResources: ["memory"]), ou escale com métricas custom.
  • KEDA mais o seu próprio HPA. Dois controladores escreveriam o mesmo número de réplicas. Transfira um HPA existente com a annotation transfer-hpa-ownership do KEDA.
  • VPA em DaemonSets. Ele estraga a previsão dos autoscalers de nós sobre o que um novo nó vai executar; a documentação do Kubernetes desaconselha.
  • Requests errados. Baixos demais, e novos nós não ajudam; altos demais, e os nós nunca parecem subutilizados.

O tempo também importa. Um pico de CPU chega a uma decisão após até 15 segundos para a próxima coleta mais 15 para a próxima sincronização do HPA. Pods que não cabem esperam até mais 10 segundos por uma varredura do Cluster Autoscaler, ou de 1 a 10 pelo lote do Karpenter. Depois a VM dá boot: a AWS diz que o Karpenter lança capacidade em menos de um minuto; a FAQ do Cluster Autoscaler cita de três a quatro minutos no Google Compute Engine. Para ter folga mais rápido, rode pods de reserva de baixa prioridade que os pods reais preemptam, como essa FAQ descreve.

O diagrama de autoscaling do Kubernetes

Uma fila orders alimenta o KEDA, que escala um Deployment worker. O metrics-server alimenta um HPA que escala um Deployment api e um VPA que define seus requests de memória. Um pod Pending vai para o Cluster Autoscaler ou o Karpenter, que chamam a API da nuvem, e um novo nó entra.

21 componentes · 13 conexões

Abrir no Archboard
Conteúdo do diagrama
  • orders queue
  • KEDA
  • worker
  • new pod
  • metrics-server
  • HPA: api
  • api
  • VPA: api memory
  • Cluster Autoscaler
  • Karpenter
  • Cloud provider API
  • New node
  • queue length
  • replicas 0–N
  • CPU usage
  • replicas
  • memory usage
  • memory requests
  • new replica
  • Unschedulable
  • resize node group
  • launch instances
  • VM joins
Os loops de autoscaling de um cluster. O HPA define as réplicas pela CPU a cada 15 segundos, o VPA define os requests de memória, o KEDA escala um worker pelo tamanho da fila, e um pod Pending passa para o Cluster Autoscaler ou o Karpenter, que pedem um nó à nuvem.

Como ler:

  • Linha de cima, verde-azulado: o KEDA lê a fila orders e escala o Deployment worker entre zero e N réplicas.
  • Linha do meio, azul: o HPA escala o Deployment api pelo uso de CPU a cada 15 segundos.
  • Embaixo, roxo: o VPA define apenas os requests de memória em api, então nunca compete com o HPA.
  • Centro: uma réplica que não cabe em nenhum nó fica Pending. A camada de nós reage a esse pod, não à CPU.
  • Direita, âmbar: o Cluster Autoscaler redimensiona um grupo de nós, ou o Karpenter lança instâncias, pela API da nuvem, e a nova VM entra. O bloco Markdown lista os padrões.

Desenhando diagramas de autoscaling com clareza

  • Um loop, uma linha. O sinal entra no controlador; o que ele altera sai dele.
  • Escreva o período ao lado de cada controlador. Ele responde à maioria das perguntas de «por que não escalou».
  • Nomeie o recurso que cada autoscaler controla, para que um HPA e um VPA na mesma carga de trabalho visivelmente não se sobreponham.
  • Desenhe o pod Pending. Ele é a passagem de bastão entre a camada de pods e a camada de nós.
  • Deixe de fora: réplicas individuais, kubelets e scalers extras.

Erros comuns são uma seta do HPA direto para os nós, os dois autoscalers de nós desenhados como se rodassem juntos, e nenhuma menção aos requests. Para o cluster em volta dos loops, veja como desenhar um diagrama de arquitetura do Kubernetes.

Monte no Archboard

  1. Entre com Google ou GitHub e crie um diagrama.
  2. No pacote Kubernetes, adicione dois nós Deployment, worker e api, mais um HPA e um VPA para api. Defina o modo de atualização do VPA como InPlaceOrRecreate.
  3. Adicione um nó Métricas do pacote DevOps para o metrics-server e uma Fila do pacote Dados.
  4. Adicione um Recurso personalizado do pacote Kubernetes com o kind ScaledObject para o KEDA, e um Pod com fase Pending entre os Deployments.
  5. Para a camada de nós, adicione um Deployment para o Cluster Autoscaler, um Recurso personalizado com o kind NodePool para o Karpenter, um Recurso de nuvem do pacote Nuvem para a API da nuvem, e um Node.
  6. Conecte-os com arestas rotuladas (CPU usage, replicas, Unschedulable e assim por diante), dê uma cor a cada loop e adicione um rótulo Texto do pacote Básico com o período.
  7. Adicione um bloco Markdown do pacote Básico com os padrões.

A ferramenta de YAML do Kubernetes para diagrama transforma manifestos existentes em um primeiro rascunho das cargas de trabalho; um método repetível para transformar YAML em um diagrama legível mostra a limpeza. Mais na página do caso de uso Kubernetes.

O exemplo usa 13 nós de diagrama e fica dentro do plano Free.

Perguntas frequentes

Qual é a diferença entre HPA e VPA? O HPA muda quantos pods rodam, com base em métricas como a utilização de CPU. O VPA muda os requests de CPU e memória de cada pod, com base no histórico de uso.

Posso usar HPA e VPA juntos? Sim, se agirem em métricas diferentes: HPA em CPU com VPA limitado à memória, ou HPA em métricas custom ou external com VPA em ambas.

Devo usar Cluster Autoscaler ou Karpenter? Karpenter, se a sua nuvem oferecer suporte e você quiser que ele escolha os tipos de instância e substitua nós por outros mais baratos. Cluster Autoscaler para outros provedores e grupos de nós fixos. Nunca os dois nos mesmos nós.

O Kubernetes pode escalar um deployment a zero? Sim, com o KEDA, ou com o scale-to-zero do HPA, em beta e habilitado por padrão desde o Kubernetes 1.37. Ambos precisam de uma métrica que exista sem pods em execução, como o tamanho de uma fila.

Por que meu HPA mostra metas de CPU desconhecidas? Normalmente o metrics-server está ausente, ou um container não tem request de CPU, então a utilização não pode ser calculada. Execute kubectl describe hpa para ver o erro.

Comece grátis — um assento, sem cartão de crédito.

Artigos relacionados

← Voltar ao blog

Abra um canvas em um minuto

Entre com Google ou GitHub. Grátis para um assento. Faça upgrade quando a equipe entrar.