Mostrando el Markdown sin formato: no se pudo cargar el visor.
## Objetivo
Construyes una pequeña configuración de IAM en la nube en tu propio equipo: creas usuarios con una política de mínimo privilegio, ves en acción la denegación por defecto y el deny explícito, reutilizas una política administrada mediante un grupo, das a un usuario credenciales temporales asumiendo un rol y rotas una clave de acceso. Todo se ejecuta contra un emulador local, así que no puedes romper nada real ni gastar un céntimo.
## Objetivos
- Autenticarte como distintos principales y distinguir un fallo de autenticación de un fallo de autorización.
- Escribir una política JSON de mínimo privilegio y probar una solicitud permitida y otra denegada para cada sentencia.
- Demostrar que un deny explícito anula un allow.
- Reutilizar permisos mediante una política administrada asociada a un grupo.
- Asumir un rol para obtener credenciales temporales (clave ASIA y token de sesión) y comparar la identidad y los permisos antes y después.
- Rotar una clave de acceso sin interrumpir el acceso, y revisar las claves con su último uso.
## Requisitos previos
- Podman 4 o posterior en Linux, sin privilegios de root, sin `sudo` (probado con Podman 5.8). Docker sirve si sustituyes `podman` por `docker` en los comandos.
- Imágenes que se descargan la primera vez que se usan (unos 900 MB de disco en total): `docker.io/motoserver/moto:5.2.4` (el servidor) y `docker.io/amazon/aws-cli:2.38.0` (el cliente).
- El puerto TCP `9100` libre en `127.0.0.1`.
- Sin cuenta en la nube, sin tarjeta de crédito y sin acceso a Internet una vez descargadas las imágenes.
- [La lección de IAM en la nube](lesson.es.md) de este módulo.
> [!WARNING]
> El laboratorio es gratuito y local. El servidor escucha solo en `127.0.0.1`. Las "claves" que creas son cadenas aleatorias para un emulador y no significan nada en ningún otro sitio; el laboratorio las guarda en archivos de texto plano para que los pasos sean cortos, algo que **nunca** debes hacer con credenciales reales. Los cambios se quedan dentro de una carpeta (`~/iam-lab`), un contenedor y, opcionalmente, dos imágenes, que se eliminan al final.
> [!NOTE]
> **¿Por qué API compatibles con AWS?** El laboratorio habla las API de AWS IAM, STS y S3 porque son el estándar de facto: la mayoría de los tutoriales, herramientas, módulos de Terraform y servicios de almacenamiento compatibles con S3 de otros proveedores las entienden, y los emuladores de código abierto te permiten practicar gratis. Otros proveedores difieren en la sintaxis y el vocabulario (OpenStack Keystone con usuarios, proyectos y tokens; Azure con asignaciones de roles en un ámbito; Google Cloud con roles asociados a miembros sobre un recurso), pero comparten los conceptos que practicas aquí: principales, denegación por defecto, mínimo privilegio y credenciales temporales.
> [!NOTE]
> **Límites del emulador.** [Moto](https://docs.getmoto.org/) es un emulador, no la nube real, e implementa solo una parte de IAM. En esta configuración (Moto 5.2.4), `Allow` y `Deny` sobre acciones y recursos se aplican en IAM, STS y S3, que es lo que necesita el laboratorio. Estos comportamientos de la nube real **no** se reproducen, así que no los esperes ni cuentes con ellos: los bloques `Condition` se ignoran (una condición de MFA o de IP siempre "se cumple"); desactivar una clave de acceso no la bloquea; no se verifica la caducidad de las credenciales temporales; `iam simulate-principal-policy` falla con un error del servidor; y las URL prefirmadas y las solicitudes anónimas fallan con un error del servidor cuando se exige autenticación. En una nube real, todo esto funciona.
## Arquitectura
<figure class="diagram" style="--dg-w: 1080px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 1080 440" width="1080" height="440" role="img" aria-labelledby="iam-lab-architecture-es-title iam-lab-architecture-es-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="es">
<title id="iam-lab-architecture-es-title">Arquitectura del lab: contenedor AWS CLI hablando con un emulador IAM Moto local</title>
<desc id="iam-lab-architecture-es-desc">En tu ordenador Linux con Podman sin root, una terminal ejecuta funciones de shell de lab.sh en la carpeta ~/iam-lab, que también contiene los archivos JSON de políticas y una carpeta keys con claves solo para el lab. Cada comando aws ejecuta el contenedor de AWS CLI v2, imagen amazon/aws-cli:2.38.0, lanzado con run --rm, con ~/iam-lab montada en /work. La CLI envía solicitudes HTTP firmadas a 127.0.0.1 puerto 9100, que se asigna al puerto 5000 del contenedor lab-iam-moto, que ejecuta Moto 5.2.4, un emulador de API de AWS que exige autenticación tras las 3 primeras llamadas. Moto guarda su estado en memoria: los usuarios admin, bob, carol y dave, el grupo analysts, el rol reader, la política administrada reports-reader y el bucket lab-data.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="1079" height="439" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l2"><rect class="dg-tint" x="20" y="20" width="1040" height="400" rx="16" fill="#f1f7f3" stroke="#a1ccb1" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 33) scale(0.7500)" fill="none" stroke="#15803d" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g>
<text x="62" y="47" font-size="13" class="dg-ink" fill="#15803d" font-weight="700">Tu ordenador: Linux con Podman sin root</text></g>
<rect class="dg-card" x="44" y="66" width="250" height="120" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(60 82) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g>
<text x="102" y="103" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Terminal</text>
<text x="62" y="134" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">use bob</text>
<text x="62" y="154" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">aws s3api get-object ...</text>
<text x="62" y="174" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">funciones de shell de lab.sh</text>
<rect class="dg-card" x="44" y="250" width="250" height="132" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(60 266) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"/><path d="M14 2v4a2 2 0 0 0 2 2h4"/><path d="M10 9H8"/><path d="M16 13H8"/><path d="M16 17H8"/></g>
<text x="102" y="287" font-size="15" class="dg-text" fill="#17171c" font-weight="700">~/iam-lab</text>
<text x="62" y="318" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">lab.sh (funciones)</text>
<text x="62" y="338" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">keys/ (solo claves del lab)</text>
<text x="62" y="358" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">*.json (políticas)</text>
<g class="dg-l1"><rect class="dg-tint" x="340" y="60" width="290" height="150" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(356 73) scale(0.7500)" fill="none" stroke="#0369a1" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g>
<text x="382" y="87" font-size="13" class="dg-ink" fill="#0369a1" font-weight="700">Podman: AWS CLI (run --rm)</text></g>
<rect class="dg-card" x="356" y="100" width="258" height="96" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(372 116) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g></g>
<g class="dg-l1"><text x="414" y="137" font-size="15" class="dg-ink" fill="#0369a1" font-weight="700">AWS CLI v2</text></g>
<text x="374" y="168" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">amazon/aws-cli:2.38.0</text>
<text x="374" y="188" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">monta ~/iam-lab en /work</text>
<g class="dg-l7"><rect class="dg-tint" x="740" y="60" width="300" height="340" rx="16" fill="#f6f2fd" stroke="#c5a9f0" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(756 73) scale(0.7500)" fill="none" stroke="#6d28d9" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g>
<text x="782" y="87" font-size="13" class="dg-ink" fill="#6d28d9" font-weight="700">Podman: lab-iam-moto</text></g>
<rect class="dg-card" x="756" y="100" width="268" height="96" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l7"><g class="dg-icon" transform="translate(772 116) scale(1.2500)" fill="none" stroke="#6d28d9" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M17.5 19H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9Z"/></g></g>
<g class="dg-l7"><text x="814" y="137" font-size="15" class="dg-ink" fill="#6d28d9" font-weight="700">Moto 5.2.4</text></g>
<text x="774" y="168" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">emulador de API AWS :5000</text>
<text x="774" y="188" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">auth exigida tras 3 llamadas</text>
<text x="760" y="226" font-size="11" class="dg-muted" fill="#5c5c68" font-weight="700" letter-spacing="1.2">ESTADO EN MEMORIA</text>
<g class="dg-l1"><rect class="dg-solid" x="758" y="240" width="118" height="26" rx="13" fill="#0369a1"/><text x="817" y="257.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">usuario admin</text></g>
<g class="dg-l1"><rect class="dg-solid" x="882" y="240" width="103" height="26" rx="13" fill="#0369a1"/><text x="933.5" y="257.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">usuario bob</text></g>
<g class="dg-l1"><rect class="dg-solid" x="758" y="272" width="118" height="26" rx="13" fill="#0369a1"/><text x="817" y="289.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">usuario carol</text></g>
<g class="dg-l1"><rect class="dg-solid" x="882" y="272" width="110" height="26" rx="13" fill="#0369a1"/><text x="937" y="289.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">usuario dave</text></g>
<g class="dg-l2"><rect class="dg-solid" x="758" y="304" width="125" height="26" rx="13" fill="#15803d"/><text x="820.5" y="321.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">grupo analysts</text></g>
<g class="dg-l3"><rect class="dg-solid" x="889" y="304" width="96" height="26" rx="13" fill="#b45309"/><text x="937" y="321.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">rol reader</text></g>
<g class="dg-l7"><rect class="dg-solid" x="758" y="336" width="190" height="26" rx="13" fill="#6d28d9"/><text x="853" y="353.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">política reports-reader</text></g>
<g class="dg-l4"><rect class="dg-solid" x="758" y="368" width="132" height="26" rx="13" fill="#c2410c"/><text x="824" y="385.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">bucket lab-data</text></g>
<path class="dg-line" d="M296 130H332" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M327 124l8 6-8 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<g class="dg-l1"><path class="dg-stroke" d="M634 148H732" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><path class="dg-stroke" d="M727 142l8 6-8 6" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><rect class="dg-bg-plain" x="637.36" y="136" width="95.28" height="24" rx="12" fill="#ffffff"/><text x="685" y="152.5" font-size="11.5" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle">HTTP firmado</text></g>
<text x="685" y="176" font-size="11" class="dg-muted" fill="#5c5c68" font-weight="600" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">127.0.0.1:9100</text>
<path class="dg-line" d="M296 320H485V218" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="7 6"/>
<path class="dg-line" d="M479 225l6-8 6 8" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<rect class="dg-bg-plain" x="424.48" y="278" width="121.04" height="24" rx="12" fill="#ffffff"/><text x="485" y="294.5" font-size="11.5" class="dg-muted" fill="#5c5c68" font-weight="600" text-anchor="middle">montado en /work</text>
</svg></figure>
*Figura 1. Cada comando `aws` es un contenedor cliente de corta vida que envía solicitudes firmadas al emulador en `127.0.0.1:9100`; el emulador guarda usuarios, políticas y datos en memoria.*
## Pasos
### Paso 1 — Crea la carpeta de trabajo e inicia el emulador
Todos los archivos van en una sola carpeta, para que la limpieza sea fácil. El contenedor del servidor tiene un nombre que empieza por `lab-iam-`, y `INITIAL_NO_AUTH_ACTION_COUNT=3` le dice a Moto que acepte sus tres primeras llamadas a la API sin autenticación. Necesitas exactamente eso para arrancar el primer administrador, porque nadie puede firmar una solicitud hasta que existen un usuario y una clave. Después de la tercera llamada, toda solicitud debe estar firmada por una clave conocida y se comprueba contra las políticas.
```bash
mkdir -p ~/iam-lab && cd ~/iam-lab
podman run -d --name lab-iam-moto -p 127.0.0.1:9100:5000 \
-e INITIAL_NO_AUTH_ACTION_COUNT=3 docker.io/motoserver/moto:5.2.4
```
Salida esperada (un ID de contenedor; el tuyo será distinto):
```text
f97527afd13808739cf9b751e2d21b95469f2837c6cbb991e688d8f806244295
```
> [!IMPORTANT]
> Las tres llamadas gratuitas son un contador del servidor: haz exactamente los pasos 3 a 5 en orden y no ejecutes otros comandos `aws` antes. Si te equivocas de orden, elimina el contenedor y empieza de nuevo: `podman rm -f lab-iam-moto`, y repite este paso. (Un comando que falla por tu parte antes de llegar al servidor, por ejemplo por un error al escribir el nombre de un archivo, no gasta una llamada.)
### Paso 2 — Define las funciones auxiliares
Crea un pequeño archivo con tres funciones de shell y cárgalo. Es la única "herramienta" del laboratorio. Léelo una vez: es corto.
- `aws` ejecuta el contenedor de la AWS CLI v2 y lo apunta al emulador. Pasa tus credenciales desde variables de entorno, monta la carpeta actual en `/work` para que `file://policy.json` funcione (`:Z` reetiqueta la carpeta para equipos con SELinux, como Fedora) y usa una región fija.
- `use <nombre>` cambia tu terminal a la identidad cuya clave está guardada en `keys/<nombre>`.
- `newkey <usuario>` crea una clave de acceso para un usuario y la guarda en `keys/<usuario>`.
```bash
cat > lab.sh <<'SCRIPT'
# Lab helpers: source this file in every terminal you use for the lab.
aws() { podman run --rm --network host -v "$PWD:/work:Z" -w /work -e AWS_ACCESS_KEY_ID -e AWS_SECRET_ACCESS_KEY -e AWS_SESSION_TOKEN -e AWS_DEFAULT_REGION=us-east-1 -e AWS_PAGER= docker.io/amazon/aws-cli:2.38.0 --endpoint-url http://127.0.0.1:9100 "$@"; }
# use <name>: act as the user whose key is saved in ~/iam-lab/keys/<name>
use() { read -r AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY < "$HOME/iam-lab/keys/$1"; export AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY; unset AWS_SESSION_TOKEN; }
# newkey <user>: create an access key for <user> and save it (lab only: never store real keys in plain files)
newkey() { aws iam create-access-key --user-name "$1" --query 'AccessKey.[AccessKeyId,SecretAccessKey]' --output text > "$HOME/iam-lab/keys/$1"; }
SCRIPT
mkdir -p keys && chmod 700 keys
source lab.sh
```
El primer comando `aws` descarga la imagen de la CLI (unos 470 MB), así que tarda un momento, una sola vez. Ejecuta `source ~/iam-lab/lab.sh` en cada terminal nueva, desde `~/iam-lab`.
### Paso 3 — Arranca el administrador (llamadas gratuitas 1 a 3)
El emulador no comprueba las credenciales de las tres primeras llamadas, pero la CLI sigue queriendo unas, así que usas el par ficticio `test` / `test`. Creas un usuario `admin`, le das una política que lo permite todo y creas su clave de acceso. El archivo de política tiene la forma que viste en la lección: una versión y una sentencia.
```bash
export AWS_ACCESS_KEY_ID=test AWS_SECRET_ACCESS_KEY=test
cat > admin-policy.json <<'JSON'
{
"Version": "2012-10-17",
"Statement": [
{ "Effect": "Allow", "Action": "*", "Resource": "*" }
]
}
JSON
aws iam create-user --user-name admin
aws iam put-user-policy --user-name admin --policy-name admin-all --policy-document file://admin-policy.json
newkey admin
```
Salida esperada (el ID de usuario y la fecha serán distintos; `put-user-policy` y `newkey` no imprimen nada):
```text
{
"User": {
"Path": "/",
"UserName": "admin",
"UserId": "c2ndbofy683n3gu2ii3r",
"Arn": "arn:aws:iam::123456789012:user/admin",
"CreateDate": "2026-11-07T18:58:03.515092+00:00"
}
}
```
La cuenta `123456789012` es el ID de cuenta fijo que usa Moto. Esa política tan amplia es solo para este administrador del laboratorio: en la lección viste por qué `*` sobre `*` es peligroso en la vida real.
### Paso 4 — Inicia sesión como admin y comprueba cómo falla la autenticación
Cambia a la clave que acabas de guardar. A partir de ahora, cada solicitud se firma y se comprueba.
```bash
use admin
aws sts get-caller-identity
aws iam list-users --query 'Users[].UserName'
```
Salida esperada (el ID de usuario será distinto):
```text
{
"UserId": "c2ndbofy683n3gu2ii3r",
"Account": "123456789012",
"Arn": "arn:aws:iam::123456789012:user/admin"
}
[
"admin"
]
```
`get-caller-identity` es la respuesta de la nube a "¿quién soy?" y funciona para cualquier identidad válida sin permisos adicionales. Ejecútalo siempre que dudes de qué identidad usa tu terminal. Ahora prueba de nuevo la clave ficticia, que ya no es una identidad conocida:
```bash
AWS_ACCESS_KEY_ID=test AWS_SECRET_ACCESS_KEY=test aws iam list-users
```
Salida esperada:
```text
aws: [ERROR]: An error occurred (InvalidClientTokenId) when calling the ListUsers operation: The security token included in the request is invalid.
```
Esto es un fallo de **autenticación**: el servidor no sabe quién eres. Tenlo presente: en los pasos siguientes verás `AccessDenied`, que es un problema distinto.
### Paso 5 — Crea un bucket con dos carpetas
Necesitas algo que proteger. Como admin, crea el bucket `lab-data` y sube un "informe" inofensivo y un "secreto". Ambos son texto falso.
```bash
aws s3api create-bucket --bucket lab-data
echo "Q3 revenue: 42 (fake)" > q3.txt
echo "admin password: not-a-real-secret" > passwords.txt
aws s3 cp q3.txt s3://lab-data/reports/q3.txt --only-show-errors
aws s3 cp passwords.txt s3://lab-data/secret/passwords.txt --only-show-errors
aws s3 ls s3://lab-data --recursive
```
Salida esperada (las marcas de tiempo serán distintas):
```text
{
"Location": "/lab-data"
}
2026-11-07 18:58:18 22 reports/q3.txt
2026-11-07 18:58:19 34 secret/passwords.txt
```
### Paso 6 — Crea a bob con una política de mínimo privilegio
Bob es un analista que debe leer y escribir informes y nada más. La política tiene dos sentencias, escritas como en la lección: `ListBucket` se aplica al ARN del bucket, mientras que `GetObject` y `PutObject` se aplican a los objetos bajo `reports/`.
```bash
cat > bob-policy.json <<'JSON'
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ListTheBucket",
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::lab-data"
},
{
"Sid": "ReadWriteReports",
"Effect": "Allow",
"Action": ["s3:GetObject", "s3:PutObject"],
"Resource": "arn:aws:s3:::lab-data/reports/*"
}
]
}
JSON
aws iam create-user --user-name bob --query User.Arn
aws iam put-user-policy --user-name bob --policy-name reports-rw --policy-document file://bob-policy.json
newkey bob
```
Salida esperada:
```text
"arn:aws:iam::123456789012:user/bob"
```
`put-user-policy` crea una **política en línea (inline)**: vive dentro del usuario y tiene un nombre (`reports-rw`). El otro tipo, una política administrada, lo conocerás en el Paso 9.
### Paso 7 — Prueba lo que Bob puede y no puede hacer
Actúa como Bob e intenta ocho solicitudes. Para cada una, predice la respuesta antes de ejecutarla: decide la política, no la suerte.
```bash
use bob
aws sts get-caller-identity --query Arn --output text
echo "Q4 draft (fake)" > q4.txt
# 1. List the reports
aws s3api list-objects-v2 --bucket lab-data --prefix reports/ --query 'Contents[].Key'
# 2. Read a report
aws s3api get-object --bucket lab-data --key reports/q3.txt q3-bob.txt --query ContentLength
cat q3-bob.txt
# 3. Write a report
aws s3api put-object --bucket lab-data --key reports/q4.txt --body q4.txt --query ETag
# 4. Write outside reports/
aws s3api put-object --bucket lab-data --key secret/q4.txt --body q4.txt
# 5. Read the secret
aws s3api get-object --bucket lab-data --key secret/passwords.txt x.txt
# 6. List all buckets
aws s3api list-buckets
# 7. Delete a report
aws s3api delete-object --bucket lab-data --key reports/q4.txt
# 8. Use IAM
aws iam list-users
```
Salida esperada (el ETag será distinto):
```text
arn:aws:iam::123456789012:user/bob
[
"reports/q3.txt"
]
22
Q3 revenue: 42 (fake)
"\"c32c8500d318ac0878b49cc441b6b837\""
aws: [ERROR]: An error occurred (AccessDenied) when calling the PutObject operation: Access Denied
aws: [ERROR]: An error occurred (AccessDenied) when calling the GetObject operation: Access Denied
aws: [ERROR]: An error occurred (AccessDenied) when calling the ListBuckets operation: Access Denied
aws: [ERROR]: An error occurred (AccessDenied) when calling the DeleteObject operation: Access Denied
aws: [ERROR]: An error occurred (AccessDenied) when calling the ListUsers operation: User: arn:aws:iam::123456789012:user/bob is not authorized to perform: iam:ListUsers
```
Las solicitudes 1 a 3 coinciden con un `Allow`. Las solicitudes 4 y 5 apuntan a `secret/`, que ninguna sentencia permite. La solicitud 6 necesita `s3:ListAllMyBuckets`, que Bob no tiene. La solicitud 7, `DeleteObject`, no está en la lista de acciones permitidas. Todas son **denegación por defecto**: ninguna política dijo "no", simplemente no hay ningún "sí". Fíjate en que todas las denegaciones son `AccessDenied`, no `InvalidClientTokenId`: Bob se autenticó sin problemas.
### Paso 8 — Haz la política demasiado amplia y después añade un deny explícito
Supón que alguien "simplifica" la política de Bob con `s3:*` sobre `reports/*`. Después limitas el daño con un deny explícito sobre el borrado. Los cambios de política son tarea de administrador, así que cambia a admin y vuelve.
```bash
use admin
cat > bob-policy-broad.json <<'JSON'
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ListTheBucket",
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::lab-data"
},
{
"Sid": "EverythingInReports",
"Effect": "Allow",
"Action": "s3:*",
"Resource": "arn:aws:s3:::lab-data/reports/*"
}
]
}
JSON
aws iam put-user-policy --user-name bob --policy-name reports-rw --policy-document file://bob-policy-broad.json
use bob
aws s3api delete-object --bucket lab-data --key reports/q4.txt && echo "delete succeeded"
aws s3api put-object --bucket lab-data --key reports/q4.txt --body q4.txt --query ETag
```
Salida esperada:
```text
delete succeeded
"\"c32c8500d318ac0878b49cc441b6b837\""
```
Poner una política con el mismo nombre sustituye a la anterior. Bob ya puede borrar: el allow más amplio cubre `DeleteObject`. Has vuelto a subir `q4.txt` para poder probar el paso siguiente. Ahora añade a la política una tercera sentencia, un deny explícito:
```bash
use admin
cat > bob-policy-deny.json <<'JSON'
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ListTheBucket",
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::lab-data"
},
{
"Sid": "EverythingInReports",
"Effect": "Allow",
"Action": "s3:*",
"Resource": "arn:aws:s3:::lab-data/reports/*"
},
{
"Sid": "NeverDelete",
"Effect": "Deny",
"Action": "s3:DeleteObject",
"Resource": "*"
}
]
}
JSON
aws iam put-user-policy --user-name bob --policy-name reports-rw --policy-document file://bob-policy-deny.json
use bob
aws s3api delete-object --bucket lab-data --key reports/q4.txt
aws s3api get-object --bucket lab-data --key reports/q4.txt q4-back.txt --query ContentLength
aws s3api list-objects-v2 --bucket lab-data --query 'Contents[].Key'
```
Salida esperada:
```text
aws: [ERROR]: An error occurred (AccessDenied) when calling the DeleteObject operation: Access Denied
16
[
"reports/q3.txt",
"reports/q4.txt",
"secret/passwords.txt"
]
```
El allow de `s3:*` sigue coincidiendo con `DeleteObject`, pero el `Deny` explícito gana: el borrado falla y el objeto sigue ahí (16 bytes). Fíjate también en el último resultado: Bob puede *listar* todo el bucket, incluido el nombre `secret/passwords.txt`, porque `ListBucket` se permitió sobre el ARN del bucket sin límite de prefijo. No puede leer el archivo, pero se entera de que existe. En una nube real lo acotas con una `Condition` sobre el prefijo de la clave; el emulador ignora las condiciones, así que no puedes probarlo aquí.
### Paso 9 — Reutiliza permisos con una política administrada y un grupo
Las políticas en línea se copian por usuario. Una **política administrada** es un documento con nombre y reutilizable que creas una vez y asocias a muchos usuarios, grupos o roles. Crea una política de solo lectura, asóciala a un grupo `analysts` y añade un usuario nuevo, dave, al grupo. Dave recibe sus permisos del grupo y no tiene ninguna política propia.
```bash
use admin
cat > reports-reader.json <<'JSON'
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::lab-data"
},
{
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::lab-data/reports/*"
}
]
}
JSON
aws iam create-policy --policy-name reports-reader --policy-document file://reports-reader.json --query Policy.Arn
aws iam create-group --group-name analysts --query Group.Arn
aws iam attach-group-policy --group-name analysts --policy-arn arn:aws:iam::123456789012:policy/reports-reader
aws iam create-user --user-name dave --query User.Arn
aws iam add-user-to-group --group-name analysts --user-name dave
aws iam list-groups-for-user --user-name dave --query 'Groups[].GroupName'
newkey dave
```
Salida esperada:
```text
"arn:aws:iam::123456789012:policy/reports-reader"
"arn:aws:iam::123456789012:group/analysts"
"arn:aws:iam::123456789012:user/dave"
[
"analysts"
]
```
Prueba a Dave:
```bash
use dave
aws s3api get-object --bucket lab-data --key reports/q3.txt q3-dave.txt --query ContentLength
aws s3api put-object --bucket lab-data --key reports/dave.txt --body q4.txt
aws s3api get-object --bucket lab-data --key secret/passwords.txt x.txt
```
Salida esperada:
```text
22
aws: [ERROR]: An error occurred (AccessDenied) when calling the PutObject operation: Access Denied
aws: [ERROR]: An error occurred (AccessDenied) when calling the GetObject operation: Access Denied
```
Dave puede leer informes porque su grupo tiene la política administrada; no puede escribir ni leer el secreto. Añadir al siguiente analista es una sola llamada `add-user-to-group`, y cambiar lo que pueden hacer los analistas significa editar una única política. Eso es RBAC en la práctica.
### Paso 10 — Asume un rol para obtener credenciales temporales
Carol necesita acceso de lectura a los informes solo de vez en cuando. En lugar de un permiso permanente, creas un **rol** `reader` que ella puede asumir. El rol tiene una **política de confianza** (quién puede asumirlo) y una **política de permisos** (qué puede hacer; reutilizas `reports-reader.json`).
```bash
use admin
aws iam create-user --user-name carol --query User.Arn
newkey carol
cat > reader-trust.json <<'JSON'
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam::123456789012:user/carol" },
"Action": "sts:AssumeRole"
}
]
}
JSON
aws iam create-role --role-name reader --assume-role-policy-document file://reader-trust.json --query Role.Arn
aws iam put-role-policy --role-name reader --policy-name read-reports --policy-document file://reports-reader.json
cat > carol-assume.json <<'JSON'
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::123456789012:role/reader"
}
]
}
JSON
aws iam put-user-policy --user-name carol --policy-name may-assume-reader --policy-document file://carol-assume.json
```
Salida esperada:
```text
"arn:aws:iam::123456789012:user/carol"
"arn:aws:iam::123456789012:role/reader"
```
> [!NOTE]
> La última política permite a Carol llamar a `sts:AssumeRole` sobre este único rol. AWS real acepta por sí sola una política de confianza que nombre a un usuario de la misma cuenta, sin ella; el emulador exige las dos, así que la añades aquí. Muchos equipos la añaden de todos modos para que el permiso sea visible en el usuario.
Ahora actúa como Carol. Primero intenta leer un informe directamente: ella no tiene permiso propio. Después asume el rol. La línea `read` toma los tres valores temporales (ID de clave, secreto, token de sesión) de la respuesta y los pone en variables de entorno.
```bash
use carol
aws sts get-caller-identity
aws s3api get-object --bucket lab-data --key reports/q3.txt x.txt
read -r AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN < <(
aws sts assume-role --role-arn arn:aws:iam::123456789012:role/reader \
--role-session-name carol-lab --duration-seconds 900 \
--query 'Credentials.[AccessKeyId,SecretAccessKey,SessionToken]' --output text)
export AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN
echo "key id starts with: ${AWS_ACCESS_KEY_ID:0:4} session token length: ${#AWS_SESSION_TOKEN}"
```
Salida esperada (el ID de usuario y la longitud del token serán distintos):
```text
{
"UserId": "2lahxwq9nou7k0ox8yzp",
"Account": "123456789012",
"Arn": "arn:aws:iam::123456789012:user/carol"
}
aws: [ERROR]: An error occurred (AccessDenied) when calling the GetObject operation: Access Denied
key id starts with: ASIA session token length: 356
```
La clave ahora empieza por `ASIA`, el prefijo de las credenciales temporales (las claves de larga duración empiezan por `AKIA`), y el token de sesión forma parte de cada solicitud. Compara identidades y permisos:
```bash
aws sts get-caller-identity
aws s3api get-object --bucket lab-data --key reports/q3.txt q3-role.txt --query ContentLength
aws s3api put-object --bucket lab-data --key reports/carol.txt --body q4.txt
aws s3api get-object --bucket lab-data --key secret/passwords.txt x.txt
```
Salida esperada:
```text
{
"UserId": "AROARZPUZDIKOPOZ53WR2:carol-lab",
"Account": "123456789012",
"Arn": "arn:aws:sts::123456789012:assumed-role/reader/carol-lab"
}
22
aws: [ERROR]: An error occurred (AccessDenied) when calling the PutObject operation: Access Denied
aws: [ERROR]: An error occurred (AccessDenied) when calling the GetObject operation: Access Denied
```
Carol es ahora `assumed-role/reader/carol-lab`: se aplican los permisos del rol (leer informes, nada más), y los suyos propios quedan en suspenso. El nombre de sesión `carol-lab` aparecería en los registros de auditoría, así que aun así puedes saber quién actuó. Estas credenciales se solicitaron por 900 segundos (15 minutos) y dejarían de funcionar entonces; el emulador no aplica la caducidad (consulta la nota sobre el emulador), pero una nube real sí. Vuelve a la identidad propia de Carol: `use` borra el token de sesión.
```bash
use carol
aws sts get-caller-identity --query Arn --output text
```
Salida esperada:
```text
arn:aws:iam::123456789012:user/carol
```
### Paso 11 — Rota una clave de acceso
Las claves de larga duración deben sustituirse con regularidad, sin cortes de servicio. El orden seguro es: crear la segunda clave, cambiar la aplicación para que use esa, confirmar que la clave antigua ya no se usa y borrar la antigua. Un usuario puede tener dos claves a la vez, y eso es lo que lo hace posible. Rota la clave de Bob.
```bash
use admin
cp keys/bob keys/bob.old
read -r OLDKEY _ < keys/bob.old
aws iam list-access-keys --user-name bob --query 'AccessKeyMetadata[].[AccessKeyId,Status]' --output text
newkey bob
aws iam list-access-keys --user-name bob --query 'length(AccessKeyMetadata)'
```
Salida esperada (los ID de clave serán distintos; cada ID tiene 20 caracteres):
```text
AKIAIOSFODNN7EXAMPLE Active
2
```
Bob tiene ahora dos claves activas. Ambas funcionan, así que puedes pasar sus aplicaciones a la nueva (`keys/bob`) a tu ritmo:
```bash
use bob; aws sts get-caller-identity --query Arn --output text
use bob.old; aws sts get-caller-identity --query Arn --output text
```
Salida esperada:
```text
arn:aws:iam::123456789012:user/bob
arn:aws:iam::123456789012:user/bob
```
Cuando nada use ya la clave antigua, bórrala y confirma que solo funciona la nueva:
```bash
use admin
aws iam delete-access-key --user-name bob --access-key-id "$OLDKEY"
aws iam list-access-keys --user-name bob --query 'length(AccessKeyMetadata)'
use bob.old; aws sts get-caller-identity
use bob; aws sts get-caller-identity --query Arn --output text
```
Salida esperada:
```text
1
aws: [ERROR]: An error occurred (InvalidClientTokenId) when calling the GetCallerIdentity operation: The security token included in the request is invalid.
arn:aws:iam::123456789012:user/bob
```
La clave antigua falla en la **autenticación**, exactamente igual que la clave ficticia del Paso 4.
> [!NOTE]
> En una nube real puedes poner antes una clave en `Inactive` (`aws iam update-access-key --status Inactive`) y esperar unos días para ver qué se rompe antes de borrarla. Moto no aplica la desactivación, así que el laboratorio pasa directamente a borrar.
### Paso 12 — Revisa: ¿quién existe y cuándo se usaron las claves?
Una revisión de accesos periódica empieza con un inventario. Lista los usuarios, cuenta sus claves y comprueba cuándo se usó una clave por última vez y para qué servicio. Las claves que nadie ha usado en meses son candidatas a borrarse.
```bash
use admin
aws iam list-users --query 'Users[].UserName' --output text
for u in admin bob carol dave; do echo -n "$u keys: "; aws iam list-access-keys --user-name $u --query 'length(AccessKeyMetadata)'; done
aws iam get-access-key-last-used --access-key-id "$(cut -f1 keys/bob)"
```
Salida esperada (la fecha y el orden serán distintos):
```text
admin bob dave carol
admin keys: 1
bob keys: 1
carol keys: 1
dave keys: 1
{
"UserName": "bob",
"AccessKeyLastUsed": {
"LastUsedDate": "2026-11-07T18:59:40.119388+00:00",
"ServiceName": "sts",
"Region": "us-east-1"
}
}
```
En una nube real, aquí abrirías también el registro de auditoría (por ejemplo CloudTrail) y mirarías las llamadas hechas con cada identidad.
## Verificación
Ejecuta esta comprobación. Prueba cada solicitud y compara el resultado (`allowed` o `denied`) con lo que deberían producir las políticas. Cada línea debe empezar por `PASS`.
```bash
check() { local want=$1 label=$2; shift 2; if "$@" >/dev/null 2>&1; then got=allowed; else got=denied; fi; if [ "$got" = "$want" ]; then echo "PASS $label"; else echo "FAIL $label (got $got)"; fi; }
use bob
check allowed "bob: read reports/q3.txt" aws s3api get-object --bucket lab-data --key reports/q3.txt /dev/null
check allowed "bob: write reports/q5.txt" aws s3api put-object --bucket lab-data --key reports/q5.txt --body q4.txt
check denied "bob: write secret/q5.txt" aws s3api put-object --bucket lab-data --key secret/q5.txt --body q4.txt
check denied "bob: delete reports/q5.txt" aws s3api delete-object --bucket lab-data --key reports/q5.txt
check denied "bob: list all buckets" aws s3api list-buckets
use dave
check allowed "dave: read reports/q3.txt" aws s3api get-object --bucket lab-data --key reports/q3.txt /dev/null
check denied "dave: write reports/d.txt" aws s3api put-object --bucket lab-data --key reports/d.txt --body q4.txt
use carol
check denied "carol: read reports/q3.txt directly" aws s3api get-object --bucket lab-data --key reports/q3.txt /dev/null
read -r AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN < <(aws sts assume-role --role-arn arn:aws:iam::123456789012:role/reader --role-session-name carol-verify --query 'Credentials.[AccessKeyId,SecretAccessKey,SessionToken]' --output text)
export AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN
check allowed "carol as reader: read reports/q3.txt" aws s3api get-object --bucket lab-data --key reports/q3.txt /dev/null
check denied "carol as reader: write reports/c.txt" aws s3api put-object --bucket lab-data --key reports/c.txt --body q4.txt
use bob.old
check denied "bob's old key: any call" aws sts get-caller-identity
```
Salida esperada:
```text
PASS bob: read reports/q3.txt
PASS bob: write reports/q5.txt
PASS bob: write secret/q5.txt
PASS bob: delete reports/q5.txt
PASS bob: list all buckets
PASS dave: read reports/q3.txt
PASS dave: write reports/d.txt
PASS carol: read reports/q3.txt directly
PASS carol as reader: read reports/q3.txt
PASS carol as reader: write reports/c.txt
PASS bob's old key: any call
```
Una comprobación `denied` pasa ante cualquier fallo, así que mira también a mano una denegación (Paso 7) y confirma que dice `AccessDenied`, no un error de conexión.
## Resolución de problemas
| Síntoma | Causa probable | Solución |
|---|---|---|
| `Could not connect to the endpoint URL: "http://127.0.0.1:9100/"` | El contenedor del servidor no se está ejecutando, o el puerto 9100 lo ocupa otra cosa. | `podman ps -a --filter name=lab-iam-` y `podman logs lab-iam-moto`. Si el puerto está ocupado, detén el otro programa. Si tuviste que empezar de nuevo, rehaz los pasos 3 a 12. |
| `InvalidClientTokenId` en un comando que debería funcionar | La terminal usa la clave equivocada: la clave ficticia `test` tras las tres llamadas gratuitas, una clave borrada, o una shell que nunca ejecutó `use`. | Ejecuta `use <nombre>` y comprueba con `aws sts get-caller-identity`. Si el orden del arranque salió mal, ejecuta `podman rm -f lab-iam-moto`, repite el Paso 1 y haz los pasos 3 a 5 en orden. |
| `Unable to locate credentials` (`NoCredentials`) | Una terminal nueva sin las funciones auxiliares ni las credenciales. | `cd ~/iam-lab && source lab.sh && use admin`. |
| `Unable to load paramfile file://...: Permission denied` | SELinux bloquea la carpeta montada, o la función `aws` se copió sin `:Z`. | Comprueba que la opción `-v "$PWD:/work:Z"` está intacta, y que ejecutas desde `~/iam-lab`. |
| `AccessDenied` en una solicitud que esperabas que funcionara | La política no coincide con la acción o el recurso, normalmente por el ARN del bucket frente al del objeto, o por una política en línea antigua. | `aws iam get-user-policy --user-name bob --policy-name reports-rw` como admin, y compara la acción y el ARN con la solicitud. |
| `MalformedPolicyDocument: Syntax errors in policy` | JSON no válido en el archivo de política: falta una coma, unas comillas o una llave. | Revisa el archivo, por ejemplo con `python3 -m json.tool bob-policy.json`. |
| `Unknown options` o un error de análisis con `--query` y `--output text` | Un `--query` que devuelve un objeto, en lugar de una lista o una cadena, puede fallar en modo texto. | Usa `--output json`, o una consulta que devuelva una lista (`[...]`) o un único valor. |
## Reto (opcional)
Crea un usuario `erin` que pueda *solo* leer objetos bajo `reports/2026/` y no tenga forma de listar ni leer nada más. Después escribe la política que además le exigiría MFA, y explica por qué puedes escribirla pero no probarla en este laboratorio. Por último, crea un rol `uploader` que carol pueda asumir para subir objetos a `reports/` pero nunca para borrarlos, y demuéstralo con los comandos del Paso 10.
## Limpieza
Detén y elimina el contenedor del servidor, y borra la carpeta del laboratorio. La carpeta contiene las claves, las políticas y los archivos descargados del laboratorio; el emulador guarda sus datos solo en memoria, así que eliminar el contenedor elimina todos los usuarios, políticas y objetos.
```bash
unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN
podman rm -f lab-iam-moto
cd ~ && rm -r ~/iam-lab
```
Salida esperada:
```text
lab-iam-moto
```
Las dos imágenes se quedan en tu almacenamiento local para que una segunda ejecución arranque al instante. Para liberar el espacio en disco (unos 900 MB), elimínalas también. Si piensas hacer el laboratorio de almacenamiento que usa la misma imagen del emulador, conserva la imagen de Moto:
```bash
podman rmi docker.io/amazon/aws-cli:2.38.0 docker.io/motoserver/moto:5.2.4
```
Comprueba que no queda nada:
```bash
podman ps -a --filter name=lab-iam-
ls ~/iam-lab
```
El primer comando debería imprimir solo su línea de encabezado, y el segundo debería decir que la carpeta no existe. Las funciones `aws` y `use` desaparecen al cerrar la terminal.
## Qué has aprendido
- La autenticación y la autorización fallan de forma distinta: una clave desconocida o borrada da `InvalidClientTokenId`, una identidad conocida sin un `Allow` coincidente da `AccessDenied`.
- Todo se deniega salvo que una política lo permita (denegación por defecto), y `ListBucket` (ARN del bucket) y `GetObject` (ARN del objeto) necesitan recursos distintos.
- Un allow amplio puede limitarse con un `Deny` explícito, y el deny siempre gana.
- Una política administrada asociada a un grupo da a todos los miembros los mismos permisos desde un único lugar.
- `AssumeRole` cambia la identidad de un usuario por la de un rol: claves `ASIA` con un token de sesión, solo los permisos del rol y un nombre de sesión que queda en la pista de auditoría.
- Rotar una clave es seguro porque un usuario puede tener dos claves: crear, cambiar, comprobar, borrar.
- Un emulador es una buena forma de aprender el modelo, pero no reproduce todo (condiciones, desactivación y caducidad), así que prueba eso en una nube real.