iamops.dev
Argo en X Feed RSS
ESEspañol

Labs Práctico · 25 minutos

Permit.io detrás de AuthZEN: decidir qué llamadas MCP puede hacer un agente

Puse un PDP de Permit.io detrás de un pequeño punto de aplicación MCP que habla AuthZEN. El pago de 90 dólares se denegó y el de 45 se permitió.

Capturas de la consola de Permit.io de mi lab, con datos ocultos: el editor de políticas con los roles payments_reader y payments_writer, y el registro de auditoría con dos llamadas permitidas y cuatro denegadas.
En resumenRehice el lab de OPA (Open Policy Agent) con Permit.io en el plan…
Repite este lab 7 pasos

Escribí este lab para que puedas repetirlo tú mismo. Cada paso tiene los comandos para copiar y la salida que obtuve yo, y puedes marcarlo como hecho. Las marcas se quedan solo en este navegador.

Ir a los pasos

Cómo funciona

Copia un prompt listo para Claude Code, Cursor, Codex o cualquier agente de código. Solo para entornos de prueba.

Mostrar el prompt
I want to run a hands-on lab from iamops.dev, and I would like your help to do it safely.

Lab: Permit.io detrás de AuthZEN: decidir qué llamadas MCP puede hacer un agente
Read the whole lab here (Markdown): https://iamops.dev/es/permit-authzen-mcp-tool-call-policy.md

What the lab needs before the first step:
- A free Permit.io account; the API key of its Development environment typed at the env.sh prompt
- Linux with Podman 5 or Docker, curl, jq and Python 3.10 or newer

How I want you to work:
1. Read the lab from start to finish first (each step lists its own prerequisites). Then check that the prerequisites are in place and that the tool versions match what the lab expects. Tell me what is missing before you run anything.
2. Run one step at a time. Before each command, show it to me and say in a sentence what it does.
3. Ask me before anything that costs money, creates cloud resources, touches a real tenant or account, or deletes anything. Wait for my answer.
4. Use the placeholders from the lab. Never paste real secrets, tokens or production identities into a command, a file or this chat. If a value is needed, tell me where to set it myself.
5. After each step, compare the output with the expected output in the lab. If it does not match, stop and tell me what differs. Do not carry on or invent a fix without asking me.
6. At the end, report what passed, what failed and which cleanup you did. Then offer to tick the steps off for me. The lab page keeps ticks only in my browser, so if you cannot do that, list the steps I should tick.

This lab is for test environments only. Do not run it against production, or against a tenant or account that holds real data or real users.

You may answer in my language.

A principios de mes construí un punto de decisión para llamadas a herramientas MCP con OPA: un agente propone un tools/call, algo delante del servidor MCP pregunta a un motor de políticas, y el motor responde sí o no mediante AuthZEN. Esta vez el motor es Permit.io.

Permit.io encaja bien en la comparación por dos motivos. Su PDP habla AuthZEN 1.0 sin configuración extra, y en marzo el equipo lanzó Permit MCP Gateway, un proxy delante de los servidores MCP que comprueba cada llamada contra Permit. Su artículo sobre las seis capas que todo gateway MCP debe aplicar es una lista breve y útil de lo que un gateway tiene que hacer aparte de enrutar.

Usé solo lo que incluye el plan gratuito Community. Las cuentas nuevas empiezan con una prueba Pro de 14 días, pero este lab no la necesita: RBAC, ABAC, el Edge PDP y el registro de auditoría están todos en el plan gratuito.

Cómo modela Permit las llamadas MCP#

La documentación de arquitectura del gateway describe la correspondencia. Cada servidor MCP se convierte en un tipo de recurso de Permit, con la clave del servidor. Cada herramienta se convierte en una acción sobre ese tipo de recurso. Para una llamada, el gateway ejecuta un permit.check() con el agente como usuario, el nombre de la herramienta como acción y el servidor como recurso, más una segunda comprobación para la persona cuando un admin importó el servidor. Las dos tienen que permitir.

Encima hay niveles de confianza (bajo para lecturas, medio para escrituras, alto para borrados) y un techo: el agente nunca obtiene más de lo que el admin dio a la persona. Permit construye ese techo con reglas ReBAC. La documentación también dice que si el PDP no responde, el gateway rechaza la petición con el error JSON-RPC (llamadas a procedimiento remoto en JavaScript Object Notation) -32005. Una denegación normal es -32004. Reutilicé -32004 en mi punto de aplicación.

El PDP es la parte que probé. Permit ofrece tres tipos. El Cloud PDP está alojado en cloudpdp.api.permit.io y cubre RBAC y ReBAC. El Edge PDP es un contenedor de código abierto (permitio/pdp-v2) que incluye OPA y el cliente OPAL (Open Policy Administration Layer) y cubre también ABAC. Nexus PDP es un contenedor más reciente con almacenamiento en disco. Los tres sirven los endpoints AuthZEN: evaluación, evaluaciones por lotes, las tres API (interfaz de programación) de búsqueda y el documento de descubrimiento.

Diagrama de secuencia: el plano de control de Permit envía la política y los datos al PDP Edge. Un agente de IA envía un tools/call MCP a pep.py, que toma el sujeto de la sesión y envía una evaluación AuthZEN al PDP. Para 9000 céntimos frente a un límite de 5000, el PDP responde decision false y pep.py devuelve el error -32004. Para 4500 céntimos con confirmación responde decision true y la herramienta se ejecuta. Sin clave en el PEP o con el PDP parado, pep.py deniega y se queda cerrado. El PDP envía los registros de decisiones al registro de auditoría de Permit.
El flujo que ejecuté. El punto de aplicación construye la petición AuthZEN desde la sesión, no desde lo que escribió el modelo. El PDP decide con la política que bajó de Permit, y los errores acaban en denegación.

Preparación#

Usé Podman 5.4.2 en Debian 13 para la imagen Edge PDP permitio/pdp-v2:0.9.17, Python 3.13, el SDK (kit de desarrollo de software) de Python de Permit 3.0.1 (el paquete en el Python Package Index se llama permit), curl y jq. Todo escucha en localhost: 7766 para el PDP y 8383 para el punto de aplicación. Docker funciona igual: cambia podman por docker.

Necesitas una cuenta gratuita de Permit.io. Regístrate en app.permit.io, abre el entorno Development del proyecto por defecto y copia su clave API en Settings, API Keys. El lab lee la clave desde un aviso oculto a una sola variable del shell. Nunca va a un archivo, un log o una captura, y el contenedor PDP la recibe como PDP_API_KEY.

El escenario es el del lab de OPA. Un agente llamado support-bot puede leer el saldo y los movimientos, y puede enviar pagos de hasta 5000 céntimos, 50 dólares, cuando el usuario ha confirmado. read-bot solo puede leer. Las herramientas son get_balance, list_transactions y send_payment en un servidor MCP, payments_mcp. delete_account no existe.

La política#

setup_permit.py crea la política mediante la API de Permit, así que puedes reconstruirla en cualquier entorno y quitarla con cleanup_permit.py:

  • Tipo de recurso payments_mcp con las tres herramientas como acciones y dos atributos, amount_cents y user_confirmed.
  • Un atributo de usuario limit_cents, a 5000 para los dos agentes.
  • Dos roles en lugar de los scopes: payments_reader con las dos herramientas de lectura (RBAC), y payments_writer sin permisos simples.
  • Un resource set ABAC, payment_within_limit: resource.amount_cents menor o igual que user.limit_cents, comparados por referencia, y resource.user_confirmed igual a true. payments_writer obtiene send_payment solo sobre ese conjunto.
Consola de Permit.io, Policy, pestaña Resources: tipo de recurso Payments MCP server con la clave payments_mcp, los atributos amount_cents: number y user_confirmed: bool, y las acciones get_balance, list_transactions y send_payment.
El servidor MCP como recurso. Un tipo de recurso, una acción por herramienta y los dos atributos que lee la regla ABAC.
Consola de Permit.io, Policy Editor: el rol payments.read (payments_reader) tiene get_balance y list_transactions marcados en la columna Payments MCP server y nada en la columna Payment within limit; el rol payments.write (payments_writer) solo tiene send_payment marcado, en la columna Payment within limit.
Los roles en el editor de políticas. El lector tiene las dos herramientas de lectura. El escritor tiene send_payment solo en la columna del resource set, no en el servidor.
Consola de Permit.io, vista de edición del recurso dinámico ABAC Payment within limit and confirmed, clave payment_within_limit, tipo de recurso payments_mcp, con dos condiciones: resource.amount_cents less-than-equals (ref) user.limit_cents, y resource.user_confirmed equals True.
La regla ABAC. Abierta en el panel de edición; no cambié nada. El importe se compara con el atributo de límite del agente, no con un número fijo.
Consola de Permit.io, Directory, Default Tenant, Users: support-bot con acceso de primer nivel payments_writer y payments_reader, y read-bot con payments_reader.
Los dos agentes. Los dos agentes son usuarios del tenant por defecto; solo support-bot tiene el rol de escritura.
Salida de terminal: un entorno virtual de Python recibe el paquete permit 3.0.1, setup_permit.py imprime policy created con payments_mcp, 2 roles, 1 resource set y 2 agentes, podman arranca permit-pdp desde pdp-v2 0.9.17 con PDP_API_KEY tomada de una variable del shell, y el endpoint healthy indica status ok para OPA y horizon.
Política cargada, PDP sano. La clave pasa como variable y nunca aparece. A los 30 segundos las dos partes del PDP están ok.

El PDP descargó la política dentro de los 30 segundos que le di, y /healthy indicó ok para sus dos partes.

El punto de aplicación#

pep.py recibe un tools/call JSON-RPC, obtiene el agente de la cabecera de sesión y envía a Permit una Access Evaluation AuthZEN. La forma sigue la correspondencia del gateway: el sujeto es el agente, la acción es el nombre de la herramienta, el recurso es el servidor MCP. El importe y la confirmación van en resource.properties, porque la documentación de Permit dice que el PDP lee tenant de ahí y pasa las demás claves a la política como atributos del recurso.

python
body = {
    "subject": {"type": "user", "id": agent},
    "action": {"name": tool},
    "resource": {"type": "payments_mcp", "id": "payments_mcp", "properties": {
        "tenant": "default",
        "amount_cents": args.get("amount_cents", 0),
        "user_confirmed": bool(args.get("user_confirmed", False)),
    }},
}

Las líneas importantes son las que siguen a la llamada. Solo HTTP (Hypertext Transfer Protocol) 200 con "decision": true permite. Cualquier error HTTP, un tiempo agotado, una conexión rechazada o una respuesta sin booleano es una denegación, y el log dice cuál fue.

Permit responde con algo más que la decisión. El campo context lleva el razonamiento, incluidos los roles del agente y su limit_cents. pep.py guarda los códigos cortos del motivo para su propio log y al agente solo le dice denied: policy. Un agente que puede leer el límite puede aprender a partir un pago para quedarse por debajo.

Prueba 1: AuthZEN con clave#

Primero comprobé los endpoints AuthZEN directamente, con la clave en la cabecera bearer: el documento de descubrimiento, una evaluación para get_balance, un lote de cuatro pagos en una sola petición y una búsqueda de los sujetos que pueden llamar a get_balance.

Salida de terminal: el documento de descubrimiento AuthZEN lista seis entradas, una evaluación para get_balance responde decision true con el rol payments_reader, un lote de cuatro evaluaciones send_payment responde false, true, false, false con los códigos rbac y abac, y una búsqueda de sujetos devuelve read-bot y support-bot.
Cuatro pagos, un sí. Solo pasa el pago confirmado de 45 dólares, por la regla ABAC. 90 dólares, los 45 sin confirmar y read-bot se rechazan.

El lote es la política en cuatro líneas. 90 dólares frente al límite de 50: false. 45 dólares confirmados: true, permitido por la regla ABAC. 45 dólares sin confirmar: false. Los mismos 45 dólares por parte de read-bot, indicado como sujeto del elemento del lote: false. La búsqueda de sujetos encontró a los dos agentes, porque los dos tienen payments_reader. La búsqueda de acciones devolvió una lista vacía para los dos agentes en mi prueba. No investigué por qué, así que aquí no me apoyo en ella.

Prueba 2: seis llamadas por el punto de aplicación#

Después arranqué pep.py y envié las seis llamadas del lab de OPA: una lectura del saldo, un pago de 90 dólares, uno de 45 con y sin confirmación, un pago de read-bot y el desconocido delete_account.

Salida de terminal: seis respuestas JSON-RPC de pep.py, dos resultados para get_balance y send_payment y cuatro errores -32004 denied: policy, luego las líneas de pep.log: get_balance ALLOW por rbac, send_payment de 90 dólares DENY, send_payment de 45 confirmado ALLOW por abac, el no confirmado DENY, read-bot DENY y delete_account DENY con rbac no_such_action.
Dos permitidas, cuatro denegadas. El mismo resultado que en el lab de OPA. El agente solo ve denied: policy; los códigos de motivo se quedan en el log.

Los resultados coinciden con el lab de OPA. Dos llamadas pasaron: la lectura del saldo, permitida por el rol, y el pago confirmado de 45 dólares, permitido por la regla ABAC. La política denegó cuatro. Para delete_account el PDP dijo no_such_action: la herramienta no es una acción de payments_mcp, así que ningún rol puede concederla.

Cada decisión llegó también al registro de auditoría de Permit. Las conté con la API del registro de auditoría: usuario, acción, tipo de recurso y decisión para cada llamada de esta prueba, incluidas las del Cloud PDP en la prueba 4.

Consola de Permit.io, Audit Log, vista Check: filas de las 11:23:53 a las 11:25:17 del 22 de noviembre de 2026, todas sobre payments_mcp en el tenant default. Las seis filas de las 11:25:17 son delete_account denegado, send_payment de read-bot denegado, send_payment de support-bot denegado, permitido y denegado, y get_balance permitido.
Las decisiones en el registro de auditoría. Las seis filas de las 11:25:17 son una prueba de las seis llamadas: dos permitidas, cuatro denegadas. Las filas de abajo son de pruebas anteriores.
Consola de Permit.io, Audit Event para send_payment de read-bot sobre payments_mcp a las 11:25:17, decisión denegada, con el JSON de depuración que muestra abac allow false, code no_matching_rules y el motivo de que read-bot no coincide con ninguna regla que conceda el permiso send_payment sobre payments_mcp.
Por qué se rechazó a read-bot. La entrada de auditoría guarda el razonamiento que devolvió el PDP: ninguna regla coincide.

Prueba 3: fail closed con una política activa#

Una política que funciona no elimina el camino de error. Reinicié pep.py con una clave vacía contra el mismo PDP sano, y luego paré el contenedor PDP y volví a enviar el pago de 45 dólares.

Salida de terminal: pep.py reiniciado con una clave vacía devuelve el error -32004 denied: pdp error HTTP 403, fail closed para el pago confirmado de 45 dólares; después de que podman pare permit-pdp, la misma llamada devuelve denied: pdp unreachable (URLError), fail closed, y pep.log muestra los dos motivos.
Una llamada permitida, rechazada dos veces. La política dice que sí, pero sin clave o sin PDP el punto de aplicación dice que no, y el log dice por qué.

Las dos veces se rechazó el pago confirmado de 45 dólares, que la política permite. La línea del log dice por qué: pdp error HTTP 403 y pdp unreachable, no decision false. Esa diferencia es la que debe vigilar una alerta.

Prueba 4: el Cloud PDP no evalúa ABAC#

El Cloud PDP aceptó la misma clave y el mismo lote, y respondió false cuatro veces. El motivo estaba en el context: ABAC is not supported yet in the Cloud PDP. Con pep.py apuntando al Cloud PDP, la lectura del saldo siguió pasando por el rol, pero el pago confirmado de 45 dólares se rechazó.

Salida de terminal: el mismo lote enviado a cloudpdp.api.permit.io responde cuatro veces decision false con ABAC is not supported yet in the Cloud PDP; pep.py apuntado al Cloud PDP permite get_balance y deniega las dos llamadas send_payment, y el log muestra abac NOT_SUPPORTED.
El Cloud PDP se salta ABAC. El rol sigue funcionando, la regla del límite no, así que incluso el pago confirmado de 45 dólares se rechaza.

Se queda cerrado, que es la dirección segura, pero parecería una política rota si no lo supieras. Límites como este necesitan el Edge PDP, o una política que no dependa de ABAC.

Antes de la clave: qué hace un PDP sin clave#

Antes de que existiera la cuenta ejecuté el mismo lab sin clave. Mantengo estos resultados porque muestran cómo se ve un PDP mal configurado desde el punto de aplicación.

El contenedor arrancó sin PDP_API_KEY y no terminó. Su watchdog reiniciaba una y otra vez el servidor API interno, y /healthy indicaba un error.

Salida de terminal: podman arranca permit-pdp desde pdp-v2 0.9.17, el contenedor está en marcha, el log dice Failed to get Environment API Key con ApiKeyError No API key specified, y el endpoint healthy devuelve status error con el mensaje de que el PDP aún no tiene clave API.
En marcha, pero no sano. El contenedor funciona, y el PDP dice claramente que no tiene clave API.

Las peticiones AuthZEN recibían códigos de estado y nunca una decisión: 401 sin cabecera, 403 con un token bearer vacío y 503 con una clave incorrecta. El contenedor también pedía un token para el documento de descubrimiento.

Salida de terminal: healthy responde HTTP 503, una evaluación AuthZEN sin cabecera Authorization responde Missing Authorization header con HTTP 401, y la misma petición con un token bearer vacío responde que quien llama no está autorizado, con HTTP 403.
Ninguna decisión, solo códigos de estado. 503 en la salud, 401 sin cabecera, 403 con una clave vacía.

Las seis llamadas por pep.py se denegaron, cada una con pdp error HTTP 403. El resultado correcto por el motivo equivocado. Para el agente, un PDP que perdió su clave se ve igual que una política estricta, así que solo el log puede distinguirlos.

Salida de terminal: seis respuestas JSON-RPC, cada una un error con código -32004 y el mensaje denied, pdp error HTTP 403, fail closed, seguidas del log del punto de aplicación con una línea DENY por llamada para support-bot y read-bot.
Seis llamadas, seis denegaciones. Hasta la inocente lectura del saldo se rechaza, porque el PDP no dio ninguna decisión.

El Cloud PDP servía su documento de descubrimiento sin token y respondía 401 a una evaluación sin token. Los cuerpos de error son distintos: JSON en el Cloud PDP, texto plano en el contenedor.

Salida de terminal: el documento de descubrimiento del Cloud PDP lista los endpoints de evaluación, de evaluaciones por lotes y las tres búsquedas, una evaluación sin token responde Unauthorized con HTTP 401, y el punto de aplicación apuntado al Cloud PDP deniega dos llamadas con pdp error HTTP 401, fail closed.
El descubrimiento es público, las decisiones no. Aparecen los cinco endpoints AuthZEN, y el punto de aplicación cierra ante el 401.

Trampas#

  • El Cloud PDP ignora ABAC. Responde false con NOT_SUPPORTED en el context. Para reglas de atributos usa el Edge PDP. Tampoco envía cabeceras CORS (Cross-Origin Resource Sharing), así que un navegador no puede leer sus respuestas: llámelo desde un servidor.
  • El context de la decisión cuenta mucho. Roles, atributos y nombres de reglas vuelven con cada respuesta. Registra los códigos, no se los pases al agente.
  • Una clave que falta no es una política. El contenedor sigue en marcha y responde 401, 403 o 503 según lo que envíes. Solo el PEP puede convertir eso en una denegación segura.
  • El sujeto viene de la sesión. pep.py ignora cualquier nombre de agente en los argumentos. Lo mismo vale para user_confirmed: en un gateway real debe venir de un paso de confirmación que el modelo no pueda falsificar.
  • Las listas de herramientas no se filtran. Según la documentación del gateway de Permit, tools/list devuelve todas las herramientas de origen y el control ocurre en cada llamada. Un agente puede ver una herramienta que no puede usar.
  • El gateway usa el check del SDK, no AuthZEN. AuthZEN es la forma en que otro PEP, como el mío, habla con el mismo PDP.

Qué haría con esto#

  1. Hacer que el punto de aplicación se cierre ante errores y registre el motivo, y luego parar el PDP en una prueba y comprobar la línea del log.
  2. Alertar cuando las denegaciones vengan de errores del PDP y no de decisiones de política.
  3. Mantener la clave del PDP del lado del servidor, en el gateway o en un sidecar, nunca en un navegador ni en el prompt de un agente.
  4. Elegir el tipo de PDP según el modelo de política: límites ABAC como este necesitan el Edge PDP.
  5. Quitar el context de la decisión antes de que algo vuelva al agente.

Qué no se probó#

Este lab usa su propio pequeño punto de aplicación en lugar del Permit MCP Gateway alojado. Solo usa funciones del plan gratuito Community.

Las imágenes de terminal se generaron a partir de la salida guardada del 22 de noviembre de 2026; las capturas de la consola son del mismo día. La clave nunca aparece.

Repite este lab#

Este lab necesita una cuenta gratuita de Permit.io, Linux con Podman o Docker, curl, jq y Python 3.10 o posterior. Cuenta con unos 25 minutos. env.sh pide la clave API de tu entorno Development en un aviso oculto; mantenla fuera de archivos, chats y capturas. Abre cada paso, copia los bloques y compara la salida con la mía.

Cada valor entre corchetes angulares es un marcador para tu entorno de prueba. Nada en esta página es un identificador o secreto real.

Define tus variables una sola vez

bash · env.sh
# Paste into every terminal you use for this lab.
export PDP_IMAGE="docker.io/permitio/pdp-v2:0.9.17"
export PDP_URL="http://localhost:7766"
# The API key of your Permit.io Development environment (Settings, API Keys). Type it at the prompt;
# it stays in this shell only. Never put it in a file you commit, a chat or a screenshot.
read -rsp "Permit API key: " PERMIT_API_KEY; echo; export PERMIT_API_KEY
# Headers for every AuthZEN call to the PDP.
AUTHZ=(-H "authorization: Bearer $PERMIT_API_KEY" -H "content-type: application/json")
Paso 1Carga la política en tu entorno de Permit

Objetivo. Instala el SDK de Python de Permit en un entorno virtual y ejecuta setup_permit.py para crear el recurso, los roles, el resource set ABAC y dos agentes.

Requisitos

  • Una cuenta gratuita de Permit.io; la clave API de su entorno Development escrita en el aviso de env.sh
  • Linux con Podman 5 o Docker, curl, jq y Python 3.10 o posterior
bash · setup_permit.py
cat > setup_permit.py <<'EOF'
"""Create the lab policy in a Permit.io environment (free Community plan).
Reads PERMIT_API_KEY from the environment. Run once; cleanup_permit.py removes it.
Model: one resource type per MCP server, one action per tool (the way Permit MCP Gateway maps servers and tools)."""
import asyncio, inspect, os
from permit import Permit

permit = Permit(token=os.environ["PERMIT_API_KEY"], pdp=os.environ.get("PDP_URL", "http://localhost:7766"))
api = permit.api


async def call(result):
    return await result if inspect.isawaitable(result) else result


async def main():
    # The MCP server "payments_mcp" and its three tools. Payment calls carry the amount and the confirmation.
    await call(api.resources.create({
        "key": "payments_mcp", "name": "Payments MCP server",
        "actions": {"get_balance": {}, "list_transactions": {}, "send_payment": {}},
        "attributes": {"amount_cents": {"type": "number"}, "user_confirmed": {"type": "bool"}},
    }))
    # The agent's delegated limit is a user attribute.
    await call(api.resource_attributes.create("__user", {"key": "limit_cents", "type": "number"}))
    # Scopes become roles. The reader can call the two read tools on every call.
    await call(api.roles.create({"key": "payments_reader", "name": "payments.read",
                                 "permissions": ["payments_mcp:get_balance", "payments_mcp:list_transactions"]}))
    # The writer gets send_payment only on calls inside the limit and confirmed by the user.
    await call(api.roles.create({"key": "payments_writer", "name": "payments.write"}))
    await call(api.condition_sets.create({
        "key": "payment_within_limit", "name": "Payment within limit and confirmed",
        "type": "resourceset", "resource_id": "payments_mcp",
        "conditions": {"allOf": [
            {"resource.amount_cents": {"less-than-equals": {"ref": "user.limit_cents"}}},
            {"resource.user_confirmed": {"equals": True}},
        ]},
    }))
    await call(api.condition_set_rules.create({
        "user_set": "payments_writer", "is_role": True,
        "permission": "payments_mcp:send_payment", "resource_set": "payment_within_limit",
    }))
    # Two agents: support-bot holds both scopes and a 5000-cent limit, read-bot only reads.
    for key, roles in (("support-bot", ["payments_reader", "payments_writer"]), ("read-bot", ["payments_reader"])):
        await call(api.users.sync({"key": key, "attributes": {"limit_cents": 5000}}))
        for role in roles:
            await call(api.users.assign_role({"user": key, "role": role, "tenant": "default"}))
    print("policy created: payments_mcp, 2 roles, 1 resource set, 2 agents")

asyncio.run(main())
EOF
bash · setup-policy.sh
python3 -m venv .venv && .venv/bin/pip install -q permit==3.0.1
.venv/bin/python setup_permit.py

Salida esperada

salida
policy created: payments_mcp, 2 roles, 1 resource set, 2 agents
Paso 2Arranca el Edge PDP de Permit con la clave

Objetivo. Arranca la imagen Edge PDP con la versión fija y PDP_API_KEY desde la variable del shell, espera a que descargue la política y lee su endpoint de salud.

Requisitos

  • La política del paso anterior existe
  • Puertos 7766 y 8383 libres
bash · start-pdp.sh
podman pull -q $PDP_IMAGE > /dev/null
podman run -d --name permit-pdp -p 7766:7000 -e PDP_API_KEY=$PERMIT_API_KEY $PDP_IMAGE | cut -c1-12
sleep 30
podman ps --format "{{.Names}} {{.Image}} {{.Status}}"
curl -s $PDP_URL/healthy | jq -c '{status, opa: .components.opa.status, horizon: .components.horizon.status}'

Salida esperada

salida
<container-id>
permit-pdp docker.io/permitio/pdp-v2:0.9.17 Up 30 seconds
{"status":"ok","opa":"ok","horizon":"ok"}
Paso 3Pregunta al PDP por AuthZEN

Objetivo. Lee el documento de descubrimiento, envía una evaluación, un lote de cuatro pagos y una búsqueda de sujetos, y compara las decisiones.

Requisitos

  • El PDP está sano
bash · authzen.sh
cat > get_balance.json <<'EOF'
{"subject": {"type": "user", "id": "support-bot"},
 "action": {"name": "get_balance"},
 "resource": {"type": "payments_mcp", "id": "payments_mcp", "properties": {"tenant": "default"}}}
EOF
cat > batch.json <<'EOF'
{"subject": {"type": "user", "id": "support-bot"},
 "action": {"name": "send_payment"},
 "evaluations": [
  {"resource": {"type": "payments_mcp", "id": "payments_mcp", "properties": {"tenant": "default", "amount_cents": 9000, "user_confirmed": true}}},
  {"resource": {"type": "payments_mcp", "id": "payments_mcp", "properties": {"tenant": "default", "amount_cents": 4500, "user_confirmed": true}}},
  {"resource": {"type": "payments_mcp", "id": "payments_mcp", "properties": {"tenant": "default", "amount_cents": 4500, "user_confirmed": false}}},
  {"subject": {"type": "user", "id": "read-bot"}, "resource": {"type": "payments_mcp", "id": "payments_mcp", "properties": {"tenant": "default", "amount_cents": 4500, "user_confirmed": true}}}
 ]}
EOF
cat > search.json <<'EOF'
{"subject": {"type": "user"},
 "action": {"name": "get_balance"},
 "resource": {"type": "payments_mcp", "id": "payments_mcp", "properties": {"tenant": "default"}}}
EOF
curl -s $PDP_URL/.well-known/authzen-configuration "${AUTHZ[@]}" | jq -c '[keys[] | sub("_endpoint$"; "")]'
curl -s -X POST $PDP_URL/access/v1/evaluation "${AUTHZ[@]}" -d @get_balance.json \
  | jq -c '{decision, roles: .context.rbac.allowing_roles}'
curl -s -X POST $PDP_URL/access/v1/evaluations "${AUTHZ[@]}" -d @batch.json \
  | jq -c '.evaluations[] | {decision, rbac: .context.rbac.code, abac: .context.abac.code}'
curl -s -X POST $PDP_URL/access/v1/search/subject "${AUTHZ[@]}" -d @search.json | jq -c '.results'

Salida esperada

salida
["access_evaluation","access_evaluations","policy_decision_point","search_action","search_resource","search_subject"]
{"decision":true,"roles":["payments_reader"]}
{"decision":false,"rbac":"no_permission","abac":"no_matching_rules"}
{"decision":true,"rbac":null,"abac":"allow"}
{"decision":false,"rbac":"no_permission","abac":"no_matching_rules"}
{"decision":false,"rbac":"no_permission","abac":"no_matching_rules"}
[{"type":"user","id":"support-bot"},{"type":"user","id":"read-bot"}]
Paso 4Pasa seis llamadas por el punto de aplicación

Objetivo. Escribe pep.py y calls.sh, arranca el punto de aplicación y envía las seis llamadas MCP del lab de OPA.

Requisitos

  • El PDP está sano
  • Puerto 8383 libre
bash · pep.py
cat > pep.py <<'EOF'
"""A tiny enforcement point in front of an MCP server, for the lab only.
It takes an MCP JSON-RPC tools/call, builds an AuthZEN Access Evaluation from what the
gateway knows (the session), not from what the model wrote, and asks the PDP.
Anything other than HTTP 200 with "decision": true is a deny. Standard library only."""
import json, os, urllib.request
from http.server import BaseHTTPRequestHandler, HTTPServer

PDP = os.environ.get("PDP_URL", "http://localhost:7766") + "/access/v1/evaluation"
KEY = os.environ.get("PERMIT_API_KEY", "")
# Stand-in for a verified session: in a real gateway this comes from the token and the delegation record.
SESSIONS = {"s-support": "support-bot", "s-read": "read-bot"}


def ask_pdp(agent, tool, args):
    body = {
        "subject": {"type": "user", "id": agent},
        "action": {"name": tool},
        "resource": {"type": "payments_mcp", "id": "payments_mcp", "properties": {
            "tenant": "default",
            "amount_cents": args.get("amount_cents", 0),
            "user_confirmed": bool(args.get("user_confirmed", False)),
        }},
    }
    req = urllib.request.Request(PDP, data=json.dumps(body).encode(), method="POST", headers={
        "content-type": "application/json", "authorization": f"Bearer {KEY}"})
    try:
        with urllib.request.urlopen(req, timeout=3) as r:
            answer = json.load(r)
    except urllib.error.HTTPError as e:
        return False, f"pdp error HTTP {e.code}, fail closed"
    except Exception as e:
        return False, f"pdp unreachable ({type(e).__name__}), fail closed"
    if not isinstance(answer, dict):
        return False, "pdp sent no decision, fail closed"
    # Permit puts its reasoning in "context". Keep the codes for our log, never send them to the agent.
    ctx = answer.get("context") or {}
    codes = ", ".join(f"{k} {ctx[k]['code']}" for k in ("rbac", "abac", "rebac")
                      if isinstance(ctx.get(k), dict) and "code" in ctx[k])
    return answer.get("decision") is True, f"decision {json.dumps(answer.get('decision'))} ({codes or 'no context'})"


class Gateway(BaseHTTPRequestHandler):
    def log_message(self, *a):
        pass

    def do_POST(self):
        msg = json.loads(self.rfile.read(int(self.headers["content-length"])))
        agent = SESSIONS.get(self.headers.get("x-session", ""))
        params = msg.get("params", {})
        if msg.get("method") != "tools/call" or not agent:
            allowed, why = False, "no session or not a tools/call"
        else:
            allowed, why = ask_pdp(agent, params.get("name", ""), params.get("arguments", {}))
        print(f"{agent} {params.get('name')} -> {'ALLOW' if allowed else 'DENY'}: {why}", flush=True)
        if allowed:
            out = {"jsonrpc": "2.0", "id": msg.get("id"),
                   "result": {"content": [{"type": "text", "text": f"called {params['name']} (stub)"}]}}
        else:
            # The agent learns that it was denied and whether the PDP failed, not the policy details.
            reason = "policy" if why.startswith("decision") else why
            out = {"jsonrpc": "2.0", "id": msg.get("id"), "error": {"code": -32004, "message": f"denied: {reason}"}}
        data = json.dumps(out).encode()
        self.send_response(200)
        self.send_header("content-type", "application/json")
        self.end_headers()
        self.wfile.write(data)


HTTPServer(("127.0.0.1", 8383), Gateway).serve_forever()
EOF
bash · calls.sh
cat > calls.sh <<'EOF'
# Six MCP tool calls through the enforcement point on :8383.
call() { # session tool arguments-json
  curl -s localhost:8383/mcp -H 'content-type: application/json' -H "x-session: $1" \
    -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"'"$2"'","arguments":'"$3"'}}'; echo; }
call s-support get_balance '{}'
call s-support send_payment '{"amount_cents":9000,"user_confirmed":true}'
call s-support send_payment '{"amount_cents":4500,"user_confirmed":true}'
call s-support send_payment '{"amount_cents":4500,"user_confirmed":false}'
call s-read    send_payment '{"amount_cents":4500,"user_confirmed":true}'
call s-support delete_account '{}'
EOF
python3 pep.py > pep.log &
sleep 1
bash calls.sh
cat pep.log

Salida esperada

salida
{"jsonrpc": "2.0", "id": 1, "result": {"content": [{"type": "text", "text": "called get_balance (stub)"}]}}
{"jsonrpc": "2.0", "id": 1, "error": {"code": -32004, "message": "denied: policy"}}
{"jsonrpc": "2.0", "id": 1, "result": {"content": [{"type": "text", "text": "called send_payment (stub)"}]}}
{"jsonrpc": "2.0", "id": 1, "error": {"code": -32004, "message": "denied: policy"}}
{"jsonrpc": "2.0", "id": 1, "error": {"code": -32004, "message": "denied: policy"}}
{"jsonrpc": "2.0", "id": 1, "error": {"code": -32004, "message": "denied: policy"}}
support-bot get_balance -> ALLOW: decision true (rbac allow)
support-bot send_payment -> DENY: decision false (rbac no_permission, abac no_matching_rules)
support-bot send_payment -> ALLOW: decision true (abac allow)
support-bot send_payment -> DENY: decision false (rbac no_permission, abac no_matching_rules)
read-bot send_payment -> DENY: decision false (rbac no_permission, abac no_matching_rules)
support-bot delete_account -> DENY: decision false (rbac no_such_action, abac no_matching_rules)
Paso 5Rompe la clave y luego para el PDP

Objetivo. Reinicia el punto de aplicación con una clave vacía, luego para el contenedor PDP, y envía cada vez el pago permitido de 45 dólares.

Requisitos

  • pep.py y calls.sh del paso anterior
bash · fail-closed.sh
pkill -f "python3 pep.py"; sleep 1
env -u PERMIT_API_KEY python3 pep.py > pep.log &
sleep 1
bash calls.sh | sed -n 3p
pkill -f "python3 pep.py"; sleep 1
python3 pep.py >> pep.log &
podman stop permit-pdp > /dev/null && podman ps -a --format "{{.Names}} {{.Status}}"
sleep 1
bash calls.sh | sed -n 3p
cat pep.log | sed -n '3p;9p'
podman start permit-pdp > /dev/null

Salida esperada

salida
{"jsonrpc": "2.0", "id": 1, "error": {"code": -32004, "message": "denied: pdp error HTTP 403, fail closed"}}
permit-pdp Exited (0) Less than a second ago
{"jsonrpc": "2.0", "id": 1, "error": {"code": -32004, "message": "denied: pdp unreachable (URLError), fail closed"}}
support-bot send_payment -> DENY: pdp error HTTP 403, fail closed
support-bot send_payment -> DENY: pdp unreachable (URLError), fail closed
Paso 6Envía el mismo lote al Cloud PDP

Objetivo. Envía el lote al Cloud PDP de Permit con la misma clave, luego apunta el punto de aplicación hacia él y envía las tres primeras llamadas.

Requisitos

  • HTTPS saliente hacia cloudpdp.api.permit.io
bash · cloud-pdp.sh
curl -s -X POST https://cloudpdp.api.permit.io/access/v1/evaluations "${AUTHZ[@]}" -d @batch.json \
  | jq -c '.evaluations[] | {decision, abac: .context.abac.reason}'
pkill -f "python3 pep.py"; sleep 1
PDP_URL=https://cloudpdp.api.permit.io python3 pep.py > pep.log &
sleep 1
bash calls.sh | head -3
cat pep.log | head -3

Salida esperada

salida
{"decision":false,"abac":"ABAC is not supported yet in the Cloud PDP"}
{"decision":false,"abac":"ABAC is not supported yet in the Cloud PDP"}
{"decision":false,"abac":"ABAC is not supported yet in the Cloud PDP"}
{"decision":false,"abac":"ABAC is not supported yet in the Cloud PDP"}
{"jsonrpc": "2.0", "id": 1, "result": {"content": [{"type": "text", "text": "called get_balance (stub)"}]}}
{"jsonrpc": "2.0", "id": 1, "error": {"code": -32004, "message": "denied: policy"}}
{"jsonrpc": "2.0", "id": 1, "error": {"code": -32004, "message": "denied: policy"}}
support-bot get_balance -> ALLOW: decision true (abac ABAC_EARLY_EXIT, rebac EARLY_EXIT)
support-bot send_payment -> DENY: decision false (rbac NO_PERMISSION, abac NOT_SUPPORTED, rebac NO_PERMISSION)
support-bot send_payment -> DENY: decision false (rbac NO_PERMISSION, abac NOT_SUPPORTED, rebac NO_PERMISSION)
Paso 7Limpieza

Objetivo. Para el punto de aplicación, borra el contenedor, elimina la política de tu entorno de Permit y borra los archivos.

Requisitos

  • Nada más usa los puertos 7766 y 8383
bash · cleanup.sh
cat > cleanup_permit.py <<'EOF'
"""Remove what setup_permit.py created. Reads PERMIT_API_KEY from the environment."""
import asyncio, inspect, os
from permit import Permit

api = Permit(token=os.environ["PERMIT_API_KEY"]).api


async def call(result):
    return await result if inspect.isawaitable(result) else result


async def main():
    for step in (lambda: api.users.delete("support-bot"), lambda: api.users.delete("read-bot"),
                 lambda: api.condition_sets.delete("payment_within_limit"),
                 lambda: api.roles.delete("payments_writer"), lambda: api.roles.delete("payments_reader"),
                 lambda: api.resource_attributes.delete("__user", "limit_cents"),
                 lambda: api.resources.delete("payments_mcp")):
        try:
            await call(step())
        except Exception as e:  # keep going, report what is left
            print("cleanup:", type(e).__name__, str(e)[:120])
    print("cleanup done")

asyncio.run(main())
EOF
pkill -f "python3 pep.py"
podman rm -f permit-pdp > /dev/null
.venv/bin/python cleanup_permit.py
rm -rf .venv setup_permit.py cleanup_permit.py pep.py calls.sh get_balance.json batch.json search.json pep.log
podman ps -a --format "{{.Names}}" | grep -c permit-pdp
curl -s -o /dev/null -w "%{http_code}\n" localhost:8383 ; curl -s -o /dev/null -w "%{http_code}\n" localhost:7766/healthy

Salida esperada

salida
cleanup done
0
000
000

Fuentes#

Coméntalo en X o LinkedIn

Seguir en X

Nuevos artículos por correo

Un correo a la semana con nuevos artículos y labs. Puedes darte de baja cuando quieras.

Tu dirección se guarda en Kit, el servicio que envía los correos. Detalles

Artículos y labs relacionados