Curso de Docker Model Runner para Equipos de Infraestructura

Instalación de Docker y Docker Compose

Instalación de Python, pip y virtualenv

Estructura recomendada de proyecto

Gestión de dependencias con `requirements.txt` o `poetry`

Práctica: crear un proyecto modelo simple

Instalación de herramientas auxiliares (Postman, curl)

Uso de Makefiles para reproducibilidad

Configurar acceso GPU en Docker

Setup en Windows Subsystem for Linux (WSL)

Control de versiones con Git

Guardar modelos con `pickle`, `joblib`, `ONNX`, `torchscript`

Serialización y compatibilidad

Estructura de entrada/salida estándar

Práctica: guardar modelo de clasificación sklearn

Validación de consistencia del modelo

Versión del framework y la dependencia

Empaquetado de modelos en carpeta `model/`

Separación de lógica de inferencia

Tips para modelos grandes

Seguridad y limpieza del artefacto

¿Qué es FastAPI y por qué se usa?

Práctica: crear endpoint `/predict`

Validación automática de entrada con Pydantic

Respuesta JSON estructurada

Manejo de errores y logs

Middleware útil (CORS, logging, auth)

Swagger automático y documentación

Tests básicos con `pytest`

Monitorización con Prometheus o Logs

Buenas prácticas de API para modelos

Estructura mínima de un Dockerfile

Multi-stage builds y optimización

Práctica: Dockerizar modelo sklearn + FastAPI

Uso de `ENTRYPOINT` vs `CMD`

Variables de entorno

Exposición de puertos

Build reproducible y pequeño

Consideraciones de seguridad

Validación post-build

Generar imagen y ejecutar con `docker run`

¿Qué es y para qué sirve `docker-compose.yml`?

Práctica: añadir MongoDB o Redis para caché

Configurar redes, volúmenes y variables

Healthchecks para containers de modelos

Levantar stack completo con `docker compose up`

Logs y debugging con Compose

Entradas simuladas y batch mode

Servicio de UI para pruebas

Configurar entornos dev/test/prod

Reutilizar configuración entre proyectos

Estructura de carpetas por versión

Práctica: `/models/v1/model.pkl`, `/v2/model.onnx`

Uso de `ENV` y `ARG` para cambiar modelos en Dockerfile

Carga dinámica en ejecución

Versionado semántico en endpoints

Múltiples versiones servidas a la vez

Control desde frontend o API Gateway

Registros de modelos y metadatos

Documentación interna por versión

Validación automática

Servir en localhost y probar con curl/Postman

Exponer vía `ngrok` o túneles seguros

Práctica: desplegar en EC2 + Docker

Alternativas: Railway, Render, Heroku, Modal

Persistencia de logs y stats

Seguridad con HTTPS y CORS

Control de tráfico entrante

Endpoint para `health` y `readiness`

Deployment a pruebas o QA

Buenas prácticas de despliegue simple

Diferencias entre batch y online

Práctica: endpoint para inferencia de múltiples entradas

Validación paralela de entradas

Queue en memoria (Redis, Celery)

Background tasks con FastAPI

Resultados en bloque o stream

Control de carga y throttling

Códigos de respuesta estándar

Callback para procesamiento posterior

Diseño de pipelines asincrónicos

Configuración de GPU con NVIDIA Docker

Práctica: servir modelo PyTorch con CUDA

Imagen base oficial NVIDIA

Monitorización del uso de GPU

Precauciones en builds multiarch

Control de compatibilidad CUDA/cuDNN

Benchmark y perfilado de inferencia

Control de tiempo de respuesta

Balanceo CPU/GPU

Casos reales en visión o NLP

Tests unitarios y de integración

Práctica: validar predict(), estructura de entrada

Tests para API con `pytest`, `requests`, `httpx`

Validaciones contractuales de entrada

Fixtures de datos de prueba

Test de estrés (artillery, locust)

Verificación de compatibilidad REST

Mock de backend o servicios externos

Generación de cobertura

Automatización en pipeline CI

GitHub Actions para test y build

Práctica: pipeline que construye y sube imagen

Pruebas automáticas al hacer merge

Linter + test + docker build + push

Despliegue automatizado en staging

Control de credenciales en GitHub Secrets

Versionado automático por tag

Imagen por feature branch

Rollbacks y validaciones

Documentación generada en CI

Logs estructurados con `structlog`, `loguru`

Exportación a stdout para Docker

Ingesta en Promtail + Loki o CloudWatch

IDs de solicitud para trazabilidad

Práctica: log de cada predicción

Logs de errores y tiempo medio

Obfuscación de datos sensibles

Trazabilidad completa por versión de modelo

Integración con Sentry o ELK

Reporte automático de fallos

Métricas básicas: latencia, throughput, errores

Exportar con Prometheus

Dashboard en Grafana

Práctica: ver latencia promedio y por clase

Exportar métricas por endpoint

Métricas de hardware (RAM, CPU, GPU)

Alertas configurables

Panel por versión de modelo

Visualización por cliente o input

Observabilidad MLOps

Práctica: proteger endpoint con API Key

Uso de tokens JWT

Autenticación básica o OAuth2

Roles: admin, usuario, auditor

Rate limiting por usuario/IP

Encriptado de tráfico

Validación de cabeceras y orígenes

Autorización a endpoints específicos

Acceso temporal o tokens firmados

Registro de accesos

Práctica: servir 3 modelos con balanceador

Load balancing (Traefik, Nginx)

Routing por versión/modelo/cliente

Despliegue canario o A/B testing

Clúster de runners con Docker Swarm o Kubernetes

Replicación dinámica

Monitoreo distribuido

Logs por contenedor

Escalado manual y automático

Observabilidad por nodo

Crear Deployment y Service

Práctica: correr Model Runner en Minikube

Montar volúmenes para modelos

ConfigMaps y Secrets

Health Probes

HPA (Horizontal Pod Autoscaler)

Ingress y TLS

Observabilidad con Prometheus Operator

Canary y rolling update

Helm Chart básico

Generar OpenAPI/Swagger con FastAPI

Práctica: documentación autoexplorable

Añadir ejemplos de uso en frontend o SDK

Generación automática de cliente (`openapi-generator`)

Incluye metadata del modelo (versión, fecha, precisión)

Endpoint `/model_info`

Repositorio estructurado y reusable

README con pruebas y ejemplos

Publicación de changelogs

Entrega con Docker Hub o ECR

Seleccionar un modelo real (visión/NLP/tabular)

Diseñar input/output y API

Crear Model Runner desde cero

Dockerizar y probar localmente

Crear imagen y desplegar

Monitorear métricas

Agregar control de acceso básico

Publicar documentación

Pruebas de inferencia

Presentación del proyecto final

Buenas prácticas en MLOps con Docker

Diferencias con soluciones como Triton o BentoML

Comunidad OSS y GitHub

Tendencias en model serving

Opciones serverless para runners

Documentación oficial de Docker + IA

Microservicios vs modelo monolítico

Control del ciclo de vida de modelos

Casos reales (NLP, visión, predicción tabular)

Próximos pasos: CI/CD, Model Registry, Seldon, KServe