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 tu modelo de machine learning a un colega en otro departamento. Sin Docker, tendrías que enviar una lista larga de instrucciones: "instala Python 3.8, luego numpy 1.21, luego scikit-learn 0.24, asegúrate de que el sistema operativo sea Ubuntu 20.04..." Con Docker, simplemente envías un contenedor que ya contiene todo lo necesario, como una maleta lista para viajar que tiene toda tu ropa organizada y lista para usar.

La diferencia clave con las máquinas virtuales tradicionales es que los contenedores comparten el kernel del sistema operativo anfitrión, lo que los hace mucho más ligeros y rápidos. Para un científico de datos, esto significa poder reproducir exactamente el mismo entorno de desarrollo en cualquier máquina, desde tu laptop hasta un servidor en la nube, eliminando el famoso problema de "funciona en mi máquina".

Cómo funciona en la práctica

Vamos a ver el flujo típico que seguirás como científico de datos. Primero, escribes un Dockerfile, que es como una receta que describe cómo construir tu contenedor. Este archivo especifica la imagen base (por ejemplo, una imagen con Python y las bibliotecas científicas ya instaladas), copia tu código, instala dependencias adicionales y define cómo ejecutar tu aplicación.

Luego, usas el comando docker build para crear una imagen a partir de ese Dockerfile. Esta imagen es un paquete inmutable que contiene tu aplicación y todo lo que necesita. Finalmente, con docker run, creas y ejecutas un contenedor a partir de esa imagen. Piensa en la imagen como la clase en programación orientada a objetos, y el contenedor como una instancia de esa clase que se está ejecutando.

Código en acción

Aquí tienes un Dockerfile básico para un modelo de ML simple:

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

# Establecemos el directorio de trabajo dentro del contenedor
WORKDIR /app

# Copiamos el archivo de requisitos primero (para aprovechar la caché de Docker)
COPY requirements.txt .

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

# Copiamos el resto del código de la aplicación
COPY . .

# Comando para ejecutar cuando se inicie el contenedor
CMD ["python", "train_model.py"]

Y aquí está el archivo requirements.txt correspondiente:

numpy==1.21.0
pandas==1.3.0
scikit-learn==0.24.2
joblib==1.0.1

Errores comunes

1. No limpiar la caché de pip en el Dockerfile: Si instalas paquetes con pip sin el flag --no-cache-dir, la imagen final será más grande de lo necesario. Siempre usa RUN pip install --no-cache-dir -r requirements.txt.

2. Copiar todo el directorio al principio: Esto invalida la caché de Docker en cada cambio pequeño. En su lugar, copia primero los archivos que cambian menos (como requirements.txt), instala dependencias, y luego copia el resto del código.

3. Ejecutar como usuario root por defecto: Por seguridad, crea un usuario no privilegiado en tu Dockerfile y ejecuta la aplicación con ese usuario.

4. No especificar versiones exactas en requirements.txt: Esto puede llevar a inconsistencias entre entornos. Siempre fija las versiones de tus dependencias.

Checklist de dominio

✓ Puedo explicar la diferencia entre imagen Docker y contenedor
✓ Sé escribir un Dockerfile básico para una aplicación Python
✓ Entiendo cómo usar la caché de Docker eficientemente
✓ Puedo construir una imagen con docker build
✓ Sé ejecutar un contenedor con docker run
✓ Comprendo la importancia de las capas en las imágenes Docker
✓ Sé inspeccionar imágenes y contenedores con comandos como docker images y docker ps

Containeriza tu primer modelo de ML

En este ejercicio, containerizarás un script simple de entrenamiento de modelo de machine learning.

Crea un directorio nuevo para tu proyecto

Dentro del directorio, crea un archivo train_model.py con este contenido:

import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
import joblib

# Cargar datos
data = load_iris()
X = pd.DataFrame(data.data, columns=data.feature_names)
y = pd.Series(data.target)

# Dividir datos
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Entrenar modelo
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Guardar modelo
joblib.dump(model, 'iris_model.pkl')
print("Modelo entrenado y guardado como iris_model.pkl")
print(f"Accuracy en test: {model.score(X_test, y_test):.2f}")

Crea un archivo requirements.txt con las dependencias necesarias
Escribe un Dockerfile que:
- Use una imagen base de Python 3.8
- Establezca un directorio de trabajo
- Copie e instale las dependencias
- Copie el script Python
- Ejecute el script al iniciar el contenedor
Construye la imagen con: docker build -t mi-modelo-ml .
Ejecuta el contenedor con: docker run mi-modelo-ml
Verifica que el modelo se haya creado dentro del contenedor

Pistas

Recuerda que el archivo requirements.txt debe incluir scikit-learn, pandas y joblib
En el Dockerfile, copia primero requirements.txt para aprovechar la caché de Docker
Si ves errores de permisos, revisa que los archivos estén en el directorio correcto

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Instalación y Configuración de Docker en tu Máquina