Módulo 6: Modal — Deployment serverless de LLMs
Módulo 6: Modal — Deployment serverless de LLMs
Llegaste al módulo donde aprenderás a deployar un modelo de lenguaje a producción sin tener que aprender Kubernetes, sin levantar un cluster con GPUs, y sin pagar por una máquina prendida 24/7.
Hasta aquí, conoces tres formas de acceder a un LLM:
- OpenAI API (Módulo 2): managed en la nube, pagas por token, alguien más opera la infraestructura.
- LM Studio / Ollama (Módulos 3-4): self-hosted, corre en tu máquina o en un servidor que tú administras.
- OpenRouter (Módulo 5): un agregador que te da acceso a múltiples managed providers con una sola API.
Te falta una cuarta forma que está creciendo rápido en startups de AI: serverless con GPU. Y eso es Modal.
Al terminar este módulo vas a poder:
- Decidir cuándo Modal le gana a managed cloud y self-hosted (no es siempre, y eso es importante)
- Deployar una función Python con acceso a GPU en menos de 5 minutos
- Servir un modelo open-source (Mistral 7B) como endpoint REST con autoscaling
- Calcular el costo real de tu deployment para distintos patrones de tráfico
- Optimizar cold starts y cost para producción
¿Dónde estamos en el path?
Estás en el Módulo 6 de 8. Llevas:
| Módulo | Te enseñó |
|---|---|
| 1 | Framework para decidir qué proveedor usar |
| 2 | OpenAI API (cloud managed) |
| 3 | LM Studio (local con GUI) |
| 4 | Ollama (local con CLI + Docker) |
| 5 | OpenRouter (agregador multi-modelo) |
| 6 | Modal (serverless con GPU) ← estás aquí |
| 7 | Comparación cuantitativa de todas las opciones |
| 8 | Unified client que abstrae proveedores |
Después de este módulo te queda una opción más en tu caja de herramientas y vas a estar listo para la comparación cuantitativa del Módulo 7, donde benchmarkeas todas las opciones con datos reales.
El mapa mental: el cuarto cuadrante
Para entender Modal, ubícalo en este mapa:
| Tú no operas infraestructura | Tú operas infraestructura | |
|---|---|---|
| Modelos cerrados (GPT-4, Claude) | OpenAI / Anthropic / OpenRouter | (no aplica — son cerrados) |
| Modelos open-source (Mistral, Llama) | Modal, Replicate, RunPod | Ollama, LM Studio, vLLM en tu server |
El cuadrante "yo no opero infraestructura + corro modelos open-source que yo elijo" es donde vive Modal. Antes de que existieran estas plataformas, si querías correr Llama 3 en producción tenías que levantar tu propia GPU en AWS, instalar drivers de CUDA, configurar inference servers, manejar autoscaling... mucho trabajo de DevOps.
Modal hace una promesa específica: "escribe Python con un decorador, nosotros nos encargamos del resto". Tu código de inferencia no cambia. Lo que cambia es que tu función vive en una infraestructura que no existe hasta que alguien la invoca — y cuando termina, deja de existir y deja de cobrarte.
Esto se llama serverless con GPU. "Serverless" no quiere decir que no haya servidores (los hay, en data centers), quiere decir que tú no los administras y no pagas cuando no los usas.
Un escenario que ilustra el módulo
Imagina que eres AI Engineer en una startup de 6 personas. El producto es un chatbot de soporte técnico que usa un modelo open-source fine-tuneado (no quieres mandar conversaciones de clientes a OpenAI por una restricción contractual con clientes enterprise).
El tráfico tiene este patrón:
- 9am-6pm hora laboral: 200-400 requests/minuto
- 6pm-9pm: 50-80 requests/minuto
- 9pm-9am: prácticamente 0
- Fines de semana: 10% del tráfico de un día laboral
Tienes tres caminos:
Camino 1 — Self-hosted (Ollama en una VM con GPU): Rentas una A100 en AWS. Cuesta ~$2.50/hora prendida 24/7 = ~$1,800/mes. Funciona, pero pagas la GPU completa de domingo en la madrugada cuando nadie la usa. Y si un día el tráfico explota a 1,000 req/min, tu única GPU se satura.
Camino 2 — Managed (OpenAI): Descartado. La restricción contractual te bloquea.
Camino 3 — Serverless con GPU (Modal): Defines tu función de inferencia, Modal corre instancias solamente cuando llegan requests. En horario laboral escala a 4 instancias en paralelo si hace falta. En la madrugada, cero instancias prendidas. Pagas por segundos de GPU usados, no por horas reservadas.
El cálculo aproximado (con números públicos de Modal a inicios de 2026): si tu request promedio toma 800ms de GPU y procesas ~1.5M requests/mes, terminas pagando entre $300-600/mes según GPU elegida. Tres a seis veces menos que el camino self-hosted, con autoscaling gratis.
Pero — y esto es importante — si el tráfico fuera constante a 200 req/min las 24 horas, el self-hosted ganaría. Modal cobra por uso; con uso saturado, "por uso" termina siendo más caro que "renta fija de la GPU".
Este es exactamente el tipo de decisión que el Módulo 1 (Decision Framework) te enseñó a hacer. Modal no es mejor en abstracto — es mejor para tráfico variable o impredecible.
¿Por qué este módulo importa profesionalmente?
Tres razones concretas:
1. Startups AI lo usan en producción. Empresas como Suno, Lexica, Sieve, y muchas startups del último batch de Y Combinator corren su inferencia en Modal o competidores similares (Replicate, RunPod, Beam). Si trabajas en una startup AI en 2026, hay buena probabilidad de que te toque deployar algo serverless.
2. Es el único path realista para deployar modelos OSS sin equipo DevOps. Si trabajas solo o en un equipo chico, montar Kubernetes con GPU operators, drivers CUDA, autoscaling y observabilidad no es viable. Modal te deja saltar todo eso. Esto es un diferenciador real en entrevistas — saber deployar inferencia OSS sin pelearte con infraestructura.
3. Es el patrón que más se va a parecer al futuro. AWS Lambda popularizó serverless en 2014. GPU-serverless está en su fase equivalente a Lambda en 2016: emergente pero claramente la dirección. Aprender Modal te da el modelo mental para cualquier plataforma similar que aparezca.
Mapa del módulo
| Cápsula | Tema | Qué construirás / aprenderás |
|---|---|---|
| 01 | Introducción (esta cápsula) | Modelo mental + decisión de cuándo usar Modal |
| 02 | Setup cuenta y CLI | Cuenta gratis, CLI configurada, primer modal token |
| 03 | Primera función serverless | Función Python remota con decorador, observas cold start |
| 04 | Deploy de un modelo LLM | Mistral 7B con vLLM, GPU A10G, carga de pesos en imagen |
| 05 | API REST con Modal | Endpoint HTTP público con autenticación básica |
| 06 | Autoscaling y cold starts | Container reuse, keep-warm, GPU pinning para reducir latencia |
| 07 | Cost optimization | Cálculo real de costo por request, GPU sizing, batching |
| 08 | Proyecto: API escalable | Endpoint production-ready con monitoring básico |
El flujo es: entiendes la plataforma (01) → te conectas (02) → corres un hello-world (03) → escalas a un LLM real (04) → lo expones como API (05) → lo afinas para producción (06-07) → cierras con un proyecto integrable (08).
Conexión con el proyecto final del path
El Módulo 8 del path construye un Unified AI Client que abstrae proveedores. Tu deployment de Modal de este módulo va a ser uno de los providers detrás de esa abstracción:
client = UnifiedAIClient(provider="modal", fallback=["openrouter", "ollama"])
response = client.chat("¿Qué es FastAPI?")Cuando llegues al Módulo 8, ya vas a tener tu Modal endpoint funcionando — sólo vas a escribir el adaptador. Por eso este módulo termina con un endpoint robusto, no un demo.
Qué NO se cubre en este módulo
Para mantener el scope claro:
- ❌ Fine-tuning de modelos en Modal. Modal soporta entrenamiento; este módulo cubre solo inferencia. El fine-tuning vive en la guía Advanced LLM Techniques.
- ❌ Cluster autoscaling avanzado (multi-region, GPU pooling complejo). Vemos autoscaling básico, no orquestación enterprise.
- ❌ Comparación cuantitativa contra los otros providers. Eso es el Módulo 7, donde benchmarkeas todo con datos reales.
- ❌ Construcción de tu propio inference server con vLLM/TGI desde cero. Usamos vLLM como caja parcialmente cerrada; profundizar en optimización a nivel kernel está fuera de scope.
- ❌ Alternativas equivalentes (Replicate, RunPod, Beam). Mencionamos cuándo elegirlas, no las cubrimos hands-on. El modelo mental de Modal te transfiere a ellas.
Trampas comunes al cursar este módulo
Cuatro malentendidos que valen la pena evitar:
Trampa 1 — "Serverless es gratis." No lo es. "Serverless" sólo significa que no pagas infraestructura inactiva. Cuando tu función corre, pagas segundos de GPU y eso suma rápido si tu modelo es lento o tu tráfico es alto. Antes de deployar a producción, mide cost-per-request (lo vemos en cápsula 07).
Trampa 2 — "Modal compite con OpenAI." No. OpenAI te vende acceso a un modelo cerrado (GPT-4, etc.). Modal te vende infraestructura para correr el modelo que tú elijas (Mistral, Llama, tu fine-tune). Son productos distintos. Si quieres GPT-4, no usas Modal. Si quieres correr un modelo OSS sin levantar tu propia infra, sí.
Trampa 3 — "Más GPU = mejor." La GPU más grande no siempre es la respuesta. Una A10G ($) puede servir Mistral 7B perfectamente bien. Pasar a H100 ($$$$) sólo tiene sentido si tu modelo no entra en la A10G o necesitas throughput muy alto. La cápsula 04 te enseña a elegir GPU según modelo.
Trampa 4 — "El cold start no importa."
Sí importa, mucho. Si tu chatbot tarda 30 segundos en responder la primera vez porque tiene que descargar pesos de 14GB, perdiste al usuario. La cápsula 06 cubre estrategias: container reuse, keep_warm, pre-warmed pools.
Pregunta de auto-evaluación
Antes de avanzar a la cápsula 02, asegúrate de poder responder:
- ¿Cuál es la diferencia entre managed (OpenAI), self-hosted (Ollama en tu server) y serverless con GPU (Modal)? ¿En una frase cada uno?
- Para un workload con tráfico constante 24/7, ¿qué opción es probablemente más barata: Modal o un servidor self-hosted con Ollama? ¿Por qué?
- Si una startup necesita correr Llama 3 70B y no tiene equipo DevOps, ¿qué camino tiene más sentido y por qué?
- ¿Qué significa cold start en el contexto de serverless? ¿Qué lo causa cuando sirves un LLM?
Si dudas en alguna, vale la pena releer la sección "Un escenario que ilustra el módulo" arriba antes de seguir. Si te sientes cómodo respondiendo todo, estás listo.
Respuestas guía
- Managed: alguien corre y opera el modelo, tú llamas una API y pagas por uso. Self-hosted: tú levantas y administras la máquina que corre el modelo. Serverless con GPU: alguien provee la infraestructura on-demand, tú escribes el código y pagas por tiempo de ejecución, sin operar nada.
- Self-hosted suele ganar con tráfico constante 24/7 porque la GPU está saturada, y "pagar la GPU completa" termina siendo más eficiente que "pagar por uso" cuando el uso es máximo. Modal gana con tráfico variable.
- Modal (o equivalentes serverless). Llama 3 70B requiere GPUs grandes; sin equipo DevOps, levantar y administrar GPUs grandes en AWS/GCP es muy costoso en tiempo humano.
- Cold start = tiempo desde que llega un request hasta que tu función empieza a responder, cuando no había una instancia corriendo. En LLMs lo dominan: arrancar el container, descargar pesos del modelo, cargarlos en GPU. Puede ir de segundos a minutos dependiendo del modelo.
Evidencia de éxito al terminar el módulo
Vas a saber que tuviste éxito si:
- Tienes una cuenta de Modal funcionando y CLI autenticada
- Deployaste un endpoint REST público que sirve Mistral 7B con GPU
- Sabes el costo aproximado por request de tu deployment
- Puedes explicarle a otro engineer (o a un PM) cuándo Modal le gana a las alternativas y cuándo no
- Tu endpoint está listo para conectarse al Unified Client del Módulo 8
La siguiente cápsula
Empezamos con 02: Setup de cuenta y CLI, donde:
- Creas tu cuenta gratis con los créditos iniciales
- Instalas y autenticas la CLI de Modal
- Verificas que puedes correr una función remota desde tu máquina
Antes de avanzar, asegúrate de tener:
- Python 3.10+ instalado
pipouvfuncionando- Una cuenta de email para registrarte en Modal
- Familiaridad básica con terminal (estuvo cubierto si vienes del Módulo 4 con Ollama)
Tiempo estimado para terminar el módulo: 2-3 horas.
Recursos para el módulo
- Modal Docs — Getting Started — referencia oficial, la fuente de verdad de sintaxis y precios.
- Modal Pricing — precios actuales de GPU/CPU/storage. Cambian; consulta antes de calcular cost de producción.
- Modal Examples Repo — ejemplos oficiales, incluyendo varios LLMs.
- vLLM Documentation — el inference server que usaremos sobre Modal para servir Mistral.
- "GPU serverless landscape 2024-2026" — contexto comparando Modal vs Replicate, RunPod, Beam (mantente crítico: lo escribió Modal).
- Hugging Face Mistral 7B Instruct — el modelo que deployaremos.