Das Paper beschreibt sein Datenmodell und seine Konfigurationssprache, gibt aber nur eine ausgearbeitete Richtlinie an, Abbildung 1. Seine Schlussfolgerung beansprucht mehr: Das “simple yet flexible data model and configuration language support a variety of access control policies from both consumer and enterprise applications” (§6) (einfache, aber flexible Datenmodell und die Konfigurationssprache unterstützen eine Vielzahl von Zugriffskontrollrichtlinien sowohl aus Verbraucher- als auch aus Unternehmensanwendungen). Der Abschnitt zu verwandten Arbeiten nennt die abgedeckten Muster: “Zanzibar’s data model supports permissions, users, groups, and inheritance” (Das Datenmodell von Zanzibar unterstützt Berechtigungen, Benutzer, Gruppen und Vererbung), wie man sie in Multics, UNIX, POSIX-ACLs und VMS findet, und “a number of Zanzibar clients have implemented RBAC policies on top of Zanzibar’s namespace configuration language” (§5) (eine Reihe von Zanzibar-Clients hat RBAC-Richtlinien auf Grundlage der Namespace-Konfigurationssprache von Zanzibar implementiert).
Diese Seite schreibt acht Anforderungen aus, die in der Praxis vorkommen. Jeder Abschnitt nennt die Frage, die das Muster beantwortet, die Tupel, die Regel in der Notation des Papers aus Abbildung 1, wo das Paper sie ausdrücken kann, dieselbe Regel in der Schemasprache von SpiceDB und in der DSL von OpenFGA sowie einen Graphen der Tupel, in dem der Pfad hervorgehoben ist, der die Antwort entscheidet. Die Liste der Muster folgt den Modellierungsleitfäden von OpenFGA; die Tupelseite erklärt die Notation.
Das durchgehende Beispiel: Anne, Beto und Chen (user:anne, user:beto, user:chen); das Dokument doc:readme in folder:A; die Gruppe group:eng. Anne ist Eigentümerin des Readmes, Beto ist in eng, die Mitglieder von eng sehen das Readme, und Chen sieht Ordner A.
Rollen und Berechtigungen
Die Frage: Darf Anne das Readme bearbeiten, und darf Beto es? Eine Rolle ist etwas, das man vergibt (owner, editor, viewer). Eine Berechtigung ist etwas, das man prüft (edit, view). Rollen zu vergeben und Berechtigungen zu prüfen hält die Prüfungen stabil, wenn sich die Rollen ändern.
Tupel:
doc:readme#owner@user:anne
doc:readme#viewer@group:eng#member
group:eng#member@user:beto
In der Notation des Papers sind Rollen Relationen mit gespeicherten Tupeln, und Berechtigungen sind Relationen, deren Regel kein _this hat, sodass niemand direkt ein Tupel in sie schreiben kann. Nur union und computed_userset werden gebraucht, beide aus Abbildung 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" } }
} } }
Abbildung 1 erledigt dieselbe Aufgabe anders: Sie legt _this und die größere Rolle in dieselbe Relation (“All owners are editors, and all editors are viewers”, also: Alle Eigentümer sind Bearbeiter, und alle Bearbeiter sind Betrachter). Beide Formen sind Umschreibregeln; die obige hält die Namen für Vergabe und Prüfung getrennt.
SpiceDB trennt die beiden Arten in der Syntax: relation-Zeilen sind das, was gespeichert werden darf, permission-Zeilen werden berechnet. Die Dokumentation sagt “relations should be named as nouns” (Relationen sollten als Substantive benannt werden) und “permissions should be named as verbs or nouns” (Berechtigungen sollten als Verben oder Substantive benannt werden) (Schema-Dokumentation).
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
}
SpiceDB-Schema; folgt der dokumentierten Syntax mit Stand 2026-11-13; kein Validator wurde ausgeführt.
OpenFGA hat nur eine Art von Relation. Eine Relation ohne Typbeschränkung in eckigen Klammern kann nicht direkt geschrieben werden; der Leitfaden zu Rollen und Berechtigungen von OpenFGA verwendet solche Relationen (booking_viewer, booking_adder) als Berechtigungen, und seine anderen Leitfäden versehen sie mit dem Präfix 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
OpenFGA-DSL; folgt der dokumentierten Syntax mit Stand 2026-11-13; kein Validator wurde ausgeführt.
Woher kommt Annes edit?
edit und view enthalten keine Tupel. Eine neue Rolle, etwa commenter, hinzuzufügen bedeutet eine neue Relation und ein weiteres Kind in den Berechtigungsregeln; kein bestehendes Tupel ändert sich.
Wie viele Relationen
Eine häufige Kritik an diesem Stil betrifft die Namen. In Osos Blogbeitrag „Google Zanzibar Isn’t Flexible“ (Oso verkauft ein konkurrierendes Autorisierungsprodukt) schreibt Greg Sarjeant, dass “the literature about ReBAC is rife with “relations” like can_delete and can_archive” (die Literatur über ReBAC voller „Relationen“ wie can_delete und can_archive ist), nennt das “essentially the same thing as creating a relation for every authorized action” (im Wesentlichen dasselbe, wie für jede autorisierte Aktion eine Relation anzulegen) und folgert, es sei “an indication that relations are the wrong abstraction for authorization” (ein Hinweis darauf, dass Relationen die falsche Abstraktion für Autorisierung sind) (Oso, 2024-11-01, aktualisiert 2025-11-07).
Die Zahl wächst tatsächlich: Jede Aktion, die die Anwendung prüft, braucht einen Namen im Schema. Was Umschreibregeln klein halten, ist die Zahl der gespeicherten Tupel und die Zahl der Relationen, in die jemand schreibt. In den obigen Schemas enthalten drei Relationen Tupel (owner, editor, viewer), und die Berechtigungen sind reine Funktionen davon; can_archive hinzuzufügen berührt also einmal das Schema und kein Tupel. Die eigene Begründung des Papers für Umschreibungen ist dieselbe: Eine abgeleitete Relation als Tupel für jedes Objekt zu speichern, “would be wasteful and make it hard to make modifications across all objects” (§2.3.1) (wäre verschwenderisch und würde Änderungen über alle Objekte hinweg erschweren). Ob Berechtigungsnamen im Schema Kosten oder Dokumentation sind, ist der Punkt, in dem Oso und die Produkte im Zanzibar-Stil uneins sind; diese Seite entscheidet das nicht.
Vererbung von Eltern zu Kind
Die Frage: Kann Chen, der Ordner A sieht, das Readme darin sehen? Vererbung von einem Container ist das Blatt tuple_to_userset: die parent-Tupel des Objekts lesen und dann auf jedem Elternobjekt nach einer Relation fragen.
Tupel:
doc:readme#parent@folder:A#...
folder:A#viewer@user:chen
Abbildung 1 des Papers enthält diese Regel bereits als drittes Kind von viewer. Ergänzt um die Berechtigung view aus dem vorigen Abschnitt:
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"
} } }
} } }
In SpiceDB folgt der Pfeil parent->view der Relation parent und fragt view auf dem, was er findet (Schema-Dokumentation):
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
}
SpiceDB-Schema; folgt der dokumentierten Syntax mit Stand 2026-11-13; kein Validator wurde ausgeführt.
In OpenFGA lautet dasselbe X from Y; der Parent-Child-Leitfaden verwendet es, um Bearbeiter eines Ordners zu Bearbeitern seiner Dokumente zu machen.
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
OpenFGA-DSL; folgt der dokumentierten Syntax mit Stand 2026-11-13; kein Validator wurde ausgeführt.
Beide Produktversionen geben auch folder ein parent, das auf folder zeigt, sodass ein Ordner vom darüberliegenden Ordner erbt und die Kette so tief ist, wie die Tupel sie machen. Abbildung 1 des Papers zeigt nur die Dokumentseite.
Welche Tupel entscheiden über Chens Zugriff?
Das Readme in einen anderen Ordner zu verschieben ist eine einzige Tupeländerung (ein parent-Tupel löschen, ein anderes schreiben), und jede geerbte Berechtigung folgt. Genau darum geht es im „New Enemy“-Beispiel A des Papers: “document ACLs inherit from folder ACLs” (§2.2) (Dokument-ACLs erben von Ordner-ACLs), also spielt die Reihenfolge von ACL-Änderungen und Verschiebungen eine Rolle; siehe Konsistenz.
Gruppen und verschachtelte Gruppen
Die Frage: Beto ist in einem Unterteam; erreicht ihn eine Berechtigung für eng? Diese Variante des durchgehenden Beispiels fügt ein hypothetisches Unterteam group:sre hinzu, mit Beto in sre und sre in eng.
Tupel:
group:sre#member@user:beto
group:eng#member@group:sre#member
doc:readme#viewer@group:eng#member
Eine Gruppe braucht im Paper keine Umschreibregel. member ist eine einfache Relation, und weil der Benutzer eines Tupels ein Userset sein kann, “a ⟨userset⟩ allows ACLs to refer to groups and thus supports representing nested group membership” (§2.1) (erlaubt ein ⟨userset⟩ es ACLs, auf Gruppen zu verweisen, und unterstützt damit die Darstellung verschachtelter Gruppenmitgliedschaften):
name: "group"
relation { name: "member" }
Die Konfigurationen des Papers sagen nichts darüber, welche Arten von Benutzern eine Relation akzeptiert. Beide Produkte verlangen das im Schema: Verschachtelung funktioniert nur dort, wo group#member als erlaubtes Subjekt aufgeführt ist.
definition group {
relation member: user | group#member
}
SpiceDB-Schema; folgt der dokumentierten Syntax mit Stand 2026-11-13; kein Validator wurde ausgeführt.
type group
relations
define member: [user, group#member]
OpenFGA-DSL; folgt der dokumentierten Syntax mit Stand 2026-11-13; kein Validator wurde ausgeführt.
Wie erreicht die Berechtigung Beto?
Die Tupel des Dokuments haben sich nicht geändert, als sre eng beigetreten ist: Eine Gruppe ist ein Userset, das mit denselben Tupeln geschrieben wird wie eine ACL (§2.1), sodass eine Änderung der Mitgliedschaft innerhalb der Gruppe bleibt. Dieselbe Indirektion ist der Grund, warum tiefe oder breite Gruppen per Zeigerverfolgung langsam zu prüfen sind; die Antwort des Papers ist der Leopard-Index (§3.2.4).
Sperrlisten (Ausschluss)
Die Frage: Mitglieder von eng dürfen das Readme sehen, außer einer Person. In dieser Variante ist Beto für das Readme gesperrt. Ein Ausschluss entfernt eine Menge aus einer anderen.
Tupel:
doc:readme#viewer@group:eng#member
group:eng#member@user:beto
doc:readme#blocked@user:beto
Das Paper nennt den Ausschluss als Operator (§2.3.1) und als Knoten im Userset-Baum von Expand (§2.4.5), aber Abbildung 1 zeigt nicht, wie er geschrieben wird. Der folgende Block übernimmt die Form von Abbildung 1 mit exclusion anstelle von union; das Schlüsselwort und die Regel, dass das erste Kind die Basis ist und das zweite abgezogen wird, sind Annahmen dieser Seite, nicht die Syntax des Papers.
relation { name: "blocked" }
relation {
name: "can_view"
userset_rewrite {
exclusion {
child { computed_userset { relation: "view" } }
child { computed_userset { relation: "blocked" } }
} } }
SpiceDB schreibt den Ausschluss als - (Schema-Dokumentation). Die gesperrte Berechtigung auf view aufzubauen hält den Ausdruck frei von Klammern:
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
}
SpiceDB-Schema; folgt der dokumentierten Syntax mit Stand 2026-11-13; kein Validator wurde ausgeführt.
OpenFGA schreibt ihn als but not (difference in der JSON-Form); sein Sperrlisten-Leitfaden sperrt ein Mitglied eines Teams für die Bearbeitung eines Dokuments, das das Team bearbeiten darf.
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
OpenFGA-DSL; folgt der dokumentierten Syntax mit Stand 2026-11-13 (die Seite zur Konfigurationssprache erlaubt Klammern zum Gruppieren von Operatoren); kein Validator wurde ausgeführt.
Welches Tupel entscheidet?
Ein Pfad zum Dokument genügt nicht mehr: Der Ausschluss muss beide Seiten betrachten. Zanzibar bricht den Rest eines Teilbaums nur ab, “when the outcome of one node determines the result of a subtree” (§3.2.3) (wenn das Ergebnis eines Knotens das Ergebnis eines Teilbaums bestimmt). Ein Ja entscheidet eine Vereinigung; bei einem Ausschluss entscheidet ein Ja auf der Basisseite nichts, solange die abgezogene Seite nicht bekannt ist. Beachten Sie auch, was gesperrt wird: Weil can_view von ganz view abzieht, verliert auch ein gesperrter Eigentümer can_view.
Öffentlicher Zugriff (Wildcards)
Die Frage: Kann überhaupt jeder ein öffentliches Dokument sehen? Das Paper hat in seiner Notation keine Antwort. Ein ⟨user⟩ ist “⟨user_id⟩ | ⟨userset⟩”, und eine Benutzer-ID “is an integer” (ist eine ganze Zahl) (§2.1); es gibt keinen Wert, der jeden Benutzer bedeutet, und das Paper behandelt öffentliche Objekte nicht. Innerhalb des Modells des Papers ist die nächstliegende Konstruktion eine Gruppe, die jeden Benutzer enthält, was ein Tupel pro Benutzer erfordert; wie Google öffentliches Teilen handhabt, ist nicht beschrieben.
Beide Produkte fügen ein Wildcard-Subjekt hinzu, user:*, das nur dort erlaubt ist, wo das Schema es aufführt. Das Tupel:
doc:readme#viewer@user:*
definition doc {
relation viewer: user | user:* | group#member
permission view = viewer
}
SpiceDB-Schema; folgt der dokumentierten Syntax mit Stand 2026-11-13; kein Validator wurde ausgeführt.
type doc
relations
define viewer: [user, user:*, group#member]
OpenFGA-DSL; folgt der dokumentierten Syntax mit Stand 2026-11-13; kein Validator wurde ausgeführt.
Beide Projekte warnen davor. AuthZed: “Be very careful with wildcard support in your schema!” (Seien Sie sehr vorsichtig mit Wildcard-Unterstützung in Ihrem Schema!) und “Only grant it to read permissions, unless you intend to allow for universal writing” (Vergeben Sie sie nur für Leseberechtigungen, es sei denn, Sie wollen universelles Schreiben erlauben) (Schema-Dokumentation). OpenFGA: “type-bound public access is not a wildcard or a regex expression” (typgebundener öffentlicher Zugriff ist keine Wildcard und kein regulärer Ausdruck); user:* darf nur als Benutzer vorkommen, nicht als Objekt (document:*) und nicht innerhalb eines Usersets (org:*#member) (Leitfaden zu öffentlichem Zugriff).
Mehrere Einschränkungen (Schnittmenge)
Die Frage: Nur Eigentümer, die auch Mitglieder des Teams des Dokuments sind, dürfen es veröffentlichen. Darf Anne das Readme veröffentlichen? Eine Schnittmenge verlangt, dass ein Benutzer in jedem Kind enthalten ist.
Diese Variante fügt eine Relation team vom Readme zu group:eng hinzu. Tupel:
doc:readme#owner@user:anne
doc:readme#team@group:eng#...
group:eng#member@user:beto
Wie beim Ausschluss nennt das Paper die Schnittmenge (§2.3.1), zeigt aber nicht, wie sie geschrieben wird. Dieser Block übernimmt die Form von Abbildung 1; das Schlüsselwort intersection ist eine Annahme:
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 schreibt die Schnittmenge als &:
definition doc {
relation owner: user
relation team: group
permission publish = owner & team->member
}
SpiceDB-Schema; folgt der dokumentierten Syntax mit Stand 2026-11-13; kein Validator wurde ausgeführt.
OpenFGA schreibt sie als and; sein Leitfaden zu mehreren Einschränkungen baut dieselbe Form, can_delete als Schreibende, die auch Mitglieder der besitzenden Organisation sind.
type doc
relations
define owner: [user]
define team: [group]
define can_publish: owner and member from team
OpenFGA-DSL; folgt der dokumentierten Syntax mit Stand 2026-11-13; kein Validator wurde ausgeführt.
Warum wird Anne abgewiesen?
Die entscheidende Tatsache ist ein fehlendes Tupel. group:eng#member@user:anne hinzuzufügen würde die Antwort zu Ja machen, ohne das Dokument anzufassen.
Benutzerdefinierte Rollen
Die Frage: Ein Administrator definiert zur Laufzeit eine neue Rolle, „reviewer“, und gibt ihr Lesezugriff auf das Readme. Kann Chen, der die Rolle innehat, es sehen? Im Schema festgelegte Rollen (owner, editor) ändern sich nur, wenn sich das Schema ändert; benutzerdefinierte Rollen sind Daten.
Der Leitfaden zu benutzerdefinierten Rollen von OpenFGA modelliert sie als eigenen Typ, “because our roles are going to be dynamic and might change frequently” (weil unsere Rollen dynamisch sein werden und sich häufig ändern können): Benutzer stehen zu einem role-Objekt in der Relation assignee, und den Zugewiesenen der Rolle werden Relationen als Userset gewährt (role:media-manager#assignee als editor von asset-category:logos). Der Beitrag zu benutzerdefinierten Rollen von AuthZed (2021-10-27) tut dasselbe mit role#member.
Tupel (eine Variante: Chen hat eine Rolle statt einer Ordnerberechtigung):
role:reviewer#assignee@user:chen
doc:readme#viewer@role:reviewer#assignee
doc:readme#editor@role:maintainer#assignee
Im Paper ist das das Gruppenmuster mit einem anderen Namespace-Namen: role ist ein Namespace mit einer einfachen Relation, und das viewer des Readmes speichert ein Userset, das darauf zeigt. Keine Regel ändert sich:
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
}
SpiceDB-Schema; folgt der dokumentierten Syntax mit Stand 2026-11-13; kein Validator wurde ausgeführt.
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
OpenFGA-DSL; folgt der dokumentierten Syntax mit Stand 2026-11-13; kein Validator wurde ausgeführt.
Wie gewährt eine zur Laufzeit definierte Rolle Zugriff?
Die Berechtigungen der Rolle gelten pro Objekt. Eine Rolle, die „darf in diesem Repository überall Issues anlegen und löschen“ bedeuten soll, braucht auch ihre Berechtigungsmenge als Daten. Die Seite zum Zugriffskontrollmanagement von AuthZed zeigt dieses feinere Muster: eine role-Definition mit einer Wildcard-Relation pro Berechtigung (relation create_issue: user:*), ein role_grant-Objekt, das eine Rolle mit Begünstigten verbindet, und Berechtigungen der Form permission create_issue = role->create_issue & grantee. Der Preis ist eine Schemarelation pro Berechtigung, was die Namensfrage von oben zurückbringt.
Übertragung des Eigentums
Die Frage: Anne übergibt das Readme an Beto. Danach muss Beto der Eigentümer sein und Anne nicht, ohne einen Moment, in dem beide oder keiner es sind. Das ist kein Schemamuster: Keine der drei Notationen kann „genau ein Eigentümer“ deklarieren, und die hier zitierte Schema-Dokumentation zeigt keine Kardinalitätsbeschränkung. Es ist ein Schreibmuster.
Die Tupeländerung:
delete doc:readme#owner@user:anne
write doc:readme#owner@user:beto
Die Write-API des Papers deckt das ab. Clients “may also modify all tuples related to an object via a read-modify-write process with optimistic concurrency control” (können auch alle Tupel eines Objekts über einen Read-Modify-Write-Prozess mit optimistischer Nebenläufigkeitskontrolle ändern): die Tupel des Objekts einschließlich eines „Lock“-Tupels pro Objekt lesen, die Schreibvorgänge “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” (zusammen mit einem Touch auf das Lock-Tupel … mit der Bedingung, dass die Schreibvorgänge nur committet werden, wenn das Lock-Tupel seit dem Lesen nicht geändert wurde) senden und es andernfalls erneut versuchen (§2.4.2). Das Lock-Tupel verhindert, dass zwei gleichzeitige Übertragungen beide gelingen.
- SpiceDB.
WriteRelationships“atomically writes and/or deletes a set of specified relationships” (schreibt und/oder löscht atomar eine Menge angegebener Beziehungen), und “if any preconditions fail, the entire transaction will be reverted” (wenn eine Vorbedingung fehlschlägt, wird die gesamte Transaktion rückgängig gemacht) (permission_service.proto). Eine VorbedingungMUST_MATCHaufdoc:readme#owner@user:anneübernimmt die Rolle des Lock-Tupels aus dem Paper: Die Übertragung schlägt fehl, wenn Anne nicht mehr Eigentümerin ist. - OpenFGA. “You can combine both writes and deletes in a single transactional API request” (Sie können Schreib- und Löschvorgänge in einer einzigen transaktionalen API-Anfrage kombinieren), und “all operations in the request will either succeed together or fail together” (alle Operationen der Anfrage gelingen entweder gemeinsam oder scheitern gemeinsam), bis zu 100 Tupel pro Anfrage (Tupel aktualisieren). Dieselbe Seite sagt, dass das Schreiben eines bereits existierenden Tupels “would normally cause the whole request to fail” (normalerweise die ganze Anfrage scheitern lassen würde), und bietet
on_missing: "ignore"für “deleting tuples that might not exist” (das Löschen von Tupeln, die möglicherweise nicht existieren) an (OpenFGA v1.10.0 und später). Das legt nahe, dass das Löschen eines fehlenden Tupels die Anfrage standardmäßig scheitern lässt, wodurch das Löschen wie das Lock-Tupel wirken würde; die Seite nennt diesen Standard nicht ausdrücklich, und er wurde hier nicht ausprobiert.
Was ändert sich?
Alles, was vom Eigentum abgeleitet ist (edit, view), wandert mit dem einen Tupel. Anne behält jeden Zugriff, den sie über andere Pfade hat, etwa über ein direktes viewer-Tupel oder eine Gruppe; eine Übertragung, die Anne jeden Zugriff entziehen soll, muss auch diese Tupel löschen.
Quellen
- Ruoming Pang et al., “Zanzibar: Google’s Consistent, Global Authorization System”, USENIX ATC ’19, usenix.org/conference/atc19/presentation/pang
- Modellierungsleitfäden von OpenFGA: roles and permissions, parent-child, blocklists, public access, multiple restrictions, custom roles
- OpenFGA, configuration language
- OpenFGA, update tuples
- AuthZed, SpiceDB schema docs
- AuthZed, access-control management
- AuthZed, User Defined Roles, 2021-10-27
- AuthZed,
permission_service.proto - Greg Sarjeant, Google Zanzibar Isn’t Flexible, Oso, 2024-11-01 (aktualisiert 2025-11-07)