Diseño de sistemas

Cómo llega un mensaje de chat a alguien que está sin conexión

Alice envía un mensaje mientras el móvil de Bob está apagado. Que le llegue, una sola vez y en orden en cada dispositivo, depende de saber dónde está él: en otro servidor, en ninguno, o en dos dispositivos a la vez. Cinco versiones de un backend de chat, desde un servidor hasta un grupo de 500.

Ir a la arquitectura final

Alice escribe “¿Seguimos en pie para el sábado?” y pulsa enviar. El móvil de Bob está en un cajón con la batería agotada, y su portátil está cerrado sobre el escritorio. Una hora después conecta el móvil al cargador y el mensaje debería estar ahí: una sola vez, en su lugar de la conversación, y también en el portátil cuando lo abra.

Entonces, ¿dónde está Bob? Puede estar conectado al mismo servidor que Alice, a otro distinto, a ninguno, o a dos a la vez desde dos dispositivos. Cada uno de esos lugares necesita su propia forma de hacerle llegar el mensaje, y la mayor parte de un backend de chat es la suma de esas formas.

El resto de este artículo sigue ese único mensaje. Cada sección es un caso que la versión anterior no puede manejar, casi siempre un lugar donde Bob puede estar, y el cambio más pequeño que lo resuelve, con lo que cuesta. Si ya conoces los backends de chat, los títulos cuentan la historia y el último dibujo es el resultado; si no, empieza por el caso en que todo corre en un solo servidor. Learn tiene el diseño terminado, un chat en tiempo real resuelto paso a paso; este artículo trata de cómo se llega a un diseño así.

Dos millones de personas, medio millón de sockets

El producto es chat uno a uno y en grupo dentro de una app móvil. Todos los números de aquí son inventados para el ejercicio y están redondeados para que las cuentas sean fáciles; ninguno está medido en un servicio real:

  • 2 millones de usuarios diarios. En el pico nocturno hay unos 300.000 conectados a la vez, muchos desde dos dispositivos, así que digamos medio millón de conexiones abiertas.
  • Unos 60 mensajes por usuario al día: 120 millones diarios, unos 1.400 por segundo de media, y varias veces eso en el pico nocturno, digamos 4.000 por segundo.
  • Un servidor de chat mantiene unas 50.000 conexiones WebSocket, casi siempre inactivas. Es una suposición de dimensionamiento para este ejercicio; la cifra real depende de la memoria por conexión, de TLS y de lo que el servidor haga con cada una.
  • Los grupos tienen como máximo 500 miembros. Es un límite de producto, y se plantea como tal.
  • Un mensaje almacenado ocupa unos 200 bytes con sus IDs y marcas de tiempo: unos 24 GB al día.

Mira la primera y la tercera línea juntas. Medio millón de conexiones a 50.000 por servidor son diez servidores solo para mantener a todos conectados, antes de enviar un solo mensaje. Unos pocos miles de mensajes por segundo son trabajo normal para una base de datos. Con estos números, las conexiones abiertas se agotan mucho antes que los mensajes por segundo.

Antes de dibujar nada, tres límites de tiempo, todos supuestos. Alice debería ver “enviado” bastante menos de un segundo después de pulsar enviar, y solo cuando el mensaje ya esté almacenado. Un Bob conectado debería verlo en menos de un segundo. A un Bob sin conexión se le debería enviar una notificación en pocos segundos, y encontrar la conversación completa al abrir la app. El tercer límite tiene dos mitades por una razón: la notificación solo le dice a Bob que mire, y es el almacén el que de verdad le entrega el mensaje.

Todos en un servidor

Empecemos por el caso en que todos están en el mismo sitio. El móvil de Alice y el de Bob mantienen cada uno un WebSocket abierto con un único servidor de chat. Un WebSocket es una conexión que permanece abierta en ambos sentidos, de modo que el servidor puede enviarle un mensaje a Bob en cuanto lo tiene, en lugar de esperar a que su móvil lo pida. Una petición y respuesta normales no pueden hacer eso: el servidor solo responde cuando el cliente pregunta.

Cuando llega el mensaje de Alice, el servidor hace tres cosas, en este orden: escribe el mensaje en el almacén de mensajes, se lo confirma a Alice (su móvil muestra “enviado”) y lo escribe en el socket de Bob. El orden es la primera decisión de verdad del diseño. Si el servidor entregara primero y almacenara después, una caída entre ambos pasos dejaría un mensaje que Bob ya leyó y que el sistema ya no tiene: ausente del historial de Alice y de cualquier dispositivo que Bob use después. Primero almacenar, luego entregar, y todo mensaje que alguien ha visto es un mensaje que el sistema sigue teniendo.

Etapa 1 de 5: Un servidor: almacenar y luego entregar
Un servidor: almacenar y luego entregarEl móvil de Alice y el de Bob mantienen cada uno un WebSocket con un único servidor de chat. El servidor de chat escribe cada mensaje en el almacén de mensajes, una base de datos relacional, y después lo envía por el WebSocket de Bob.WebSocketMóvil de AliceSPA / MóvilCLIENTES E INTERFAZServidor de chatServidor en tiempo real (WebSocket / SSE)Servidor en tiempo real(WebSocket / SSE)SERVICIOS Y APISAlmacén mensajesAlmacén SQL genéricoALMACENES DE DATOSMóvil de BobSPA / MóvilCLIENTES E INTERFAZ
Un servidor: almacenar y luego entregarEl móvil de Alice y el de Bob mantienen cada uno un WebSocket con un único servidor de chat. El servidor de chat escribe cada mensaje en el almacén de mensajes, una base de datos relacional, y después lo envía por el WebSocket de Bob.WebSocketMóvil de AliceSPA / MóvilCLIENTES E INTERFAZServidor de chatServidor en tiempo real (WebSocket / SSE)Servidor en tiempo real(WebSocket / SSE)SERVICIOS Y APISAlmacén mensajesAlmacén SQL genéricoALMACENES DE DATOSMóvil de BobSPA / MóvilCLIENTES E INTERFAZ

El servidor de chat almacena el mensaje antes de escribirlo en el socket de Bob.

Más informaciónTransporte en tiempo real: long-polling vs SSE vs WebSocketWebSockets a escala: gateways, enrutamiento y drenaje

El almacén de mensajes puede ser una base de datos relacional corriente: una tabla de mensajes con la conversación, el remitente, el texto y una marca de tiempo. ¿Y el móvil apagado de Bob? En esta versión, el mensaje de Alice espera en el almacén, y cuando Bob abra la app, esta carga los mensajes recientes de cada conversación. Así que Bob lo recibe, con el tiempo, si se da el caso de que abra la app. Nada se lo avisa.

Para un lanzamiento con unos pocos miles de personas conectadas, esto basta. Un servidor guarda todos los sockets, encuentra el de Bob en su propia memoria y escribe en él. Aun así, los costes ya se ven. El servidor es un punto único de fallo: cuando se reinicia, todos los usuarios se desconectan a la vez. Y tiene un techo que no tiene nada que ver con los mensajes: hacia las 50.000 conexiones está lleno, y nuestro pico nocturno necesita diez veces eso.

Bob está en otro servidor

Ahora hay varios servidores de chat, unos doce para el pico nocturno, lo que deja margen para perder uno, con un balanceador de carga delante que elige un servidor para cada conexión nueva. Un WebSocket permanece en el servidor donde se abrió hasta que se cierra, así que una vez que el balanceador ha elegido, ahí es donde vive el usuario.

Repitamos el mensaje de Alice, esta vez con el móvil de Bob encendido. La conexión de Alice cayó en un servidor; la de Bob, en otro. El servidor de Alice almacena el mensaje, se lo confirma, busca el socket de Bob en su propia memoria y no encuentra nada. Bob está conectado, pero no aquí.

Los servidores necesitan una forma de pasarse mensajes entre sí, y la más simple es publicación/suscripción (pub/sub). Cada usuario tiene un canal en un broker de pub/sub. Cuando se abre el socket de Bob en un servidor, ese servidor se suscribe al canal de Bob, y se da de baja cuando se cierra el último socket suyo allí. El servidor de Alice no necesita saber dónde está Bob: publica el mensaje en el canal de Bob, el broker se lo entrega al servidor que esté suscrito, y ese servidor lo escribe en el socket de Bob.

Etapa 2 de 5: Bob está en otro servidor
Bob está en otro servidorUn balanceador de carga reparte ahora las conexiones entre varios servidores de chat. El servidor de chat de Alice almacena el mensaje y después lo publica en el canal de Bob en un servicio de pub/sub; otro servidor de chat, el que tiene el WebSocket de Bob, está suscrito a ese canal y entrega el mensaje al móvil de Bob.al canal de BobWebSocketMóvil de AliceSPA / MóvilCLIENTES E INTERFAZBalanceador de cargaBalanceador decargaEnrutador de tráficoPLATAFORMA Y RUNTIMEServidor de chatServidor en tiempo real (WebSocket / SSE)Servidor en tiempo real(WebSocket / SSE)SERVICIOS Y APISAlmacén mensajesAlmacén SQL genéricoALMACENES DE DATOSCanal por usuarioPublicación / suscripciónPublicación /suscripciónMENSAJERÍA Y FLUJOS DETRABAJOOtro servidor de chatOtro servidor dechatServidor en tiempo real (WebSocket / SSE)Servidor en tiempo real(WebSocket / SSE)SERVICIOS Y APISMóvil de BobSPA / MóvilCLIENTES E INTERFAZ
Bob está en otro servidorUn balanceador de carga reparte ahora las conexiones entre varios servidores de chat. El servidor de chat de Alice almacena el mensaje y después lo publica en el canal de Bob en un servicio de pub/sub; otro servidor de chat, el que tiene el WebSocket de Bob, está suscrito a ese canal y entrega el mensaje al móvil de Bob.al canal de BobWebSocketMóvil de AliceSPA / MóvilCLIENTES E INTERFAZBalanceador de cargaBalanceador decargaEnrutador de tráficoPLATAFORMA Y RUNTIMEServidor de chatServidor en tiempo real (WebSocket / SSE)Servidor en tiempo real(WebSocket / SSE)SERVICIOS Y APISAlmacén mensajesAlmacén SQL genéricoALMACENES DE DATOSCanal por usuarioPublicación / suscripciónPublicación /suscripciónMENSAJERÍA Y FLUJOS DETRABAJOOtro servidor de chatOtro servidor dechatServidor en tiempo real (WebSocket / SSE)Servidor en tiempo real(WebSocket / SSE)SERVICIOS Y APISMóvil de BobSPA / MóvilCLIENTES E INTERFAZ

El servidor de Alice publica en el canal de Bob; el servidor que tiene el socket de Bob está suscrito a él.

Más informaciónBalanceo de carga y escalado horizontalPub/sub: topics, suscripciones y replay

Un broker simple como Redis Pub/Sub no guarda nada: entrega a quien esté suscrito en ese instante, y un servidor cuyo enlace se cae dos segundos pierde esos dos segundos para siempre. Eso suena alarmante y aquí es aceptable, por la razón que ya daba la versión de un solo servidor: el mensaje se almacenó antes de publicarse. El broker es una vía rápida hacia un Bob conectado, no el lugar donde viven sus mensajes. Lo que sí requiere cuidado es cómo recupera Bob lo que la vía rápida dejó caer.

¿Qué pasa cuando un servidor de chat muere con 50.000 sockets? Cada uno de esos clientes lo nota en pocos segundos y se reconecta a través del balanceador de carga a los otros servidores, que vuelven a suscribirse a sus canales. Los mensajes publicados en esos canales durante el hueco no llegaron a nadie, pero están en el almacén, y cada móvil carga lo que se perdió al reconectarse. Un detalle decide si eso funciona: un móvil que se reconecta debe suscribirse primero y consultar el almacén después. En el orden contrario, un mensaje almacenado entre los dos pasos no está ni en la respuesta ni se entrega en vivo.

La reconexión en sí es el segundo coste de tener varios servidores. Cincuenta mil móviles que se reconectan todos en el mismo segundo, cada uno abriendo una conexión cifrada (TLS), comprobando un token y pidiéndole al almacén lo que se perdió, pueden sobrecargar a los servidores que siguen en pie; si estos se vuelven lentos, los handshakes expiran, los móviles reintentan y la carga se retroalimenta. Los clientes esperan un retraso aleatorio y creciente antes de reconectarse (backoff con jitter), y los despliegues cierran los sockets por lotes en lugar de todos a la vez (draining). Ese fallo tiene un artículo propio en este blog, enlazado al final. También explica por qué son una docena de servidores y no diez: los que sobreviven necesitan margen para las conexiones de un servidor.

Bob está sin conexión

Ahora el caso con el que empezó el artículo. El móvil de Bob está apagado. El servidor de Alice almacena el mensaje, se lo confirma y publica en el canal de Bob. Nadie está suscrito, así que el broker no se lo entrega a nadie, y ahí termina todo. Nada en este diseño registra que Bob está sin conexión, así que nada le avisa de que hay un mensaje esperando. El mensaje está a salvo en el almacén e invisible hasta que él abra la app por su cuenta.

Para notificar a Bob, el servidor tiene que saber que no está conectado en ningún sitio. De eso se encarga un registro de conexiones: un almacén clave-valor rápido que asocia a cada usuario con los servidores de chat que tienen un socket suyo. Un servidor escribe la entrada de Bob cuando se abre allí su primer socket y la borra cuando se cierra el último. Un servidor que se cae no borra nada, y un móvil que se queda sin batería no cierra nada, así que cada entrada lleva un tiempo de vida (TTL) que el servidor renueva solo mientras el móvil siga respondiendo a sus heartbeats; cuando cualquiera de los dos se queda en silencio, sus entradas caducan en pocos segundos. El mismo registro puede responder “¿Bob está en línea?” para el punto verde que ven los demás usuarios, aunque un punto fiable necesita heartbeats y un período de gracia, algo que cubre el artículo de Learn sobre presencia.

Con el registro, el servidor de Alice puede distinguir los dos casos. Si Bob tiene una entrada, la publicación debería llegarle y no hace falta push. Si no la tiene, el servidor pone un trabajo de push en una cola de entrega, y un servicio de notificaciones toma los trabajos de la cola y envía una notificación push a través del servicio de push de la plataforma del teléfono: Apple Push Notification service (APNs) para los iPhone, Firebase Cloud Messaging (FCM) para Android. La arista de trazos hacia el móvil de Bob en el dibujo representa ese salto a través de Apple o Google.

Etapa 3 de 5: Bob está sin conexión
Bob está sin conexiónUn registro de conexiones, un almacén clave-valor, anota ahora qué servidor de chat tiene los sockets de cada usuario; el servidor que tiene el socket de Bob escribe su entrada. El servidor de chat de Alice lo consulta ahí y, cuando Bob no tiene entrada, pone un trabajo de push en una cola de entrega. Un servicio de notificaciones toma el trabajo y envía una notificación push al móvil de Bob a través del servicio de push de la plataforma del teléfono.al canal de BobWebSocketjob de pushMóvil de AliceSPA / MóvilCLIENTES E INTERFAZBalanceador de cargaBalanceador decargaEnrutador de tráficoPLATAFORMA Y RUNTIMEServidor de chatServidor en tiempo real (WebSocket / SSE)Servidor en tiempo real(WebSocket / SSE)SERVICIOS Y APISAlmacén mensajesAlmacén SQL genéricoALMACENES DE DATOSCola de entregaColaMENSAJERÍA Y FLUJOS DETRABAJOCanal por usuarioPublicación / suscripciónPublicación /suscripciónMENSAJERÍA Y FLUJOS DETRABAJORegistro conexionesConsultas KV genéricasALMACENES DE DATOSOtro servidor de chatOtro servidor dechatServidor en tiempo real (WebSocket / SSE)Servidor en tiempo real(WebSocket / SSE)SERVICIOS Y APISServicio de notificacionesServicio denotificacionesPush / CorreoSERVICIOS Y APISMóvil de BobSPA / MóvilCLIENTES E INTERFAZ
Bob está sin conexiónUn registro de conexiones, un almacén clave-valor, anota ahora qué servidor de chat tiene los sockets de cada usuario; el servidor que tiene el socket de Bob escribe su entrada. El servidor de chat de Alice lo consulta ahí y, cuando Bob no tiene entrada, pone un trabajo de push en una cola de entrega. Un servicio de notificaciones toma el trabajo y envía una notificación push al móvil de Bob a través del servicio de push de la plataforma del teléfono.al canal de BobWebSocketjob de pushMóvil de AliceSPA / MóvilCLIENTES E INTERFAZBalanceador de cargaBalanceador decargaEnrutador de tráficoPLATAFORMA Y RUNTIMEServidor de chatServidor en tiempo real (WebSocket / SSE)Servidor en tiempo real(WebSocket / SSE)SERVICIOS Y APISAlmacén mensajesAlmacén SQL genéricoALMACENES DE DATOSCola de entregaColaMENSAJERÍA Y FLUJOS DETRABAJOCanal por usuarioPublicación / suscripciónPublicación /suscripciónMENSAJERÍA Y FLUJOS DETRABAJORegistro conexionesConsultas KV genéricasALMACENES DE DATOSOtro servidor de chatOtro servidor dechatServidor en tiempo real (WebSocket / SSE)Servidor en tiempo real(WebSocket / SSE)SERVICIOS Y APISServicio de notificacionesServicio denotificacionesPush / CorreoSERVICIOS Y APISMóvil de BobSPA / MóvilCLIENTES E INTERFAZ

Sin entrada en el registro no hay ningún socket en ningún sitio: el servidor encola un trabajo de push.

Más informaciónPresencia y estado efímeroNotificaciones y mensajería transaccionalColas de mensajes y workers asíncronos

¿Por qué una cola entre el servidor de chat y el servicio de notificaciones? Porque el servicio de push es de otro, con su propia latencia y sus propios malos días, y Alice nunca debería esperar por él. Su mensaje queda almacenado y confirmado tanto si Apple responde rápido como si no.

El push le dice a Bob que mire, pero no entrega la conversación. APNs y FCM no prometen que cada notificación llegue: un móvil que estuvo apagado durante horas puede recibir algunas tarde, varias agrupadas en una, o ninguna. Así que la entrega sigue donde ya estaba. Cuando Bob abre la app, su móvil le pide al almacén todos los mensajes posteriores al último que tiene. En esta versión, el servidor de chat marca cada mensaje con su propio reloj al almacenarlo, y “el último” significa la marca de tiempo del mensaje más reciente que hay en el móvil. Ten presente ese cursor; la siguiente sección lo desmonta.

Las piezas nuevas fallan de formas que vale la pena nombrar:

  • El servicio de push va lento o está caído. Los trabajos se acumulan en la cola y las notificaciones llegan tarde. El chat en sí no se ve afectado, y Bob sigue recibiendo todo cuando abre la app.
  • El registro está desactualizado. Durante unos segundos después de que se cae un servidor de chat, la entrada de Bob sigue apuntando a él. Un mensaje enviado en esa ventana se publica en el canal de Bob, al que ya no está suscrito ningún servidor vivo, y no sale ningún push, porque el registro decía que estaba conectado. Cuando su móvil se reconecta y se pone al día, el mensaje está ahí. Un registro desactualizado cuesta una notificación, no un mensaje.
  • El registro está caído. El servidor no puede distinguir conectado de sin conexión y tiene que apostar por uno. Este diseño trata a todos como sin conexión: sigue publicando en el canal del destinatario y además encola un push. El coste son notificaciones redundantes para quien ya vio el mensaje; la otra apuesta costaría notificaciones perdidas para quien no lo vio, que es peor. La entrega en vivo nunca consulta el registro, así que sigue funcionando.

Bob en dos dispositivos, y un mensaje enviado dos veces

Bob también tiene un portátil. Algunas noches los dos dispositivos están conectados a la vez, y el enrutamiento ya lo maneja: en el dibujo el portátil está en el mismo servidor que el móvil, que se suscribió al canal de Bob cuando llegó su primer socket; en cualquier otro servidor, ese servidor también se suscribiría a su canal. Esta noche es el otro caso: el portátil estuvo abierto más temprano, cuando el móvil ya estaba muerto en el cajón. Lo que falla ahora es más sutil: tres maneras en que el mismo mensaje puede llegarle mal a Bob, y cada una se arregla con una regla, no con una pieza nueva.

Dos veces. El mensaje de Alice está almacenado, pero la confirmación nunca llega a su móvil; ella entró en un túnel. Su móvil hace lo que debe y vuelve a enviar el mensaje, y Bob lo ve dos veces. El arreglo empieza en el móvil de Alice: le da a cada mensaje un ID cuando ella pulsa enviar, y un reenvío lleva el mismo ID. El almacén rechaza un segundo mensaje con un ID que ya tiene en esa conversación y responde al reenvío con la confirmación del original, y todo cliente ignora un mensaje cuyo ID ya muestra. Reenviar hasta que llegue una confirmación hace que la entrega sea al menos una vez; la deduplicación por ID convierte eso en mostrado una vez.

Fuera de orden, o con huecos. El cursor por marca de tiempo del caso sin conexión pierde mensajes, y no pocas veces. Los relojes de dos servidores de chat difieren por unos milisegundos, así que un mensaje almacenado después puede llevar una marca anterior. Dos mensajes pueden compartir el mismo milisegundo. Y un mensaje cuya escritura tarda un poco más en confirmarse puede aparecer en el almacén después de que el móvil de Bob ya haya leído más allá de su marca de tiempo; pedir entonces “todo lo posterior a la marca más reciente que tengo” lo salta para siempre.

El arreglo es un número de secuencia por conversación, asignado por el almacén en la misma escritura que guarda el mensaje: 41, 42, 43, sin que dos mensajes compartan uno. En un almacén relacional, puede ser un contador en la fila de la conversación, incrementado en la misma transacción que inserta el mensaje, de modo que las escrituras concurrentes en una conversación toman sus números una tras otra. Eso da a cada conversación exactamente una autoridad sobre su orden. Suponemos que incluso un grupo activo envía muchos menos mensajes por segundo de los que una fila admite en actualizaciones, así que esperar por esa fila no cuesta nada apreciable con estos números.

Cada dispositivo guarda entonces su propio “último número de secuencia que tengo” para cada conversación. El móvil de Bob murió sabiendo hasta el 40; el portátil, abierto más temprano, sabe hasta el 41, el último mensaje antes de la pregunta de Alice. Cuando el móvil se reconecta, pide todo lo posterior al 40 en esa conversación; cuando se abre el portátil, pide todo lo posterior al 41. Los dos se ponen al día de forma independiente, ya que cada uno puede haberse perdido mensajes distintos.

Un hueco estando conectado. El broker puede perder un mensaje mientras los sockets de Bob siguen abiertos, de modo que su móvil nunca se reconecta y nunca se pone al día. Los números de secuencia lo hacen visible: un dispositivo que recibe el 41 y luego el 43 sabe que existe el 42, se lo pide al almacén y mantiene su cursor en el 41 hasta que llega el 42; un cursor que saltara al 43 se saltaría el 42 para siempre si el dispositivo muriera antes. Un hueco justo al final de una conversación tranquila no tiene un mensaje siguiente que lo revele, así que los clientes también le piden al almacén de vez en cuando el último número de secuencia de cada conversación.

Etapa 4 de 5: Una vez, en orden, en cada dispositivo
Una vez, en orden, en cada dispositivoEl portátil de Bob mantiene ahora un WebSocket con el mismo servidor de chat que su móvil, que entrega cada mensaje a ambos. El resto del sistema no cambia; esta etapa añade reglas, no componentes: IDs de mensaje generados por el cliente, números de secuencia por conversación asignados por el almacén de mensajes y un cursor de puesta al día que guarda cada dispositivo.al canal de BobWebSocketjob de pushMóvil de AliceSPA / MóvilCLIENTES E INTERFAZBalanceador de cargaBalanceador decargaEnrutador de tráficoPLATAFORMA Y RUNTIMEServidor de chatServidor en tiempo real (WebSocket / SSE)Servidor en tiempo real(WebSocket / SSE)SERVICIOS Y APISAlmacén mensajesAlmacén SQL genéricoALMACENES DE DATOSCola de entregaColaMENSAJERÍA Y FLUJOS DETRABAJOCanal por usuarioPublicación / suscripciónPublicación /suscripciónMENSAJERÍA Y FLUJOS DETRABAJORegistro conexionesConsultas KV genéricasALMACENES DE DATOSOtro servidor de chatOtro servidor dechatServidor en tiempo real (WebSocket / SSE)Servidor en tiempo real(WebSocket / SSE)SERVICIOS Y APISPortátil de BobSPA / MóvilCLIENTES E INTERFAZServicio de notificacionesServicio denotificacionesPush / CorreoSERVICIOS Y APISMóvil de BobSPA / MóvilCLIENTES E INTERFAZ
Una vez, en orden, en cada dispositivoEl portátil de Bob mantiene ahora un WebSocket con el mismo servidor de chat que su móvil, que entrega cada mensaje a ambos. El resto del sistema no cambia; esta etapa añade reglas, no componentes: IDs de mensaje generados por el cliente, números de secuencia por conversación asignados por el almacén de mensajes y un cursor de puesta al día que guarda cada dispositivo.al canal de BobWebSocketjob de pushMóvil de AliceSPA / MóvilCLIENTES E INTERFAZBalanceador de cargaBalanceador decargaEnrutador de tráficoPLATAFORMA Y RUNTIMEServidor de chatServidor en tiempo real (WebSocket / SSE)Servidor en tiempo real(WebSocket / SSE)SERVICIOS Y APISAlmacén mensajesAlmacén SQL genéricoALMACENES DE DATOSCola de entregaColaMENSAJERÍA Y FLUJOS DETRABAJOCanal por usuarioPublicación / suscripciónPublicación /suscripciónMENSAJERÍA Y FLUJOS DETRABAJORegistro conexionesConsultas KV genéricasALMACENES DE DATOSOtro servidor de chatOtro servidor dechatServidor en tiempo real (WebSocket / SSE)Servidor en tiempo real(WebSocket / SSE)SERVICIOS Y APISPortátil de BobSPA / MóvilCLIENTES E INTERFAZServicio de notificacionesServicio denotificacionesPush / CorreoSERVICIOS Y APISMóvil de BobSPA / MóvilCLIENTES E INTERFAZ

Ningún servicio nuevo: IDs de mensaje, números de secuencia por conversación y un cursor por dispositivo.

Más informaciónMessage DeduplicationIdempotencia y las ilusiones del exactamente-una-vez

El número de secuencia también indica cómo crecerá el almacén. A 24 GB al día, unos 9 TB al año, tarde o temprano superará a una sola base de datos, y cuando lo haga, la conversación es la clave de partición natural: todas las puestas al día de arriba leen una conversación, y la autoridad de secuencia de una conversación vive en la misma partición que sus mensajes. Eso es un paso futuro, no este, así que el dibujo mantiene una sola caja.

Una pregunta que esto deja al producto: cuando Bob está conectado en el portátil y su móvil está apagado, ¿el móvil también debería recibir una notificación? En este diseño no, porque al registro se le pregunta si Bob tiene un socket en algún sitio, no en cada dispositivo. Las apps de mensajería responden esa pregunta de maneras distintas, y cualquiera de las dos respuestas funciona con el resto del diseño.

Alice escribe a 500 personas

Alice hace la misma pregunta en el grupo de su barrio, de 500 miembros: “¿Seguimos en pie para el sábado?” Pasa eso por el diseño que tenemos y el camino de envío se convierte en un bucle: por cada uno de los otros 499 miembros, buscarlo en el registro, publicar en su canal y encolar un push para cada uno que esté sin conexión. El trabajo del servidor de chat por mensaje ahora crece con el tamaño del grupo, en los mismos servidores que guardan los sockets de todos. Peor aún, el servidor le confirma a Alice cuando el mensaje queda almacenado, antes de que termine ese bucle; un servidor que se cae a mitad ya le dijo a Alice “enviado”, y los push que aún no había encolado simplemente desaparecen. Ese hueco ya existía en el diseño uno a uno, entre almacenar un mensaje y encolar su push; un grupo estira esa ventana a lo largo del trabajo de 499 miembros.

El arreglo es sacar el fan-out del camino de envío. El servidor de chat almacena el mensaje y, en la misma transacción de base de datos, registra un trabajo: entregar el mensaje 42 de este grupo. Un pequeño relay dentro de los servidores de chat mueve los trabajos registrados a la cola de entrega. Escribir el trabajo en la misma transacción que el mensaje es lo que hace segura la confirmación: si el mensaje está almacenado, su trabajo existe, aunque el servidor muera al instante siguiente. Es el patrón de outbox transaccional, y cuesta una tabla más en una base de datos en la que el servidor ya escribe. También cierra el hueco del caso uno a uno, porque ahora el trabajo de cada mensaje se registra así.

También responde a una pregunta que planteó la cola de entrega cuando apareció: ¿y si la cola está caída? El relay no puede mover los trabajos, así que esperan en la tabla de outbox. Alice sigue enviando mientras la tabla de outbox crece, y las notificaciones y los mensajes de grupo llegan cuando la cola vuelve. Los mensajes uno a uno, que además conservan una publicación directa, siguen llegando en vivo.

Los workers de fan-out toman los trabajos de la cola y hacen el bucle lejos de los servidores que guardan los sockets. El trabajo lleva solo el mensaje y el grupo. Un worker lee la lista de miembros del almacén, publica el mensaje en el canal de cada miembro, pregunta al registro en una sola consulta por lotes qué miembros no tienen socket y se los pasa al servicio de notificaciones. Un worker confirma un trabajo solo cuando su bucle ha terminado y el servicio de notificaciones ha almacenado los push que enviará, y el relay marca un trabajo como movido solo cuando la cola lo ha almacenado, de modo que una caída en cualquiera de los dos lados repite trabajo en vez de perderlo: a un miembro se le puede enviar el mensaje dos veces, algo que su ID absorbe, o el miembro puede recibir una segunda notificación. Esas lecturas y la consulta al registro no están dibujadas, para que el dibujo no tenga líneas que se crucen. Consultar al registro cuando se ejecuta el trabajo, y no cuando Alice envía, también significa que un worker retrasado decide según quién está conectado ahora, no según quién lo estaba cuando se envió el mensaje. La lista de miembros funciona al revés: el worker lee el grupo tal como estaba en el mensaje 42 (cada membresía registra los números de secuencia donde empieza y termina), de modo que quien se une un segundo después de que Alice envíe no recibe un mensaje anterior a su ingreso. Los trabajos de push de los mensajes uno a uno viajan ahora de la misma manera, como trabajos con un único destinatario, así que los servidores de chat dejan de leer el registro: solo escriben entradas por los sockets que tienen, y los workers hacen la lectura.

Etapa 5 de 5: Fan-out fuera del camino de envío
Fan-out fuera del camino de envíoLa arquitectura final. Para un mensaje de grupo, el servidor de chat almacena el mensaje y un trabajo de entrega, que llega a la cola de entrega. Los workers de fan-out toman cada trabajo, publican el mensaje en el canal de cada miembro en el servicio de pub/sub y pasan los miembros sin conexión abierta al servicio de notificaciones, que envía las notificaciones push.al canal de BobWebSocketun job por mensajemiembros offlineMóvil de AliceSPA / MóvilCLIENTES E INTERFAZBalanceador de cargaBalanceador decargaEnrutador de tráficoPLATAFORMA Y RUNTIMEServidor de chatServidor en tiempo real (WebSocket / SSE)Servidor en tiempo real(WebSocket / SSE)SERVICIOS Y APISAlmacén mensajesAlmacén SQL genéricoALMACENES DE DATOSCola de entregaColaMENSAJERÍA Y FLUJOS DETRABAJOCanal por usuarioPublicación / suscripciónPublicación /suscripciónMENSAJERÍA Y FLUJOS DETRABAJORegistro conexionesConsultas KV genéricasALMACENES DE DATOSWorkers de fan-outConsumidorMENSAJERÍA Y FLUJOS DETRABAJOOtro servidor de chatOtro servidor dechatServidor en tiempo real (WebSocket / SSE)Servidor en tiempo real(WebSocket / SSE)SERVICIOS Y APISPortátil de BobSPA / MóvilCLIENTES E INTERFAZServicio de notificacionesServicio denotificacionesPush / CorreoSERVICIOS Y APISMóvil de BobSPA / MóvilCLIENTES E INTERFAZ
Fan-out fuera del camino de envíoLa arquitectura final. Para un mensaje de grupo, el servidor de chat almacena el mensaje y un trabajo de entrega, que llega a la cola de entrega. Los workers de fan-out toman cada trabajo, publican el mensaje en el canal de cada miembro en el servicio de pub/sub y pasan los miembros sin conexión abierta al servicio de notificaciones, que envía las notificaciones push.al canal de BobWebSocketun job por mensajemiembros offlineMóvil de AliceSPA / MóvilCLIENTES E INTERFAZBalanceador de cargaBalanceador decargaEnrutador de tráficoPLATAFORMA Y RUNTIMEServidor de chatServidor en tiempo real (WebSocket / SSE)Servidor en tiempo real(WebSocket / SSE)SERVICIOS Y APISAlmacén mensajesAlmacén SQL genéricoALMACENES DE DATOSCola de entregaColaMENSAJERÍA Y FLUJOS DETRABAJOCanal por usuarioPublicación / suscripciónPublicación /suscripciónMENSAJERÍA Y FLUJOS DETRABAJORegistro conexionesConsultas KV genéricasALMACENES DE DATOSWorkers de fan-outConsumidorMENSAJERÍA Y FLUJOS DETRABAJOOtro servidor de chatOtro servidor dechatServidor en tiempo real (WebSocket / SSE)Servidor en tiempo real(WebSocket / SSE)SERVICIOS Y APISPortátil de BobSPA / MóvilCLIENTES E INTERFAZServicio de notificacionesServicio denotificacionesPush / CorreoSERVICIOS Y APISMóvil de BobSPA / MóvilCLIENTES E INTERFAZ

Un trabajo duradero por mensaje; los workers hacen el trabajo por miembro.

Más informaciónFan-out: empujar vs. tirar (push vs pull)Transactional OutboxDiseño resuelto: un chat en tiempo real

Los mensajes uno a uno conservan su publicación directa en el canal del destinatario, así que el caso común no se vuelve más lento. Los mensajes de grupo tardan unos milisegundos más en llegar a los miembros conectados, porque antes pasan por la cola y por un worker. A cambio, la cola pasa a ser el lugar donde se ve una acumulación: si los workers se atrasan, los mensajes de grupo y las notificaciones llegan tarde, mientras que los mensajes uno a uno siguen llegando en vivo.

Los workers publican una vez por miembro. Un sistema más grande agruparía a los miembros por el servidor que, según el registro, los tiene y publicaría una vez por servidor, muchos menos mensajes para el broker; el precio es que el registro pasa al camino en vivo, y entonces una caída del registro detiene la entrega en vivo en lugar de causar solo notificaciones de más. Con 500 miembros, este diseño mantiene el registro fuera del camino en vivo: una caída del registro sigue costando solo notificaciones de más.

Hay un tamaño a partir del cual enviar una copia a cada miembro deja de tener sentido: un canal que siguen cientos de miles de personas. Allí, los lectores consultan los mensajes del canal cuando lo abren, en vez de que a cada uno se le envíe una copia. Es otro producto, con sus propios equilibrios entre push y pull, y este diseño no lo necesita con 500 miembros.

Dónde puede atascarse todavía el mensaje de Alice

Una última vez, la pregunta de Alice a través de todo el dibujo. Su móvil le asigna un ID y la envía por el balanceador de carga a un servidor de chat. El servidor la almacena como el número 42 de la conversación, registra su trabajo de entrega en la misma transacción y le dice a Alice “enviado”. Publica en el canal de Bob; nadie está suscrito. Un worker recoge el trabajo, no encuentra entrada de Bob en el registro y le pasa un push al servicio de notificaciones, y Apple lo transmite cuando el móvil de Bob vuelve a encenderse, o no. Una hora después el móvil se reconecta, se suscribe y pide todo lo posterior al 40. El portátil, abierto a la mañana siguiente, pide todo lo posterior al 41. El mensaje aparece una vez en cada dispositivo, en su lugar, y nada de su recorrido tuvo que funcionar a la primera salvo el almacén.

Doce cajas: tres son el móvil de Alice y el móvil y el portátil de Bob, y los dos servidores de chat representan a una docena. Esto es lo que pasa cuando se rompe cada una de las demás, y quién lo nota:

  • Se cae un servidor de chat → sus usuarios se desconectan, se reconectan con backoff y jitter a los otros servidores, vuelven a suscribirse y se ponen al día por número de secuencia. Los mensajes enviados entretanto estaban almacenados; nadie pierde ninguno.
  • Falla el balanceador de carga → los móviles ya no pueden llegar a ningún servidor de chat. Usa uno gestionado y redundante, o ejecuta dos.
  • El broker se retrasa o pierde mensajes → la entrega en vivo llega tarde o a trozos. La detección de huecos y la sincronización periódica traen los mensajes que faltan desde el almacén.
  • El registro está desactualizado → se puede perder una notificación. El registro está caído → todos se tratan como sin conexión: notificaciones de más, entrega en vivo sin cambios.
  • La cola de entrega está caída, o los workers se atrasan o se caen → los trabajos esperan en el outbox o en la cola, y el trabajo de un worker caído se vuelve a ejecutar; las notificaciones y los mensajes de grupo llegan tarde, los mensajes uno a uno siguen llegando en vivo y Alice sigue enviando.
  • El servicio de notificaciones o el servicio de push que hay detrás va lento o está caído → las notificaciones llegan tarde o no llegan; todo está en la app cuando se abre.
  • El almacén de mensajes está caído → el envío se detiene. El móvil de Alice conserva el mensaje y reintenta con el mismo ID. Es la única dependencia que el camino de envío no puede rodear, porque cada garantía de este diseño empieza con “el mensaje está almacenado”. Ejecútalo replicado, con cada escritura en una segunda máquina antes de que Alice vea “enviado”, o un failover puede perder mensajes que a ella le dijeron que se habían enviado.

Salvo el balanceador de carga, que solo tiene que ser redundante, el almacén es la única caja cuya caída impide que Alice envíe, y ningún fallo de la lista puede perder un mensaje que a ella le dijeron que se envió. El broker y el servicio de push son vías rápidas a las que se les permite fallar, porque detrás de cada una el almacén sigue teniendo el mensaje, y todos los dispositivos saben cómo pedirlo.

Fuera de este diseño

  • Cifrado de extremo a extremo. El enrutamiento de este artículo lo soporta; lo que cambia es lo que el servidor puede leer, algo que cubren el diseño de chat resuelto de Learn y el Desafío Mensajería Cifrada de Extremo a Extremo.
  • Confirmaciones de lectura e indicadores de escritura. Ambos son estado efímero sobre una conversación, no mensajes dentro de ella. Un indicador de escritura puede perderse sin daño; una confirmación de lectura se parece más a un mensaje y normalmente se almacena.
  • Fotos, vídeo y archivos. Los adjuntos van a un almacenamiento de objetos, y el mensaje lleva una referencia a ellos, no los bytes.
  • Llamadas de voz y vídeo, que son medios en tiempo real con sus propios protocolos.
  • Búsqueda sobre el historial de mensajes, un índice aparte alimentado desde el almacén.
  • Varias regiones. Aquí Bob y Alice están en el mismo continente.

Dibújalo tú mismo

El Desafío Sistema de chat pide esta arquitectura. Su paleta nombra productos (MongoDB, Redis, Kafka, un proveedor de push) donde este artículo dibuja cajas genéricas; un topic de Kafka puede hacer de cola de entrega. Dibújalo y luego envíale la pregunta de Alice a un Bob cuyo móvil está apagado.