guide:sync@fr

Guides

Garder les tuples synchronisés avec vos données

Pourquoi l’article n’aborde jamais les doubles écritures, ce qui se passe lorsque la base de données d’une application et un service d’autorisation divergent, et les schémas employés pour les maintenir en phase.

Faits vérifiés le Sections de l’article §1, §2.2, §2.4.2, §2.4.3, §2.4.4, §3.1.2

Un service d’autorisation ne sait que ce qu’on lui a dit. Lorsqu’Anne partage doc:readme ou retire Beto de group:eng, le fait naît généralement dans la base de données propre à l’application et doit parvenir au service d’autorisation sous forme de tuple. Deux systèmes, deux écritures, aucune transaction commune. Cette page explique pourquoi l’article mentionne à peine le problème, comment les deux écritures échouent, et les schémas employés pour les maintenir en phase.

Pourquoi l’article peut s’en dispenser

L’article décrit Zanzibar comme « a system for storing permissions and performing authorization checks based on the stored permissions » (un système de stockage des permissions et de vérification des autorisations fondée sur les permissions stockées) (§1), et présente « unified ACL storage and an RPC-based API » (un stockage unifié des ACL et une API fondée sur des RPC) comme « a philosophy also core to Zanzibar’s design » (une philosophie également au cœur de la conception de Zanzibar) (§5). Les ACL et les groupes résident dans Zanzibar. L’application cliente conserve son contenu dans son propre stockage, et la seule chose qu’elle y stocke concernant l’autorisation est le zookie.

Le protocole de l’article est conçu de sorte que la seule écriture qui concerne les deux côtés soit atomique côté client : « The client stores the zookie with the content change in an atomic write to the client storage » (Le client stocke le zookie avec la modification du contenu, au moyen d’une écriture atomique dans le stockage du client) (§2.2). La vérification qui a produit le zookie est une lecture ; « the content-change check does not need to be evaluated in the same transaction as the application content modification » (la vérification de modification de contenu n’a pas besoin d’être évaluée dans la même transaction que la modification du contenu de l’application) (§2.2). À l’intérieur de Zanzibar, le tuple et son entrée dans le journal des modifications forment une seule transaction : « Every Zanzibar write is committed to both the tuple storage and the changelog shard in a single transaction » (Chaque écriture Zanzibar est validée à la fois dans le stockage des tuples et dans le fragment du journal des modifications, en une seule transaction) (§3.1.2) ; Watch ne peut donc pas manquer une écriture validée.

L’article ne dit pas si les applications de Google conservent aussi leur propre copie de faits tels que « qui est propriétaire de ce document », ni comment elles la réconcilieraient. Il n’aborde pas ce cas.

La plupart des utilisateurs partent d’ailleurs. Le propriétaire est une colonne de la table documents ; l’appartenance aux équipes est une table de jointure ; les licences facturées résident dans un autre service. Le même fait existe alors en double, et chaque modification de ce fait est une double écriture.

Comment les doubles écritures échouent

L’article d’AuthZed sur le sujet le dit sans détour : « The dual-write problem presents itself in all distributed systems » (Le problème de la double écriture se pose dans tous les systèmes distribués) (AuthZed, The Dual-Write Problem). Aucun ordre des deux écritures n’est sûr à lui seul, car le processus peut s’arrêter entre les deux. Que se passe-t-il dans chaque ordre ?

Base de données d’abord, écriture du tuple perdueAnne retire Beto du groupe eng. L’application valide la modification dans sa base de données. Avant de supprimer le tuple dans le service d’autorisation, l’application plante. Le tuple est toujours là ; une vérification ultérieure laisse donc Beto consulter le readme, alors que les données propres à l’application indiquent qu’il n’est plus membre.tempsappbase de l’appservice d’autoris.jamais envoyéAnne retireBeto de engsupprimer la lignemembre, COMMITplantage avantsuppr. du tupleeng memberbeto : toujours làBeto consultele readme : autorisé
Une révocation perdue échoue en mode ouvert, et rien dans l’application ne le montre.
Tuple d’abord, base de données annuléeAnne fait de Beto un éditeur du readme. L’application ouvre une transaction de base de données et insère une ligne de partage, puis écrit le tuple editor dans le service d’autorisation, puis plante avant la validation. La base de données annule la transaction ; l’application n’affiche donc aucun partage, mais le service d’autorisation laisse Beto modifier.tempsappbase de l’appservice d’autoris.Anne fait de Betoun éditeurBEGIN, insérerligne de partageécrire readmeeditor betoplantage avantCOMMITannulé : aucuneligne de partageBeto peut modifier
Les deux systèmes divergent ; ici, l’autorisation n’existe que là où l’interface ne peut pas l’afficher.

Remarquez que le cadre de gauche est le plus dangereux pour la sécurité, et celui de droite pour la confiance : Beto conserve un accès qu’il aurait dû perdre, ou détient un accès que personne ne voit et ne peut donc révoquer. Le cadre de droite est le cas que détaille 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 » (nous avons écrit dans SpiceDB mais nous n’avons pas validé la transaction dans notre base de données, et SpiceDB et notre base de données sont désormais en désaccord sur l’état du monde) (The Dual-Write Problem). Réessayer dans le gestionnaire de requêtes ne referme aucune des deux brèches, car le plantage peut survenir avant la nouvelle tentative.

Les options

L’article d’AuthZed énumère les choix possibles : ne rien faire, vérifier la cohérence hors bande, faire du service d’autorisation la source de vérité, l’event sourcing/CQRS, les environnements d’exécution durable, et la boîte d’envoi transactionnelle (transactional outbox) (The Dual-Write Problem). Ne rien faire « is an option that may be viable in the right context » (est une option qui peut être viable dans le bon contexte) ; la vérification hors bande signifie que « you can check that the two systems agree on a periodic basis » (vous pouvez vérifier périodiquement que les deux systèmes concordent), ce qui détecte la dérive sans l’empêcher. Les trois options ci-dessous sont celles qui suppriment la fenêtre par construction ou la referment de façon fiable.

Le service d’autorisation comme source de vérité

Stocker chaque relation une seule fois, dans le service d’autorisation, et nulle part ailleurs. C’est l’organisation de l’article. AuthZed : « make a single write to SpiceDB and avoid the dual-write problem entirely » (effectuer une seule écriture dans SpiceDB et éviter entièrement le problème de la double écriture) (The Dual-Write Problem).

Le coût est que l’application ne peut plus interroger ces données comme les siennes : si la propriété n’existe que dans SpiceDB, une interface utilisateur qui s’appuie dessus « wouldn’t be able to filter, sort, or paginate that table as easily » (ne pourrait pas filtrer, trier ou paginer cette table aussi facilement), car SpiceDB « isn’t a general-purpose database » (n’est pas une base de données généraliste). Le problème de liste décrit dans Lister ce qu’un utilisateur peut voir s’applique alors à chaque écran qui affiche la relation. Oso défend la direction opposée pour son propre produit, en vous permettant d’« apply your application data to authorization decisions without synchronizing it » (appliquer les données de votre application aux décisions d’autorisation sans les synchroniser) (Oso, Launching Local Authorization, article d’éditeur), ce qui évite la synchronisation en laissant les données dans la base de données de l’application plutôt qu’en les déplaçant.

Boîte d’envoi transactionnelle et relais

Garder la base de données de l’application comme source de vérité, et rendre la seconde écriture durable plutôt qu’immédiate. Dans la même transaction que la modification métier, insérer dans une table outbox (boîte d’envoi) une ligne qui décrit la modification de tuple. Un relais distinct lit la boîte d’envoi et applique les modifications au service d’autorisation, en réessayant jusqu’à ce qu’elles réussissent. La forme générale du schéma : « first store the message in the database as part of the transaction that updates the business entities » (stocker d’abord le message dans la base de données, dans le cadre de la transaction qui met à jour les entités métier) (Chris Richardson, Transactional outbox).

Que fait le relais lorsque le service d’autorisation est brièvement indisponible ?

Boîte d’envoi transactionnelle et relaisAnne retire Beto du groupe eng. Dans une seule transaction de base de données, l’application supprime la ligne membre et insère une ligne dans la boîte d’envoi. Le relais lit cette ligne et envoie la suppression du tuple ; la première tentative échoue, il réessaie donc. La seconde tentative réussit, et le relais marque la ligne de la boîte d’envoi comme traitée. Jusque-là, le service d’autorisation laisse encore entrer Beto.tempsappbase de l’apprelaisservice d’autoris.atomiquenouvel essaiackAnne retireBeto de engune txn : lignemembre + outboxlire la ligneoutbox suivanteBeto toujoursautorisééchec suppr. :nouvel essaituple suppriméligne outboxmarquée traitée
Rien n’est perdu, mais la modification atteint le service d’autorisation plus tard que la base de données.

Remarquez la boîte rouge à droite : la boîte d’envoi garantit que la modification arrive, pas qu’elle arrive immédiatement. Entre la validation et la réussite du relais, l’ancien accès reste valable. Le relais doit aussi tolérer les répétitions car, selon les termes mêmes du schéma, « The Message relay might publish a message more than once » (Le relais de messages peut publier un message plus d’une fois) (Transactional outbox) ; AuthZed renvoie à « SpiceDB allowing for idempotent writes with its TOUCH operation » (SpiceDB, qui permet des écritures idempotentes avec son opération TOUCH), et à l’ordre : « As long as this process is effectively single-threaded and retries operations until they succeed » (Tant que ce processus est effectivement monothread et réessaie les opérations jusqu’à ce qu’elles réussissent) (The Dual-Write Problem). Appliquer une suppression avant la création qui la précède laisserait un état erroné.

Capture des modifications de données

Au lieu d’interroger périodiquement la boîte d’envoi, lire le journal de validation propre à la base de données. Debezium, par exemple, utilise le décodage logique de PostgreSQL : après un instantané initial, il « continuously captures row-level changes that insert, update, and delete database content and that were committed to a PostgreSQL database » (capture en continu les modifications au niveau des lignes qui insèrent, mettent à jour et suppriment du contenu de la base de données et qui ont été validées dans une base PostgreSQL) et les diffuse vers des topics Kafka. AuthZed le décrit comme l’un des outils les plus couramment utilisés pour le schéma de la boîte d’envoi : « It watches changes in an outbox table and submits them as events to Kafka » (Il surveille les modifications d’une table outbox et les soumet sous forme d’événements à Kafka) (The Dual-Write Problem).

Quel chemin parcourt une modification, de la validation jusqu’au tuple ?

Capture des modifications de données vers le service d’autorisationL’application valide en une seule transaction les lignes métier et une ligne de boîte d’envoi dans sa base de données. Debezium lit les modifications validées dans le journal d’écriture anticipée (WAL) et les publie dans un topic Kafka. Un consommateur lit le topic, transforme chaque événement en écriture ou suppression de tuple et l’applique au service d’autorisation. Des doublons sont possibles après un redémarrage du connecteur ; les écritures du consommateur doivent donc être idempotentes.appbase de l’applignes + outboxDebezium(lit le WAL)topic Kafkaconsommateur :événement → tupleservice d’autoris.une txnmodificationsvalidéespublierconsommerTOUCH /DELETE
Chaque étape ajoute du retard ; seules les modifications validées entrent dans le pipeline, si bien qu’une transaction annulée ne devient jamais un tuple.

Remarquez la première étape : comme Debezium lit les modifications validées, la défaillance de droite décrite plus haut ne peut pas se produire. Les doublons, en revanche, restent possibles. La documentation de Debezium pour PostgreSQL indique que « while it is recovering from the fault, it’s possible that the connector might emit some duplicate change events » (pendant qu’il se remet de la panne, il est possible que le connecteur émette des événements de modification en double), et que « consumers should always anticipate some duplicate events » (les consommateurs doivent toujours s’attendre à quelques événements en double) (Debezium PostgreSQL connector). Son routeur d’événements outbox est la forme packagée de la combinaison boîte d’envoi et 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 » (Une implémentation du schéma outbox évite les incohérences entre l’état interne d’un service (tel qu’il est généralement persisté dans sa base de données) et l’état des événements consommés par les services qui ont besoin des mêmes données) (Debezium, Outbox Event Router).

Watch alimente des index, mais n’est pas une file d’attente

Les schémas ci-dessus font entrer les modifications dans le service d’autorisation. Watch (§2.4.3) les fait sortir : « Some clients maintain secondary indices of relation tuples in Zanzibar. They can do so with our Watch API. » (Certains clients maintiennent des index secondaires des tuples de relation de Zanzibar. Ils peuvent le faire grâce à notre API Watch.) Une réponse transporte les modifications « in ascending timestamp order » (par ordre croissant d’horodatage) jusqu’à un zookie de pulsation, que « the client can use … to resume watching where the previous watch response left off » (le client peut utiliser … pour reprendre la surveillance là où la réponse Watch précédente s’était arrêtée) (§2.4.3). L’indexeur incrémental de Leopard est le consommateur propre à l’article (§3.2.4).

Le client détient la position de reprise, et le serveur ne conserve l’historique que pendant un certain temps. La documentation 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 » (Les modifications historiques ne peuvent être demandées que dans la limite de la fenêtre de ramasse-miettes configurée sur le stockage sous-jacent. Elle est généralement de 24 heures, mais peut varier selon le stockage utilisé) (SpiceDB, Watching Relationship Changes). Un ticket de SpiceDB en énonce la conséquence : « 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 » (l’API Watch n’est pas durable ; si vous voulez écrire dans une file d’attente durable, vous devez prendre les messages provenant de l’API Watch et les placer quelque part) (spicedb#2015, fermé comme non planifié le 2026-10-29). Le ticket ouvert spicedb#2285 ajoute que le comportement par défaut « starts watching from the HEAD revision which leaves gaps of updates that may have not been seen » (commence la surveillance à partir de la révision HEAD, ce qui laisse des trous de mises à jour qui n’ont peut-être pas été vues).

Qu’advient-il d’un index dont le consommateur est arrêté plus longtemps que cette fenêtre ?

Reprendre Watch, et perdre la positionL’indexeur applique un lot de modifications et enregistre le jeton de flux t50 avec les lignes de l’index. Il se déconnecte, se reconnecte avec t50 et reçoit les modifications suivantes. Plus tard, il est arrêté plus longtemps que la fenêtre de ramasse-miettes du stockage ; t50 a expiré, il ne peut donc pas reprendre et doit reconstruire l’index à partir d’une lecture complète.tempsservice d’autoris.indexeurindexenregistrerreprisereprise impossiblemodifs jusqu’aujeton t50appliquer le lotlignes + t50,une txndéconnectéWatch depuis t50modifs aprèst50arrêté plus longtempsque la fenêtre GCt50 expiréreconstruire parlecture complète
Enregistrez le jeton dans la même transaction que les lignes qu’il couvre, et prévoyez un chemin de reconstruction pour le cas où l’historique a disparu.

Remarquez le premier événement de la colonne de l’index : le jeton est stocké avec les lignes qu’il a produites. Si l’indexeur enregistrait d’abord le jeton puis plantait, il sauterait des modifications ; s’il appliquait les lignes puis plantait avant l’enregistrement, il les réappliquerait, ce qui n’est sans conséquence que si les écritures dans l’index sont idempotentes. Pour survivre à une longue panne, copiez le flux dans une file d’attente durable que vous contrôlez, comme le dit le ticket, ou soyez prêt à reconstruire. Le champ de reprise de SpiceDB est ChangesThrough : la documentation recommande d’appeler Watch « in a loop, sending in the last received ZedToken from ChangesThrough if the call disconnects » (en boucle, en renvoyant le dernier ZedToken reçu dans ChangesThrough si l’appel se déconnecte) (Watching Relationship Changes).

Les zookies et chaque option

Le protocole zookie exige deux choses du client : demander un zookie lorsque le contenu est enregistré, et le stocker avec le contenu (§2.2, §2.4.4). La documentation de SpiceDB donne le même conseil pour les ZedTokens : les stocker « alongside the newly updated content in the application database » (à côté du contenu nouvellement mis à jour dans la base de données de l’application), et les mettre à jour lorsque la ressource est créée ou supprimée, lorsque son contenu change et lorsqu’un accès à celle-ci est ajouté ou retiré (SpiceDB, Consistency). La vérification de modification de contenu ne pose pas de problème de double écriture qui lui soit propre : c’est une lecture, et le jeton entre dans la base de données de l’application dans la même transaction que le contenu.

Les options diffèrent par ce que ce jeton peut garantir.

Option Quand la modification d’ACL se trouve dans le service d’autorisation Ce que couvre un jeton stocké
Service d’autorisation comme source de vérité Au retour de l’écriture, avant que l’utilisateur en soit informé Tout, comme dans l’article : le jeton de l’écriture, ou une vérification de modification de contenu ultérieure, est au moins aussi frais que la modification d’ACL
Boîte d’envoi et relais Lorsque le relais réussit, après la validation en base de données Uniquement les modifications que le relais a déjà appliquées. Une vérification de modification de contenu effectuée avant cela voit l’ancienne ACL
Capture des modifications de données Après que le journal a été lu, publié et consommé Comme la boîte d’envoi, avec davantage d’étapes de retard
Index alimenté par Watch Déjà présente ; le retard est dans l’index Rien directement : les zookies sont opaques, l’index ne peut donc pas savoir s’il est aussi frais qu’un jeton donné. Revérifier avec le jeton, ou comparer la position enregistrée par l’index

Pour les lignes « boîte d’envoi » et « CDC », la garantie de l’article est plus faible qu’il n’y paraît. L’exemple B du §2.2 suppose que la modification d’ACL (B1) se trouve dans Zanzibar avant que la modification de contenu (B2) soit vérifiée. Avec un relais intermédiaire, Anne peut retirer Beto, enregistrer un nouveau contenu une seconde plus tard et obtenir un zookie d’une vérification de modification de contenu exécutée avant que le relais ait appliqué le retrait. Le zookie est correct pour les données dont disposait Zanzibar ; ce sont ces données qui étaient en retard. Deux atténuations, qui ne proviennent d’aucune des sources ci-dessus et n’ont pas été testées ici : envoyer les révocations directement au service d’autorisation et les enregistrer ensuite dans la base de données (en acceptant le mode de défaillance de droite comme un état visible « toujours listé mais refusé »), ou faire en sorte que le relais réécrive le jeton qu’il reçoit dans les lignes concernées, afin que les vérifications ultérieures le transportent.

La règle d’opacité de l’article est délibérée : les zookies sont opaques « to discourage our clients from choosing arbitrary timestamps and to allow future extensions » (afin de dissuader nos clients de choisir des horodatages arbitraires et de permettre des extensions futures) (§2.4). Le coût apparaît dans la dernière ligne : un client ne peut pas comparer deux zookies pour déterminer lequel est le plus récent.

Réécrire sans risque les tuples d’un objet : le tuple de verrou

Une tâche de synchronisation veut souvent remplacer tous les tuples d’un objet pour les faire correspondre à la base de données, par exemple pour que les lecteurs du readme soient exactement ceux qu’indique la table de partage. Deux tâches de ce type, ou une tâche et la modification d’un utilisateur, peuvent entrer en concurrence. La réponse de l’article est un contrôle de concurrence optimiste avec un tuple de verrou (lock tuple) (§2.4.2) :

« The lock tuple is just a regular relation tuple used by clients to detect write races » (Le tuple de verrou est simplement un tuple de relation ordinaire utilisé par les clients pour détecter les écritures concurrentes) (§2.4.2). Que se passe-t-il lorsque deux tâches de synchronisation réécrivent en même temps les tuples du readme ?

Concurrence optimiste avec un tuple de verrouLes deux tâches de synchronisation lisent tous les tuples de doc:readme, y compris le tuple de verrou, à la même version. La tâche 1 envoie ses écritures avec un touch sur le tuple de verrou, à condition que le verrou n’ait pas changé ; Zanzibar valide et le verrou change. La tâche 2 envoie ses écritures avec la même condition ; le verrou a changé, Zanzibar les rejette donc, et la tâche 2 revient à l’étape 1 et relit.tempstâche de synchro 1tâche de synchro 2Zanzibarnouvel essailire tuples dureadme + verrouverrou enversion 7lire tuples dureadme + verrouécriture + touch,si verrou inchangévalidation ;verrou modifiéécriture + touch,si verrou inchangéverrou modifié :rejetéretour à l’étape 1 :relire
Aucune tâche ne détient de verrou pendant son calcul ; l’écriture conditionnelle détecte la concurrence au moment de la validation.

Remarquez que la tâche 2 n’est pas bloquée pendant que la tâche 1 travaille ; elle n’apprend l’existence du conflit qu’au moment de valider, puis recalcule à partir de données fraîches. Cela convient aux tâches de synchronisation, qui peuvent toujours recalculer à partir de la base de données.

Sources