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?
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).
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?
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.
ReadChangesdevuelve 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,StreamedListObjectsyListUsersquedan 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
- https://github.com/openfga/openfga
- https://github.com/openfga/openfga/releases
- https://openfga.dev/docs
- https://openfga.dev/docs/concepts
- https://openfga.dev/docs/configuration-language
- https://openfga.dev/docs/interacting/consistency
- https://openfga.dev/docs/interacting/read-tuple-changes
- https://openfga.dev/docs/interacting/contextual-tuples
- https://openfga.dev/docs/modeling/conditions
- https://openfga.dev/docs/best-practices/running-in-production
- https://openfga.dev/docs/getting-started/setup-openfga/configure-openfga
- https://github.com/openfga/api/blob/main/openfga/v1/openfga_service.proto
- https://github.com/openfga/sample-stores/blob/main/stores/gdrive/model.fga
- https://openfga.dev/blog/incubation-announcement
- https://www.cncf.io/blog/2025/11/11/openfga-becomes-a-cncf-incubating-project/
- https://www.cncf.io/projects/openfga/
- https://docs.fga.dev/fga