Políticas de acceso como código

Unos 32 minutos de lectura, con 13 ejemplos en 11 secciones.

Edición 2026.11.31 Ejemplos verificados el 19 de nov de 2026 108 de 108 ejemplos pasan Qué ha cambiado

Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros

Traducido del libro en inglés, edición 2026.11.31. Lee el original

Al final de este capítulo podrás escribir las reglas de acceso de una plataforma de datos como una sola política que deniega por defecto y devuelve los filtros de filas y las máscaras de columnas como datos. La política permite según el rol y restringe según el atributo, y un motor puede aplicar toda su decisión. La escribirás en Rego, el lenguaje de políticas de Open Policy Agent (OPA), la probarás como lo hace opa test, el ejecutor de pruebas de OPA, la comprobarás con una tabla de quién ve qué que los propietarios de los datos pueden leer, sabrás en qué se diferencia de OPA el motor en proceso que usa este libro, y verás las mismas reglas en Cedar, un lenguaje de políticas más acotado.

Cada grupo que lee el almacén de datos de la plataforma, desde los agentes de soporte hasta el asistente de cursos, necesita algo distinto. Los agentes de soporte atienden cada uno una región, americas, emea o apac, y necesitan los datos de contacto de los alumnos para responder tickets. Los instructores ven los alumnos y las reseñas de sus propios cursos, sin datos de contacto. Marketing solo puede acceder a alumnos que aceptaron el correo de marketing. Finanzas concilia los pagos, y la columna heredada card_number de billing.payments nunca debe mostrar más que sus últimos cuatro dígitos. Los científicos de datos ven learner_id tal como está almacenado, para unir tablas por él, con las columnas personales seudonimizadas y el texto libre redactado. El asistente de cursos lee solo las reseñas cuyos autores aceptaron el entrenamiento con IA. El capítulo 1 mostró una regla, los agentes de soporte solo ven su propia región, y la aplicó a una consulta. Las reglas de todos los grupos deben estar en un solo lugar, enunciadas con exactitud y probadas antes de que alguien dependa de ellas.

Los términos de este capítulo son los que usa el resto del libro. Una política es código que responde si una solicitud puede continuar. Una decisión es la respuesta de una política. El principal es quien pide, un rol es un grupo de principales con el mismo trabajo, y un atributo es cualquier otro hecho que una regla lee, sobre el principal, los datos o la solicitud. Un filtro de filas limita qué filas devuelve una consulta, y una máscara de columna cambia cómo se muestran los valores de una columna, como la seudonimización, que reemplaza un identificador por un sustituto consistente.

La política de la plataforma es governance/policies/access.rego, y sus pruebas están en governance/policies/access_test.rego. El módulo compartido del libro, lib.policy, carga ambas en regopy 1.5.2, el enlace de Python a rego-cpp, la implementación en C++ de Rego de Microsoft, que evalúa las políticas dentro del propio proceso de Python sin necesidad de ejecutar un servidor.

Da a la solicitud la forma de las de Trino

Último cambio en la edición 2026.11.27

Un motor de políticas responde preguntas sobre requests, así que la forma de un request decide qué sistemas pueden hacer la pregunta. La premisa de OPA es que la política se saca del servicio que la aplica: OPA "te permite desacoplar la política de ese servicio de software", de modo que pueda leerse, versionarse y probarse por separado (filosofía de OPA). El servicio envía un documento JSON que describe la solicitud, y la política lo lee como input. Trino, un motor SQL de código abierto, hace exactamente esto: para cada comprobación de acceso que necesita una consulta, su plugin de OPA envía un documento con context.identity, el usuario y sus grupos, y action, la operación y el recurso, hasta el catálogo, el esquema, la tabla y las columnas (Trino 484, control de acceso con OPA).

La política de la plataforma lee los mismos campos, así que decide la solicitud de Trino de leer columnas, SelectFromColumns, tal como Trino la envía. Trino necesita más que esa decisión. Quiere cada filtro de filas y máscara de columnas como SQL, un filtro de filas como {"expression": "clause"}, donde la política devuelve una columna y un valor (Trino 484, control de acceso con OPA). También pregunta por otras comprobaciones, como ExecuteQuery y AccessCatalog, que el allow de esta política deniega (OpaAccessControl.java en Trino 484). El capítulo 6 muestra lo que debe devolver un módulo junto a la política para esas comprobaciones. lib.policy.request construye las solicitudes de la plataforma con la forma de Trino, y el siguiente ejemplo la usa para un agente de soporte de emea, agent-a05, que lee tres columnas de support.tickets:

trino-shaped-request.py Python 3.12.15 · pyarrow 26.0.1 · pyiceberg 0.12.0 · regopy 1.5.2 Superado
"""The request a support agent's read sends the policy, shaped as Trino's OPA plugin sends it. The point rests on the printed `action`: the operation SelectFromColumns, and the table with the columns the query reads."""import jsonfrom lib import policy# A support agent's query reads three columns of the tickets table: the request Trino's OPA plugin would send for it.# no groups here, because the policy reads them from users.toml; no purpose either, since request adds one only when givenrequest = policy.request("agent-a05", "support.tickets", ["ticket_id", "opened_at", "body"])print(json.dumps(request, indent=2))
Salidapython trino-shaped-request.py
{
  "context": {
    "identity": {
      "user": "agent-a05"
    }
  },
  "action": {
    "operation": "SelectFromColumns",
    "resource": {
      "table": {
        "catalogName": "platform",
        "schemaName": "support",
        "tableName": "tickets",
        "columns": [
          "ticket_id",
          "opened_at",
          "body"
        ]
      }
    }
  }
}

La operación es SelectFromColumns, el nombre que Trino da a una lectura, y la tabla aparece bajo action.resource.table con su catálogo, esquema, nombre y las columnas que toca la consulta. La solicitud de la plataforma difiere de la de Trino en dos puntos que importan. Omite context.identity.groups, porque la política busca los grupos de un usuario en el mismo archivo que sus atributos, governance/users.toml, de modo que las pruebas y la política leen una única fuente de verdad. Y puede incluir un purpose en el nivel superior, como ai-training, que Trino no envía. Detrás de Trino, recomendamos derivar el propósito de la identidad, por ejemplo dando a la canalización de entrenamiento un usuario de servicio propio, en lugar de confiar en un valor que fija el cliente.

Regla práctica: Da a la entrada de la política la forma de las solicitudes del motor que la aplicará, campo por campo, y añade solo lo que ese motor no puede enviar, en el nivel superior, donde lo ve un revisor. Si tu motor no es Trino, parte en cambio de su formato de solicitud, y mantén la forma en una sola función, como hace lib.policy.request, para que las pruebas y quienes llaman no se desalineen.

Genera los datos que lee la política

Último cambio en la edición 2026.11.31

La solicitud indica quién pide qué. Todo lo demás que una regla necesita además de la solicitud, como los grupos de cada usuario y la clasificación de cada columna, proviene de un segundo documento, que OPA llama data. Un dato de ese documento es tan actual como su fuente, y cada dato que lee la política de la plataforma ya tiene un responsable. Los usuarios y sus atributos viven en governance/users.toml. La clasificación de cada columna vive en governance/metadata.toml, el archivo de metadatos revisado que el capítulo 2 indexa por el ID de campo de Iceberg. Y qué instructor imparte qué curso está en la propia tabla learning.courses. Escribir cualquiera de estos datos en la política, o copiarlos en un segundo archivo, crea una copia que alguien tiene que acordarse de actualizar.

lib.policy.data_document construye el documento a partir de esas tres fuentes cada vez que se carga una política, y nunca a partir de algo escrito a mano:

generated-policy-data.py Python 3.12.15 · pyarrow 26.0.1 · pyiceberg 0.12.0 · regopy 1.5.2 Superado
"""The data the policy reads besides the request, built from the files that own each fact. The point rests on the last two lines: instructor 17's courses come from learning.courses, not from anything typed."""from lib import policy# What the policy reads besides the request, built from the files that own each fact.# the document's one top-level key, which the policy reads as data.platformdata = policy.data_document()["platform"]print("users, from governance/users.toml:", len(data["users"]))print("agent-a05:", data["users"]["agent-a05"])print("instructor-17:", data["users"]["instructor-17"])classifications = data["classifications"]print("tables, from governance/metadata.toml:", len(classifications))print("columns classified:", sum(len(columns) for columns in classifications.values()))print("crm.learners.email:", classifications["crm.learners"]["email"])print("billing.payments.card_number:", classifications["billing.payments"]["card_number"])courses = data["instructor_courses"]print("instructors with courses, from learning.courses:", len(courses))# instructor IDs are string keys in the document, so the lookup is "17"print("instructor 17's courses:", courses["17"])
Salidapython generated-policy-data.py
users, from governance/users.toml: 8
agent-a05: {'groups': ['support'], 'region': 'emea'}
instructor-17: {'groups': ['instructor'], 'instructor_id': 17}
tables, from governance/metadata.toml: 10
columns classified: 77
crm.learners.email: personal
billing.payments.card_number: sensitive
instructors with courses, from learning.courses: 48
instructor 17's courses: [2, 75, 80, 87, 103, 134]

Cada dato del documento proviene del archivo o la tabla que lo posee, y la salida etiqueta cada recuento con su fuente: los usuarios de governance/users.toml, las columnas clasificadas de las tablas de governance/metadata.toml, y los instructores de learning.courses. agent-a05 tiene un grupo y una región, y instructor-17 un grupo y un ID de instructor, pero nada en users.toml indica qué cursos imparte el instructor 17. El documento encuentra [2, 75, 80, 87, 103, 134] en learning.courses. Cuando la plataforma publique otro de sus cursos, el filtro de filas del instructor lo incluirá la próxima vez que se generen los datos de la política, sin editar nada en ningún sitio. Una clasificación funciona de la misma manera: cambiar card_number de sensitive requeriría un único cambio revisado en metadata.toml, y la política lo seguiría.

Regla práctica: Genera los datos de la política a partir del archivo o la tabla que posee cada dato, cada vez que cargues la política, y nunca copies un dato en la política ni en un segundo archivo. Cuando un dato todavía no tiene responsable, como la región de un agente de soporte, asígnale un único archivo, revisado como si fuera código, tal como hace la plataforma con users.toml.

Denegar por defecto, luego permitir por rol

Último cambio en la edición 2026.11.31

Con la solicitud y sus datos en su lugar, lo primero que una política debe resolver es qué ocurre con una solicitud que ninguna regla previó. El principio de valores predeterminados seguros de Saltzer y Schroeder consiste en "basar las decisiones de acceso en el permiso y no en la exclusión" (Saltzer y Schroeder, 1975). En Rego, eso es un valor predeterminado. Una regla cuyo cuerpo nunca se evalúa como verdadero no tiene valor, lo que Rego llama indefinido, y OPA usa el valor predeterminado cuando todas las reglas que comparten un nombre están indefinidas (lenguaje de políticas de OPA). Con default allow := false, una solicitud que ninguna regla allow cubre se deniega, sin importar quién la envíe ni lo que pida.

El control de acceso basado en roles, formalizado por primera vez por Ferraiolo y Kuhn en 1992, concede acceso según el cargo que ocupa un principal y no según quién es. En la plataforma, un rol es un grupo en users.toml, y el objeto readable de la política asocia cada grupo con las tablas que puede leer. Una solicitud se permite cuando es una lectura, algún grupo del usuario puede leer la tabla y no falta nada de lo que dependen los filtros de filas del grupo:

default allow := false

allow if {
	input.action.operation == "SelectFromColumns"
	readable_by_a_group
	not missing_attribute
}

La última línea protege contra un fallo que la sección sobre producción muestra al eliminarla. Imprime el mapa y decide cuatro solicitudes para ver el valor predeterminado en acción:

allow-by-role.py Python 3.12.15 · pyarrow 26.0.1 · pyiceberg 0.12.0 · regopy 1.5.2 Superado
"""Which groups may read which tables, then four requests decided by the default-deny policy. The points rest on the four decisions and their reasons, printed last."""from lib import policyrego = policy.interpreter()# The groups the policy knows, and the tables each may read: the role part of the policy.readable = policy.evaluate(rego, "data.platform.access.readable", {})for group, tables in readable.items():    print(f"{group} may read:", ", ".join(tables))# Who may read what. Anything no rule allows is denied, including a user or an operation the policy has never seen.requests = [    policy.request("finance-1", "billing.payments", ["amount"]),    policy.request("marketing-1", "billing.payments", ["amount"]),    policy.request("someone-else", "crm.learners", ["learner_id"]),]delete = policy.request("finance-1", "billing.payments", ["amount"])# the same request as finance's read, asking to delete insteaddelete["action"]["operation"] = "DeleteFromTable"for request in requests + [delete]:    decision = policy.decide(request, rego)    who, table = request["context"]["identity"]["user"], request["action"]["resource"]["table"]    print(f"{who}, {request['action']['operation']} on {table['schemaName']}.{table['tableName']}:",          "allowed" if decision["allow"] else "denied", "|", "; ".join(decision["reasons"]))
Salidapython allow-by-role.py
ai may read: learning.courses, learning.reviews
data-science may read: analytics.course_performance, analytics.learner_activity, billing.payments, crm.learners, learning.courses, learning.enrollments, learning.events, learning.reviews
finance may read: billing.payments, learning.courses, learning.enrollments
instructor may read: learning.courses, learning.enrollments, learning.reviews
marketing may read: crm.learners, learning.courses, marketing.audience
support may read: crm.learners, support.tickets
finance-1, SelectFromColumns on billing.payments: allowed | finance may read billing.payments
marketing-1, SelectFromColumns on billing.payments: denied | no group of this user may read this table
someone-else, SelectFromColumns on crm.learners: denied | no group of this user may read this table
finance-1, DeleteFromTable on billing.payments: denied | DeleteFromTable is not an operation this policy allows

Solo se permite lo que una regla concede. Finanzas puede leer billing.payments, y el motivo indica el grupo que lo permitió. Marketing no puede, y tampoco someone-else, un usuario que la política nunca ha conocido, porque nada les concede nada. La cuarta solicitud es de finanzas otra vez, pero para eliminar en lugar de leer. Ninguna regla menciona DeleteFromTable, así que también se deniega, y el motivo lo explica. Una política que intentara enumerar lo prohibido habría necesitado una regla para esa operación; esta no necesita ninguna. Cada decisión lleva sus motivos, de modo que una denegación puede explicarse a la persona afectada y registrarse.

Regla práctica: Empieza cada política con default allow := false, y permite solo mediante reglas que nombren el rol y el recurso. Mantén el mapa de roles a tablas en un solo lugar, donde un revisor pueda leerlo completo de una vez, y da a cada decisión un motivo. Cuando se deniega una solicitud que debería haberse permitido, añade una regla que la permita; nunca debilites el valor predeterminado.

Filtrar por atributo: región, consentimiento y finalidad

Último cambio en la edición 2026.11.31

Los roles indican qué tablas puede leer un grupo; no pueden indicar qué filas. La guía de NIST sobre control de acceso basado en atributos define el enfoque general, en el que el acceso se decide según atributos del sujeto, del objeto, de las operaciones solicitadas y, a veces, del entorno. Considera el rol como uno de esos atributos (NIST SP 800-162). La alternativa, un rol para cada combinación, es lo que la guía de NIST llama «explosión de roles».

La plataforma muestra por qué. El soporte por región necesitaría tres roles de soporte, y añadir el consentimiento de marketing y una finalidad para el entrenamiento de IA multiplicaría de nuevo los roles. En su lugar, la política mantiene un rol por puesto y lee tres atributos. La región es un atributo del principal, a partir de users.toml. El consentimiento es un atributo de los datos: las columnas marketing_consent y ai_training_consent de crm.learners. La finalidad es un atributo de la solicitud. Cada uno se convierte en un filtro de filas, una condición estructurada sobre una columna que el motor añade a la consulta. El filtro del agente de soporte lee la región del agente:

row_filters contains {"column": "support_region", "equals": user.region} if {
	"support" in groups
	table in {"crm.learners", "support.tickets"}
}

Las lecturas de agentes de soporte, de un instructor, de marketing y de un científico de datos muestran lo que hace cada atributo, leyendo la científica de datos las reseñas dos veces, una sin finalidad y otra para ai-training:

attributes-as-row-filters.py Python 3.12.15 · pyarrow 26.0.1 · pyiceberg 0.12.0 · regopy 1.5.2 Superado
"""Row filters the policy builds for seven reads, from three attributes: the agent's region, the learner's consent and the request's purpose. The points rest on the analyst's two review reads, with and without a purpose."""import jsonfrom lib import policyrego = policy.interpreter()# Region is the agent's attribute, consent the learner's, and purpose the request's. Each becomes a row filter.reads = [    ("agent-a01", "support.tickets", ["ticket_id"], None),    ("agent-a05", "support.tickets", ["ticket_id"], None),    ("agent-a09", "support.tickets", ["ticket_id"], None),    ("instructor-17", "learning.reviews", ["rating"], None),    ("marketing-1", "crm.learners", ["email"], None),    ("analyst-1", "learning.reviews", ["rating", "body"], None),    # the same read with a purpose, the one attribute the requester supplies    ("analyst-1", "learning.reviews", ["rating", "body"], "ai-training"),]for user, table, columns, purpose in reads:    decision = policy.decide(policy.request(user, table, columns, purpose), rego)    who = user + (f" for {purpose}" if purpose else "")    # json shows the consent filter with its learner_consented key, not a column    print(f"{who} reads {table}, row filters:", json.dumps(decision["row_filters"]))    if "body" in columns:        print(f"{who} reads {table}, body shown as:", decision["column_masks"]["body"])
Salidapython attributes-as-row-filters.py
agent-a01 reads support.tickets, row filters: [{"column": "support_region", "equals": "americas"}]
agent-a05 reads support.tickets, row filters: [{"column": "support_region", "equals": "emea"}]
agent-a09 reads support.tickets, row filters: [{"column": "support_region", "equals": "apac"}]
instructor-17 reads learning.reviews, row filters: [{"column": "course_id", "in": [2, 75, 80, 87, 103, 134]}]
marketing-1 reads crm.learners, row filters: [{"column": "marketing_consent", "equals": true}, {"column": "status", "equals": "active"}]
analyst-1 reads learning.reviews, row filters: []
analyst-1 reads learning.reviews, body shown as: redact
analyst-1 for ai-training reads learning.reviews, row filters: [{"learner_consented": "ai_training_consent"}]
analyst-1 for ai-training reads learning.reviews, body shown as: redact_contacts

La finalidad es lo que cambia la vista de una científica de datos sobre el texto de las reseñas. Sin finalidad, todas las reseñas son visibles, pero el texto, body, se muestra como redact. Para ai-training, solo permanecen las reseñas de estudiantes que aceptaron el entrenamiento de IA, y el texto vuelve como redact_contacts, sin datos de contacto. Los tres agentes reciben la misma regla con un valor por región, desde un solo rol, y el filtro de la instructora 17 enumera sus cursos, generado a partir de learning.courses. Marketing recibe dos filtros, consentimiento otorgado y cuenta activa, y el motor aplica ambos. El filtro de entrenamiento de IA, learner_consented, comprueba el autor de la reseña, no la reseña, así que aplicarlo exige una unión con crm.learners. Un estudiante que se registró antes de que la plataforma preguntara por el entrenamiento de IA no tiene respuesta en ai_training_consent, según la ficha de datos de la plataforma, por lo que aplicar el filtro debe tratar una respuesta desconocida como un no.

La finalidad es el único atributo que aporta el solicitante, así que solo revela más bajo una condición más estrecha: indicar ai-training muestra el texto de las reseñas, pero solo para los estudiantes que consienten y sin datos de contacto. Omitirla, o indicar cualquier otra finalidad, obtiene de todos modos lo que permite el rol, con el texto oculto.

Regla práctica: Modela cada condición como un atributo del principal, de los datos o de la solicitud, leído mediante una regla por rol, en lugar de como otro rol. Cuando un atributo proviene del solicitante, como ocurre con una finalidad, deja que desbloquee el acceso solo bajo una condición más estrecha, de modo que omitirlo, o indicarlo mal, recaiga en lo que el rol permite de todos modos.

Devuelve la decisión como un solo documento

Último cambio en la edición 2026.11.31

Un sí o un no no puede transmitir los filtros de filas que producen los atributos. Una decisión de Rego no tiene por qué ser sí o no, porque las políticas de OPA pueden representar decisiones como datos estructurados, desde booleanos hasta mapas de listas de mapas (filosofía de OPA). La política de la plataforma usa datos estructurados para devolver toda su respuesta como un solo documento, data.platform.access.decision, con cuatro claves: allow, los row_filters, las column_masks y los reasons. lib.policy.decide la pide con una sola consulta y la devuelve como un diccionario de Python.

Los filtros y las máscaras son datos, nunca SQL. Un filtro indica una columna y un valor o una lista de valores, o, en el caso del consentimiento, la columna de consentimiento del alumno. Una máscara es un nombre, uno de redact, last4, pseudonymize y redact_contacts. Lo que aplica la decisión convierte cada uno en SQL con su propio código, de modo que nada de lo que contenga una solicitud o un registro de usuario, como una región escrita en users.toml, puede llegar a una consulta como texto SQL. Las máscaras siguen la clasificación de cada columna. Las columnas sensibles se ocultan a todos, excepto los últimos cuatro dígitos de un número de tarjeta, que ve finanzas. Las columnas personales se muestran a soporte, que necesita los datos de contacto, y se enmascaran para los demás según lo que exija su trabajo. Y una columna que los metadatos no clasifican se considera sensible:

classification(column) := level if {
	level := data.platform.classifications[table][column]
} else := "sensitive"

Supón que marketing lee cuatro columnas de crm.learners, tres de ellas clasificadas en los metadatos. La cuarta, linkedin_url, representa una columna que una canalización ha añadido y que nadie ha clasificado todavía:

one-decision-document.py Python 3.12.15 · pyarrow 26.0.1 · pyiceberg 0.12.0 · regopy 1.5.2 Superado
"""The whole decision for one read: marketing's four columns of crm.learners, one of them unclassified. The point rests on the masks and the reasons, which give one line per mask and per group that allowed the read."""import jsonfrom lib import policy# Marketing reads four columns of crm.learners. `linkedin_url` stands for a column added to the table and not yet# classified in governance/metadata.toml.request = policy.request("marketing-1", "crm.learners", ["full_name", "email", "phone", "linkedin_url"])# with no interpreter given, decide loads the platform's policy itselfdecision = policy.decide(request)print(json.dumps(decision, indent=2))print("keys:", ", ".join(sorted(decision)))
Salidapython one-decision-document.py
{
  "allow": true,
  "column_masks": {
    "linkedin_url": "redact",
    "phone": "redact"
  },
  "reasons": [
    "linkedin_url is sensitive, shown as redact",
    "marketing may read crm.learners",
    "phone is personal, shown as redact"
  ],
  "row_filters": [
    {
      "column": "marketing_consent",
      "equals": true
    },
    {
      "column": "status",
      "equals": "active"
    }
  ]
}
keys: allow, column_masks, reasons, row_filters

Marketing obtiene la lectura, con sus dos filtros de filas, y dos de las cuatro columnas aparecen enmascaradas. phone es personal, y marketing no la necesita para el correo electrónico. linkedin_url no está clasificada, así que se trata como sensible hasta que alguien la revise. full_name y email no tienen máscara, y una columna sin máscara se muestra tal como está almacenada, que es lo que marketing necesita para enviar un correo. Las razones ofrecen una línea por cada grupo que permitió la lectura y una por cada máscara, de modo que el documento se explica por sí mismo. Una denegación lleva filtros y máscaras vacíos, porque la política construye los dos resultados con reglas separadas, así que nada posterior puede confundir una denegación con una lectura con algunas columnas enmascaradas.

Regla práctica: Devuelve un documento de decisión por solicitud, que contenga la autorización, los filtros de filas, las máscaras de columnas y las razones, y léelo como un todo. Mantén los filtros y las máscaras como nombres y valores que tu código de cumplimiento traduce, nunca como SQL que escribe la política. Si un motor necesita SQL de la política, como hace Trino con sus filtros de filas y máscaras de columnas (Trino 484, control de acceso con OPA), genéralo en una única función probada entre ambos.

Prueba unitaria de la política en Rego

Último cambio en la edición 2026.11.27

El documento de decisión es lo que una prueba puede comparar, lo cual importa porque una política decide quién ve datos personales, y un cambio en ella puede ampliar el acceso sin que nadie lo note en un diff. La respuesta de OPA son pruebas escritas en Rego: una prueba es una regla cuyo nombre lleva el prefijo test_, y "Si la regla de prueba está indefinida o genera un valor distinto de verdadero, el resultado de la prueba se informa como FAIL" (prueba de políticas de OPA). Una prueba prepara su solicitud con with, que reemplaza una parte de input o de data para una sola expresión.

El motor del libro, regopy, no tiene opa test, así que lib.policy.run_tests cumple ese papel. Encuentra cada regla test_ en los archivos _test.rego de la carpeta, evalúa cada una e informa PASS cuando la regla es verdadera, FAIL cuando es falsa o está indefinida, y ERROR cuando la evaluación falla. Cada prueba de la plataforma fija el usuario y la acción como dos rutas separadas, cada una con un valor literal, por razones que la sección sobre regopy muestra:

test_finance_sees_only_the_last_four_digits if {
	decision := access.decision with input.context.identity.user as "finance-1"
		with input.action as {"operation": "SelectFromColumns", "resource": {"table": {"schemaName": "billing", "tableName": "payments", "columns": ["amount", "card_number"]}}}
	decision.allow
	decision.row_filters == []
	decision.column_masks == {"card_number": "last4"}
}

Las pruebas cubren el permiso de acceso, los filtros y las máscaras de cada grupo, y las formas en que se deniega una solicitud: una tabla que el grupo no tiene asignada, una operación distinta de una lectura, un usuario que la política no conoce y un agente de soporte sin región.

policy-unit-tests.py Python 3.12.15 · pyarrow 26.0.1 · pyiceberg 0.12.0 · regopy 1.5.2 Superado
"""Runs every test in the platform's Rego test file and counts the passes. The point rests on the last line, the tests passed out of all of them."""from collections import Counterfrom lib import policy# Every `test_` rule in governance/policies/access_test.rego, run by name: PASS, FAIL or ERROR, as `opa test` reports.results = policy.run_tests()for test, result in results.items():    print(f"{result}: {test}")# len(results) counts every test, so one that fails or errors still shows in the totalprint("tests passed:", f"{Counter(results.values())['PASS']} of {len(results)}")
Salidapython policy-unit-tests.py
PASS: test_support_reads_only_its_own_region
PASS: test_support_without_a_region_is_denied
PASS: test_marketing_sees_only_consenting_active_learners
PASS: test_a_group_only_reads_its_own_tables
PASS: test_finance_sees_only_the_last_four_digits
PASS: test_data_science_never_sees_card_numbers
PASS: test_data_science_sees_pseudonyms_not_people
PASS: test_an_unclassified_column_is_hidden
PASS: test_an_unknown_user_is_denied
PASS: test_an_instructor_sees_only_their_courses
PASS: test_the_assistant_reads_only_consented_reviews
PASS: test_training_reads_only_consented_reviews_without_contacts
tests passed: 12 of 12

Una prueba que solo comprueba decision.allow dejaría pasar la mayoría de los errores, así que cada prueba de una lectura permitida compara completos los filtros de fila y las máscaras de columna. En la prueba de finanzas, decision.row_filters == [] falla si la política añade cualquier filtro a las lecturas de finanzas, y decision.column_masks == {"card_number": "last4"} falla si enmascara una columna de más o de menos, o si muestra el número de tarjeta de otra manera. En la ejecución pasan 12 of 12 pruebas.

Regla práctica: Escribe una prueba para cada regla que conceda o restrinja el acceso, y una para cada forma en que una solicitud puede ser denegada, y compara filtros y máscaras completos, no claves sueltas. Ejecuta las pruebas con cada cambio en la política y en los datos que la política lee.

Revisa quién ve qué a partir de una tabla de decisiones

Último cambio en la edición 2026.11.31

Las pruebas unitarias las escribe en Rego quien escribe la política. Las personas que son dueñas de los datos, como el responsable de soporte o el equipo de finanzas, también deberían poder revisar la política, sin tener que leer Rego. Una tabla de decisiones tiene una fila por solicitud, e indica quién lee qué tabla y qué debe recibir de vuelta, en los términos de su trabajo.

La tabla de la plataforma es lib.policy.WHO_SEES_WHAT, una lista de filas en Python. Cada fila indica un usuario, una tabla, las columnas que se leen y un propósito opcional; después, si la lectura está permitida, qué columnas prueban los filtros de la fila y cuáles se enmascaran, y de qué manera. Cada fila pasa por lib.policy.decide, que devuelve el documento de decisión, y el ejemplo imprime una línea por fila, en la forma que sirve para mostrárselo a los dueños de los datos:

who-sees-what.py Python 3.12.15 · pyarrow 26.0.1 · pyiceberg 0.12.0 · regopy 1.5.2 Superado
"""Each row of the who-sees-what table run through the policy and printed as one line, with the count of rows the policy matches. The point rests on the last line, the count of rows whose decision matches the outcome its row expects."""from lib import policyrego = policy.interpreter()# Each row of lib.policy.WHO_SEES_WHAT is a request and the decision a reviewer expects for it.matching = 0for case in policy.WHO_SEES_WHAT:    decision = policy.decide(policy.request(case.user, case.table, case.columns, case.purpose), rego)    # matches returns True or False, which add as 1 or 0    matching += policy.matches(case, decision)    who = case.user + (f" ({case.purpose})" if case.purpose else "")    shown = "allowed" if decision["allow"] else "denied"    # a consent filter has no column key, so filtered_on reads its learner_consented key    filters = ", ".join(policy.filtered_on(decision)) or "-"    masks = ", ".join(f"{column}: {mask}" for column, mask in decision["column_masks"].items()) or "-"    print(f"{who:26} {case.table:17} {shown:8} rows: {filters:29} masks: {masks}")print("rows of the table the policy matches:", f"{matching} of {len(policy.WHO_SEES_WHAT)}")
Salidapython who-sees-what.py
agent-a05                  crm.learners      allowed  rows: support_region                masks: -
agent-a05                  billing.payments  denied   rows: -                             masks: -
instructor-17              learning.reviews  allowed  rows: course_id                     masks: body: redact_contacts
instructor-17              crm.learners      denied   rows: -                             masks: -
marketing-1                crm.learners      allowed  rows: marketing_consent, status     masks: phone: redact
finance-1                  billing.payments  allowed  rows: -                             masks: card_number: last4
analyst-1                  billing.payments  allowed  rows: -                             masks: card_number: redact
analyst-1                  crm.learners      allowed  rows: -                             masks: email: pseudonymize, notes: redact
analyst-1                  learning.reviews  allowed  rows: -                             masks: body: redact
analyst-1 (ai-training)    learning.reviews  allowed  rows: ai_training_consent           masks: body: redact_contacts
assistant-1                learning.reviews  allowed  rows: ai_training_consent           masks: body: redact_contacts
someone-else               crm.learners      denied   rows: -                             masks: -
rows of the table the policy matches: 12 of 12

Recorre la tabla de arriba abajo y las reglas de cada rol se hacen visibles como resultados. La política coincide con las 12 of 12 filas: el agente de soporte filtrado por región y sin acceso a los pagos; el instructor filtrado por curso y sin acceso a la tabla de alumnos; finanzas viendo card_number como last4, mientras que el científico de datos lo ve como redact; y las dos lecturas de las reseñas por parte del científico de datos, con y sin propósito. Un revisor que crea que una fila es incorrecta puede indicarlo en una solicitud de cambios sin necesidad de saber qué regla la produjo.

Regla práctica: Mantén en el repositorio, junto con la política, una tabla de quién ve qué, ejecútala con las pruebas unitarias y muestra su forma impresa a los dueños de los datos, en términos que puedan comprobar. Cuando un dueño no esté de acuerdo con una fila, cambia primero la fila, y deja que la fila que falla determine el cambio en la política.

Conoce las diferencias entre regopy y OPA

Último cambio en la edición 2026.11.27

Las pruebas de la plataforma se ejecutan en regopy porque los ejemplos del libro deben funcionar sin conexión, en segundos y dentro de Python, y OPA es un programa aparte. regopy 1.5.2 es muy parecido a OPA. Su motor declara que soporta Rego v1.18.1 tal como lo define OPA, y que supera todas las suites de pruebas no integradas que OPA publica. Su README enumera las funciones integradas que no soporta, como net.* y http.send (README de rego-cpp en v1.5.2), pero regopy también difiere de OPA de maneras que ese README no enumera. La política y las pruebas de la plataforma evitan cada uno de los casos siguientes, y el propio OPA es la referencia para cualquier cosa que esté en producción.

El primer grupo se ejecuta sin ningún error:

regopy-silent-differences.py Python 3.12.15 · regopy 1.5.2 Superado
"""Small policies that regopy answers differently from OPA, each printed with the answer regopy gives. The prose's points rest on the printed values, and the bound and literal-mock lines are the controls where regopy agrees with OPA."""import jsonfrom regopy import Input, Interpreterdef ask(rules: str, query: str, request: dict) -> str:    """One query's answer from regopy: the value bound to x, or "undefined"."""    rego = Interpreter()    rego.add_module("example", "package example\n" + rules)    rego.set_input(Input(request))    output = str(rego.query(query))    # regopy writes undefined as a bare word; otherwise the binding for x is the answer    return output if output == "undefined" else json.dumps(json.loads(output)["bindings"]["x"])admins_only = 'default allow := false\nallow if input.user == "admin"\n'# no variable in the queryprint("a false decision, queried on its own:", ask(admins_only, "data.example.allow", {"user": "guest"}))# bound to x, the same false decision comes back as a valueprint("the same decision, bound to a variable:", ask(admins_only, "x := data.example.allow", {"user": "guest"}))pre_1_0 = 'allow { input.user == "admin" }\n'                      # no `if`: OPA 1.x refuses to load thisprint("a rule in pre-1.0 syntax:", ask(pre_1_0, "x := data.example.allow", {"user": "admin"}))# regoin is never defined, so deny is undefined and not deny is true for any requesttypo = 'region := "emea"\ndefault allow := false\nallow if not deny\ndeny if input.region != regoin\n'print("a deny with a misspelt, unbound variable, for apac:", ask(typo, "x := data.example.allow", {"region": "apac"}))mocks = """region := input.user.regionemea := {"region": "emea"}with_a_literal := seen if { seen := region with input.user as {"region": "emea"} }with_a_reference := seen if { seen := region with input.user as emea }"""print("region under a mock written as a literal:", ask(mocks, "x := data.example.with_a_literal", {"user": {"region": "apac"}}))# the mock refers to the rule emea, which regopy ignores, so the real input's region comes backprint("region under a mock that refers to a rule:", ask(mocks, "x := data.example.with_a_reference", {"user": {"region": "apac"}}))
Salidapython regopy-silent-differences.py
a false decision, queried on its own: undefined
the same decision, bound to a variable: false
a rule in pre-1.0 syntax: true
a deny with a misspelt, unbound variable, for apac: true
region under a mock written as a literal: "emea"
region under a mock that refers to a rule: "apac"
  • Una decisión falsa devuelve indefinido. Si pides data.example.allow por sí solo, regopy responde undefined cuando el valor es false, de modo que «denegado» no puede distinguirse de «sin decisión». Si la consulta se liga a una variable, la misma consulta devuelve false. lib.policy liga cada decisión que lee.
  • La sintaxis anterior a 1.0 se ejecuta. Desde OPA 1.0, if es obligatorio en cada regla y contains para las reglas de valores múltiples (notas de la versión OPA v1.0.0), y el registro de cambios de rego-cpp indica que dejó de soportar Rego v0 (registro de cambios de rego-cpp). Sin embargo, regopy evalúa allow { ... } y responde true, así que una política puede pasar aquí y no cargarse en OPA, y también detrás de Trino.
  • Una variable sin ligar desactiva una regla. OPA exige que una variable en una comparación esté ligada por otra expresión de la misma regla, y rechaza la política en caso contrario (lenguaje de políticas de OPA). regopy la ejecuta de todos modos. Un deny con regoin mal escrito en lugar de region queda indefinido en silencio, de modo que allow if not deny permite una solicitud de apac, como muestra true.
  • Un mock que hace referencia a otra regla se ignora. En una política cuya regla region lee input.user.region, una simulación escrita como literal, with input.user as {"region": "emea"}, da "emea". Escrito como referencia a una regla que contiene el mismo objeto, da el "apac" de la entrada real.

El segundo grupo falla, y un solo fallo arrastra a Python con él. Un caso añade una prueba a una copia de las pruebas de la plataforma; el otro da formato a la misma cadena a partir de nueve fuentes:

regopy-failed-outputs.py Python 3.12.15 · pyarrow 26.0.1 · pyiceberg 0.12.0 · regopy 1.5.2 Superado
"""One test that replaces the whole input, and what that does to the interpreter: every query fails, and printing a failed output ends Python. The points rest on the printed error count, the assert that true does not succeed, and the signal the crash ends with."""import signalimport subprocessimport sysimport tempfilefrom collections import Counterfrom pathlib import Pathfrom lib import policy# The platform's tests, plus one that replaces the whole input at once rather than one path at a time.whole_input = """test_finance_reads_payments if {	access.decision.allow with input as {"context": {"identity": {"user": "finance-1"}}, "action": {"operation": "SelectFromColumns", "resource": {"table": {"schemaName": "billing", "tableName": "payments", "columns": ["amount"]}}}}}"""with tempfile.TemporaryDirectory() as name:    folder = Path(name)    for path in policy.POLICIES.glob("*.rego"):        (folder / path.name).write_text(path.read_text(encoding="utf-8"), encoding="utf-8")    with open(folder / "access_test.rego", "a", encoding="utf-8") as tests:        tests.write(whole_input)    results = policy.run_tests(folder)    print("tests that end in ERROR:", f"{Counter(results.values())['ERROR']} of {len(results)}")    rego = policy.interpreter(folder, tests=True)    succeeded = rego.query("true").ok()    # no query succeeds here, not even true: the interpreter loads the file with the broken test    assert not succeeded    print("the query true succeeds:", succeeded)    # lib.policy checks each output before reading it, so a decision asked of this interpreter raises an error.    try:        policy.decide(policy.request("finance-1", "billing.payments", ["amount"]), rego)    except RuntimeError as error:        print("lib.policy.decide raises:", error)    # Printing one of those failed outputs, in a separate Python process.    crash = "import sys; from pathlib import Path; from lib import policy; print(policy.interpreter(Path(sys.argv[1]), tests=True).query('true'))"    ended = subprocess.run([sys.executable, "-c", crash, str(folder)], capture_output=True)    # a negative return code names the signal that ended the process    print("printing the failed output ends Python with:", signal.Signals(-ended.returncode).name)
Salidapython regopy-failed-outputs.py
tests that end in ERROR: 13 of 13
the query true succeeds: False
lib.policy.decide raises: regopy couldn't evaluate data.platform.access.decision, so there is no decision to read
printing the failed output ends Python with: SIGSEGV
regopy-sprintf-quotes.py Python 3.12.15 · regopy 1.5.2 Superado
"""One label formatted from nine sources, the schema taken from each in turn. The point rests on the printed lines where regopy's JSON is invalid: a source that keeps its quotes breaks the output."""import jsonfrom regopy import Input, Interpreter# The same label, sprintf("%s.%s", [schema, input.table]), with the schema "crm" taken from nine places.# crm is a rule and schema_of a function, two of the nine sourceshelpers = 'crm := "crm"\nschema_of(x) := "crm" if x == 1\n'cases = [    ("from input.schema", "input.schema", "true"),    ("from a rule", "crm", "true"),    ("from a function", "schema_of(1)", "true"),    ("from iterating over a set", "s", 'some s in {"crm"}'),    ("from object.get, the key found", 'object.get(input, "schema", "public")', "true"),    # namespace is not in the input, so object.get returns its default, crm    ("from object.get, its default", 'object.get(input, "namespace", "crm")', "true"),    ("from lower(input.schema)", "lower(input.schema)", "true"),    ("from concat", 'concat("", ["c", "rm"])', "true"),    ("from a local variable set to a literal", "v", 'v := "crm"'),]for name, schema, body in cases:    rego = Interpreter()    rego.add_module("example", f'package example\n{helpers}label := sprintf("%s.%s", [{schema}, input.table]) if {{ {body} }}\n')    rego.set_input(Input({"schema": "crm", "table": "learners"}))    try:        print(f"{name}:", json.loads(str(rego.query("x := data.example.label")))["bindings"]["x"])    except json.JSONDecodeError as error:        print(f"{name}, regopy's invalid JSON:", error.doc)
Salidapython regopy-sprintf-quotes.py
from input.schema: crm.learners
from a rule: crm.learners
from a function: crm.learners
from iterating over a set: crm.learners
from object.get, the key found: crm.learners
from object.get, its default, regopy's invalid JSON: {"expressions":[true], "bindings":{"x":""crm".learners"}}
from lower(input.schema), regopy's invalid JSON: {"expressions":[true], "bindings":{"x":""crm".learners"}}
from concat, regopy's invalid JSON: {"expressions":[true], "bindings":{"x":""crm".learners"}}
from a local variable set to a literal, regopy's invalid JSON: {"expressions":[true], "bindings":{"x":""crm".learners"}}
  • Reemplazar la entrada completa rompe todas las consultas. Una prueba adicional que escribe su solicitud como with input as {...}, y evalúa reglas que llaman a funciones integradas como sprintf, hace que cada consulta de ese intérprete falle. Entonces cada prueba termina en ERROR, 13 of 13, y también lo hace la primera consulta hecha a un intérprete nuevo cargado con los mismos archivos, antes de que se ejecute ninguna prueba: incluso la consulta true falla. Reemplazar una ruta a la vez, como hacen las pruebas de la plataforma, funciona.
  • Imprimir una salida fallida tumba Python. Convertir una de esas salidas fallidas en una cadena termina el proceso con SIGSEGV. Por eso lib.policy comprueba output.ok() antes de leer nada, y una decisión pedida a ese intérprete lanza un error en su lugar: regopy couldn't evaluate data.platform.access.decision, so there is no decision to read.
  • sprintf conserva comillas sobrantes. Dar formato a una cadena devuelta por algunas funciones integradas, como el valor por defecto de object.get, lower o concat, o a una variable local asignada a un literal, conserva sus comillas. La salida propia de regopy queda entonces como JSON no válido, que su envoltorio de Python no logra analizar, como muestra {"expressions":[true], "bindings":{"x":""crm".learners"}}. Las cadenas procedentes de input, de una regla, de una función, de una iteración y del valor encontrado por object.get se formatean correctamente, y la política de la plataforma solo formatea cadenas como esas.

Regla práctica: Trata regopy como un evaluador local rápido y a OPA como la referencia. Escribe solo Rego v1, liga cada decisión a una variable, simula la entrada una ruta a la vez con valores literales y comprueba que una salida tuvo éxito antes de leerla. Antes de que una política proteja datos de producción, verifícala y pruébala con el propio OPA, con opa check --strict y opa test.

Escribe las mismas reglas en Cedar

Último cambio en la edición 2026.11.31

Rego no es el único lenguaje para políticas como las de la plataforma. Los diseñadores de Cedar lo presentan como un lenguaje para la autorización expresiva, rápida, segura y analizable (Cutler et al., 2024), y adopta una visión más estrecha de lo que es una decisión, el sujeto sigue siendo Cedar. Una solicitud de Cedar nombra un principal, una acción y un recurso, y la respuesta sigue tres reglas: denegación por defecto, forbid prevalece sobre permit, y omisión ante errores, que la documentación define como "si la evaluación de una política devuelve un error, la política no interviene en la respuesta de autorización; se omite" (Cedar, authorization). Un esquema declara cada tipo de entidad, los tipos de principal y recurso que una solicitud puede nombrar, con sus atributos, y los atributos son obligatorios salvo que el esquema los marque como opcionales (Cedar, schema). La validación comprueba las políticas contra un esquema antes de cualquier solicitud, y un conjunto que valida evita la mayoría de los errores que la evaluación podría producir, para las solicitudes que coinciden con el esquema (Cedar, validation). Los ejemplos del libro ejecutan Cedar con cedarpy 4.12.2, que envuelve la biblioteca Rust Cedar Policy para Python (cedarpy).

Las reglas de la plataforma en Cedar están en governance/policies/access.cedar, con el esquema en access.cedarschema. Un permit por grupo repite el mapa readable de la política en Rego. Un forbid mantiene a los agentes de soporte limitados a los alumnos de su propia región, y otra política oculta las columnas sensibles a todos excepto a la vista de finanzas sobre los números de tarjeta. lib.policy.cedar_entities genera los usuarios, grupos, tablas y columnas a partir del mismo documento de datos que lee la política en Rego, y el código añade el primer alumno de crm.learners en cada región:

cedar-same-rules.py Python 3.12.15 · cedarpy 4.12.2 · pyarrow 26.0.1 · pyiceberg 0.12.0 · regopy 1.5.2 Superado
"""The platform's Cedar policies checked against their schema, then asked the questions the Rego policy answers, over entities generated from its data. The points rest on the printed decisions, and on the misspelt-region error the schema gives before any request."""import cedarpyfrom lib import policyfrom lib.platform import loadpolicies = policy.CEDAR_POLICIES.read_text(encoding="utf-8")schema = policy.CEDAR_SCHEMA.read_text(encoding="utf-8")print("policies valid against the schema:", cedarpy.validate_policies(policies, schema).validation_passed)# misspells region in the policy's text, so the schema reports the attribute that User lackstypo = cedarpy.validate_policies(policies.replace("principal.region", "principal.regoin"), schema)# the validator's first errorprint("with region misspelt:", typo.errors[0].error)# Entities generated from the files the Rego policy reads, plus the first learner of crm.learners in each region.first = {}for learner in load("crm.learners").select(["learner_id", "support_region"]).to_pylist():    # setdefault keeps the first learner seen in each region    first.setdefault(learner["support_region"], learner)entities = policy.cedar_entities(learners=first.values())def ask(user: str, resource: str) -> cedarpy.AuthzResult:    request = {"principal": f'User::"{user}"', "action": 'Action::"read"', "resource": resource, "context": {}}    return cedarpy.is_authorized(request, policies, entities, schema)for user, kind, name in [("finance-1", "Column", "billing.payments.card_number"),                         ("analyst-1", "Column", "billing.payments.card_number"),                         ("analyst-1", "Column", "billing.payments.amount"),                         ("marketing-1", "Table", "billing.payments")]:    print(f"{user} reads {name}:", ask(user, f'{kind}::"{name}"').decision.value)for region, learner in sorted(first.items()):    print(f"agent-a05 (emea) reads a learner in {region}:", ask("agent-a05", f'Learner::"{learner["learner_id"]}"').decision.value)answer = ask("finance-1", 'Column::"billing.payments.card_number"')# the policies that decided the answer, and those skipped on an error, come from its diagnosticsprint("everything Cedar returns for finance-1's card numbers:", answer.decision.value, list(answer.diagnostics.reasons), list(answer.diagnostics.errors))
Salidapython cedar-same-rules.py
policies valid against the schema: True
with region misspelt: for policy `policy6`, attribute `regoin` on entity type `User` not found
finance-1 reads billing.payments.card_number: Allow
analyst-1 reads billing.payments.card_number: Deny
analyst-1 reads billing.payments.amount: Allow
marketing-1 reads billing.payments: Deny
agent-a05 (emea) reads a learner in americas: Deny
agent-a05 (emea) reads a learner in apac: Deny
agent-a05 (emea) reads a learner in emea: Allow
everything Cedar returns for finance-1's card numbers: Allow ['policy3'] []

Las decisiones coinciden con la política en Rego siempre que Cedar pueda expresarlas. Finanzas puede leer la columna card_number, y el científico de datos no, mientras que Rego permite la lectura y oculta la columna. El científico de datos puede leer amount, y marketing no puede leer los pagos. El agente emea puede leer al alumno emea y a ninguno de los otros dos. Las políticas también validan contra el esquema, y si se escribe mal region se obtiene un error preciso antes de ejecutar nada: for policy policy6, attribute regoin on entity type User not found.

Rego no tiene una comprobación de este tipo por defecto. La misma errata en un atributo, user.regoin en el filtro de filas del agente de soporte, no está definida ni en OPA ni en regopy, y opa check --strict la deja pasar, porque OPA comprueba las referencias contra un esquema solo cuando se le proporciona uno (OPA policy language, schemas), y la plataforma no proporciona ninguno. El filtro de filas del agente desaparece, y solo una prueba que compare los filtros, como test_support_reads_only_its_own_region, lo detecta.

Cedar devuelve una decisión y poco más. La última línea de la salida es todo lo que devuelve para los números de tarjeta de finanzas: la decisión y el ID de la política que la tomó. cedarpy nombra las políticas por posición, policy3 para la cuarta, no por sus anotaciones @id como finance-tables. La documentación de Cedar indica que @id no significa nada para el propio lenguaje: su CLI lo usa para asignar IDs a las políticas, y otras interfaces los asignan de otra forma (Cedar, syntax). Nada en la respuesta indica last4, la máscara que devuelve la política en Rego para los números de tarjeta de finanzas, porque Cedar puede permitir una columna pero no puede indicar cómo mostrarla. Esa regla pasaría al código de aplicación, fuera de la política y de sus pruebas. Con las filas ocurre lo mismo. Cedar decide un alumno a la vez, así que filtrar los alumnos de la plataforma implica una solicitud por alumno, o la evaluación parcial experimental de Cedar, que devuelve políticas residuales para las partes que aún no puede decidir, y cuyo resultado no es una decisión de autorización definitiva (cedarpy). El artículo sobre Cedar expone la disyuntiva desde el otro lado: "La expresividad añadida de Rego es una bendición pero también una maldición". Añade que Rego no ofrece conceptos de autorización integrados como allow o deny. El mismo artículo informa de que Cedar es entre 42.8 y 80.8 veces más rápido que Rego en la mediana, en tres cargas de trabajo con relaciones transitivas, con Cedar 3.0.1 frente a Rego de OPA 0.61.0. Son mediciones de sus diseñadores, no de este libro, y no dicen nada sobre regopy.

Regla práctica: Elige Cedar cuando cada pregunta sea "¿puede este principal hacer esto sobre este recurso?", como en las comprobaciones de permisos de una aplicación, y quieras que un esquema valide cada política antes de ejecutarla. Elige Rego cuando la respuesta deba transportar datos, como ocurre con los filtros de filas y las máscaras de columnas de un almacén de datos, o cuando el motor ya consulta a OPA, como hace Trino. Para el almacén de datos de la plataforma, recomendamos Rego.

Qué sale mal en producción

Último cambio en la edición 2026.11.27

Consideramos que el fallo más dañino es una regla que deja de aplicarse en silencio porque falta un atributo, y ocurre en ambos lenguajes. En Rego, "Las expresiones que se refieren a valores no definidos también son indefinidas" (OPA policy language). El filtro de filas del agente de soporte toma su valor de user.region, así que para un usuario sin región el filtro directamente no existe. Una regla que permite por grupo sigue permitiendo, y sin filtro significa todas las filas.

Copia la política y las pruebas de la plataforma en una carpeta temporal y elimina la única línea, not missing_attribute, de allow. Después añade un agente de soporte con su grupo y sin región, como ocurre cuando se asigna un rol antes de que alguien configure su región, y pide a ambas políticas los tickets del agente:

missing-region-guard.py Python 3.12.15 · pyarrow 26.0.1 · pyiceberg 0.12.0 · regopy 1.5.2 Superado
"""The support policy with and without its guard, asked for a support agent's tickets. The prose's points rest on the printed reasons, row filters and regions seen with each version, and on the test the copy without the guard fails."""import tempfilefrom pathlib import Pathfrom lib import policyfrom lib.platform import load# A support agent added to users.toml with their group, before anyone has set their region.data = policy.data_document()data["platform"]["users"]["agent-new"] = {"groups": ["support"]}request = policy.request("agent-new", "support.tickets", ["ticket_id", "body"])# every region with a ticket, the candidates for what the agent may seeregions = sorted(set(load("support.tickets").column("support_region").to_pylist()))# A copy of the platform's policy and tests, with one line taken out of `allow`: the missing-attribute guard.with tempfile.TemporaryDirectory() as name:    folder = Path(name)    for path in policy.POLICIES.glob("*.rego"):        # the guard's line in allow is indented with a tab, and this removes it        (folder / path.name).write_text(path.read_text(encoding="utf-8").replace("\tnot missing_attribute\n", ""), encoding="utf-8")    for label, policies in [("with the guard", policy.POLICIES), ("without the guard", folder)]:        decision = policy.decide(request, policy.interpreter(policies, data=data))        # a region counts when the decision allows the read and every row filter names it, so no filters means every region        seen = [r for r in regions if decision["allow"] and all(f["equals"] == r for f in decision["row_filters"])]        print(f"{label}, allowed:", decision["allow"])        print(f"{label}, reasons:", "; ".join(decision["reasons"]))        print(f"{label}, row filters:", decision["row_filters"])        print(f"{label}, regions whose tickets the agent sees:", ", ".join(seen) or "none")    failing = [test for test, result in policy.run_tests(folder).items() if result != "PASS"]print("tests that fail without the guard:", ", ".join(failing))
Salidapython missing-region-guard.py
with the guard, allowed: False
with the guard, reasons: support's row filter needs the user's region, and there is none
with the guard, row filters: []
with the guard, regions whose tickets the agent sees: none
without the guard, allowed: True
without the guard, reasons: support may read support.tickets; support's row filter needs the user's region, and there is none
without the guard, row filters: []
without the guard, regions whose tickets the agent sees: americas, apac, emea
tests that fail without the guard: test_support_without_a_region_is_denied

Sin la protección, se permite el acceso al agente, con los filtros de filas [], y ve los tickets de americas, apac, emea, incluidos todos los mensajes y los datos de contacto de cada estudiante. Los motivos ya indican que falta la región; nada en allow lo comprobó. Con la protección, se deniega el acceso al agente, y el motivo nombra lo que falta: support's row filter needs the user's region, and there is none. default allow := false tampoco ayudó, porque una regla sí permitió. Una prueba lo detecta, test_support_without_a_region_is_denied, por eso las pruebas de la política incluyen el caso del atributo ausente.

Cedar falla de la misma forma, mediante skip on error. Quita la comprobación has region de las forbid de los agentes de soporte en las políticas Cedar de la plataforma, y la condición lee principal.region en un agente que no tiene ninguno:

cedar-missing-region.py Python 3.12.15 · cedarpy 4.12.2 · pyarrow 26.0.1 · pyiceberg 0.12.0 · regopy 1.5.2 Superado
"""Cedar's support forbid with and without its `has region` check, asked about a support agent with no region. The points rest on the printed decisions with each version, and on the validation error the unguarded policy gets."""import cedarpyfrom lib import policyfrom lib.platform import loadguarded = policy.CEDAR_POLICIES.read_text(encoding="utf-8")unguarded = guarded.replace("principal has region && ", "")            # the same forbid, without its `has` checkschema = policy.CEDAR_SCHEMA.read_text(encoding="utf-8")# A support agent with no region yet, as when a role is given before anyone sets one, and the first learner of crm.learners in each region.data = policy.data_document()data["platform"]["users"]["agent-new"] = {"groups": ["support"]}first = {}for learner in load("crm.learners").select(["learner_id", "support_region"]).to_pylist():    first.setdefault(learner["support_region"], learner)entities = policy.cedar_entities(learners=first.values(), data=data)for name, policies in [("with `has region`", guarded), ("without it", unguarded)]:    for region, learner in sorted(first.items()):        request = {"principal": 'User::"agent-new"', "action": 'Action::"read"',                   "resource": f'Learner::"{learner["learner_id"]}"', "context": {}}        answer = cedarpy.is_authorized(request, policies, entities, schema)        print(f"{name}, a learner in {region}:", answer.decision.value)    # answer is the last learner's request, in emea, the last region in sorted order    print(f"{name}, policies skipped on an error:", list(answer.diagnostics.errors))# the first error the validator returns for the unguarded policiesprint("validation without it:", cedarpy.validate_policies(unguarded, schema).errors[0].error)
Salidapython cedar-missing-region.py
with `has region`, a learner in americas: Deny
with `has region`, a learner in apac: Deny
with `has region`, a learner in emea: Deny
with `has region`, policies skipped on an error: []
without it, a learner in americas: Allow
without it, a learner in apac: Allow
without it, a learner in emea: Allow
without it, policies skipped on an error: ['error while evaluating policy `policy6`: `User::"agent-new"` does not have the attribute `region`']
validation without it: for policy `policy6`, unable to guarantee safety of access to optional attribute `region` on entity type `User`

Sin la comprobación, Cedar permite que un agente de soporte sin región lea a los estudiantes de las tres regiones. Al evaluar forbid se produce un error, Cedar omite esa política y el permit de soporte sigue aplicándose. Con la comprobación, al mismo agente se le deniega todo acceso a los estudiantes. Pasar el esquema a is_authorized no lo evitó, porque el esquema declara region como opcional, ya que los usuarios fuera de soporte no tienen ninguno. Lo detectó la validación, antes de cualquier solicitud: for policy policy6, unable to guarantee safety of access to optional attribute region on entity type User.

Otros fallos a vigilar:

  • Un atributo mal escrito no es un error, sino un valor indefinido. user.regoin en lugar de user.region pasa opa check --strict, y el filtro de soporte desaparece igual que con una región ausente. Compara filtros completos en las pruebas, y dale a OPA un esquema si quieres la comprobación antes de ejecutar cualquier prueba.
  • Una regla de denegación que lee un atributo ausente falla abierta. La protección corrige allow; un deny o un forbid requiere el mismo cuidado. Deniega explícitamente cuando falte un atributo obligatorio, y escribe la prueba para ello antes de la regla.
  • Políticas que nadie puede probar. Las reglas guardadas en la configuración de un motor o en vistas hechas a mano por rol no se pueden probar unitariamente ni comparar, así que se desvían. Guarda la política, sus pruebas y su tabla de decisiones en el repositorio, y ejecuta las tres en cada cambio.
  • regopy pasa y OPA rechaza. La sintaxis anterior a 1.0 y las variables no ligadas se ejecutan en regopy. Verifica cada política con opa check --strict antes de desplegarla en OPA.
  • Datos que cambiaron bajo la política. Trasladar a un agente de soporte a otra región es un solo cambio en users.toml, y la decisión solo lo refleja cuando se reconstruye el documento de datos. Reconstrúyelo siempre que cambien sus fuentes, y despliégalo junto con la política.

Lo que decidió este capítulo

Último cambio en la edición 2026.11.27
  • Una sola política, en Rego, governance/policies/access.rego, deniega por defecto, permite por grupo y restringe mediante tres atributos: la región del agente, el consentimiento del alumno y el propósito de la solicitud.
  • Las solicitudes tienen la forma de las solicitudes OPA de Trino, construidas por lib.policy.request, más un purpose opcional en el nivel superior; los grupos provienen de users.toml, no de la solicitud.
  • Los datos de la política se generan mediante lib.policy.data_document a partir de users.toml, metadata.toml y learning.courses, y nunca se escriben a mano.
  • Cada decisión es un único documento con allow, row_filters, column_masks y reasons. Los filtros y las máscaras son datos, nunca SQL, y las máscaras son redact, last4, pseudonymize y redact_contacts. Una denegación no lleva filtros ni máscaras.
  • Los datos faltantes fallan en modo seguro: una columna que los metadatos no clasifican se trata como sensible, y a un usuario cuyo filtro de filas necesita un atributo que falta se le deniega el acceso.
  • El único propósito que la política conoce es ai-training, que limita las revisiones a los alumnos que aceptaron el entrenamiento de IA y muestra su texto sin los datos de contacto. Una lectura sin propósito obtiene lo que permite su rol, con el texto de las revisiones oculto.
  • Dos tipos de prueba se ejecutan con cada cambio: las pruebas unitarias de Rego mediante lib.policy.run_tests, y la tabla de quién ve qué, lib.policy.WHO_SEES_WHAT.
  • regopy para los ejemplos, OPA como referencia: solo Rego v1, cada decisión ligada a una variable, la entrada simulada una ruta a la vez con literales, y cada salida verificada antes de leerla.
  • Cedar sirve para comparar (governance/policies/access.cedar). Se adapta a comprobaciones de permitir o denegar sobre recursos individuales; el almacén de datos de la plataforma necesita filtros y máscaras como datos, por eso usa Rego. Una política de acceso solo es tan clara como de exhaustivas sean sus pruebas. Escribir las reglas como código significa que un cambio en quién ve qué es un diff que un revisor puede leer, y que una prueba puede ejecutarse antes de que alguien dependa de ella.

Este capítulo, en esta edición

Edición 2026.11.31Ejemplos verificados el 19 de nov de 2026Superan la prueba 13 de 13 ejemplos ejemplos de este capítulo

Traducido del libro en inglés, edición 2026.11.31.

Cita esta sección

Formato

Cada formato cita el libro en inglés, que esta traducción sigue.

Cada formato nombra esta edición. Su enlace abre la edición actual, donde el encabezado de cada sección indica cuándo cambió su texto por última vez. Las fechas de acceso y de recuperación son el día en que lo abres.

En esta página

Capítulo 5 de 10: Políticas de acceso como código

  1. Da a la solicitud la forma de las de Trino
  2. Genera los datos que lee la política
  3. Denegar por defecto, luego permitir por rol
  4. Filtrar por atributo: región, consentimiento y finalidad
  5. Devuelve la decisión como un solo documento
  6. Prueba unitaria de la política en Rego
  7. Revisa quién ve qué a partir de una tabla de decisiones
  8. Conoce las diferencias entre regopy y OPA
  9. Escribe las mismas reglas en Cedar
  10. Qué sale mal en producción
  11. Lo que decidió este capítulo

Volver arribaTodos los capítulos