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

- URL: https://iamops.dev/de/permit-authzen-mcp-tool-call-policy/
- Language: de
- Author: Argo
- Published: 2026-11-22
- Category: Labs
- Depth: Praxis
- Time: 25 Min.
- Topics: Permit.io, AuthZEN, MCP, Autorisierung, KI-Agenten

## Kurz gesagt

- Ich habe das [Lab mit OPA (Open Policy Agent)](https://iamops.dev/de/opa-authzen-mcp-tool-call-policy/) mit Permit.io im Gratis-Plan Community nachgebaut: Ein kleiner [Enforcement Point](https://iamops.dev/de/permit-authzen-mcp-tool-call-policy/#der-enforcement-point) macht aus jedem tools/call des MCP (Model Context Protocol) eine Anfrage über AuthZEN (den Autorisierungsstandard von OpenID) an den Permit Edge PDP (Policy Decision Point).
- Mit [Rollen und einer Regel für ABAC (attributbasierte Zugriffskontrolle)](https://iamops.dev/de/permit-authzen-mcp-tool-call-policy/#die-policy) hat der Edge PDP [die Zahlung über 90 Dollar gegen ein Limit von 50 abgelehnt](https://iamops.dev/de/permit-authzen-mcp-tool-call-policy/#lauf-2-sechs-tool-aufrufe-durch-den-enforcement-point) und 45 Dollar mit Bestätigung erlaubt. Zwei erlaubt, vier abgelehnt, wie bei OPA.
- Ohne Schlüssel im PEP (Policy Enforcement Point) oder mit gestopptem PDP [blieb jeder Aufruf zu](https://iamops.dev/de/permit-authzen-mcp-tool-call-policy/#lauf-3-fail-closed-mit-aktiver-policy). Das Log sagt, ob eine Ablehnung von der Policy oder von einem Fehler kam.
- Der [Cloud PDP wertet kein ABAC aus](https://iamops.dev/de/permit-authzen-mcp-tool-call-policy/#lauf-4-der-cloud-pdp-wertet-kein-abac-aus): Dieselbe Zahlung über 45 Dollar wurde dort abgelehnt. Wählen Sie den PDP nach dem Policy-Modell. Die Modelle stehen in meinem [Explainer zu RBAC (rollenbasierte Zugriffskontrolle), ABAC und ReBAC (beziehungsbasierte Zugriffskontrolle)](https://iamops.dev/de/rbac-abac-rebac-explained/).
- [Vor dem Schlüssel](https://iamops.dev/de/permit-authzen-mcp-tool-call-policy/#vor-dem-schlüssel-was-ein-pdp-ohne-schlüssel-tut) antwortete der PDP mit 401, 403 oder 503 und nie mit einer Entscheidung. Der Abschnitt bleibt, weil er zeigt, wie ein falsch konfigurierter PDP aussieht.

Anfang des Monats habe ich einen [Entscheidungspunkt für MCP-Tool-Aufrufe mit OPA](https://iamops.dev/de/opa-authzen-mcp-tool-call-policy/) gebaut: Ein Agent schlägt einen `tools/call` vor, etwas vor dem MCP-Server fragt eine Policy-Engine, und die Engine antwortet über [AuthZEN](https://iamops.dev/de/authzen-opa-cedar-explained/) 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](https://www.permit.io/blog/announcing-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](https://www.permit.io/blog/six-layers-mcp-gateway), 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](https://docs.permit.io/permit-mcp-gateway/architecture/) 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](https://iamops.dev/de/rbac-abac-rebac-explained/#rebac-fragt-nach-beziehungen)-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.](https://iamops.dev/media/permit-authzen-mcp-tool-call-policy/00-flow.webp)

*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](https://iamops.dev/de/rbac-abac-rebac-explained/#rbac-fragt-nach-der-rolle)) und `payments_writer` ohne einfache Berechtigungen.
- Ein [ABAC](https://iamops.dev/de/rbac-abac-rebac-explained/#abac-fragt-nach-attributen)-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.](https://iamops.dev/media/permit-authzen-mcp-tool-call-policy/permit-console-resource.webp)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

### Schritt 1: Die 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

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

**Erwartete Ausgabe**

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

### Schritt 2: Den 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

`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}'
```

**Erwartete Ausgabe**

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

### Schritt 3: Den 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

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

**Erwartete Ausgabe**

```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"}]
```

### Schritt 4: Sechs 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

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

**Erwartete Ausgabe**

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

### Schritt 5: Den 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

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

**Erwartete Ausgabe**

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

### Schritt 6: Denselben 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

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

**Erwartete Ausgabe**

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

### Schritt 7: Aufrä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

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

**Erwartete Ausgabe**

```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/)
