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:
- 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.
- El updater revisa los pods cada minuto y desaloja o redimensiona los que quedan fuera de los límites, respetando los PodDisruptionBudgets.
- 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-ownershipde 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
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
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
- Inicia sesión con Google o GitHub y crea un diagrama.
- 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.
- Añade un nodo Métricas del paquete DevOps para metrics-server y una Cola del paquete Datos.
- Añade un Recurso personalizado del paquete Kubernetes con el kind ScaledObject para KEDA, y un Pod con fase Pending entre los Deployments.
- 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.
- 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.
- 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.