O artigo descreve seu modelo de dados e sua linguagem de configuração, mas apresenta apenas uma política completa, a Figura 1. Sua conclusão afirma mais: “simple yet flexible data model and configuration language support a variety of access control policies from both consumer and enterprise applications” (o modelo de dados e a linguagem de configuração, simples porém flexíveis, suportam uma variedade de políticas de controle de acesso de aplicações tanto de consumo quanto corporativas) (§6). A seção de trabalhos relacionados nomeia os padrões que ele cobre: “Zanzibar’s data model supports permissions, users, groups, and inheritance” (o modelo de dados do Zanzibar suporta permissões, usuários, grupos e herança), como encontrados no Multics, no UNIX, nas ACLs POSIX e no VMS, e “a number of Zanzibar clients have implemented RBAC policies on top of Zanzibar’s namespace configuration language” (vários clientes do Zanzibar implementaram políticas RBAC sobre a linguagem de configuração de namespace do Zanzibar) (§5).
Esta página descreve oito requisitos que surgem na prática. Cada seção apresenta a pergunta que o padrão responde, as tuplas, a regra na notação da Figura 1 do artigo quando o artigo consegue expressá-la, a mesma regra na linguagem de schema do SpiceDB e na DSL do OpenFGA, e um grafo das tuplas com o caminho que decide a resposta destacado. A lista de padrões segue os guias de modelagem do OpenFGA; a página sobre tuplas explica a notação.
O exemplo recorrente: Anne, Beto e Chen (user:anne, user:beto, user:chen); o documento doc:readme em folder:A; o grupo group:eng. Anne é dona do readme, Beto está em eng, os membros de eng visualizam o readme e Chen visualiza a pasta A.
Papéis e permissões
A pergunta: Anne pode editar o readme, e Beto pode? Um papel (role) é algo que se concede (owner, editor, viewer). Uma permissão é algo que se verifica (edit, view). Conceder papéis e verificar permissões mantém as verificações estáveis quando os papéis mudam.
Tuplas:
doc:readme#owner@user:anne
doc:readme#viewer@group:eng#member
group:eng#member@user:beto
Na notação do artigo, papéis são relações com tuplas armazenadas, e permissões são relações cuja regra não tem _this, de modo que ninguém pode escrever uma tupla diretamente nelas. Apenas union e computed_userset são necessários, ambos da Figura 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" } }
} } }
A Figura 1 faz o mesmo trabalho de outra forma: ela coloca _this e o papel maior na mesma relação (“All owners are editors, and all editors are viewers”, todos os donos são editores, e todos os editores são visualizadores). As duas formas são regras de reescrita; a de cima mantém separados os nomes que se concedem e os nomes que se verificam.
O SpiceDB separa os dois tipos na sintaxe: as linhas relation são o que pode ser armazenado, as linhas permission são calculadas. Sua documentação diz “relations should be named as nouns” (relações devem ser nomeadas como substantivos) e “permissions should be named as verbs or nouns” (permissões devem ser nomeadas como verbos ou substantivos) (documentação de schema).
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
}
Schema do SpiceDB; segue a sintaxe documentada em 2026-11-13; nenhum validador foi executado.
O OpenFGA tem um único tipo de relação. Uma relação sem restrição de tipo entre colchetes não pode ser escrita diretamente; o guia de papéis e permissões do OpenFGA usa tais relações (booking_viewer, booking_adder) como permissões, e seus outros guias as prefixam com 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 do OpenFGA; segue a sintaxe documentada em 2026-11-13; nenhum validador foi executado.
De onde vem o edit de Anne?
Observe que edit e view não contêm tuplas. Adicionar um novo papel, por exemplo commenter, significa uma nova relação e mais um filho nas regras de permissão; nenhuma tupla existente muda.
Quantas relações
Uma crítica frequente a esse estilo diz respeito aos nomes. No post de blog da Oso “Google Zanzibar Isn’t Flexible” (a Oso vende um produto de autorização concorrente), Greg Sarjeant escreve que “the literature about ReBAC is rife with “relations” like can_delete and can_archive” (a literatura sobre ReBAC está repleta de “relações” como can_delete e can_archive), chama isso de “essentially the same thing as creating a relation for every authorized action” (essencialmente a mesma coisa que criar uma relação para cada ação autorizada) e conclui que é “an indication that relations are the wrong abstraction for authorization” (um indício de que relações são a abstração errada para autorização) (Oso, 2024-11-01, atualizado em 2025-11-07).
A contagem de fato cresce: toda ação que a aplicação verifica precisa de um nome no schema. O que as regras de reescrita mantêm pequeno é o número de tuplas armazenadas e o número de relações em que alguém escreve. Nos schemas acima, três relações contêm tuplas (owner, editor, viewer) e as permissões são funções puras delas, de modo que adicionar can_archive altera o schema uma vez e nenhuma tupla. A própria motivação do artigo para as reescritas é a mesma: armazenar uma relação derivada como uma tupla para cada objeto “would be wasteful and make it hard to make modifications across all objects” (seria um desperdício e dificultaria fazer modificações em todos os objetos) (§2.3.1). Se nomes de permissão no schema são um custo ou uma documentação é o ponto em que a Oso e os produtos no estilo Zanzibar discordam; esta página não resolve essa questão.
Herança pai-filho
A pergunta: Chen, que visualiza a pasta A, pode visualizar o readme dentro dela? A herança a partir de um contêiner é a folha tuple_to_userset: ler as tuplas parent do objeto e, em seguida, consultar uma relação em cada pai.
Tuplas:
doc:readme#parent@folder:A#...
folder:A#viewer@user:chen
A Figura 1 do artigo já contém essa regra como o terceiro filho de viewer. Acrescentada à permissão view da seção anterior:
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"
} } }
} } }
No SpiceDB, a seta parent->view segue a relação parent e consulta view no que encontra (documentação de schema):
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
}
Schema do SpiceDB; segue a sintaxe documentada em 2026-11-13; nenhum validador foi executado.
No OpenFGA, o mesmo é X from Y; o guia pai-filho o usa para tornar os editores de uma pasta editores de seus documentos.
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 do OpenFGA; segue a sintaxe documentada em 2026-11-13; nenhum validador foi executado.
As duas versões dos produtos também dão a folder um parent que aponta para folder, de modo que uma pasta herda da pasta acima dela e a cadeia é tão profunda quanto as tuplas a tornam. A Figura 1 do artigo mostra apenas o lado do documento.
Quais tuplas decidem o acesso de Chen?
Observe que mover o readme para outra pasta é uma única alteração de tupla (apagar uma tupla parent, escrever outra), e todas as concessões herdadas acompanham a mudança. É o mesmo movimento de que trata o Exemplo A do problema do “novo inimigo” no artigo: “document ACLs inherit from folder ACLs” (as ACLs dos documentos herdam das ACLs da pasta) (§2.2), de modo que a ordem das alterações de ACL e das movimentações importa; veja consistência.
Grupos e grupos aninhados
A pergunta: Beto está em uma subequipe; uma concessão a eng chega até ele? Esta variante do exemplo recorrente acrescenta uma subequipe hipotética group:sre, com Beto em sre e sre dentro de eng.
Tuplas:
group:sre#member@user:beto
group:eng#member@group:sre#member
doc:readme#viewer@group:eng#member
Um grupo não precisa de regra de reescrita no artigo. member é uma relação simples e, como o usuário de uma tupla pode ser um userset, “a ⟨userset⟩ allows ACLs to refer to groups and thus supports representing nested group membership” (um ⟨userset⟩ permite que ACLs se refiram a grupos e, assim, possibilita representar associações a grupos aninhados) (§2.1):
name: "group"
relation { name: "member" }
As configurações do artigo nada dizem sobre quais tipos de usuário uma relação aceita. Os dois produtos exigem isso no schema: o aninhamento só funciona onde group#member está listado como sujeito permitido.
definition group {
relation member: user | group#member
}
Schema do SpiceDB; segue a sintaxe documentada em 2026-11-13; nenhum validador foi executado.
type group
relations
define member: [user, group#member]
DSL do OpenFGA; segue a sintaxe documentada em 2026-11-13; nenhum validador foi executado.
Como a concessão chega a Beto?
Observe que as tuplas do documento não mudaram quando sre entrou em eng: um grupo é um userset escrito com as mesmas tuplas que uma ACL (§2.1), de modo que uma alteração de associação fica dentro do grupo. A mesma indireção é o motivo pelo qual grupos profundos ou largos são lentos de verificar por pointer chasing; a resposta do artigo é o índice Leopard (§3.2.4).
Listas de bloqueio (exclusão)
A pergunta: os membros de eng podem visualizar o readme, exceto uma pessoa. Nesta variante, Beto está bloqueado no readme. A exclusão remove um conjunto de outro.
Tuplas:
doc:readme#viewer@group:eng#member
group:eng#member@user:beto
doc:readme#blocked@user:beto
O artigo lista a exclusão como operador (§2.3.1) e como nó na árvore de userset do Expand (§2.4.5), mas a Figura 1 não mostra como ela é escrita. O bloco abaixo copia a forma da Figura 1 com exclusion no lugar de union; a palavra-chave e a regra de que o primeiro filho é a base e o segundo é subtraído são uma suposição desta página, não a sintaxe do artigo.
relation { name: "blocked" }
relation {
name: "can_view"
userset_rewrite {
exclusion {
child { computed_userset { relation: "view" } }
child { computed_userset { relation: "blocked" } }
} } }
O SpiceDB escreve a exclusão como - (documentação de schema). Definir a permissão com bloqueio sobre view mantém a expressão livre de parênteses:
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
}
Schema do SpiceDB; segue a sintaxe documentada em 2026-11-13; nenhum validador foi executado.
O OpenFGA a escreve como but not (difference em sua forma JSON); seu guia de listas de bloqueio bloqueia um membro de uma equipe de editar um documento que a equipe pode editar.
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 do OpenFGA; segue a sintaxe documentada em 2026-11-13 (a página da linguagem de configuração permite parênteses para agrupar operadores); nenhum validador foi executado.
Qual tupla decide?
Observe que um caminho até o documento já não basta: a exclusão precisa olhar os dois lados. O Zanzibar cancela o restante de uma subárvore apenas “when the outcome of one node determines the result of a subtree” (quando o resultado de um nó determina o resultado de uma subárvore) (§3.2.3). Um sim decide uma união; em uma exclusão, um sim no lado da base nada decide até que o lado subtraído seja conhecido. Observe também o que fica bloqueado: como can_view subtrai de todo o view, um dono bloqueado também perde can_view.
Acesso público (curingas)
A pergunta: qualquer pessoa pode visualizar um documento público? O artigo não tem resposta em sua notação. Um ⟨user⟩ é “⟨user_id⟩ | ⟨userset⟩” e um ID de usuário “is an integer” (é um inteiro) (§2.1); não há valor que signifique todos os usuários, e o artigo não discute objetos públicos. Dentro do modelo do artigo, a construção mais próxima é um grupo que contém todos os usuários, o que exige uma tupla por usuário; não se descreve como o Google lida com o compartilhamento público.
Os dois produtos acrescentam um sujeito curinga (wildcard), user:*, permitido apenas onde o schema o lista. A tupla:
doc:readme#viewer@user:*
definition doc {
relation viewer: user | user:* | group#member
permission view = viewer
}
Schema do SpiceDB; segue a sintaxe documentada em 2026-11-13; nenhum validador foi executado.
type doc
relations
define viewer: [user, user:*, group#member]
DSL do OpenFGA; segue a sintaxe documentada em 2026-11-13; nenhum validador foi executado.
Os dois projetos alertam sobre isso. AuthZed: “Be very careful with wildcard support in your schema!” (tenha muito cuidado com o suporte a curingas no seu schema!) e “Only grant it to read permissions, unless you intend to allow for universal writing” (conceda-o apenas a permissões de leitura, a menos que pretenda permitir escrita universal) (documentação de schema). OpenFGA: “type-bound public access is not a wildcard or a regex expression” (o acesso público vinculado a tipo não é um curinga nem uma expressão regular); user:* só pode aparecer como usuário, não como objeto (document:*) nem dentro de um userset (org:*#member) (guia de acesso público).
Múltiplas restrições (interseção)
A pergunta: apenas donos que também são membros da equipe do documento podem publicá-lo. Anne pode publicar o readme? A interseção exige que um usuário esteja em todos os filhos.
Esta variante acrescenta uma relação team do readme para group:eng. Tuplas:
doc:readme#owner@user:anne
doc:readme#team@group:eng#...
group:eng#member@user:beto
Assim como a exclusão, o artigo nomeia a interseção (§2.3.1), mas não mostra como ela é escrita. Este bloco copia a forma da Figura 1; a palavra-chave intersection é uma suposição:
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"
} } }
} } }
O SpiceDB escreve a interseção como &:
definition doc {
relation owner: user
relation team: group
permission publish = owner & team->member
}
Schema do SpiceDB; segue a sintaxe documentada em 2026-11-13; nenhum validador foi executado.
O OpenFGA a escreve como and; seu guia de múltiplas restrições constrói a mesma forma, can_delete como escritores que também são membros da organização proprietária.
type doc
relations
define owner: [user]
define team: [group]
define can_publish: owner and member from team
DSL do OpenFGA; segue a sintaxe documentada em 2026-11-13; nenhum validador foi executado.
Por que Anne é recusada?
Observe que o fato decisivo é uma tupla ausente. Acrescentar group:eng#member@user:anne tornaria a resposta sim sem tocar no documento.
Papéis personalizados
A pergunta: um administrador define um novo papel, “reviewer”, em tempo de execução e lhe dá acesso de visualização ao readme. Chen, que detém o papel, pode visualizá-lo? Papéis fixados no schema (owner, editor) só mudam quando o schema muda; papéis personalizados são dados.
O guia de papéis personalizados do OpenFGA os modela como um tipo separado “because our roles are going to be dynamic and might change frequently” (porque nossos papéis serão dinâmicos e podem mudar com frequência): os usuários são relacionados a um objeto role como assignee, e os assignees do papel recebem relações como um userset (role:media-manager#assignee como editor de asset-category:logos). O post sobre papéis definidos pelo usuário da AuthZed (2021-10-27) faz o mesmo com role#member.
Tuplas (uma variante: Chen detém um papel em vez de uma concessão na pasta):
role:reviewer#assignee@user:chen
doc:readme#viewer@role:reviewer#assignee
doc:readme#editor@role:maintainer#assignee
No artigo, este é o padrão de grupos com outro nome de namespace: role é um namespace com uma relação simples, e o viewer do readme armazena um userset que aponta para ele. Nenhuma regra muda:
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
}
Schema do SpiceDB; segue a sintaxe documentada em 2026-11-13; nenhum validador foi executado.
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 do OpenFGA; segue a sintaxe documentada em 2026-11-13; nenhum validador foi executado.
Como um papel criado em tempo de execução concede acesso?
Observe que as concessões do papel são por objeto. Um papel que deva significar “pode criar e apagar issues em qualquer lugar deste repositório” também precisa ter seu conjunto de permissões armazenado como dados. A página de gerenciamento de controle de acesso da AuthZed mostra esse padrão mais refinado: uma definição role com uma relação curinga por permissão (relation create_issue: user:*), um objeto role_grant que liga um papel a quem o recebe, e permissões da forma permission create_issue = role->create_issue & grantee. O preço é uma relação de schema por permissão, o que traz de volta a questão dos nomes discutida acima.
Transferência de propriedade
A pergunta: Anne transfere o readme para Beto. Depois disso, Beto deve ser o dono e Anne não, sem nenhum momento em que ambos ou nenhum sejam donos. Este não é um padrão de schema: nenhuma das três notações consegue declarar “exatamente um dono”, e a documentação de schema citada aqui não mostra nenhuma restrição de cardinalidade. É um padrão de escrita.
A alteração de tuplas:
delete doc:readme#owner@user:anne
write doc:readme#owner@user:beto
A API Write do artigo cobre isso. Os clientes “may also modify all tuples related to an object via a read-modify-write process with optimistic concurrency control” (também podem modificar todas as tuplas relacionadas a um objeto por meio de um processo de leitura-modificação-escrita com controle de concorrência otimista): ler as tuplas do objeto, incluindo uma tupla de “lock” por objeto, enviar as escritas “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” (junto com um toque na tupla de lock … com a condição de que as escritas só sejam confirmadas se a tupla de lock não tiver sido modificada desde a leitura) e, caso contrário, tentar novamente (§2.4.2). A tupla de lock impede que duas transferências simultâneas sejam ambas bem-sucedidas.
- SpiceDB.
WriteRelationships“atomically writes and/or deletes a set of specified relationships” (escreve e/ou apaga atomicamente um conjunto de relacionamentos especificados), e “if any preconditions fail, the entire transaction will be reverted” (se alguma pré-condição falhar, a transação inteira será revertida) (permission_service.proto). Uma pré-condiçãoMUST_MATCHsobredoc:readme#owner@user:annefaz o papel da tupla de lock do artigo: a transferência falha se Anne já não for a dona. - OpenFGA. “You can combine both writes and deletes in a single transactional API request” (é possível combinar escritas e exclusões em uma única requisição transacional à API), e “all operations in the request will either succeed together or fail together” (todas as operações da requisição terão sucesso juntas ou falharão juntas), até 100 tuplas por requisição (update tuples). A mesma página diz que escrever uma tupla que já existe “would normally cause the whole request to fail” (normalmente faria a requisição inteira falhar) e oferece
on_missing: "ignore"para “deleting tuples that might not exist” (apagar tuplas que talvez não existam) (OpenFGA v1.10.0 e posteriores). Isso implica que apagar uma tupla inexistente faz a requisição falhar por padrão, o que faria a exclusão agir como a tupla de lock; a página não afirma esse padrão explicitamente, e isso não foi executado aqui.
O que muda?
Observe que tudo o que deriva da propriedade (edit, view) acompanha essa única tupla. Anne mantém qualquer acesso que tenha por outros caminhos, como uma tupla viewer direta ou um grupo; uma transferência que deva remover todo o acesso de Anne precisa apagar também essas tuplas.
Fontes
- Ruoming Pang et al., “Zanzibar: Google’s Consistent, Global Authorization System”, USENIX ATC ’19, usenix.org/conference/atc19/presentation/pang
- Guias de modelagem do OpenFGA: roles and permissions, parent-child, blocklists, public access, multiple restrictions, custom roles
- OpenFGA, configuration language
- OpenFGA, update tuples
- AuthZed, documentação de schema do SpiceDB
- 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 (atualizado em 2025-11-07)