QuorumWiki
Jugar
Patrones

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.

Pasos de escalado#

Construye un sistema paso a paso, desde una sola máquina hasta varias regiones.

1
Una sola máquina

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.

2
Separa el servidor y el almacenamiento

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.

3
Servidores de aplicaciones sin estado

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.

4
Escala primero hacia arriba

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.

5
Varios servidores de aplicaciones tras un balanceador de carga

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.

6
Descartar nodos caídos con comprobaciones de estado

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.

7
Un pooler entre los servidores y la base de datos

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.

8
DNS por delante

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.

9
Archivos estáticos en almacenamiento de objetos y una CDN

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.

10
Añadir una caché

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.

11
Añadir una réplica de lectura

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.

12
Enruta lecturas y escrituras por separado

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.

13
Búsqueda junto a la base de datos

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.

14
Almacenes documentales y de columnas anchas

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.

15
Divide la base de datos por funcionalidad

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.

16
El trabajo lento, a una cola y a workers

Pasa a una Cola el trabajo que el usuario no espera, y deja que los Workers la drenen a su propio ritmo.

17
Plataforma de mensajes para fan-out

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.

18
Funciones para trabajos con picos

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.

19
Autoescalar el nivel de cómputo

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.

20
Transmite los cambios con CDC

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.

21
Informes fuera de la primaria, en un almacén

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.

22
WAF y gateway al frente

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.

23
Autenticación y TLS en el gateway

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.

24
Feature flags y CI para despliegues seguros

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.

25
Una capa de WebSockets para tiempo real

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.

26
Haz sharding de la base de datos

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.

27
SQL distribuido y almacenes sin líder

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.

28
Logs, métricas y trazas

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.

29
Divide en servicios con una malla

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.

30
Multirregión con GeoDNS

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.

31
Cómputo en el edge

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.

32
Recuperación ante desastres y una región de failover

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.

33
Un LLM detrás de un gateway en GPU

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.

34
Búsqueda vectorial y embeddings

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.

Cache-aside

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.

Write-through y write-behind

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.

Protección contra estampidas de caché

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.

Calentamiento de caché y caché en niveles

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.

Réplicas de lectura

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.

CDN push y pull

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).

Escalado vertical y horizontal

Haz más grande una máquina, o ejecuta más máquinas, y sabe cuál elegir primero.

Autoescalado, reactivo y programado

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.

Pool de conexiones

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.

Algoritmos de balanceo de carga

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.

Balanceo de carga de capa 4 y capa 7

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.

Fan-out en escritura y en lectura

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.

Vistas materializadas y desnormalización

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.

Precómputo

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.

Sharding

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.

Hashing consistente

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.

Claves calientes y shards calientes

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.

Federación

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.

Estrategias de replicación

Elige cómo se mantienen sincronizadas las copias de los datos, cambiando latencia de escritura y escrituras perdidas por lecturas obsoletas y complejidad.

Lecturas y escrituras de quórum

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.

Consenso y elección de 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.

Lee tus propias escrituras

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.

Búsqueda de texto completo y el índice invertido

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.

Separar OLTP y OLAP

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.

Almacenamiento de objetos y reglas de ciclo de vida

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.

Nivelación de carga con colas

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.

Consumidores competidores

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.

Publicación y suscripción

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.

Cola de mensajes muertos

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.

Contrapresión

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.

Claves de idempotencia

Etiqueta cada escritura con una clave única que el servidor recuerda, para que una petición reintentada haga el trabajo una sola vez.

Outbox transaccional

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.

Captura de cambios de datos

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.

Claim check

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.

Tiempos de espera

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.

Reintentos con backoff y jitter

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.

Circuit breaker

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.

Bulkhead

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.

Descarte de carga

Cuando la demanda supera la capacidad, rechaza pronto el trabajo más barato para que el trabajo que conservas siga terminando a tiempo.

Limitación de tasa

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.

Peticiones hedged

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.

Degradación elegante

Cuando un sistema no puede hacerlo todo, apaga primero las funciones costosas, para que el núcleo del producto siga funcionando.

Comprobaciones de estado y failover

Sondea cada servidor y deja de enviarle tráfico cuando deja de responder, y pasa a un standby cuando cae una zona entera.

Ingeniería del caos

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.

Operar y observar#

Observa el sistema, fija objetivos y prepárate para el día en que falle.

Seguridad y edge#

La puerta de entrada, el cifrado, los secretos y dónde pueden vivir los datos.

Coste#

Paga por lo que usas y sabe cuánto cuesta cada usuario.

En producción#

Formas que sistemas reales sostuvieron a escala, con el tablero que muestra por qué.

Nueve servidores, una base de datos: Stack Overflow

Stack Overflow mantuvo un solo SQL Server y un puñado de grandes servidores web, y puso Redis y Elasticsearch a su lado.

Shard por tienda: Shopify

Shopify dividió su flota de MySQL en pods por tienda, y luego enrutó cada petición al pod que la posee.

Particiona los mensajes por canal: Discord

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.

Ten tu propio edge: Netflix

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.

Mover tablas entre clústeres: GitHub

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.

Una cola delante de la cola: Slack

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.

Una caché delante del grafo: Meta

Meta puso un nivel de memcached con write-through delante de MySQL con sharding, y mantuvo una región primaria para cada shard.

Haz sharding de la tabla de bloques: Notion

Notion dividió su tabla de bloques en 480 shards lógicos, y luego envió los cambios por Kafka a un data lake.

Haz sharding de Postgres tras un router: Figma

Figma mantuvo Postgres y construyó un router de consultas delante de shards horizontales, cuando el particionado vertical se agotó.

Canario para las reglas del edge: Cloudflare

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.

Pon el shard en el ID: Pinterest

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.

Un gateway por dominio: Uber

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.

Indexar los blobs: Dropbox

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.

Mover shards en línea: Stripe

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.

Fuera del juego#

Patrones que Quorum no puede construir, con referencias que merece la pena leer.

Saga

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

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

Event sourcing guarda cada cambio como un evento en un registro de solo adición y construye el estado actual reproduciéndolo.

Sidecar

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.

Capa anticorrupción

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 para frontends

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.

Composición de API

La composición de API responde una consulta que abarca varios servicios llamando a cada uno y uniendo los resultados en memoria.

Commit en dos fases

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.

CRDT

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.

Sesiones persistentes

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.

Long polling y server-sent events

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.