Saltar al contenido

Lección 17 de 20 · Lectura y práctica

Containerizar el Modelo y sus Dependencias

Tipo de lección: VideoConcepto claveContainerizar un modelo de ML significa empaquetarlo junto con todas sus dependencias en una unidad estandarizada llamada contenedor. Imagina que tu modelo es una planta delicada: necesita.

Del concepto a la práctica

Taller de esta lección

La reproducibilidad depende de fijar no solo el código, sino también el artefacto del modelo, las dependencias y el comando de arranque. Una imagen debe recibir únicamente los archivos necesarios y ejecutar una comprobación sencilla antes de atender peticiones.

Ejemplo resuelto

Usa el servicio y catálogo JSON completos de la lección anterior. Un Dockerfile mínimo puede ser:

dockerfile
FROM python:3.12-slim
WORKDIR /app
COPY requirements.lock .
RUN pip install --no-cache-dir -r requirements.lock
COPY app.py catalogo.json .
EXPOSE 5000
CMD ["python", "app.py"]

El lockfile fija el entorno y la entrada u1/2 devuelve los identificadores p3,p2 del catálogo incluido. No depende de una ruta personal del equipo.

Pruébalo

  1. Coloca los tres archivos y el modelo en un directorio limpio.

  2. Construye la imagen con una etiqueta concreta, como recomendador:prueba-1.

  3. Inicia el contenedor y envía una entrada conocida del conjunto de validación.

  4. Compara la salida con la predicción obtenida antes de empaquetar.

Error frecuente: copiar el modelo desde una ruta inexistente o ignorada. Corrígelo verificando el contexto de construcción y listando explícitamente el archivo antes de construir.

Comprueba tu resultado

Crea dos entradas de validación, registra sus salidas fuera y dentro del contenedor y confirma que ambas coinciden exactamente. El resultado esperado es una tabla con dos filas, entrada, predicción externa, predicción interna y una columna coincide=true.

Contexto completo para el servicio del proyecto

Usa el app.py y catalogo.json completos de la lección anterior, más requirements.lock generado en ese mismo entorno. El Dockerfile de referencia para el laboratorio es:

dockerfile
FROM python:3.12-slim
WORKDIR /app
COPY requirements.lock .
RUN pip install --no-cache-dir -r requirements.lock
COPY app.py catalogo.json ./
ENV PYTHONDONTWRITEBYTECODE=1
USER 1000:1000
EXPOSE 5000
CMD ["python", "-B", "app.py"]

.dockerignore excluye .git, .venv, __pycache__, logs y datos ajenos; no debe excluir catalogo.json. La etiqueta base describe la familia del laboratorio; registra su digest resuelto para reproducir la construcción exacta. No empaquetes un entorno entrenado con versiones distintas ni consideres suficiente un requirements con paquetes sin versión.

Pruebas completas: {"user_id":"u1","limit":2} devuelve items p3,p2; {"user_id":"u2","limit":1} devuelve p1, en ambos casos versión catalogo-1. Publica el puerto únicamente en localhost para la prueba. Estas salidas sustituyen etiquetas arbitrarias que no podían deducirse de un modelo no suministrado. La API no necesita entrenar al arrancar.

Secuencia de código, imagen de contenedor, pruebas, registro y despliegue de instancias idénticas.
CursaloMapa de práctica
Del código al despliegue

El código se empaqueta en una imagen y se prueba antes de publicarlo. Esa misma imagen se guarda en un registro y se usa en el despliegue. Comprobar la salud de las instancias permite detectar un fallo sin reconstruir el artefacto.

Ver la infografía en tamaño completo ↗

Tipo de lección: Video

Concepto clave

Containerizar un modelo de ML significa empaquetarlo junto con todas sus dependencias en una unidad estandarizada llamada contenedor. Imagina que tu modelo es una planta delicada: necesita tierra especifica, agua con cierto pH, y una temperatura controlada. En lugar de intentar recrear estas condiciones en cada jardin donde la quieras plantar, la pones en un invernadero portatil (el contenedor) que ya tiene todo lo necesario. Asi, puedes moverla a cualquier lado y siempre crecera igual.

Docker es la herramienta que construye estos invernaderos. Usa un Dockerfile como plano de construccion para especificar: que sistema operativo base usar (como Ubuntu), que paquetes de Python instalar (scikit-learn, pandas), donde copiar tu codigo del modelo, y que comando ejecutar para iniciar el servicio. El resultado es una imagen Docker inmutable que contiene tu modelo entrenado, el codigo de inferencia, y el entorno de ejecucion, todo en uno.

Como funciona en la practica

Vamos a containerizar un modelo de recomendacion simple basado en filtrado colaborativo. Sigue estos pasos:

  1. Preparar los archivos: Tenemos un modelo entrenado (model.pkl), un script de inferencia (predict.py), y un archivo de requisitos (requirements.txt).
  2. Escribir el Dockerfile: Creamos un archivo llamado Dockerfile que define las capas de la imagen.
  3. Construir la imagen: Ejecutamos docker build -t recomendador:1.0 . para crear la imagen.
  4. Probar localmente: Corremos docker run -p 5000:5000 recomendador:1.0 para verificar que el servicio funciona.
  5. Subir al registro: Etiquetamos y empujamos la imagen a Docker Hub o un registro privado para usar en Kubernetes.

Codigo en accion

Primero, veamos el script de inferencia predict.py que usara nuestro modelo:

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

app = Flask(__name__)

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

@app.route('/predict', methods=['POST'])
def predict():
    data = request.get_json()
    user_features = np.array(data['features']).reshape(1, -1)
    prediction = model.predict(user_features)
    return jsonify({'recommendation': int(prediction[0])})

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

Ahora, el Dockerfile que containeriza todo:

# Usar una imagen base ligera de Python
FROM python:3.9-slim

# Establecer el directorio de trabajo
WORKDIR /app

# Copiar los archivos de requisitos e instalar dependencias
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copiar el modelo y el codigo
COPY model.pkl predict.py .

# Exponer el puerto que usa Flask
EXPOSE 5000

# Comando para ejecutar la aplicacion
CMD ["python", "predict.py"]

Errores comunes

  • Imagenes demasiado grandes: Usar imagenes base como python:3.9 (1GB+) en lugar de python:3.9-slim (200MB). Solucion: Siempre elige variantes slim o alpine para reducir tamaño y mejorar tiempos de despliegue.
  • No limpiar cache de pip: Dejar archivos temporales en la imagen. Mejora el Dockerfile con RUN pip install --no-cache-dir -r requirements.txt para ahorrar espacio.
  • Exponer puertos incorrectos: Flask corre en 5000 por defecto, pero si cambias el puerto en el codigo, debes actualizar EXPOSE y el mapeo en docker run.
  • Modelo no incluido en la imagen: Olvidar copiar el archivo .pkl con COPY. Verifica que todos los archivos necesarios esten listados en el Dockerfile.
  • Variables de entorno hardcodeadas: Poner paths o claves directamente en el codigo. Usa variables de entorno Docker para configuracion sensible.

Checklist de dominio

  1. ¿Puedes escribir un Dockerfile que instale dependencias Python desde requirements.txt?
  2. ¿Sabes construir una imagen Docker y etiquetarla con version?
  3. ¿Verificas que el contenedor funcione localmente antes de subirlo al registro?
  4. ¿Usas imagenes base optimizadas (slim/alpine) para reducir tamaño?
  5. ¿Expones correctamente los puertos que tu aplicacion usa?
  6. ¿Incluyes todos los archivos necesarios (modelo, codigo, configs) en la imagen?
  7. ¿Documentas el proceso de construccion y ejecucion para tu equipo?

Containeriza un modelo de regresion lineal para API REST

En este ejercicio, containerizaras un modelo de regresion lineal simple que predice precios basado en caracteristicas. Sigue estos pasos:

  1. Descarga los archivos base: Crea un directorio de trabajo y dentro, guarda estos tres archivos:
    - model_linear.pkl (un modelo de sklearn LinearRegression ya entrenado)
    - app.py (codigo Flask similar al de la leccion, adaptado para regresion)
    - requirements.txt (con flask, scikit-learn, numpy)
  2. Escribe el Dockerfile: Crea un archivo Dockerfile que:
    - Use python:3.9-slim como imagen base
    - Establezca WORKDIR en /app
    - Copie requirements.txt y ejecute pip install
    - Copie model_linear.pkl y app.py
    - Exponga el puerto 5000
    - Use CMD para ejecutar app.py
  3. Construye la imagen: Ejecuta docker build -t regresor:1.0 . en tu terminal, dentro del directorio.
  4. Ejecuta el contenedor: Corre docker run -p 5000:5000 regresor:1.0 y verifica que el servicio este activo.
  5. Prueba la API: Usa curl o Postman para enviar una peticion POST a http://localhost:5000/predict con un JSON como {"features": [100, 5]}. Deberias recibir una prediccion numerica.
  6. Optimiza: Modifica el Dockerfile para reducir el tamaño de la imagen, por ejemplo, limpiando cache de apt si usas paquetes del sistema.
Pistas
  • Asegurate de que requirements.txt incluya scikit-learn==1.0.2 y flask==2.0.3 para compatibilidad.
  • Si el contenedor falla al iniciar, revisa los logs con docker logs para ver errores de importacion.
  • Para reducir el tamaño, considera usar --no-cache-dir en pip install y combinar RUN comandos en uno solo.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Sigue con Containerización y Despliegue de Modelos de ML con Docker y Kubernetes

Esta lección forma parte de un curso de Cursalo. Revisa su programa y elige entre la compra individual o el acceso a toda la escuela.

Si ya tenías acceso a este curso, entra con tu cuenta: tus derechos y tu progreso se conservan. No necesitas comprarlo de nuevo.

01 / ELEGIR UNA RUTA

El próximo paso

Aprende IA mientras construyes algo que sí necesitas.

Empieza por el curso inicial o explora el catálogo para encontrar una práctica alineada con tu trabajo.