🎯 Objetivo del tema
El administrador aún no ha insertado un video para esta sección.
🗺️ Mapa del tema
Construir la API es solo la mitad del trabajo: la otra mitad es llevarla a internet. En la era del cloud, el deploy es sorprendentemente fácil: subes tu código a GitHub, conectas una plataforma de deploy (Railway, Render, Vercel), y en 2 minutos tienes tu API en producción con HTTPS automático. Vamos a ver el flujo completo, las mejores plataformas de 2024-2025, y los errores más comunes del primer deploy.
Railway, Render, Vercel: comparativa honesta.
Push, conectar repo, configurar env vars, deploy.
Cómo configurar JWT_SECRET, MONGODB_URI, etc. sin subirlos a Git.
De mi-app.railway.app a mi-app.com con HTTPS automático.
Cómo saber si tu API está caída y qué está fallando.
Los 7 problemas típicos y cómo solucionarlos.
2.11.1 Las 3 mejores plataformas de deploy para Node.js
En 2024-2025 hay 3 plataformas que dominan el deploy moderno de Node.js: Railway, Render y Vercel. Las 3 tienen plan gratuito, HTTPS automático, y deploy con cada push a GitHub. La elección depende de tu caso de uso, no del precio (las 3 son baratas o gratis para empezar).
| Aspecto | Railway | Render | Vercel |
|---|---|---|---|
| Plan gratuito | 500h/mes + $5 de crédito. | 750h/mes (servicios web). | Hobby plan (suficiente para aprender). |
| Mejor para | Backend completo (Node + BD). | Backend y frontend. | Frontend + serverless functions. |
| Soporta Docker | Sí. | Sí. | Limitado (mejor serverless). |
| Tiempo de deploy | 2-3 min desde push. | 2-3 min desde push. | 30 seg (es su especialidad). |
| Custom domain | Sí (gratis). | Sí (gratis). | Sí (gratis). |
| HTTPS automático | Sí. | Sí. | Sí. |
| PostgreSQL incluido | Sí (plugin). | Sí (gratis 90 días). | No (usar Neon, Supabase). |
El administrador aún no ha insertado un video para esta sección.
2.11.2 El flujo completo: de GitHub a producción
El deploy moderno es RIDÍCULAMENTE simple: subes tu código a GitHub, conectas tu repo a una plataforma, y cada vez que hagas push, la plataforma redespliega automáticamente. CI/CD gratis y sin configurar nada.
Paso a paso: tu primer deploy en Railway
- 1. Sube tu código a GitHub: git init, git add, git commit, git push.
- 2. Crea cuenta en railway.app con tu GitHub.
- 3. 'New Project' > 'Deploy from GitHub repo' > selecciona tu repo.
- 4. Railway detecta automáticamente que es Node.js (gracias al package.json).
- 5. Configura las variables de entorno: pestaña 'Variables' > agrega las de tu .env (excepto las que ya inyecta Railway).
- 6. Railway instala dependencias (npm install) y ejecuta 'npm start' automáticamente.
- 7. En 2-3 minutos, tu API está en producción en una URL tipo https://mi-app.railway.app.
- 8. Cada push a main redespliega automáticamente. Magia.
El administrador aún no ha insertado un video para esta sección.
2.11.3 Variables de entorno en producción
Las variables de entorno son el mecanismo para configurar tu app según el entorno: desarrollo, staging, producción. En desarrollo las pones en .env (con dotenv); en producción las configuras en la plataforma. NUNCA subas el .env a Git: cada entorno tiene las suyas.
| Variable | Desarrollo (.env) | Producción (Railway) |
|---|---|---|
| PORT | 3000 | Asignado por Railway (usar process.env.PORT). |
| MONGODB_URI | mongodb://localhost:... | mongodb+srv://user:pass@cluster.mongodb.net/... |
| JWT_SECRET | mi_secreto_dev | openssl rand -hex 64 (largo, aleatorio). |
| NODE_ENV | development | production. |
// .env (desarrollo, NUNCA subir a Git)
PORT=3000
MONGODB_URI=mongodb://localhost:27017/mi_app
JWT_SECRET=secreto_para_desarrollo
NODE_ENV=development
// .gitignore (CRÍTICO)
.env
.env.local
.env.production
node_modules/
// config.js: leer variables con validación
import dotenv from 'dotenv';
dotenv.config(); // lee el .env
export const config = {
port: process.env.PORT || 3000,
mongoUri: process.env.MONGODB_URI,
jwtSecret: process.env.JWT_SECRET,
nodeEnv: process.env.NODE_ENV || 'development',
};
// Validar que las variables críticas existan
if (!config.jwtSecret || config.jwtSecret.length < 32) {
throw new Error('JWT_SECRET debe existir y tener al menos 32 caracteres');
}Variables de entorno: .env, .gitignore, config.js
El administrador aún no ha insertado un video para esta sección.
2.11.4 Dominio personalizado y HTTPS
Tu API empieza en mi-app.railway.app. Para profesionalizar, usas un dominio personalizado: api.mi-dominio.com. Las 3 plataformas (Railway, Render, Vercel) tienen HTTPS automático con Let's Encrypt: tu sitio se sirve por HTTPS sin que tengas que configurar nada.
Cómo configurar un dominio personalizado
- 1. Compra el dominio en Namecheap, Google Domains, Cloudflare (~$10/año).
- 2. En tu plataforma (Railway > Settings > Domains), agrega api.mi-dominio.com.
- 3. La plataforma te da un CNAME: api.mi-dominio.com CNAME mi-app.railway.app.
- 4. En tu registrador de dominios, configura ese CNAME.
- 5. Espera 5-30 minutos a que propague el DNS.
- 6. La plataforma automáticamente emite un certificado Let's Encrypt y activa HTTPS.
- 7. Configura redirects: HTTP -> HTTPS, www -> sin www (en la plataforma o en Cloudflare).
El administrador aún no ha insertado un video para esta sección.
2.11.5 Monitoreo y logs en producción
En producción, necesitas saber si tu API está caída, si tiene errores, y cómo está rindiendo. Las 3 plataformas (Railway, Render, Vercel) te dan logs en tiempo real, métricas básicas (CPU, RAM, requests), y alertas. Para cosas más avanzadas, hay herramientas gratuitas como UptimeRobot (monitoreo 24/7) y Sentry (tracking de errores).
| Herramienta | Para qué sirve | Costo |
|---|---|---|
| Logs de Railway/Render | Ver requests, errores, y stdout de tu app en tiempo real. | Incluido. |
| UptimeRobot | Te avisa si tu API está caída (cada 5 min). | Gratis hasta 50 monitores. |
| Sentry | Tracking de errores: te dice QUÉ error, en QUÉ línea, con qué contexto. | Gratis hasta 5,000 eventos/mes. |
| LogRocket / Hotjar | Grabaciones de sesiones de usuarios (ver qué hacen). | Gratis hasta 1,000 sesiones. |
| Google Analytics | Tráfico y comportamiento de usuarios. | Gratis. |
El administrador aún no ha insertado un video para esta sección.
2.11.6 Errores comunes del primer deploy
El primer deploy SIEMPRE tiene errores. Es normal, es humano, y es la mejor forma de aprender. Aquí están los 7 problemas más comunes y cómo solucionarlos en menos de 5 minutos cada uno.
| Error | Causa típica | Solución |
|---|---|---|
| 'Application failed to start' | Script de inicio incorrecto o dependencias faltantes. | Verifica que 'npm start' funcione localmente. |
| 'Cannot connect to MongoDB' | MONGODB_URI no configurada o BD en otra red. | Configura la URI en variables de entorno de la plataforma. |
| 'Port 3000 already in use' | Hardcoded port en vez de process.env.PORT. | Usa process.env.PORT || 3000. |
| 'JWT must be provided' | JWT_SECRET no configurada en producción. | Agrega JWT_SECRET a las env vars de la plataforma. |
| 'CORS error' en el frontend | El backend no permite el dominio del frontend. | Configura cors({ origin: 'https://mi-frontend.com' }). |
| 404 en todas las rutas | Sirves el frontend con Express pero la ruta es del backend. | Separa frontend y backend en servicios distintos. |
| App se duerme después de inactividad | Plan gratuito duerme servicios sin uso. | Upgrade a plan pago, o usa un keep-alive ping (UptimeRobot). |
El administrador aún no ha insertado un video para esta sección.
📚 Contenido ampliado
Material adicional, referencias externas verificadas y ejemplos extendidos.
🤖 AI Mission
El primer deploy enseña más que 10 tutoriales. Hazlo.
Misión: Toma tu API de Express + MongoDB del Tema 2.10, súbela a Railway, configura las variables de entorno, y verifica que funcione en producción. Después, configura un dominio personalizado (o un subdominio gratis) y HTTPS. Pídele a la IA que audite tu deploy. Anota en tu cuaderno: ¿qué problemas encontraste? ¿cuánto tardaste en tener la API en producción?
Pasos sugeridos
- Asegúrate de que tu API funciona localmente con npm start.
- Sube el código a GitHub: git add, commit, push.
- Crea cuenta en railway.app con GitHub.
- New Project > Deploy from GitHub > selecciona tu repo.
- Configura variables de entorno en Railway: MONGODB_URI, JWT_SECRET, NODE_ENV=production.
- Espera 2-3 min a que termine el deploy. Railway te da una URL.
- Prueba la URL: GET /perfil, POST /login. ¿Funciona?
- Si hay errores, ve a la pestaña 'Logs' y léelos.
- Configura un monitor en UptimeRobot.com (gratis) para que te avise si la API se cae.
- Opcional: configura un dominio personalizado (comprar dominio ~$10, o usar un subdominio gratis con servicios como eu.org).
- Pídele a la IA: 'Tengo mi API en Railway. Dame 2 sugerencias de mejora: seguridad, performance, o monitoreo. NO me des código, dime QUÉ agregar.'
- Aplica 2 mejoras.
- Anota en tu cuaderno: 3 problemas que encontraste, cómo los resolviste, y cuánto tardaste de localhost a producción.
📓 Entregable: URL pública de tu API en Railway, capturas de: pantalla de Railway con el deploy exitoso, logs sin errores, monitor de UptimeRobot activo, y media página de cuaderno con tu reflexión del proceso.
🚫 Errores típicos de razonamiento
Por qué: .env contiene secretos (JWT_SECRET, MONGODB_URI, API keys). Si lo subes a Git, cualquiera con acceso al repo puede verlos y usarlos. Solución: agregar .env a .gitignore desde el INICIO del proyecto. Si ya lo subiste, hay que ROTAR todos los secretos (cambiar las claves) porque Git guarda el historial.
Por qué: Las plataformas de deploy (Railway, Render, Heroku) asignan un puerto DINÁMICAMENTE vía la variable de entorno PORT. Si hardcodeas 3000, la plataforma no puede enrutar las peticiones. Usa SIEMPRE: const PORT = process.env.PORT || 3000; Es un error tan común que hay memes sobre él.
Por qué: Si tu API se cae de noche y no la abres, no te enteras hasta que un usuario se queja. Un monitor externo (UptimeRobot, gratis) te avisa por email/Slack cuando tu API está caída. Es la diferencia entre enterarte en minutos vs enterarte en horas.
Por qué: Por seguridad, los navegadores bloquean peticiones cross-origin (frontend en un dominio, backend en otro). Si tu frontend está en mi-app.vercel.app y tu backend en api.railway.app, el navegador va a bloquear las peticiones a menos que el backend explícitamente permita ese origen con cors({ origin: 'https://mi-app.vercel.app' }).
Por qué: Si tu código de desarrollo (con tu secret) se filtra, el atacante puede generar tokens válidos para tu producción. Genera SIEMPRE secrets DIFERENTES por entorno: openssl rand -hex 64 para producción. Es una capa más de defensa en profundidad.
🧪 Laboratorio práctico
El primer deploy es un rito de paso. Hazlo, sufre un poco, y nunca más lo olvidarás.
Laboratorio: Deploy completo de tu API con Railway + UptimeRobot + Sentry
Objetivo: Llevar tu API de Express + MongoDB del Tema 2.10 a producción con Railway, configurar monitoring con UptimeRobot, tracking de errores con Sentry, y un subdominio personalizado (opcional). El resultado: tu API en internet, monitoreada, y con HTTPS.
Pasos
- Parte del proyecto 'api-libros-mongo' del Tema 2.10.
- Verifica que .env NO está en Git, pero .env.example SÍ (con placeholders).
- Verifica que el script 'start' funciona: npm start debe arrancar la app.
- Sube a GitHub: git add, commit, push.
- Crea cuenta en railway.app con GitHub.
- New Project > Deploy from GitHub > selecciona tu repo.
- Configura variables: MONGODB_URI, JWT_SECRET, NODE_ENV=production.
- Espera 2-3 min. Verifica que la URL de Railway responde.
- Ve a la pestaña Logs: ¿hay errores? Corrígelos.
- Crea cuenta en sentry.io (gratis). Crea un proyecto Node.js.
- Instala: npm install @sentry/node. Agrega Sentry.init() en server.js.
- Configura la DSN de Sentry como variable de entorno en Railway.
- Prueba: tira tu app a propósito (throw new Error('test')). Verifica que Sentry captura el error.
- Crea cuenta en uptimerobot.com. Agrega un monitor HTTP a la URL de Railway cada 5 min.
- Comparte la URL con 1 persona y pídele feedback.
- Haz commit: 'feat: deploy con Railway, Sentry y UptimeRobot configurados'.
- Anota en tu cuaderno: URL pública, problemas encontrados, soluciones, tiempo total de deploy.
📓 Entregable: URL pública de la API en Railway, capturas de: deploy exitoso, dashboard de Sentry con un error capturado, monitor de UptimeRobot activo, y commit en Git.