guide:sync@es

Guías

Mantener las tuplas al día con los datos

Por qué el artículo nunca trata las escrituras dobles, qué sale mal cuando la base de datos de una aplicación y un servicio de autorización no coinciden, y los patrones que se usan para mantenerlos sincronizados.

Datos verificados el Secciones del artículo §1, §2.2, §2.4.2, §2.4.3, §2.4.4, §3.1.2

Un servicio de autorización solo sabe lo que se le ha dicho. Cuando Anne comparte doc:readme o quita a Beto de group:eng, el hecho suele empezar en la propia base de datos de la aplicación y tiene que llegar al servicio de autorización como una tupla. Dos sistemas, dos escrituras, ninguna transacción compartida. Esta página explica por qué el artículo apenas menciona el problema, cómo fallan las dos escrituras y los patrones que se usan para mantenerlas sincronizadas.

Por qué el artículo puede dejarlo fuera

El artículo describe Zanzibar como “a system for storing permissions and performing authorization checks based on the stored permissions” (un sistema para almacenar permisos y realizar comprobaciones de autorización basadas en los permisos almacenados) (§1), y presenta el “unified ACL storage and an RPC-based API” (almacenamiento unificado de ACL y una API basada en RPC) como “a philosophy also core to Zanzibar’s design” (una filosofía también central en el diseño de Zanzibar) (§5). Las ACL y los grupos residen en Zanzibar. La aplicación cliente guarda su contenido en su propio almacenamiento, y lo único que almacena sobre autorización es el zookie.

El protocolo del artículo está planteado para que la única escritura que abarca ambos lados sea atómica en el lado del cliente: “The client stores the zookie with the content change in an atomic write to the client storage” (El cliente almacena el zookie junto con el cambio de contenido en una escritura atómica en el almacenamiento del cliente) (§2.2). La comprobación que produjo el zookie es una lectura; “the content-change check does not need to be evaluated in the same transaction as the application content modification” (la comprobación de cambio de contenido no necesita evaluarse en la misma transacción que la modificación del contenido de la aplicación) (§2.2). Dentro de Zanzibar, la tupla y su entrada en el registro de cambios son una sola transacción: “Every Zanzibar write is committed to both the tuple storage and the changelog shard in a single transaction” (Cada escritura de Zanzibar se confirma tanto en el almacenamiento de tuplas como en el fragmento del registro de cambios en una única transacción) (§3.1.2), así que Watch no puede perder una escritura confirmada.

El artículo no dice si las aplicaciones de Google guardan también su propia copia de datos como “quién es el propietario de este documento”, ni cómo la conciliarían. No trata ese caso.

La mayoría de quienes lo adoptan parten de otro sitio. El propietario es una columna de la tabla documents; la pertenencia a equipos es una tabla de unión; las licencias de facturación residen en otro servicio. El mismo hecho existe entonces dos veces, y cada cambio en él es una escritura doble.

Cómo fallan las escrituras dobles

La entrada de AuthZed sobre el tema lo dice sin rodeos: “The dual-write problem presents itself in all distributed systems” (el problema de la escritura doble se presenta en todos los sistemas distribuidos) (AuthZed, The Dual-Write Problem). Ningún orden de las dos escrituras es seguro por sí solo, porque el proceso puede detenerse entre ambas. ¿Qué ocurre en cada orden?

Primero la base de datos; se pierde la escritura de la tuplaAnne quita a Beto del grupo eng. La aplicación confirma el cambio en su base de datos. Antes de eliminar la tupla en el servicio de autorización, la aplicación se cae. La tupla sigue ahí, así que una comprobación posterior permite a Beto ver el readme, aunque los propios datos de la aplicación digan que ya no es miembro.tiempoappBD de la appservicio de authznunca enviadaAnne quita aBeto de engborra la fila demiembro, COMMITcaída antes deborrar la tuplamiembro de engbeto: sigue ahíBeto ve elreadme: permitido
Una revocación perdida falla de forma abierta, y nada en la aplicación lo muestra.
Primero la tupla; se revierte la base de datosAnne hace a Beto editor del readme. La aplicación abre una transacción de base de datos e inserta una fila de compartición, luego escribe la tupla editor en el servicio de autorización y después se cae antes de confirmar. La base de datos revierte, así que la aplicación no muestra ninguna compartición, pero el servicio de autorización permite a Beto editar.tiempoappBD de la appservicio de authzAnne hace a BetoeditorBEGIN, insertafila de comparticiónescribe readmeeditor betocaída antesde COMMITrevertido: sin filade comparticiónBeto puede editar
Los dos sistemas discrepan; aquí la concesión existe solo donde la interfaz no puede mostrarla.

Obsérvese que la viñeta de la izquierda es la peligrosa para la seguridad y la de la derecha para la confianza: Beto conserva un acceso que debería haber perdido, o tiene un acceso que nadie puede ver para revocarlo. La viñeta de la derecha es el caso que analiza AuthZed: “we’ve written to SpiceDB but we haven’t committed the transaction to our database, and now SpiceDB and our database disagree about the state of the world” (hemos escrito en SpiceDB pero no hemos confirmado la transacción en nuestra base de datos, y ahora SpiceDB y nuestra base de datos discrepan sobre el estado del mundo) (The Dual-Write Problem). Reintentar en el manejador de la solicitud no cierra ninguno de los dos huecos, porque la caída puede producirse antes del reintento.

Las opciones

La entrada de AuthZed enumera las opciones: no hacer nada, la comprobación de consistencia fuera de banda, hacer del servicio de autorización la fuente de verdad, event sourcing/CQRS, los entornos de ejecución duradera y el outbox transaccional (The Dual-Write Problem). No hacer nada “is an option that may be viable in the right context” (es una opción que puede ser viable en el contexto adecuado); la comprobación fuera de banda significa que “you can check that the two systems agree on a periodic basis” (puede comprobar periódicamente que los dos sistemas coinciden), lo que detecta la deriva pero no la evita. Las tres siguientes son las que eliminan la ventana estructuralmente o lo cierran de forma fiable.

El servicio de autorización como fuente de verdad

Almacenar cada relación una sola vez, en el servicio de autorización, y en ningún otro sitio. Es la disposición del artículo. AuthZed: “make a single write to SpiceDB and avoid the dual-write problem entirely” (hacer una única escritura en SpiceDB y evitar por completo el problema de la escritura doble) (The Dual-Write Problem).

El coste es que la aplicación ya no puede consultar esos datos como los suyos propios: con la titularidad solo en SpiceDB, una interfaz de usuario sobre ellos “wouldn’t be able to filter, sort, or paginate that table as easily” (no podría filtrar, ordenar ni paginar esa tabla con la misma facilidad), porque SpiceDB “isn’t a general-purpose database” (no es una base de datos de propósito general). El problema de los listados de Listar lo que un usuario puede ver se aplica entonces a cada pantalla que muestre la relación. Oso defiende la dirección opuesta para su propio producto, que permite “apply your application data to authorization decisions without synchronizing it” (aplicar los datos de la aplicación a las decisiones de autorización sin sincronizarlos) (Oso, Launching Local Authorization, entrada del proveedor), lo que evita la sincronización dejando los datos en la base de datos de la aplicación en lugar de moverlos.

Outbox transaccional y relé

Mantener la base de datos de la aplicación como fuente de verdad y hacer que la segunda escritura sea duradera en lugar de inmediata. En la misma transacción que el cambio de negocio, insertar en una tabla outbox una fila que describe el cambio de tuplas. Un relé independiente lee el outbox y aplica los cambios al servicio de autorización, reintentando hasta que tengan éxito. La forma general del patrón: “first store the message in the database as part of the transaction that updates the business entities” (almacenar primero el mensaje en la base de datos como parte de la transacción que actualiza las entidades de negocio) (Chris Richardson, Transactional outbox).

¿Qué hace el relé cuando el servicio de autorización no está disponible durante un momento?

Outbox transaccional y reléAnne quita a Beto del grupo eng. En una sola transacción de base de datos, la aplicación borra la fila de miembro e inserta una fila en el outbox. El relé lee la fila del outbox y envía la eliminación de la tupla; el primer intento falla, así que reintenta. El segundo intento tiene éxito, y el relé marca como hecha la fila del outbox. Hasta entonces, el servicio de autorización sigue dejando pasar a Beto.tiempoappBD de la appreléservicio de authzatómicareintentoackAnne quita aBeto de enguna txn: fila demiembro + outboxlee la siguientefila del outboxBeto siguepermitidoel borrado falla:reintentotupla eliminadafila del outboxmarcada hecha
No se pierde nada, pero el cambio llega al servicio de autorización más tarde que a la base de datos.

Obsérvese la caja roja de la derecha: el outbox garantiza que el cambio llega, no que llegue de inmediato. Entre la confirmación y el éxito del relé, el acceso antiguo sigue vigente. El relé tiene que tolerar además repeticiones porque, en palabras del propio patrón, “The Message relay might publish a message more than once” (el relé de mensajes podría publicar un mensaje más de una vez) (Transactional outbox); AuthZed remite a “SpiceDB allowing for idempotent writes with its TOUCH operation” (que SpiceDB permite escrituras idempotentes con su operación TOUCH), y al orden: “As long as this process is effectively single-threaded and retries operations until they succeed” (siempre que este proceso sea en la práctica de un solo hilo y reintente las operaciones hasta que tengan éxito) (The Dual-Write Problem). Aplicar una eliminación antes de la creación anterior dejaría un estado incorrecto.

Captura de datos de cambios

En lugar de sondear el outbox, leer el propio registro de confirmaciones de la base de datos. Debezium, por ejemplo, usa la decodificación lógica de PostgreSQL: tras una instantánea inicial, “continuously captures row-level changes that insert, update, and delete database content and that were committed to a PostgreSQL database” (captura de forma continua los cambios a nivel de fila que insertan, actualizan y eliminan contenido de la base de datos y que se confirmaron en una base de datos PostgreSQL) y los transmite a topics de Kafka. AuthZed la describe como una de las herramientas más usadas para el patrón outbox: “It watches changes in an outbox table and submits them as events to Kafka” (observa los cambios en una tabla outbox y los envía como eventos a Kafka) (The Dual-Write Problem).

¿Por dónde viaja un cambio desde la confirmación hasta convertirse en una tupla?

Captura de datos de cambios hacia el servicio de autorizaciónLa aplicación confirma filas de negocio y una fila del outbox en una sola transacción en su base de datos. Debezium lee los cambios confirmados del registro de escritura anticipada y los publica en un topic de Kafka. Un consumidor lee el topic, convierte cada evento en una escritura o eliminación de tupla y la aplica al servicio de autorización. Tras reiniciarse el conector puede haber duplicados, así que las escrituras del consumidor deben ser idempotentes.appBD de la appfilas + outboxDebezium(lee el WAL)topic de Kafkaconsumidor:evento → tuplaservicio de authzuna txncambiosconfirmadospublicaconsumeTOUCH /DELETE
Cada salto añade retraso; solo entran en la canalización los cambios confirmados, así que una transacción revertida nunca se convierte en una tupla.

Obsérvese el primer salto: como Debezium lee cambios confirmados, el fallo de la derecha descrito antes no puede ocurrir. Los duplicados, sí. La documentación de PostgreSQL de Debezium dice que, “while it is recovering from the fault, it’s possible that the connector might emit some duplicate change events” (mientras se recupera del fallo, es posible que el conector emita algunos eventos de cambio duplicados), y que “consumers should always anticipate some duplicate events” (los consumidores siempre deben prever algunos eventos duplicados) (conector de PostgreSQL de Debezium). Su outbox event router es la forma empaquetada de la combinación de outbox y CDC: “An outbox pattern implementation avoids inconsistencies between a service’s internal state (as typically persisted in its database) and state in events consumed by services that need the same data” (una implementación del patrón outbox evita las incoherencias entre el estado interno de un servicio, normalmente persistido en su base de datos, y el estado de los eventos que consumen los servicios que necesitan los mismos datos) (Debezium, Outbox Event Router).

Watch alimenta índices, pero no es una cola

Los patrones anteriores llevan los cambios hacia el servicio de autorización. Watch (§2.4.3) los saca de él: “Some clients maintain secondary indices of relation tuples in Zanzibar. They can do so with our Watch API.” (Algunos clientes mantienen índices secundarios de las tuplas de relación de Zanzibar. Pueden hacerlo con nuestra API Watch.) Una respuesta lleva los cambios “in ascending timestamp order” (en orden ascendente de marca de tiempo) hasta un zookie de latido, que “the client can use … to resume watching where the previous watch response left off” (el cliente puede utilizar … para reanudar la observación donde la dejó la respuesta de observación anterior) (§2.4.3). El indexador incremental de Leopard es el consumidor del propio artículo (§3.2.4).

La posición de reanudación es responsabilidad del cliente, y el servidor solo conserva el historial durante un tiempo. La documentación de SpiceDB: “Historical changes can only be requested until the configured garbage collection window on the underlying datastore. This is typically 24 hours, but may differ based on the datastore used” (los cambios históricos solo pueden solicitarse hasta la ventana de recolección de basura configurada en el almacén de datos subyacente. Suele ser de 24 horas, pero puede variar según el almacén de datos utilizado) (SpiceDB, Watching Relationship Changes). Un issue de SpiceDB enuncia la consecuencia: “the Watch API is non-durable; if you want to write to a durable queue, you have to take the messages coming from the Watch API and put them somewhere” (la API Watch no es duradera; si quiere escribir en una cola duradera, tiene que tomar los mensajes que salen de la API Watch y ponerlos en algún sitio) (spicedb#2015, cerrado como no planificado el 2026-10-29). El issue abierto spicedb#2285 añade que el comportamiento predeterminado “starts watching from the HEAD revision which leaves gaps of updates that may have not been seen” (empieza a observar desde la revisión HEAD, lo que deja huecos de actualizaciones que pueden no haberse visto).

¿Qué le ocurre a un índice cuyo consumidor está caído durante más tiempo que esa ventana?

Reanudar Watch y perder la posiciónEl indexador aplica un lote de cambios y guarda el token del flujo t50 junto con las filas del índice. Se desconecta, vuelve a conectarse con t50 y recibe los cambios siguientes. Más tarde está caído durante más tiempo que la ventana de recolección de basura del almacén de datos; t50 ha caducado, así que no puede reanudar y debe reconstruir el índice a partir de una lectura completa.tiemposervicio de authzindexadoríndiceguardareanudano puede reanudarcambios hastael token t50aplica el lotefilas + t50,una txndesconectadoWatch desde t50cambiosposteriores a t50caído más quela ventana de GCt50 caducadoreconstruye conlectura completa
Guarde el token en la misma transacción que las filas que cubre, y mantenga una vía de reconstrucción para cuando el historial ya no exista.

Obsérvese el primer evento del carril del índice: el token se almacena con las filas que produjo. Si el indexador guardara primero el token y luego se cayera, se saltaría cambios; si aplicara las filas y se cayera antes de guardarlo, las volvería a aplicar, lo que solo es inocuo cuando las escrituras en el índice son idempotentes. Para sobrevivir a una caída larga, hay que copiar el flujo en una cola duradera propia, como dice el issue, o estar preparado para reconstruir. El campo de reanudación de SpiceDB es ChangesThrough: la documentación recomienda llamar a Watch “in a loop, sending in the last received ZedToken from ChangesThrough if the call disconnects” (en un bucle, enviando el último ZedToken recibido de ChangesThrough si la llamada se desconecta) (Watching Relationship Changes).

Los zookies y cada opción

El protocolo de zookies necesita dos cosas del cliente: pedir un zookie cuando se guarda el contenido y almacenarlo con el contenido (§2.2, §2.4.4). La documentación de SpiceDB da el mismo consejo para los ZedTokens: almacenarlos “alongside the newly updated content in the application database” (junto al contenido recién actualizado en la base de datos de la aplicación), y actualizarlos cuando se crea o se elimina el recurso, cuando cambia su contenido y cuando se añade o se retira acceso a él (SpiceDB, Consistency). La comprobación de cambio de contenido no tiene un problema de escritura doble propio: es una lectura, y el token va a la base de datos de la aplicación en la misma transacción que el contenido.

Las opciones difieren en lo que ese token puede prometer.

Opción Cuándo está el cambio de ACL en el servicio de autorización Qué cubre un token almacenado
Servicio de autorización como fuente de verdad Cuando termina la escritura, antes de avisar al usuario Todo, como en el artículo: el token de la escritura, o una comprobación de cambio de contenido posterior, es al menos tan reciente como el cambio de ACL
Outbox y relé Cuando el relé tiene éxito, después de la confirmación en la base de datos Solo los cambios que el relé ya ha aplicado. Una comprobación de cambio de contenido hecha antes ve la ACL antigua
Captura de datos de cambios Después de que el registro se lea, se publique y se consuma Igual que el outbox, con más saltos de retraso
Índice alimentado por Watch Ya está; el retraso está en el índice Nada directamente: los zookies son opacos, así que el índice no puede saber si está tan al día como un token dado. Volver a comprobar con el token, o comparar la posición guardada del propio índice

Para las filas del outbox y de CDC, la garantía del artículo es más débil de lo que parece. El Ejemplo B de §2.2 depende de que el cambio de ACL (B1) esté en Zanzibar antes de que se compruebe el cambio de contenido (B2). Con un relé de por medio, Anne puede quitar a Beto, guardar contenido nuevo un segundo después y obtener un zookie de una comprobación de cambio de contenido que se ejecutó antes de que el relé aplicara la eliminación. El zookie es correcto para los datos que tenía Zanzibar; esos datos iban por detrás. Dos mitigaciones, ninguna procedente de las fuentes anteriores y ninguna probada aquí: enviar las revocaciones directamente al servicio de autorización y registrarlas en segundo lugar en la base de datos (aceptando el modo de fallo de la derecha como un estado visible de “sigue en la lista pero denegado”), o hacer que el relé escriba el token que recibe en las filas afectadas para que las comprobaciones posteriores lo lleven.

La regla de opacidad del artículo es deliberada: los zookies son opacos “to discourage our clients from choosing arbitrary timestamps and to allow future extensions” (para disuadir a nuestros clientes de elegir marcas de tiempo arbitrarias y para permitir extensiones futuras) (§2.4). El coste está en la última fila: un cliente no puede comparar dos zookies para decidir cuál es más reciente.

Reescribir de forma segura las tuplas de un objeto: la tupla de bloqueo

Un proceso de sincronización a menudo quiere sustituir todas las tuplas de un objeto para que coincidan con la base de datos, por ejemplo para fijar los lectores del readme exactamente a lo que dice la tabla de comparticiones. Dos procesos así, o un proceso y la edición de un usuario, pueden entrar en carrera. La respuesta del artículo es la concurrencia optimista con una tupla de bloqueo (§2.4.2):

“The lock tuple is just a regular relation tuple used by clients to detect write races” (La tupla de bloqueo no es más que una tupla de relación normal que los clientes utilizan para detectar carreras de escritura) (§2.4.2). ¿Qué ocurre cuando dos procesos de sincronización reescriben a la vez las tuplas del readme?

Concurrencia optimista con una tupla de bloqueoLos dos procesos de sincronización leen todas las tuplas de doc:readme, incluida la tupla de bloqueo, en la misma versión. El proceso 1 envía sus escrituras con un toque sobre la tupla de bloqueo, condicionadas a que el bloqueo no haya cambiado; Zanzibar las confirma y el bloqueo cambia. El proceso 2 envía sus escrituras con la misma condición; el bloqueo ha cambiado, así que Zanzibar las rechaza, y el proceso 2 vuelve al paso 1 y lee de nuevo.tiempoproceso 1proceso 2Zanzibarreintentolee tuplas delreadme + bloqueobloqueo enla versión 7lee tuplas delreadme + bloqueoescribe + toque,si bloqueo intactoconfirma;el bloqueo cambiaescribe + toque,si bloqueo intactobloqueo cambiado:rechazadovuelve al paso 1:lee de nuevo
Ningún proceso mantiene un bloqueo mientras calcula; la escritura condicional detecta la carrera en el momento de confirmar.

Obsérvese que el proceso 2 no queda bloqueado mientras trabaja el proceso 1; solo se entera del conflicto cuando intenta confirmar, y entonces vuelve a calcular con datos actuales. Eso conviene a los procesos de sincronización, que siempre pueden volver a calcular a partir de la base de datos.

Fuentes