Crear un Dockerfile para un Modelo de Scikit-learn

Concepto clave

Un Dockerfile es un archivo de texto que contiene instrucciones para construir una imagen de Docker. Piensa en ello como una receta que especifica todos los ingredientes y pasos necesarios para crear un contenedor reproducible. Para científicos de datos, esto significa encapsular tu modelo de Scikit-learn, sus dependencias y el entorno de ejecución en un paquete autónomo.

La analogía del mundo real sería preparar una caja de herramientas completa para un trabajo específico. En lugar de llevar herramientas sueltas (tu código, bibliotecas, configuraciones), metes todo en una caja organizada (el contenedor) que puedes llevar a cualquier sitio y usar inmediatamente. Esto elimina el clásico problema de "funciona en mi máquina" y permite despliegues consistentes en Kubernetes.

Cómo funciona en la práctica

Vamos a crear un Dockerfile para un modelo de clasificación con Scikit-learn paso a paso. Primero, necesitas un proyecto estructurado. Supongamos que tienes estos archivos:

• train_model.py: Script para entrenar el modelo
• predict.py: Script para hacer predicciones
• requirements.txt: Dependencias de Python
• model.pkl: Modelo entrenado (generado por train_model.py)

El Dockerfile definirá cómo construir una imagen que incluya Python, instale las dependencias, copie tus archivos y configure el punto de entrada. La construcción se hace con docker build y la ejecución con docker run. Esto crea un contenedor aislado que puede ejecutar tu modelo en cualquier sistema con Docker instalado.

Codigo en accion

Aquí tienes un Dockerfile básico para un modelo Scikit-learn:

# Usa una imagen base oficial de Python
FROM python:3.9-slim

# Establece el directorio de trabajo en el contenedor
WORKDIR /app

# Copia el archivo de dependencias
COPY requirements.txt .

# Instala las dependencias
RUN pip install --no-cache-dir -r requirements.txt

# Copia el resto de los archivos del proyecto
COPY . .

# Expone el puerto si tu aplicación usa un servidor web (opcional)
EXPOSE 5000

# Define el comando por defecto para ejecutar el script de predicción
CMD ["python", "predict.py"]

Y este es el contenido típico de requirements.txt:

scikit-learn==1.3.0
pandas==2.0.3
flask==2.3.2
numpy==1.24.3

Para construir la imagen, ejecutas:

docker build -t sklearn-model .

Y para ejecutar el contenedor:

docker run -p 5000:5000 sklearn-model

Errores comunes

1. No optimizar el tamaño de la imagen: Usar imágenes base grandes como python:3.9 en lugar de python:3.9-slim puede resultar en imágenes de varios GB. Solución: Usa variantes slim o alpine y limpia la caché de pip con --no-cache-dir.
2. Copiar todos los archivos innecesariamente: Incluir datos de entrenamiento grandes o archivos temporales en la imagen. Solución: Usa un .dockerignore para excluir archivos como datasets crudos, logs o entornos virtuales.
3. No fijar versiones de dependencias: Usar scikit-learn sin versión puede causar incompatibilidades al actualizar. Solución: Especifica versiones exactas en requirements.txt.
4. Ejecutar como root por defecto: Aumenta el riesgo de seguridad. Solución: Añade un usuario no privilegiado en el Dockerfile con RUN useradd -m appuser && chown -R appuser /app y USER appuser.
5. No manejar señales de terminación: Los contenedores pueden no apagarse correctamente en Kubernetes. Solución: Asegúrate de que tu script Python capture señales como SIGTERM para limpieza.

Checklist de dominio

• Puedo escribir un Dockerfile que instale Scikit-learn y sus dependencias desde requirements.txt
• Sé cómo reducir el tamaño de la imagen usando capas eficientes y .dockerignore
• Entiendo la diferencia entre COPY, ADD, RUN y CMD en un Dockerfile
• Puedo construir una imagen y ejecutar un contenedor que sirva predicciones de un modelo
• Sé cómo exponer puertos y mapearlos correctamente al ejecutar el contenedor
• Reconozco la importancia de la seguridad al definir usuarios no root en el contenedor
• Puedo debuggear problemas comunes como fallos de dependencias o permisos

Containerizar un modelo de regresión lineal con Flask API

En este ejercicio, crearás un Dockerfile para un modelo de regresión lineal de Scikit-learn que exponga una API REST con Flask. Sigue estos pasos:

1. Crea un directorio de proyecto con los siguientes archivos:
   • train.py: Entrena un modelo simple de regresión lineal con datos sintéticos y guarda el modelo como model.pkl
   • app.py: Crea un servidor Flask con un endpoint /predict que acepte datos JSON y devuelva predicciones
   • requirements.txt: Lista las dependencias (scikit-learn, flask, pandas, numpy)
   • .dockerignore: Excluye archivos innecesarios
2. Escribe un Dockerfile que:
   • Use una imagen base Python slim
   • Instale las dependencias desde requirements.txt
   • Copie los archivos del proyecto
   • Exponga el puerto 5000
   • Ejecute app.py al iniciar el contenedor
3. Construye la imagen con docker build -t linear-regression-api .
4. Ejecuta el contenedor con docker run -p 5000:5000 linear-regression-api
5. Prueba la API enviando una solicitud POST a http://localhost:5000/predict con datos JSON de ejemplo

Entrega: Tu Dockerfile completo y el comando de ejecución que usaste.

• Usa datos sintéticos en train.py con make_regression de sklearn.datasets para simplificar
• En app.py, asegúrate de cargar el modelo una vez al inicio para eficiencia
• Incluye en .dockerignore archivos como __pycache__, .git, y datasets grandes

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.