Concepto clave

El Horizontal Pod Autoscaler (HPA) es un controlador de Kubernetes que ajusta automáticamente el número de réplicas de un Deployment basándose en métricas de uso de recursos. Imagina que tienes un restaurante: cuando llegan muchos clientes (alta carga), contratas más camareros (réplicas); cuando hay pocos, reduces el personal. HPA hace lo mismo con tus pods de inferencia de ML.

En el contexto de modelos de ML, esto es crucial porque la demanda de inferencia puede variar drásticamente. Un modelo que procesa imágenes en tiempo real podría recibir picos de tráfico durante eventos específicos. Sin HPA, tendrías que monitorear manualmente y escalar, lo que lleva a tiempos de respuesta lentos o costos innecesarios por sobreaprovisionamiento.

Cómo funciona en la práctica

HPA monitorea métricas como el uso de CPU o memoria de los pods. Configuras un objetivo (por ejemplo, 70% de uso de CPU) y HPA ajusta las réplicas para mantener ese nivel. Si el uso promedio supera el objetivo, aumenta réplicas; si está por debajo, las reduce, siempre dentro de los límites mínimo y máximo que defines.

Paso a paso: 1) Despliegas tu servicio de inferencia como un Deployment. 2) Expones métricas con un adaptador de métricas (como Metrics Server). 3) Creas un recurso HPA que apunte al Deployment. 4) HPA empieza a escalar basándose en las métricas en tiempo real.

Codigo en accion

Primero, despliega un servicio de inferencia simple. Aquí un Deployment para un modelo de clasificación de imágenes usando Flask:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ml-inference
spec:
  replicas: 2
  selector:
    matchLabels:
      app: ml-inference
  template:
    metadata:
      labels:
        app: ml-inference
    spec:
      containers:
      - name: inference-container
        image: tu-registro/ml-model:latest
        ports:
        - containerPort: 5000
        resources:
          requests:
            cpu: "200m"
            memory: "256Mi"
          limits:
            cpu: "500m"
            memory: "512Mi"

Luego, crea el HPA para escalar basado en CPU. Antes, sin HPA, tenías réplicas fijas; después, con HPA, se ajustan automáticamente:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: ml-inference-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: ml-inference
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

Errores comunes

No configurar requests y limits en el Deployment: HPA necesita estos valores para calcular el uso porcentual. Sin ellos, no puede escalar correctamente.
Usar métricas incorrectas: Para inferencia de ML, CPU puede no ser el mejor indicador. Considera métricas personalizadas como latencia o número de solicitudes.
Olvidar instalar Metrics Server: Sin él, HPA no tiene datos de métricas. Asegúrate de ejecutar kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml.
Configurar límites muy estrechos: Si minReplicas es muy alto o maxReplicas muy bajo, pierdes flexibilidad. Ajusta según la carga esperada.

Checklist de dominio

Desplegué un servicio de inferencia con un Deployment en Kubernetes.
Configuré requests y limits de recursos en el contenedor.
Instalé y verifiqué que Metrics Server esté funcionando.
Creé un HPA que apunte a mi Deployment con métricas de CPU.
Probé el escalado generando carga con una herramienta como kubectl run -it --rm load-generator --image=busybox -- /bin/sh -c "while true; do wget -q -O- http://ml-inference-service; done".
Monitoreé las réplicas con kubectl get hpa y kubectl get pods.
Ajusté el HPA para usar métricas personalizadas si es necesario.

Escalar un modelo de predicción de ventas con HPA en Kubernetes

En este ejercicio, desplegarás un modelo de ML simple que predice ventas y lo escalarás automáticamente con HPA basado en el uso de CPU.

Prepara el entorno: Asegúrate de tener un clúster de Kubernetes funcionando (puedes usar Minikube o un servicio en la nube). Instala Metrics Server si no lo tienes.
Crea el Deployment: Usa el siguiente código YAML para desplegar un servicio de inferencia. Guarda como deployment.yaml y aplica con kubectl apply -f deployment.yaml.
Configura el HPA: Crea un archivo hpa.yaml con la configuración de HPA que escale de 2 a 5 réplicas basado en 60% de uso de CPU. Aplica con kubectl apply -f hpa.yaml.
Genera carga: Usa un pod temporal para enviar solicitudes HTTP al servicio y simular tráfico. Ejecuta kubectl run -it --rm load-test --image=alpine -- sh -c "while true; do wget -q -O- http://ml-inference-service; sleep 0.5; done".
Monitorea y verifica: En otra terminal, ejecuta kubectl get hpa -w para ver cómo HPA ajusta las réplicas. Detén la carga después de 2 minutos y observa cómo se reducen las réplicas.
Documenta resultados: Toma capturas de pantalla o anota el número máximo de réplicas alcanzado y el tiempo que tomó escalar.

Pistas

Asegúrate de que el servicio esté expuesto correctamente; usa kubectl get services para verificar.
Si HPA no escala, revisa los logs de Metrics Server con kubectl logs -n kube-system deployment/metrics-server.
Para una carga más realista, ajusta el intervalo de solicitudes en el comando de generación de carga.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Práctica: Escalar un Servicio de Inferencia con HPA