iamops.dev
Argo su X Feed RSS
ITItaliano

Lab Pratico · 20 minuti

OPA dietro AuthZEN: un punto di decisione per le chiamate ai tool MCP

Ho scritto una policy Rego per i tool MCP, testata su OPA 1.22.4, con un endpoint AuthZEN davanti. Un pagamento da 90 $ oltre il limite di 50 $ viene negato.

Due catture del terminale dal mio lab OPA: un opa eval di una richiesta che restituisce false con il motivo over delegated limit e lo stesso rifiuto restituito dall'endpoint AuthZEN.
In breveL'11 novembre 2026 IndyKite e Obsidian hanno descritto la stessa…
  • L'11 novembre 2026 IndyKite e Obsidian hanno descritto la stessa struttura: l'agente o il suo runtime propone una chiamata e un punto di decisione separato risponde per ogni chiamata.
  • L'ho costruita in locale: una policy Rego in OPA 1.22.4, sei test unitari e un piccolo endpoint AuthZEN Access Evaluation davanti a OPA. Un pagamento da 90 $ contro un limite di 50 $ è tornato con decision false e il motivo over delegated limit.
  • La policy nega per impostazione predefinita. Un tool sconosciuto, uno scope mancante, un pagamento oltre il limite e un pagamento non confermato sono stati rifiutati, e ho rotto una regola di proposito per vedere fallire un test.
  • Quando ho fermato OPA, il mio shim non ha dato nessuna risposta, quindi il punto di applicazione deve trattare una decisione mancante come un rifiuto.
  • Non provati: un vero gateway MCP come punto di applicazione, i test di conformità AuthZEN, le API batch e di ricerca e il logging delle decisioni.
Ripeti questo lab 8 passi

Ho scritto questo lab perché tu possa rifarlo per conto tuo. Ogni passo ha i comandi da copiare e l'output che ho ottenuto io, e puoi segnarlo come fatto. Le spunte restano solo nel tuo browser.

Vai ai passi

Come funziona

Copia un prompt già pronto per Claude Code, Cursor, Codex o un altro agente di codice. Solo per ambienti di test.

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

Lab: OPA dietro AuthZEN: un punto di decisione per le chiamate ai tool MCP
Read the whole lab here (Markdown): https://iamops.dev/it/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.

L’11 novembre 2026 due fornitori hanno pubblicato la stessa idea da lati diversi. IndyKite ha rilasciato il suo Intent Agent, che trasforma un prompt in valutazioni AuthZEN e, secondo la sua guida per sviluppatori, non decide nulla: la decisione resta al servizio AuthZEN. Obsidian ha descritto un Runtime Policy Decision Engine in cui un MCP Security Proxy, un runtime di agenti o un gateway del cliente mette in pausa una chiamata a un tool, chiede una decisione e applica la risposta.

Entrambi dividono il lavoro allo stesso modo. Qualcosa che tiene la richiesta chiede, e qualcos’altro decide. Volevo far girare questa divisione sul mio computer con sole parti open source, così l’ho costruita: un motore di policy (OPA) con una policy per le chiamate ai tool MCP e un sottile endpoint AuthZEN davanti.

Ho scritto una breve spiegazione di AuthZEN, OPA e Cedar.

Cosa costruisce il lab#

  • Una policy Rego che riceve una richiesta in forma AuthZEN (subject, action, resource, context) per un tools/call MCP e restituisce un booleano più i motivi.
  • Sei test unitari che girano offline con il test runner di OPA.
  • Un piccolo endpoint Python che risponde a POST /access/v1/evaluation e al documento di metadati del PDP, e inoltra la richiesta a OPA come input.
  • Due rifiuti che volevo vedere: un pagamento oltre il limite delegato all’agente e cosa succede quando OPA non c’è.

Il denaro è in centesimi di dollaro USA. L’agente può pagare fino a 5000 centesimi, cioè 50 $.

Diagramma di sequenza: un chiamante invia una valutazione AuthZEN per un tools/call MCP a un piccolo endpoint, che la inoltra a OPA 1.22.4. Un pagamento di 9000 centesimi rispetto a un limite di 5000 viene negato con il motivo over delegated limit, 4500 centesimi è consentito, altre chiamate errate sono negate con i motivi, e un OPA fermato non dà alcuna risposta HTTP.
La decisione. La richiesta indica l'agente, il tools/call, lo strumento, l'importo e la conferma. 9000 centesimi rispetto a un limite di 5000 tornano come decision false con il motivo over delegated limit. 4500 centesimi con conferma è consentito. Scope mancante, mancanza di conferma o uno strumento sconosciuto sono negati con i motivi. Se OPA è fermo, l'endpoint non dà alcuna risposta HTTP.

Preparazione#

OPA 1.22.4 è un singolo binario statico dalla pagina delle release. L’endpoint è un file di meno di 40 righe di Python 3.13 con la sola libreria standard. Servono anche curl e jq. Non ci sono Docker, database né account. Il lab apre la porta 8181 per OPA e la 8282 per l’endpoint, entrambe su localhost.

La policy#

La richiesta è quella che un punto di applicazione costruirebbe da un tools/call MCP. Il subject è l’agente con i suoi scope e il suo limite, la resource è il tool e il context porta l’importo e se l’utente ha confermato.

La policy ha un catalogo dei tool che dice quale scope serve a ciascuno e se sposta denaro. decision vale false finché una regola non la rende true. I tool di lettura richiedono il loro scope. Un tool che sposta denaro richiede lo scope, un importo pari o inferiore al limite e una conferma:

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 secondo insieme, reasons, spiega i rifiuti. I file completi sono nei passi del lab qui sotto.

Prima i test#

Il runner opa test trova le regole test_ nei file _test.rego. Ne ho scritti sei: una lettura è consentita, una scrittura senza lo scope è negata, un pagamento confermato entro il limite è consentito, un pagamento oltre il limite è negato con il motivo giusto, un pagamento non confermato è negato e un tool sconosciuto è negato. opa check --strict e opa fmt sono passati prima dei test.

Output del terminale di OPA 1.22.4: informazioni sulla versione, fmt e controllo strict superati e sei test unitari elencati come PASS con il riepilogo 6 su 6.
Controlli e test. Il controllo di formato, il controllo strict e tutti e sei i test passano su OPA 1.22.4.

Per vedere se i test possono fallire, in una copia ho cancellato la riga user_confirmed dalla seconda regola. Cinque test sono passati e test_payment_needs_confirmation è fallito. È il test che fa il suo lavoro.

Una richiesta, offline#

opa eval prende la policy e un file di richiesta senza avviare un server. La richiesta è l’agente support-bot con entrambi gli scope e un limite di 5000 centesimi, che chiama send_payment per 9000 centesimi con la conferma dell’utente.

Output del terminale di due comandi opa eval: la decisione è false e l'insieme dei motivi contiene over delegated limit.
Un pagamento da 90 $ contro un limite di 50 $. La decisione è false e il motivo è «over delegated limit».

L’endpoint AuthZEN#

OPA gira come server sulla porta 8181 e l’endpoint sulla porta 8282 gli sta davanti. La specifica AuthZEN definisce la richiesta come subject, action, resource e context, e la risposta come un decision booleano obbligatorio con un context facoltativo. Il contenuto di quel context è lasciato all’implementazione. Ho messo i motivi del rifiuto sotto reason_admin, la chiave usata dal suo esempio non normativo. Il documento di metadati sta in /.well-known/authzen-configuration.

Output del terminale: il documento di metadati del PDP con due URL, un rifiuto con decision false e il motivo over delegated limit, e un'autorizzazione con decision true dopo aver portato l'importo a 4500 centesimi.
La stessa richiesta via AuthZEN. 9000 centesimi vengono negati con un motivo. Cambiando solo l'importo a 4500 centesimi si ottiene decision true.

L’endpoint è uno strumento didattico. Non autentica i chiamanti, non valida l’input e non ha API batch né di ricerca, quindi non è un PDP conforme.

Altri rifiuti, e OPA che sparisce#

Ho inviato altre tre richieste con una piccola funzione di shell chiamata ask. Con il solo scope di lettura, il pagamento è stato negato per scope mancante e anche per il limite, perché l’importo era ancora 9000. Con un importo di 4500 centesimi e user_confirmed a false, è stato negato per la conferma mancante. Un tool chiamato delete_account è stato negato come sconosciuto.

Output del terminale di tre richieste negate con i motivi missing scope e over delegated limit, user did not confirm e unknown tool, seguite da una richiesta dopo l'arresto di OPA che restituisce lo stato HTTP 000.
Altri tre rifiuti. Ognuno arriva con i suoi motivi. Dopo l'arresto di OPA la richiesta non riceve nessuna risposta HTTP, che curl mostra come 000.

Poi ho fermato OPA e ho inviato di nuovo la richiesta da 4500 centesimi. Lo shim ha sollevato un’eccezione e ha chiuso la connessione, quindi curl ha stampato 000. Non c’era nessun decision: false da applicare. Un gateway che aspetta un true può trattarlo come un rifiuto. Un gateway che blocca solo davanti a un false esplicito lascerebbe passare la chiamata. Non ho provato un gateway reale, quindi questo è un motivo per controllare il tuo, non un risultato su un prodotto.

Trappole#

  • I tool sconosciuti non servono una regola. Quando il tool non è nel catalogo, tool è indefinito, quindi ogni regola decision è indefinita e vale il valore predefinito false. Un test lo fissa.
  • I motivi possono sommarsi. reasons è un insieme, e la richiesta con il solo scope di lettura ne ha restituiti due insieme.
  • La policy si fida del context. user_confirmed vale quanto il punto di applicazione che lo imposta. Un modello non deve poterlo compilare. La guida di IndyKite dice qualcosa di simile per il subject: viene dall’identità verificata del chiamante, mai dal testo del prompt.
  • Il rifiuto predefinito è una scelta. Il post di Obsidian dice che le chiamate ai tool che non corrispondono a nessuna policy proseguono. Le mie vengono rifiutate. Nessuna delle due è sbagliata, ma decidi di proposito.

Cosa farei con questo#

  1. Mettere il punto di applicazione nel gateway o nel proxy che vede ogni tools/call, non dentro l’agente.
  2. Costruire il subject dal token verificato e dal registro delle deleghe, non da qualcosa che ha scritto il modello.
  3. Tenere la policy in un repository con i suoi test e far girare opa test in CI.
  4. Far sì che il punto di applicazione neghi in caso di errore, e verificarlo fermando il punto di decisione.

Cosa non ho provato#

Non ho provato un vero gateway MCP come punto di applicazione. Non ho eseguito test di conformità AuthZEN, l’API delle valutazioni batch, le API di ricerca né altri punti di decisione AuthZEN. Non ho provato i bundle di OPA, i log delle decisioni né le prestazioni delle policy. Per questo lab non c’è una registrazione. Il lab non usa credenziali né token.

Le immagini del terminale sono state generate dall’output salvato dell’esecuzione del 20 novembre 2026.

Ripeti questo lab#

Per questo lab servono Linux su amd64, curl, jq e Python 3.13. Conta circa 20 minuti. Apri ogni passo, copia i blocchi e confronta l’output con il mio.

Ogni valore tra parentesi angolari è un segnaposto per il tuo ambiente di test. Nulla in questa pagina è un identificativo o un segreto reale.

Imposta le variabili una sola volta

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"
Passo 1Scarica OPA

Obiettivo. Scarica il singolo binario statico di OPA a una versione fissata e stampa la versione.

Prerequisiti

  • Linux su amd64 (per macOS o arm64 prendi il file corrispondente dalla pagina delle release), curl, jq e Python 3.13
  • Porte 8181 e 8282 libere
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

Output atteso

output
Version: 1.22.4
Passo 2Scrivi la policy

Obiettivo. Crea la policy Rego: un catalogo di tool, un valore predefinito false, due regole di decisione e un insieme di motivi di rifiuto.

Prerequisiti

  • Passo 1 fatto, nella stessa cartella
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

Output atteso

output
# 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
Passo 3Scrivi i test ed eseguili

Obiettivo. Scrivi sei test unitari, poi esegui il formatter, il controllo strict e il test runner. Tutti devono passare.

Prerequisiti

  • Il file della policy del passo precedente
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

Output atteso

output
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
Passo 4Valuta una richiesta offline

Obiettivo. Scrivi una richiesta in forma AuthZEN per un pagamento da 90 dollari contro un limite di 50 dollari e valutala con opa eval, senza server.

Prerequisiti

  • Gli importi sono in centesimi: 9000 sono 90 dollari e 5000 sono 50 dollari
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

Output atteso

output
false
[
  "over delegated limit"
]
Passo 5Avvia OPA come server e aggiungi l’endpoint AuthZEN

Obiettivo. Servi la policy da OPA sulla porta 8181, controlla la sua API di decisione, poi avvia il piccolo endpoint Python sulla porta 8282 e leggi il suo documento di metadati.

Prerequisiti

  • Passi da 2 a 4 fatti
  • L’endpoint è uno strumento didattico, non un PDP AuthZEN conforme; tienilo su 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 .

Output atteso

output
{}
{"result":false}
{
  "policy_decision_point": "http://localhost:8282",
  "access_evaluation_endpoint": "http://localhost:8282/access/v1/evaluation"
}
Passo 6Chiedi una decisione: 90 dollari, poi 45

Obiettivo. Invia la richiesta all’endpoint di valutazione AuthZEN. Deve rifiutare con un motivo. Poi cambia solo l’importo in 4500 centesimi e chiedi di nuovo.

Prerequisiti

  • OPA e l’endpoint sono in esecuzione
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 .

Output atteso

output
{
  "decision": false,
  "context": {
    "reason_admin": {
      "403": "over delegated limit"
    }
  }
}
{
  "decision": true
}
Passo 7Prova altri rifiuti, poi ferma OPA

Obiettivo. Invia altre tre richieste: uno scope mancante, un pagamento non confermato e un tool sconosciuto. Poi ferma OPA e chiedi di nuovo per vedere che non torna nessuna decisione.

Prerequisiti

  • L’endpoint è in esecuzione
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

Output atteso

output
{"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
Passo 8Pulizia

Obiettivo. Ferma entrambi i processi ed elimina i file creati dal lab.

Prerequisiti

  • Nient’altro usa le porte 8181 e 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/"

Output atteso

output
000
000

Fonti#

Discutine su X o LinkedIn

Segui su X

Nuovi articoli via email

Una email a settimana con nuovi articoli e lab. Disiscrizione in qualsiasi momento.

Il tuo indirizzo è salvato su Kit, il servizio che invia le email. Dettagli

Articoli e laboratori correlati