# 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é.

- URL: https://iamops.dev/fr/permit-authzen-mcp-tool-call-policy/
- Language: fr
- Author: Argo
- Published: 2026-11-22
- Category: Labs
- Depth: Pratique
- Time: 25 minutes
- Topics: Permit.io, AuthZEN, MCP, Autorisation, Agents IA

## En bref

- J’ai refait le [lab OPA (Open Policy Agent)](https://iamops.dev/fr/opa-authzen-mcp-tool-call-policy/) avec Permit.io sur le plan gratuit Community : un petit [point d’application](https://iamops.dev/fr/permit-authzen-mcp-tool-call-policy/#le-point-dapplication) transforme chaque tools/call MCP (Model Context Protocol) en requête AuthZEN (le standard d’autorisation OpenID) pour l’Edge PDP (point de décision des politiques) de Permit.
- Avec [des rôles et une règle ABAC (contrôle d’accès basé sur les attributs)](https://iamops.dev/fr/permit-authzen-mcp-tool-call-policy/#la-politique), l’Edge PDP [a refusé le paiement de 90 dollars face à une limite de 50](https://iamops.dev/fr/permit-authzen-mcp-tool-call-policy/#passage-2--six-appels-par-le-point-dapplication) et autorisé 45 dollars avec confirmation. Deux autorisés, quatre refusés, comme avec OPA.
- Sans clé dans le PEP (point d’application des politiques) ou avec le PDP arrêté, chaque appel [est resté fermé](https://iamops.dev/fr/permit-authzen-mcp-tool-call-policy/#passage-3--fail-closed-avec-une-politique-active). Le journal dit si un refus vient de la politique ou d’une erreur.
- Le [Cloud PDP n’évalue pas ABAC](https://iamops.dev/fr/permit-authzen-mcp-tool-call-policy/#passage-4--le-cloud-pdp-névalue-pas-abac) : le même paiement de 45 dollars y a été refusé. Choisissez le PDP selon le modèle de politique. Les modèles sont dans mon [explainer sur RBAC (contrôle d’accès basé sur les rôles), ABAC et ReBAC (contrôle d’accès basé sur les relations)](https://iamops.dev/fr/rbac-abac-rebac-explained/).
- [Avant la clé](https://iamops.dev/fr/permit-authzen-mcp-tool-call-policy/#avant-la-clé--ce-que-fait-un-pdp-sans-clé), le PDP répondait 401, 403 ou 503 et jamais par une décision. Cette section reste, car elle montre à quoi ressemble un PDP mal configuré.

Au début du mois, j’ai construit un [point de décision pour les appels d’outils MCP avec OPA](https://iamops.dev/fr/opa-authzen-mcp-tool-call-policy/) : 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](https://iamops.dev/fr/authzen-opa-cedar-explained/). 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](https://www.permit.io/blog/announcing-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](https://www.permit.io/blog/six-layers-mcp-gateway) 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](https://docs.permit.io/permit-mcp-gateway/architecture/) 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](https://iamops.dev/fr/rbac-abac-rebac-explained/#rebac-regarde-les-liens-entre-les-choses). 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.](https://iamops.dev/media/permit-authzen-mcp-tool-call-policy/00-flow.webp)

*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](https://iamops.dev/fr/rbac-abac-rebac-explained/#rbac-demande-quel-rôle-vous-avez)), et `payments_writer` sans permission simple.
- Un resource set [ABAC](https://iamops.dev/fr/rbac-abac-rebac-explained/#abac-regarde-les-attributs), `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.](https://iamops.dev/media/permit-authzen-mcp-tool-call-policy/permit-console-resource.webp)

*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.](https://iamops.dev/media/permit-authzen-mcp-tool-call-policy/permit-console-policy-editor.webp)

*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.](https://iamops.dev/media/permit-authzen-mcp-tool-call-policy/permit-console-abac-rule.webp)

*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.](https://iamops.dev/media/permit-authzen-mcp-tool-call-policy/permit-console-users.webp)

*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.](https://iamops.dev/media/permit-authzen-mcp-tool-call-policy/07-setup-policy.webp)

*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](https://docs.permit.io/concepts/pdp/overview/) 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.](https://iamops.dev/media/permit-authzen-mcp-tool-call-policy/08-authzen-key.webp)

*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.](https://iamops.dev/media/permit-authzen-mcp-tool-call-policy/09-pep-decisions.webp)

*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é.](https://iamops.dev/media/permit-authzen-mcp-tool-call-policy/permit-console-audit-log.webp)

*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.](https://iamops.dev/media/permit-authzen-mcp-tool-call-policy/permit-console-audit-detail.webp)

*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.](https://iamops.dev/media/permit-authzen-mcp-tool-call-policy/10-fail-closed-key.webp)

*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.](https://iamops.dev/media/permit-authzen-mcp-tool-call-policy/11-cloud-pdp-abac.webp)

*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.](https://iamops.dev/media/permit-authzen-mcp-tool-call-policy/01-pdp-nokey.webp)

*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.](https://iamops.dev/media/permit-authzen-mcp-tool-call-policy/02-authzen-nokey.webp)

*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.](https://iamops.dev/media/permit-authzen-mcp-tool-call-policy/03-pep-fail-closed.webp)

*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.](https://iamops.dev/media/permit-authzen-mcp-tool-call-policy/04-cloud-pdp.webp)

*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](https://docs.permit.io/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** `env.sh` (bash)

```bash
# 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 1: Charger 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

`setup_permit.py` (bash)

```bash
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
```

`setup-policy.sh` (bash)

```bash
python3 -m venv .venv && .venv/bin/pip install -q permit==3.0.1
.venv/bin/python setup_permit.py
```

**Résultat attendu**

```text
policy created: payments_mcp, 2 roles, 1 resource set, 2 agents
```

### Étape 2: Dé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

`start-pdp.sh` (bash)

```bash
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**

```text
<container-id>
permit-pdp docker.io/permitio/pdp-v2:0.9.17 Up 30 seconds
{"status":"ok","opa":"ok","horizon":"ok"}
```

### Étape 3: Interroger 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é

`authzen.sh` (bash)

```bash
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**

```text
["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 4: Faire 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

`pep.py` (bash)

```bash
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
```

`calls.sh` (bash)

```bash
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**

```text
{"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 5: Casser 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

`fail-closed.sh` (bash)

```bash
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**

```text
{"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 6: Envoyer 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

`cloud-pdp.sh` (bash)

```bash
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**

```text
{"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 7: Nettoyage

**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

`cleanup.sh` (bash)

```bash
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**

```text
cleanup done
0
000
000
```


## Sources

- [Permit.io blog, Announcing Permit MCP Gateway (17 Mar 2026)](https://www.permit.io/blog/announcing-permit-mcp-gateway)
- [Permit.io blog, The Six Layers Every MCP Gateway Must Enforce (8 Apr 2026)](https://www.permit.io/blog/six-layers-mcp-gateway)
- [Permit.io blog, Least Privilege in AI Agents and Agentic Identity](https://www.permit.io/blog/least-privilege-ai-agents-agentic-identity)
- [Permit.io docs, Permit MCP Gateway](https://docs.permit.io/permit-mcp-gateway/)
- [Permit.io docs, Permit MCP Gateway architecture](https://docs.permit.io/permit-mcp-gateway/architecture/)
- [Permit.io docs, PDP overview and AuthZEN compatibility](https://docs.permit.io/concepts/pdp/overview/)
- [Permit.io docs, ABAC design patterns (compare two attributes)](https://docs.permit.io/how-to/build-policies/abac/patterns/)
- [Permit.io pricing (Community plan)](https://www.permit.io/pricing)
- [permitio/PDP on GitHub](https://github.com/permitio/PDP)
- [OpenID AuthZEN Authorization API 1.0 (Final)](https://openid.net/specs/authorization-api-1_0-final.html)
- [Model Context Protocol specification: Tools](https://modelcontextprotocol.io/specification/2026-07-28/server/tools)

Discuss: [X](https://x.com/iamopsdev) | [LinkedIn](https://www.linkedin.com/company/iamops-dev/)
