Vertical u horizontal
- Lección 4 de 40
- 11 min
- Inicial
- 11 pasos
Tu app vive en un solo servidor y el tráfico no para de crecer. Hay dos caminos para ganar capacidad y cada uno tiene su precio.
- Usuarios
- 500.000
- Peticiones
- 20.000 pet/s
- Latencia p95
- 95 ms
- Errores
- 0%
- Coste US$/mes
- 14.400
- petición
- respuesta
- esperando en cola
Paso 1 de 11
Concepto
Una sola máquina lo hace todo
Al principio tu app corre en un único servidor: cada vez que alguien abre una pantalla o guarda algo, la petición sale de su dispositivo, llega a esa máquina y vuelve con la respuesta.
Con 100 usuarios conectados llegan unas 4 peticiones por segundo. La máquina tiene 4 vCPU y aguanta unas 400 pet/s, así que trabaja al 1%.
Paso 2 de 11
Problema
Un video se hace viral
De un día para otro tienes 120 veces más usuarios: 12.000 conectados y 480 pet/s. El servidor solo sirve unas 400, así que sobran 80 por segundo.
La CPU se queda clavada en el 100%, las peticiones esperan en cola, la latencia p95 sube a 2,4 s y cerca del 17% (80 de cada 480) termina en timeout.
Qué cambió
- Usuarios 100 → 12.000
- CPU 1% → 100%
- Timeouts: ≈ 17%
Paso 3 de 11
Solución
Camino 1: una máquina más grande
La salida más directa es cambiar a un servidor con más vCPU, más memoria y discos más rápidos. Pasas de 4 a 16 vCPU: unas 1.600 pet/s de capacidad.
El código no cambia en nada. A esto se le llama escalado vertical (escalar hacia arriba). Con 480 pet/s la CPU baja al 30%.
Qué cambió
- Servidor 4 → 16 vCPU
- CPU 100% → 30%
- Coste 150 → 600 US$/mes
Paso 4 de 11
Compromiso
Hasta que no hay máquina más grande
El producto sigue creciendo hasta 500.000 usuarios y 20.000 pet/s. Subes de tamaño una y otra vez hasta la máquina más grande del catálogo: 192 vCPU. Sobre el papel serían 19.200 pet/s, pero en la práctica rinde unas 17.600.
El software no aprovecha 192 núcleos igual que 16: locks, memoria compartida y un único disco se vuelven cuellos de botella. El 12% de las peticiones falla. Y cada salto de tamaño es una migración con reinicio.
Qué cambió
- Usuarios 12.000 → 500.000
- Máquina más grande alcanzada
- Coste 600 → 7.200 US$/mes
Paso 5 de 11
Problema
Todo depende de una sola caja
Hay un problema peor que el techo: si esa máquina cae, cae todo. Basta un despliegue con un bug, un disco lleno o una fuente de poder rota.
Un componente cuya caída tumba el sistema completo es un punto único de fallo (SPOF, por sus siglas en inglés).
Qué cambió
- Servidor de apps caído
- Errores 12% → 100%
Paso 6 de 11
Solución
Camino 2: más máquinas iguales
En lugar de una máquina enorme, pones varias medianas a trabajar en paralelo con el mismo código: aquí, cuatro de 96 vCPU (unas 9.600 pet/s cada una).
Si necesitas más capacidad, sumas otro servidor. No hay un techo duro y cada máquina es solo una parte del total. Esto es escalado horizontal (escalar hacia fuera), y es como crecen casi todos los sistemas grandes.
Qué cambió
- 1 máquina gigante → 4 medianas
- Coste 7.200 → 14.400 US$/mes
- CPU ≈ 52% en cada una
- Errores 100% → 0%
Paso 7 de 11
Problema
Capacidad de pico que duerme
El tráfico sigue el horario de la gente. A las 8 de la noche hacen falta los cuatro servidores; a las 4 de la mañana hay una décima parte de usuarios y cada uno trabaja al 5%.
Estás pagando la capacidad del pico las 24 horas, aunque la mayor parte del día casi no se use.
Qué cambió
- 4 a. m.: usuarios 500.000 → 50.000
- CPU ≈ 52% → 5%
Paso 8 de 11
Solución
Que la flota siga a la demanda
Como todos los servidores son iguales, un autoescalador puede encender y apagar máquinas por ti, por ejemplo para mantener la CPU media cerca del 50%.
De madrugada se queda en dos (el mínimo, para sobrevivir a la caída de uno) y por la tarde vuelve a cuatro. Si la mitad del día corren cuatro y la otra mitad dos, el coste medio baja a 10.800 US$/mes.
Qué cambió
- 2 servidores apagados de madrugada
- CPU 5% → 10% en los que quedan
- Coste medio 14.400 → 10.800 US$/mes
Paso 9 de 11
Problema
Caso: una oferta relámpago
Al mediodía hay 150.000 usuarios y dos servidores van sobrados (6.000 pet/s, 31% de CPU). Empieza una oferta y en dos minutos el tráfico se multiplica por 5: 750.000 usuarios, 30.000 pet/s.
El autoescalador pide 4 servidores más, pero en este ejemplo cada uno tarda unos 3 minutos en arrancar. Mientras tanto, los dos que hay sirven 19.200 pet/s: casi dos tercios. El resto, un 36%, falla. La solución es escalar antes: programarlo para eventos conocidos y dejar margen para los imprevistos.
Qué cambió
- Usuarios × 5 al mediodía
- 4 servidores arrancando (≈ 3 min)
- Errores 0% → 36% mientras arrancan
Paso 10 de 11
Problema
¿Y quién manda cada petición a un servidor?
Hasta ahora cada grupo de usuarios apunta a la dirección de un servidor concreto. Si el Servidor B se cae, una cuarta parte de los usuarios recibe errores aunque haya tres servidores sanos al lado.
Los clientes no saben qué servidores están vivos o saturados. Hace falta algo delante que reciba cada petición y la mande a un servidor sano.
Qué cambió
- Servidor B caído
- Errores 0% → 25%
Paso 11 de 11
Resumen
Arriba frente a fuera
Vertical: una máquina más grande. Cero cambios de código y nada nuevo que operar, pero con techo, con reinicio en cada salto y con un punto único de fallo.
Horizontal: más máquinas iguales. Sin techo práctico, una caída solo afecta a una parte y permite autoescalar. A cambio, los servidores no pueden guardar estado y necesitas un balanceador.
← → paso · R repetir · Espacio pausa
Aprenderás
- Reconocer cuándo un servidor está saturado (visto)
- Escalar en vertical y saber dónde se acaba (visto)
- Escalar en horizontal con varias máquinas iguales (visto)
- Autoescalar con el ritmo del día y adelantarte a los picos (visto)
- Entender por qué escalar en horizontal pide un balanceador (visto)