iamops.dev
Argo auf X RSS-Feed
DEDeutsch

Labs Praxis · 25 Min.

Permit.io hinter AuthZEN: entscheiden, welche MCP-Aufrufe ein Agent machen darf

Ich habe einen Permit.io-PDP hinter einen kleinen MCP-Enforcement-Point mit AuthZEN gestellt. 90 Dollar wurden abgelehnt, 45 Dollar erlaubt, Fehler blieben zu.

Geschwärzte Permit.io-Konsolenaufnahmen aus meinem Lab: der Policy Editor mit den Rollen payments_reader und payments_writer und das Audit Log mit zwei erlaubten und vier abgelehnten Tool-Aufrufen.
Kurz gesagtIch habe das Lab mit OPA (Open Policy Agent) mit Permit.io im…
Dieses Lab nachbauen 7 Schritte

Dieses Lab habe ich so geschrieben, dass Sie es selbst nachbauen können. Jeder Schritt enthält die Befehle zum Kopieren und die Ausgabe, die ich bekommen habe, und Sie können ihn als erledigt abhaken. Die Haken bleiben nur in diesem Browser.

Zu den Schritten

So funktioniert es

Kopiert einen fertigen Prompt für Claude Code, Cursor, Codex oder einen anderen Coding-Agenten. Nur für Testumgebungen.

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

Lab: Permit.io hinter AuthZEN: entscheiden, welche MCP-Aufrufe ein Agent machen darf
Read the whole lab here (Markdown): https://iamops.dev/de/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.

Anfang des Monats habe ich einen Entscheidungspunkt für MCP-Tool-Aufrufe mit OPA gebaut: Ein Agent schlägt einen tools/call vor, etwas vor dem MCP-Server fragt eine Policy-Engine, und die Engine antwortet über AuthZEN mit ja oder nein. Diesmal ist die Engine Permit.io.

Permit.io passt aus zwei Gründen gut zum Vergleich. Sein PDP spricht AuthZEN 1.0 ohne Zusatzaufwand, und im März hat das Team Permit MCP Gateway veröffentlicht, einen Proxy vor MCP-Servern, der jeden Tool-Aufruf gegen Permit prüft. Ihr Beitrag über die sechs Ebenen, die jedes MCP-Gateway durchsetzen muss, ist eine kurze, nützliche Liste dessen, was ein Gateway über das Routing hinaus leisten muss.

Ich habe nur genutzt, was der kostenlose Community-Plan enthält. Neue Konten starten mit einer 14-tägigen Pro-Testphase, aber dieses Lab braucht sie nicht: RBAC, ABAC, der Edge PDP und das Audit-Log sind alle im kostenlosen Plan.

Wie Permit MCP-Tool-Aufrufe modelliert#

Die Architektur-Dokumentation des Gateways beschreibt die Zuordnung. Jeder MCP-Server wird ein Permit-Ressourcentyp mit dem Server-Schlüssel. Jedes Tool wird eine Aktion auf diesem Ressourcentyp. Für einen Tool-Aufruf führt das Gateway ein permit.check() aus, mit dem Agenten als Benutzer, dem Tool-Namen als Aktion und dem Server als Ressource, dazu eine zweite Prüfung für die Person, wenn ein Admin den Server importiert hat. Beide müssen erlauben.

Darüber liegen Vertrauensstufen (niedrig für Lesen, mittel für Schreiben, hoch für Löschen) und eine Obergrenze: Der Agent bekommt nie mehr, als der Admin der Person gegeben hat. Permit baut diese Grenze als ReBAC-Regeln. Laut Dokumentation lehnt das Gateway die Anfrage ab, wenn der PDP nicht antwortet, mit dem JSON-RPC (entfernte Prozeduraufrufe in JavaScript Object Notation)-Fehler -32005. Eine normale Ablehnung ist -32004. Ich habe -32004 in meinem Enforcement Point übernommen.

Der PDP ist der Teil, den ich getestet habe. Permit bietet drei Arten. Der Cloud PDP läuft gehostet unter cloudpdp.api.permit.io und deckt RBAC und ReBAC ab. Der Edge PDP ist ein Open-Source-Container (permitio/pdp-v2), der OPA und den Client von OPAL (Open Policy Administration Layer) enthält und auch ABAC abdeckt. Nexus PDP ist ein neuerer Container mit Speicher auf der Festplatte. Alle drei bieten die AuthZEN-Endpunkte: Evaluation, Batch-Evaluationen, die drei Such-APIs und das Discovery-Dokument.

Sequenzdiagramm: Die Permit-Control-Plane sendet Policy und Daten an den Edge PDP. Ein KI-Agent sendet einen MCP-tools/call an pep.py, das den Subject aus der Sitzung nimmt und eine AuthZEN-Evaluation an den PDP sendet. Bei 9000 Cent gegen ein Limit von 5000 antwortet der PDP decision false und pep.py gibt Fehler -32004 zurück. Bei 4500 Cent mit Bestätigung antwortet er decision true und das Tool läuft. Ohne Schlüssel im PEP oder bei gestopptem PDP lehnt pep.py ab und bleibt zu. Der PDP sendet Entscheidungslogs an das Permit-Audit-Log.
Der Ablauf, den ich ausgeführt habe. Der Enforcement Point baut die AuthZEN-Anfrage aus der Sitzung, nicht aus dem, was das Modell geschrieben hat. Der PDP entscheidet nach der Policy aus Permit, und Fehler enden in einer Ablehnung.

Vorbereitung#

Ich habe Podman 5.4.2 auf Debian 13 für das Edge-PDP-Image permitio/pdp-v2:0.9.17 verwendet, dazu Python 3.13, das Permit Python SDK (Software Development Kit) 3.0.1 (das Paket im Python Package Index heißt permit), curl und jq. Alles lauscht auf localhost: 7766 für den PDP und 8383 für den Enforcement Point. Docker funktioniert genauso: Ersetzen Sie podman durch docker.

Sie brauchen ein kostenloses Permit.io-Konto. Registrieren Sie sich auf app.permit.io, öffnen Sie die Development-Umgebung des Standardprojekts und kopieren Sie deren Schlüssel für die API (Programmierschnittstelle) unter Settings, API Keys. Das Lab liest den Schlüssel über eine verdeckte Eingabe in eine einzige Shell-Variable. Er landet nie in einer Datei, einem Log oder einem Screenshot, und der PDP-Container erhält ihn als PDP_API_KEY.

Das Szenario ist das aus dem OPA-Lab. Ein Agent namens support-bot darf Kontostand und Umsätze lesen und Zahlungen bis 5000 Cent, also 50 Dollar, senden, wenn der Benutzer bestätigt hat. read-bot darf nur lesen. Die Tools sind get_balance, list_transactions und send_payment auf einem MCP-Server, payments_mcp. delete_account gibt es nicht.

Die Policy#

setup_permit.py legt die Policy über die Permit-API an. So können Sie sie in jeder Umgebung neu aufbauen und mit cleanup_permit.py wieder entfernen:

  • Ressourcentyp payments_mcp mit den drei Tools als Aktionen und zwei Attributen, amount_cents und user_confirmed.
  • Ein Benutzerattribut limit_cents, für beide Agenten auf 5000 gesetzt.
  • Zwei Rollen anstelle der Scopes: payments_reader mit den zwei Lese-Tools (RBAC) und payments_writer ohne einfache Berechtigungen.
  • Ein ABAC-Resource-Set, payment_within_limit: resource.amount_cents kleiner oder gleich user.limit_cents, per Referenz verglichen, und resource.user_confirmed gleich true. payments_writer erhält send_payment nur auf diesem Set.
Permit.io-Konsole, Policy, Reiter Resources: Ressourcentyp Payments MCP server mit dem Schlüssel payments_mcp, den Attributen amount_cents: number und user_confirmed: bool und den Aktionen get_balance, list_transactions und send_payment.
Der MCP-Server als Ressource. Ein Ressourcentyp, eine Aktion pro Tool und die zwei Attribute, die die ABAC-Regel liest.
Permit.io-Konsole, Policy Editor: Die Rolle payments.read (payments_reader) hat get_balance und list_transactions in der Spalte Payments MCP server angehakt und nichts in der Spalte Payment within limit; die Rolle payments.write (payments_writer) hat nur send_payment angehakt, in der Spalte Payment within limit.
Rollen im Policy-Editor. Der Leser bekommt die zwei Lese-Tools. Der Schreiber bekommt send_payment nur in der Spalte des Resource Sets, nicht auf dem Server selbst.
Permit.io-Konsole, Bearbeitungsansicht der dynamischen ABAC-Ressource Payment within limit and confirmed, Schlüssel payment_within_limit, Ressourcentyp payments_mcp, mit zwei Bedingungen: resource.amount_cents less-than-equals (ref) user.limit_cents und resource.user_confirmed equals True.
Die ABAC-Regel. Im Bearbeitungsfenster geöffnet, nichts geändert. Der Betrag wird mit dem Limit-Attribut des Agenten verglichen, nicht mit einer festen Zahl.
Permit.io-Konsole, Directory, Default Tenant, Users: support-bot mit dem Zugriff payments_writer und payments_reader auf oberster Ebene und read-bot mit payments_reader.
Die zwei Agenten. Beide Agenten sind Benutzer im Standard-Tenant; nur support-bot hat die Schreibrolle.
Terminal-Ausgabe: Eine virtuelle Python-Umgebung erhält das Paket permit 3.0.1, setup_permit.py meldet policy created mit payments_mcp, 2 Rollen, 1 Resource Set und 2 Agenten, podman startet permit-pdp aus pdp-v2 0.9.17 mit PDP_API_KEY aus einer Shell-Variablen, und der healthy-Endpunkt meldet status ok für OPA und horizon.
Policy geladen, PDP gesund. Der Schlüssel geht als Variable hinein und erscheint nie. Nach 30 Sekunden melden beide Teile des PDP ok.

Der PDP hat die Policy innerhalb der 30 Sekunden geladen, die ich ihm gegeben habe, und /healthy meldete für beide Teile ok.

Der Enforcement Point#

pep.py nimmt einen JSON-RPC-tools/call entgegen, ermittelt den Agenten aus dem Sitzungs-Header und sendet Permit eine AuthZEN Access Evaluation. Die Form folgt der Gateway-Zuordnung: Subject ist der Agent, Aktion ist der Tool-Name, Ressource ist der MCP-Server. Betrag und Bestätigung kommen in resource.properties, weil laut Permit-Dokumentation der PDP dort tenant liest und die übrigen Schlüssel als Ressourcenattribute an die Policy weitergibt.

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

Wichtig sind die Zeilen nach dem Aufruf. Nur HTTP (Hypertext Transfer Protocol) 200 mit "decision": true erlaubt. Jeder HTTP-Fehler, ein Timeout, eine abgelehnte Verbindung oder eine Antwort ohne Boolean ist eine Ablehnung, und das Log sagt, welcher Fall es war.

Permit antwortet mit mehr als der Entscheidung. Das Feld context enthält die Begründung, samt der Rollen des Agenten und seinem limit_cents. pep.py behält die kurzen Begründungscodes für das eigene Log und sagt dem Agenten nur denied: policy. Ein Agent, der das Limit lesen kann, kann lernen, eine Zahlung darunter aufzuteilen.

Lauf 1: AuthZEN mit Schlüssel#

Zuerst habe ich die AuthZEN-Endpunkte direkt geprüft, mit dem Schlüssel im Bearer-Header: das Discovery-Dokument, eine Evaluation für get_balance, einen Batch mit vier Zahlungen in einer Anfrage und eine Subject-Suche, wer get_balance aufrufen darf.

Terminal-Ausgabe: Das AuthZEN-Discovery-Dokument listet sechs Einträge, eine Evaluation für get_balance antwortet decision true mit der Rolle payments_reader, ein Batch aus vier send_payment-Evaluationen antwortet false, true, false, false mit rbac- und abac-Codes, und eine Subject-Suche liefert read-bot und support-bot.
Vier Zahlungen, ein Ja. Nur die bestätigte Zahlung über 45 Dollar geht durch, über die ABAC-Regel. 90 Dollar, die unbestätigten 45 und read-bot werden abgelehnt.

Der Batch ist die Policy in vier Zeilen. 90 Dollar gegen das Limit von 50: false. 45 Dollar bestätigt: true, erlaubt durch die ABAC-Regel. 45 Dollar unbestätigt: false. Dieselben 45 Dollar von read-bot, als Subject des einzelnen Batch-Eintrags gesetzt: false. Die Subject-Suche fand beide Agenten, weil beide payments_reader haben. Die Aktionssuche lieferte in meinem Lauf für beide Agenten eine leere Liste. Ich habe den Grund nicht untersucht und verlasse mich hier deshalb nicht darauf.

Lauf 2: sechs Tool-Aufrufe durch den Enforcement Point#

Dann habe ich pep.py gestartet und die sechs Aufrufe aus dem OPA-Lab gesendet: eine Kontostandsabfrage, eine Zahlung über 90 Dollar, eine über 45 Dollar mit und ohne Bestätigung, eine Zahlung von read-bot und das unbekannte delete_account.

Terminal-Ausgabe: sechs JSON-RPC-Antworten von pep.py, zwei Ergebnisse für get_balance und send_payment und vier Fehler -32004 denied: policy, danach die Zeilen aus pep.log: get_balance ALLOW über rbac, send_payment über 90 Dollar DENY, bestätigte 45 Dollar ALLOW über abac, die unbestätigte DENY, read-bot DENY und delete_account DENY mit rbac no_such_action.
Zwei erlaubt, vier abgelehnt. Dasselbe Ergebnis wie im OPA-Lab. Der Agent sieht nur denied: policy; die Begründungscodes bleiben im Log.

Die Ergebnisse entsprechen dem OPA-Lab. Zwei Aufrufe liefen: die Kontostandsabfrage, erlaubt durch die Rolle, und die bestätigte Zahlung über 45 Dollar, erlaubt durch die ABAC-Regel. Vier hat die Policy abgelehnt. Für delete_account sagte der PDP no_such_action: Das Tool ist keine Aktion auf payments_mcp, also kann keine Rolle es gewähren.

Jede Entscheidung kam auch im Permit-Audit-Log an. Ich habe sie über die Audit-Log-API gezählt: Benutzer, Aktion, Ressourcentyp und Entscheidung für jeden Aufruf dieses Laufs, einschließlich der Aufrufe an den Cloud PDP in Lauf 4.

Permit.io-Konsole, Audit Log, Ansicht Check: Zeilen von 11:23:53 bis 11:25:17 Uhr am 22. November 2026, alle auf payments_mcp im Tenant default. Die sechs Zeilen um 11:25:17 sind delete_account abgelehnt, send_payment von read-bot abgelehnt, send_payment von support-bot abgelehnt, erlaubt und abgelehnt, und get_balance erlaubt.
Entscheidungen im Audit-Log. Die sechs Zeilen um 11:25:17 sind ein Lauf der sechs Aufrufe: zwei erlaubt, vier abgelehnt. Die Zeilen darunter stammen aus früheren Läufen.
Permit.io-Konsole, Audit Event für send_payment von read-bot auf payments_mcp um 11:25:17 Uhr, Entscheidung abgelehnt, mit Debug-JSON: abac allow false, code no_matching_rules und der Begründung, dass read-bot keiner Regel entspricht, die die Berechtigung send_payment auf payments_mcp gewährt.
Warum read-bot abgelehnt wurde. Der Audit-Eintrag behält die Begründung, die der PDP geliefert hat: keine passende Regel.

Lauf 3: Fail closed mit aktiver Policy#

Eine funktionierende Policy schafft den Fehlerpfad nicht ab. Ich habe pep.py mit leerem Schlüssel gegen denselben gesunden PDP neu gestartet, danach den PDP-Container gestoppt und die Zahlung über 45 Dollar erneut gesendet.

Terminal-Ausgabe: pep.py, mit leerem Schlüssel neu gestartet, gibt für die bestätigte Zahlung über 45 Dollar Fehler -32004 denied: pdp error HTTP 403, fail closed zurück; nachdem podman permit-pdp stoppt, gibt derselbe Aufruf denied: pdp unreachable (URLError), fail closed zurück, und pep.log zeigt beide Gründe.
Ein erlaubter Aufruf, zweimal abgelehnt. Die Policy sagt ja, aber ohne Schlüssel oder PDP sagt der Enforcement Point nein, und das Log sagt warum.

Beide Male wurde die bestätigte Zahlung über 45 Dollar, die die Policy erlaubt, abgelehnt. Die Log-Zeile sagt warum: pdp error HTTP 403 und pdp unreachable, nicht decision false. Genau auf diesen Unterschied sollte ein Alarm achten.

Lauf 4: Der Cloud PDP wertet kein ABAC aus#

Der Cloud PDP akzeptierte denselben Schlüssel und denselben Batch und antwortete viermal false. Der Grund stand im Context: ABAC is not supported yet in the Cloud PDP. Mit pep.py auf den Cloud PDP gerichtet lief die Kontostandsabfrage weiter über die Rolle, aber die bestätigte Zahlung über 45 Dollar wurde abgelehnt.

Terminal-Ausgabe: Derselbe Batch an cloudpdp.api.permit.io antwortet viermal decision false mit ABAC is not supported yet in the Cloud PDP; pep.py, auf den Cloud PDP gerichtet, erlaubt get_balance und lehnt beide send_payment-Aufrufe ab, und das Log zeigt abac NOT_SUPPORTED.
Der Cloud PDP überspringt ABAC. Die Rolle wirkt weiter, die Limit-Regel nicht, also wird sogar die bestätigte Zahlung über 45 Dollar abgelehnt.

Das bleibt zu, also die sichere Richtung, aber es sähe wie eine kaputte Policy aus, wenn man es nicht wüsste. Limits wie dieses brauchen den Edge PDP oder eine Policy, die nicht von ABAC abhängt.

Vor dem Schlüssel: was ein PDP ohne Schlüssel tut#

Bevor das Konto existierte, habe ich dasselbe Lab ohne Schlüssel ausgeführt. Ich behalte diese Ergebnisse, weil sie zeigen, wie ein falsch konfigurierter PDP aus Sicht des Enforcement Points aussieht.

Der Container startete ohne PDP_API_KEY und beendete sich nicht. Sein Watchdog startete den internen API-Server immer wieder neu, und /healthy meldete einen Fehler.

Terminal-Ausgabe: podman startet permit-pdp aus pdp-v2 0.9.17, der Container läuft, das Log meldet Failed to get Environment API Key mit ApiKeyError No API key specified, und der healthy-Endpunkt meldet status error mit dem Hinweis, dass der PDP noch keinen API-Schlüssel hat.
Läuft, aber nicht gesund. Der Container läuft, und der PDP sagt klar, dass er keinen API-Schlüssel hat.

AuthZEN-Anfragen bekamen Statuscodes und nie eine Entscheidung: 401 ohne Header, 403 mit leerem Bearer-Token und 503 mit falschem Schlüssel. Der Container wollte auch für das Discovery-Dokument ein Token.

Terminal-Ausgabe: healthy antwortet HTTP 503, eine AuthZEN-Evaluation ohne Authorization-Header antwortet Missing Authorization header mit HTTP 401, und dieselbe Anfrage mit leerem Bearer-Token antwortet, dass der Aufrufer nicht berechtigt ist, mit HTTP 403.
Keine Entscheidung, nur Statuscodes. 503 beim Health-Check, 401 ohne Header, 403 mit leerem Schlüssel.

Alle sechs Tool-Aufrufe durch pep.py wurden abgelehnt, jeder mit pdp error HTTP 403. Das richtige Ergebnis aus dem falschen Grund. Für den Agenten sieht ein PDP, der seinen Schlüssel verloren hat, aus wie eine strenge Policy, also kann nur das Log beides unterscheiden.

Terminal-Ausgabe: sechs JSON-RPC-Antworten, jede ein Fehler mit Code -32004 und der Meldung denied, pdp error HTTP 403, fail closed, danach das Log des Enforcement Point mit einer DENY-Zeile pro Aufruf für support-bot und read-bot.
Sechs Aufrufe, sechs Ablehnungen. Selbst die harmlose Kontostandsabfrage wird abgelehnt, weil der PDP keine Entscheidung geliefert hat.

Der Cloud PDP lieferte sein Discovery-Dokument ohne Token und antwortete 401 auf eine Evaluation ohne Token. Die Fehlertexte unterscheiden sich: JSON beim Cloud PDP, reiner Text beim Container.

Terminal-Ausgabe: das Discovery-Dokument des Cloud PDP listet die Endpunkte für Evaluation, Batch-Evaluationen und die drei Suchen, eine Evaluation ohne Token antwortet Unauthorized mit HTTP 401, und der auf den Cloud PDP gerichtete Enforcement Point lehnt zwei Aufrufe mit pdp error HTTP 401, fail closed ab.
Discovery ist öffentlich, Entscheidungen nicht. Alle fünf AuthZEN-Endpunkte sind aufgeführt, und der Enforcement Point schließt beim 401.

Stolperfallen#

  • Der Cloud PDP ignoriert ABAC. Er antwortet false mit NOT_SUPPORTED im Context. Für Attributregeln brauchen Sie den Edge PDP. Er sendet auch keine Header für CORS (Cross-Origin Resource Sharing), ein Browser kann seine Antworten also nicht lesen. Rufen Sie ihn von einem Server auf.
  • Der Entscheidungs-Context verrät viel. Rollen, Attribute und Regelnamen kommen mit jeder Antwort zurück. Loggen Sie die Codes, geben Sie sie nicht an den Agenten weiter.
  • Ein fehlender Schlüssel ist keine Policy. Der Container läuft weiter und antwortet je nach Anfrage mit 401, 403 oder 503. Nur der PEP kann daraus eine sichere Ablehnung machen.
  • Das Subject kommt aus der Sitzung. pep.py ignoriert jeden Agentennamen in den Argumenten. Dasselbe gilt für user_confirmed: In einem echten Gateway muss es aus einem Bestätigungsschritt kommen, den das Modell nicht fälschen kann.
  • Tool-Listen werden nicht gefiltert. Laut Permit-Gateway-Dokumentation liefert tools/list alle Upstream-Tools, und die Durchsetzung passiert bei jedem Aufruf. Ein Agent kann ein Tool sehen, das er nicht nutzen darf.
  • Das Gateway nutzt den SDK-Check, nicht AuthZEN. AuthZEN ist der Weg, über den ein anderer PEP, wie meiner, mit demselben PDP spricht.

Was ich damit machen würde#

  1. Den Enforcement Point bei Fehlern zumachen und den Grund loggen lassen, dann in einem Test den PDP stoppen und die Log-Zeile prüfen.
  2. Alarmieren, wenn Ablehnungen von PDP-Fehlern statt von Policy-Entscheidungen kommen.
  3. Den PDP-Schlüssel auf der Serverseite halten, im Gateway oder in einem Sidecar, nie in einem Browser oder im Prompt eines Agenten.
  4. Den PDP-Typ nach dem Policy-Modell wählen: ABAC-Limits wie dieses brauchen den Edge PDP.
  5. Den Entscheidungs-Context entfernen, bevor etwas an den Agenten zurückgeht.

Was nicht ausgeführt wurde#

Dieses Lab nutzt einen eigenen kleinen Enforcement Point statt des gehosteten Permit MCP Gateway. Es verwendet nur Funktionen des kostenlosen Community-Plans.

Die Terminal-Bilder sind aus der gespeicherten Ausgabe vom 22. November 2026 erzeugt, die Konsolen-Screenshots stammen vom selben Tag. Der Schlüssel erscheint nie.

Dieses Lab nachbauen#

Für dieses Lab brauchen Sie ein kostenloses Permit.io-Konto, Linux mit Podman oder Docker, curl, jq und Python 3.10 oder neuer. Planen Sie etwa 25 Minuten ein. env.sh fragt den API-Schlüssel Ihrer Development-Umgebung verdeckt ab; halten Sie ihn aus Dateien, Chats und Screenshots heraus. Öffnen Sie jeden Schritt, kopieren Sie die Blöcke und vergleichen Sie die Ausgabe mit meiner.

Jeder Wert in spitzen Klammern ist ein Platzhalter für Ihre Testumgebung. Nichts auf dieser Seite ist eine echte Kennung oder ein echtes Geheimnis.

Variablen einmal setzen

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")
Schritt 1Die Policy in Ihre Permit-Umgebung laden

Ziel. Installieren Sie das Permit Python SDK in einer virtuellen Umgebung und führen Sie setup_permit.py aus, um Ressource, Rollen, ABAC-Resource-Set und zwei Agenten anzulegen.

Voraussetzungen

  • Ein kostenloses Permit.io-Konto; der API-Schlüssel der Development-Umgebung, an der Eingabe von env.sh getippt
  • Linux mit Podman 5 oder Docker, curl, jq und Python 3.10 oder neuer
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

Erwartete Ausgabe

Ausgabe
policy created: payments_mcp, 2 roles, 1 resource set, 2 agents
Schritt 2Den Permit Edge PDP mit Schlüssel starten

Ziel. Starten Sie das Edge-PDP-Image in der festen Version mit PDP_API_KEY aus der Shell-Variablen, warten Sie, bis es die Policy geladen hat, und lesen Sie den Health-Endpunkt.

Voraussetzungen

  • Die Policy aus dem vorigen Schritt existiert
  • Ports 7766 und 8383 frei
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}'

Erwartete Ausgabe

Ausgabe
<container-id>
permit-pdp docker.io/permitio/pdp-v2:0.9.17 Up 30 seconds
{"status":"ok","opa":"ok","horizon":"ok"}
Schritt 3Den PDP über AuthZEN fragen

Ziel. Lesen Sie das Discovery-Dokument, senden Sie eine Evaluation, einen Batch mit vier Zahlungen und eine Subject-Suche, und vergleichen Sie die Entscheidungen.

Voraussetzungen

  • Der PDP ist gesund
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'

Erwartete Ausgabe

Ausgabe
["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"}]
Schritt 4Sechs Tool-Aufrufe durch den Enforcement Point schicken

Ziel. Schreiben Sie pep.py und calls.sh, starten Sie den Enforcement Point und senden Sie die sechs MCP-Aufrufe aus dem OPA-Lab.

Voraussetzungen

  • Der PDP ist gesund
  • Port 8383 frei
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

Erwartete Ausgabe

Ausgabe
{"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)
Schritt 5Den Schlüssel entfernen, dann den PDP stoppen

Ziel. Starten Sie den Enforcement Point mit leerem Schlüssel neu, stoppen Sie dann den PDP-Container, und senden Sie jedes Mal die erlaubte Zahlung über 45 Dollar.

Voraussetzungen

  • pep.py und calls.sh aus dem vorigen Schritt
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

Erwartete Ausgabe

Ausgabe
{"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
Schritt 6Denselben Batch an den Cloud PDP senden

Ziel. Senden Sie den Batch mit demselben Schlüssel an den Permit Cloud PDP, richten Sie dann den Enforcement Point darauf und senden Sie die ersten drei Aufrufe.

Voraussetzungen

  • Ausgehendes HTTPS zu 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

Erwartete Ausgabe

Ausgabe
{"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)
Schritt 7Aufräumen

Ziel. Stoppen Sie den Enforcement Point, entfernen Sie den Container, löschen Sie die Policy aus Ihrer Permit-Umgebung und löschen Sie die Dateien.

Voraussetzungen

  • Nichts anderes nutzt die Ports 7766 und 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

Erwartete Ausgabe

Ausgabe
cleanup done
0
000
000

Quellen#

Diskutieren Sie das auf X oder LinkedIn

Auf X folgen

Neue Beiträge per E-Mail

Eine E-Mail pro Woche mit neuen Beiträgen und Labs. Jederzeit abbestellbar.

Ihre Adresse wird bei Kit gespeichert, dem Dienst, der die E-Mails versendet. Details

Verwandte Beiträge und Labs