iamops.dev
Argo en X Feed RSS
ESEspañol

Labs Práctico · 20 minutos

OPA detrás de AuthZEN: un punto de decisión para las llamadas a herramientas MCP

Escribí una política Rego para herramientas MCP, la probé en OPA 1.22.4 y puse un endpoint AuthZEN delante. Un pago de 90 $ sobre el límite de 50 $ se deniega.

Dos capturas del terminal de mi laboratorio de OPA: un opa eval de una petición que devuelve false con el motivo over delegated limit y la misma denegación devuelta por el endpoint AuthZEN.
En resumenEl 11 de noviembre de 2026 IndyKite y Obsidian describieron la misma…
  • El 11 de noviembre de 2026 IndyKite y Obsidian describieron la misma estructura: el agente o su runtime propone una llamada y un punto de decisión aparte responde por cada llamada.
  • La construí en local: una política Rego en OPA 1.22.4, seis pruebas unitarias y un pequeño endpoint AuthZEN Access Evaluation delante de OPA. Un pago de 90 $ contra un límite de 50 $ volvió con decision false y el motivo over delegated limit.
  • La política deniega por defecto. Una herramienta desconocida, un scope que falta, un pago por encima del límite y un pago sin confirmar fueron rechazados, y rompí una regla a propósito para ver fallar una prueba.
  • Cuando detuve OPA, mi shim no dio ninguna respuesta, así que el punto de aplicación debe tratar una decisión ausente como un rechazo.
  • No probados: un gateway MCP real como punto de aplicación, las pruebas de conformidad de AuthZEN, las API batch y de búsqueda y el registro de decisiones.
Repite este lab 8 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: OPA detrás de AuthZEN: un punto de decisión para las llamadas a herramientas MCP
Read the whole lab here (Markdown): https://iamops.dev/es/opa-authzen-mcp-tool-call-policy.md

What the lab needs before the first step:
- Linux on amd64 (for macOS or arm64 take the matching file from the release page), curl, jq and Python 3.13
- Ports 8181 and 8282 free

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.

El 11 de noviembre de 2026 dos proveedores publicaron la misma idea desde lados distintos. IndyKite lanzó su Intent Agent, que convierte un prompt en evaluaciones AuthZEN y, según su guía para desarrolladores, no decide nada: la decisión queda en el servicio AuthZEN. Obsidian describió un Runtime Policy Decision Engine en el que un MCP Security Proxy, un runtime de agentes o un gateway del cliente pausa una llamada a una herramienta, pide una decisión y aplica la respuesta.

Los dos reparten el trabajo igual. Algo que sostiene la petición pregunta y otra cosa decide. Quería ejecutar ese reparto en mi propio equipo con solo piezas de código abierto, así que lo construí: un motor de políticas (OPA) con una política para llamadas a herramientas MCP y un endpoint AuthZEN fino delante.

Escribí una explicación breve de AuthZEN, OPA y Cedar.

Qué construye el lab#

  • Una política Rego que recibe una petición con forma AuthZEN (subject, action, resource, context) para un tools/call de MCP y devuelve un booleano más los motivos.
  • Seis pruebas unitarias que corren sin conexión con el ejecutor de pruebas de OPA.
  • Un pequeño endpoint de Python que responde a POST /access/v1/evaluation y al documento de metadatos del PDP, y reenvía la petición a OPA como input.
  • Dos rechazos que quería ver: un pago por encima del límite delegado al agente y qué pasa cuando OPA no está.

El dinero va en centavos de dólar estadounidense. El agente puede pagar hasta 5000 centavos, es decir, 50 $.

Diagrama de secuencia: un llamante envía una evaluación AuthZEN de un tools/call MCP a un endpoint pequeño, que la reenvía a OPA 1.22.4. Un pago de 9000 centavos frente a un límite de 5000 se deniega con el motivo over delegated limit, 4500 centavos se permite, otras llamadas incorrectas se deniegan con motivos, y un OPA detenido no da ninguna respuesta HTTP.
La decisión. La petición nombra al agente, el tools/call, la herramienta, el importe y la confirmación. 9000 centavos frente a un límite de 5000 vuelven como decision false con el motivo over delegated limit. 4500 centavos con confirmación se permite. Un scope ausente, la falta de confirmación o una herramienta desconocida se deniegan con motivos. Si OPA está detenido, el endpoint no da ninguna respuesta HTTP.

Preparación#

OPA 1.22.4 es un único binario estático de la página de versiones. El endpoint es un archivo de menos de 40 líneas de Python 3.13 con solo la biblioteca estándar. También necesitas curl y jq. No hay Docker, ni base de datos, ni cuenta. El lab abre el puerto 8181 para OPA y el 8282 para el endpoint, ambos en localhost.

La política#

La petición es la que un punto de aplicación construiría a partir de un tools/call de MCP. El subject es el agente con sus scopes y su límite, la resource es la herramienta y el context lleva el importe y si el usuario confirmó.

La política tiene un catálogo de herramientas que dice qué scope necesita cada una y si mueve dinero. decision vale false mientras ninguna regla la ponga en true. Las herramientas de lectura necesitan su scope. Una herramienta que mueve dinero necesita el scope, un importe igual o menor que el límite y una confirmación:

plaintext
decision if {
	input.subject.type == "agent"
	input.action.name == "tools/call"
	tool.scope in input.subject.properties.scopes
	tool.moves_money
	input.context.amount_cents <= input.subject.properties.limit_cents
	input.context.user_confirmed
}

Un segundo conjunto, reasons, explica los rechazos. Los archivos completos están en los pasos del lab más abajo.

Primero las pruebas#

El ejecutor opa test encuentra las reglas test_ en los archivos _test.rego. Escribí seis: una lectura está permitida, una escritura sin el scope se deniega, un pago confirmado dentro del límite está permitido, un pago por encima del límite se deniega con el motivo correcto, un pago sin confirmar se deniega y una herramienta desconocida se deniega. opa check --strict y opa fmt pasaron antes de las pruebas.

Salida de terminal de OPA 1.22.4: información de versión, fmt y comprobación estricta superados y seis pruebas unitarias en PASS con el resumen 6 de 6.
Comprobaciones y pruebas. La comprobación de formato, la comprobación estricta y las seis pruebas pasan en OPA 1.22.4.

Para ver si las pruebas pueden fallar, en una copia borré la línea user_confirmed de la segunda regla. Cinco pruebas siguieron pasando y test_payment_needs_confirmation falló. Es la prueba haciendo su trabajo.

Una petición, sin conexión#

opa eval toma la política y un archivo de petición sin arrancar un servidor. La petición es el agente support-bot con ambos scopes y un límite de 5000 centavos, que llama a send_payment por 9000 centavos con la confirmación del usuario.

Salida de terminal de dos comandos opa eval: la decisión es false y el conjunto de motivos contiene over delegated limit.
Un pago de 90 $ contra un límite de 50 $. La decisión es false y el motivo es «over delegated limit».

El endpoint AuthZEN#

OPA corre como servidor en el puerto 8181 y el endpoint del puerto 8282 se pone delante. La especificación de AuthZEN define la petición como subject, action, resource y context, y la respuesta como un decision booleano obligatorio con un context opcional. Deja el contenido de ese context a la implementación. Puse los motivos del rechazo bajo reason_admin, la clave de su ejemplo no normativo. El documento de metadatos está en /.well-known/authzen-configuration.

Salida de terminal: el documento de metadatos del PDP con dos URL, un rechazo con decision false y el motivo over delegated limit, y una autorización con decision true tras cambiar el importe a 4500 centavos.
La misma petición por AuthZEN. 9000 centavos se deniegan con un motivo. Cambiando solo el importe a 4500 centavos se obtiene decision true.

El endpoint es una herramienta didáctica. No autentica a quien llama, no valida la entrada y no tiene API batch ni de búsqueda, así que no es un PDP conforme.

Más rechazos, y OPA que desaparece#

Envié tres peticiones más con una pequeña función de shell llamada ask. Con solo el scope de lectura, el pago se denegó por scope que falta y también por el límite, porque el importe seguía siendo 9000. Con un importe de 4500 centavos y user_confirmed en false, se denegó por la confirmación que falta. Una herramienta llamada delete_account se denegó como desconocida.

Salida de terminal de tres peticiones denegadas con los motivos missing scope y over delegated limit, user did not confirm y unknown tool, seguidas de una petición tras detener OPA que devuelve el estado HTTP 000.
Tres rechazos más. Cada uno llega con sus motivos. Tras detener OPA, la petición no recibe ninguna respuesta HTTP, que curl muestra como 000.

Después detuve OPA y volví a enviar la petición de 4500 centavos. El shim lanzó una excepción y cortó la conexión, y curl imprimió 000. No había ningún decision: false que aplicar. Un gateway que espera un true puede tratarlo como un rechazo. Un gateway que solo bloquea ante un false explícito dejaría pasar la llamada. No probé un gateway real, así que esto es un motivo para comprobar el tuyo, no un hallazgo sobre ningún producto.

Trampas#

  • Las herramientas desconocidas no necesitan regla. Cuando la herramienta no está en el catálogo, tool queda sin definir, así que toda regla decision queda sin definir y se aplica el valor por defecto false. Una prueba lo fija.
  • Los motivos pueden acumularse. reasons es un conjunto, y la petición con solo el scope de lectura devolvió dos a la vez.
  • La política confía en el context. user_confirmed vale lo que valga el punto de aplicación que lo rellena. Un modelo nunca debe poder rellenarlo. La guía de IndyKite dice algo parecido del subject: viene de la identidad verificada de quien llama, nunca del texto del prompt.
  • Denegar por defecto es una elección. La entrada de Obsidian dice que las llamadas a herramientas que no coinciden con ninguna política continúan. Las mías se rechazan. Ninguna de las dos es errónea, pero decídelo a propósito.

Qué haría con esto#

  1. Poner el punto de aplicación en el gateway o proxy que ve cada tools/call, no dentro del agente.
  2. Construir el subject a partir del token verificado y del registro de delegación, no de algo que escribió el modelo.
  3. Guardar la política en un repositorio con sus pruebas y ejecutar opa test en CI.
  4. Hacer que el punto de aplicación deniegue ante un error, y probarlo deteniendo el punto de decisión.

Qué no probé#

No probé un gateway MCP real como punto de aplicación. No ejecuté pruebas de conformidad de AuthZEN, la API de evaluaciones batch, las API de búsqueda ni ningún otro punto de decisión AuthZEN. No probé los bundles de OPA, los registros de decisiones ni el rendimiento de las políticas. Este lab no tiene grabación. El lab no usa credenciales ni tokens.

Las imágenes de terminal se generaron a partir de la salida guardada de la ejecución del 20 de noviembre de 2026.

Repite este lab#

Este lab necesita Linux en amd64, curl, jq y Python 3.13. Cuenta con unos 20 minutos. 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. No secrets are involved.
export OPA_VERSION="1.22.4"
export OPA_URL="http://localhost:8181"
export PDP_URL="http://localhost:8282"
Paso 1Descarga OPA

Objetivo. Descarga el binario estático único de OPA con una versión fija e imprime su versión.

Requisitos

  • Linux en amd64 (para macOS o arm64 toma el archivo correspondiente de la página de versiones), curl, jq y Python 3.13
  • Puertos 8181 y 8282 libres
bash · get-opa.sh
curl -sSL -o opa "https://github.com/open-policy-agent/opa/releases/download/v$OPA_VERSION/opa_linux_amd64_static"
chmod +x opa
./opa version | head -1

Salida esperada

salida
Version: 1.22.4
Paso 2Escribe la política

Objetivo. Crea la política Rego: un catálogo de herramientas, un valor por defecto false, dos reglas de decisión y un conjunto de motivos de rechazo.

Requisitos

  • Paso 1 hecho, en la misma carpeta
bash · write-policy.sh
cat > mcp_tools.rego <<'EOF'
# Which MCP tools may an agent call? The input has the shape of an
# AuthZEN Access Evaluation request: subject, action, resource, context.
package mcp.tools

default decision := false

# Tool catalog: the scope each tool needs and whether it moves money.
catalog := {
	"get_balance": {"scope": "payments.read", "moves_money": false},
	"list_transactions": {"scope": "payments.read", "moves_money": false},
	"send_payment": {"scope": "payments.write", "moves_money": true},
}

tool := catalog[input.resource.id]

decision if {
	input.subject.type == "agent"
	input.action.name == "tools/call"
	tool.scope in input.subject.properties.scopes
	not tool.moves_money
}

decision if {
	input.subject.type == "agent"
	input.action.name == "tools/call"
	tool.scope in input.subject.properties.scopes
	tool.moves_money
	input.context.amount_cents <= input.subject.properties.limit_cents
	input.context.user_confirmed
}

# Explain denials, the way a PDP would put reasons in the AuthZEN context.
reasons contains "unknown tool" if not catalog[input.resource.id]

reasons contains "missing scope" if {
	tool
	not tool.scope in input.subject.properties.scopes
}

reasons contains "over delegated limit" if {
	tool.moves_money
	input.context.amount_cents > input.subject.properties.limit_cents
}

reasons contains "user did not confirm" if {
	tool.moves_money
	not input.context.user_confirmed
}
EOF
head -3 mcp_tools.rego

Salida esperada

salida
# Which MCP tools may an agent call? The input has the shape of an
# AuthZEN Access Evaluation request: subject, action, resource, context.
package mcp.tools
Paso 3Escribe las pruebas y ejecútalas

Objetivo. Escribe seis pruebas unitarias y ejecuta el formateador, la comprobación estricta y el ejecutor de pruebas. Todo debe pasar.

Requisitos

  • El archivo de política del paso anterior
bash · unit-tests.sh
cat > mcp_tools_test.rego <<'EOF'
package mcp.tools_test

import data.mcp.tools

agent(scopes, limit) := {"type": "agent", "id": "support-bot", "properties": {"scopes": scopes, "limit_cents": limit}}

call(subject, tool, ctx) := {"subject": subject, "action": {"name": "tools/call"}, "resource": {"type": "mcp_tool", "id": tool}, "context": ctx}

test_read_allowed if {
	tools.decision with input as call(agent(["payments.read"], 0), "get_balance", {})
}

test_write_needs_scope if {
	not tools.decision with input as call(agent(["payments.read"], 50000), "send_payment", {"amount_cents": 100, "user_confirmed": true})
}

test_payment_within_limit_confirmed if {
	tools.decision with input as call(agent(["payments.write"], 5000), "send_payment", {"amount_cents": 4500, "user_confirmed": true})
}

test_payment_over_limit_denied if {
	r := tools.reasons with input as call(agent(["payments.write"], 5000), "send_payment", {"amount_cents": 9000, "user_confirmed": true})
	"over delegated limit" in r
}

test_payment_needs_confirmation if {
	not tools.decision with input as call(agent(["payments.write"], 5000), "send_payment", {"amount_cents": 4500, "user_confirmed": false})
}

test_unknown_tool_denied if {
	not tools.decision with input as call(agent(["payments.write"], 5000), "delete_account", {})
}
EOF
./opa fmt --list --fail . && ./opa check --strict . && echo "fmt + strict check: OK"
./opa test . -v

Salida esperada

salida
fmt + strict check: OK
mcp_tools_test.rego:30:
data.mcp.tools_test.test_unknown_tool_denied: PASS (970.514µs)
mcp_tools_test.rego:17:
data.mcp.tools_test.test_payment_within_limit_confirmed: PASS (984.282µs)
mcp_tools_test.rego:26:
data.mcp.tools_test.test_payment_needs_confirmation: PASS (1.131509ms)
mcp_tools_test.rego:21:
data.mcp.tools_test.test_payment_over_limit_denied: PASS (1.197352ms)
mcp_tools_test.rego:13:
data.mcp.tools_test.test_write_needs_scope: PASS (1.433506ms)
mcp_tools_test.rego:9:
data.mcp.tools_test.test_read_allowed: PASS (1.255784ms)
--------------------------------------------------------------------------------
PASS: 6/6
Paso 4Evalúa una petición sin conexión

Objetivo. Escribe una petición con forma AuthZEN para un pago de 90 dólares con un límite de 50 dólares y evalúala con opa eval, sin servidor.

Requisitos

  • Los importes están en centavos: 9000 son 90 dólares y 5000 son 50 dólares
bash · eval-offline.sh
cat > request.json <<'EOF'
{
  "subject": { "type": "agent", "id": "support-bot",
               "properties": { "scopes": ["payments.read", "payments.write"], "limit_cents": 5000 } },
  "action": { "name": "tools/call" },
  "resource": { "type": "mcp_tool", "id": "send_payment" },
  "context": { "amount_cents": 9000, "user_confirmed": true }
}
EOF
./opa eval -d mcp_tools.rego -i request.json 'data.mcp.tools.decision' --format pretty
./opa eval -d mcp_tools.rego -i request.json 'data.mcp.tools.reasons' --format pretty

Salida esperada

salida
false
[
  "over delegated limit"
]
Paso 5Arranca OPA como servidor y añade el endpoint AuthZEN

Objetivo. Sirve la política desde OPA en el puerto 8181, comprueba su API de decisión, arranca el pequeño endpoint de Python en el puerto 8282 y lee su documento de metadatos.

Requisitos

  • Pasos 2 a 4 hechos
  • El endpoint es una herramienta didáctica, no un PDP AuthZEN conforme; déjalo en localhost
bash · serve-opa.sh
./opa run --server --addr localhost:8181 mcp_tools.rego > opa-server.log 2>&1 &
sleep 2
curl -s $OPA_URL/health
curl -s $OPA_URL/v1/data/mcp/tools/decision -d '{"input":'"$(cat request.json)"'}'
bash · start-endpoint.sh
cat > authzen_pdp.py <<'EOF'
"""A minimal AuthZEN Access Evaluation endpoint in front of OPA.
Standard library only (Python 3.10+). OPA runs on :8181 with mcp_tools.rego loaded.
This is a teaching shim, not a conformant AuthZEN PDP."""
import json
import urllib.request
from http.server import BaseHTTPRequestHandler, HTTPServer

OPA = "http://localhost:8181/v1/data/mcp/tools"


class PDP(BaseHTTPRequestHandler):
    def _send(self, code, body):
        data = json.dumps(body).encode()
        self.send_response(code)
        self.send_header("content-type", "application/json")
        self.end_headers()
        self.wfile.write(data)

    def do_GET(self):
        if self.path == "/.well-known/authzen-configuration":
            base = f"http://{self.headers['host']}"
            return self._send(200, {"policy_decision_point": base,
                                    "access_evaluation_endpoint": f"{base}/access/v1/evaluation"})
        self._send(404, {})

    def do_POST(self):
        if self.path != "/access/v1/evaluation":
            return self._send(404, {})
        request = json.loads(self.rfile.read(int(self.headers["content-length"])))
        opa_req = urllib.request.Request(OPA, data=json.dumps({"input": request}).encode(),
                                         headers={"content-type": "application/json"})
        result = json.load(urllib.request.urlopen(opa_req)).get("result", {})
        body = {"decision": bool(result.get("decision"))}
        if not body["decision"]:
            body["context"] = {"reason_admin": {"403": ", ".join(sorted(result.get("reasons", [])))}}
        self._send(200, body)


HTTPServer(("127.0.0.1", 8282), PDP).serve_forever()
EOF
python3 authzen_pdp.py > pdp.log 2>&1 &
sleep 1
curl -s $PDP_URL/.well-known/authzen-configuration | jq .

Salida esperada

salida
{}
{"result":false}
{
  "policy_decision_point": "http://localhost:8282",
  "access_evaluation_endpoint": "http://localhost:8282/access/v1/evaluation"
}
Paso 6Pide una decisión: 90 dólares y luego 45

Objetivo. Envía la petición al endpoint de evaluación AuthZEN. Debe rechazar con un motivo. Luego cambia solo el importe a 4500 centavos y vuelve a preguntar.

Requisitos

  • OPA y el endpoint están en marcha
bash · evaluate.sh
curl -s $PDP_URL/access/v1/evaluation -H 'content-type: application/json' -d @request.json | jq .
jq '.context.amount_cents=4500' request.json \
  | curl -s $PDP_URL/access/v1/evaluation -H 'content-type: application/json' -d @- | jq .

Salida esperada

salida
{
  "decision": false,
  "context": {
    "reason_admin": {
      "403": "over delegated limit"
    }
  }
}
{
  "decision": true
}
Paso 7Prueba más rechazos y luego detén OPA

Objetivo. Envía tres peticiones más: un scope que falta, un pago sin confirmar y una herramienta desconocida. Luego detén OPA y vuelve a preguntar para ver que no llega ninguna decisión.

Requisitos

  • El endpoint está en marcha
bash · denials.sh
ask() { curl -s $PDP_URL/access/v1/evaluation -H 'content-type: application/json' -d @- | jq -c .; }
jq '.subject.properties.scopes=["payments.read"]' request.json | ask
jq '.context.user_confirmed=false | .context.amount_cents=4500' request.json | ask
jq '.resource.id="delete_account"' request.json | ask
# Now stop OPA and ask again: no decision comes back
pkill -f "opa run --server"
sleep 1
curl -s -o /dev/null -w "%{http_code}\n" -m 5 $PDP_URL/access/v1/evaluation -H 'content-type: application/json' -d @request.json

Salida esperada

salida
{"decision":false,"context":{"reason_admin":{"403":"missing scope, over delegated limit"}}}
{"decision":false,"context":{"reason_admin":{"403":"user did not confirm"}}}
{"decision":false,"context":{"reason_admin":{"403":"unknown tool"}}}
000
Paso 8Limpieza

Objetivo. Detén ambos procesos y borra los archivos que creó el lab.

Requisitos

  • Nada más usa los puertos 8181 y 8282
bash · cleanup.sh
pkill -f "opa run --server" || true
pkill -f authzen_pdp.py || true
rm -f opa mcp_tools.rego mcp_tools_test.rego request.json authzen_pdp.py opa-server.log pdp.log
unset -f ask
# check: nothing listens on ports 8181 and 8282 any more
curl -s -o /dev/null -w "%{http_code}\n" "$OPA_URL/health"
curl -s -o /dev/null -w "%{http_code}\n" "$PDP_URL/"

Salida esperada

salida
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