Saltar al contenido

Diagrama de autoescalado de Kubernetes: HPA, VPA, KEDA, Cluster Autoscaler y Karpenter

Los bucles de autoescalado de Kubernetes en un diagrama: qué vigilan HPA, VPA, KEDA, Cluster Autoscaler y Karpenter, cuándo actúan y cómo evitar que choquen.

· Fundador y desarrollador

Publicado el

Una cola orders alimenta a KEDA, que escala un Deployment worker. metrics-server alimenta un HPA que escala un Deployment api y un VPA que fija sus requests de memoria. Un pod Pending va a Cluster Autoscaler o Karpenter, que llaman a la API de la nube, y se une un nodo nuevo.

El tráfico se duplica a las 9:00. En unos 30 segundos, el HorizontalPodAutoscaler pide seis réplicas más de la API. Cuatro arrancan; dos se quedan en Pending, porque ningún nodo tiene hueco para sus requests de CPU. El autoescalador de nodos pide una máquina a la nube, y las dos últimas arrancan cuando esta ha iniciado y se ha unido al clúster.

Esa mañana funcionó con varios bucles de control, cada uno con su propia entrada y su propio reloj. Bien ajustados, nadie los nota. Con requests incorrectos, o con dos autoescaladores en desacuerdo, acabas con pods desalojados en bucle o nodos que nunca se reducen.

Este artículo repasa cada bucle con sus valores por defecto actuales (Kubernetes 1.37), los puntos donde los bucles se pelean y un diagrama que los muestra todos.

Los bucles de autoescalado de un vistazo

Bucle Cambia Vigila Periodo por defecto
HorizontalPodAutoscaler (HPA) Número de réplicas Métricas resource, custom y external 15 s
VerticalPodAutoscaler (VPA) Requests de CPU y memoria Historial de uso 1 min
KEDA Número de réplicas, hasta cero Fuentes de eventos como la longitud de una cola Sondeo cada 30 s
Cluster Autoscaler Tamaño del grupo de nodos Pods no planificables Análisis cada 10 s
Karpenter Nodos individuales Pods no planificables, coste de los nodos Lotes de 1 a 10 s

Los pods conectan las capas, y los requests son la moneda: el scheduler y los dos autoescaladores de nodos deciden según la CPU y la memoria solicitadas, no según el uso real, como subraya la documentación de Kubernetes sobre autoescalado de nodos.

HPA: réplicas a partir de métricas

El controlador del HPA se ejecuta en kube-controller-manager y recalcula cada 15 segundos. La CPU y la memoria vienen de metrics.k8s.io, servido por metrics-server, que consulta cada kubelet cada 15 segundos. Esa API pasó a ser estable como v1 en Kubernetes 1.37, pero el HPA sigue leyendo v1beta1. Otras métricas llegan mediante adaptadores para tu pipeline de métricas: custom.metrics.k8s.io para valores como las peticiones por segundo, external.metrics.k8s.io para valores externos al clúster como una cola en la nube. La referencia del HPA documenta la fórmula:

desiredReplicas = ceil(currentReplicas × currentMetricValue / desiredMetricValue)

Con 4 réplicas al 90 % de CPU y un objetivo del 60 %, el HPA pide ceil(4 × 90 / 60) = 6. Al 64 % no hace nada: la proporción de 1,07 está dentro de la tolerancia por defecto del 10 %. La utilización es relativa a los requests, así que un contenedor sin request de CPU impide que el HPA actúe sobre la CPU. Con varias métricas, gana el resultado más grande.

Ajuste Valor por defecto
Periodo de sincronización 15 s
Tolerancia 10 %; un campo por HPA es estable desde 1.37
Estabilización del scale-down 300 s, usando la recomendación más alta de esa ventana
Límite del scale-up 100 % o 4 pods cada 15 s, lo que sea mayor
Periodo de inicialización de CPU 5 min; se ignora la CPU de los pods que aún no están listos

El scale-to-zero está en beta y activado por defecto en 1.37: con una métrica object o external puedes definir minReplicas: 0, como explica el anuncio de la versión. La CPU y la memoria no pueden despertar una carga de trabajo desde cero, porque se miden en pods en ejecución.

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 del historial de uso

El VPA es un complemento del proyecto Kubernetes autoscaler, cuya línea de versiones actual es la 1.8. Tiene tres componentes:

  1. El recommender calcula un objetivo, un límite inferior y un límite superior por contenedor cada minuto. La memoria sigue los picos de 8 días; el historial de CPU pierde la mitad de su peso cada 24 horas.
  2. El updater revisa los pods cada minuto y desaloja o redimensiona los que quedan fuera de los límites, respetando los PodDisruptionBudgets.
  3. El admission controller, un mutating webhook, escribe los requests recomendados en los pods nuevos.
Modo de actualización Efecto
Off Solo recomendaciones
Initial Requests fijados solo al crear el pod
Recreate Pods desalojados y recreados
InPlaceOrRecreate Redimensionados in situ, desalojados si falla
InPlace Redimensionados solo in situ; alfa en VPA 1.7
Auto Alias obsoleto de Recreate

El redimensionado de pods in situ es estable desde Kubernetes 1.35, y InPlaceOrRecreate está en disponibilidad general desde VPA 1.6. El updater sigue desalojando cuando un redimensionado no es viable o queda aplazado más de cinco minutos. Ejecuta Off durante una semana y compara las recomendaciones con tus requests antes de activar las actualizaciones. El VPA aún no admite cargas de trabajo con resources a nivel de pod; la referencia del VPA cubre el resto.

Cluster Autoscaler frente a Karpenter

Ambos reaccionan a los pods que el scheduler marcó como no planificables, y ambos simulan la planificación con requests, no con el uso de los nodos.

Cluster Autoscaler hace crecer grupos de nodos que defines de antemano, como los Auto Scaling groups de AWS. Cada 10 segundos prueba los pods no planificables en un nodo plantilla de cada grupo, elige un grupo con un expander (least-waste por defecto) y pide a la nube que lo haga crecer; su FAQ se marca menos de 30 segundos para eso en clústeres de menos de 100 nodos. Un nodo cuyos pods solicitan menos del 50 % de su CPU y memoria asignables, y que podrían moverse a otro sitio, se elimina tras 10 minutos. PodDisruptionBudgets restrictivos, almacenamiento local y pods anotados con safe-to-evict: "false" lo impiden.

Karpenter no tiene grupos de nodos. Un NodePool fija restricciones como familias de instancias, zonas y límites; un NodeClass guarda los ajustes de la nube. Karpenter agrupa los pods pendientes durante 1 a 10 segundos, los empaqueta con bin-packing y lanza instancias directamente, en AWS ofreciendo a EC2 Fleet hasta 60 tipos de instancia. Sus docs de disrupción cubren la eliminación: la consolidación borra o reemplaza nodos infrautilizados (WhenEmptyOrUnderutilized por defecto), los nodos con drift se reemplazan, y los presupuestos limitan ambos al 10 % de los nodos de un NodePool por defecto. Los nodos también caducan a las 720 horas.

Cluster Autoscaler Karpenter
Unidad de escalado Grupos de nodos predefinidos Nodos individuales, elegidos por lote
Tipos de instancia Fijos por grupo Cualquier tipo que permita el NodePool
Eliminar nodos Menos del 50 % solicitado durante 10 minutos Consolidación y drift dentro de presupuestos, más caducidad
Proveedores de nube Muchos Menos, entre ellos AWS y Azure

En el momento de escribir esto (noviembre de 2026), EKS Auto Mode se basa en Karpenter, AKS node auto-provisioning ejecuta Karpenter por ti, y GKE gestiona su propio cluster autoscaler. Ejecuta un autoescalador de nodos por conjunto de nodos; la guía de migración de Karpenter lleva Cluster Autoscaler a cero réplicas.

KEDA: colas y scale-to-zero

KEDA, un proyecto CNCF graduated, añade escalado orientado a eventos con más de 70 scalers: lag de consumidores en particiones de Kafka, longitud de cola de RabbitMQ o SQS, consultas de Prometheus, cron. Un ScaledObject apunta a un Deployment. El operador de KEDA gestiona por sí mismo el paso de 0 a 1 y la vuelta, sondeando cada 30 segundos y escalando a cero tras un cooldown de 300 segundos. De 1 a N gestiona un HPA y lo alimenta mediante la API de external metrics, como describe la referencia de 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

El scale-to-zero cuesta un arranque en frío, lo que encaja con una cola duradera. Para HTTP hace falta una capa de búfer, porque los Services no retienen peticiones mientras no haya ningún pod listo. Con el scale-to-zero del HPA en beta, un HPA sobre una métrica external ya puede llegar a cero por sí solo, pero KEDA sigue aportando los scalers, la autenticación de triggers y los ScaledJobs para trabajo por lotes. El diagrama de arquitectura orientada a eventos muestra las colas alrededor de esos workers.

Cómo interactúan los bucles y dónde se pelean

  • HPA y VPA sobre una misma métrica. El VPA sube los requests de CPU, la utilización baja, el HPA quita réplicas, los pods restantes trabajan más calientes y el VPA vuelve a subir los requests. Combina un HPA sobre CPU con un VPA limitado a memoria (controlledResources: ["memory"]), o escala con métricas custom.
  • KEDA más tu propio HPA. Dos controladores escribirían un mismo número de réplicas. Cede un HPA existente con la anotación transfer-hpa-ownership de KEDA.
  • VPA sobre DaemonSets. Estropea la predicción de los autoescaladores de nodos sobre lo que ejecutará un nodo nuevo; la documentación de Kubernetes lo desaconseja.
  • Requests incorrectos. Demasiado bajos, y los nodos nuevos no ayudan; demasiado altos, y los nodos nunca parecen infrautilizados.

El tiempo también importa. Un pico de CPU llega a una decisión tras hasta 15 segundos para la siguiente recogida más 15 para la siguiente sincronización del HPA. Los pods que no caben esperan hasta 10 segundos más a un análisis de Cluster Autoscaler, o de 1 a 10 al lote de Karpenter. Luego arranca la VM: AWS dice que Karpenter lanza capacidad en menos de un minuto; la FAQ de Cluster Autoscaler cita de tres a cuatro minutos en Google Compute Engine. Para tener margen más rápido, ejecuta pods marcadores de baja prioridad que los pods reales desplazan, como describe esa FAQ.

El diagrama de autoescalado de Kubernetes

Una cola orders alimenta a KEDA, que escala un Deployment worker. metrics-server alimenta un HPA que escala un Deployment api y un VPA que fija sus requests de memoria. Un pod Pending va a Cluster Autoscaler o Karpenter, que llaman a la API de la nube, y se une un nodo nuevo.

21 componentes · 13 conexiones

Abrir en Archboard
Contenido del 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
Los bucles de autoescalado de un clúster. El HPA fija las réplicas según la CPU cada 15 segundos, el VPA fija los requests de memoria, KEDA escala un worker según la longitud de una cola, y un pod Pending pasa a Cluster Autoscaler o Karpenter, que piden un nodo a la nube.

Cómo leerlo:

  • Fila superior, turquesa: KEDA lee la cola orders y escala el Deployment worker entre cero y N réplicas.
  • Fila central, azul: el HPA escala el Deployment api según el uso de CPU cada 15 segundos.
  • Abajo, morado: el VPA fija solo los requests de memoria en api, así que nunca compite con el HPA.
  • Centro: una réplica que no cabe en ningún nodo se queda en Pending. La capa de nodos reacciona a ese pod, no a la CPU.
  • Derecha, ámbar: Cluster Autoscaler redimensiona un grupo de nodos, o Karpenter lanza instancias, a través de la API de la nube, y la nueva VM se une. El bloque Markdown lista los valores por defecto.

Cómo dibujar diagramas de autoescalado con claridad

  • Un bucle, una línea. La señal entra en el controlador; lo que cambia sale de él.
  • Escribe el periodo junto a cada controlador. Responde a la mayoría de las preguntas de «por qué no escaló».
  • Nombra el recurso que posee cada autoescalador, para que un HPA y un VPA sobre una misma carga de trabajo se vea que no se solapan.
  • Dibuja el pod Pending. Es el traspaso entre la capa de pods y la capa de nodos.
  • Deja fuera: las réplicas individuales, los kubelets y los scalers adicionales.

Los errores comunes son una flecha del HPA directamente a los nodos, los dos autoescaladores de nodos dibujados como si funcionaran juntos, y no mencionar los requests. Para el clúster alrededor de los bucles, consulta cómo dibujar un diagrama de arquitectura de Kubernetes.

Constrúyelo en Archboard

  1. Inicia sesión con Google o GitHub y crea un diagrama.
  2. Del paquete Kubernetes, añade dos nodos Deployment, worker y api, además de un HPA y un VPA para api. Fija el modo de actualización del VPA en InPlaceOrRecreate.
  3. Añade un nodo Métricas del paquete DevOps para metrics-server y una Cola del paquete Datos.
  4. Añade un Recurso personalizado del paquete Kubernetes con el kind ScaledObject para KEDA, y un Pod con fase Pending entre los Deployments.
  5. Para la capa de nodos, añade un Deployment para Cluster Autoscaler, un Recurso personalizado con el kind NodePool para Karpenter, un Recurso en la nube del paquete Nube para la API de la nube, y un Node.
  6. Conéctalos con aristas etiquetadas (CPU usage, replicas, Unschedulable, etc.), dale un color a cada bucle y añade una etiqueta Texto del paquete Básico con su periodo.
  7. Añade un bloque Markdown del paquete Básico con los valores por defecto.

La herramienta de YAML de Kubernetes a diagrama convierte manifiestos existentes en un primer borrador de las cargas de trabajo; un método repetible para convertir YAML en un diagrama legible muestra la limpieza. Más en la página del caso de uso de Kubernetes.

El ejemplo usa 13 nodos de diagrama, dentro del plan Free.

Preguntas frecuentes

¿Cuál es la diferencia entre HPA y VPA? El HPA cambia cuántos pods se ejecutan, según métricas como la utilización de CPU. El VPA cambia los requests de CPU y memoria de cada pod, según el historial de uso.

¿Puedo usar HPA y VPA juntos? Sí, si actúan sobre métricas distintas: HPA sobre CPU con VPA limitado a memoria, o HPA sobre métricas custom o external con VPA sobre ambas.

¿Debería usar Cluster Autoscaler o Karpenter? Karpenter, si tu nube lo admite y quieres que elija los tipos de instancia y reemplace nodos por otros más baratos. Cluster Autoscaler para otros proveedores y grupos de nodos fijos. Nunca ambos sobre los mismos nodos.

¿Puede Kubernetes escalar un deployment a cero? Sí, con KEDA, o con el scale-to-zero del HPA, en beta y activado por defecto desde Kubernetes 1.37. Ambos necesitan una métrica que exista sin pods en ejecución, como la longitud de una cola.

¿Por qué mi HPA muestra objetivos de CPU desconocidos? Normalmente falta metrics-server, o un contenedor no tiene request de CPU, así que no se puede calcular la utilización. Ejecuta kubectl describe hpa para ver el error.

Empieza gratis — un puesto, sin tarjeta de crédito.

Artículos relacionados

← Volver al blog

Abre un lienzo en un minuto

Inicia sesión con Google o GitHub. Gratis para un asiento. Mejora el plan cuando se una el equipo.