En bref
- 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
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.
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 :
- Attache l’identité à l’application et prouve que le conteneur ne détient aucun secret.
- Fait exiger par l’API en aval (la Resource API, une inscription d’application) une attribution de rôle d’application.
- Montre la demande de jeton refusée, puis accorde un seul rôle app-only étroit.
- 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.

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.

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

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é :
az ad sp update --id <resource-sp-id> --set appRoleAssignmentRequired=trueDeux 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.

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.

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.

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.

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é.
execa une limite de débit. Sans--replica,az containerapp execpeut 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é#
- 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.
- Partez sans rôle et ajoutez un rôle à l’étendue la plus étroite. Nommez les rôles app-only
*.Allpour que les relecteurs voient qu’il n’y a pas de limite utilisateur. - Exigez l’attribution sur les API internes pour que le service de jetons soit la première barrière.
- Validez signature, audience, émetteur et rôle dans l’API. Entra ne décide que de qui obtient un jeton.
- 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
# 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' Étapes terminées : 0 sur 8
É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
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
{
"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
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
{
"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
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
{
"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
# 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@@") {
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
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
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
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
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
{
"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é
# 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")) 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
-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
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
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
- Microsoft Learn: Managed identities in Azure Container Apps
- Microsoft Learn: Managed identities for Azure resources
- Microsoft Learn: Restrict your app to a set of users (app role assignment required)
- Microsoft Learn: Azure Container Apps billing
Discuter de cet article#
Utile ? Partagez-le et dites-moi ce que vous en pensez.
Cet article en Markdown · RSS · JSON feed
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