Usar Volumes para Persistencia de Datos y Modelos

Concepto clave

En el mundo de los pipelines de Machine Learning, la persistencia de datos y modelos es como tener una bodega bien organizada para tu restaurante. Imagina que cada vez que cocinas (entrenas un modelo), tuvieras que comprar todos los ingredientes desde cero y tirar las recetas exitosas. Los volumes en Docker y Kubernetes son esa bodega que mantiene tus ingredientes (datos) y recetas (modelos) seguros y accesibles entre ejecuciones.

Un volume es un mecanismo para persistir datos generados y utilizados por contenedores Docker. A diferencia del sistema de archivos efímero del contenedor, que se destruye cuando el contenedor se detiene, los volumes sobreviven al ciclo de vida del contenedor. En Kubernetes, esto se extiende con PersistentVolumes y PersistentVolumeClaims, que abstraen los detalles del almacenamiento subyacente (como discos en la nube o sistemas NAS).

Cómo funciona en la práctica

Veamos un escenario típico: tienes un pipeline de ML que carga datos de entrenamiento, entrena un modelo, y guarda el modelo entrenado. Sin volumes, cada vez que el contenedor se reinicia, pierdes el modelo. Con volumes, montas un directorio persistente donde guardar el modelo.

Paso 1: Define un volume en tu Dockerfile o docker-compose.yml. Paso 2: En tu script de entrenamiento, guarda el modelo en la ruta montada. Paso 3: En Kubernetes, creas un PersistentVolumeClaim para solicitar almacenamiento, y montas ese claim en tu pod. Así, aunque el pod falle y se reinicie, el modelo persiste.

Codigo en accion

Primero, un ejemplo con Docker Compose para desarrollo local:

version: '3.8'
services:
  ml-training:
    build: .
    volumes:
      - model-storage:/app/models
    command: python train.py

volumes:
  model-storage:

Ahora, en Kubernetes para producción. Archivo pvc.yaml:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: ml-model-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

Archivo deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ml-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ml-app
  template:
    metadata:
      labels:
        app: ml-app
    spec:
      containers:
      - name: ml-container
        image: your-ml-image:latest
        volumeMounts:
        - name: model-storage
          mountPath: /app/models
        command: ["python", "train.py"]
      volumes:
      - name: model-storage
        persistentVolumeClaim:
          claimName: ml-model-pvc

Errores comunes

• No verificar permisos de escritura: Al montar volumes, asegúrate de que el usuario dentro del contenedor tenga permisos para escribir en el directorio montado. Usa chmod o configura el usuario en el Dockerfile.
• Confundir volumes con bind mounts: Los bind mounts dependen de la estructura del host, mientras que los volumes son gestionados por Docker. Para portabilidad en Kubernetes, usa volumes.
• Olvidar limpiar volumes no utilizados: Los volumes pueden acumularse y consumir espacio. Usa docker volume prune o gestiona lifecycle policies en Kubernetes.
• No probar la persistencia en reinicios: Siempre prueba que los datos sobreviven a un reinicio del contenedor o pod antes de pasar a producción.

Checklist de dominio

1. Puedo explicar la diferencia entre el sistema de archivos efímero de un contenedor y un volume persistente.
2. Sé cómo definir y usar un volume en Docker Compose para un proyecto de ML.
3. Puedo crear un PersistentVolumeClaim y montarlo en un pod de Kubernetes.
4. Entiendo cómo configurar permisos para evitar errores de escritura en volumes.
5. Puedo listar y limpiar volumes no utilizados en Docker y Kubernetes.
6. Sé cómo estructurar mi código de ML para guardar y cargar modelos desde rutas montadas.
7. Puedo probar la persistencia de datos tras reiniciar un contenedor o pod.

Implementar persistencia para un modelo de clasificación de imágenes

En este ejercicio, containerizarás un pipeline simple de ML que entrena un modelo de clasificación de imágenes y usa volumes para persistir el modelo entrenado.

1. Clona el repositorio de ejemplo: git clone https://github.com/ejemplo/ml-volume-demo.git
2. Examina el archivo train.py. Actualmente guarda el modelo en /tmp/model.pkl. Modifícalo para guardar en /app/models/model.pkl.
3. Crea un Dockerfile que:
   • Use una imagen base de Python 3.9
   • Copie el código y instale dependencias (scikit-learn, pandas)
   • Cree el directorio /app/models y establezca permisos adecuados
   • Defina un volume para /app/models
4. Construye la imagen: docker build -t ml-model:latest .
5. Crea un archivo docker-compose.yml que:
   • Defina un servicio usando la imagen construida
   • Monte un volume llamado model-storage en /app/models
6. Ejecuta con docker-compose up y verifica que el modelo se guarde.
7. Detén el contenedor con docker-compose down y vuelve a ejecutar. El modelo debería persistir.

• Recuerda que en Dockerfile, puedes usar VOLUME /app/models para declarar el punto de montaje.
• En docker-compose.yml, define el volume en la sección 'volumes' a nivel superior y refiérelo en el servicio.
• Si tienes errores de permisos, agrega 'USER root' en el Dockerfile temporalmente para debug.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.