Patrones
Diseño de sistemas en piezas pequeñas: construye un Diseño paso a paso y consulta el patrón detrás de cada paso.
Una chuleta para diseñar sistemas, en cuatro partes que se remiten entre sí. Los pasos de escalado añaden una pieza cada vez y dicen cuándo avanzar. Los patrones explican la idea detrás de cada paso, lo que cuesta y cómo ajustarlo en el juego. Las páginas de producción muestran una forma que una empresa real sostuvo a escala, y las de fallos muestran una que se rompió, con el incidente en marcha en el tablero. Ambas nombran las piezas que Quorum no puede modelar.
¿Eres nuevo? Empieza por Una sola máquina y sube de nivel, o salta a un patrón cuando un indicador de tu Tablero se ponga rojo. La mayoría de las páginas dibujan un Diseño real en el tablero del propio juego y explican cada ajuste que usa.
Fundamentos#
El vocabulario en el que se apoya el resto: latencia, disponibilidad, CAP y la cola.
La latencia es cuánto tarda una petición, el throughput es cuántas terminan por segundo, y subir una a menudo empuja a la otra en el sentido equivocado.
Cada nueve extra de disponibilidad reduce a una décima parte el tiempo de caída permitido, y cada dependencia dura de una cadena baja el total.
Cuando la red se parte, un almacén replicado debe rechazar algunas peticiones o servir datos obsoletos, e incluso estando sano cambia latencia por consistencia.
Un modelo de consistencia dice qué valores puede devolver una lectura tras una escritura, y los más fuertes cuestan latencia y disponibilidad.
El número de peticiones dentro de un sistema es igual a la tasa de llegada por el tiempo que cada una pasa allí, lo que dimensiona cada pool, cola y límite de conexiones.
El pequeño porcentaje de peticiones más lentas determina cómo se siente un servicio, y una petición que se abre en abanico a muchos servidores se topa con esa cola casi siempre.
Ocho suposiciones que valen en una máquina y fallan a través de una red, cada una con una defensa estándar.
Pasos de escalado#
Construye un sistema paso a paso, desde una sola máquina hasta varias regiones.
Ejecuta el código y los datos en una máquina. Es la forma más barata de lanzar y el lugar correcto para empezar.
Saca los datos del Servidor de aplicaciones a su propio Nodo de Base de datos, para que el código y los datos dejen de pelearse por una máquina y cada uno pueda crecer por separado.
No guardes en el Servidor de aplicaciones nada que necesitaría una segunda copia, para que cualquier copia pueda responder cualquier petición y una caída no cueste nada.
Dale al Servidor de aplicaciones una instancia más grande antes de añadir una segunda. Es el cambio más barato que añade capacidad.
Pon un Balanceador de carga delante de Servidores de aplicaciones idénticos para que el tráfico se reparta entre ellos y la capacidad crezca añadiendo copias.
Haz que el Balanceador de carga sondee cada servidor y deje de enviar tráfico a uno que ha fallado, para que un host caído cueste segundos en lugar de una parte de las peticiones.
Pon un Pooler de conexiones entre los Servidores de aplicaciones y la Base de datos para que muchas conexiones de la aplicación compartan unas pocas conexiones de la base de datos.
Pon DNS delante de varios Balanceadores de carga para que el punto de entrada no sea una sola máquina, y ajusta su TTL a la rapidez de failover que necesitas.
Sirve páginas y contenido multimedia desde el edge y guarda los archivos en Almacenamiento de objetos, para que el origen solo atienda lo que debe estar fresco.
Coloca una Caché entre el Servidor de aplicaciones y la Base de datos para que las lecturas repetidas se respondan desde memoria y la Base de datos conserve su capacidad para las escrituras.
Copia la Base de datos en una réplica que responde las lecturas, para que la capacidad del primario se dedique a las escrituras y el tráfico de lectura escale horizontalmente.
Envía las escrituras a la primaria y las lecturas a una réplica, y devuelve a la primaria las lecturas que siguen a una escritura para que los usuarios nunca vean que falta su propio cambio.
Pon la búsqueda de texto completo en su propio Motor de búsqueda, para que una consulta pesada deje de quitar CPU y caché a los pagos y a las escrituras.
Usa un almacén documental para datos que se leen y escriben por clave con una forma cambiante, y uno de columnas anchas cuando las escrituras superan una máquina, y acepta a qué renuncia cada uno.
Da a cada funcionalidad su propio Servidor de aplicaciones y Base de datos, para que la carga y los fallos de una funcionalidad se queden en su propio carril.
Pasa a una Cola el trabajo que el usuario no espera, y deja que los Workers la drenen a su propio ritmo.
Envía cada notificación a través de una Cola y Workers a un proveedor gestionado, para que un envío lento o fallido nunca retenga una petición.
Ejecuta el trabajo a ráfagas o poco frecuente en una Función serverless que factura por uso y escala desde cero, y deja la carga constante en máquinas.
Enlaza los Servidores de aplicaciones con un Autoescalador para que el número de copias siga a la carga, dentro de un mínimo y un tope que tú eliges.
Lee el log de escritura de la Base de datos y publica cada cambio en un flujo, para que la búsqueda y otras copias sigan a los datos sin una segunda escritura.
Envía los recorridos de informes a un Almacén de datos columnar, para que la analítica deje de expulsar la caché de búfer de la que dependen los pagos.
Pon un WAF y un API Gateway delante de los Servidores de aplicaciones, para que los bots y las ráfagas se detengan antes de que te cuesten capacidad.
Comprueba cada token una sola vez en el API Gateway, deja el hash de contraseñas en manos de un Proveedor de autenticación y haz que un gestor de certificados renueve el TLS, para que la puerta de entrada deje de costarle al Servidor de aplicaciones y deje de caducar.
Lanza a través de un pipeline que envía primero un canario, y pon las Funcionalidades nuevas detrás de flags, para que un mal despliegue rompa una parte de los usuarios en lugar de todos.
Mantén abiertas las conexiones en tiempo real en un Hub en tiempo real que ejecuta un runtime hecho para ello, y enruta a él solo el tráfico en tiempo real, para que el chat y las actualizaciones en vivo dejen de devorar workers del Servidor de aplicaciones.
Divide la Base de datos en shards por una clave, para que las escrituras se reparta entre varias primarias cuando una máquina en su mayor tamaño ya está llena.
Sustituye los shards hechos a mano por un almacén que replica por sí solo, ya sea sin líder con quórums ajustables o SQL sobre Raft, y elige según si necesitas que cada lectura sea correcta.
Conecta los Nodos a Analítica e investiga la línea de visibilidad, para ver la causa de los errores, el historial y el salto lento de cada petición en lugar de adivinar.
Rompe una base de código en Servicios sobre un Clúster de Kubernetes y pon un Service mesh a su lado, para que cada uno se despliegue por separado y cada llamada tenga reintentos, un breaker y métricas.
Abre una segunda región, dirige a ella los Usuarios de cada zona con GeoDNS y mantén las lecturas locales, para que los Usuarios lejanos dejen de pagar el océano dos veces en cada petición.
Ejecuta handlers pequeños en Funciones edge junto al usuario y deja el trabajo pesado en el Servidor de aplicaciones, para que las peticiones baratas se salten el viaje al origen.
Haz copia de seguridad del primario, mantén un standby para la pérdida de una zona y un almacén repartido entre regiones para la pérdida de una región, y demuéstralo con un simulacro.
Sirve prompts de IA desde tus propios Nodos GPU junto a una API de LLM alojada, y ajusta modelo, precisión y tamaño de lote, porque una GPU sale más barata por prompt solo mientras se mantiene ocupada.
Guarda embeddings de tus documentos en un Índice vectorial y busca los más cercanos antes de cada prompt, para que las respuestas usen tus propios datos en lugar de solo los del modelo.
Escalar lecturas y cómputo#
Cachés, réplicas, balanceadores de carga y autoescalado.
Mantén las lecturas calientes en memoria y deja que la app llene la caché en un fallo, para que la base de datos sirva cada fila popular una vez en lugar de una vez por petición.
Deja que la caché también reciba escrituras, ya sea pasándolas directamente a la base de datos o reteniéndolas un momento, para que las lecturas nunca vean un valor viejo.
Evita que muchos lectores reconstruyan a la vez la misma clave de caché caducada, para que una sola clave popular no tumbe la base de datos.
Llena una caché antes de que reciba tráfico, y pon una segunda caché entre la primera y el origen, para que una caché fría o lejana no envíe cada lectura a la fuente.
Copia la base de datos a seguidores que sirven lecturas, para que el tráfico de lectura escale hacia fuera mientras una primaria recibe las escrituras.
Pon copias de tu contenido en servidores cercanos a los usuarios, llenándolos bajo demanda desde tu origen (pull) o subiéndolos tú mismo (push).
Haz más grande una máquina, o ejecuta más máquinas, y sabe cuál elegir primero.
Añade copias de un servicio cuando sube la carga y quítalas cuando baja, ya sea después de que aparezca la carga o antes de un pico que puedes predecir.
Pon un pooler entre la app y la base de datos para que muchas conexiones de la app compartan unas pocas conexiones a la base de datos.
Elige cómo un balanceador de carga escoge entre servidores, porque la regla adecuada depende de si los servidores difieren y de si las peticiones difieren.
Elige entre un balanceador que reenvía conexiones TCP con rapidez y uno que lee cada petición HTTP para poder enrutar según el contenido.
Construye el feed de un usuario o cuando alguien publica, copiando la publicación a cada seguidor, o cuando el usuario lee, reuniendo las publicaciones de todos a quienes sigue.
Guarda la respuesta de una consulta costosa, o mantén una copia ya unida de los datos, para que las lecturas dejen de repetir el mismo trabajo una y otra vez.
Haz el trabajo costoso antes de que nadie lo pida, para que una petición lea una respuesta lista en lugar de construirla.
Escalar los datos#
Sharding, replicación, quórums y los almacenes que encajan con cada forma.
Divide un conjunto de datos entre varias bases de datos según una clave, para que las escrituras y el almacenamiento escalen más allá de lo que cabe en una máquina.
Coloca las claves en un anillo de servidores, para que añadir o quitar un servidor mueva solo su parte de las claves en lugar de casi todas.
Cuando una clave o un shard se lleva una gran parte del tráfico, añadir servidores no ayuda, así que reparte esa clave o cambia la clave de shard.
Divide los datos por funcionalidad en bases de datos separadas, para que cada servicio sea dueño de sus tablas y una funcionalidad muy ocupada no pueda ralentizar al resto.
Elige cómo se mantienen sincronizadas las copias de los datos, cambiando latencia de escritura y escrituras perdidas por lecturas obsoletas y complejidad.
Mantén varias copias de cada clave y haz que una lectura y una escritura consulten cada una las suficientes para solaparse, de modo que las lecturas vean la última escritura sin un líder.
Haz que un grupo de servidores se ponga de acuerdo en un único orden de escrituras mediante una votación por mayoría, para que los datos sigan correctos mientras falla una minoría.
Después de que un usuario escriba, envía sus lecturas a la primaria durante un tiempo, para que nunca vea datos más viejos que su propio cambio.
Indexa cada palabra con los documentos que la contienen en un motor de búsqueda aparte, para que una consulta lea unas pocas listas cortas en lugar de recorrer cada fila.
Ejecuta los informes en un almacén columnar aparte, para que los grandes recorridos dejen de expulsar la caché y de frenar la base de datos que atiende a los usuarios.
Guarda los archivos en almacenamiento de objetos y deja que las reglas de ciclo de vida muevan los objetos antiguos a clases más baratas, para que el coste de almacenamiento deje de crecer al ritmo de cada subida.
Mensajería y asincronía#
Colas, streams y las garantías entre ellos.
Pon una cola entre un productor a ráfagas y un consumidor constante, para que un pico se convierta en una espera corta en lugar de un fallo.
Deja que varios workers lean de una misma cola, para que cada tarea vaya a exactamente uno de ellos y el throughput crezca añadiendo workers.
Publica cada evento una vez en un tema y deja que lo lean todos los servicios interesados, para que los productores dejen de saber quién consume sus eventos.
Mueve un mensaje que sigue fallando a una cola aparte tras unos pocos intentos, para que un solo mensaje defectuoso no bloquee a los workers.
Haz que un consumidor lento presione hacia atrás a sus productores, para que una cola siga acotada en lugar de crecer hasta agotar la memoria o la latencia.
Etiqueta cada escritura con una clave única que el servidor recuerda, para que una petición reintentada haga el trabajo una sola vez.
Escribe el evento en la misma transacción de base de datos que el cambio, y luego publícalo desde allí, para que la base de datos y el broker nunca discrepen.
Lee el registro de cambios de la base de datos y publica cada cambio como un evento, para que el buscador, el almacén de datos y la caché sigan al día sin que la app escriba dos veces.
Guarda una carga grande en el almacenamiento de objetos y envía solo una referencia por la cola, para que los mensajes sigan siendo pequeños y rápidos.
Resiliencia#
Timeouts, reintentos, breakers y otras formas de fallar en pequeño.
Da a cada llamada de red un plazo, porque una llamada que espera para siempre retiene como rehenes un hilo, una conexión y un usuario.
Reintenta una llamada fallida tras una espera creciente y aleatoria, para que un fallo breve se cure en lugar de convertirse en una tormenta de reintentos.
Deja de llamar a una dependencia que sigue fallando, responde rápido con una alternativa y sondea de vez en cuando para ver si se ha recuperado.
Da a cada dependencia o cliente su propio pool de capacidad, para que una parte que falla no pueda vaciar los recursos que necesitan todas las demás.
Cuando la demanda supera la capacidad, rechaza pronto el trabajo más barato para que el trabajo que conservas siga terminando a tiempo.
Limita cuántas peticiones por segundo puede enviar un cliente o un servicio, para que un solo llamador ruidoso no consuma la capacidad que todos comparten.
Envía una segunda copia de una llamada lenta y quédate con la primera respuesta, para que un servidor lento poco frecuente deje de marcar tu latencia de cola.
Cuando un sistema no puede hacerlo todo, apaga primero las funciones costosas, para que el núcleo del producto siga funcionando.
Sondea cada servidor y deja de enviarle tráfico cuando deja de responder, y pasa a un standby cuando cae una zona entera.
Rompe tu propio sistema en un horario y bajo vigilancia, para encontrar el eslabón débil antes de que lo haga una caída.
Despliegues y cambios#
Publica y migra sin tumbar el sistema.
Cambia el esquema de una base de datos en pasos pequeños que el código viejo y el nuevo aceptan, para que un despliegue nunca necesite una caída ni un lanzamiento sincronizado.
Lanza una versión nueva junto a la vieja, o primero a unos pocos usuarios, para que un mal lanzamiento llegue a poca gente y se revierta rápido.
Pon una funcionalidad nueva detrás de un interruptor que puedes subir o bajar en tiempo de ejecución, para que desplegar el código y lanzarlo sean pasos distintos.
Reemplaza un sistema antiguo pieza a pieza tras una única puerta de entrada, para que el nuevo tome el relevo sin una reescritura de golpe.
Describe tu infraestructura en archivos y aplícala desde el control de versiones, para que cada entorno sea igual y cada cambio tenga un historial.
Cambia una base de datos en vivo sin bloquearla, para que las escrituras sigan fluyendo mientras el esquema o los datos se mueven.
Operar y observar#
Observa el sistema, fija objetivos y prepárate para el día en que falle.
Vigila cuatro cosas en cada servicio, latencia, tráfico, errores y saturación, y comprueba tres más en cada recurso, para que un panel responda "qué está roto" antes de que nadie abra un log.
Elige un objetivo de fiabilidad que los usuarios notarían, trata los fallos que permite como un presupuesto, y deja que el presupuesto restante decida si publicar o reforzar.
Informa de p50, p95 y p99 en lugar de la media, porque la media diluye las peticiones lentas de las que se quejan los usuarios reales.
Sigue una petición a través de cada servicio como una traza, y decide cuando termina qué trazas conservar, para que las lentas y las fallidas sobrevivan al muestreo.
Pon a una persona de guardia cada vez, escribe la solución de cada fallo que el equipo ya ha resuelto y automatiza los que se repiten.
Elige cuánta capacidad en standby mantener para una región perdida, desde solo copias de seguridad hasta un segundo sitio que sirve tráfico todo el tiempo, y paga por la velocidad que necesitas.
Fija dos objetivos para cada desastre, cuántos datos puedes perder y cuánto tiempo puedes estar caído, y deja que ellos elijan el diseño de copias de seguridad y standby.
Seguridad y edge#
La puerta de entrada, el cifrado, los secretos y dónde pueden vivir los datos.
Pon una única puerta de entrada delante de tus servicios, para que los límites de tasa, la autenticación y la fusión de peticiones ocurran una vez en lugar de en cada servicio.
Filtra el tráfico hostil en el edge con un firewall que bloquea patrones de ataque conocidos, y desafía a los clientes sospechosos en lugar de bloquearlos para que los usuarios reales sigan pasando.
Cifra los datos en la red con TLS y en disco con claves que controlas, y automatiza la renovación de certificados para que una fecha de caducidad nunca tumbe el sitio.
Guarda claves, contraseñas y tokens en una bóveda que los entrega bajo demanda, para que ninguno esté en el código, en una imagen ni en la lista de deseos de una página de phishing.
Comprueba las librerías de cada build contra listas de vulnerabilidades conocidas, para que un paquete defectuoso o malicioso haga fallar el pipeline antes de llegar a producción.
Mantén los datos personales de una región en servidores de esa región, y enruta allí a sus usuarios, para cumplir la ley local y los contratos de clientes sin un producto aparte.
Coste#
Paga por lo que usas y sabe cuánto cuesta cada usuario.
Ajusta cada máquina a la carga que lleva, y luego compra la parte estable con un compromiso y la parte interrumpible con un gran descuento.
Reduce la factura por los bytes que salen de tu nube comprimiendo las respuestas, sirviéndolas desde una CDN y manteniendo el tráfico conversador dentro de una zona y una región.
Divide la factura por lo que compra, para que cada tipo de petición, servicio y equipo cargue con su propio coste, y "la factura de la nube subió" se convierta en una respuesta concreta.
En producción#
Formas que sistemas reales sostuvieron a escala, con el tablero que muestra por qué.
Stack Overflow mantuvo un solo SQL Server y un puñado de grandes servidores web, y puso Redis y Elasticsearch a su lado.
Shopify dividió su flota de MySQL en pods por tienda, y luego enrutó cada petición al pod que la posee.
Discord guardó billones de mensajes en un almacén de columnas anchas, particionados por canal y por tiempo, y los leyó con un quórum.
Netflix construyó su propia CDN y puso una capa de memcached delante de la base de datos, para que el vídeo y las lecturas personalizadas nunca toquen el origen.
GitHub dividió un clúster de MySQL en dominios de esquema y luego movió las tablas a clústeres separados con Vitess y un cutover de escrituras.
Slack puso Kafka delante de Redis, de modo que una ráfaga de trabajos esperaba en un log duradero en lugar de llenar la memoria de la cola.
Meta puso un nivel de memcached con write-through delante de MySQL con sharding, y mantuvo una región primaria para cada shard.
Notion dividió su tabla de bloques en 480 shards lógicos, y luego envió los cambios por Kafka a un data lake.
Figma mantuvo Postgres y construyó un router de consultas delante de shards horizontales, cuando el particionado vertical se agotó.
Una sola regla de WAF llevó al 100% la CPU de todos los edges de Cloudflare, y la solución fue un canario antes del despliegue global.
Pinterest ejecutó 4,096 shards de MySQL y codificó el número de shard en el ID de 64 bits de cada objeto, de modo que una lectura no necesitaba un servicio de consulta.
Uber agrupó 2,200 microservicios críticos en dominios, puso un gateway delante de cada uno y usó una malla para las llamadas entre ellos.
Dropbox puso un Block Index en MySQL con sharding delante de los bloques inmutables de Magic Pocket, así que una lectura era una búsqueda por hash y una obtención de bloque.
Stripe movió cientos de millones de objetos sin tiempo de inactividad y luego construyó una Data Movement Platform que copia chunks entre shards de MongoDB mientras la aplicación sigue escribiendo.
Cuando se rompió#
Caídas que cambiaron el diseño, y el tablero que muestra la dependencia.
Un cambio de streaming en Consul bajo carga dejó caído a Roblox durante 73 horas, porque el plano de control era también la vía de los despliegues y de la monitorización.
Una entrada mal escrita eliminó los servidores detrás de los subsistemas de índice y de ubicación de S3, y us-east-1 perdió S3 durante unas cuatro horas.
Fuera del juego#
Patrones que Quorum no puede construir, con referencias que merece la pena leer.
Una saga ejecuta una transacción de negocio como una cadena de transacciones locales entre servicios y deshace los pasos terminados con acciones compensatorias cuando falla un paso posterior.
CQRS usa un modelo para cambiar los datos y otro distinto para leerlos, de modo que cada lado se pueda modelar y escalar para su propio trabajo.
Event sourcing guarda cada cambio como un evento en un registro de solo adición y construye el estado actual reproduciéndolo.
Un sidecar se ejecuta junto a la aplicación principal en su propio proceso o contenedor y se ocupa de tareas compartidas como el registro, el proxy y la seguridad.
Una capa anticorrupción traduce entre tu modelo y el de un sistema heredado o ajeno, para que el diseño antiguo no se filtre en el nuevo.
Backends for frontends da a cada tipo de cliente, como web, iOS y Android, su propio backend pequeño en lugar de una API compartida.
La composición de API responde una consulta que abarca varios servicios llamando a cada uno y uniendo los resultados en memoria.
El commit en dos fases hace que varias bases de datos confirmen o aborten una transacción juntas, votando primero y confirmando después, al precio de bloquearse cuando falla el coordinador.
Un tipo de dato replicado libre de conflictos permite que cada réplica acepte escrituras por su cuenta y aun así se fusione en el mismo estado sin coordinación.
Las sesiones persistentes hacen que un balanceador de carga devuelva un cliente al servidor que usó primero, para que la memoria de ese servidor pueda guardar el estado del cliente.
El long polling y los server-sent events permiten que un servidor envíe actualizaciones a un navegador por HTTP simple, sin la conexión bidireccional de un WebSocket.