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

- URL: https://iamops.dev/de/secretless-agent-managed-identity-container-app/
- Language: de
- Author: Argo
- Published: 2026-11-05
- Category: Labs
- Topics: Managed Identity, Entra ID, KI-Agenten, Workload-Identität, Azure

## Kurz gesagt

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

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.](https://iamops.dev/media/secretless-agent-managed-identity-container-app/01-context.webp)

*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.](https://iamops.dev/media/secretless-agent-managed-identity-container-app/03-app-definition.webp)

*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.](https://iamops.dev/media/secretless-agent-managed-identity-container-app/05-secretless.webp)

*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.](https://iamops.dev/media/secretless-agent-managed-identity-container-app/07-refused.webp)

*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.](https://iamops.dev/media/secretless-agent-managed-identity-container-app/10-assign.webp)

*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.](https://iamops.dev/media/secretless-agent-managed-identity-container-app/13-token.webp)

*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.](https://iamops.dev/media/secretless-agent-managed-identity-container-app/15-validate.webp)

*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** `env.sh` (bash)

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

`identity.sh` (bash)

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

```text
{
  "clientId": "<identity-client-id>",
  "name": "agent-lab-mi",
  "principalId": "<identity-principal-id>"
}
0
```

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

`environment.sh` (bash)

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

```text
{
  "logs": null,
  "name": "cae-agent-lab",
  "provisioningState": "Succeeded"
}
```

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

`resource-api.sh` (bash)

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

```text
{
  "appRoleAssignmentRequired": false,
  "appRoles": [],
  "name": "Agent Lab - Resource API"
}
```

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

`agent.py` (python)

```python
# 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@@")
```

`deploy.sh` (bash)

```bash
{
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**

```text
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 5: Zuweisung 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

`refused.sh` (bash)

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

```text
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 6: Eine 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

`grant.sh` (bash)

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

```text
{
  "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 7: Die 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

`validate.py` (python)

```python
# 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"))
```

`validate.sh` (bash)

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

```text
-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 8: Aufrä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

`cleanup.sh` (bash)

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

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


## Sources

- [Microsoft Security Blog, 5 Nov 2026: Threat actors use agentic AI tooling to find and abuse exposed secrets](https://www.microsoft.com/en-us/security/blog/2026/11/05/threat-actors-use-agentic-ai-tooling-to-find-and-abuse-exposed-secrets/)
- [Microsoft Learn: Managed identities in Azure Container Apps](https://learn.microsoft.com/en-us/azure/container-apps/managed-identity)
- [Microsoft Learn: Managed identities for Azure resources](https://learn.microsoft.com/en-us/entra/identity/managed-identities-azure-resources/overview)
- [Microsoft Learn: Restrict your app to a set of users (app role assignment required)](https://learn.microsoft.com/en-us/entra/identity-platform/howto-restrict-your-app-to-a-set-of-users)
- [Microsoft Learn: Azure Container Apps billing](https://azure.microsoft.com/en-us/pricing/details/container-apps/)
