# Agente de IA autónomo sin secretos en Azure: llamar a una API con identidad administrada desde Container Apps

> Laboratorio: un agente de Container Apps con identidad administrada y sin secretos recibe un rol de aplicación estrecho y la API valida su token app-only.

- URL: https://iamops.dev/es/secretless-agent-managed-identity-container-app/
- Language: es
- Author: Argo
- Published: 2026-11-05
- Category: Labs
- Topics: Identidad administrada, Entra ID, Agentes de IA, Identidad de workload, Azure

## En resumen

- Un agente autónomo que no guarda secretos no tiene nada que filtrar: una Container App con identidad administrada asignada por el usuario, sin secreto de cliente, certificado ni ingress.
- La identidad empieza sin roles; con la asignación obligatoria en la API, la solicitud de token se rechaza (AADSTS501051) hasta que se concede un solo rol estrecho.
- El token app-only contiene roles y no scp, y la API valida igualmente firma, audiencia, emisor y rol.
- Los tokens se guardan en caché unas 24 horas, así que quitar un rol no es una revocación inmediata.
- Trata la identidad como una cuenta privilegiada: un responsable, una fecha de revisión y una alerta sobre las asignaciones de rol.

El 5 de noviembre de 2026, Microsoft Threat Intelligence describió a atacantes que usan un marco ofensivo basado en agentes para buscar secretos expuestos en repositorios públicos y luego iniciar sesión como cargas de trabajo con credenciales de aplicación válidas. La lectura defensiva es sencilla: un agente autónomo que no guarda ningún secreto no tiene nada que filtrar. Construí uno en Azure y comprobé cada afirmación.

## Qué muestra el laboratorio

Un pequeño agente se ejecuta como Azure Container App. No tiene usuario, ni secreto de cliente, ni certificado. Su identidad es una **identidad administrada asignada por el usuario** que empieza sin ningún rol. El laboratorio:

1. Asocia la identidad a la app y demuestra que el contenedor no guarda ningún secreto.
2. Hace que la API posterior (la *Resource API*, un registro de aplicación) exija una asignación de rol de aplicación.
3. Muestra la solicitud de token rechazada y luego concede **un** solo rol app-only estrecho.
4. Lee el token app-only que obtiene el agente y lo comprueba como lo haría la API.

## Preparación

Use un tenant y una suscripción de prueba aparte. El agente funciona con 0,25 vCPU y 0,5 GiB en el plan de Consumo, sin ingress y sin área de trabajo de Log Analytics. Los primeros 180 000 vCPU-segundos al mes son gratuitos, que este tamaño agota en unas 200 horas de ejecución: elimine la app cuando termine. La identidad administrada y el rol de aplicación son gratuitos.

![Salida de terminal: la Azure CLI muestra la suscripción y el tenant, la identidad administrada con su ID de cliente y su ID de principal, y cero asignaciones de rol. Los identificadores son marcadores.](https://iamops.dev/media/secretless-agent-managed-identity-container-app/01-context.webp)

*Empezar de cero. La identidad administrada no tiene asignaciones de rol, así que cada permiso del laboratorio es una concesión deliberada y visible. Los identificadores son marcadores.*

La app se define en YAML. La imagen es pública y solo se usa por su Python, así que no hace falta ninguna credencial de registro. El bloque identity asocia la identidad administrada. No hay sección `ingress`, así que nadie puede llamar desde fuera.

![Salida de terminal de la definición de la app: ubicación, bloque identity asignado por el usuario, ID del entorno, imagen pública del contenedor, recursos de 0,25 vCPU y 0,5 GiB y el ID de cliente como variable de entorno. Los ID son marcadores.](https://iamops.dev/media/secretless-agent-managed-identity-container-app/03-app-definition.webp)

*Nada que robar. Todo lo que un atacante podría sacar de esta definición es público: el nombre de una imagen, un ID de cliente y el código. Los ID de suscripción y de cliente son marcadores.*

## La ejecución

**El contenedor guarda un endpoint de identidad, no un secreto.** La plataforma inyecta `IDENTITY_ENDPOINT`, una URL de localhost, e `IDENTITY_HEADER`, un valor por contenedor (enmascarado en la salida). Ninguna otra variable parece un secreto y no hay montado ningún volumen de secretos.

![Salida de terminal desde dentro del contenedor: el endpoint de identidad en localhost, la cabecera de identidad enmascarada, el ID de cliente público y ninguna variable llamada secret, password, key o certificate, ni volúmenes de secretos montados.](https://iamops.dev/media/secretless-agent-managed-identity-container-app/05-secretless.webp)

*Dentro del contenedor. La cabecera no es una credencial para Entra. Solo demuestra al endpoint local que quien llama está en este contenedor, lo que bloquea los trucos de SSRF.*

**Exigir la asignación en la API.** Por defecto Entra emite un token app-only a cualquier service principal del tenant que lo pida, con un claim `roles` vacío. Poner `appRoleAssignmentRequired` a `true` en el service principal de la Resource API hace que Entra rechace a quien no esté asignado:

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

**Dos pruebas negativas.** La solicitud del agente de un token para la Resource API es rechazada por el servicio de tokens con AADSTS501051, y un token para Graph (Graph no exige asignación) no contiene roles, de modo que `GET /v1.0/users` devuelve `403`.

![Salida de terminal de dos rechazos: HTTP 400 con AADSTS501051, que indica que la identidad administrada no está asignada a un rol de la Resource API, y HTTP 403 Authorization_RequestDenied de Graph. Los ID son marcadores.](https://iamops.dev/media/secretless-agent-managed-identity-container-app/07-refused.webp)

*Rechazado dos veces. El rechazo ocurre antes de llamar a la API y nombra la identidad administrada, lo que lo hace fácil de localizar en una revisión o un incidente. «Tener un token» no significa «tener acceso».*

**Una concesión estrecha.** Añada a la Resource API un rol de aplicación solo app-only `Data.Read.All` (tipo de miembro permitido: aplicación) y asígnelo a la identidad administrada mediante Microsoft Graph. El centro de administración no puede asignar un rol de aplicación a una identidad administrada; se hace con Graph, PowerShell o la CLI.

![Salida de terminal de dos llamadas a Graph: añadir el rol de aplicación Data.Read.All a la Resource API y asignarlo al service principal de la identidad administrada. Los ID de objeto son marcadores.](https://iamops.dev/media/secretless-agent-managed-identity-container-app/10-assign.webp)

*La única concesión del laboratorio. Es un objeto de Graph corriente que una herramienta de gobierno o un script pueden leer.*

**El token app-only.** Entra almacena en caché los tokens de las identidades administradas, así que el contenedor sigue recibiendo su token antiguo hasta un día. Reiniciar la revisión da uno nuevo, que ahora contiene el rol.

![Claims decodificados del token app-only tras reiniciar la revisión: la audiencia es la Resource API, la aplicación y el ID de objeto son la identidad administrada, idtyp es app, roles contiene Data.Read.All y no hay claim scope. Los identificadores son marcadores.](https://iamops.dev/media/secretless-agent-managed-identity-container-app/13-token.webp)

*Token app-only. Un claim roles sin scp es como una API distingue una llamada app-only de una delegada. No hay usuario; los permisos propios de la identidad son el único límite.*

**Hacer de API.** El token pasa del contenedor a un archivo temporal con modo 0600 y se destruye al final; nunca se imprime. Un script de validación comprueba la firma RS256 con las claves del tenant, la audiencia, el emisor y la caducidad, y luego autoriza cada ruta según el rol.

![Salida de terminal de la comprobación del lado de la API: GET data devuelve 200 para el rol Data.Read.All, POST data devuelve 403 por falta del rol Data.Write.All y un token con roles editados devuelve 401 porque falla la verificación de la firma.](https://iamops.dev/media/secretless-agent-managed-identity-container-app/15-validate.webp)

*La API sigue decidiendo. La lectura se permite, la escritura se rechaza y un token con claims manipulados no supera la verificación de la firma.*

## Trampas habituales

- **Los tokens se guardan en caché unas 24 horas.** Quitar el rol no basta para una revocación urgente. Reinicie o vuelva a desplegar la carga de trabajo, o desactive la identidad.
- **`exec` tiene un límite de frecuencia.** Sin `--replica`, `az containerapp exec` puede elegir una réplica detenida y los reintentos topan con HTTP 429 y diez minutos de espera. Indique la réplica en ejecución.
- **«Assignment required» es un interruptor que hay que activar.** Sin él, «poder obtener un token» y «estar autorizado» son cosas distintas, y cada API debe comprobar los roles por sí misma.
- **Los tenants gratuitos registran menos.** El registro de auditoría del directorio muestra la concesión. Los registros de inicio de sesión de las identidades administradas requieren Entra ID P1 o P2 y conviene exportarlos a su SIEM.
- **Elimine el cómputo cuando termine.** El cómputo cuesta dinero; la identidad y el rol llevan el riesgo y necesitan un responsable y una fecha de revisión como cualquier otra cuenta privilegiada.

## Conclusiones de seguridad

1. Una carga de trabajo sin secretos no tiene nada que filtrar. Prefiera identidades administradas o credenciales federadas a los secretos de cliente.
2. Empiece sin roles y añada un rol con el ámbito más estrecho. Nombre los roles app-only `*.All` para que quien revise vea que no hay límite de usuario.
3. Exija la asignación en las API internas para que el servicio de tokens sea la primera puerta.
4. Valide firma, audiencia, emisor y rol en la API. Entra solo decide quién obtiene un token.
5. Trate las identidades administradas con roles de aplicación como cuentas no humanas privilegiadas: responsable, recertificación, una alerta sobre las asignaciones de rol a service principals.

## Qué no se ejecutó

El laboratorio no desplegó un blueprint ni una identidad de agente de Entra Agent ID, donde un token de identidad administrada sería la credencial del blueprint. El recorrido por el portal de los objetos resultantes se grabó pero no se publica, porque las vistas del portal muestran identificadores del tenant. Para este laboratorio no se publica ninguna grabación.

*Las imágenes del terminal se generaron a partir de la salida guardada de la ejecución, con identificadores, secretos y marcas de tiempo sustituidos por marcadores.*

## Repite este lab

Necesitas una suscripción de Azure en un tenant de prueba, la CLI de Azure y unos 90 minutos. El agente corre en Azure Container Apps con 0,25 vCPU, así que la factura es casi cero si lo borras todo al final. Abre cada paso, copia los bloques y compara la salida con la mía.

Cada valor entre corchetes angulares es un marcador para tu entorno de prueba. Nada en esta página es un identificador o secreto real.

**Define tus variables una sola vez** `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'
```

### Paso 1: Crea la identidad y comprueba que no tiene roles

**Objetivo.** Crea una identidad administrada asignada por el usuario y comprueba que no tiene ninguna asignación de rol. Cada permiso a partir de aquí es una concesión deliberada.

**Requisitos**

- Un tenant y una suscripción de prueba, nunca los de producción
- Azure CLI 2.60 o posterior, jq y 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
```

**Salida esperada**

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

### Paso 2: Crea el entorno de Container Apps

**Objetivo.** Crea el entorno en el plan Consumption, sin espacio de trabajo de Log Analytics, para que no se facture nada más.

**Requisitos**

- Las variables de env.sh y la identidad del paso anterior
- Permisos para crear recursos en el grupo de recursos

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

**Salida esperada**

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

### Paso 3: Registra la Resource API

**Objetivo.** Crea la API de destino como registro de aplicación con su service principal. Todavía nada da acceso.

**Requisitos**

- Permiso para crear registros de aplicaciones en el tenant de prueba

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

**Salida esperada**

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

### Paso 4: Despliega el agente sin secretos

**Objetivo.** Ejecuta un pequeño agente de Python como Container App con la identidad asociada, sin ingress y sin secretos, y mira qué contiene realmente el contenedor.

**Requisitos**

- El entorno y la identidad de los pasos anteriores
- La imagen es pública y solo sirve por su Python, así que no hace falta credencial de registro

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

**Salida esperada**

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

### Paso 5: Exige asignación y mira fallar la petición de token

**Objetivo.** Activa la asignación obligatoria para la Resource API y pide un token desde el contenedor. Entra lo rechaza, y Graph rechaza una llamada que necesita un permiso.

**Requisitos**

- El agente está en marcha (REPLICA está definida)
- Fija la réplica: sin --replica, exec puede elegir una parada y toparse con un límite de peticiones

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

**Salida esperada**

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

### Paso 6: Concede un único app role estrecho y lee el token

**Objetivo.** Añade a la Resource API un rol solo de aplicación Data.Read.All y asígnalo a la identidad administrada mediante Microsoft Graph. Después lee el token app-only que recibe el agente.

**Requisitos**

- El portal no puede asignar un app role a una identidad administrada, así que se hace con az rest
- Permisos para gestionar asignaciones de app roles en el tenant

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

**Salida esperada**

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

### Paso 7: Haz de API: valida el token y autoriza por rol

**Objetivo.** Comprueba firma, audience, issuer y caducidad como lo haría la API y autoriza cada ruta por rol. Un token con roles editados debe fallar.

**Requisitos**

- Python 3 con pip, para instalar PyJWT y cryptography
- El token pasa por un archivo temporal 0600 y nunca se imprime

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

**Salida esperada**

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

### Paso 8: Limpieza

**Objetivo.** Borra la app, el entorno, el registro de la Resource API y el grupo de recursos, y elimina los archivos locales.

**Requisitos**

- El cómputo cuesta dinero, así que no te saltes este paso

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

**Salida esperada**

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