Cinco métricas ocultas de Kubernetes: cómo configurar un autoescalado fiable de podsArtículo · digest del 28 de octubre
Bodegón de claroscuro dramático de una consola de servidor con cinco indicadores adelantados de autoescalado de pods en Kubernetes.
Artículo3 secciones≈ 6 min

Cinco métricas ocultas de Kubernetes: cómo configurar un autoescalado fiable de pods

Pregúntale a cualquier administrador de sistemas o ingeniero DevOps cómo tiene configurado el autoescalado horizontal de pods (Horizontal Pod Autoscaler, HPA) en Kubernetes y, nueve de cada diez veces, escucharás la misma respuesta automática: «Pues por CPU y memoria RAM, el umbral clásico del 70–80 %».

Sobre el papel suena lógico: llega una oleada de usuarios, los procesadores echan humo, Kubernetes detecta el pico de uso y añade cinco réplicas más del servicio. Pero en producción real con alta carga, ese esquema simplista provoca caídas en cascada con demasiada frecuencia. Cuando la CPU de un contenedor ya va al 90 %, suele ser tarde para salvar el servicio: la cola de peticiones entrantes está desbordada, los timeouts caen como un alud y los nuevos pods aún tardan dos o tres minutos en inicializarse, descargar la imagen y pasar las sondas de readiness. Al final, la carga se redistribuye sobre los pods vivos que quedan y el clúster se derrumba como fichas de dominó.

Los ingenieros del laboratorio de investigación Applied Computing Research Labs (ACRL) publicaron un análisis detallado de los cuellos de botella del escalado, desgranando cinco métricas poco evidentes que permiten configurar un autoescalado predictivo mucho antes de que las CPUs toquen techo.

Por qué la CPU y la memoria engañan al autoescalador

Veamos la física del proceso. Las métricas de uso de CPU y RAM son indicadores retardados (lagging indicators): reflejan una catástrofe que ya ha ocurrido, no su aproximación.

Es más, en microservicios asíncronos modernos escritos en Node.js, Go o Java, la CPU puede estar ocupada apenas al 30 % y, aun así, el servicio estar completamente muerto de cara al cliente. Por ejemplo, si se agota el pool de conexiones a PostgreSQL o una pasarela de pagos remota empieza a responder con 5 segundos de retraso, los hilos de entrada de la aplicación quedan bloqueados esperando entrada/salida (I/O wait). ¡La CPU mientras tanto está ociosa! Kubernetes ve un 25 % de carga de CPU y da por hecho que todo va de maravilla, mientras los usuarios reciben errores HTTP 504 Gateway Timeout.

Los investigadores de ACRL definieron cinco métricas fundamentales centradas en el rendimiento real (throughput) y la profundidad de las colas.

Cinco métricas clave de ACRL: señales adelantadas de carga

  1. Velocidad de crecimiento de la cola de mensajes (Queue Ingestion Rate vs Processing Rate): En workers asíncronos (RabbitMQ, Kafka, SQS), guiarse por la CPU no tiene sentido. Lo que importa no es la longitud absoluta de la cola, sino la derivada: la tasa de llegada de mensajes nuevos menos la tasa de procesamiento. Si el delta se vuelve positivo, hay que escalar de inmediato.
  2. Tiempo de espera en búfer (Queue Dwell Time): Mide cuántos milisegundos pasa un mensaje o una petición HTTP en la cola antes de que un hilo libre empiece a ejecutarlo de verdad. Superar un umbral de 200–300 ms es motivo directo para añadir pods.
  3. Latencia del handshake TCP y RTT (Connection Handshake Latency): Se mide en la capa del balanceador Ingress. Un repunte en el tiempo de establecimiento de conexiones TCP delata que el backlog de sockets del sistema operativo dentro del pod (somaxconn) se está desbordando.
  4. Ratio de saturación del pool de conexiones (Pool Saturation Ratio): Relación entre los hilos de ejecución activos y el tamaño total del pool de workers. Cuando el pool alcanza el 85 % de ocupación, el servicio se queda sin margen de maniobra ante picos repentinos de tráfico.
  5. Percentil de latencia p99 en el borde del Ingress: El tiempo de respuesta de las peticiones más lentas avisa de una degradación mucho antes de que empiece a subir la latencia media p50.

Si estás diseñando pruebas de estrés para comprobar estas métricas, échale un ojo a nuestra guía: pruebas de carga realistas en Kubernetes: diseño de una suite en k6 para arquitectura de microservicios, donde se muestra cómo detectar estos umbrales de forma instrumental.

Configuración práctica de KEDA y del manifiesto HPA

Para escalar por métricas adelantadas, los recursos estándar de Kubernetes se quedan cortos: hace falta el operador KEDA (Kubernetes Event-driven Autoscaling) o un adaptador personalizado de métricas de Prometheus (Prometheus Adapter).

Aquí tienes un ejemplo listo para usar de manifiesto ScaledObject para KEDA que vigila la velocidad de crecimiento de una cola en Kafka y el tiempo en búfer:

apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: order-processor-autoscaler
  namespace: production
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: order-processor
  minReplicaCount: 3
  maxReplicaCount: 30
  cooldownPeriod: 300
  pollingInterval: 15
  advanced:
    horizontalPodAutoscalerConfig:
      behavior:
        scaleUp:
          stabilizationWindowSeconds: 0
          policies:
            - type: Percent
              value: 100
              periodSeconds: 15
        scaleDown:
          stabilizationWindowSeconds: 300
          policies:
            - type: Percent
              value: 10
              periodSeconds: 60
  triggers:
    - type: kafka
      metadata:
        bootstrapServers: kafka-cluster:9092
        topic: orders.v1
        consumerGroup: order-workers
        lagThreshold: "50"
        activationLagThreshold: "10"

Y así se ve la configuración de un HPA estándar al conectar métricas externas de latencia del Ingress desde Prometheus, con protección frente al flapping (oscilación continua de réplicas):

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: api-gateway-hpa
  namespace: production
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: api-gateway
  minReplicas: 4
  maxReplicas: 40
  metrics:
    - type: External
      external:
        metric:
          name: ingress_request_duration_p99_seconds
          selector:
            matchLabels:
              service: api-gateway
        target:
          type: Value
          averageValue: 250m
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 0
      policies:
        - type: Pods
          value: 4
          periodSeconds: 15
    scaleDown:
      stabilizationWindowSeconds: 300

Fíjate en la sección behavior: al escalar hacia arriba, la ventana de estabilización se pone a cero para reaccionar al instante ante un pico, mientras que al escalar hacia abajo se fija una ventana de cinco minutos (stabilizationWindowSeconds: 300). Eso protege al clúster de crear y destruir pods en bucle cuando el tráfico llega en diente de sierra.

Pasar a métricas predictivas exige dedicar un tiempo a calibrar Prometheus, pero se amortiza en la primera gran campaña de ventas o en el primer repunte brusco de actividad de tus usuarios.

Quiero un análisis detalladoLos votos ayudan a elegir qué analizar a fondo. Este material tiene 0 votos.
Fuentes · 2