Concepto clave

El despliegue de modelos de ML en producción requiere containerización para garantizar consistencia entre entornos y orquestación para manejar múltiples instancias de manera eficiente. Imagina que tu modelo es una receta de cocina: Docker es como empaquetar todos los ingredientes y utensilios en una caja hermética que funciona igual en cualquier cocina, mientras que Kubernetes es el chef ejecutivo que coordina múltiples cocineros para servir muchos platos simultáneamente sin colapsar la cocina.

En el contexto de un sistema de recomendación, esto significa que tu modelo entrenado, junto con todo su entorno de ejecución (Python, bibliotecas, archivos de configuración), se encapsula en una imagen Docker. Luego, Kubernetes despliega esta imagen en pods (contenedores en ejecución) que pueden escalar automáticamente según la demanda de usuarios, gestionar fallos y balancear la carga. La clave está en separar claramente el código del modelo de la infraestructura, permitiendo que los científicos de datos se enfoquen en mejorar el algoritmo mientras los ingenieros gestionan la escalabilidad.

Cómo funciona en la práctica

Vamos a desplegar un sistema de recomendación basado en filtrado colaborativo. Paso 1: Creas un script Python que carga el modelo entrenado (por ejemplo, un modelo de factorización matricial) y expone una API REST con Flask/FastAPI. Paso 2: Escribes un Dockerfile que copia este script, instala dependencias (scikit-learn, pandas, Flask) y define el comando de inicio. Paso 3: Construyes la imagen y la subes a un registro como Docker Hub. Paso 4: Defines un Deployment en Kubernetes que especifica cuántas réplicas del pod ejecutar, los recursos de CPU/memoria, y configuraciones como variables de entorno para parámetros del modelo. Paso 5: Expones el servicio con un Service de tipo LoadBalancer o Ingress para que los usuarios finales puedan acceder a las recomendaciones.

Un flujo típico: Un usuario visita una app web, que envía una solicitud HTTP al servicio Kubernetes; este enruta la petición a uno de los pods disponibles; el pod ejecuta el modelo y devuelve la recomendación personalizada en JSON; si la carga aumenta, Kubernetes crea automáticamente más pods para manejar el tráfico.

Código en acción

Dockerfile para el modelo de recomendación:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY model.pkl .
COPY app.py .
EXPOSE 5000
CMD ["python", "app.py"]

app.py con la API:

from flask import Flask, request, jsonify
import pickle
import numpy as np

app = Flask(__name__)

# Cargar modelo al iniciar
with open('model.pkl', 'rb') as f:
    model = pickle.load(f)

@app.route('/recommend', methods=['POST'])
def recommend():
    data = request.json
    user_id = data['user_id']
    # Supongamos que el modelo tiene un método predict
    recommendations = model.predict(user_id, top_n=5)
    return jsonify({'recommendations': recommendations})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Errores comunes

No versionar las imágenes Docker: Usar latest en producción puede causar inconsistencias. Siempre usa tags específicos (ej: v1.2.0).
Olvidar límites de recursos en Kubernetes: Sin resources.requests/limits en el Deployment, los pods pueden consumir toda la CPU/memoria del nodo, causando inestabilidad.
Hardcodear configuraciones en el código: Parámetros como URLs de bases de datos deben ir en ConfigMaps o Secrets, no en el script Python.
Ignorar health checks: No definir livenessProbe y readinessProbe puede hacer que Kubernetes envíe tráfico a pods caídos.
No probar localmente primero: Construir y ejecutar el contenedor con Docker antes de subir a Kubernetes evita errores básicos de dependencias.

Checklist de dominio

¿Puedes construir una imagen Docker que incluya tu modelo de ML y una API funcional?
¿Sabes desplegar esa imagen en un cluster Kubernetes con al menos 2 réplicas?
¿Has configurado un Service para exponer tu modelo a internet o a otros servicios internos?
¿Utilizas ConfigMaps o Secrets para gestionar configuraciones sensibles (ej: claves de API)?
¿Has implementado health checks para que Kubernetes gestione automáticamente pods fallidos?
¿Puedes escalar manualmente tu despliegue con kubectl scale?
¿Entiendes cómo monitorear los logs y métricas de tus pods en producción?

Despliega un Modelo de Recomendación en Minikube

En este ejercicio, desplegarás un modelo de recomendación simple en un cluster local de Kubernetes usando Minikube. Sigue estos pasos:

Prepara tu entorno: Instala Docker, Minikube y kubectl si no los tienes. Inicia Minikube con minikube start.
Crea un directorio de proyecto con tres archivos: Dockerfile (usa el ejemplo de arriba), requirements.txt (con Flask, scikit-learn, pandas) y app.py (puedes simular el modelo con una función que devuelva recomendaciones aleatorias si no tienes un modelo real).
Construye la imagen Docker: docker build -t recommendation-model:v1 .
Etiqueta y sube la imagen al registro de Minikube: minikube image load recommendation-model:v1
Crea un archivo deployment.yaml que defina un Deployment con 2 réplicas, recursos límite (ej: 256Mi de memoria), y un puerto 5000. Incluye un livenessProbe que verifique /health (añade esta ruta a tu app.py).
Aplica el Deployment: kubectl apply -f deployment.yaml
Crea un Service de tipo NodePort para exponerlo: kubectl expose deployment recommendation-deployment --type=NodePort --port=5000
Verifica que todo funcione: Usa kubectl get pods para ver pods en estado Running, y minikube service recommendation-deployment --url para obtener la URL y probar con curl.

Pistas

Si Minikube no inicia, verifica que la virtualización esté habilitada en tu BIOS.
Para simular un modelo en app.py, usa una función que devuelva una lista fija de recomendaciones basada en user_id.
Asegúrate de que el puerto en EXPOSE del Dockerfile coincida con el puerto en el Deployment.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Quiz: Evaluación del Proyecto Integrador

Quiz Interactivo