Quiz: Conceptos Básicos de Docker

Concepto clave

Docker es una plataforma de containerización que permite empaquetar aplicaciones y sus dependencias en unidades estandarizadas llamadas contenedores. Imagina que eres un científico de datos que necesita enviar un modelo de machine learning a un colega. En lugar de enviar un documento largo con instrucciones sobre cómo configurar Python, instalar bibliotecas específicas y configurar variables de entorno, simplemente le envías un paquete que contiene todo lo necesario para ejecutar el modelo, listo para usar en cualquier computadora. Eso es lo que hace Docker: crea un entorno aislado y reproducible que garantiza que tu código funcione de la misma manera en cualquier lugar, desde tu laptop hasta un servidor en la nube.

Los contenedores son ligeros porque comparten el kernel del sistema operativo del host, a diferencia de las máquinas virtuales que requieren un sistema operativo completo. Esto los hace ideales para desplegar modelos de ML, donde la eficiencia y la portabilidad son cruciales. Por ejemplo, si desarrollas un modelo en TensorFlow con Python 3.8 en tu máquina local, Docker asegura que ese mismo entorno se replique exactamente en producción, evitando problemas como "funciona en mi máquina".

Cómo funciona en la práctica

Para containerizar un modelo de ML con Docker, sigues un flujo paso a paso que comienza con la creación de un Dockerfile, un archivo de texto que define cómo construir la imagen del contenedor. Primero, especificas una imagen base, como una versión oficial de Python. Luego, instalas las dependencias necesarias, como scikit-learn o pandas, copias tu código y configuras el punto de entrada para ejecutar el modelo. Una vez que tienes el Dockerfile, usas el comando docker build para crear una imagen, que es una plantilla inmutable del contenedor. Finalmente, ejecutas la imagen con docker run para iniciar un contenedor en vivo.

Veamos un ejemplo básico: supongamos que tienes un script de Python llamado modelo.py que entrena un clasificador simple. El proceso implica escribir un Dockerfile, construir la imagen y ejecutarla. Esto te permite probar el modelo en un entorno aislado antes de desplegarlo en Kubernetes. La clave es que cada paso es reproducible; si alguien más clona tu repositorio, puede reconstruir la imagen exacta y obtener los mismos resultados.

Código en acción

Aquí tienes un ejemplo funcional de un Dockerfile para un modelo de ML básico. Primero, el antes: un script de Python sin containerizar que podría fallar en otra máquina debido a dependencias faltantes.

# modelo.py
import pandas as pd
from sklearn.linear_model import LogisticRegression
import pickle

# Cargar datos y entrenar modelo
data = pd.read_csv('datos.csv')
X = data.drop('target', axis=1)
y = data['target']
model = LogisticRegression()
model.fit(X, y)

# Guardar modelo
with open('modelo.pkl', 'wb') as f:
    pickle.dump(model, f)
print("Modelo entrenado y guardado")

Ahora, el después: un Dockerfile que containeriza este script, asegurando que funcione en cualquier entorno.

# Dockerfile
# Usar una imagen base oficial de Python
FROM python:3.8-slim

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

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

# Copiar el script de Python
COPY modelo.py .
COPY datos.csv .

# Comando para ejecutar el script
CMD ["python", "modelo.py"]

Para construir y ejecutar: docker build -t modelo-ml . y luego docker run modelo-ml. Esto crea un contenedor que ejecuta el modelo de forma aislada.

Errores comunes

• No optimizar el tamaño de la imagen: Usar imágenes base grandes como python:latest puede resultar en imágenes de varios GB. Solución: usa versiones slim (e.g., python:3.8-slim) y limpia cachés después de instalar paquetes.
• Olvidar exponer puertos: Si tu modelo sirve predicciones via API (e.g., con Flask), no configurar EXPOSE en el Dockerfile puede evitar que el contenedor sea accesible. Solución: añade EXPOSE 5000 si usas el puerto 5000.
• Copiar archivos innecesarios: Incluir datos grandes o archivos temporales en la imagen aumenta su tamaño. Solución: usa un .dockerignore para excluir archivos como __pycache__ o datasets crudos.
• No usar variables de entorno para configuraciones: Hardcodear rutas o parámetros en el código limita la flexibilidad. Solución: usa ENV en el Dockerfile o pasa variables al ejecutar con -e.
• Ignorar el contexto de build: Ejecutar docker build desde un directorio incorrecto puede causar errores al copiar archivos. Solución: siempre verifica que el Dockerfile y los archivos necesarios estén en el mismo directorio o ajusta las rutas en el COPY.

Checklist de dominio

1. ¿Puedes explicar la diferencia entre una imagen Docker y un contenedor en una analogía simple?
2. ¿Sabes escribir un Dockerfile básico que instale Python, dependencias y ejecute un script de ML?
3. ¿Entiendes cómo usar docker build y docker run para crear y ejecutar contenedores?
4. ¿Puedes listar al menos tres mejores prácticas para optimizar imágenes Docker en proyectos de ML?
5. ¿Eres capaz de depurar un error común como "puerto no expuesto" o "dependencia faltante" en un contenedor?
6. ¿Conoces la utilidad de un archivo .dockerignore y cómo crearlo?
7. ¿Puedes containerizar un modelo simple y verificar que funcione en un entorno aislado?

Containeriza un modelo de clasificación con Docker

En este ejercicio práctico, containerizarás un modelo de machine learning básico usando Docker, simulando un escenario real donde necesitas empaquetar tu trabajo para compartirlo con un equipo. Sigue estos pasos:

1. Prepara tu entorno: Asegúrate de tener Docker instalado en tu máquina. Crea un nuevo directorio para el proyecto y navega a él en tu terminal.
2. Crea los archivos necesarios: Dentro del directorio, crea un script de Python llamado train_model.py que cargue un dataset simple (puedes usar sklearn.datasets.load_iris), entrene un modelo de clasificación (e.g., RandomForestClassifier), y guarde el modelo entrenado en un archivo model.pkl usando pickle.
3. Escribe un Dockerfile: Crea un archivo llamado Dockerfile (sin extensión) que:
   • Use la imagen base python:3.8-slim.
   • Establezca un directorio de trabajo, por ejemplo, /app.
   • Copie un archivo requirements.txt (que debes crear con al menos scikit-learn y pandas) e instale las dependencias.
   • Copie el script train_model.py.
   • Defina el comando para ejecutar el script al iniciar el contenedor.
4. Construye y ejecuta la imagen: En la terminal, ejecuta docker build -t ml-classifier . para construir la imagen. Luego, ejecuta docker run ml-classifier para iniciar el contenedor y ver la salida del entrenamiento.
5. Verifica el resultado: Confirma que el contenedor se ejecutó correctamente y que el archivo model.pkl se generó dentro del contenedor (puedes inspeccionar con docker run -it ml-classifier sh para entrar al contenedor y listar archivos).

Este ejercicio te prepara para containerizar flujos más complejos de ML y desplegarlos en Kubernetes.

• Recuerda que el archivo requirements.txt debe listar scikit-learn y pandas con versiones específicas si es necesario, por ejemplo: scikit-learn==1.0.2.
• Si encuentras un error al construir la imagen, verifica que todos los archivos (Dockerfile, requirements.txt, train_model.py) estén en el mismo directorio desde donde ejecutas docker build.
• Para ver los logs del contenedor si falla, usa docker logs después de ejecutarlo, o añade prints en tu script para depurar.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.