system:openfga@pt-BR

Ecossistema

OpenFGA

O mecanismo de autorização da CNCF inspirado no Zanzibar, lido à luz do artigo.

Fatos verificados em Seções do artigo §2.1, §2.2, §2.3.1, §2.4, §3, §3.1.3, §3.2.2, §3.2.4

Mantenedor
CNCF project (Okta core maintainer)
Licença
Apache-2.0
Linguagem
Go
Status
Ativo, CNCF Incubating
Versão mais recente
v1.22.1 (2026-10-28)
Repositório
github.com/openfga/openfga
Documentação
openfga.dev/docs

O OpenFGA é um mecanismo de autorização de código aberto. Sua documentação afirma que a forma JSON de sua linguagem de modelo, a que a API aceita, “closely tracks the language in the Zanzibar paper” (segue de perto a linguagem do artigo do Zanzibar); a DSL acrescenta açúcar sintático e é compilada para esse JSON (linguagem de configuração). A publicação da CNCF que anuncia sua incubação diz que ele “was developed by a group of Okta employees, and is the foundation for the Auth0 FGA commercial offering” (foi desenvolvido por um grupo de funcionários da Okta e é a base da oferta comercial Auth0 FGA) (CNCF, 2025-11-11). É escrito em Go e licenciado sob Apache-2.0 (repositório). O serviço gerenciado da Auth0 descreve a si mesmo como “based on OpenFGA, an open-source project owned by the Cloud Native Computing Foundation” (baseado no OpenFGA, um projeto de código aberto pertencente à Cloud Native Computing Foundation) (documentação do Auth0 FGA).

Termos do artigo e termos do OpenFGA

A própria documentação do OpenFGA inclui uma tabela de “Equivalent Zanzibar Concepts” (conceitos equivalentes do Zanzibar) (linguagem de configuração); esta a estende à API e ao armazenamento.

No artigo No OpenFGA
Configuração de namespace (§2.3) Um type em um modelo de autorização, escrito na DSL ou em JSON (linguagem de configuração)
Tupla de relação object#relation@user (§2.1) Relationship tuple com user, relation, object, por exemplo user:anne, owner, doc:readme; um userset é escrito group:eng#member
_this (§2.3.1) Uma restrição de tipo direta, como [user, group#member] (this em JSON)
computed_userset Um nome de relação isolado, por exemplo or owner
tuple_to_userset viewer from parent (tupleToUserset em JSON)
union / intersection / exclusion or / and / but not (union / intersection / difference em JSON)
Zookie (§2.4) Nenhum; uma consulta escolhe MINIMIZE_LATENCY ou HIGHER_CONSISTENCY (consistência)
Check (§2.4.4) Check, BatchCheck
Read (§2.4.1) Read
Write (§2.4.2) Write
Watch (§2.4.3) ReadChanges, uma leitura de lista paginada com um token de continuação (alterações de tuplas)
Expand (§2.4.5) Expand
Fora da API do artigo ListObjects, StreamedListObjects, ListUsers; stores; versões de modelo (WriteAuthorizationModel, ReadAuthorizationModel(s))
Leopard (§3.2.4) Nenhum equivalente na documentação citada aqui
Spanner (§3) memory (o padrão), postgres, mysql, sqlite (configurar o OpenFGA)

Os nomes da API vêm de openfga_service.proto.

O exemplo recorrente como modelo

A Figura 1 do artigo torna os donos editores, os editores visualizadores, e os visualizadores da pasta pai visualizadores do documento (§2.3.1). Na DSL do OpenFGA, as mesmas regras ficam em uma linha por relação:

model
  schema 1.1

type user

type group
  relations
    define member: [user]

type folder
  relations
    define viewer: [user, group#member]

type doc
  relations
    define parent: [folder]
    define owner: [user]
    define editor: [user, group#member] or owner
    define viewer: [user, group#member] or editor or viewer from parent

As tuplas de Anne, Beto e Chen:

user relation object
user:anne owner doc:readme
folder:A parent doc:readme
user:beto member group:eng
group:eng#member viewer doc:readme
user:chen viewer folder:A

Por quais dessas tuplas uma verificação de viewer sobre o readme passa para cada pessoa?

O exemplo recorrente como tuplas do OpenFGACinco tuplas. user:anne é owner de doc:readme. user:beto é member de group:eng, e group:eng#member é viewer de doc:readme. user:chen é viewer de folder:A, e folder:A é parent de doc:readme. O caminho de Anne está destacado: owner leva a editor, que leva a viewer.user:anneuser:betouser:chengroup:engfolder:Adoc:readmeownermemberviewer(eng#member)viewerparent
Cada seta é uma tupla armazenada. A tupla owner de Anne (destacada) conta como editor e, depois, como viewer; Beto entra pelo grupo e Chen por viewer from parent.

Observe que é o modelo, e não uma tupla, que carrega “donos são editores” e “editores são visualizadores”: é o ponto do artigo de que relacionamentos entre relações pertencem à configuração, e não a uma tupla por objeto (§2.3.1).

Arquitetura

Em que consiste uma implantação do OpenFGA? A documentação descreve servidores sobre um único repositório de dados SQL. Cada servidor pode manter caches em memória para o Check, e o guia de produção recomenda “a small pool of servers with high capacity (memory and CPU cores) instead of a big pool of servers, to increase cache hit ratios” (um pequeno conjunto de servidores de alta capacidade, em memória e núcleos de CPU, em vez de um grande conjunto de servidores, para aumentar as taxas de acerto do cache) (execução em produção). Para o PostgreSQL, é possível configurar um repositório de dados secundário (réplica de leitura); leituras HIGHER_CONSISTENCY vão para o primário (configurar o OpenFGA). Os consumidores de alterações chamam ReadChanges e guardam o token de continuação (alterações de tuplas).

Arquitetura do OpenFGAUm cliente da aplicação envia Check a um de dois servidores OpenFGA por gRPC ou HTTP. Cada servidor tem um cache de Check em memória opcional. Ambos os servidores escrevem em um repositório de dados PostgreSQL primário e podem ler de uma réplica de leitura opcional, alimentada pela replicação do PostgreSQL. Um consumidor de alterações chama ReadChanges em um servidor com um token de continuação.Aplicação(cliente gRPC / HTTP)Consumidor de alterações(consulta ReadChanges)Servidor OpenFGA+ cache de CheckServidor OpenFGA+ cache de CheckRepositório primárioPostgreSQL · MySQL · SQLiteRéplica de leitura(PostgreSQL, opcional)CheckReadChanges + tokenescritas, HIGHER_CONSISTENCYoutras leiturasreplicação
Amarelo: servidores. Verde: repositórios de dados. Azul: clientes. Tracejado: opcional. A documentação não descreve despacho de servidor para servidor.

Compare com a Figura 2 do artigo (§3): os aclservers distribuem trabalho entre si, os watchservers enviam um stream, e o Leopard mantém um índice desnormalizado. A documentação do OpenFGA citada aqui não descreve nenhum dos três; os servidores respondem a partir do repositório de dados e de seus próprios caches.

Consistência sem zookies

O OpenFGA não tem zookie. Sua documentação diz isso em “Future work”: o artigo “has a feature called Zookies” (tem um recurso chamado Zookies), e o OpenFGA “is considering a similar feature in future releases” (está considerando um recurso semelhante em versões futuras) (consistência). Em vez disso, o Read e as APIs de consulta recebem um de dois valores:

Modo Comportamento (documentação de consistência) Análogo no artigo
MINIMIZE_LATENCY (padrão) “will serve queries from the cache when possible” (servirá as consultas a partir do cache quando possível) Uma requisição sem zookie: “a reasonably recent snapshot” (um snapshot razoavelmente recente) (§2.4.1)
HIGHER_CONSISTENCY “will skip the cache and query the database directly” (ignorará o cache e consultará o banco de dados diretamente) Nenhum exato; o mais próximo é avaliar no snapshot mais recente

O cache vem “disabled by default” (desativado por padrão), e nesse caso “all queries will have strong consistency regardless of the consistency mode specified” (todas as consultas terão consistência forte, independentemente do modo de consistência especificado) (consistência). O modo só importa depois que um cache é ativado.

Com o cache ativado, Chen ainda consegue ver o readme logo depois de ser removido da pasta A?

Cache e modos de consistência no OpenFGACom o cache de Check ativado, uma primeira verificação de Chen sobre o readme é permitida e armazenada em cache. A aplicação então apaga a tupla viewer de Chen sobre a pasta A. Uma segunda verificação com MINIMIZE_LATENCY pode ser respondida a partir do cache e ainda dizer permitido. Uma terceira verificação com HIGHER_CONSISTENCY ignora o cache, lê o repositório de dados e é negada.tempoAplicaçãoServidor OpenFGARepositório de dadosCheckWrite (delete)MINIMIZE_LATENCYHIGHER_CONSISTENCYChen pode ver?permitido, em cacheapaga a tupla de Chentupla apagadaChen pode ver?cache: permitidoChen pode ver?lê as tuplasnegado
A linha 2 é o caso contra o qual a documentação adverte: a alteração da tupla “might not be taken in consideration” (pode não ser levada em consideração) se o resultado vier do cache. Um zookie permitiria à aplicação pedir “pelo menos tão atual quanto a minha escrita” (§2.2); aqui a escolha é tudo ou nada.

A documentação sugere decidir por requisição: se a aplicação armazena quando um recurso foi modificado pela última vez, ela pode comparar esse momento com o TTL do cache para escolher entre os dois modos (consistência). Esse timestamp desempenha parte do papel de um zookie, mantido pela aplicação. Também existem flags de invalidação de cache (cache-controller-enabled), que verificam se houve escritas recentes no store.

Diferenças em relação ao artigo

  • Sem zookie. Nenhum token de consistência é retornado ou aceito; dois modos e um cache desativado por padrão o substituem (consistência). O modelo de consistência do artigo se apoia nos zookies (§2.2).
  • As alterações são consultadas periodicamente. ReadChanges retorna uma página de alterações de tuplas “sorted by ascending time” (ordenadas por tempo crescente) com um token de continuação (openfga_service.proto). O Watch do artigo é um stream com heartbeat zookies (§2.4.3).
  • Armazenamento. O artigo usa o Spanner (§3.1). O OpenFGA oferece memory (padrão, “Data is lost between server restarts”, os dados se perdem entre reinicializações do servidor), PostgreSQL (com uma réplica de leitura opcional), MySQL e SQLite (configurar o OpenFGA).
  • Condições. Uma restrição de tipo como [user with non_expired_grant] faz uma tupla contar apenas quando uma condição CEL é satisfeita (condições). A tupla do artigo (§2.1) não tem condição.
  • Tuplas contextuais. Tuplas enviadas com uma única requisição Check, ListObjects, ListUsers ou Expand, “not persisted in the datastore” (não persistidas no repositório de dados) (conceitos, tuplas contextuais).
  • Curingas. [user, user:*] permite uma concessão pública (linguagem de configuração); a gramática de tuplas do artigo não tem curinga (§2.1).
  • Stores e versões de modelo. Um store contém “one or more versions of an authorization model” (uma ou mais versões de um modelo de autorização) e suas tuplas; “Store data cannot be shared across stores” (os dados de um store não podem ser compartilhados entre stores) (conceitos). No artigo, as configurações são armazenadas em uma tabela indexada pelo ID do namespace, ao lado de um changelog de atualizações de configuração, e cada requisição é avaliada em um único timestamp de snapshot da configuração (§3.1.3, §3.2.2). Uma verificação no OpenFGA pode nomear a versão do modelo que utiliza.
  • Sem Leopard. A documentação citada aqui descreve caches de Check e caches de iteradores, não um índice de conjuntos pré-computado como o Leopard (§3.2.4).
  • APIs de listagem. ListObjects, StreamedListObjects e ListUsers estão fora da API do artigo (§2.4).

Situação

Em 2026-11-13: ativo. Versão mais recente v1.22.1 em 2026-10-28; primeira versão v0.1.0 em 2022-06-10; cerca de 6,1 mil estrelas no GitHub; Apache-2.0 (repositório, versões).

  • Junho de 2022: tornou-se código aberto (publicação do projeto, 2026-01-07).
  • 2022: aceito como projeto Sandbox da CNCF. As fontes divergem quanto à data: a página do projeto na CNCF diz que o OpenFGA “was accepted to CNCF on September 14, 2022” (foi aceito na CNCF em 14 de setembro de 2022) e seu anúncio diz setembro de 2022; a publicação do próprio projeto diz dezembro de 2022 (página do projeto na CNCF, CNCF, publicação do projeto).
  • 2025-10-28: passou ao nível de maturidade Incubating, segundo a página do projeto na CNCF.
  • 2025-11-11: a CNCF anuncia que seu Technical Oversight Committee “has voted to accept OpenFGA as a CNCF incubating project” (votou por aceitar o OpenFGA como projeto em incubação da CNCF) (CNCF).
  • O serviço gerenciado é o Auth0 FGA (documentação).

Fontes