L’article décrit son modèle de données et son langage de configuration, mais ne donne qu’une seule politique détaillée, la figure 1. Sa conclusion va plus loin : le « simple yet flexible data model and configuration language support a variety of access control policies from both consumer and enterprise applications » (modèle de données et langage de configuration simples mais flexibles prennent en charge une variété de politiques de contrôle d’accès issues d’applications grand public comme d’entreprise) (§6). Sa section sur les travaux connexes nomme les motifs qu’il couvre : « Zanzibar’s data model supports permissions, users, groups, and inheritance » (le modèle de données de Zanzibar prend en charge les permissions, les utilisateurs, les groupes et l’héritage) tels qu’on les trouve dans Multics, UNIX, les ACL POSIX et VMS, et « a number of Zanzibar clients have implemented RBAC policies on top of Zanzibar’s namespace configuration language » (un certain nombre de clients de Zanzibar ont mis en œuvre des politiques RBAC au-dessus du langage de configuration d’espaces de noms de Zanzibar) (§5).
Cette page expose huit exigences qui se présentent en pratique. Chaque section donne la question à laquelle le motif répond, les tuples, la règle dans la notation de l’article issue de la figure 1 lorsque l’article permet de l’exprimer, la même règle dans le langage de schéma de SpiceDB et dans le DSL d’OpenFGA, et un graphe des tuples où le chemin qui décide de la réponse est mis en évidence. La liste des motifs suit les guides de modélisation d’OpenFGA ; la page sur les tuples explique la notation.
L’exemple suivi : Anne, Beto et Chen (user:anne, user:beto, user:chen) ; le document doc:readme dans folder:A ; le groupe group:eng. Anne est propriétaire du readme, Beto fait partie d’eng, les membres d’eng voient le readme, et Chen voit le dossier A.
Rôles et permissions
La question : Anne peut-elle modifier le readme, et Beto le peut-il ? Un rôle est quelque chose que l’on accorde (owner, editor, viewer). Une permission est quelque chose que l’on vérifie (edit, view). Accorder des rôles et vérifier des permissions permet de garder les vérifications stables lorsque les rôles changent.
Tuples :
doc:readme#owner@user:anne
doc:readme#viewer@group:eng#member
group:eng#member@user:beto
Dans la notation de l’article, les rôles sont des relations dotées de tuples stockés, et les permissions sont des relations dont la règle ne comporte pas _this, de sorte que personne ne peut leur écrire directement un tuple. Seuls union et computed_userset sont nécessaires, tous deux issus de la figure 1 :
name: "doc"
relation { name: "owner" }
relation { name: "editor" }
relation { name: "viewer" }
relation {
name: "edit"
userset_rewrite {
union {
child { computed_userset { relation: "owner" } }
child { computed_userset { relation: "editor" } }
} } }
relation {
name: "view"
userset_rewrite {
union {
child { computed_userset { relation: "viewer" } }
child { computed_userset { relation: "edit" } }
} } }
La figure 1 remplit la même fonction autrement : elle place _this et le rôle plus large dans la même relation (« All owners are editors, and all editors are viewers », tous les propriétaires sont des éditeurs, et tous les éditeurs sont des lecteurs). Les deux formes sont des règles de réécriture ; celle ci-dessus sépare les noms d’attribution des noms de vérification.
SpiceDB sépare les deux catégories dans la syntaxe : les lignes relation désignent ce qui peut être stocké, les lignes permission sont calculées. Sa documentation indique que « relations should be named as nouns » (les relations doivent être nommées par des noms) et que « permissions should be named as verbs or nouns » (les permissions doivent être nommées par des verbes ou des noms) (documentation sur les schémas).
definition user {}
definition group {
relation member: user
}
definition doc {
relation owner: user
relation editor: user | group#member
relation viewer: user | group#member
permission edit = owner + editor
permission view = viewer + edit
}
Schéma SpiceDB ; suit la syntaxe documentée au 2026-11-13 ; aucun validateur n’a été exécuté.
OpenFGA ne possède qu’une seule catégorie de relation. Une relation sans restriction de type entre crochets ne peut pas être écrite directement ; le guide des rôles et permissions d’OpenFGA utilise de telles relations (booking_viewer, booking_adder) comme permissions, et ses autres guides les préfixent par can_.
model
schema 1.1
type user
type group
relations
define member: [user]
type doc
relations
define owner: [user]
define editor: [user, group#member]
define viewer: [user, group#member]
define can_edit: owner or editor
define can_view: viewer or can_edit
DSL OpenFGA ; suit la syntaxe documentée au 2026-11-13 ; aucun validateur n’a été exécuté.
D’où vient le edit d’Anne ?
Remarquez que edit et view ne contiennent aucun tuple. Ajouter un nouveau rôle, par exemple commenter, revient à ajouter une relation et un enfant de plus dans les règles de permission ; aucun tuple existant ne change.
Combien de relations
Une critique fréquente de ce style porte sur les noms. Dans l’article de blog d’Oso « Google Zanzibar Isn’t Flexible » (Oso commercialise un produit d’autorisation concurrent), Greg Sarjeant écrit que « the literature about ReBAC is rife with “relations” like can_delete and can_archive » (la littérature sur ReBAC regorge de « relations » comme can_delete et can_archive), qualifie cela de « essentially the same thing as creating a relation for every authorized action » (essentiellement la même chose que créer une relation pour chaque action autorisée), et conclut que c’est « an indication that relations are the wrong abstraction for authorization » (le signe que les relations sont la mauvaise abstraction pour l’autorisation) (Oso, 2024-11-01, mis à jour le 2025-11-07).
Le nombre augmente effectivement : chaque action que l’application vérifie nécessite un nom dans le schéma. Ce que les règles de réécriture maintiennent réduit, c’est le nombre de tuples stockés et le nombre de relations dans lesquelles on écrit. Dans les schémas ci-dessus, trois relations contiennent des tuples (owner, editor, viewer) et les permissions en sont des fonctions pures : ajouter can_archive modifie donc le schéma une fois et aucun tuple. La motivation que l’article lui-même donne aux réécritures est la même : stocker une relation dérivée sous forme de tuple pour chaque objet « would be wasteful and make it hard to make modifications across all objects » (serait source de gaspillage et rendrait difficiles les modifications portant sur l’ensemble des objets) (§2.3.1). La question de savoir si les noms de permissions dans le schéma constituent un coût ou une documentation est le point sur lequel Oso et les produits de type Zanzibar divergent ; cette page ne la tranche pas.
Héritage parent-enfant
La question : Chen, qui voit le dossier A, peut-il voir le readme qu’il contient ? L’héritage depuis un conteneur correspond à la feuille tuple_to_userset : lire les tuples parent de l’objet, puis interroger une relation sur chaque parent.
Tuples :
doc:readme#parent@folder:A#...
folder:A#viewer@user:chen
La figure 1 de l’article contient déjà cette règle comme troisième enfant de viewer. Ajoutée à la permission view de la section précédente :
relation { name: "parent" }
relation {
name: "view"
userset_rewrite {
union {
child { computed_userset { relation: "viewer" } }
child { computed_userset { relation: "edit" } }
child { tuple_to_userset {
tupleset { relation: "parent" }
computed_userset {
object: $TUPLE_USERSET_OBJECT # parent folder
relation: "viewer"
} } }
} } }
Dans SpiceDB, la flèche parent->view suit la relation parent et interroge view sur ce qu’elle trouve (documentation sur les schémas) :
definition folder {
relation parent: folder
relation viewer: user | group#member
permission view = viewer + parent->view
}
definition doc {
relation parent: folder
relation owner: user
relation editor: user | group#member
relation viewer: user | group#member
permission edit = owner + editor
permission view = viewer + edit + parent->view
}
Schéma SpiceDB ; suit la syntaxe documentée au 2026-11-13 ; aucun validateur n’a été exécuté.
Dans OpenFGA, la même chose s’écrit X from Y ; le guide parent-enfant l’utilise pour faire des éditeurs d’un dossier les éditeurs de ses documents.
type folder
relations
define parent: [folder]
define viewer: [user, group#member] or viewer from parent
type doc
relations
define parent: [folder]
define owner: [user]
define editor: [user, group#member]
define viewer: [user, group#member] or viewer from parent
define can_edit: owner or editor
define can_view: viewer or can_edit
DSL OpenFGA ; suit la syntaxe documentée au 2026-11-13 ; aucun validateur n’a été exécuté.
Les deux versions des produits dotent également folder d’un parent qui pointe vers folder, de sorte qu’un dossier hérite du dossier qui le contient et que la profondeur de la chaîne ne dépend que des tuples. La figure 1 de l’article ne montre que le côté document.
Quels tuples décident de l’accès de Chen ?
Remarquez que déplacer le readme dans un autre dossier représente une seule modification de tuple (supprimer un tuple parent, en écrire un autre), et que toutes les autorisations héritées suivent. C’est précisément le mouvement dont traite l’exemple A du « nouvel ennemi » dans l’article : « document ACLs inherit from folder ACLs » (les ACL des documents héritent des ACL des dossiers) (§2.2), si bien que l’ordre des modifications d’ACL et des déplacements compte ; voir cohérence.
Groupes et groupes imbriqués
La question : Beto fait partie d’une sous-équipe ; une autorisation accordée à eng l’atteint-elle ? Cette variante de l’exemple suivi ajoute une sous-équipe hypothétique group:sre, Beto faisant partie de sre et sre faisant partie d’eng.
Tuples :
group:sre#member@user:beto
group:eng#member@group:sre#member
doc:readme#viewer@group:eng#member
Dans l’article, un groupe n’a besoin d’aucune règle de réécriture. member est une relation simple, et comme l’utilisateur d’un tuple peut être un userset, « a ⟨userset⟩ allows ACLs to refer to groups and thus supports representing nested group membership » (un ⟨userset⟩ permet aux ACL de faire référence à des groupes et permet ainsi de représenter l’appartenance à des groupes imbriqués) (§2.1) :
name: "group"
relation { name: "member" }
Les configurations de l’article ne disent rien des types d’utilisateurs qu’une relation accepte. Les deux produits l’exigent dans le schéma : l’imbrication ne fonctionne que là où group#member figure parmi les sujets autorisés.
definition group {
relation member: user | group#member
}
Schéma SpiceDB ; suit la syntaxe documentée au 2026-11-13 ; aucun validateur n’a été exécuté.
type group
relations
define member: [user, group#member]
DSL OpenFGA ; suit la syntaxe documentée au 2026-11-13 ; aucun validateur n’a été exécuté.
Comment l’autorisation atteint-elle Beto ?
Remarquez que les tuples du document n’ont pas changé lorsque sre a rejoint eng : un groupe est un userset écrit avec les mêmes tuples qu’une ACL (§2.1), de sorte qu’un changement d’appartenance reste à l’intérieur du groupe. C’est cette même indirection qui explique pourquoi les groupes profonds ou larges sont lents à vérifier par poursuite de pointeurs ; la réponse de l’article est l’index Leopard (§3.2.4).
Listes de blocage (exclusion)
La question : les membres d’eng peuvent voir le readme, à l’exception d’une personne. Dans cette variante, Beto est bloqué sur le readme. L’exclusion retire un ensemble d’un autre.
Tuples :
doc:readme#viewer@group:eng#member
group:eng#member@user:beto
doc:readme#blocked@user:beto
L’article cite l’exclusion comme opérateur (§2.3.1) et comme nœud de l’arbre de userset d’Expand (§2.4.5), mais la figure 1 ne montre pas comment elle s’écrit. Le bloc ci-dessous reprend la forme de la figure 1 avec exclusion à la place de union ; le mot-clé, ainsi que la règle selon laquelle le premier enfant est la base et le second est soustrait, sont une hypothèse de cette page et non la syntaxe de l’article.
relation { name: "blocked" }
relation {
name: "can_view"
userset_rewrite {
exclusion {
child { computed_userset { relation: "view" } }
child { computed_userset { relation: "blocked" } }
} } }
SpiceDB écrit l’exclusion sous la forme - (documentation sur les schémas). Définir la permission avec blocage au-dessus de view permet d’éviter les parenthèses dans l’expression :
definition doc {
relation parent: folder
relation owner: user
relation editor: user | group#member
relation viewer: user | group#member
relation blocked: user
permission edit = owner + editor
permission view = viewer + edit + parent->view
permission can_view = view - blocked
}
Schéma SpiceDB ; suit la syntaxe documentée au 2026-11-13 ; aucun validateur n’a été exécuté.
OpenFGA l’écrit sous la forme but not (difference dans sa forme JSON) ; son guide des listes de blocage empêche un membre d’une équipe de modifier un document que l’équipe peut modifier.
type doc
relations
define parent: [folder]
define blocked: [user]
define owner: [user]
define editor: [user, group#member]
define viewer: [user, group#member] or viewer from parent
define can_edit: owner or editor
define can_view: (viewer or can_edit) but not blocked
DSL OpenFGA ; suit la syntaxe documentée au 2026-11-13 (la page du langage de configuration autorise les parenthèses pour regrouper les opérateurs) ; aucun validateur n’a été exécuté.
Quel tuple décide ?
Remarquez qu’un chemin vers le document ne suffit plus : l’exclusion doit examiner les deux côtés. Zanzibar n’annule le reste d’un sous-arbre que « when the outcome of one node determines the result of a subtree » (lorsque le résultat d’un nœud détermine le résultat d’un sous-arbre) (§3.2.3). Un seul oui décide d’une union ; pour une exclusion, un oui du côté de la base ne décide de rien tant que le côté soustrait n’est pas connu. Remarquez aussi ce qui est bloqué : comme can_view soustrait de l’ensemble de view, un propriétaire bloqué perd lui aussi can_view.
Accès public (jokers)
La question : n’importe qui peut-il voir un document public ? L’article n’apporte pas de réponse dans sa notation. Un ⟨user⟩ est « ⟨user_id⟩ | ⟨userset⟩ » et un identifiant d’utilisateur « is an integer » (est un entier) (§2.1) ; il n’existe aucune valeur qui signifie « tous les utilisateurs », et l’article n’aborde pas les objets publics. Dans le modèle de l’article, la construction la plus proche est un groupe qui contient tous les utilisateurs, ce qui nécessite un tuple par utilisateur ; la manière dont Google gère le partage public n’est pas décrite.
Les deux produits ajoutent un sujet joker (wildcard), user:*, qui n’est autorisé que là où le schéma le mentionne. Le tuple :
doc:readme#viewer@user:*
definition doc {
relation viewer: user | user:* | group#member
permission view = viewer
}
Schéma SpiceDB ; suit la syntaxe documentée au 2026-11-13 ; aucun validateur n’a été exécuté.
type doc
relations
define viewer: [user, user:*, group#member]
DSL OpenFGA ; suit la syntaxe documentée au 2026-11-13 ; aucun validateur n’a été exécuté.
Les deux projets mettent en garde à ce sujet. AuthZed : « Be very careful with wildcard support in your schema! » (soyez très prudent avec la prise en charge des jokers dans votre schéma !) et « Only grant it to read permissions, unless you intend to allow for universal writing » (ne l’accordez qu’à des permissions de lecture, à moins que vous n’ayez l’intention d’autoriser l’écriture universelle) (documentation sur les schémas). OpenFGA : « type-bound public access is not a wildcard or a regex expression » (l’accès public lié à un type n’est ni un joker ni une expression régulière) ; user:* ne peut apparaître qu’en tant qu’utilisateur, et non en tant qu’objet (document:*) ni à l’intérieur d’un userset (org:*#member) (guide de l’accès public).
Restrictions multiples (intersection)
La question : seuls les propriétaires qui sont aussi membres de l’équipe du document peuvent le publier. Anne peut-elle publier le readme ? L’intersection exige qu’un utilisateur figure dans chaque enfant.
Cette variante ajoute une relation team du readme vers group:eng. Tuples :
doc:readme#owner@user:anne
doc:readme#team@group:eng#...
group:eng#member@user:beto
Comme pour l’exclusion, l’article nomme l’intersection (§2.3.1) mais ne montre pas comment elle s’écrit. Ce bloc reprend la forme de la figure 1 ; le mot-clé intersection est une hypothèse :
relation { name: "team" }
relation {
name: "publish"
userset_rewrite {
intersection {
child { computed_userset { relation: "owner" } }
child { tuple_to_userset {
tupleset { relation: "team" }
computed_userset {
object: $TUPLE_USERSET_OBJECT # the doc's team
relation: "member"
} } }
} } }
SpiceDB écrit l’intersection sous la forme & :
definition doc {
relation owner: user
relation team: group
permission publish = owner & team->member
}
Schéma SpiceDB ; suit la syntaxe documentée au 2026-11-13 ; aucun validateur n’a été exécuté.
OpenFGA l’écrit sous la forme and ; son guide des restrictions multiples construit la même forme, can_delete désignant les rédacteurs qui sont aussi membres de l’organisation propriétaire.
type doc
relations
define owner: [user]
define team: [group]
define can_publish: owner and member from team
DSL OpenFGA ; suit la syntaxe documentée au 2026-11-13 ; aucun validateur n’a été exécuté.
Pourquoi l’accès est-il refusé à Anne ?
Remarquez que le fait décisif est un tuple manquant. Ajouter group:eng#member@user:anne rendrait la réponse positive sans toucher au document.
Rôles personnalisés
La question : un administrateur définit un nouveau rôle, « reviewer », à l’exécution, et lui donne l’accès en lecture au readme. Chen, qui détient ce rôle, peut-il le voir ? Les rôles fixés dans le schéma (owner, editor) ne changent que lorsque le schéma change ; les rôles personnalisés sont des données.
Le guide des rôles personnalisés d’OpenFGA les modélise comme un type distinct « because our roles are going to be dynamic and might change frequently » (parce que nos rôles vont être dynamiques et pourraient changer fréquemment) : les utilisateurs sont liés à un objet role en tant qu’assignee, et les titulaires du rôle reçoivent des relations sous forme de userset (role:media-manager#assignee en tant qu’editor de asset-category:logos). L’article d’AuthZed sur les rôles définis par l’utilisateur (2021-10-27) procède de même avec role#member.
Tuples (une variante : Chen détient un rôle au lieu d’une autorisation sur le dossier) :
role:reviewer#assignee@user:chen
doc:readme#viewer@role:reviewer#assignee
doc:readme#editor@role:maintainer#assignee
Dans l’article, il s’agit du motif des groupes sous un autre nom d’espace de noms : role est un espace de noms doté d’une relation simple, et le viewer du readme stocke un userset qui pointe vers lui. Aucune règle ne change :
name: "role"
relation { name: "assignee" }
definition role {
relation assignee: user
}
definition doc {
relation owner: user
relation editor: user | group#member | role#assignee
relation viewer: user | group#member | role#assignee
permission edit = owner + editor
permission view = viewer + edit
}
Schéma SpiceDB ; suit la syntaxe documentée au 2026-11-13 ; aucun validateur n’a été exécuté.
type role
relations
define assignee: [user]
type doc
relations
define owner: [user]
define editor: [user, group#member, role#assignee]
define viewer: [user, group#member, role#assignee]
define can_edit: owner or editor
define can_view: viewer or can_edit
DSL OpenFGA ; suit la syntaxe documentée au 2026-11-13 ; aucun validateur n’a été exécuté.
Comment un rôle créé à l’exécution accorde-t-il l’accès ?
Remarquez que les autorisations du rôle sont définies par objet. Un rôle censé signifier « peut créer et supprimer des tickets n’importe où dans ce dépôt » nécessite que son ensemble de permissions soit lui aussi stocké sous forme de données. La page d’AuthZed sur la gestion du contrôle d’accès présente ce motif plus fin : une définition role comportant une relation joker par permission (relation create_issue: user:*), un objet role_grant qui relie un rôle à des bénéficiaires, et des permissions de la forme permission create_issue = role->create_issue & grantee. Le prix à payer est une relation de schéma par permission, ce qui ramène à la question de nommage évoquée plus haut.
Transfert de propriété
La question : Anne cède le readme à Beto. Ensuite, Beto doit être propriétaire et Anne ne doit plus l’être, sans aucun moment où les deux, ou aucun des deux, le seraient. Il ne s’agit pas d’un motif de schéma : aucune des trois notations ne peut déclarer « exactement un propriétaire », et la documentation de schéma citée ici ne présente aucune contrainte de cardinalité. C’est un motif d’écriture.
La modification des tuples :
delete doc:readme#owner@user:anne
write doc:readme#owner@user:beto
L’API Write de l’article le couvre. Les clients « may also modify all tuples related to an object via a read-modify-write process with optimistic concurrency control » (peuvent également modifier tous les tuples liés à un objet au moyen d’un processus de lecture-modification-écriture avec contrôle de concurrence optimiste) : lire les tuples de l’objet, y compris un tuple de « verrou » par objet, envoyer les écritures « along with a touch on the lock tuple … with the condition that the writes will be committed only if the lock tuple has not been modified since the read » (accompagnées d’une modification du tuple de verrou … à la condition que les écritures ne soient validées que si le tuple de verrou n’a pas été modifié depuis la lecture), et réessayer dans le cas contraire (§2.4.2). Le tuple de verrou empêche deux transferts simultanés de réussir tous les deux.
- SpiceDB.
WriteRelationships« atomically writes and/or deletes a set of specified relationships » (écrit et/ou supprime de manière atomique un ensemble de relations spécifiées), et « if any preconditions fail, the entire transaction will be reverted » (si une précondition échoue, l’ensemble de la transaction est annulé) (permission_service.proto). Une préconditionMUST_MATCHsurdoc:readme#owner@user:annejoue le rôle du tuple de verrou de l’article : le transfert échoue si Anne n’est plus propriétaire. - OpenFGA. « You can combine both writes and deletes in a single transactional API request » (vous pouvez combiner des écritures et des suppressions dans une seule requête d’API transactionnelle), et « all operations in the request will either succeed together or fail together » (toutes les opérations de la requête réussiront ensemble ou échoueront ensemble), dans la limite de 100 tuples par requête (mise à jour des tuples). La même page indique qu’écrire un tuple qui existe déjà « would normally cause the whole request to fail » (ferait normalement échouer la requête entière), et propose
on_missing: "ignore"pour « deleting tuples that might not exist » (supprimer des tuples qui pourraient ne pas exister) (OpenFGA v1.10.0 et versions ultérieures). Cela implique que la suppression d’un tuple absent fait échouer la requête par défaut, ce qui ferait jouer à la suppression le rôle du tuple de verrou ; la page n’énonce pas explicitement ce comportement par défaut, et il n’a pas été testé ici.
Qu’est-ce qui change ?
Remarquez que tout ce qui découle de la propriété (edit, view) se déplace avec ce seul tuple. Anne conserve tout accès dont elle dispose par d’autres chemins, comme un tuple viewer direct ou un groupe ; un transfert censé retirer à Anne tout accès doit également supprimer ces tuples.
Sources
- Ruoming Pang et al., « Zanzibar: Google’s Consistent, Global Authorization System », USENIX ATC ’19, usenix.org/conference/atc19/presentation/pang
- Guides de modélisation d’OpenFGA : rôles et permissions, parent-enfant, listes de blocage, accès public, restrictions multiples, rôles personnalisés
- OpenFGA, langage de configuration
- OpenFGA, mise à jour des tuples
- AuthZed, documentation sur les schémas SpiceDB
- AuthZed, gestion du contrôle d’accès
- AuthZed, User Defined Roles, 2021-10-27
- AuthZed,
permission_service.proto - Greg Sarjeant, Google Zanzibar Isn’t Flexible, Oso, 2024-11-01 (mis à jour le 2025-11-07)