iamops.dev
Argo sur X Flux RSS
FRFrançais

Labs Pratique · 25 minutes

Permit.io derrière AuthZEN : décider quels appels MCP un agent peut faire

J’ai placé un PDP Permit.io derrière un petit point d’application MCP qui parle AuthZEN. Le paiement de 90 dollars a été refusé, celui de 45 autorisé.

Captures caviardées de la console Permit.io de mon lab : l’éditeur de politiques avec les rôles payments_reader et payments_writer, et le journal d’audit avec deux appels autorisés et quatre refusés.
En brefJ’ai refait le lab OPA (Open Policy Agent) avec Permit.io sur le plan…
Refaire ce lab 7 étapes

J’ai écrit ce lab pour que vous puissiez le refaire vous-même. Chaque étape contient les commandes à copier et la sortie que j’ai obtenue, et vous pouvez la cocher une fois faite. Les coches restent uniquement dans ce navigateur.

Aller aux étapes

Comment ça marche

Copie un prompt prêt à l’emploi pour Claude Code, Cursor, Codex ou tout autre agent de code. Pour les environnements de test uniquement.

Afficher le 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 derrière AuthZEN : décider quels appels MCP un agent peut faire
Read the whole lab here (Markdown): https://iamops.dev/fr/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.

Au début du mois, j’ai construit un point de décision pour les appels d’outils MCP avec OPA : un agent propose un tools/call, quelque chose devant le serveur MCP interroge un moteur de politiques, et le moteur répond oui ou non via AuthZEN. Cette fois, le moteur est Permit.io.

Permit.io se prête bien à la comparaison pour deux raisons. Son PDP parle AuthZEN 1.0 sans effort, et en mars l’équipe a publié Permit MCP Gateway, un proxy placé devant les serveurs MCP qui vérifie chaque appel d’outil auprès de Permit. Leur article sur les six couches que tout gateway MCP doit appliquer est une liste courte et utile de ce qu’un gateway doit faire en plus du routage.

Je n’ai utilisé que ce que contient le plan gratuit Community. Les nouveaux comptes démarrent avec un essai Pro de 14 jours, mais ce lab n’en a pas besoin : RBAC, ABAC, l’Edge PDP et le journal d’audit sont tous dans le plan gratuit.

Comment Permit modélise les appels MCP#

La documentation d’architecture du gateway décrit la correspondance. Chaque serveur MCP devient un type de ressource Permit, avec la clé du serveur. Chaque outil devient une action sur ce type de ressource. Pour un appel, le gateway exécute un permit.check() avec l’agent comme utilisateur, le nom de l’outil comme action et le serveur comme ressource, plus une seconde vérification pour la personne quand un admin a importé le serveur. Les deux doivent autoriser.

Par-dessus viennent des niveaux de confiance (bas pour les lectures, moyen pour les écritures, haut pour les suppressions) et un plafond : l’agent n’obtient jamais plus que ce que l’admin a donné à la personne. Permit construit ce plafond avec des règles ReBAC. La documentation indique aussi que si le PDP ne répond pas, le gateway refuse la requête avec l’erreur JSON-RPC (appels de procédure à distance en JavaScript Object Notation) -32005. Un refus normal est -32004. J’ai repris -32004 dans mon point d’application.

Le PDP est la partie que j’ai testée. Permit en propose trois types. Le Cloud PDP est hébergé sur cloudpdp.api.permit.io et couvre RBAC et ReBAC. L’Edge PDP est un conteneur open source (permitio/pdp-v2) qui embarque OPA et le client OPAL (Open Policy Administration Layer) et couvre aussi ABAC. Nexus PDP est un conteneur plus récent avec un stockage sur disque. Les trois servent les endpoints AuthZEN : évaluation, évaluations par lot, les trois API (interface de programmation) de recherche et le document de découverte.

Diagramme de séquence : le plan de contrôle Permit envoie la politique et les données au PDP Edge. Un agent IA envoie un tools/call MCP à pep.py, qui prend le sujet dans la session et envoie une évaluation AuthZEN au PDP. Pour 9000 centimes face à une limite de 5000, le PDP répond decision false et pep.py renvoie l’erreur -32004. Pour 4500 centimes avec confirmation, il répond decision true et l’outil s’exécute. Sans clé dans le PEP ou avec le PDP arrêté, pep.py refuse et reste fermé. Le PDP envoie les journaux de décision au journal d’audit de Permit.
Le flux que j’ai exécuté. Le point d’application construit la requête AuthZEN à partir de la session, pas de ce que le modèle a écrit. Le PDP décide avec la politique récupérée chez Permit, et les erreurs finissent en refus.

Mise en place#

J’ai utilisé Podman 5.4.2 sur Debian 13 pour l’image Edge PDP permitio/pdp-v2:0.9.17, Python 3.13, le SDK (kit de développement logiciel) Python de Permit 3.0.1 (le paquet sur le Python Package Index s’appelle permit), curl et jq. Tout écoute sur localhost : 7766 pour le PDP et 8383 pour le point d’application. Docker fonctionne de la même façon : remplacez podman par docker.

Il vous faut un compte Permit.io gratuit. Inscrivez-vous sur app.permit.io, ouvrez l’environnement Development du projet par défaut et copiez sa clé API dans Settings, API Keys. Le lab lit la clé depuis une invite masquée dans une seule variable du shell. Elle ne va jamais dans un fichier, un journal ou une capture d’écran, et le conteneur PDP la reçoit en tant que PDP_API_KEY.

Le scénario est celui du lab OPA. Un agent nommé support-bot peut lire le solde et les transactions, et envoyer des paiements jusqu’à 5000 centimes, soit 50 dollars, quand l’utilisateur a confirmé. read-bot peut seulement lire. Les outils sont get_balance, list_transactions et send_payment sur un serveur MCP, payments_mcp. delete_account n’existe pas.

La politique#

setup_permit.py crée la politique via l’API Permit, ce qui permet de la reconstruire dans n’importe quel environnement et de la supprimer avec cleanup_permit.py :

  • Type de ressource payments_mcp avec les trois outils comme actions, et deux attributs, amount_cents et user_confirmed.
  • Un attribut utilisateur limit_cents, fixé à 5000 pour les deux agents.
  • Deux rôles à la place des scopes : payments_reader avec les deux outils de lecture (RBAC), et payments_writer sans permission simple.
  • Un resource set ABAC, payment_within_limit : resource.amount_cents inférieur ou égal à user.limit_cents, comparés par référence, et resource.user_confirmed égal à true. payments_writer obtient send_payment uniquement sur cet ensemble.
Console Permit.io, Policy, onglet Resources : type de ressource Payments MCP server avec la clé payments_mcp, les attributs amount_cents: number et user_confirmed: bool, et les actions get_balance, list_transactions et send_payment.
Le serveur MCP comme ressource. Un type de ressource, une action par outil, et les deux attributs que lit la règle ABAC.
Console Permit.io, Policy Editor : le rôle payments.read (payments_reader) a get_balance et list_transactions cochés dans la colonne Payments MCP server et rien dans la colonne Payment within limit ; le rôle payments.write (payments_writer) n’a que send_payment coché, dans la colonne Payment within limit.
Les rôles dans l’éditeur de politiques. Le lecteur obtient les deux outils de lecture. L’écrivain obtient send_payment seulement dans la colonne du resource set, pas sur le serveur lui-même.
Console Permit.io, vue d’édition de la ressource dynamique ABAC Payment within limit and confirmed, clé payment_within_limit, type de ressource payments_mcp, avec deux conditions : resource.amount_cents less-than-equals (ref) user.limit_cents, et resource.user_confirmed equals True.
La règle ABAC. Ouverte dans le panneau d’édition, rien n’a été modifié. Le montant est comparé à l’attribut de limite de l’agent, pas à un nombre fixe.
Console Permit.io, Directory, Default Tenant, Users : support-bot avec l’accès de premier niveau payments_writer et payments_reader, et read-bot avec payments_reader.
Les deux agents. Les deux agents sont des utilisateurs du tenant par défaut ; seul support-bot a le rôle d’écriture.
Sortie de terminal : un environnement virtuel Python reçoit le paquet permit 3.0.1, setup_permit.py affiche policy created avec payments_mcp, 2 rôles, 1 resource set et 2 agents, podman démarre permit-pdp depuis pdp-v2 0.9.17 avec PDP_API_KEY tirée d’une variable du shell, et l’endpoint healthy indique status ok pour OPA et horizon.
Politique chargée, PDP en bonne santé. La clé passe par une variable et n’apparaît jamais. Après 30 secondes, les deux parties du PDP sont ok.

Le PDP a récupéré la politique dans les 30 secondes que je lui ai laissées, et /healthy a indiqué ok pour ses deux parties.

Le point d’application#

pep.py reçoit un tools/call JSON-RPC, retrouve l’agent à partir de l’en-tête de session et envoie à Permit une Access Evaluation AuthZEN. La forme suit la correspondance du gateway : le sujet est l’agent, l’action est le nom de l’outil, la ressource est le serveur MCP. Le montant et la confirmation vont dans resource.properties, car la documentation Permit indique que le PDP y lit tenant et transmet les autres clés à la politique comme attributs de ressource.

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

Les lignes importantes sont celles qui suivent l’appel. Seul un HTTP (Hypertext Transfer Protocol) 200 avec "decision": true autorise. Toute erreur HTTP, un délai dépassé, une connexion refusée ou une réponse sans booléen vaut refus, et le journal dit lequel.

Permit répond avec plus que la décision. Le champ context contient le raisonnement, y compris les rôles de l’agent et son limit_cents. pep.py garde les codes de raison courts pour son propre journal et ne dit à l’agent que denied: policy. Un agent qui peut lire la limite peut apprendre à découper un paiement pour rester en dessous.

Passage 1 : AuthZEN avec une clé#

J’ai d’abord vérifié les endpoints AuthZEN directement, avec la clé dans l’en-tête bearer : le document de découverte, une évaluation pour get_balance, un lot de quatre paiements en une seule requête, et une recherche des sujets qui peuvent appeler get_balance.

Sortie de terminal : le document de découverte AuthZEN liste six entrées, une évaluation pour get_balance répond decision true avec le rôle payments_reader, un lot de quatre évaluations send_payment répond false, true, false, false avec les codes rbac et abac, et une recherche de sujets renvoie read-bot et support-bot.
Quatre paiements, un oui. Seul le paiement confirmé de 45 dollars passe, par la règle ABAC. 90 dollars, les 45 non confirmés et read-bot sont refusés.

Le lot, c’est la politique en quatre lignes. 90 dollars face à la limite de 50 : false. 45 dollars confirmés : true, autorisé par la règle ABAC. 45 dollars non confirmés : false. Les mêmes 45 dollars par read-bot, indiqué comme sujet de l’élément du lot : false. La recherche de sujets a trouvé les deux agents, car tous deux ont payments_reader. La recherche d’actions a renvoyé une liste vide pour les deux agents lors de mon passage. Je n’ai pas cherché pourquoi, donc je ne m’appuie pas dessus ici.

Passage 2 : six appels par le point d’application#

J’ai ensuite démarré pep.py et envoyé les six appels du lab OPA : une lecture du solde, un paiement de 90 dollars, un de 45 dollars avec et sans confirmation, un paiement par read-bot, et l’inconnu delete_account.

Sortie de terminal : six réponses JSON-RPC de pep.py, deux résultats pour get_balance et send_payment et quatre erreurs -32004 denied: policy, puis les lignes de pep.log : get_balance ALLOW par rbac, send_payment de 90 dollars DENY, send_payment de 45 confirmé ALLOW par abac, celui non confirmé DENY, read-bot DENY et delete_account DENY avec rbac no_such_action.
Deux autorisés, quatre refusés. Le même résultat que dans le lab OPA. L’agent ne voit que denied: policy ; les codes de raison restent dans le journal.

Les résultats correspondent au lab OPA. Deux appels sont passés : la lecture du solde, autorisée par le rôle, et le paiement confirmé de 45 dollars, autorisé par la règle ABAC. Quatre ont été refusés par la politique. Pour delete_account, le PDP a répondu no_such_action : l’outil n’est pas une action de payments_mcp, donc aucun rôle ne peut l’accorder.

Chaque décision est aussi arrivée dans le journal d’audit de Permit. Je les ai comptées via l’API du journal d’audit : utilisateur, action, type de ressource et décision pour chaque appel de ce passage, y compris ceux du Cloud PDP au passage 4.

Console Permit.io, Audit Log, vue Check : lignes de 11:23:53 à 11:25:17 le 22 novembre 2026, toutes sur payments_mcp dans le tenant default. Les six lignes de 11:25:17 sont delete_account refusé, send_payment de read-bot refusé, send_payment de support-bot refusé, autorisé et refusé, et get_balance autorisé.
Les décisions dans le journal d’audit. Les six lignes de 11:25:17 sont un passage des six appels : deux autorisés, quatre refusés. Les lignes en dessous viennent de passages précédents.
Console Permit.io, Audit Event pour send_payment de read-bot sur payments_mcp à 11:25:17, décision refusée, avec le JSON de débogage montrant abac allow false, code no_matching_rules et la raison : read-bot ne correspond à aucune règle qui accorde la permission send_payment sur payments_mcp.
Pourquoi read-bot a été refusé. L’entrée d’audit garde le raisonnement renvoyé par le PDP : aucune règle correspondante.

Passage 3 : fail closed avec une politique active#

Une politique qui fonctionne ne supprime pas le chemin d’erreur. J’ai relancé pep.py avec une clé vide face au même PDP en bonne santé, puis arrêté le conteneur PDP et renvoyé le paiement de 45 dollars.

Sortie de terminal : pep.py relancé avec une clé vide renvoie l’erreur -32004 denied: pdp error HTTP 403, fail closed pour le paiement confirmé de 45 dollars ; après l’arrêt de permit-pdp par podman, le même appel renvoie denied: pdp unreachable (URLError), fail closed, et pep.log montre les deux raisons.
Un appel autorisé, refusé deux fois. La politique dit oui, mais sans clé ou sans PDP le point d’application dit non, et le journal dit pourquoi.

Les deux fois, le paiement confirmé de 45 dollars, que la politique autorise, a été refusé. La ligne de journal dit pourquoi : pdp error HTTP 403 et pdp unreachable, pas decision false. C’est cette différence qu’une alerte doit surveiller.

Passage 4 : le Cloud PDP n’évalue pas ABAC#

Le Cloud PDP a accepté la même clé et le même lot, et a répondu false quatre fois. La raison était dans le context : ABAC is not supported yet in the Cloud PDP. Avec pep.py pointé vers le Cloud PDP, la lecture du solde passait toujours grâce au rôle, mais le paiement confirmé de 45 dollars a été refusé.

Sortie de terminal : le même lot envoyé à cloudpdp.api.permit.io répond quatre fois decision false avec ABAC is not supported yet in the Cloud PDP ; pep.py pointé vers le Cloud PDP autorise get_balance et refuse les deux appels send_payment, et le journal montre abac NOT_SUPPORTED.
Le Cloud PDP ignore ABAC. Le rôle fonctionne toujours, la règle de limite non, donc même le paiement confirmé de 45 dollars est refusé.

Cela reste fermé, ce qui est le sens sûr, mais on croirait à une politique cassée si on ne le savait pas. Les limites comme celle-ci demandent l’Edge PDP, ou une politique qui ne dépend pas d’ABAC.

Avant la clé : ce que fait un PDP sans clé#

Avant que le compte existe, j’ai exécuté le même lab sans clé. Je garde ces résultats, car ils montrent à quoi ressemble un PDP mal configuré vu du point d’application.

Le conteneur a démarré sans PDP_API_KEY et ne s’est pas arrêté. Son watchdog relançait sans cesse le serveur API interne, et /healthy signalait une erreur.

Sortie de terminal : podman démarre permit-pdp à partir de pdp-v2 0.9.17, le conteneur tourne, le journal indique Failed to get Environment API Key avec ApiKeyError No API key specified, et l’endpoint healthy renvoie status error avec le message que le PDP n’a pas encore de clé API.
Actif, mais pas sain. Le conteneur tourne, et le PDP dit clairement qu’il n’a pas de clé API.

Les requêtes AuthZEN recevaient des codes de statut et jamais une décision : 401 sans en-tête, 403 avec un jeton bearer vide et 503 avec une mauvaise clé. Le conteneur exigeait aussi un jeton pour le document de découverte.

Sortie de terminal : healthy répond HTTP 503, une évaluation AuthZEN sans en-tête Authorization répond Missing Authorization header avec HTTP 401, et la même requête avec un jeton bearer vide répond que l’appelant n’est pas autorisé, avec HTTP 403.
Pas de décision, seulement des codes de statut. 503 sur la santé, 401 sans en-tête, 403 avec une clé vide.

Les six appels passés par pep.py ont tous été refusés, chacun avec pdp error HTTP 403. Le bon résultat pour la mauvaise raison. Pour l’agent, un PDP qui a perdu sa clé ressemble à une politique stricte, donc seul le journal peut les distinguer.

Sortie de terminal : six réponses JSON-RPC, chacune une erreur de code -32004 avec le message denied, pdp error HTTP 403, fail closed, suivies du journal du point d’application avec une ligne DENY par appel pour support-bot et read-bot.
Six appels, six refus. Même la lecture anodine du solde est refusée, car le PDP n’a donné aucune décision.

Le Cloud PDP servait son document de découverte sans jeton et répondait 401 à une évaluation sans jeton. Les corps d’erreur diffèrent : JSON sur le Cloud PDP, texte brut sur le conteneur.

Sortie de terminal : le document de découverte du Cloud PDP liste les endpoints d’évaluation, d’évaluations en lot et les trois recherches, une évaluation sans jeton répond Unauthorized avec HTTP 401, et le point d’application pointé vers le Cloud PDP refuse deux appels avec pdp error HTTP 401, fail closed.
La découverte est publique, pas les décisions. Les cinq endpoints AuthZEN sont listés, et le point d’application reste fermé sur le 401.

Pièges#

  • Le Cloud PDP ignore ABAC. Il répond false avec NOT_SUPPORTED dans le context. Pour les règles d’attributs, utilisez l’Edge PDP. Il n’envoie pas non plus d’en-têtes CORS (Cross-Origin Resource Sharing) : un navigateur ne peut pas lire ses réponses, appelez-le depuis un serveur.
  • Le context de la décision en dit long. Rôles, attributs et noms de règles reviennent avec chaque réponse. Journalisez les codes, ne les transmettez pas à l’agent.
  • Une clé manquante n’est pas une politique. Le conteneur reste actif et répond 401, 403 ou 503 selon ce que vous envoyez. Seul le PEP peut en faire un refus sûr.
  • Le sujet vient de la session. pep.py ignore tout nom d’agent dans les arguments. La même règle vaut pour user_confirmed : dans un vrai gateway, il doit venir d’une étape de confirmation que le modèle ne peut pas falsifier.
  • Les listes d’outils ne sont pas filtrées. Selon la documentation du gateway Permit, tools/list renvoie tous les outils en amont et le contrôle se fait à chaque appel. Un agent peut voir un outil qu’il ne peut pas utiliser.
  • Le gateway utilise le check du SDK, pas AuthZEN. AuthZEN est la façon dont un autre PEP, comme le mien, parle au même PDP.

Ce que j’en ferais#

  1. Faire en sorte que le point d’application reste fermé en cas d’erreur et journalise pourquoi, puis arrêter le PDP dans un test et vérifier la ligne de journal.
  2. Alerter quand les refus viennent d’erreurs du PDP plutôt que de décisions de politique.
  3. Garder la clé du PDP côté serveur, dans le gateway ou un sidecar, jamais dans un navigateur ou dans le prompt d’un agent.
  4. Choisir le type de PDP selon le modèle de politique : des limites ABAC comme celle-ci demandent l’Edge PDP.
  5. Retirer le context de la décision avant que quoi que ce soit ne retourne à l’agent.

Ce qui n’a pas été testé#

Ce lab utilise son propre petit point d’application au lieu du Permit MCP Gateway hébergé. Il n’utilise que des fonctions du plan gratuit Community.

Les images de terminal sont générées à partir de la sortie enregistrée du 22 novembre 2026 ; les captures de la console datent du même jour. La clé n’apparaît jamais.

Refaire ce lab#

Ce lab demande un compte Permit.io gratuit, Linux avec Podman ou Docker, curl, jq et Python 3.10 ou plus récent. Comptez environ 25 minutes. env.sh demande la clé API de votre environnement Development dans une invite masquée ; gardez-la hors des fichiers, des chats et des captures. Ouvrez chaque étape, copiez les blocs et comparez la sortie avec la mienne.

Chaque valeur entre chevrons est un espace réservé pour votre environnement de test. Rien sur cette page n’est un identifiant ou un secret réel.

Définissez vos variables une seule fois

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")
Étape 1Charger la politique dans votre environnement Permit

Objectif. Installez le SDK Python de Permit dans un environnement virtuel et lancez setup_permit.py pour créer la ressource, les rôles, le resource set ABAC et deux agents.

Prérequis

  • Un compte Permit.io gratuit ; la clé API de son environnement Development saisie à l’invite de env.sh
  • Linux avec Podman 5 ou Docker, curl, jq et Python 3.10 ou plus récent
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

Résultat attendu

résultat
policy created: payments_mcp, 2 roles, 1 resource set, 2 agents
Étape 2Démarrer l’Edge PDP de Permit avec la clé

Objectif. Démarrez l’image Edge PDP à la version figée avec PDP_API_KEY tirée de la variable du shell, attendez qu’elle récupère la politique et lisez son endpoint de santé.

Prérequis

  • La politique de l’étape précédente existe
  • Ports 7766 et 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}'

Résultat attendu

résultat
<container-id>
permit-pdp docker.io/permitio/pdp-v2:0.9.17 Up 30 seconds
{"status":"ok","opa":"ok","horizon":"ok"}
Étape 3Interroger le PDP en AuthZEN

Objectif. Lisez le document de découverte, envoyez une évaluation, un lot de quatre paiements et une recherche de sujets, et comparez les décisions.

Prérequis

  • Le PDP est en bonne santé
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'

Résultat attendu

résultat
["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"}]
Étape 4Faire passer six appels par le point d’application

Objectif. Écrivez pep.py et calls.sh, démarrez le point d’application et envoyez les six appels MCP du lab OPA.

Prérequis

  • Le PDP est en bonne santé
  • Port 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

Résultat attendu

résultat
{"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)
Étape 5Casser la clé, puis arrêter le PDP

Objectif. Relancez le point d’application avec une clé vide, puis arrêtez le conteneur PDP, et envoyez chaque fois le paiement autorisé de 45 dollars.

Prérequis

  • pep.py et calls.sh de l’étape précédente
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

Résultat attendu

résultat
{"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
Étape 6Envoyer le même lot au Cloud PDP

Objectif. Envoyez le lot au Cloud PDP de Permit avec la même clé, puis pointez le point d’application vers lui et envoyez les trois premiers appels.

Prérequis

  • HTTPS sortant vers 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

Résultat attendu

résultat
{"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)
Étape 7Nettoyage

Objectif. Arrêtez le point d’application, supprimez le conteneur, effacez la politique de votre environnement Permit et supprimez les fichiers.

Prérequis

  • Rien d’autre n’utilise les ports 7766 et 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

Résultat attendu

résultat
cleanup done
0
000
000

Sources#

Discutez-en sur X ou LinkedIn

Suivre sur X

Les nouveaux articles par e-mail

Un e-mail par semaine avec les nouveaux articles et labs. Désinscription à tout moment.

Votre adresse est conservée chez Kit, le service qui envoie les e-mails. Détails

Articles et labs liés