iamops.dev
Argo sur X Flux RSS
FRFrançais

Labs Technique 6 min de lecture

Un agent d'IA autonome sans secret sur Azure : appeler une API avec une identité managée depuis Container Apps

Lab : un agent Container Apps avec identité managée et sans secret reçoit un seul rôle étroit, obtient un jeton app-only et l'API le valide.

Deux captures du terminal de mon lab Azure : une requête de l'identité managée refusée avant l'attribution du rôle et l'agent dans le conteneur montrant le point d'accès d'identité, sans aucun secret dans l'environnement.
En brefUn agent autonome qui ne détient aucun secret n'a rien à laisser fuiter…
  • Un agent autonome qui ne détient aucun secret n'a rien à laisser fuiter : une Container App avec identité managée affectée à l'utilisateur, sans secret client, ni certificat, ni ingress.
  • L'identité démarre sans rôle ; avec l'attribution obligatoire sur l'API, la demande de jeton est refusée (AADSTS501051) tant qu'un seul rôle étroit n'est pas accordé.
  • Le jeton app-only contient roles et pas scp, et l'API valide quand même signature, audience, émetteur et rôle.
  • Les jetons sont mis en cache environ 24 heures : retirer un rôle n'est donc pas une révocation immédiate.
  • Traitez l'identité comme un compte privilégié : un responsable, une date de revue et une alerte sur les attributions de rôles.
Refaire ce lab 8 étapes

J’ai écrit ce lab pour que vous puissiez le refaire vous-même. Chaque étape contient les commandes à copier et la sortie que j’ai obtenue, et vous pouvez la cocher une fois faite. Les coches restent uniquement dans ce navigateur.

Aller aux étapes

Comment ça marche

Copie un prompt prêt à l’emploi pour Claude Code, Cursor, Codex ou tout autre agent de code. Pour les environnements de test uniquement.

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

Lab: Un agent d'IA autonome sans secret sur Azure : appeler une API avec une identité managée depuis Container Apps
Read the whole lab here (Markdown): https://iamops.dev/fr/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.

Le 5 novembre 2026, Microsoft Threat Intelligence a décrit des attaquants qui utilisent un framework offensif à base d’agents pour chercher des secrets exposés dans des dépôts publics, puis se connectent comme des charges de travail avec des identifiants d’application valides. La lecture défensive est simple : un agent autonome qui ne détient aucun secret n’a rien à laisser fuiter. J’en ai construit un sur Azure et j’ai vérifié chaque affirmation.

Ce que montre le laboratoire#

Un petit agent s’exécute comme Azure Container App. Il n’a ni utilisateur, ni secret client, ni certificat. Son identité est une identité managée affectée à l’utilisateur qui démarre sans aucun rôle. Le laboratoire :

  1. Attache l’identité à l’application et prouve que le conteneur ne détient aucun secret.
  2. Fait exiger par l’API en aval (la Resource API, une inscription d’application) une attribution de rôle d’application.
  3. Montre la demande de jeton refusée, puis accorde un seul rôle app-only étroit.
  4. Lit le jeton app-only que l’agent obtient et le vérifie comme le ferait l’API.

Mise en place#

Utilisez un tenant et un abonnement de test séparés. L’agent tourne à 0,25 vCPU et 0,5 GiB sur le plan Consommation, sans ingress et sans espace de travail Log Analytics. Les 180 000 premières vCPU-secondes par mois sont gratuites, ce que cette taille épuise en environ 200 heures d’exécution : supprimez donc l’application quand vous avez fini. L’identité managée et le rôle d’application sont gratuits.

Sortie du terminal : l'Azure CLI affiche l'abonnement et le tenant, l'identité managée avec son ID de client et son ID de principal, et zéro attribution de rôle. Les identifiants sont des espaces réservés.
Partir de zéro. L'identité managée n'a aucune attribution de rôle ; chaque autorisation du laboratoire est donc une concession délibérée et visible. Les identifiants sont des espaces réservés.

L’application est définie en YAML. L’image est publique et ne sert que pour son Python, donc aucun identifiant de registre n’est nécessaire. Le bloc identity attache l’identité managée. Il n’y a pas de section ingress : personne ne peut appeler de l’extérieur.

Sortie du terminal de la définition de l'application : emplacement, bloc identity affecté à l'utilisateur, ID de l'environnement, image publique de conteneur, ressources de 0,25 vCPU et 0,5 GiB et ID de client en variable d'environnement. Les ID sont des espaces réservés.
Rien à voler. Tout ce qu'un attaquant pourrait tirer de cette définition est public : un nom d'image, un ID de client et le code. Les ID d'abonnement et de client sont des espaces réservés.

Le déroulement#

Le conteneur détient un point de terminaison d’identité, pas un secret. La plateforme injecte IDENTITY_ENDPOINT, une URL localhost, et IDENTITY_HEADER, une valeur propre au conteneur (masquée dans la sortie). Aucune autre variable ne ressemble à un secret et aucun volume de secrets n’est monté.

Sortie du terminal depuis l'intérieur du conteneur : le point de terminaison d'identité sur localhost, l'en-tête d'identité masqué, l'ID de client public et aucune variable nommée secret, password, key ou certificate, ni volume de secrets monté.
Dans le conteneur. L'en-tête n'est pas un identifiant pour Entra. Il prouve seulement au point de terminaison local que l'appelant se trouve dans ce conteneur, ce qui bloque les astuces SSRF.

Exiger l’attribution sur l’API. Par défaut, Entra délivre un jeton app-only à tout service principal du tenant qui le demande, avec un claim roles vide. Mettre appRoleAssignmentRequired à true sur le service principal de la Resource API fait refuser le jeton à quiconque n’est pas attribué :

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

Deux tests négatifs. La demande de jeton de l’agent pour la Resource API est refusée par le service de jetons avec AADSTS501051, et un jeton pour Graph (Graph n’exige pas d’attribution) ne contient aucun rôle, si bien que GET /v1.0/users renvoie 403.

Sortie du terminal de deux refus : HTTP 400 avec AADSTS501051 indiquant que l'identité managée n'est attribuée à aucun rôle pour la Resource API, et HTTP 403 Authorization_RequestDenied de Graph. Les ID sont des espaces réservés.
Refusé deux fois. Le refus intervient avant l'appel de l'API et nomme l'identité managée, ce qui le rend facile à repérer lors d'une revue ou d'un incident. « Avoir un jeton » ne signifie pas « avoir l'accès ».

Une concession étroite. Ajoutez à la Resource API un rôle d’application app-only Data.Read.All (type de membre autorisé : application) et attribuez-le à l’identité managée via Microsoft Graph. Le centre d’administration ne peut pas attribuer un rôle d’application à une identité managée ; il faut passer par Graph, PowerShell ou la CLI.

Sortie du terminal de deux appels Graph : ajout du rôle d'application Data.Read.All à la Resource API et attribution au service principal de l'identité managée. Les ID d'objet sont des espaces réservés.
La seule concession du laboratoire. C'est un objet Graph ordinaire qu'un outil de gouvernance ou un script peut lire.

Le jeton app-only. Entra met en cache les jetons des identités managées ; le conteneur continue donc de recevoir son ancien jeton jusqu’à un jour. Redémarrer la révision en fournit un nouveau, qui contient désormais le rôle.

Claims décodés du jeton app-only après le redémarrage de la révision : l'audience est la Resource API, l'application et l'ID d'objet sont l'identité managée, idtyp vaut app, roles contient Data.Read.All et il n'y a pas de claim scope. Les identifiants sont des espaces réservés.
Jeton app-only. Un claim roles sans scp est la façon dont une API distingue un appel app-only d'un appel délégué. Il n'y a pas d'utilisateur ; les droits de l'identité elle-même sont la seule limite.

Jouer le rôle de l’API. Le jeton passe du conteneur à un fichier temporaire en mode 0600 et est détruit à la fin ; il n’est jamais affiché. Un script de validation vérifie la signature RS256 avec les clés du tenant, l’audience, l’émetteur et l’expiration, puis autorise chaque route d’après le rôle.

Sortie du terminal du contrôle côté API : GET data renvoie 200 pour le rôle Data.Read.All, POST data renvoie 403 faute du rôle Data.Write.All et un jeton aux rôles modifiés renvoie 401 car la vérification de signature échoue.
L'API décide quand même. La lecture est autorisée, l'écriture refusée, et un jeton aux claims modifiés échoue à la vérification de signature.

Pièges#

  • Les jetons sont mis en cache environ 24 heures. Retirer le rôle ne suffit pas pour une révocation urgente. Redémarrez ou redéployez la charge de travail, ou désactivez l’identité.
  • exec a une limite de débit. Sans --replica, az containerapp exec peut choisir une réplique arrêtée, et les nouvelles tentatives se heurtent à HTTP 429 avec dix minutes d’attente. Désignez la réplique en cours d’exécution.
  • « Assignment required » est un interrupteur à activer. Sans lui, « pouvoir obtenir un jeton » et « être autorisé » sont deux choses différentes, et chaque API doit vérifier les rôles elle-même.
  • Les tenants gratuits journalisent moins. Le journal d’audit de l’annuaire montre la concession. Les journaux de connexion des identités managées exigent Entra ID P1 ou P2 et doivent être exportés vers votre SIEM.
  • Supprimez le calcul quand vous avez fini. Le calcul coûte de l’argent ; l’identité et le rôle portent le risque et ont besoin d’un responsable et d’une date de revue comme tout autre compte privilégié.

Enseignements de sécurité#

  1. Une charge de travail sans secret n’a rien à laisser fuiter. Préférez les identités managées ou les identifiants fédérés aux secrets clients.
  2. Partez sans rôle et ajoutez un rôle à l’étendue la plus étroite. Nommez les rôles app-only *.All pour que les relecteurs voient qu’il n’y a pas de limite utilisateur.
  3. Exigez l’attribution sur les API internes pour que le service de jetons soit la première barrière.
  4. Validez signature, audience, émetteur et rôle dans l’API. Entra ne décide que de qui obtient un jeton.
  5. Traitez les identités managées qui détiennent des rôles d’application comme des comptes non humains privilégiés : responsable, recertification, une alerte sur les attributions de rôles aux service principals.

Ce qui n’a pas été exécuté#

Le laboratoire n’a déployé ni blueprint ni identité d’agent Entra Agent ID, où un jeton d’identité managée serait l’identifiant du blueprint. La visite du portail sur les objets obtenus a été enregistrée mais n’est pas publiée, car les vues du portail montrent des identifiants de tenant. Aucun enregistrement n’est publié pour ce laboratoire.

Les images du terminal ont été générées à partir de la sortie enregistrée de l’exécution, avec identifiants, secrets et horodatages remplacés par des espaces réservés.

Refaire ce lab#

Il faut un abonnement Azure dans un tenant de test, l'Azure CLI et environ 90 minutes. L'agent tourne sur Azure Container Apps avec 0,25 vCPU, la facture reste donc proche de zéro si vous tout supprimez à la fin. Ouvrez chaque étape, copiez les blocs et comparez la sortie avec la mienne.

Chaque valeur entre chevrons est un espace réservé pour votre environnement de test. Rien sur cette page n’est un identifiant ou un secret réel.

Définissez vos variables une seule fois

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'
Étape 1Créer l'identité et prouver qu'elle n'a aucun rôle

Objectif. Créez une identité managée affectée à l'utilisateur et vérifiez qu'elle n'a aucune attribution de rôle. Chaque permission ensuite est une attribution délibérée.

Prérequis

  • Un tenant et un abonnement de test, jamais de production
  • Azure CLI 2.60 ou plus récente, jq et 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

Résultat attendu

résultat
{
  "clientId": "<identity-client-id>",
  "name": "agent-lab-mi",
  "principalId": "<identity-principal-id>"
}
0
Étape 2Créer l'environnement Container Apps

Objectif. Créez l'environnement sur le plan Consumption, sans workspace Log Analytics, pour que rien d'autre ne soit facturé.

Prérequis

  • Les variables de env.sh et l'identité de l'étape précédente
  • Droits pour créer des ressources dans le groupe de ressources
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)

Résultat attendu

résultat
{
  "logs": null,
  "name": "cae-agent-lab",
  "provisioningState": "Succeeded"
}
Étape 3Enregistrer la Resource API

Objectif. Créez l'API aval comme enregistrement d'application avec son service principal. Rien ne donne encore accès.

Prérequis

  • Droit de créer des enregistrements d'applications dans le tenant de test
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

Résultat attendu

résultat
{
  "appRoleAssignmentRequired": false,
  "appRoles": [],
  "name": "Agent Lab - Resource API"
}
Étape 4Déployer l'agent sans secret

Objectif. Lancez un petit agent Python comme Container App avec l'identité attachée, sans ingress et sans secret, puis regardez ce que le conteneur contient vraiment.

Prérequis

  • L'environnement et l'identité des étapes précédentes
  • L'image est publique et ne sert que pour Python, aucun identifiant de registre n'est donc nécessaire
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"

Résultat attendu

résultat
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
Étape 5Exiger l'affectation et voir la demande de jeton échouer

Objectif. Activez l'affectation obligatoire pour la Resource API, puis demandez un jeton depuis le conteneur. Entra refuse, et Graph refuse un appel qui exige une permission.

Prérequis

  • L'agent tourne (REPLICA est définie)
  • Fixez la réplique : sans --replica, exec peut en choisir une arrêtée et atteindre une limite de débit
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"

Résultat attendu

résultat
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."}}
Étape 6Accorder un seul rôle d'application étroit et lire le jeton

Objectif. Ajoutez à la Resource API un rôle d'application seule Data.Read.All et attribuez-le à l'identité managée via Microsoft Graph. Lisez ensuite le jeton app-only que reçoit l'agent.

Prérequis

  • Le portail ne peut pas attribuer un rôle d'application à une identité managée, on passe donc par az rest
  • Droits pour gérer les attributions de rôles d'application dans le tenant
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"

Résultat attendu

résultat
{
  "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]
Étape 7Jouer l'API : valider le jeton et autoriser par rôle

Objectif. Vérifiez signature, audience, issuer et expiration comme le ferait l'API, puis autorisez chaque route par rôle. Un jeton aux rôles modifiés doit échouer.

Prérequis

  • Python 3 avec pip, pour installer PyJWT et cryptography
  • Le jeton passe par un fichier temporaire 0600 et n'est jamais affiché
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"

Résultat attendu

résultat
-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)
Étape 8Nettoyage

Objectif. Supprimez l'application, l'environnement, l'enregistrement de la Resource API et le groupe de ressources, et effacez les fichiers locaux.

Prérequis

  • Le calcul coûte de l'argent, ne sautez donc pas cette étape
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

Résultat attendu

résultat
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#

Discuter de cet article#

Utile ? Partagez-le et dites-moi ce que vous en pensez.

Suivre sur X

Les nouveaux articles par e-mail

Un e-mail par semaine avec les nouveaux articles et labs. Désinscription à tout moment.

Votre adresse est conservée chez Kit, le service qui envoie les e-mails. Détails

Articles et labs liés