iamops.dev
Argo su X Feed RSS
ITItaliano

Lab Pratico · 25 minuti

Permit.io dietro AuthZEN: decidere quali chiamate MCP può fare un agente

Ho messo un PDP Permit.io dietro un piccolo punto di enforcement MCP che parla AuthZEN. Il pagamento da 90 dollari è stato negato, quello da 45 consentito.

Schermate oscurate della console Permit.io dal mio lab: l’editor delle policy con i ruoli payments_reader e payments_writer, e l’Audit Log con due chiamate consentite e quattro negate.
In breveHo rifatto il lab OPA (Open Policy Agent) con Permit.io sul piano…
Ripeti questo lab 7 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: Permit.io dietro AuthZEN: decidere quali chiamate MCP può fare un agente
Read the whole lab here (Markdown): https://iamops.dev/it/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.

All’inizio del mese ho costruito un punto di decisione per le chiamate MCP con OPA: un agente propone una tools/call, qualcosa davanti al server MCP chiede a un motore di policy, e il motore risponde sì o no tramite AuthZEN. Questa volta il motore è Permit.io.

Permit.io si presta bene al confronto per due motivi. Il suo PDP parla AuthZEN 1.0 senza configurazione aggiuntiva, e a marzo il team ha rilasciato Permit MCP Gateway, un proxy davanti ai server MCP che controlla ogni chiamata su Permit. Il loro articolo sui sei livelli che ogni gateway MCP deve applicare è un elenco breve e utile di cosa deve fare un gateway oltre all’instradamento.

Ho usato solo ciò che include il piano gratuito Community. I nuovi account partono con una prova Pro di 14 giorni, ma a questo lab non serve: RBAC, ABAC, l’Edge PDP e l’audit log sono tutti nel piano gratuito.

Come Permit modella le chiamate MCP#

La documentazione di architettura del gateway descrive la mappatura. Ogni server MCP diventa un tipo di risorsa Permit, con la chiave del server. Ogni tool diventa un’azione su quel tipo di risorsa. Per una chiamata il gateway esegue un permit.check() con l’agente come utente, il nome del tool come azione e il server come risorsa, più un secondo controllo per la persona quando un admin ha importato il server. Entrambi devono consentire.

Sopra ci sono i livelli di fiducia (basso per le letture, medio per le scritture, alto per le cancellazioni) e un tetto: l’agente non ottiene mai più di quanto l’admin ha dato alla persona. Permit costruisce questo tetto con regole ReBAC. La documentazione dice anche che se il PDP non risponde, il gateway rifiuta la richiesta con l’errore JSON-RPC (chiamate di procedura remota in JavaScript Object Notation) -32005. Un rifiuto normale è -32004. Ho riusato -32004 nel mio punto di enforcement.

Il PDP è la parte che ho testato. Permit ne offre tre tipi. Il Cloud PDP è ospitato su cloudpdp.api.permit.io e copre RBAC e ReBAC. L’Edge PDP è un container open source (permitio/pdp-v2) che include OPA e il client OPAL (Open Policy Administration Layer) e copre anche ABAC. Nexus PDP è un container più recente con archivio su disco. Tutti e tre servono gli endpoint AuthZEN: valutazione, valutazioni batch, le tre API (interfaccia di programmazione) di ricerca e il documento di discovery.

Diagramma di sequenza: il control plane di Permit invia policy e dati all’Edge PDP. Un agente AI invia una tools/call MCP a pep.py, che prende il soggetto dalla sessione e invia al PDP una valutazione AuthZEN. Per 9000 centesimi con un limite di 5000 il PDP risponde decision false e pep.py restituisce l’errore -32004. Per 4500 centesimi con conferma risponde decision true e il tool viene eseguito. Senza chiave nel PEP o con il PDP fermo, pep.py nega e chiude. Il PDP invia i log delle decisioni all’audit log di Permit.
Il flusso che ho eseguito. Il punto di enforcement costruisce la richiesta AuthZEN dalla sessione, non da ciò che ha scritto il modello. Il PDP decide con la policy scaricata da Permit, e gli errori finiscono in un rifiuto.

Preparazione#

Ho usato Podman 5.4.2 su Debian 13 per eseguire l’immagine Edge PDP permitio/pdp-v2:0.9.17, Python 3.13, l’SDK (kit di sviluppo software) Python di Permit 3.0.1 (il pacchetto sul Python Package Index si chiama permit), curl e jq. Tutto ascolta su localhost: 7766 per il PDP e 8383 per il punto di enforcement. Docker funziona allo stesso modo: sostituisci podman con docker.

Serve un account Permit.io gratuito. Registrati su app.permit.io, apri l’ambiente Development del progetto predefinito e copia la sua chiave API da Settings, API Keys. Il lab legge la chiave da un prompt nascosto in una sola variabile di shell. Non finisce mai in un file, in un log o in uno screenshot, e il container PDP la riceve come PDP_API_KEY.

Lo scenario è quello del lab OPA. Un agente chiamato support-bot può leggere saldo e movimenti e può inviare pagamenti fino a 5000 centesimi, 50 dollari, quando l’utente ha confermato. read-bot può solo leggere. I tool sono get_balance, list_transactions e send_payment su un server MCP, payments_mcp. delete_account non esiste.

La policy#

setup_permit.py crea la policy tramite l’API di Permit, così puoi ricostruirla in qualsiasi ambiente e toglierla con cleanup_permit.py:

  • Tipo di risorsa payments_mcp con i tre tool come azioni e due attributi, amount_cents e user_confirmed.
  • Un attributo utente limit_cents, a 5000 per entrambi gli agenti.
  • Due ruoli al posto degli scope: payments_reader con i due tool di lettura (RBAC), e payments_writer senza permessi semplici.
  • Un resource set ABAC, payment_within_limit: resource.amount_cents minore o uguale a user.limit_cents, confrontati per riferimento, e resource.user_confirmed uguale a true. payments_writer ottiene send_payment solo su quel set.
Console Permit.io, Policy, scheda Resources: tipo di risorsa Payments MCP server con chiave payments_mcp, attributi amount_cents: number e user_confirmed: bool, e le azioni get_balance, list_transactions e send_payment.
Il server MCP come risorsa. Un tipo di risorsa, un’azione per tool, e i due attributi letti dalla regola ABAC.
Console Permit.io, Policy Editor: il ruolo payments.read (payments_reader) ha get_balance e list_transactions spuntati nella colonna Payments MCP server e niente nella colonna Payment within limit; il ruolo payments.write (payments_writer) ha solo send_payment spuntato, nella colonna Payment within limit.
I ruoli nell’editor delle policy. Il lettore ha i due tool di lettura. Lo scrittore ha send_payment solo nella colonna del resource set, non sul server.
Console Permit.io, vista di modifica della risorsa dinamica ABAC Payment within limit and confirmed, chiave payment_within_limit, tipo di risorsa payments_mcp, con due condizioni: resource.amount_cents less-than-equals (ref) user.limit_cents, e resource.user_confirmed equals True.
La regola ABAC. Aperta nel pannello di modifica; non ho cambiato nulla. L’importo è confrontato con l’attributo di limite dell’agente, non con un numero fisso.
Console Permit.io, Directory, Default Tenant, Users: support-bot con accesso di primo livello payments_writer e payments_reader, e read-bot con payments_reader.
I due agenti. Entrambi gli agenti sono utenti del tenant predefinito; solo support-bot ha il ruolo di scrittura.
Output di terminale: un ambiente virtuale Python riceve il pacchetto permit 3.0.1, setup_permit.py stampa policy created con payments_mcp, 2 ruoli, 1 resource set e 2 agenti, podman avvia permit-pdp da pdp-v2 0.9.17 con PDP_API_KEY presa da una variabile di shell, e l’endpoint healthy riporta status ok per OPA e horizon.
Policy caricata, PDP sano. La chiave passa come variabile e non compare mai. Dopo 30 secondi entrambe le parti del PDP sono ok.

Il PDP ha scaricato la policy entro i 30 secondi che gli ho dato, e /healthy ha riportato ok per entrambe le sue parti.

Il punto di enforcement#

pep.py riceve una tools/call JSON-RPC, ricava l’agente dall’header di sessione e invia a Permit una Access Evaluation AuthZEN. La forma segue la mappatura del gateway: il soggetto è l’agente, l’azione è il nome del tool, la risorsa è il server MCP. Importo e conferma vanno in resource.properties, perché la documentazione Permit dice che il PDP legge tenant da lì e passa le altre chiavi alla policy come attributi della risorsa.

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)),
    }},
}

Le righe importanti sono quelle dopo la chiamata. Consente solo HTTP (Hypertext Transfer Protocol) 200 con "decision": true. Qualsiasi errore HTTP, un timeout, una connessione rifiutata o una risposta senza booleano è un rifiuto, e il log dice quale dei casi è stato.

Permit risponde con più della sola decisione. Il campo context contiene il ragionamento, compresi i ruoli dell’agente e il suo limit_cents. pep.py tiene i codici brevi del motivo per il proprio log e all’agente dice solo denied: policy. Un agente che può leggere il limite può imparare a spezzare un pagamento per restarci sotto.

Prova 1: AuthZEN con la chiave#

Per prima cosa ho controllato direttamente gli endpoint AuthZEN, con la chiave nell’header bearer: il documento di discovery, una valutazione per get_balance, un batch di quattro pagamenti in una sola richiesta e una ricerca dei soggetti che possono chiamare get_balance.

Output di terminale: il documento di discovery AuthZEN elenca sei voci, una valutazione per get_balance risponde decision true con il ruolo payments_reader, un batch di quattro valutazioni send_payment risponde false, true, false, false con i codici rbac e abac, e una ricerca di soggetti restituisce read-bot e support-bot.
Quattro pagamenti, un sì. Passa solo il pagamento da 45 dollari confermato, grazie alla regola ABAC. 90 dollari, i 45 non confermati e read-bot vengono rifiutati.

Il batch è la policy in quattro righe. 90 dollari con il limite di 50: false. 45 confermati: true, consentito dalla regola ABAC. 45 non confermati: false. Gli stessi 45 da parte di read-bot, indicato come soggetto della singola voce del batch: false. La ricerca dei soggetti ha trovato entrambi gli agenti, perché entrambi hanno payments_reader. La ricerca delle azioni nella mia prova ha restituito una lista vuota per entrambi gli agenti. Non ho approfondito il perché, quindi qui non ci faccio affidamento.

Prova 2: sei chiamate dal punto di enforcement#

Poi ho avviato pep.py e inviato le sei chiamate del lab OPA: una lettura del saldo, un pagamento da 90 dollari, uno da 45 con e senza conferma, un pagamento di read-bot e lo sconosciuto delete_account.

Output di terminale: sei risposte JSON-RPC da pep.py, due risultati per get_balance e send_payment e quattro errori -32004 denied: policy, poi le righe di pep.log: get_balance ALLOW per rbac, send_payment da 90 dollari DENY, send_payment da 45 confermato ALLOW per abac, quello non confermato DENY, read-bot DENY e delete_account DENY con rbac no_such_action.
Due consentite, quattro negate. Lo stesso esito del lab OPA. L’agente vede solo denied: policy; i codici del motivo restano nel log.

I risultati coincidono con il lab OPA. Due chiamate sono passate: la lettura del saldo, consentita dal ruolo, e il pagamento da 45 dollari confermato, consentito dalla regola ABAC. Quattro sono state negate dalla policy. Per delete_account il PDP ha detto no_such_action: il tool non è un’azione di payments_mcp, quindi nessun ruolo può concederlo.

Ogni decisione è arrivata anche nell’audit log di Permit. Le ho contate tramite l’API dell’audit log: utente, azione, tipo di risorsa e decisione per ogni chiamata di questa prova, comprese quelle del Cloud PDP nella prova 4.

Console Permit.io, Audit Log, vista Check: righe dalle 11:23:53 alle 11:25:17 del 22 novembre 2026, tutte su payments_mcp nel tenant default. Le sei righe delle 11:25:17 sono delete_account negato, send_payment di read-bot negato, send_payment di support-bot negato, consentito e negato, e get_balance consentito.
Le decisioni nell’audit log. Le sei righe delle 11:25:17 sono una prova delle sei chiamate: due consentite, quattro negate. Le righe sotto vengono da prove precedenti.
Console Permit.io, Audit Event per send_payment di read-bot su payments_mcp alle 11:25:17, decisione negata, con il JSON di debug che mostra abac allow false, code no_matching_rules e il motivo che read-bot non corrisponde a nessuna regola che concede il permesso send_payment su payments_mcp.
Perché read-bot è stato rifiutato. La voce dell’audit log conserva il ragionamento restituito dal PDP: nessuna regola corrispondente.

Prova 3: fail closed con una policy attiva#

Una policy funzionante non elimina il percorso di errore. Ho riavviato pep.py con una chiave vuota contro lo stesso PDP sano, poi ho fermato il container PDP e reinviato il pagamento da 45 dollari.

Output di terminale: pep.py riavviato con una chiave vuota restituisce l’errore -32004 denied: pdp error HTTP 403, fail closed per il pagamento da 45 dollari confermato; dopo che podman ferma permit-pdp la stessa chiamata restituisce denied: pdp unreachable (URLError), fail closed, e pep.log mostra entrambi i motivi.
Una chiamata consentita, rifiutata due volte. La policy dice sì, ma senza chiave o senza PDP il punto di enforcement dice no, e il log dice perché.

Entrambe le volte il pagamento da 45 dollari confermato, che la policy consente, è stato rifiutato. La riga di log dice perché: pdp error HTTP 403 e pdp unreachable, non decision false. È questa differenza che un allarme deve guardare.

Prova 4: il Cloud PDP non valuta ABAC#

Il Cloud PDP ha accettato la stessa chiave e lo stesso batch e ha risposto false quattro volte. Il motivo era nel context: ABAC is not supported yet in the Cloud PDP. Con pep.py puntato sul Cloud PDP, la lettura del saldo è passata grazie al ruolo, ma il pagamento da 45 dollari confermato è stato rifiutato.

Output di terminale: lo stesso batch inviato a cloudpdp.api.permit.io risponde quattro volte decision false con ABAC is not supported yet in the Cloud PDP; pep.py puntato sul Cloud PDP consente get_balance e nega entrambe le chiamate send_payment, e il log mostra abac NOT_SUPPORTED.
Il Cloud PDP salta ABAC. Il ruolo funziona ancora, la regola sul limite no, quindi anche il pagamento da 45 dollari confermato viene rifiutato.

Si chiude in sicurezza, che è la direzione giusta, ma sembrerebbe una policy rotta se non lo sapessi. Limiti come questo richiedono l’Edge PDP, oppure una policy che non dipende da ABAC.

Prima della chiave: cosa fa un PDP senza chiave#

Prima che l’account esistesse ho eseguito lo stesso lab senza chiave. Tengo questi risultati perché mostrano com’è un PDP configurato male visto dal punto di enforcement.

Il container è partito senza PDP_API_KEY e non è uscito. Il suo watchdog continuava a riavviare il server API interno, e /healthy segnalava un errore.

Output di terminale: podman avvia permit-pdp da pdp-v2 0.9.17, il container è attivo, il log dice Failed to get Environment API Key con ApiKeyError No API key specified, e l’endpoint healthy riporta status error con il messaggio che il PDP non ha ancora una chiave API.
Attivo, ma non sano. Il container gira, e il PDP dice chiaramente che non ha una chiave API.

Le richieste AuthZEN ricevevano codici di stato e mai una decisione: 401 senza header, 403 con un token bearer vuoto e 503 con una chiave sbagliata. Il container voleva un token anche per il documento di discovery.

Output di terminale: healthy risponde HTTP 503, una valutazione AuthZEN senza header Authorization risponde Missing Authorization header con HTTP 401, e la stessa richiesta con un token bearer vuoto risponde che il chiamante non è autorizzato, con HTTP 403.
Nessuna decisione, solo codici di stato. 503 sull’health, 401 senza header, 403 con una chiave vuota.

Tutte e sei le chiamate passate da pep.py sono state negate, ognuna con pdp error HTTP 403. Il risultato giusto per il motivo sbagliato. Per l’agente un PDP che ha perso la chiave sembra uguale a una policy severa, quindi solo il log può distinguerli.

Output di terminale: sei risposte JSON-RPC, ognuna un errore con codice -32004 e il messaggio denied, pdp error HTTP 403, fail closed, seguite dal log del punto di enforcement con una riga DENY per chiamata per support-bot e read-bot.
Sei chiamate, sei rifiuti. Anche l’innocua lettura del saldo viene rifiutata, perché il PDP non ha dato una decisione.

Il Cloud PDP serviva il documento di discovery senza token e rispondeva 401 a una valutazione senza token. I corpi di errore sono diversi: JSON sul Cloud PDP, testo semplice sul container.

Output di terminale: il documento di discovery del Cloud PDP elenca gli endpoint di valutazione, di valutazioni batch e le tre ricerche, una valutazione senza token risponde Unauthorized con HTTP 401, e il punto di enforcement puntato sul Cloud PDP nega due chiamate con pdp error HTTP 401, fail closed.
La discovery è pubblica, le decisioni no. Tutti e cinque gli endpoint AuthZEN sono elencati, e il punto di enforcement chiude sul 401.

Trappole#

  • Il Cloud PDP ignora ABAC. Risponde false con NOT_SUPPORTED nel context. Per le regole sugli attributi usa l’Edge PDP. Non invia nemmeno header CORS (Cross-Origin Resource Sharing), quindi un browser non può leggerne le risposte: chiamatelo da un server.
  • Il context della decisione dice molto. Ruoli, attributi e nomi delle regole tornano con ogni risposta. Registra i codici, non inoltrarli all’agente.
  • Una chiave mancante non è una policy. Il container resta attivo e risponde 401, 403 o 503 a seconda di cosa invii. Solo il PEP può trasformarlo in un rifiuto sicuro.
  • Il soggetto viene dalla sessione. pep.py ignora qualsiasi nome di agente negli argomenti. Lo stesso vale per user_confirmed: in un gateway reale deve venire da un passo di conferma che il modello non può falsificare.
  • L’elenco dei tool non è filtrato. Secondo la documentazione del gateway Permit, tools/list restituisce tutti i tool a monte e il controllo avviene su ogni chiamata. Un agente può vedere un tool che non può usare.
  • Il gateway usa il check dell’SDK, non AuthZEN. AuthZEN è il modo in cui un altro PEP, come il mio, parla con lo stesso PDP.

Cosa farei con questo#

  1. Far chiudere il punto di enforcement in caso di errore e registrare il motivo, poi fermare il PDP in un test e controllare la riga di log.
  2. Mettere un allarme quando i rifiuti vengono da errori del PDP invece che da decisioni di policy.
  3. Tenere la chiave PDP lato server, nel gateway o in un sidecar, mai in un browser o nel prompt di un agente.
  4. Scegliere il tipo di PDP in base al modello di policy: limiti ABAC come questo richiedono l’Edge PDP.
  5. Togliere il context della decisione prima che qualcosa torni all’agente.

Cosa non ho provato#

Questo lab usa un proprio piccolo punto di enforcement al posto del Permit MCP Gateway ospitato. Usa solo funzioni del piano gratuito Community.

Le immagini di terminale sono generate dall’output salvato del 22 novembre 2026; gli screenshot della console sono dello stesso giorno. La chiave non compare mai.

Ripeti questo lab#

Per questo lab servono un account Permit.io gratuito, Linux con Podman o Docker, curl, jq e Python 3.10 o successivo. Conta circa 25 minuti. env.sh chiede la chiave API del tuo ambiente Development in un prompt nascosto; tienila fuori da file, chat e screenshot. 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.
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")
Passo 1Carica la policy nel tuo ambiente Permit

Obiettivo. Installa l’SDK Python di Permit in un ambiente virtuale ed esegui setup_permit.py per creare risorsa, ruoli, resource set ABAC e due agenti.

Prerequisiti

  • Un account Permit.io gratuito; la chiave API del suo ambiente Development digitata al prompt di env.sh
  • Linux con Podman 5 o Docker, curl, jq e Python 3.10 o successivo
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

Output atteso

output
policy created: payments_mcp, 2 roles, 1 resource set, 2 agents
Passo 2Avvia l’Edge PDP di Permit con la chiave

Obiettivo. Avvia l’immagine Edge PDP alla versione fissata con PDP_API_KEY dalla variabile di shell, attendi che scarichi la policy e leggi l’endpoint di health.

Prerequisiti

  • La policy del passo precedente esiste
  • Porte 7766 e 8383 libere
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}'

Output atteso

output
<container-id>
permit-pdp docker.io/permitio/pdp-v2:0.9.17 Up 30 seconds
{"status":"ok","opa":"ok","horizon":"ok"}
Passo 3Interroga il PDP via AuthZEN

Obiettivo. Leggi il documento di discovery, invia una valutazione, un batch di quattro pagamenti e una ricerca di soggetti, e confronta le decisioni.

Prerequisiti

  • Il PDP è 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'

Output atteso

output
["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"}]
Passo 4Fai passare sei chiamate dal punto di enforcement

Obiettivo. Scrivi pep.py e calls.sh, avvia il punto di enforcement e invia le sei chiamate MCP del lab OPA.

Prerequisiti

  • Il PDP è sano
  • Porta 8383 libera
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

Output atteso

output
{"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)
Passo 5Rompi la chiave, poi ferma il PDP

Obiettivo. Riavvia il punto di enforcement con una chiave vuota, poi ferma il container PDP, e invia ogni volta il pagamento da 45 dollari consentito.

Prerequisiti

  • pep.py e calls.sh del passo precedente
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

Output atteso

output
{"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
Passo 6Invia lo stesso batch al Cloud PDP

Obiettivo. Invia il batch al Cloud PDP di Permit con la stessa chiave, poi punta il punto di enforcement su di esso e invia le prime tre chiamate.

Prerequisiti

  • HTTPS in uscita verso 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

Output atteso

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

Obiettivo. Ferma il punto di enforcement, rimuovi il container, elimina la policy dal tuo ambiente Permit e cancella i file.

Prerequisiti

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

Output atteso

output
cleanup done
0
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