system:openfga@es

Ecosistema

OpenFGA

El motor de autorización de la CNCF inspirado en Zanzibar, leído frente al artículo.

Datos verificados el Secciones del artículo §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)
Licencia
Apache-2.0
Lenguaje
Go
Estado
Activo, CNCF Incubating
Última versión
v1.22.1 (2026-10-28)
Repositorio
github.com/openfga/openfga
Documentación
openfga.dev/docs

OpenFGA es un motor de autorización de código abierto. Su documentación dice que la forma JSON de su lenguaje de modelos, la que acepta la API, “closely tracks the language in the Zanzibar paper” (sigue de cerca el lenguaje del artículo de Zanzibar); el DSL añade azúcar sintáctico y se compila a ese JSON (configuration language). La entrada de la CNCF que anuncia su incubación dice que “was developed by a group of Okta employees, and is the foundation for the Auth0 FGA commercial offering” (lo desarrolló un grupo de empleados de Okta y es la base de la oferta comercial Auth0 FGA) (CNCF, 2025-11-11). Está escrito en Go y tiene licencia Apache-2.0 (repositorio). El servicio gestionado de Auth0 se describe a sí mismo como “based on OpenFGA, an open-source project owned by the Cloud Native Computing Foundation” (basado en OpenFGA, un proyecto de código abierto propiedad de la Cloud Native Computing Foundation) (documentación de Auth0 FGA).

Términos del artículo y términos de OpenFGA

La propia documentación de OpenFGA incluye una tabla de “Equivalent Zanzibar Concepts” (conceptos equivalentes de Zanzibar) (configuration language); esta la amplía a la API y al almacenamiento.

En el artículo En OpenFGA
Configuración del espacio de nombres (§2.3) Un type en un modelo de autorización, escrito en el DSL o en JSON (configuration language)
Tupla de relación object#relation@user (§2.1) Relationship tuple con user, relation, object, p. ej. user:anne, owner, doc:readme; un userset se escribe group:eng#member
_this (§2.3.1) Una restricción de tipo directa como [user, group#member] (this en JSON)
computed_userset Un nombre de relación sin más, p. ej. or owner
tuple_to_userset viewer from parent (tupleToUserset en JSON)
union / intersection / exclusion or / and / but not (union / intersection / difference en JSON)
Zookie (§2.4) Ninguno; una consulta elige MINIMIZE_LATENCY o HIGHER_CONSISTENCY (consistency)
Check (§2.4.4) Check, BatchCheck
Read (§2.4.1) Read
Write (§2.4.2) Write
Watch (§2.4.3) ReadChanges, una lectura de lista paginada con un token de continuación (tuple changes)
Expand (§2.4.5) Expand
No está en la API del artículo ListObjects, StreamedListObjects, ListUsers; stores; versiones del modelo (WriteAuthorizationModel, ReadAuthorizationModel(s))
Leopard (§3.2.4) Sin equivalente en la documentación citada aquí
Spanner (§3) memory (el predeterminado), postgres, mysql, sqlite (configure OpenFGA)

Los nombres de la API proceden de openfga_service.proto.

El ejemplo de referencia como modelo

La Figura 1 del artículo hace que los propietarios sean editores, los editores lectores, y los lectores de la carpeta padre lectores del documento (§2.3.1). En el DSL de OpenFGA, las mismas reglas ocupan una línea por relación:

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

Las tuplas de Anne, Beto y 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 cuáles de estas tuplas pasa, para cada persona, una comprobación de viewer sobre el readme?

El ejemplo de referencia como tuplas de OpenFGACinco tuplas. user:anne es owner de doc:readme. user:beto es member de group:eng, y group:eng#member es viewer de doc:readme. user:chen es viewer de folder:A, y folder:A es parent de doc:readme. El camino de Anne está resaltado: owner lleva a editor, que lleva a viewer.user:anneuser:betouser:chengroup:engfolder:Adoc:readmeownermemberviewer(eng#member)viewerparent
Cada flecha es una tupla almacenada. La tupla owner de Anne (resaltada) cuenta como editor y luego como viewer; Beto entra a través del grupo y Chen a través de viewer from parent.

Obsérvese que es el modelo, no una tupla, el que lleva “los propietarios son editores” y “los editores son lectores”: es lo que señala el artículo, que las relaciones entre relaciones pertenecen a la configuración y no a una tupla por objeto (§2.3.1).

Arquitectura

¿En qué consiste un despliegue de OpenFGA? La documentación describe servidores sobre un único almacén de datos SQL. Cada servidor puede mantener cachés en memoria para Check, y la guía de producción aconseja “a small pool of servers with high capacity (memory and CPU cores) instead of a big pool of servers, to increase cache hit ratios” (un grupo pequeño de servidores de gran capacidad, en memoria y núcleos de CPU, en lugar de un grupo grande de servidores, para aumentar las tasas de acierto de la caché) (running in production). Para PostgreSQL puede configurarse un almacén de datos secundario (réplica de lectura); las lecturas HIGHER_CONSISTENCY van a la primaria (configure OpenFGA). Quienes consumen los cambios llaman a ReadChanges y guardan el token de continuación (tuple changes).

Arquitectura de OpenFGAUn cliente de aplicación envía Check a uno de dos servidores OpenFGA mediante gRPC o HTTP. Cada servidor tiene una caché de Check en memoria opcional. Ambos servidores escriben en un almacén de datos PostgreSQL primario y pueden leer de una réplica de lectura opcional, alimentada por la replicación de PostgreSQL. Un consumidor de cambios llama a ReadChanges en un servidor con un token de continuación.Aplicación(cliente gRPC / HTTP)Consumidor de cambios(sondea ReadChanges)Servidor OpenFGA+ caché de CheckServidor OpenFGA+ caché de CheckAlmacén primarioPostgreSQL · MySQL · SQLiteRéplica de lectura(PostgreSQL, opcional)CheckReadChanges + tokenescrituras, HIGHER_CONSISTENCYotras lecturasreplicación
Amarillo: servidores. Verde: almacenes de datos. Azul: clientes. Discontinuo: opcional. La documentación no describe ningún despacho entre servidores.

Compárese con la Figura 2 del artículo (§3): los aclservers se reparten el trabajo entre sí, los watchservers envían un flujo y Leopard mantiene un índice desnormalizado. La documentación de OpenFGA citada aquí no describe ninguno de los tres; los servidores responden a partir del almacén de datos y de sus propias cachés.

Consistencia sin zookies

OpenFGA no tiene zookie. Su documentación lo dice en “Future work” (trabajo futuro): el artículo “has a feature called Zookies” (tiene una función llamada Zookies), y OpenFGA “is considering a similar feature in future releases” (está considerando una función similar para versiones futuras) (consistency). En su lugar, Read y las API de consulta aceptan uno de dos valores:

Modo Comportamiento (documentación de consistencia) Equivalente en el artículo
MINIMIZE_LATENCY (predeterminado) “will serve queries from the cache when possible” (servirá las consultas desde la caché cuando sea posible) Una solicitud sin zookie: “a reasonably recent snapshot” (una instantánea razonablemente reciente) (§2.4.1)
HIGHER_CONSISTENCY “will skip the cache and query the database directly” (se saltará la caché y consultará directamente la base de datos) Ninguno exacto; lo más cercano es evaluar en la instantánea más reciente

La caché está “disabled by default” (desactivada por defecto), y entonces “all queries will have strong consistency regardless of the consistency mode specified” (todas las consultas tendrán consistencia fuerte, sea cual sea el modo de consistencia especificado) (consistency). El modo solo importa una vez activada una caché.

Con la caché activada, ¿puede Chen seguir viendo el readme justo después de que se le quite de la carpeta A?

Caché y modos de consistencia en OpenFGACon la caché de Check activada, una primera comprobación de Chen sobre el readme se permite y se guarda en caché. Después, la aplicación elimina la tupla viewer de Chen sobre la carpeta A. Una segunda comprobación con MINIMIZE_LATENCY puede responderse desde la caché y seguir diciendo permitido. Una tercera comprobación con HIGHER_CONSISTENCY se salta la caché, lee el almacén de datos y se deniega.tiempoAplicaciónServidor OpenFGAAlmacén de datosCheckWrite (borrado)MINIMIZE_LATENCYHIGHER_CONSISTENCY¿puede Chen ver?permitido, en cachéborra la tupla de Chentupla eliminada¿puede Chen ver?caché: permitido¿puede Chen ver?lee las tuplasdenegado
La fila 2 es lo que advierte la documentación: el cambio de tupla “might not be taken in consideration” (podría no tenerse en cuenta) si el resultado viene de la caché. Un zookie permitiría a la aplicación pedir “al menos tan reciente como mi escritura” (§2.2); aquí la elección es todo o nada.

La documentación sugiere decidir por solicitud: si la aplicación almacena cuándo se modificó por última vez un recurso, puede comparar ese momento con el TTL de la caché para elegir entre los dos modos (consistency). Esa marca de tiempo cumple parte del papel de un zookie, y la guarda la aplicación. También existen opciones de invalidación de la caché (cache-controller-enabled), que comprueban si ha habido escrituras recientes en el store.

Diferencias con el artículo

  • Sin zookie. No se devuelve ni se acepta ningún token de consistencia; lo sustituyen dos modos más una caché desactivada por defecto (consistency). El modelo de consistencia del artículo descansa en los zookies (§2.2).
  • Los cambios se sondean. ReadChanges devuelve una página de cambios de tuplas “sorted by ascending time” (ordenados por tiempo ascendente) con un token de continuación (openfga_service.proto). El Watch del artículo es un flujo con zookies de latido (§2.4.3).
  • Almacenamiento. El artículo usa Spanner (§3.1). OpenFGA ofrece memory (predeterminado, “Data is lost between server restarts”, los datos se pierden entre reinicios del servidor), PostgreSQL (con una réplica de lectura opcional), MySQL y SQLite (configure OpenFGA).
  • Condiciones. Una restricción de tipo como [user with non_expired_grant] hace que una tupla solo cuente cuando se cumple una condición CEL (conditions). La tupla del artículo (§2.1) no tiene condición.
  • Tuplas contextuales. Tuplas enviadas con una sola solicitud Check, ListObjects, ListUsers o Expand, “not persisted in the datastore” (no persistidas en el almacén de datos) (concepts, contextual tuples).
  • Comodines. [user, user:*] permite una concesión pública (configuration language); la gramática de tuplas del artículo no tiene comodín (§2.1).
  • Stores y versiones del modelo. Un store contiene “one or more versions of an authorization model” (una o varias versiones de un modelo de autorización) y sus tuplas; “Store data cannot be shared across stores” (los datos de un store no pueden compartirse entre stores) (concepts). En el artículo, las configuraciones se almacenan en una tabla con el ID del espacio de nombres como clave, junto a un registro de cambios de las actualizaciones de configuración, y cada solicitud se evalúa en una única marca de tiempo de instantánea de la configuración (§3.1.3, §3.2.2). En OpenFGA, una comprobación puede nombrar la versión del modelo que usa.
  • Sin Leopard. La documentación citada aquí describe cachés de Check y cachés de iteradores, no un índice de conjuntos precalculado como Leopard (§3.2.4).
  • API de listado. ListObjects, StreamedListObjects y ListUsers quedan fuera de la API del artículo (§2.4).

Estado

A 2026-11-13: activo. Última versión v1.22.1 el 2026-10-28; primera versión v0.1.0 el 2022-06-10; unas 6.1k estrellas en GitHub; Apache-2.0 (repositorio, versiones).

  • Junio de 2022: publicado como código abierto (entrada del proyecto, 2026-01-07).
  • 2022: aceptado como proyecto CNCF Sandbox. Las fuentes discrepan sobre la fecha: la página del proyecto en la CNCF dice que OpenFGA “was accepted to CNCF on September 14, 2022” (fue aceptado en la CNCF el 14 de septiembre de 2022) y su anuncio dice septiembre de 2022; la entrada del propio proyecto dice diciembre de 2022 (página del proyecto en la CNCF, CNCF, entrada del proyecto).
  • 2025-10-28: pasa al nivel de madurez Incubating, según la página del proyecto en la CNCF.
  • 2025-11-11: la CNCF anuncia que su Technical Oversight Committee “has voted to accept OpenFGA as a CNCF incubating project” (ha votado aceptar OpenFGA como proyecto en incubación de la CNCF) (CNCF).
  • El servicio gestionado es Auth0 FGA (documentación).

Fuentes