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.
Repite este lab
Escribí este lab para que puedas repetirlo tú mismo. Cada paso tiene los comandos para copiar y la salida que obtuve yo, y puedes marcarlo como hecho. Las marcas se quedan solo en este navegador.
Copia un prompt listo para Claude Code, Cursor, Codex o cualquier agente de código. Solo para entornos de prueba.
Mostrar el prompt
I want to run a hands-on lab from iamops.dev, and I would like your help to do it safely. Lab: Agente de IA autónomo sin secretos en Azure: llamar a una API con identidad administrada desde Container Apps Read the whole lab here (Markdown): https://iamops.dev/es/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.
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:
- Asocia la identidad a la app y demuestra que el contenedor no guarda ningún secreto.
- Hace que la API posterior (la Resource API, un registro de aplicación) exija una asignación de rol de aplicación.
- Muestra la solicitud de token rechazada y luego concede un solo rol app-only estrecho.
- 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.

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.

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.

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

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.

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.

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.

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.
exectiene un límite de frecuencia. Sin--replica,az containerapp execpuede 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#
- Una carga de trabajo sin secretos no tiene nada que filtrar. Prefiera identidades administradas o credenciales federadas a los secretos de cliente.
- Empiece sin roles y añada un rol con el ámbito más estrecho. Nombre los roles app-only
*.Allpara que quien revise vea que no hay límite de usuario. - Exija la asignación en las API internas para que el servicio de tokens sea la primera puerta.
- Valide firma, audiencia, emisor y rol en la API. Entra solo decide quién obtiene un token.
- 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
# 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' 0 de 8 pasos hechos
Paso 1Crea 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
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
{
"clientId": "<identity-client-id>",
"name": "agent-lab-mi",
"principalId": "<identity-principal-id>"
}
0 Paso 2Crea 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
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
{
"logs": null,
"name": "cae-agent-lab",
"provisioningState": "Succeeded"
} Paso 3Registra 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
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
{
"appRoleAssignmentRequired": false,
"appRoles": [],
"name": "Agent Lab - Resource API"
} Paso 4Despliega 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
# 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" Salida esperada
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 5Exige 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
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
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 6Concede 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
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
{
"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 7Haz 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
# 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" Salida esperada
-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 8Limpieza
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
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
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) Fuentes#
- 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
Comenta este artículo#
¿Te ha servido? Compártelo y dime qué piensas.
Este artículo en Markdown · RSS · JSON feed
Nuevos artículos por correo
Un correo a la semana con nuevos artículos y labs. Puedes darte de baja cuando quieras.
Tu dirección se guarda en Kit, el servicio que envía los correos. Detalles