iamops.dev
Argo auf X RSS-Feed
DEDeutsch

Labs Praxis · 20 Min.

OPA hinter AuthZEN: ein Entscheidungspunkt für MCP-Tool-Aufrufe

Rego-Policy für MCP-Tools, getestet mit OPA 1.22.4, mit AuthZEN-Endpunkt davor: Eine Zahlung von 90 $ über dem Limit von 50 $ wird abgelehnt.

Zwei Terminalaufnahmen aus meinem OPA-Lab: ein opa eval einer Anfrage, das false mit dem Grund over delegated limit liefert, und dieselbe Ablehnung vom AuthZEN-Endpunkt.
Kurz gesagtAm 11. November 2026 beschrieben IndyKite und Obsidian dieselbe…
  • Am 11. November 2026 beschrieben IndyKite und Obsidian dieselbe Struktur: Der Agent oder seine Laufzeit schlägt einen Aufruf vor, und eine getrennte Entscheidungsstelle antwortet für jeden einzelnen Aufruf.
  • Ich habe diese Struktur lokal gebaut: eine Rego-Policy in OPA 1.22.4, sechs Unit-Tests und einen kleinen AuthZEN-Access-Evaluation-Endpunkt vor OPA. Eine Zahlung von 90 $ gegen ein Limit von 50 $ kam als decision false mit dem Grund over delegated limit zurück.
  • Die Policy lehnt standardmäßig ab. Ein unbekanntes Tool, ein fehlender Scope, eine Zahlung über dem Limit und eine unbestätigte Zahlung wurden abgelehnt, und ich habe eine Regel absichtlich zerstört, um einen Test scheitern zu sehen.
  • Als ich OPA stoppte, gab mein Shim gar keine Antwort. Der Durchsetzungspunkt muss eine fehlende Entscheidung daher als Ablehnung behandeln.
  • Nicht getestet: ein echtes MCP-Gateway als Durchsetzungspunkt, AuthZEN-Konformitätstests, die Batch- und Such-APIs und das Protokollieren von Entscheidungen.
Dieses Lab nachbauen 8 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: OPA hinter AuthZEN: ein Entscheidungspunkt für MCP-Tool-Aufrufe
Read the whole lab here (Markdown): https://iamops.dev/de/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.

Am 11. November 2026 veröffentlichten zwei Anbieter dieselbe Idee von verschiedenen Seiten. IndyKite brachte seinen Intent Agent heraus, der einen Prompt in AuthZEN-Auswertungen übersetzt und laut seinem Entwicklerleitfaden nichts entscheidet: Die Entscheidung bleibt beim AuthZEN-Dienst. Obsidian beschrieb eine Runtime Policy Decision Engine, bei der ein MCP Security Proxy, eine Agenten-Laufzeit oder ein Kunden-Gateway einen Tool-Aufruf anhält, eine Entscheidung anfordert und die Antwort umsetzt.

Beide teilen die Arbeit gleich auf. Etwas, das die Anfrage hält, fragt, und etwas anderes entscheidet. Ich wollte diese Aufteilung auf meinem eigenen Rechner mit nichts als Open-Source-Teilen laufen lassen und habe sie gebaut: eine Policy-Engine (OPA) mit einer Policy für MCP-Tool-Aufrufe und einen dünnen AuthZEN-Endpunkt davor.

Ich habe eine kurze Erklärung zu AuthZEN, OPA und Cedar geschrieben.

Was das Lab baut#

  • Eine Rego-Policy, die eine Anfrage in AuthZEN-Form (Subject, Action, Resource, Context) für einen MCP-tools/call entgegennimmt und einen Boolean samt Gründen zurückgibt.
  • Sechs Unit-Tests, die offline mit dem Test-Runner von OPA laufen.
  • Einen kleinen Python-Endpunkt, der POST /access/v1/evaluation und das Metadatendokument des PDP beantwortet und die Anfrage als Input an OPA weiterreicht.
  • Zwei Ablehnungen, die ich sehen wollte: eine Zahlung über dem delegierten Limit des Agenten und was passiert, wenn OPA nicht da ist.

Geld wird in US-Cent angegeben. Der Agent darf bis zu 5000 Cent zahlen, also 50 $.

Sequenzdiagramm: ein Aufrufer sendet eine AuthZEN-Evaluation für einen MCP-tools/call an einen kleinen Endpunkt, der sie an OPA 1.22.4 weiterleitet. Eine Zahlung über 9000 Cent bei einem Limit von 5000 wird mit dem Grund over delegated limit abgelehnt, 4500 Cent wird erlaubt, andere fehlerhafte Aufrufe werden mit Gründen abgelehnt, und ein gestopptes OPA liefert keine HTTP-Antwort.
Die Entscheidung. Die Anfrage nennt den Agenten, den tools/call, das Tool, den Betrag und die Bestätigung. 9000 Cent bei einem Limit von 5000 kommen als decision false mit dem Grund over delegated limit zurück. 4500 Cent mit Bestätigung wird erlaubt. Fehlender Scope, fehlende Bestätigung oder ein unbekanntes Tool werden mit Gründen abgelehnt. Wenn OPA gestoppt ist, gibt der Endpunkt überhaupt keine HTTP-Antwort.

Aufbau#

OPA 1.22.4 ist eine einzelne statische Binärdatei von der Release-Seite. Der Endpunkt ist eine Datei mit weniger als 40 Zeilen Python 3.13 mit nur der Standardbibliothek. Außerdem brauchen Sie curl und jq. Es gibt kein Docker, keine Datenbank und kein Konto. Das Lab öffnet Port 8181 für OPA und Port 8282 für den Endpunkt, beide auf localhost.

Die Policy#

Die Anfrage ist die, die ein Durchsetzungspunkt aus einem MCP-tools/call bauen würde. Das Subject ist der Agent mit seinen Scopes und seinem Limit, die Resource ist das Tool, und der Context trägt den Betrag und ob der Benutzer bestätigt hat.

Die Policy hat einen Tool-Katalog, der sagt, welchen Scope jedes Tool braucht und ob es Geld bewegt. decision ist false, solange keine Regel es auf true setzt. Lesende Tools brauchen ihren Scope. Ein Tool, das Geld bewegt, braucht den Scope, einen Betrag höchstens in Höhe des Limits und eine Bestätigung:

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
}

Eine zweite Menge, reasons, erklärt Ablehnungen. Die vollständigen Dateien stehen in den Lab-Schritten weiter unten.

Erst die Tests#

Der Runner opa test findet test_-Regeln in _test.rego-Dateien. Ich habe sechs geschrieben: Ein Lesen ist erlaubt, ein Schreiben ohne den Scope wird abgelehnt, eine bestätigte Zahlung innerhalb des Limits ist erlaubt, eine Zahlung über dem Limit wird mit dem richtigen Grund abgelehnt, eine unbestätigte Zahlung wird abgelehnt, und ein unbekanntes Tool wird abgelehnt. opa check --strict und opa fmt liefen vor den Tests durch.

Terminalausgabe von OPA 1.22.4: Versionsangaben, bestandene fmt- und Strict-Prüfung und sechs Unit-Tests mit PASS samt Zusammenfassung 6 von 6.
Prüfungen und Tests. Die Formatprüfung, die Strict-Prüfung und alle sechs Tests bestehen auf OPA 1.22.4.

Um zu sehen, ob die Tests scheitern können, habe ich in einer Kopie die Zeile user_confirmed aus der zweiten Regel gelöscht. Fünf Tests bestanden weiter, und test_payment_needs_confirmation scheiterte. So soll ein Test arbeiten.

Eine Anfrage, offline#

opa eval nimmt die Policy und eine Anfragedatei, ohne einen Server zu starten. Die Anfrage ist der Agent support-bot mit beiden Scopes und einem Limit von 5000 Cent, der send_payment für 9000 Cent mit Bestätigung des Benutzers aufruft.

Terminalausgabe zweier opa-eval-Befehle: Die Entscheidung ist false, und die Menge der Gründe enthält over delegated limit.
Eine Zahlung von 90 $ gegen ein Limit von 50 $. Die Entscheidung ist false, der Grund lautet „over delegated limit“.

Der AuthZEN-Endpunkt#

OPA läuft als Server auf Port 8181, und der Endpunkt auf Port 8282 steht davor. Die AuthZEN-Spezifikation definiert die Anfrage als Subject, Action, Resource und Context und die Antwort als verpflichtendes boolesches decision mit optionalem context. Den Inhalt dieses Context überlässt sie der Implementierung. Ich habe die Ablehnungsgründe unter reason_admin abgelegt, dem Schlüssel aus ihrem nicht normativen Beispiel. Das Metadatendokument liegt unter /.well-known/authzen-configuration.

Terminalausgabe: das Metadatendokument des PDP mit zwei URLs, eine Ablehnung mit decision false und dem Grund over delegated limit sowie eine Freigabe mit decision true, nachdem der Betrag auf 4500 Cent geändert wurde.
Dieselbe Anfrage über AuthZEN. 9000 Cent werden mit einem Grund abgelehnt. Ändert man nur den Betrag auf 4500 Cent, kommt decision true zurück.

Der Endpunkt ist ein Lehrbeispiel. Er authentifiziert keine Aufrufer, validiert keine Eingaben und hat weder Batch- noch Such-API, ist also kein konformer PDP.

Weitere Ablehnungen, und OPA verschwindet#

Ich habe drei weitere Anfragen über eine kleine Shell-Funktion namens ask geschickt. Mit nur dem Lese-Scope wurde die Zahlung wegen des fehlenden Scopes abgelehnt und auch wegen des Limits, weil der Betrag noch 9000 war. Mit 4500 Cent und user_confirmed auf false wurde sie wegen der fehlenden Bestätigung abgelehnt. Ein Tool namens delete_account wurde als unbekannt abgelehnt.

Terminalausgabe dreier abgelehnter Anfragen mit den Gründen missing scope und over delegated limit, user did not confirm sowie unknown tool, danach eine Anfrage nach dem Stoppen von OPA, die den HTTP-Status 000 liefert.
Drei weitere Ablehnungen. Jede kommt mit ihren Gründen. Nach dem Stoppen von OPA erhält die Anfrage gar keine HTTP-Antwort, curl zeigt das als 000.

Dann habe ich OPA gestoppt und die Anfrage mit 4500 Cent erneut geschickt. Der Shim löste eine Exception aus und trennte die Verbindung, curl gab 000 aus. Es gab kein decision: false, das sich durchsetzen ließ. Ein Gateway, das auf ein true wartet, kann das als Ablehnung behandeln. Ein Gateway, das nur bei einem ausdrücklichen false blockiert, ließe den Aufruf durch. Ich habe kein echtes Gateway getestet. Das ist also ein Grund, Ihres zu prüfen, kein Befund über ein Produkt.

Stolpersteine#

  • Unbekannte Tools brauchen keine Regel. Ist das Tool nicht im Katalog, ist tool undefiniert, damit ist jede decision-Regel undefiniert, und der Standardwert false greift. Ein Test hält das fest.
  • Gründe können sich häufen. reasons ist eine Menge, und die Anfrage mit nur dem Lese-Scope lieferte zwei auf einmal.
  • Die Policy vertraut dem Context. user_confirmed ist nur so gut wie der Durchsetzungspunkt, der es setzt. Ein Modell darf es nie ausfüllen können. Der Leitfaden von IndyKite sagt Ähnliches über das Subject: Es kommt aus der verifizierten Identität des Aufrufers, nie aus dem Prompt-Text.
  • Standardmäßig ablehnen ist eine Entscheidung. Obsidians Beitrag sagt, Tool-Aufrufe ohne passende Policy laufen weiter. Meine werden abgelehnt. Keines von beidem ist falsch, aber entscheiden Sie bewusst.

Was ich damit machen würde#

  1. Den Durchsetzungspunkt im Gateway oder Proxy platzieren, der jeden tools/call sieht, nicht im Agenten.
  2. Das Subject aus dem verifizierten Token und dem Delegationseintrag bauen, nicht aus etwas, das das Modell geschrieben hat.
  3. Die Policy mit ihren Tests in einem Repository halten und opa test in der CI laufen lassen.
  4. Den Durchsetzungspunkt im Fehlerfall ablehnen lassen und das testen, indem man den Entscheidungspunkt stoppt.

Was ich nicht getestet habe#

Ich habe kein echtes MCP-Gateway als Durchsetzungspunkt getestet. Ich habe keine AuthZEN-Konformitätstests, keine Batch-Evaluations-API, keine Such-APIs und keinen anderen AuthZEN-Entscheidungspunkt ausgeführt. Ich habe weder OPA-Bundles noch Entscheidungsprotokolle noch die Policy-Performance getestet. Für dieses Lab gibt es keine Aufzeichnung. Das Lab benutzt keine Zugangsdaten und keine Tokens.

Die Terminalbilder wurden aus der gespeicherten Ausgabe des Laufs vom 20. November 2026 gerendert.

Dieses Lab nachbauen#

Für dieses Lab brauchen Sie Linux auf amd64, curl, jq und Python 3.13. Planen Sie etwa 20 Minuten ein. Ö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. No secrets are involved.
export OPA_VERSION="1.22.4"
export OPA_URL="http://localhost:8181"
export PDP_URL="http://localhost:8282"
Schritt 1OPA herunterladen

Ziel. Laden Sie die einzelne statische OPA-Binärdatei in einer festen Version herunter und geben Sie die Version aus.

Voraussetzungen

  • Linux auf amd64 (für macOS oder arm64 nehmen Sie die passende Datei von der Release-Seite), curl, jq und Python 3.13
  • Ports 8181 und 8282 frei
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

Erwartete Ausgabe

Ausgabe
Version: 1.22.4
Schritt 2Die Policy schreiben

Ziel. Legen Sie die Rego-Policy an: einen Tool-Katalog, den Standardwert false, zwei Entscheidungsregeln und eine Menge von Ablehnungsgründen.

Voraussetzungen

  • Schritt 1 erledigt, im selben Ordner
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

Erwartete Ausgabe

Ausgabe
# 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
Schritt 3Die Tests schreiben und ausführen

Ziel. Schreiben Sie sechs Unit-Tests und führen Sie dann Formatter, Strict-Check und Test-Runner aus. Alles sollte bestehen.

Voraussetzungen

  • Die Policy-Datei aus dem vorigen Schritt
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

Erwartete Ausgabe

Ausgabe
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
Schritt 4Eine Anfrage offline auswerten

Ziel. Schreiben Sie eine Anfrage in AuthZEN-Form für eine Zahlung von 90 Dollar bei einem Limit von 50 Dollar und werten Sie sie mit opa eval ohne Server aus.

Voraussetzungen

  • Beträge sind in Cent: 9000 sind 90 Dollar und 5000 sind 50 Dollar
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

Erwartete Ausgabe

Ausgabe
false
[
  "over delegated limit"
]
Schritt 5OPA als Server starten und den AuthZEN-Endpunkt hinzufügen

Ziel. Stellen Sie die Policy mit OPA auf Port 8181 bereit, prüfen Sie dessen Entscheidungs-API, starten Sie dann den kleinen Python-Endpunkt auf Port 8282 und lesen Sie sein Metadatendokument.

Voraussetzungen

  • Schritte 2 bis 4 erledigt
  • Der Endpunkt ist ein Lehrbeispiel, kein konformer AuthZEN-PDP; lassen Sie ihn auf 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 .

Erwartete Ausgabe

Ausgabe
{}
{"result":false}
{
  "policy_decision_point": "http://localhost:8282",
  "access_evaluation_endpoint": "http://localhost:8282/access/v1/evaluation"
}
Schritt 6Eine Entscheidung anfordern: 90 Dollar, dann 45

Ziel. Senden Sie die Anfrage an den AuthZEN-Auswertungsendpunkt. Er sollte mit einem Grund ablehnen. Ändern Sie dann nur den Betrag auf 4500 Cent und fragen Sie erneut.

Voraussetzungen

  • OPA und der Endpunkt laufen
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 .

Erwartete Ausgabe

Ausgabe
{
  "decision": false,
  "context": {
    "reason_admin": {
      "403": "over delegated limit"
    }
  }
}
{
  "decision": true
}
Schritt 7Weitere Ablehnungen testen, dann OPA stoppen

Ziel. Senden Sie drei weitere Anfragen: einen fehlenden Scope, eine unbestätigte Zahlung und ein unbekanntes Tool. Stoppen Sie dann OPA und fragen Sie erneut, um zu sehen, dass keine Entscheidung zurückkommt.

Voraussetzungen

  • Der Endpunkt läuft
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

Erwartete Ausgabe

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

Ziel. Stoppen Sie beide Prozesse und löschen Sie die vom Lab erzeugten Dateien.

Voraussetzungen

  • Nichts anderes nutzt die Ports 8181 und 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/"

Erwartete Ausgabe

Ausgabe
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