iamops.dev
Argo sur X Flux RSS
FRFrançais

Labs Pratique · 20 minutes

OPA derrière AuthZEN : un point de décision pour les appels d'outils MCP

J'ai écrit une politique Rego pour les outils MCP, testée sur OPA 1.22.4, avec un point AuthZEN devant. Un paiement de 90 $ au-delà de 50 $ est refusé.

Deux captures du terminal de mon lab OPA : un opa eval d'une requête qui renvoie false avec le motif over delegated limit, et le même refus renvoyé par le point d'accès AuthZEN.
En brefLe 11 novembre 2026, IndyKite et Obsidian ont décrit la même structure…
  • Le 11 novembre 2026, IndyKite et Obsidian ont décrit la même structure : l'agent ou son runtime propose un appel, et un point de décision séparé répond pour chaque appel.
  • Je l'ai construite en local : une politique Rego dans OPA 1.22.4, six tests unitaires et un petit point d'accès AuthZEN Access Evaluation devant OPA. Un paiement de 90 $ contre une limite de 50 $ est revenu avec decision false et le motif over delegated limit.
  • La politique refuse par défaut. Un outil inconnu, un scope manquant, un paiement au-delà de la limite et un paiement non confirmé ont été refusés, et j'ai cassé une règle exprès pour voir un test échouer.
  • Quand j'ai arrêté OPA, mon shim n'a donné aucune réponse ; le point d'application doit donc traiter une décision absente comme un refus.
  • Non testés : une vraie passerelle MCP comme point d'application, les tests de conformité AuthZEN, les API batch et de recherche et la journalisation des décisions.
Refaire ce lab 8 é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: OPA derrière AuthZEN : un point de décision pour les appels d'outils MCP
Read the whole lab here (Markdown): https://iamops.dev/fr/opa-authzen-mcp-tool-call-policy.md

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

How I want you to work:
1. Read the lab from start to finish first (each step lists its own prerequisites). Then check that the prerequisites are in place and that the tool versions match what the lab expects. Tell me what is missing before you run anything.
2. Run one step at a time. Before each command, show it to me and say in a sentence what it does.
3. Ask me before anything that costs money, creates cloud resources, touches a real tenant or account, or deletes anything. Wait for my answer.
4. Use the placeholders from the lab. Never paste real secrets, tokens or production identities into a command, a file or this chat. If a value is needed, tell me where to set it myself.
5. After each step, compare the output with the expected output in the lab. If it does not match, stop and tell me what differs. Do not carry on or invent a fix without asking me.
6. At the end, report what passed, what failed and which cleanup you did. Then offer to tick the steps off for me. The lab page keeps ticks only in my browser, so if you cannot do that, list the steps I should tick.

This lab is for test environments only. Do not run it against production, or against a tenant or account that holds real data or real users.

You may answer in my language.

Le 11 novembre 2026, deux éditeurs ont publié la même idée de deux côtés. IndyKite a publié son Intent Agent, qui transforme un prompt en évaluations AuthZEN et, selon son guide développeur, ne décide rien : la décision reste au service AuthZEN. Obsidian a décrit un Runtime Policy Decision Engine où un MCP Security Proxy, un runtime d’agents ou une passerelle client met un appel d’outil en pause, demande une décision et applique la réponse.

Les deux partagent le travail de la même façon. Quelque chose qui tient la requête demande, et autre chose décide. Je voulais faire tourner ce partage sur ma propre machine avec uniquement des briques open source, alors je l’ai construit : un moteur de politiques (OPA) avec une politique pour les appels d’outils MCP, et un fin point d’accès AuthZEN devant.

J’ai écrit une courte présentation d’AuthZEN, OPA et Cedar.

Ce que construit le lab#

  • Une politique Rego qui reçoit une requête au format AuthZEN (subject, action, resource, context) pour un tools/call MCP et renvoie un booléen plus des motifs.
  • Six tests unitaires qui tournent hors ligne avec l’exécuteur de tests d’OPA.
  • Un petit point d’accès Python qui répond à POST /access/v1/evaluation et au document de métadonnées du PDP, et transmet la requête à OPA comme input.
  • Deux refus que je voulais voir : un paiement au-delà de la limite déléguée à l’agent, et ce qui se passe quand OPA n’est pas là.

L’argent est en centimes de dollar américain. L’agent peut payer jusqu’à 5000 centimes, soit 50 $.

Diagramme de séquence : un appelant envoie une évaluation AuthZEN pour un tools/call MCP à un petit endpoint, qui la transmet à OPA 1.22.4. Un paiement de 9000 cents pour une limite de 5000 est refusé avec la raison over delegated limit, 4500 cents est autorisé, d'autres appels erronés sont refusés avec des raisons, et un OPA arrêté ne donne aucune réponse HTTP.
La décision. La requête nomme l'agent, le tools/call, l'outil, le montant et la confirmation. 9000 cents pour une limite de 5000 reviennent en decision false avec la raison over delegated limit. 4500 cents avec confirmation est autorisé. Un scope manquant, l'absence de confirmation ou un outil inconnu sont refusés avec des raisons. Si OPA est arrêté, le endpoint ne donne aucune réponse HTTP.

Mise en place#

OPA 1.22.4 est un binaire statique unique de la page des versions. Le point d’accès est un fichier de moins de 40 lignes de Python 3.13 avec la seule bibliothèque standard. Il faut aussi curl et jq. Il n’y a ni Docker, ni base de données, ni compte. Le lab ouvre le port 8181 pour OPA et le 8282 pour le point d’accès, tous deux sur localhost.

La politique#

La requête est celle qu’un point d’application construirait à partir d’un tools/call MCP. Le subject est l’agent avec ses scopes et sa limite, la resource est l’outil, et le context porte le montant et si l’utilisateur a confirmé.

La politique a un catalogue d’outils qui dit quel scope chacun exige et s’il déplace de l’argent. decision vaut false tant qu’une règle ne la met pas à true. Les outils de lecture exigent leur scope. Un outil qui déplace de l’argent exige le scope, un montant au plus égal à la limite et une confirmation :

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

Un second ensemble, reasons, explique les refus. Les fichiers complets figurent dans les étapes du lab plus bas.

D’abord les tests#

L’exécuteur opa test trouve les règles test_ dans les fichiers _test.rego. J’en ai écrit six : une lecture est autorisée, une écriture sans le scope est refusée, un paiement confirmé dans la limite est autorisé, un paiement au-delà de la limite est refusé avec le bon motif, un paiement non confirmé est refusé, et un outil inconnu est refusé. opa check --strict et opa fmt sont passés avant les tests.

Sortie de terminal d'OPA 1.22.4 : informations de version, fmt et vérification stricte réussis, et six tests unitaires en PASS avec le résumé 6 sur 6.
Vérifications et tests. La vérification de format, la vérification stricte et les six tests passent sur OPA 1.22.4.

Pour voir si les tests peuvent échouer, j’ai supprimé dans une copie la ligne user_confirmed de la deuxième règle. Cinq tests ont continué à passer et test_payment_needs_confirmation a échoué. C’est le test qui fait son travail.

Une requête, hors ligne#

opa eval prend la politique et un fichier de requête sans démarrer de serveur. La requête est l’agent support-bot avec les deux scopes et une limite de 5000 centimes, qui appelle send_payment pour 9000 centimes avec la confirmation de l’utilisateur.

Sortie de terminal de deux commandes opa eval : la décision est false et l'ensemble des motifs contient over delegated limit.
Un paiement de 90 $ contre une limite de 50 $. La décision est false et le motif est « over delegated limit ».

Le point d’accès AuthZEN#

OPA tourne en serveur sur le port 8181, et le point d’accès sur le port 8282 se place devant. La spécification AuthZEN définit la requête comme subject, action, resource et context, et la réponse comme un decision booléen obligatoire avec un context facultatif. Elle laisse le contenu de ce context à l’implémentation. J’ai mis les motifs de refus sous reason_admin, la clé de son exemple non normatif. Le document de métadonnées se trouve à /.well-known/authzen-configuration.

Sortie de terminal : le document de métadonnées du PDP avec deux URL, un refus avec decision false et le motif over delegated limit, et une autorisation avec decision true après avoir changé le montant à 4500 centimes.
La même requête via AuthZEN. 9000 centimes sont refusés avec un motif. En changeant seulement le montant à 4500 centimes, on obtient decision true.

Le point d’accès est un outil pédagogique. Il n’authentifie pas les appelants, ne valide pas l’entrée et n’a ni API batch ni API de recherche ; ce n’est donc pas un PDP conforme.

D’autres refus, et OPA qui disparaît#

J’ai envoyé trois autres requêtes avec une petite fonction shell nommée ask. Avec le seul scope de lecture, le paiement a été refusé pour scope manquant, et aussi pour la limite, car le montant valait encore 9000. Avec un montant de 4500 centimes et user_confirmed à false, il a été refusé pour confirmation manquante. Un outil nommé delete_account a été refusé comme inconnu.

Sortie de terminal de trois requêtes refusées avec les motifs missing scope et over delegated limit, user did not confirm et unknown tool, suivies d'une requête après l'arrêt d'OPA qui renvoie le statut HTTP 000.
Trois autres refus. Chacun arrive avec ses motifs. Après l'arrêt d'OPA, la requête ne reçoit aucune réponse HTTP, que curl affiche comme 000.

Ensuite j’ai arrêté OPA et renvoyé la requête de 4500 centimes. Le shim a levé une exception et coupé la connexion, et curl a affiché 000. Il n’y avait aucun decision: false à appliquer. Une passerelle qui attend un true peut traiter cela comme un refus. Une passerelle qui ne bloque que sur un false explicite laisserait passer l’appel. Je n’ai pas testé de vraie passerelle ; c’est donc une raison de vérifier la vôtre, pas un constat sur un produit.

Pièges#

  • Les outils inconnus n’ont pas besoin de règle. Quand l’outil n’est pas dans le catalogue, tool est indéfini, donc chaque règle decision est indéfinie et la valeur par défaut false s’applique. Un test le fixe.
  • Les motifs peuvent s’empiler. reasons est un ensemble, et la requête avec le seul scope de lecture en a renvoyé deux à la fois.
  • La politique fait confiance au context. user_confirmed ne vaut que ce que vaut le point d’application qui le renseigne. Un modèle ne doit jamais pouvoir le remplir. Le guide d’IndyKite dit quelque chose de proche pour le subject : il vient de l’identité vérifiée de l’appelant, jamais du texte du prompt.
  • Refuser par défaut est un choix. Le billet d’Obsidian dit que les appels d’outils qui ne correspondent à aucune politique passent. Les miens sont refusés. Aucun des deux n’est faux, mais décidez-le exprès.

Ce que je ferais de cela#

  1. Placer le point d’application dans la passerelle ou le proxy qui voit chaque tools/call, pas dans l’agent.
  2. Construire le subject à partir du jeton vérifié et de l’enregistrement de délégation, pas à partir de ce que le modèle a écrit.
  3. Garder la politique dans un dépôt avec ses tests et lancer opa test en CI.
  4. Faire refuser le point d’application en cas d’erreur, et le tester en arrêtant le point de décision.

Ce que je n’ai pas testé#

Je n’ai pas testé de vraie passerelle MCP comme point d’application. Je n’ai pas lancé de tests de conformité AuthZEN, l’API d’évaluations batch, les API de recherche ni un autre point de décision AuthZEN. Je n’ai pas testé les bundles OPA, les journaux de décisions ni les performances des politiques. Il n’y a pas d’enregistrement pour ce lab. Le lab n’utilise ni identifiants ni jetons.

Les images de terminal ont été générées à partir de la sortie enregistrée de l’exécution du 20 novembre 2026.

Refaire ce lab#

Ce lab demande Linux sur amd64, curl, jq et Python 3.13. Comptez environ 20 minutes. 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. No secrets are involved.
export OPA_VERSION="1.22.4"
export OPA_URL="http://localhost:8181"
export PDP_URL="http://localhost:8282"
Étape 1Télécharger OPA

Objectif. Téléchargez le binaire statique unique d’OPA à une version figée et affichez sa version.

Prérequis

  • Linux sur amd64 (pour macOS ou arm64, prenez le fichier correspondant sur la page des versions), curl, jq et Python 3.13
  • Ports 8181 et 8282 libres
bash · get-opa.sh
curl -sSL -o opa "https://github.com/open-policy-agent/opa/releases/download/v$OPA_VERSION/opa_linux_amd64_static"
chmod +x opa
./opa version | head -1

Résultat attendu

résultat
Version: 1.22.4
Étape 2Écrire la politique

Objectif. Créez la politique Rego : un catalogue d’outils, une valeur par défaut false, deux règles de décision et un ensemble de motifs de refus.

Prérequis

  • Étape 1 faite, dans le même dossier
bash · write-policy.sh
cat > mcp_tools.rego <<'EOF'
# Which MCP tools may an agent call? The input has the shape of an
# AuthZEN Access Evaluation request: subject, action, resource, context.
package mcp.tools

default decision := false

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

tool := catalog[input.resource.id]

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

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

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

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

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

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

Résultat attendu

résultat
# Which MCP tools may an agent call? The input has the shape of an
# AuthZEN Access Evaluation request: subject, action, resource, context.
package mcp.tools
Étape 3Écrire les tests et les exécuter

Objectif. Écrivez six tests unitaires, puis lancez le formateur, la vérification stricte et l’exécuteur de tests. Tout doit passer.

Prérequis

  • Le fichier de politique de l’étape précédente
bash · unit-tests.sh
cat > mcp_tools_test.rego <<'EOF'
package mcp.tools_test

import data.mcp.tools

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

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

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

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

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

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

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

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

Résultat attendu

résultat
fmt + strict check: OK
mcp_tools_test.rego:30:
data.mcp.tools_test.test_unknown_tool_denied: PASS (970.514µs)
mcp_tools_test.rego:17:
data.mcp.tools_test.test_payment_within_limit_confirmed: PASS (984.282µs)
mcp_tools_test.rego:26:
data.mcp.tools_test.test_payment_needs_confirmation: PASS (1.131509ms)
mcp_tools_test.rego:21:
data.mcp.tools_test.test_payment_over_limit_denied: PASS (1.197352ms)
mcp_tools_test.rego:13:
data.mcp.tools_test.test_write_needs_scope: PASS (1.433506ms)
mcp_tools_test.rego:9:
data.mcp.tools_test.test_read_allowed: PASS (1.255784ms)
--------------------------------------------------------------------------------
PASS: 6/6
Étape 4Évaluer une requête hors ligne

Objectif. Écrivez une requête au format AuthZEN pour un paiement de 90 dollars avec une limite de 50 dollars et évaluez-la avec opa eval, sans serveur.

Prérequis

  • Les montants sont en centimes : 9000 font 90 dollars et 5000 font 50 dollars
bash · eval-offline.sh
cat > request.json <<'EOF'
{
  "subject": { "type": "agent", "id": "support-bot",
               "properties": { "scopes": ["payments.read", "payments.write"], "limit_cents": 5000 } },
  "action": { "name": "tools/call" },
  "resource": { "type": "mcp_tool", "id": "send_payment" },
  "context": { "amount_cents": 9000, "user_confirmed": true }
}
EOF
./opa eval -d mcp_tools.rego -i request.json 'data.mcp.tools.decision' --format pretty
./opa eval -d mcp_tools.rego -i request.json 'data.mcp.tools.reasons' --format pretty

Résultat attendu

résultat
false
[
  "over delegated limit"
]
Étape 5Lancer OPA en serveur et ajouter le point AuthZEN

Objectif. Servez la politique depuis OPA sur le port 8181, vérifiez son API de décision, puis démarrez le petit point Python sur le port 8282 et lisez son document de métadonnées.

Prérequis

  • Étapes 2 à 4 faites
  • Le point d’accès est un outil pédagogique, pas un PDP AuthZEN conforme ; gardez-le sur localhost
bash · serve-opa.sh
./opa run --server --addr localhost:8181 mcp_tools.rego > opa-server.log 2>&1 &
sleep 2
curl -s $OPA_URL/health
curl -s $OPA_URL/v1/data/mcp/tools/decision -d '{"input":'"$(cat request.json)"'}'
bash · start-endpoint.sh
cat > authzen_pdp.py <<'EOF'
"""A minimal AuthZEN Access Evaluation endpoint in front of OPA.
Standard library only (Python 3.10+). OPA runs on :8181 with mcp_tools.rego loaded.
This is a teaching shim, not a conformant AuthZEN PDP."""
import json
import urllib.request
from http.server import BaseHTTPRequestHandler, HTTPServer

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


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

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

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


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

Résultat attendu

résultat
{}
{"result":false}
{
  "policy_decision_point": "http://localhost:8282",
  "access_evaluation_endpoint": "http://localhost:8282/access/v1/evaluation"
}
Étape 6Demander une décision : 90 dollars, puis 45

Objectif. Envoyez la requête au point d’évaluation AuthZEN. Il doit refuser avec un motif. Puis changez seulement le montant à 4500 centimes et redemandez.

Prérequis

  • OPA et le point d’accès tournent
bash · evaluate.sh
curl -s $PDP_URL/access/v1/evaluation -H 'content-type: application/json' -d @request.json | jq .
jq '.context.amount_cents=4500' request.json \
  | curl -s $PDP_URL/access/v1/evaluation -H 'content-type: application/json' -d @- | jq .

Résultat attendu

résultat
{
  "decision": false,
  "context": {
    "reason_admin": {
      "403": "over delegated limit"
    }
  }
}
{
  "decision": true
}
Étape 7Essayer d’autres refus, puis arrêter OPA

Objectif. Envoyez trois autres requêtes : un scope manquant, un paiement non confirmé et un outil inconnu. Arrêtez ensuite OPA et redemandez pour voir qu’aucune décision ne revient.

Prérequis

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

Résultat attendu

résultat
{"decision":false,"context":{"reason_admin":{"403":"missing scope, over delegated limit"}}}
{"decision":false,"context":{"reason_admin":{"403":"user did not confirm"}}}
{"decision":false,"context":{"reason_admin":{"403":"unknown tool"}}}
000
Étape 8Nettoyage

Objectif. Arrêtez les deux processus et supprimez les fichiers créés par le lab.

Prérequis

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

Résultat attendu

résultat
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