Políticas de acceso como código
Unos 32 minutos de lectura, con 13 ejemplos en 11 secciones.
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
En esta página
- Da a la solicitud la forma de las de Trino
- Genera los datos que lee la política
- Denegar por defecto, luego permitir por rol
- Filtrar por atributo: región, consentimiento y finalidad
- Devuelve la decisión como un solo documento
- Prueba unitaria de la política en Rego
- Revisa quién ve qué a partir de una tabla de decisiones
- Conoce las diferencias entre regopy y OPA
- Escribe las mismas reglas en Cedar
- Qué sale mal en producción
- Lo que decidió este capítulo
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
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:
1"""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."""2import json34from lib import policy56# A support agent's query reads three columns of the tickets table: the request Trino's OPA plugin would send for it.7# no groups here, because the policy reads them from users.toml; no purpose either, since request adds one only when given8request = policy.request("agent-a05", "support.tickets", ["ticket_id", "opened_at", "body"])9print(json.dumps(request, indent=2))
python 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
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:
1"""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."""2from lib import policy34# What the policy reads besides the request, built from the files that own each fact.5# the document's one top-level key, which the policy reads as data.platform6data = policy.data_document()["platform"]78print("users, from governance/users.toml:", len(data["users"]))9print("agent-a05:", data["users"]["agent-a05"])10print("instructor-17:", data["users"]["instructor-17"])1112classifications = data["classifications"]13print("tables, from governance/metadata.toml:", len(classifications))14print("columns classified:", sum(len(columns) for columns in classifications.values()))15print("crm.learners.email:", classifications["crm.learners"]["email"])16print("billing.payments.card_number:", classifications["billing.payments"]["card_number"])1718courses = data["instructor_courses"]19print("instructors with courses, from learning.courses:", len(courses))20# instructor IDs are string keys in the document, so the lookup is "17"21print("instructor 17's courses:", courses["17"])
python generated-policy-data.pyusers, 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
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:
1"""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."""2from lib import policy34rego = policy.interpreter()56# The groups the policy knows, and the tables each may read: the role part of the policy.7readable = policy.evaluate(rego, "data.platform.access.readable", {})8for group, tables in readable.items():9 print(f"{group} may read:", ", ".join(tables))1011# Who may read what. Anything no rule allows is denied, including a user or an operation the policy has never seen.12requests = [13 policy.request("finance-1", "billing.payments", ["amount"]),14 policy.request("marketing-1", "billing.payments", ["amount"]),15 policy.request("someone-else", "crm.learners", ["learner_id"]),16]17delete = policy.request("finance-1", "billing.payments", ["amount"])18# the same request as finance's read, asking to delete instead19delete["action"]["operation"] = "DeleteFromTable"20for request in requests + [delete]:21 decision = policy.decide(request, rego)22 who, table = request["context"]["identity"]["user"], request["action"]["resource"]["table"]23 print(f"{who}, {request['action']['operation']} on {table['schemaName']}.{table['tableName']}:",24 "allowed" if decision["allow"] else "denied", "|", "; ".join(decision["reasons"]))
python allow-by-role.pyai 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
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:
1"""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."""2import json34from lib import policy56rego = policy.interpreter()78# Region is the agent's attribute, consent the learner's, and purpose the request's. Each becomes a row filter.9reads = [10 ("agent-a01", "support.tickets", ["ticket_id"], None),11 ("agent-a05", "support.tickets", ["ticket_id"], None),12 ("agent-a09", "support.tickets", ["ticket_id"], None),13 ("instructor-17", "learning.reviews", ["rating"], None),14 ("marketing-1", "crm.learners", ["email"], None),15 ("analyst-1", "learning.reviews", ["rating", "body"], None),16 # the same read with a purpose, the one attribute the requester supplies17 ("analyst-1", "learning.reviews", ["rating", "body"], "ai-training"),18]19for user, table, columns, purpose in reads:20 decision = policy.decide(policy.request(user, table, columns, purpose), rego)21 who = user + (f" for {purpose}" if purpose else "")22 # json shows the consent filter with its learner_consented key, not a column23 print(f"{who} reads {table}, row filters:", json.dumps(decision["row_filters"]))24 if "body" in columns:25 print(f"{who} reads {table}, body shown as:", decision["column_masks"]["body"])
python attributes-as-row-filters.pyagent-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
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:
1"""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."""2import json34from lib import policy56# Marketing reads four columns of crm.learners. `linkedin_url` stands for a column added to the table and not yet7# classified in governance/metadata.toml.8request = policy.request("marketing-1", "crm.learners", ["full_name", "email", "phone", "linkedin_url"])9# with no interpreter given, decide loads the platform's policy itself10decision = policy.decide(request)11print(json.dumps(decision, indent=2))12print("keys:", ", ".join(sorted(decision)))
python 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
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.
1"""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."""2from collections import Counter34from lib import policy56# Every `test_` rule in governance/policies/access_test.rego, run by name: PASS, FAIL or ERROR, as `opa test` reports.7results = policy.run_tests()8for test, result in results.items():9 print(f"{result}: {test}")10# len(results) counts every test, so one that fails or errors still shows in the total11print("tests passed:", f"{Counter(results.values())['PASS']} of {len(results)}")
python policy-unit-tests.pyPASS: 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
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:
1"""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."""2from lib import policy34rego = policy.interpreter()56# Each row of lib.policy.WHO_SEES_WHAT is a request and the decision a reviewer expects for it.7matching = 08for case in policy.WHO_SEES_WHAT:9 decision = policy.decide(policy.request(case.user, case.table, case.columns, case.purpose), rego)10 # matches returns True or False, which add as 1 or 011 matching += policy.matches(case, decision)12 who = case.user + (f" ({case.purpose})" if case.purpose else "")13 shown = "allowed" if decision["allow"] else "denied"14 # a consent filter has no column key, so filtered_on reads its learner_consented key15 filters = ", ".join(policy.filtered_on(decision)) or "-"16 masks = ", ".join(f"{column}: {mask}" for column, mask in decision["column_masks"].items()) or "-"17 print(f"{who:26} {case.table:17} {shown:8} rows: {filters:29} masks: {masks}")18print("rows of the table the policy matches:", f"{matching} of {len(policy.WHO_SEES_WHAT)}")
python who-sees-what.pyagent-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
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:
1"""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."""2import json34from regopy import Input, Interpreter567def ask(rules: str, query: str, request: dict) -> str:8 """One query's answer from regopy: the value bound to x, or "undefined"."""9 rego = Interpreter()10 rego.add_module("example", "package example\n" + rules)11 rego.set_input(Input(request))12 output = str(rego.query(query))13 # regopy writes undefined as a bare word; otherwise the binding for x is the answer14 return output if output == "undefined" else json.dumps(json.loads(output)["bindings"]["x"])151617admins_only = 'default allow := false\nallow if input.user == "admin"\n'18# no variable in the query19print("a false decision, queried on its own:", ask(admins_only, "data.example.allow", {"user": "guest"}))20# bound to x, the same false decision comes back as a value21print("the same decision, bound to a variable:", ask(admins_only, "x := data.example.allow", {"user": "guest"}))2223pre_1_0 = 'allow { input.user == "admin" }\n' # no `if`: OPA 1.x refuses to load this24print("a rule in pre-1.0 syntax:", ask(pre_1_0, "x := data.example.allow", {"user": "admin"}))2526# regoin is never defined, so deny is undefined and not deny is true for any request27typo = 'region := "emea"\ndefault allow := false\nallow if not deny\ndeny if input.region != regoin\n'28print("a deny with a misspelt, unbound variable, for apac:", ask(typo, "x := data.example.allow", {"region": "apac"}))2930mocks = """region := input.user.region31emea := {"region": "emea"}32with_a_literal := seen if { seen := region with input.user as {"region": "emea"} }33with_a_reference := seen if { seen := region with input.user as emea }34"""35print("region under a mock written as a literal:", ask(mocks, "x := data.example.with_a_literal", {"user": {"region": "apac"}}))36# the mock refers to the rule emea, which regopy ignores, so the real input's region comes back37print("region under a mock that refers to a rule:", ask(mocks, "x := data.example.with_a_reference", {"user": {"region": "apac"}}))
python regopy-silent-differences.pya 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.allowpor sí solo, regopy respondeundefinedcuando el valor esfalse, de modo que «denegado» no puede distinguirse de «sin decisión». Si la consulta se liga a una variable, la misma consulta devuelvefalse.lib.policyliga cada decisión que lee. - La sintaxis anterior a 1.0 se ejecuta. Desde OPA 1.0,
ifes obligatorio en cada regla ycontainspara 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úaallow { ... }y respondetrue, 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
denyconregoinmal escrito en lugar deregionqueda indefinido en silencio, de modo queallow if not denypermite una solicitud deapac, como muestratrue. - Un mock que hace referencia a otra regla se ignora. En una política cuya regla
regionleeinput.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:
1"""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."""2import signal3import subprocess4import sys5import tempfile6from collections import Counter7from pathlib import Path89from lib import policy1011# The platform's tests, plus one that replaces the whole input at once rather than one path at a time.12whole_input = """13test_finance_reads_payments if {14 access.decision.allow with input as {"context": {"identity": {"user": "finance-1"}}, "action": {"operation": "SelectFromColumns", "resource": {"table": {"schemaName": "billing", "tableName": "payments", "columns": ["amount"]}}}}15}16"""17with tempfile.TemporaryDirectory() as name:18 folder = Path(name)19 for path in policy.POLICIES.glob("*.rego"):20 (folder / path.name).write_text(path.read_text(encoding="utf-8"), encoding="utf-8")21 with open(folder / "access_test.rego", "a", encoding="utf-8") as tests:22 tests.write(whole_input)23 results = policy.run_tests(folder)24 print("tests that end in ERROR:", f"{Counter(results.values())['ERROR']} of {len(results)}")25 rego = policy.interpreter(folder, tests=True)26 succeeded = rego.query("true").ok()27 # no query succeeds here, not even true: the interpreter loads the file with the broken test28 assert not succeeded29 print("the query true succeeds:", succeeded)3031 # lib.policy checks each output before reading it, so a decision asked of this interpreter raises an error.32 try:33 policy.decide(policy.request("finance-1", "billing.payments", ["amount"]), rego)34 except RuntimeError as error:35 print("lib.policy.decide raises:", error)3637 # Printing one of those failed outputs, in a separate Python process.38 crash = "import sys; from pathlib import Path; from lib import policy; print(policy.interpreter(Path(sys.argv[1]), tests=True).query('true'))"39 ended = subprocess.run([sys.executable, "-c", crash, str(folder)], capture_output=True)40 # a negative return code names the signal that ended the process41 print("printing the failed output ends Python with:", signal.Signals(-ended.returncode).name)
python regopy-failed-outputs.pytests 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
1"""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."""2import json34from regopy import Input, Interpreter56# The same label, sprintf("%s.%s", [schema, input.table]), with the schema "crm" taken from nine places.7# crm is a rule and schema_of a function, two of the nine sources8helpers = 'crm := "crm"\nschema_of(x) := "crm" if x == 1\n'9cases = [10 ("from input.schema", "input.schema", "true"),11 ("from a rule", "crm", "true"),12 ("from a function", "schema_of(1)", "true"),13 ("from iterating over a set", "s", 'some s in {"crm"}'),14 ("from object.get, the key found", 'object.get(input, "schema", "public")', "true"),15 # namespace is not in the input, so object.get returns its default, crm16 ("from object.get, its default", 'object.get(input, "namespace", "crm")', "true"),17 ("from lower(input.schema)", "lower(input.schema)", "true"),18 ("from concat", 'concat("", ["c", "rm"])', "true"),19 ("from a local variable set to a literal", "v", 'v := "crm"'),20]21for name, schema, body in cases:22 rego = Interpreter()23 rego.add_module("example", f'package example\n{helpers}label := sprintf("%s.%s", [{schema}, input.table]) if {{ {body} }}\n')24 rego.set_input(Input({"schema": "crm", "table": "learners"}))25 try:26 print(f"{name}:", json.loads(str(rego.query("x := data.example.label")))["bindings"]["x"])27 except json.JSONDecodeError as error:28 print(f"{name}, regopy's invalid JSON:", error.doc)
python regopy-sprintf-quotes.pyfrom 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 comosprintf, 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 consultatruefalla. 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 esolib.policycompruebaoutput.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. sprintfconserva comillas sobrantes. Dar formato a una cadena devuelta por algunas funciones integradas, como el valor por defecto deobject.get,loweroconcat, 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 deinput, de una regla, de una función, de una iteración y del valor encontrado porobject.getse 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
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:
1"""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."""2import cedarpy34from lib import policy5from lib.platform import load67policies = policy.CEDAR_POLICIES.read_text(encoding="utf-8")8schema = policy.CEDAR_SCHEMA.read_text(encoding="utf-8")9print("policies valid against the schema:", cedarpy.validate_policies(policies, schema).validation_passed)10# misspells region in the policy's text, so the schema reports the attribute that User lacks11typo = cedarpy.validate_policies(policies.replace("principal.region", "principal.regoin"), schema)12# the validator's first error13print("with region misspelt:", typo.errors[0].error)1415# Entities generated from the files the Rego policy reads, plus the first learner of crm.learners in each region.16first = {}17for learner in load("crm.learners").select(["learner_id", "support_region"]).to_pylist():18 # setdefault keeps the first learner seen in each region19 first.setdefault(learner["support_region"], learner)20entities = policy.cedar_entities(learners=first.values())212223def ask(user: str, resource: str) -> cedarpy.AuthzResult:24 request = {"principal": f'User::"{user}"', "action": 'Action::"read"', "resource": resource, "context": {}}25 return cedarpy.is_authorized(request, policies, entities, schema)262728for user, kind, name in [("finance-1", "Column", "billing.payments.card_number"),29 ("analyst-1", "Column", "billing.payments.card_number"),30 ("analyst-1", "Column", "billing.payments.amount"),31 ("marketing-1", "Table", "billing.payments")]:32 print(f"{user} reads {name}:", ask(user, f'{kind}::"{name}"').decision.value)33for region, learner in sorted(first.items()):34 print(f"agent-a05 (emea) reads a learner in {region}:", ask("agent-a05", f'Learner::"{learner["learner_id"]}"').decision.value)35answer = ask("finance-1", 'Column::"billing.payments.card_number"')36# the policies that decided the answer, and those skipped on an error, come from its diagnostics37print("everything Cedar returns for finance-1's card numbers:", answer.decision.value, list(answer.diagnostics.reasons), list(answer.diagnostics.errors))
python cedar-same-rules.pypolicies 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
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:
1"""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."""2import tempfile3from pathlib import Path45from lib import policy6from lib.platform import load78# A support agent added to users.toml with their group, before anyone has set their region.9data = policy.data_document()10data["platform"]["users"]["agent-new"] = {"groups": ["support"]}11request = policy.request("agent-new", "support.tickets", ["ticket_id", "body"])12# every region with a ticket, the candidates for what the agent may see13regions = sorted(set(load("support.tickets").column("support_region").to_pylist()))1415# A copy of the platform's policy and tests, with one line taken out of `allow`: the missing-attribute guard.16with tempfile.TemporaryDirectory() as name:17 folder = Path(name)18 for path in policy.POLICIES.glob("*.rego"):19 # the guard's line in allow is indented with a tab, and this removes it20 (folder / path.name).write_text(path.read_text(encoding="utf-8").replace("\tnot missing_attribute\n", ""), encoding="utf-8")2122 for label, policies in [("with the guard", policy.POLICIES), ("without the guard", folder)]:23 decision = policy.decide(request, policy.interpreter(policies, data=data))24 # a region counts when the decision allows the read and every row filter names it, so no filters means every region25 seen = [r for r in regions if decision["allow"] and all(f["equals"] == r for f in decision["row_filters"])]26 print(f"{label}, allowed:", decision["allow"])27 print(f"{label}, reasons:", "; ".join(decision["reasons"]))28 print(f"{label}, row filters:", decision["row_filters"])29 print(f"{label}, regions whose tickets the agent sees:", ", ".join(seen) or "none")3031 failing = [test for test, result in policy.run_tests(folder).items() if result != "PASS"]32print("tests that fail without the guard:", ", ".join(failing))
python missing-region-guard.pywith 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:
1"""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."""2import cedarpy34from lib import policy5from lib.platform import load67guarded = policy.CEDAR_POLICIES.read_text(encoding="utf-8")8unguarded = guarded.replace("principal has region && ", "") # the same forbid, without its `has` check9schema = policy.CEDAR_SCHEMA.read_text(encoding="utf-8")1011# 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.12data = policy.data_document()13data["platform"]["users"]["agent-new"] = {"groups": ["support"]}14first = {}15for learner in load("crm.learners").select(["learner_id", "support_region"]).to_pylist():16 first.setdefault(learner["support_region"], learner)17entities = policy.cedar_entities(learners=first.values(), data=data)1819for name, policies in [("with `has region`", guarded), ("without it", unguarded)]:20 for region, learner in sorted(first.items()):21 request = {"principal": 'User::"agent-new"', "action": 'Action::"read"',22 "resource": f'Learner::"{learner["learner_id"]}"', "context": {}}23 answer = cedarpy.is_authorized(request, policies, entities, schema)24 print(f"{name}, a learner in {region}:", answer.decision.value)25 # answer is the last learner's request, in emea, the last region in sorted order26 print(f"{name}, policies skipped on an error:", list(answer.diagnostics.errors))27# the first error the validator returns for the unguarded policies28print("validation without it:", cedarpy.validate_policies(unguarded, schema).errors[0].error)
python cedar-missing-region.pywith `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.regoinen lugar deuser.regionpasaopa 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; undenyo unforbidrequiere 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 --strictantes 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
- 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 unpurposeopcional en el nivel superior; los grupos provienen deusers.toml, no de la solicitud. - Los datos de la política se generan mediante
lib.policy.data_documenta partir deusers.toml,metadata.tomlylearning.courses, y nunca se escriben a mano. - Cada decisión es un único documento con
allow,row_filters,column_masksyreasons. Los filtros y las máscaras son datos, nunca SQL, y las máscaras sonredact,last4,pseudonymizeyredact_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.