Aprende diseño de sistemas en 40 lecciones animadas sobre balanceo de carga, cachés, bases de datos y colas. Diseña un acortador de URL, un feed y un chat.
En una primera visita por TCP y TLS, el navegador resuelve el dominio, abre una conexión segura y envía una solicitud HTTP. Después muestra la respuesta del servidor.
Las redes enrutan por dirección IP numérica, no por nombre. Así que el navegador pregunta primero a un resolvedor DNS: ¿dónde está shop.example?
La respuesta — 203.0.113.7 — llega en unos 20 ms.
Ahora el navegador abre una conexión con 203.0.113.7. Un handshake TCP acuerda hablar; un handshake TLS prepara el cifrado. Cada uno necesita un viaje de ida y vuelta: ir y volver.
Aquí un viaje de ida y vuelta tarda 30 ms, así que conectar cuesta 60 ms antes de pedir un solo byte de la página.
Por la conexión abierta, el navegador envía GET /products. El servidor la interpreta, comprueba la sesión y ejecuta tu código.
Eso cuesta otro viaje de ida y vuelta más unos 10 ms de trabajo del servidor.
Los productos no viven en el servidor web: viven en una base de datos. El servidor envía una consulta y espera a que vuelvan las filas.
Mira cómo una petición entra hasta el fondo y la respuesta sale hasta el final.
El servidor convierte las filas en HTML y lo devuelve; descargarlo lleva otros 20 ms. El navegador dibuja la página, 155 ms después de pulsar Enter.
Luego ve imágenes y hojas de estilo en la página y lanza más peticiones. Reutilizar la conexión abierta les ahorra el handshake.
Sigue la carga de una página salto a salto, y descubre adónde se va de verdad el tiempo.
Dos preguntas sobre la velocidad, y por qué los servidores ocupados se vuelven lentos antes de llenarse.
Convierte una idea de producto en servidores y terabytes con cuentas que caben en una servilleta.
Tu único servidor se está derritiendo. ¿Compras uno más grande o más servidores?
Una sola puerta de entrada para muchos servidores, y las reglas que deciden quién recibe cada petición.
Por qué la siguiente petición debe funcionar en cualquier servidor, y adónde va el estado en su lugar.
Guarda las respuestas más pedidas en algún sitio mucho más rápido que la base de datos.
Copia lo que todo el mundo descarga en servidores cerca de tus usuarios, y deja de pelearte con la velocidad de la luz.
Tablas, documentos o simples claves: para qué sirve cada tipo de base de datos y a qué renuncia.
Por qué la misma consulta puede tardar dos segundos o dos milisegundos.
Qué hace de verdad una base de datos con tu escritura, y por qué unos motores están hechos para leer y otros para escribir.
Guarda copias de la base de datos en varias máquinas: para más lecturas y para sobrevivir.
Cuando los datos o las escrituras no caben en una máquina, repártelos entre muchas.
Añade o quita servidores y mueve solo una pizca de los datos.
Dar a cada fila un nombre que nadie más usará jamás, sin un contador ante el que todos tengan que hacer cola.
Cuando la red se parte, las copias de tus datos deben elegir entre tener razón y estar disponibles.
Cómo un grupo de servidores se pone de acuerdo en un líder y una historia, aunque no se pueda llegar a algunos de ellos.
Dos personas, un asiento, el mismo milisegundo. Cómo mantienen las bases de datos correctos los cambios concurrentes.
Las fotos y los vídeos no van en tu base de datos: adónde van en su lugar, y cómo llegan allí y vuelven.
Tres formas de que los programas se pidan cosas entre sí, y lo que le cuesta cada una a un móvil con 4G.
Responde al momento, haz el trabajo lento después, y no pierdas nunca una tarea por el camino.
Anuncia que algo ha pasado y deja que reaccione quien le interese, sin que nadie espere.
Cómo te avisa el servidor de que algo ha pasado: chat, resultados en directo, notificaciones.
Todo acaba fallando. Diseña para que ningún fallo individual te tumbe.
Da a cada cliente un presupuesto justo, para que un script desbocado no tumbe a todos.
Llamar con seguridad a un servicio en apuros: rendirse a tiempo, reintentar con cuidado y saber cuándo parar.
Métricas, logs y trazas: cómo averiguar qué falla, dónde y por qué, rápido.
¿Un solo código o muchos servicios? Lo que te da cada uno, lo que cuesta y cómo pasar de uno a otro.
Cómo se encuentran los servicios cuando las instancias van y vienen, y una sola puerta de entrada para todos los de fuera.
Una acción, varios servicios, varias bases de datos: cómo mantenerlo todo o nada sin una gran transacción.
Procesar miles de millones de eventos: de noche en grandes lotes, o de forma continua según llegan.
Demostrar quién es alguien, sin convertirte en la razón por la que se filtra su contraseña.
Saber quién es alguien no te dice qué puede ver o hacer. Comprobarlo, en todas partes.
Proteger los datos en la red, en disco, y las claves y contraseñas que usan tus servicios.
Saber que un cambio es seguro antes de que se enteren tus usuarios: pruebas rápidas para la lógica y unas pocas lentas para todo lo demás.
Llevar cada cambio a producción rápido y con seguridad, y deshacerlo igual de rápido.
El mismo sistema a dos niveles de zoom: el mapa de servicios, y el interior de uno de ellos.
Un primer diseño de principio a fin: de un encargo de una línea a un sistema que sirve miles de millones de redirecciones.
Publicaciones de todos los que sigues, en 200 ms, y la pregunta de cuándo hacer el trabajo.
Veinte millones de conexiones abiertas y una promesa: cada mensaje llega, en orden, exactamente una vez.