iamops.dev
Argo auf X RSS-Feed
DEDeutsch

Labs Technisch 5 Min. Lesezeit

Ein autonomer KI-Agent ohne Secrets auf Azure: eine API mit Managed Identity aus Container Apps aufrufen

Labor: Ein Container-App-Agent mit Managed Identity und ohne Secrets erhält eine enge App-Rolle, bekommt ein App-only-Token, und die API validiert es.

Zwei Terminalaufnahmen aus meinem Azure-Lab: eine Anfrage der Managed Identity, die vor der Rollenzuweisung abgelehnt wird, und der Agent im Container mit dem Identity-Endpunkt und ohne Secret in der Umgebung.
Kurz gesagtEin autonomer Agent ohne Secret hat nichts, was abfließen kann: eine…
  • Ein autonomer Agent ohne Secret hat nichts, was abfließen kann: eine Container App mit nutzerzugewiesener Managed Identity, ohne Client Secret, Zertifikat und Ingress.
  • Die Identität startet ohne Rollen; ist an der API die Zuweisung vorgeschrieben, wird die Token-Anfrage abgelehnt (AADSTS501051), bis eine enge App-Rolle vergeben ist.
  • Das App-only-Token enthält roles und kein scp, und die API prüft trotzdem Signatur, Audience, Aussteller und Rolle.
  • Tokens werden etwa 24 Stunden gecacht, das Entfernen einer Rolle ist also kein sofortiger Widerruf.
  • Behandle die Identität wie ein privilegiertes Konto: ein Verantwortlicher, ein Überprüfungsdatum und ein Alarm bei Rollenzuweisungen.
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: Ein autonomer KI-Agent ohne Secrets auf Azure: eine API mit Managed Identity aus Container Apps aufrufen
Read the whole lab here (Markdown): https://iamops.dev/de/secretless-agent-managed-identity-container-app.md

What the lab needs before the first step:
- A test tenant and subscription; never use a production one
- Azure CLI 2.60 or newer, jq and uuidgen
- Values I have to set myself (the lab uses placeholders): <TENANT_ID>, <SUBSCRIPTION_ID>, <AZURE_REGION>

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 5. November 2026 beschrieb Microsoft Threat Intelligence Angreifer, die ein agentisches Offensiv-Framework nutzen, um öffentliche Repositories nach offengelegten Secrets zu durchsuchen und mit gültigen Anwendungsanmeldedaten anschließend als Workloads aufzutreten. Die defensive Lesart ist einfach: Ein autonomer Agent ohne Secret hat nichts, was abfließen kann. Ich habe einen solchen Agenten auf Azure gebaut und jede Aussage nachgeprüft.

Was das Labor zeigt#

Ein kleiner Agent läuft als Azure Container App. Er hat keinen Nutzer, kein Client Secret und kein Zertifikat. Seine Identität ist eine nutzerzugewiesene Managed Identity, die ohne Rollen startet. Das Labor:

  1. Verbindet die Identität mit der App und beweist, dass der Container kein Secret enthält.
  2. Lässt die nachgelagerte API (die Resource API, eine App-Registrierung) eine App-Rollen-Zuweisung verlangen.
  3. Zeigt die abgelehnte Token-Anfrage und vergibt dann eine enge App-only-Rolle.
  4. Liest das App-only-Token, das der Agent erhält, und prüft es so, wie es die API täte.

Einrichtung#

Verwenden Sie einen separaten Testmandanten und ein separates Abonnement. Der Agent läuft mit 0,25 vCPU und 0,5 GiB im Verbrauchstarif, ohne Ingress und ohne Log-Analytics-Arbeitsbereich. Die ersten 180.000 vCPU-Sekunden pro Monat sind kostenlos; diese Größe verbraucht sie in rund 200 Betriebsstunden. Löschen Sie die App also, wenn Sie fertig sind. Die Managed Identity und die App-Rolle sind kostenlos.

Terminalausgabe: Die Azure CLI zeigt Abonnement und Mandant, die Managed Identity mit Client-ID und Principal-ID und null Rollenzuweisungen. Kennungen sind Platzhalter.
Bei null beginnen. Die Managed Identity hat keine Rollenzuweisungen, daher ist jede Berechtigung im Labor eine bewusste, sichtbare Vergabe. Kennungen sind Platzhalter.

Die App ist in YAML definiert. Das Image ist ein öffentliches, nur wegen seines Python genutzt, sodass keine Registry-Anmeldedaten nötig sind. Der Identity-Block verbindet die Managed Identity. Es gibt keinen ingress-Abschnitt, also kann niemand von außen aufrufen.

Terminalausgabe der App-Definition: Standort, ein nutzerzugewiesener Identity-Block, die Umgebungs-ID, ein öffentliches Container-Image, Ressourcen von 0,25 vCPU und 0,5 GiB und die Client-ID als Umgebungsvariable. IDs sind Platzhalter.
Nichts zu stehlen. Alles, was ein Angreifer dieser Definition entnehmen könnte, ist öffentlich: ein Image-Name, eine Client-ID und der Code. Abonnement- und Client-IDs sind Platzhalter.

Der Ablauf#

Der Container hält einen Identitätsendpunkt, kein Secret. Die Plattform injiziert IDENTITY_ENDPOINT, eine localhost-URL, und IDENTITY_HEADER, einen Wert pro Container (in der Ausgabe maskiert). Keine andere Variable sieht nach einem Secret aus, und es ist kein Secret-Volume eingebunden.

Terminalausgabe aus dem Container: der Identitätsendpunkt auf localhost, der maskierte Identity-Header, die öffentliche Client-ID und keine Variablen namens secret, password, key oder certificate sowie keine eingebundenen Secret-Volumes.
Im Container. Der Header ist keine Anmeldeinformation für Entra. Er beweist dem lokalen Endpunkt nur, dass der Aufrufer in diesem Container sitzt, was SSRF-Tricks blockiert.

Zuweisung an der API verlangen. Standardmäßig stellt Entra jedem Service Principal im Mandanten, der fragt, ein App-only-Token mit leerem roles-Claim aus. Setzt man appRoleAssignmentRequired am Service Principal der Resource API auf true, verweigert Entra jedem, der nicht zugewiesen ist, das Token:

bash
az ad sp update --id <resource-sp-id> --set appRoleAssignmentRequired=true

Zwei Negativtests. Die Anfrage des Agenten nach einem Token für die Resource API wird vom Token-Dienst mit AADSTS501051 abgelehnt, und ein Graph-Token (Graph verlangt keine Zuweisung) enthält keine Rollen, sodass GET /v1.0/users mit 403 antwortet.

Terminalausgabe zweier Ablehnungen: HTTP 400 mit AADSTS501051, die Managed Identity sei keiner Rolle für die Resource API zugewiesen, und HTTP 403 Authorization_RequestDenied von Graph. IDs sind Platzhalter.
Zweimal abgelehnt. Die Ablehnung erfolgt, bevor die API aufgerufen wird, und nennt die Managed Identity, was sie bei einer Prüfung oder einem Vorfall leicht auffindbar macht. „Ein Token haben“ heißt nicht „Zugriff haben“.

Eine enge Vergabe. Fügen Sie der Resource API eine reine App-only-Rolle Data.Read.All hinzu (erlaubter Mitgliedstyp: Anwendung) und weisen Sie sie der Managed Identity über Microsoft Graph zu. Das Admin Center kann einer Managed Identity keine App-Rolle zuweisen; das läuft über Graph, PowerShell oder die CLI.

Terminalausgabe zweier Graph-Aufrufe: Hinzufügen der App-Rolle Data.Read.All zur Resource API und Zuweisung an den Service Principal der Managed Identity. Objekt-IDs sind Platzhalter.
Die einzige Vergabe im Labor. Sie ist ein gewöhnliches Graph-Objekt, das ein Governance-Werkzeug oder ein Skript lesen kann.

Das App-only-Token. Entra speichert Tokens von Managed Identities im Cache, der Container erhält also bis zu einen Tag lang weiter sein altes Token. Ein Neustart der Revision liefert ein frisches, das nun die Rolle enthält.

Dekodierte Claims des App-only-Tokens nach einem Neustart der Revision: Die Audience ist die Resource API, Anwendung und Objekt-ID sind die Managed Identity, idtyp ist app, roles enthält Data.Read.All und es gibt keinen scope-Claim. Kennungen sind Platzhalter.
App-only-Token. Ein roles-Claim ohne scp ist, wie eine API einen App-only-Aufruf von einem delegierten unterscheidet. Es gibt keinen Nutzer; die eigenen Berechtigungen der Identität sind die einzige Grenze.

Die API spielen. Das Token wandert vom Container in eine temporäre Datei mit Modus 0600 und wird am Ende vernichtet; es wird nie ausgegeben. Ein Validierungsskript prüft die RS256-Signatur gegen die Schlüssel des Mandanten, die Audience, den Aussteller und das Ablaufdatum und autorisiert dann jede Route anhand der Rolle.

Terminalausgabe der API-seitigen Prüfung: GET data liefert 200 für die Rolle Data.Read.All, POST data liefert 403 wegen der fehlenden Rolle Data.Write.All, und ein Token mit bearbeiteten Rollen liefert 401, weil die Signaturprüfung fehlschlägt.
Die API entscheidet trotzdem. Lesen ist erlaubt, Schreiben wird abgelehnt, und ein Token mit manipulierten Claims besteht die Signaturprüfung nicht.

Stolperfallen#

  • Tokens werden etwa 24 Stunden gecacht. Die Rolle zu entfernen genügt für einen dringenden Widerruf nicht. Starten Sie den Workload neu oder stellen Sie ihn neu bereit, oder deaktivieren Sie die Identität.
  • exec hat ein Ratenlimit. Ohne --replica kann az containerapp exec ein gestopptes Replikat wählen, und Wiederholungen laufen in HTTP 429 mit zehn Minuten Wartezeit. Geben Sie das laufende Replikat an.
  • „Assignment required“ ist ein Schalter, den man setzen muss. Ohne ihn sind „ein Token bekommen können“ und „autorisiert sein“ verschiedene Dinge, und jede API muss die Rollen selbst prüfen.
  • Kostenlose Mandanten protokollieren weniger. Das Verzeichnis-Auditlog zeigt die Vergabe. Anmeldeprotokolle für Managed Identities brauchen Entra ID P1 oder P2 und sollten in Ihr SIEM exportiert werden.
  • Löschen Sie die Rechenressource, wenn Sie fertig sind. Rechenleistung kostet Geld; Identität und Rolle tragen das Risiko und brauchen einen Verantwortlichen und ein Überprüfungsdatum wie jedes andere privilegierte Konto.

Sicherheitserkenntnisse#

  1. Ein Workload ohne Secret hat nichts, was abfließen kann. Bevorzugen Sie Managed Identities oder föderierte Anmeldeinformationen gegenüber Client Secrets.
  2. Beginnen Sie ohne Rollen und fügen Sie eine Rolle im engsten Geltungsbereich hinzu. Benennen Sie App-only-Rollen *.All, damit Prüfer sehen, dass keine Nutzergrenze gilt.
  3. Verlangen Sie die Zuweisung bei internen APIs, damit der Token-Dienst das erste Tor ist.
  4. Validieren Sie Signatur, Audience, Aussteller und Rolle in der API. Entra entscheidet nur, wer ein Token bekommt.
  5. Behandeln Sie Managed Identities mit App-Rollen wie privilegierte nicht-menschliche Konten: Verantwortlicher, Rezertifizierung, ein Alarm bei Rollenzuweisungen an Service Principals.

Was nicht ausgeführt wurde#

Das Labor hat weder einen Entra-Agent-ID-Blueprint noch eine Agentenidentität bereitgestellt, bei der ein Managed-Identity-Token die Anmeldeinformation des Blueprints wäre. Die Portal-Tour durch die entstandenen Objekte wurde aufgezeichnet, aber nicht veröffentlicht, weil Portalansichten Mandantenkennungen zeigen. Für dieses Labor wird keine Aufzeichnung veröffentlicht.

Die Terminalbilder wurden aus der gespeicherten Ausgabe des Laufs erzeugt; Kennungen, Geheimnisse und Zeitstempel sind durch Platzhalter ersetzt.

Dieses Lab nachbauen#

Sie brauchen ein Azure-Abonnement in einem Test-Tenant, die Azure CLI und etwa 90 Minuten. Der Agent läuft auf Azure Container Apps mit 0,25 vCPU, die Rechnung bleibt also nahe null, wenn Sie am Ende alles löschen. Ö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. Replace each <PLACEHOLDER> with a value from your own test subscription.
export TENANT_ID='<TENANT_ID>'
export SUBSCRIPTION_ID='<SUBSCRIPTION_ID>'
export LOCATION='<AZURE_REGION>'
export RG='rg-agent-lab'
export IDENTITY='agent-lab-mi'
export ENV_NAME='cae-agent-lab'
export APP_NAME='agent-lab'
export RESOURCE_API_NAME='Agent Lab - Resource API'
Schritt 1Die Identität anlegen und zeigen, dass sie keine Rollen hat

Ziel. Legen Sie eine benutzerzugewiesene Managed Identity an und prüfen Sie, dass sie keine Rollenzuweisung hat. Jede Berechtigung danach ist eine bewusste Vergabe.

Voraussetzungen

  • Ein Test-Tenant und ein Test-Abonnement, nie produktive
  • Azure CLI 2.60 oder neuer, jq und uuidgen
bash · identity.sh
az login --tenant "$TENANT_ID"
az account set --subscription "$SUBSCRIPTION_ID"
az group create -n "$RG" -l "$LOCATION" -o none
az identity create -g "$RG" -n "$IDENTITY" -o none
az identity show -g "$RG" -n "$IDENTITY" --query '{name:name, clientId:clientId, principalId:principalId}' -o json
export IDENTITY_CLIENT_ID=$(az identity show -g "$RG" -n "$IDENTITY" --query clientId -o tsv)
export IDENTITY_PRINCIPAL_ID=$(az identity show -g "$RG" -n "$IDENTITY" --query principalId -o tsv)
export IDENTITY_ID=$(az identity show -g "$RG" -n "$IDENTITY" --query id -o tsv)
az role assignment list --assignee "$IDENTITY_PRINCIPAL_ID" --all -o json | jq length

Erwartete Ausgabe

Ausgabe
{
  "clientId": "<identity-client-id>",
  "name": "agent-lab-mi",
  "principalId": "<identity-principal-id>"
}
0
Schritt 2Die Container-Apps-Umgebung anlegen

Ziel. Legen Sie die Umgebung im Consumption-Plan an, ohne Log-Analytics-Workspace, damit nichts anderes Kosten verursacht.

Voraussetzungen

  • Die Variablen aus env.sh und die Identität aus dem vorigen Schritt
  • Rechte, Ressourcen in der Ressourcengruppe anzulegen
bash · environment.sh
az provider register -n Microsoft.App --wait
az extension add -n containerapp
az containerapp env create -n "$ENV_NAME" -g "$RG" -l "$LOCATION" \
  --enable-workload-profiles false --logs-destination none \
  --query '{name:name, provisioningState:properties.provisioningState, logs:properties.appLogsConfiguration.destination}' -o json
export ENV_ID=$(az containerapp env show -n "$ENV_NAME" -g "$RG" --query id -o tsv)

Erwartete Ausgabe

Ausgabe
{
  "logs": null,
  "name": "cae-agent-lab",
  "provisioningState": "Succeeded"
}
Schritt 3Die Resource-API registrieren

Ziel. Legen Sie die nachgelagerte API als App-Registrierung mit Service Principal an. Noch gibt ihr nichts Zugriff.

Voraussetzungen

  • Recht, App-Registrierungen im Test-Tenant anzulegen
bash · resource-api.sh
export RESOURCE_APP_ID=$(az ad app create --display-name "$RESOURCE_API_NAME" --sign-in-audience AzureADMyOrg --query appId -o tsv)
az ad app update --id "$RESOURCE_APP_ID" --identifier-uris "api://$RESOURCE_APP_ID"
az ad sp create --id "$RESOURCE_APP_ID" -o none
export RESOURCE_APP_OBJECT_ID=$(az ad app show --id "$RESOURCE_APP_ID" --query id -o tsv)
export RESOURCE_SP_ID=$(az ad sp show --id "$RESOURCE_APP_ID" --query id -o tsv)
az ad sp show --id "$RESOURCE_APP_ID" --query '{name:displayName, appRoleAssignmentRequired:appRoleAssignmentRequired, appRoles:appRoles}' -o json

Erwartete Ausgabe

Ausgabe
{
  "appRoleAssignmentRequired": false,
  "appRoles": [],
  "name": "Agent Lab - Resource API"
}
Schritt 4Den Agenten ohne Secret bereitstellen

Ziel. Starten Sie einen kleinen Python-Agenten als Container App mit angehängter Identität, ohne Ingress und ohne Secrets, und sehen Sie sich an, was der Container wirklich enthält.

Voraussetzungen

  • Die Umgebung und die Identität aus den vorigen Schritten
  • Das Image ist öffentlich und dient nur wegen Python, es braucht also keine Registry-Zugangsdaten
python · agent.py
# Minimal autonomous agent: no user, no secret. Uses the managed identity endpoint of Azure Container Apps.
import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
UAMI = os.environ["AZURE_CLIENT_ID"]          # client ID of agent-lab-mi (not a secret)

def token(resource):
    q = urllib.parse.urlencode({"resource": resource, "api-version": "2019-08-01", "client_id": UAMI})
    req = urllib.request.Request(os.environ["IDENTITY_ENDPOINT"] + "?" + q,
                                 headers={"X-IDENTITY-HEADER": os.environ["IDENTITY_HEADER"]})
    try:
        return json.load(urllib.request.urlopen(req, timeout=30)), None
    except urllib.error.HTTPError as e:
        return None, (e.code, e.read().decode())

def claims(jwt):
    p = jwt.split(".")[1]; return json.loads(base64.urlsafe_b64decode(p + "=" * (-len(p) % 4)))

cmd = sys.argv[1]
if cmd == "env":
    h = os.environ.get("IDENTITY_HEADER", "")
    print("IDENTITY_ENDPOINT =", os.environ.get("IDENTITY_ENDPOINT"))
    print("IDENTITY_HEADER   =", f"[set, {len(h)} chars, value masked]" if h else None)
    print("AZURE_CLIENT_ID   =", UAMI, "(public client ID of the UAMI)")
    for k in sorted(k for k in os.environ if k.startswith("MSI_")):
        same = os.environ[k] == h
        print(f"{k:<18}=", "[same value as IDENTITY_HEADER: legacy alias, masked]" if same else os.environ[k])
    hits = [k for k in os.environ if any(w in k.upper() for w in ("SECRET", "PASSWORD", "KEY", "CERT"))
            and os.environ[k] != h]
    print("other env vars named *SECRET*/*PASSWORD*/*KEY*/*CERT*:", hits or "none")
    print("mounted secret volumes (/var/run/secrets, /mnt/secrets):", [p for p in ("/var/run/secrets", "/mnt/secrets") if os.path.exists(p)] or "none")
elif cmd == "token":                       # agent.py token <resource>  -> prints decoded claims only, never the token
    t, err = token(sys.argv[2])
    if err:
        print("HTTP", err[0]); print(err[1][:600]); sys.exit(1)
    c = claims(t["access_token"])
    keep = ["aud", "iss", "appid", "azp", "oid", "sub", "idtyp", "roles", "scp", "xms_mirid", "tid", "iat", "exp"]
    print(json.dumps({k: c.get(k, "(absent)") for k in keep}, indent=1))
    print("token_type", t.get("token_type"), "· expires_on", t.get("expires_on"), "· access_token: [not printed]")
elif cmd == "graph-users":                 # app-only call to Microsoft Graph with no Graph permission
    t, err = token("https://graph.microsoft.com")
    if err: print("HTTP", err[0], err[1][:400]); sys.exit(1)
    print("Graph token roles:", claims(t["access_token"]).get("roles", "(none)"))
    req = urllib.request.Request("https://graph.microsoft.com/v1.0/users?$top=1&$select=displayName",
                                 headers={"Authorization": "Bearer " + t["access_token"]})
    try:
        r = urllib.request.urlopen(req, timeout=30); print("HTTP", r.status, r.read()[:200])
    except urllib.error.HTTPError as e:
        b = json.loads(e.read()); b["error"].pop("innerError", None); print("HTTP", e.code, json.dumps(b))
elif cmd == "handoff":                     # lab only: emit the raw token for the box-side validator, never displayed
    t, err = token(sys.argv[2]); print("@@TOKEN@@" + t["access_token"] + "@@END@@")
bash · deploy.sh
{
cat <<EOF
location: $LOCATION
identity:
  type: UserAssigned
  userAssignedIdentities:
    $IDENTITY_ID: {}
properties:
  managedEnvironmentId: $ENV_ID
  configuration:
    activeRevisionsMode: Single
  template:
    containers:
      - name: agent
        image: mcr.microsoft.com/azure-cli:latest
        resources: {cpu: 0.25, memory: 0.5Gi}
        command: ["/bin/sh", "-c"]
        args: ["printf '%s' \"\$AGENT_PY\" > /tmp/agent.py && echo agent ready && sleep infinity"]
        env:
          - name: AZURE_CLIENT_ID
            value: $IDENTITY_CLIENT_ID
          - name: AGENT_PY
            value: |
EOF
sed 's/^/              /' agent.py
echo '    scale: {minReplicas: 1, maxReplicas: 1}'
} > app.yaml
az containerapp create -n "$APP_NAME" -g "$RG" --yaml app.yaml -o none
export REPLICA=$(az containerapp replica list -n "$APP_NAME" -g "$RG" --query '[0].name' -o tsv)
az containerapp exec -n "$APP_NAME" -g "$RG" --replica "$REPLICA" --command "python3 /tmp/agent.py env"

Erwartete Ausgabe

Ausgabe
IDENTITY_ENDPOINT = http://localhost:12356/msi/token
IDENTITY_HEADER   = [set, 36 chars, value masked]
AZURE_CLIENT_ID   = <identity-client-id> (public client ID of the UAMI)
MSI_ENDPOINT      = http://localhost:12356/msi/token
MSI_SECRET        = [same value as IDENTITY_HEADER: legacy alias, masked]
other env vars named *SECRET*/*PASSWORD*/*KEY*/*CERT*: none
mounted secret volumes (/var/run/secrets, /mnt/secrets): none
Schritt 5Zuweisung erzwingen und die Token-Anfrage scheitern sehen

Ziel. Aktivieren Sie die Pflichtzuweisung für die Resource-API und fordern Sie dann aus dem Container ein Token an. Entra lehnt ab, und Graph lehnt einen Aufruf ab, der eine Berechtigung braucht.

Voraussetzungen

  • Der Agent läuft (REPLICA ist gesetzt)
  • Pinnen Sie das Replikat: ohne --replica kann exec ein gestopptes wählen und in ein Ratelimit laufen
bash · refused.sh
az ad sp update --id "$RESOURCE_SP_ID" --set appRoleAssignmentRequired=true
az containerapp exec -n "$APP_NAME" -g "$RG" --replica "$REPLICA" \
  --command "python3 /tmp/agent.py token api://$RESOURCE_APP_ID"
az containerapp exec -n "$APP_NAME" -g "$RG" --replica "$REPLICA" --command "python3 /tmp/agent.py graph-users"

Erwartete Ausgabe

Ausgabe
HTTP 400
{"exceptionMessage":"AADSTS501051: Application '<identity-client-id>' (agent-lab-mi) is not assigned to a role for the application 'api://<resource-api-id>' (Agent Lab - Resource API). Trace ID: <trace-id> Correlation ID: <correlation-id> Timestamp: <timestamp>"}
Graph token roles: (none)
HTTP 403 {"error": {"code": "Authorization_RequestDenied", "message": "Insufficient privileges to complete the operation."}}
Schritt 6Eine einzelne enge App-Rolle vergeben und das Token lesen

Ziel. Fügen Sie der Resource-API eine reine Anwendungsrolle Data.Read.All hinzu und weisen Sie sie der Managed Identity über Microsoft Graph zu. Lesen Sie dann das App-only-Token, das der Agent bekommt.

Voraussetzungen

  • Das Portal kann einer Managed Identity keine App-Rolle zuweisen, deshalb geht es über az rest
  • Rechte, App-Rollen-Zuweisungen im Tenant zu verwalten
bash · grant.sh
export ROLE_ID=$(uuidgen)
az rest -m PATCH -u "https://graph.microsoft.com/v1.0/applications/$RESOURCE_APP_OBJECT_ID" \
  --headers Content-Type=application/json \
  --body "{\"appRoles\":[{\"id\":\"$ROLE_ID\",\"allowedMemberTypes\":[\"Application\"],\"value\":\"Data.Read.All\",\"displayName\":\"Read all lab data (app-only)\",\"isEnabled\":true}]}"
az rest -m POST -u "https://graph.microsoft.com/v1.0/servicePrincipals/$IDENTITY_PRINCIPAL_ID/appRoleAssignments" \
  --body "{\"principalId\":\"$IDENTITY_PRINCIPAL_ID\",\"resourceId\":\"$RESOURCE_SP_ID\",\"appRoleId\":\"$ROLE_ID\"}" \
  --query '{appRoleId:appRoleId, principal:principalDisplayName, principalType:principalType, resource:resourceDisplayName}'
# Entra caches managed identity tokens for up to a day: restart the revision to get a fresh one
REVISION=$(az containerapp revision list -n "$APP_NAME" -g "$RG" --query '[0].name' -o tsv)
az containerapp revision restart -n "$APP_NAME" -g "$RG" --revision "$REVISION"
export REPLICA=$(az containerapp replica list -n "$APP_NAME" -g "$RG" --query '[0].name' -o tsv)
az containerapp exec -n "$APP_NAME" -g "$RG" --replica "$REPLICA" \
  --command "python3 /tmp/agent.py token api://$RESOURCE_APP_ID"

Erwartete Ausgabe

Ausgabe
{
  "appRoleId": "<role-id>",
  "principal": "agent-lab-mi",
  "principalType": "ServicePrincipal",
  "resource": "Agent Lab - Resource API"
}
"Restart succeeded"
{
 "aud": "api://<resource-api-id>",
 "iss": "https://sts.windows.net/<tenant-id>/",
 "appid": "<identity-client-id>",
 "azp": "(absent)",
 "oid": "<identity-principal-id>",
 "sub": "<identity-principal-id>",
 "idtyp": "app",
 "roles": ["Data.Read.All"],
 "scp": "(absent)",
 "tid": "<tenant-id>"
}
token_type Bearer · expires_on <timestamp> · access_token: [not printed]
Schritt 7Die API spielen: Token validieren und per Rolle autorisieren

Ziel. Prüfen Sie Signatur, Audience, Issuer und Ablauf so, wie es die API täte, und autorisieren Sie dann jede Route per Rolle. Ein Token mit geänderten Rollen muss scheitern.

Voraussetzungen

  • Python 3 mit pip, um PyJWT und cryptography zu installieren
  • Das Token läuft über eine 0600-Temp-Datei und wird nie ausgegeben
python · validate.py
# Local stand-in for the Resource API: validate an app-only Entra token and authorize by app role.
import base64, json, os, sys
import jwt   # PyJWT
TENANT = os.environ["TENANT_ID"]
AUD = "api://" + os.environ["RESOURCE_APP_ID"]
ISS = f"https://sts.windows.net/{TENANT}/"               # v1 access tokens (requestedAccessTokenVersion = null)
JWKS = jwt.PyJWKClient(f"https://login.microsoftonline.com/{TENANT}/discovery/v2.0/keys")

def check(tok, required_role):
    try:
        key = JWKS.get_signing_key_from_jwt(tok).key
        c = jwt.decode(tok, key, algorithms=["RS256"], audience=AUD, issuer=ISS)
    except Exception as e:
        return f"401 invalid token ({type(e).__name__}: {e})"
    if c.get("idtyp") != "app" or "scp" in c:
        return "403 app-only endpoint: delegated token rejected"
    if required_role not in c.get("roles", []):
        return f"403 missing app role {required_role} (token roles: {c.get('roles', [])})"
    return f"200 allow: oid {c['oid']} (managed identity) has {required_role}"

tok = open(sys.argv[1]).read().strip()
h = jwt.get_unverified_header(tok)
print("header:", {k: h[k] for k in ("alg", "typ") if k in h}, "· kid from tenant JWKS")
print("GET /data   (requires Data.Read.All)  ->", check(tok, "Data.Read.All"))
print("POST /data  (requires Data.Write.All) ->", check(tok, "Data.Write.All"))
hd, pl, sg = tok.split(".")
c = json.loads(base64.urlsafe_b64decode(pl + "=" * (-len(pl) % 4))); c["roles"] = ["Data.Read.All", "Data.Write.All"]
forged = hd + "." + base64.urlsafe_b64encode(json.dumps(c).encode()).decode().rstrip("=") + "." + sg
print("POST /data with roles edited in the payload ->", check(forged, "Data.Write.All"))
bash · validate.sh
python3 -m venv .venv && . .venv/bin/activate && pip install pyjwt cryptography
umask 077; T=$(mktemp /tmp/mi-token.XXXXXX)   # 0600 temp file, shredded at the end of the step
az containerapp exec -n "$APP_NAME" -g "$RG" --replica "$REPLICA" --command "python3 /tmp/agent.py handoff api://$RESOURCE_APP_ID" \
  | sed -n 's/.*@@TOKEN@@\(.*\)@@END@@.*/\1/p' > "$T"
stat -c '%A %s bytes (content never printed)' "$T"
python3 validate.py "$T"
shred -u "$T"

Erwartete Ausgabe

Ausgabe
-rw------- 1481 bytes (content never printed)
header: {'alg': 'RS256', 'typ': 'JWT'} · kid from tenant JWKS
GET /data   (requires Data.Read.All)  -> 200 allow: oid <identity-principal-id> (managed identity) has Data.Read.All
POST /data  (requires Data.Write.All) -> 403 missing app role Data.Write.All (token roles: ['Data.Read.All'])
POST /data with roles edited in the payload -> 401 invalid token (InvalidSignatureError: Signature verification failed)
Schritt 8Aufräumen

Ziel. Löschen Sie App, Umgebung, Resource-API-Registrierung und Ressourcengruppe und entfernen Sie die lokalen Dateien.

Voraussetzungen

  • Rechenleistung kostet Geld, überspringe diesen Schritt also nicht
bash · cleanup.sh
az containerapp delete -n "$APP_NAME" -g "$RG" -y -o none && echo app-deleted
az containerapp env delete -n "$ENV_NAME" -g "$RG" -y -o none && echo env-deleted   # can take around 20 minutes
az ad app delete --id "$RESOURCE_APP_ID" && echo resource-api-deleted
az group delete -n "$RG" -y --no-wait && echo group-delete-started
rm -f app.yaml agent.py validate.py
az resource list -g "$RG" -o table

Erwartete Ausgabe

Ausgabe
app-deleted
env-deleted
resource-api-deleted
group-delete-started
# then a table of whatever is still being deleted (empty once the group is gone)

Quellen#

Diesen Beitrag diskutieren#

Hat es dir geholfen? Teile es und sag mir, was du denkst.

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