Image for post Containerización de Aplicaciones de IA con Docker: De Desarrollo a Producción

Containerización de Aplicaciones de IA con Docker: De Desarrollo a Producción

Escrito por Sergio Márquez

Contexto del Problema

Como desarrolladores, todos hemos escuchado la frase: "¡Pero funciona en mi máquina!". Este es un lamento común que surge cuando una aplicación que funciona perfectamente en el entorno de desarrollo de un programador falla al ser desplegada en otro entorno, ya sea el de un compañero, el de pruebas o, peor aún, el de producción. Este problema se magnifica exponencialmente en el ámbito de la Inteligencia Artificial y el Machine Learning (ML).

Las aplicaciones de IA suelen tener un "infierno de dependencias" debido a la gran cantidad de librerías, frameworks y versiones específicas que requieren (TensorFlow, PyTorch, Scikit-learn, CUDA, etc.). Un modelo entrenado con una versión particular de una librería puede comportarse de manera diferente o simplemente no funcionar con otra. Además, la gestión de entornos virtuales (como venv o conda) ayuda, pero no resuelve completamente la inconsistencia del sistema operativo subyacente o de otras herramientas no Python.

Aquí es donde la containerización, y específicamente Docker, entra en juego. Docker nos permite empaquetar nuestra aplicación y todas sus dependencias (código, runtime, librerías del sistema, herramientas y configuraciones) en una unidad aislada y portable llamada "contenedor". Esto asegura que la aplicación se ejecute de manera consistente y uniforme en cualquier infraestructura, desde tu laptop hasta un servidor en la nube, eliminando el problema del "funciona en mi máquina".

Conceptos Clave

  • Contenedor: Un contenedor es una unidad de software estandarizada que empaqueta el código de una aplicación y todas sus dependencias para que la aplicación se ejecute de forma rápida y fiable de un entorno informático a otro. A diferencia de una máquina virtual (VM), que virtualiza el hardware completo, un contenedor virtualiza el sistema operativo, compartiendo el kernel del host. Esto los hace mucho más ligeros y rápidos de iniciar que las VMs.
  • Imagen Docker: Una imagen Docker es una plantilla inmutable y de solo lectura que contiene las instrucciones para crear un contenedor. Incluye el código de la aplicación, las librerías, las dependencias y la configuración del entorno. Las imágenes se construyen a partir de un Dockerfile.
  • Dockerfile: Es un archivo de texto que contiene una serie de instrucciones para construir una imagen Docker. Cada instrucción en un Dockerfile crea una capa en la imagen, lo que permite la reutilización de capas y optimiza el proceso de construcción.
  • Docker Engine: Es el componente principal de Docker. Es un demonio (proceso en segundo plano) que gestiona la construcción de imágenes, la ejecución de contenedores, la gestión de volúmenes y redes, y otras operaciones de Docker.
  • Docker Compose: Una herramienta para definir y ejecutar aplicaciones Docker multi-contenedor. Utiliza un archivo YAML para configurar los servicios de la aplicación, las redes y los volúmenes. Es ideal para entornos de desarrollo y pruebas donde necesitas orquestar varios servicios localmente (por ejemplo, una API de IA, una base de datos y un frontend).
  • Volúmenes: Mecanismos para persistir datos generados por los contenedores. Dado que los contenedores son efímeros por naturaleza, los volúmenes permiten que los datos sobrevivan al ciclo de vida del contenedor, lo cual es crucial para modelos de ML, logs o bases de datos.
  • Redes: Docker proporciona capacidades de red para permitir la comunicación entre contenedores y entre contenedores y el host.

Implementación Paso a Paso: Containerizando una API de IA con FastAPI

Vamos a containerizar una aplicación Python sencilla que expone una API de predicción de Machine Learning usando FastAPI. La API cargará un modelo pre-entrenado de Scikit-learn y realizará inferencias.

Paso 1: Prepara tu aplicación Python

Primero, necesitamos una aplicación Python. Crearemos un script para entrenar y guardar un modelo, y otro para la API de FastAPI.

model.py (para entrenar y guardar el modelo):


import joblib
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris

# Cargar un dataset simple
iris = load_iris()
X, y = iris.data, iris.target

# Entrenar un modelo simple
model = LogisticRegression(max_iter=200)
model.fit(X, y)

# Guardar el modelo
joblib.dump(model, 'logistic_regression_model.joblib')
print("Modelo guardado como logistic_regression_model.joblib")

Ejecuta python model.py para generar el archivo logistic_regression_model.joblib.

app.py (aplicación FastAPI):


import os
import joblib
from fastapi import FastAPI
from pydantic import BaseModel
import uvicorn

# Cargar el modelo. Usamos una variable de entorno para la ruta.
MODEL_PATH = os.getenv("MODEL_PATH", "logistic_regression_model.joblib")
try:
    model = joblib.load(MODEL_PATH)
    print(f"Modelo cargado desde {MODEL_PATH}")
except FileNotFoundError:
    print(f"Error: Archivo de modelo no encontrado en {MODEL_PATH}. Asegúrate de que esté disponible.")
    model = None # Para manejar el caso donde el modelo no se carga

app = FastAPI(
    title="API de Predicción de Iris",
    description="Una API simple para predecir la especie de Iris usando un modelo de Regresión Logística.",
    version="1.0.0"
)

class IrisFeatures(BaseModel):
    sepal_length: float
    sepal_width: float
    petal_length: float
    petal_width: float

@app.get("/")
async def read_root():
    return {"message": "Bienvenido a la API de Predicción de Iris. Usa /predict para obtener predicciones."}

@app.post("/predict")
async def predict_iris(features: IrisFeatures):
    if model is None:
        return {"error": "Modelo no cargado. Revisa los logs del servidor."}
    
    data = [[
        features.sepal_length,
        features.sepal_width,
        features.petal_length,
        features.petal_width,
    ]]
    prediction = model.predict(data).tolist()
    prediction_proba = model.predict_proba(data).tolist()
    
    return {
        "prediction": prediction[0],
        "prediction_probabilities": prediction_proba[0]
    }

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Paso 2: Crea el archivo requirements.txt

Este archivo listará todas las dependencias Python necesarias para tu aplicación.


fastapi
uvicorn
scikit-learn
joblib
pydantic

Paso 3: Escribe el Dockerfile

El Dockerfile contiene las instrucciones para construir tu imagen.


# Usa una imagen base de Python ligera para reducir el tamaño final de la imagen.
# python:3.9-slim-buster es una buena opción que equilibra tamaño y compatibilidad.
FROM python:3.9-slim-buster

# Establece el directorio de trabajo dentro del contenedor.
# Todas las operaciones posteriores se realizarán en este directorio.
WORKDIR /app

# Copia el archivo de requisitos e instala las dependencias.
# Es una buena práctica copiar primero los requisitos e instalarlos.
# Esto aprovecha el cache de Docker: si los requisitos no cambian, esta capa no se reconstruye.
# --no-cache-dir reduce el tamaño de la imagen al no guardar paquetes descargados.
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copia el modelo entrenado y el código de la aplicación.
# Copiar estos archivos después de instalar las dependencias asegura que si solo cambia el código,
# la capa de instalación de dependencias se reutilice del cache.
COPY logistic_regression_model.joblib .
COPY app.py .

# Expone el puerto en el que la aplicación FastAPI se ejecutará.
# Esto informa a Docker que el contenedor escuchará en este puerto.
EXPOSE 8000

# Define la variable de entorno para la ruta del modelo.
# Esto hace que la ruta del modelo sea configurable y no esté "hardcodeada" en el código.
ENV MODEL_PATH=logistic_regression_model.joblib

# Comando para ejecutar la aplicación cuando el contenedor se inicie.
# uvicorn es el servidor ASGI recomendado para FastAPI.
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

Paso 4: Construye la imagen Docker

Abre tu terminal en el directorio donde tienes app.py, model.py, requirements.txt, logistic_regression_model.joblib y Dockerfile. Ejecuta el siguiente comando para construir tu imagen:


docker build -t my-ai-app .

El flag -t etiqueta tu imagen con un nombre (my-ai-app en este caso) y el punto . indica que el Dockerfile está en el directorio actual.

Paso 5: Ejecuta el contenedor Docker

Una vez que la imagen se ha construido, puedes ejecutar un contenedor a partir de ella:


docker run -p 8000:8000 my-ai-app

El flag -p 8000:8000 mapea el puerto 8000 del host (tu máquina) al puerto 8000 del contenedor. Esto permite que accedas a la aplicación que se ejecuta dentro del contenedor a través de http://localhost:8000.

Paso 6: Verifica la aplicación

Abre tu navegador o usa curl para interactuar con la API:

  • Visita http://localhost:8000. Deberías ver el mensaje de bienvenida.
  • Para probar la predicción, puedes usar curl o una herramienta como Postman/Insomnia:

curl -X POST "http://localhost:8000/predict" \
     -H "Content-Type: application/json" \
     -d '{"sepal_length": 5.1, "sepal_width": 3.5, "petal_length": 1.4, "petal_width": 0.2}'

Deberías recibir una respuesta JSON con la predicción y las probabilidades.

Mini Proyecto / Aplicación Sencilla

El ejemplo anterior ya constituye un mini-proyecto funcional. Hemos creado una API de IA con FastAPI, la hemos empaquetado en un contenedor Docker y la hemos ejecutado. Este es el patrón fundamental para desplegar modelos de ML como servicios.

Para expandir este mini-proyecto, podrías:

  • Añadir más endpoints para diferentes modelos o funcionalidades (por ejemplo, un endpoint para reentrenar el modelo, aunque esto es más complejo y requeriría persistencia de datos).
  • Integrar una base de datos simple (como SQLite) dentro del contenedor o como un servicio separado con Docker Compose para almacenar logs de inferencia.
  • Crear un pequeño frontend (por ejemplo, con Streamlit o Gradio, aunque estos son temas diferentes) y containerizarlo también, usando Docker Compose para orquestar ambos servicios.

Errores Comunes y Depuración

Trabajar con Docker puede presentar algunos desafíos. Aquí hay una lista de errores comunes y cómo depurarlos:

  • requirements.txt incompleto o incorrecto: Si tu aplicación falla al iniciar con errores de "ModuleNotFoundError", es probable que falten dependencias en tu requirements.txt o que las versiones no sean compatibles. Asegúrate de que todas las librerías estén listadas y, si es posible, especifica versiones exactas (por ejemplo, fastapi==0.104.1).
  • Puerto no expuesto o mapeado incorrectamente: Si no puedes acceder a tu aplicación desde el navegador o curl, verifica que el puerto en tu Dockerfile (EXPOSE 8000) y en el comando docker run (-p 8000:8000) coincidan y estén correctamente mapeados.
  • Rutas incorrectas en Dockerfile: Errores como "No such file or directory" al copiar archivos (COPY) o al establecer el directorio de trabajo (WORKDIR) son comunes. Asegúrate de que las rutas relativas sean correctas desde el contexto de construcción de Docker.
  • Problemas de permisos: Si tu aplicación intenta escribir en un directorio dentro del contenedor que no tiene permisos, puede fallar. Considera crear un usuario no root en tu Dockerfile y ejecutar la aplicación con ese usuario para mejorar la seguridad.
  • Imágenes base incorrectas o demasiado grandes: Usar una imagen base como python:latest puede llevar a imágenes muy grandes. Opta por variantes -slim o -alpine cuando sea posible para reducir el tamaño y la superficie de ataque.
  • Depuración de contenedores:
    • docker logs [nombre_contenedor]: Muestra la salida estándar (stdout y stderr) de tu contenedor, lo cual es invaluable para ver errores de la aplicación.
    • docker exec -it [nombre_contenedor] bash: Te permite entrar en el contenedor y ejecutar comandos como si estuvieras en una máquina virtual. Esto es útil para inspeccionar el sistema de archivos, verificar dependencias o ejecutar scripts manualmente.
    • docker inspect [nombre_contenedor]: Proporciona información detallada sobre la configuración del contenedor, incluyendo redes, volúmenes y variables de entorno.
  • Archivos no deseados en la imagen: Crea un archivo .dockerignore (similar a .gitignore) para excluir archivos y directorios innecesarios (como .git, __pycache__, .env, etc.) de tu imagen, reduciendo su tamaño y posibles riesgos de seguridad.

Aprendizaje Futuro / Próximos Pasos

La containerización con Docker es solo el primer paso en el camino hacia un despliegue robusto y escalable de aplicaciones de IA. Aquí hay algunas áreas clave para explorar a continuación:

  • Docker Compose para entornos multi-servicio: Si tu aplicación de IA crece para incluir una base de datos, un caché (Redis) o un frontend separado, Docker Compose te permitirá definir y orquestar todos estos servicios en un solo archivo YAML, simplificando el desarrollo local y las pruebas.
  • Orquestación de contenedores a escala (Kubernetes): Para despliegues en producción que requieren alta disponibilidad, escalabilidad automática y gestión de recursos complejos (como GPUs), Kubernetes es el estándar de la industria. Aprender Kubernetes te permitirá gestionar tus contenedores Docker en clusters de servidores.
  • CI/CD con Docker: Integra la construcción de tus imágenes Docker en tus pipelines de Integración Continua/Despliegue Continuo (CI/CD). Herramientas como GitHub Actions, GitLab CI/CD o Jenkins pueden automatizar la construcción, el testeo y el despliegue de tus imágenes cada vez que se realiza un cambio en el código.
  • Optimización de imágenes Docker: Explora técnicas avanzadas como las "multi-stage builds" para crear imágenes de producción más pequeñas y seguras, separando las dependencias de construcción de las de tiempo de ejecución. También, profundiza en el uso de .dockerignore y la elección de imágenes base mínimas.
  • Seguridad de contenedores: Aprende sobre las mejores prácticas de seguridad para contenedores, incluyendo el escaneo de vulnerabilidades de imágenes, la ejecución de contenedores con el menor privilegio posible (no como root) y la implementación de políticas de red.
  • Volúmenes persistentes y gestión de datos: Para modelos que se reentrenan o datos que necesitan persistir, investiga cómo usar volúmenes de Docker de manera efectiva y cómo integrarlos con soluciones de almacenamiento en la nube.

Dominar Docker te proporcionará una base sólida para construir, desplegar y escalar tus aplicaciones de IA de manera eficiente y confiable, preparándote para los desafíos del desarrollo de software moderno.

Volver al blog