Poner modelos de machine learning en producción es uno de los mayores desafíos en MLOps. Docker y Kubernetes proporcionan herramientas poderosas para empaquetar, distribuir y gestionar modelos ML a escala.

¿Por qué Docker para ML?

Docker resuelve el problema clásico de "funciona en mi máquina" al empaquetar tu modelo, dependencias y entorno en un contenedor aislado y portable.

Ventajas:

• Consistencia: Mismo entorno en desarrollo y producción
• Aislamiento: Las dependencias no entran en conflicto entre proyectos
• Portabilidad: Funciona en cualquier lugar que soporte Docker
• Escalabilidad: Fácil replicar y escalar contenedores

Creando un Dockerfile para ML

Ejemplo básico de Dockerfile para un modelo ML:

FROM python:3.9-slim

WORKDIR /app

# Instalar dependencias
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copiar código y modelo
COPY . .

# Exponer puerto
EXPOSE 8000

# Comando para iniciar API
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

Construyendo la API

Una API simple con FastAPI para servir el modelo:

from fastapi import FastAPI
from pydantic import BaseModel
import joblib

app = FastAPI()
model = joblib.load("model.pkl")

class Input(BaseModel):
    feature1: float
    feature2: float

@app.post("/predict")
def predict(input: Input):
    prediction = model.predict([[input.feature1, input.feature2]])
    return {"prediction": prediction[0]}

Orquestación con Kubernetes

Kubernetes gestiona contenedores a escala, proporcionando auto-escalado, balanceo de carga y alta disponibilidad.

Conceptos Principales:

• Pods: Unidad menor de despliegue (contenedores)
• Services: Abstracción para exponer pods vía red
• Deployments: Gestionan réplicas de pods
• Horizontal Pod Autoscaler: Escala automáticamente basado en métricas

Ejemplo de Deployment Kubernetes

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ml-model-api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ml-model
  template:
    metadata:
      labels:
        app: ml-model
    spec:
      containers:
      - name: api
        image: ml-model:latest
        ports:
        - containerPort: 8000
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1Gi"
            cpu: "500m"
---
apiVersion: v1
kind: Service
metadata:
  name: ml-model-service
spec:
  selector:
    app: ml-model
  ports:
  - port: 80
    targetPort: 8000
  type: LoadBalancer

Consideraciones Importantes

Rendimiento

• Usa modelos optimizados (cuantización, pruning)
• Cache de predicciones cuando sea apropiado
• Batching para procesar múltiples solicitudes
• Soporte GPU si es necesario

Recursos

• Asignar memoria suficiente para cargar el modelo
• CPU/GPU según sea necesario
• Almacenamiento para modelos grandes (PVCs)

Monitoreo

• Logs estructurados
• Métricas de rendimiento (latencia, throughput)
• Health checks
• Alertas para fallos

Alternativas Simples

Para empezar de forma más simple, considera:

• FastAPI + Docker: Para APIs simples
• Flask + Docker Compose: Para desarrollo
• Plataformas Cloud ML: AWS SageMaker, GCP AI Platform, Azure ML
• Serverless: AWS Lambda, Google Cloud Functions

Flujo de Trabajo Recomendado

1. Desarrollar y entrenar modelo localmente
2. Empaquetar modelo y API en Docker
3. Probar contenedor localmente
4. Publicar imagen en registry (Docker Hub, ECR, etc.)
5. Desplegar en Kubernetes
6. Configurar monitoreo y alertas

← Volver a IA en Producción