---
title: "Laboratorio: utenti, policy e credenziali temporanee"
domain: cloud-computing
level: intermediate
duration: "75 min"
cost: "gratuito"
environment: "container (Podman rootless su Linux): un emulatore IAM locale compatibile con AWS e l'AWS CLI; nessun account cloud"
lang: it
source_hash: 4cba876c4328
---

# Laboratorio: utenti, policy e credenziali temporanee

## Obiettivo
Costruisci sul tuo computer una piccola configurazione IAM del cloud: crea utenti con una policy a privilegio minimo, osserva all'opera il rifiuto predefinito e il deny esplicito, riutilizza una policy gestita tramite un gruppo, fornisci a un utente credenziali temporanee assumendo un ruolo e ruota una chiave di accesso. Tutto viene eseguito su un emulatore locale, quindi non puoi danneggiare nulla di reale né spendere un centesimo.

## Obiettivi
- Autenticarsi come principal diversi e distinguere un errore di autenticazione da un errore di autorizzazione.
- Scrivere una policy JSON a privilegio minimo e verificare una richiesta consentita e una negata per ogni istruzione.
- Dimostrare che un deny esplicito prevale su un allow.
- Riutilizzare i permessi tramite una policy gestita associata a un gruppo.
- Assumere un ruolo per ottenere credenziali temporanee (chiave ASIA e token di sessione) e confrontare identità e permessi prima e dopo.
- Ruotare una chiave di accesso senza interrompere l'accesso e rivedere le chiavi con il loro ultimo utilizzo.

## Prerequisiti
- Podman 4 o successivo su Linux, rootless, senza `sudo` (testato con Podman 5.8). Docker funziona se nei comandi sostituisci `podman` con `docker`.
- Immagini scaricate al primo utilizzo (circa 900 MB di spazio su disco in totale): `docker.io/motoserver/moto:5.2.4` (il server) e `docker.io/amazon/aws-cli:2.38.0` (il client).
- Porta TCP `9100` libera su `127.0.0.1`.
- Nessun account cloud, nessuna carta di credito e nessun accesso a Internet dopo il download delle immagini.
- [La lezione IAM cloud](lesson.it.md) di questo modulo.

> [!WARNING]
> Il laboratorio è gratuito e locale. Il server è in ascolto solo su `127.0.0.1`. Le "chiavi" che crei sono stringhe casuali per un emulatore e non significano nulla altrove; il laboratorio le salva in file di testo semplice per mantenere brevi i passaggi, cosa che **non** devi mai fare con credenziali reali. Le modifiche restano all'interno di una cartella (`~/iam-lab`), di un container e, facoltativamente, di due immagini, tutti rimossi alla fine.

> [!NOTE]
> **Perché API compatibili con AWS?** Il laboratorio usa le API IAM, STS e S3 di AWS perché sono lo standard di fatto: la maggior parte dei tutorial, degli strumenti, dei moduli Terraform e dei servizi di storage compatibili con S3 di altri provider le comprende, e gli emulatori open source permettono di esercitarsi gratuitamente. Gli altri provider differiscono per sintassi e vocabolario (OpenStack Keystone con utenti, progetti e token; le assegnazioni di ruolo di Azure a un determinato ambito; i ruoli di Google Cloud associati a membri su una risorsa) ma condividono i concetti che qui metti in pratica: principal, rifiuto predefinito, privilegio minimo e credenziali temporanee.

> [!NOTE]
> **Limiti dell'emulatore.** [Moto](https://docs.getmoto.org/) è un emulatore, non il cloud reale, e implementa solo una parte di IAM. In questa configurazione (Moto 5.2.4), `Allow` e `Deny` su azioni e risorse vengono applicati per IAM, STS e S3, che è ciò che serve al laboratorio. Questi comportamenti del cloud reale **non** sono riprodotti, quindi non aspettarti di osservarli e non farvi affidamento: i blocchi `Condition` vengono ignorati (una condizione su MFA o IP risulta sempre soddisfatta); la disattivazione di una chiave di accesso non la blocca; la scadenza delle credenziali temporanee non viene verificata; `iam simulate-principal-policy` fallisce con un errore del server; e gli URL prefirmati e le richieste anonime falliscono con un errore del server quando l'autenticazione è obbligatoria. In un cloud reale, tutto questo funziona.

## Architettura
![Architettura del laboratorio. Sul tuo computer Linux con Podman rootless, un terminale esegue le funzioni di shell di lab.sh nella cartella ~/iam-lab, che contiene anche i file JSON delle policy e una cartella keys con chiavi usate solo nel laboratorio. Ogni comando aws esegue il container dell'AWS CLI v2, immagine amazon/aws-cli:2.38.0, avviato con run --rm, con ~/iam-lab montata in /work. La CLI invia richieste HTTP firmate a 127.0.0.1 porta 9100, mappata sulla porta 5000 del container lab-iam-moto che esegue Moto 5.2.4, un emulatore delle API di AWS che applica l'autenticazione dopo le prime 3 chiamate. Moto mantiene il proprio stato in memoria: gli utenti admin, bob, carol e dave, il gruppo analysts, il ruolo reader, la policy gestita reports-reader e il bucket lab-data](../../../assets/diagrams/iam-lab-architecture.it.svg)

*Figura 1. Ogni comando `aws` è un container client di breve durata che invia richieste firmate all'emulatore su `127.0.0.1:9100`; l'emulatore mantiene in memoria utenti, policy e dati.*

## Passaggi

### Passo 1 — Crea la cartella di lavoro e avvia l'emulatore
Tutti i file stanno in una sola cartella, così la pulizia è semplice. Il container del server ha un nome che inizia con `lab-iam-`, e `INITIAL_NO_AUTH_ACTION_COUNT=3` indica a Moto di accettare le sue prime tre chiamate API senza autenticazione. Ti serve proprio questo per avviare il primo amministratore, perché nessuno può firmare una richiesta finché non esistono un utente e una chiave. Dopo la terza chiamata, ogni richiesta deve essere firmata da una chiave nota e viene verificata rispetto alle policy.

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

Output atteso (un ID di container; il tuo sarà diverso):
```text
f97527afd13808739cf9b751e2d21b95469f2837c6cbb991e688d8f806244295
```

> [!IMPORTANT]
> Le tre chiamate gratuite sono un contatore sul server: esegui esattamente i Passi da 3 a 5 nell'ordine indicato e non eseguire altri comandi `aws` prima di essi. Se sbagli l'ordine, rimuovi il container e ricomincia: `podman rm -f lab-iam-moto`, poi ripeti questo passo. (Un comando che fallisce sul tuo lato prima di raggiungere il server, per esempio per un errore di battitura in un nome di file, non consuma una chiamata.)

### Passo 2 — Definisci le funzioni di supporto
Crea un piccolo file con tre funzioni di shell e caricalo. È l'unico "strumento" del laboratorio. Leggilo una volta: è breve.

- `aws` esegue il container dell'AWS CLI v2 e lo punta all'emulatore. Passa le tue credenziali tramite variabili d'ambiente, monta la cartella corrente in `/work` in modo che `file://policy.json` funzioni (`:Z` riassegna l'etichetta della cartella per gli host SELinux come Fedora) e usa una regione fissa.
- `use <name>` porta il tuo terminale sull'identità la cui chiave è salvata in `keys/<name>`.
- `newkey <user>` crea una chiave di accesso per un utente e la salva in `keys/<user>`.

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

Il primo comando `aws` scarica l'immagine della CLI (circa 470 MB), quindi richiede un po' di tempo, una sola volta. Esegui `source ~/iam-lab/lab.sh` in ogni nuovo terminale, da `~/iam-lab`.

### Passo 3 — Avvia l'amministratore (chiamate gratuite da 1 a 3)
L'emulatore non verifica le credenziali delle prime tre chiamate, ma la CLI ne pretende comunque qualcuna, quindi usi la coppia fittizia `test` / `test`. Crei un utente `admin`, gli assegni una policy che consente tutto e crei la sua chiave di accesso. Il file della policy ha la struttura che hai visto nella lezione: una versione e una sola istruzione.

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

Output atteso (l'ID utente e la data variano; `put-user-policy` e `newkey` non stampano nulla):
```text
{
    "User": {
        "Path": "/",
        "UserName": "admin",
        "UserId": "c2ndbofy683n3gu2ii3r",
        "Arn": "arn:aws:iam::123456789012:user/admin",
        "CreateDate": "2026-11-07T18:58:03.515092+00:00"
    }
}
```

L'account `123456789012` è l'ID di account fisso usato da Moto. Quella policy ampia è solo per questo amministratore del laboratorio: nella lezione hai visto perché `*` su `*` è pericoloso nella vita reale.

### Passo 4 — Accedi come admin e osserva un errore di autenticazione
Passa alla chiave che hai appena salvato. D'ora in poi ogni richiesta è firmata e verificata.

```bash
use admin
aws sts get-caller-identity
aws iam list-users --query 'Users[].UserName'
```

Output atteso (l'ID utente varia):
```text
{
    "UserId": "c2ndbofy683n3gu2ii3r",
    "Account": "123456789012",
    "Arn": "arn:aws:iam::123456789012:user/admin"
}
[
    "admin"
]
```

`get-caller-identity` è la risposta del cloud a "chi sono?" e funziona per qualsiasi identità valida senza permessi aggiuntivi. Eseguilo ogni volta che ti chiedi quale identità stia usando il tuo terminale. Ora riprova con la chiave fittizia, che non è più un'identità nota:

```bash
AWS_ACCESS_KEY_ID=test AWS_SECRET_ACCESS_KEY=test aws iam list-users
```

Output atteso:
```text
aws: [ERROR]: An error occurred (InvalidClientTokenId) when calling the ListUsers operation: The security token included in the request is invalid.
```

Questo è un errore di **autenticazione**: il server non sa chi sei. Tienilo a mente: nei passi successivi vedrai `AccessDenied`, che è un problema diverso.

### Passo 5 — Crea un bucket con due cartelle
Ti serve qualcosa da proteggere. Come admin, crea il bucket `lab-data` e carica un "report" innocuo e un "segreto". Entrambi sono testi inventati.

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

Output atteso (gli orari variano):
```text
{
    "Location": "/lab-data"
}
2026-11-07 18:58:18         22 reports/q3.txt
2026-11-07 18:58:19         34 secret/passwords.txt
```

### Passo 6 — Crea bob con una policy a privilegio minimo
Bob è un analista che deve leggere e scrivere i report e nient'altro. La policy ha due istruzioni, scritte come nella lezione: `ListBucket` si applica all'ARN del bucket, mentre `GetObject` e `PutObject` si applicano agli oggetti sotto `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
```

Output atteso:
```text
"arn:aws:iam::123456789012:user/bob"
```

`put-user-policy` crea una **policy inline**: risiede all'interno dell'utente e ha un nome (`reports-rw`). L'altro tipo, una policy gestita, lo incontrerai nel Passo 9.

### Passo 7 — Verifica che cosa Bob può e non può fare
Agisci come Bob e prova otto richieste. Per ciascuna, prevedi la risposta prima di eseguirla: a decidere è la policy, non la fortuna.

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

Output atteso (l'ETag varia):
```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
```

Le richieste da 1 a 3 corrispondono a un `Allow`. Le richieste 4 e 5 riguardano `secret/`, che nessuna istruzione consente. La richiesta 6 richiede `s3:ListAllMyBuckets`, che Bob non ha. La richiesta 7, `DeleteObject`, non è nell'elenco delle azioni consentite. Tutti questi casi sono il **rifiuto predefinito**: nessuna policy ha detto "no", semplicemente non c'è alcun "sì". Nota che ogni rifiuto è `AccessDenied`, non `InvalidClientTokenId`: Bob si è autenticato senza problemi.

### Passo 8 — Rendi la policy troppo ampia, poi aggiungi un deny esplicito
Supponi che qualcuno "semplifichi" la policy di Bob con `s3:*` su `reports/*`. Poi limiti il danno con un deny esplicito sull'eliminazione. Le modifiche alle policy sono un compito da amministratore, quindi passa ad admin e poi torna indietro.

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

Output atteso:
```text
delete succeeded
"\"c32c8500d318ac0878b49cc441b6b837\""
```

Salvare una policy con lo stesso nome sostituisce quella precedente. Bob ora può eliminare: l'allow più ampio copre `DeleteObject`. Hai ricaricato `q4.txt` per poter eseguire il passo successivo. Ora aggiungi alla policy una terza istruzione, un deny esplicito:

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

Output atteso:
```text

aws: [ERROR]: An error occurred (AccessDenied) when calling the DeleteObject operation: Access Denied
16
[
    "reports/q3.txt",
    "reports/q4.txt",
    "secret/passwords.txt"
]
```

L'allow `s3:*` corrisponde ancora a `DeleteObject`, ma il `Deny` esplicito vince: l'eliminazione fallisce e l'oggetto è ancora lì (16 byte). Nota anche l'ultimo risultato: Bob può *elencare* l'intero bucket, incluso il nome `secret/passwords.txt`, perché `ListBucket` è stato consentito sull'ARN del bucket senza alcun limite di prefisso. Non può leggere il file, ma scopre che esiste. In un cloud reale si restringe questo aspetto con una `Condition` sul prefisso della chiave; l'emulatore ignora le condizioni, quindi qui non puoi provarlo.

### Passo 9 — Riutilizza i permessi con una policy gestita e un gruppo
Le policy inline vengono copiate per ogni utente. Una **policy gestita** è un documento con nome e riutilizzabile, che crei una volta e associ a molti utenti, gruppi o ruoli. Crea una policy di sola lettura, associala a un gruppo `analysts` e aggiungi al gruppo un nuovo utente, dave. Dave ottiene i suoi permessi dal gruppo e non ha alcuna policy propria.

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

Output atteso:
```text
"arn:aws:iam::123456789012:policy/reports-reader"
"arn:aws:iam::123456789012:group/analysts"
"arn:aws:iam::123456789012:user/dave"
[
    "analysts"
]
```

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

Output atteso:
```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 può leggere i report perché il suo gruppo ha la policy gestita; non può scrivere né leggere il segreto. Aggiungere il prossimo analista richiede una sola chiamata `add-user-to-group`, e cambiare ciò che gli analisti possono fare significa modificare una sola policy. Questo è l'RBAC nella pratica.

### Passo 10 — Assumi un ruolo per ottenere credenziali temporanee
Carol ha bisogno di accedere in lettura ai report solo di tanto in tanto. Invece di un permesso permanente, crei un **ruolo** `reader` che lei può assumere. Il ruolo ha una **trust policy** (chi può assumerlo) e una **policy dei permessi** (che cosa può fare; riutilizzi `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
```

Output atteso:
```text
"arn:aws:iam::123456789012:user/carol"
"arn:aws:iam::123456789012:role/reader"
```

> [!NOTE]
> L'ultima policy consente a Carol di chiamare `sts:AssumeRole` su questo solo ruolo. L'AWS reale accetta da sola una trust policy che indica un utente nello stesso account, senza di essa; l'emulatore le richiede entrambe, quindi la aggiungi qui. Molti team la aggiungono comunque, in modo che il permesso sia visibile sull'utente.

Ora agisci come Carol. Per prima cosa prova a leggere direttamente un report: lei non ha alcun permesso proprio. Poi assumi il ruolo. La riga `read` prende i tre valori temporanei (ID della chiave, segreto, token di sessione) dalla risposta e li inserisce in variabili d'ambiente.

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

Output atteso (l'ID utente e la lunghezza del token variano):
```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 chiave ora inizia con `ASIA`, il prefisso delle credenziali temporanee (le chiavi di lunga durata iniziano con `AKIA`), e il token di sessione fa parte di ogni richiesta. Confronta identità e permessi:

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

Output atteso:
```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 ora è `assumed-role/reader/carol-lab`: si applicano i permessi del ruolo (leggere i report, nient'altro), e i suoi sono sospesi. Il nome di sessione `carol-lab` comparirebbe nei log di audit, quindi puoi comunque stabilire chi ha agito. Queste credenziali sono state richieste per 900 secondi (15 minuti) e smetterebbero di funzionare allo scadere; l'emulatore non applica la scadenza (vedi la nota sull'emulatore), ma un cloud reale sì. Torna all'identità personale di Carol: `use` cancella il token di sessione.

```bash
use carol
aws sts get-caller-identity --query Arn --output text
```

Output atteso:
```text
arn:aws:iam::123456789012:user/carol
```

### Passo 11 — Ruota una chiave di accesso
Le chiavi di lunga durata vanno sostituite con regolarità, senza interruzioni del servizio. L'ordine sicuro è: crea la seconda chiave, sposta l'applicazione sulla nuova, verifica che la vecchia chiave non sia più usata ed elimina la vecchia. Un utente può avere due chiavi alla volta, ed è ciò che lo rende possibile. Ruota la chiave di 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)'
```

Output atteso (gli ID delle chiavi variano; ogni ID è di 20 caratteri):
```text
AKIAIOSFODNN7EXAMPLE	Active
2
```

Bob ora ha due chiavi attive. Funzionano entrambe, quindi puoi spostare le sue applicazioni sulla nuova (`keys/bob`) con i tuoi tempi:

```bash
use bob;     aws sts get-caller-identity --query Arn --output text
use bob.old; aws sts get-caller-identity --query Arn --output text
```

Output atteso:
```text
arn:aws:iam::123456789012:user/bob
arn:aws:iam::123456789012:user/bob
```

Quando nulla usa più la vecchia chiave, eliminala e verifica che funzioni solo la nuova:

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

Output atteso:
```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 vecchia chiave fallisce all'**autenticazione**, esattamente come la chiave fittizia nel Passo 4.

> [!NOTE]
> In un cloud reale puoi anche impostare prima una chiave su `Inactive` (`aws iam update-access-key --status Inactive`) e attendere qualche giorno per vedere che cosa smette di funzionare prima di eliminarla. Moto non applica la disattivazione, quindi il laboratorio passa direttamente all'eliminazione.

### Passo 12 — Revisione: chi esiste e quando sono state usate le chiavi?
Una revisione periodica degli accessi inizia con un inventario. Elenca gli utenti, conta le loro chiavi e controlla quando una chiave è stata usata l'ultima volta e per quale servizio. Le chiavi che nessuno usa da mesi sono candidate all'eliminazione.

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

Output atteso (la data e l'ordine variano):
```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"
    }
}
```

In un cloud reale, qui apriresti anche il log di audit (per esempio CloudTrail) ed esamineresti le chiamate effettuate con ciascuna identità.

## Verifica
Esegui questo controllo. Prova ogni richiesta e confronta il risultato (`allowed` o `denied`) con quello che le policy dovrebbero produrre. Ogni riga deve iniziare con `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
```

Output atteso:
```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
```

Un controllo `denied` viene superato con qualsiasi errore, quindi osserva anche manualmente un rifiuto (Passo 7) e verifica che riporti `AccessDenied`, non un errore di connessione.

## Risoluzione dei problemi
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| `Could not connect to the endpoint URL: "http://127.0.0.1:9100/"` | Il container del server non è in esecuzione, oppure la porta 9100 è occupata da qualcos'altro. | `podman ps -a --filter name=lab-iam-` e `podman logs lab-iam-moto`. Se la porta è occupata, arresta l'altro programma. Se hai dovuto ricominciare, ripeti i Passi da 3 a 12. |
| `InvalidClientTokenId` su un comando che dovrebbe funzionare | Il terminale usa la chiave sbagliata: la chiave fittizia `test` dopo le tre chiamate gratuite, una chiave eliminata, o una shell in cui non è mai stato eseguito `use`. | Esegui `use <name>` e verifica con `aws sts get-caller-identity`. Se l'ordine dell'avvio iniziale è stato sbagliato, esegui `podman rm -f lab-iam-moto`, ripeti il Passo 1 ed esegui i Passi da 3 a 5 nell'ordine. |
| `Unable to locate credentials` (`NoCredentials`) | Un nuovo terminale senza le funzioni di supporto o le credenziali. | `cd ~/iam-lab && source lab.sh && use admin`. |
| `Unable to load paramfile file://...: Permission denied` | SELinux blocca la cartella montata, oppure la funzione `aws` è stata copiata senza `:Z`. | Verifica che l'opzione `-v "$PWD:/work:Z"` sia intatta e che tu esegua i comandi da `~/iam-lab`. |
| `AccessDenied` per una richiesta che ti aspettavi funzionasse | La policy non corrisponde all'azione o alla risorsa, di solito per l'ARN del bucket rispetto a quello dell'oggetto, oppure per una vecchia policy inline. | `aws iam get-user-policy --user-name bob --policy-name reports-rw` come admin, e confronta l'azione e l'ARN con la richiesta. |
| `MalformedPolicyDocument: Syntax errors in policy` | JSON non valido nel file della policy: una virgola, un apice o una parentesi graffa mancanti. | Controlla il file, per esempio con `python3 -m json.tool bob-policy.json`. |
| `Unknown options` o un errore di analisi con `--query` e `--output text` | Una `--query` che restituisce un oggetto, e non un elenco o una stringa, può fallire in modalità testo. | Usa `--output json`, oppure una query che restituisca un elenco (`[...]`) o un singolo valore. |

## Sfida (facoltativa)
Crea un utente `erin` che possa *solo* leggere gli oggetti sotto `reports/2026/` e non abbia alcun modo di elencare o leggere nient'altro. Poi scrivi la policy che richiederebbe anche la MFA per lei, e spiega perché puoi scriverla ma non verificarla in questo laboratorio. Infine, crea un ruolo `uploader` che carol possa assumere per caricare oggetti in `reports/` ma mai per eliminarli, e dimostralo con i comandi del Passo 10.

## Pulizia
Arresta e rimuovi il container del server ed elimina la cartella del laboratorio. La cartella contiene le chiavi, le policy e i file scaricati del laboratorio; l'emulatore mantiene i propri dati solo in memoria, quindi rimuovere il container elimina ogni utente, policy e oggetto.

```bash
unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN
podman rm -f lab-iam-moto
cd ~ && rm -r ~/iam-lab
```

Output atteso:
```text
lab-iam-moto
```

Le due immagini restano nell'archivio locale, così una seconda esecuzione parte subito. Per liberare lo spazio su disco (circa 900 MB), rimuovi anche quelle. Se intendi svolgere il laboratorio sullo storage che usa la stessa immagine dell'emulatore, conserva l'immagine di Moto:

```bash
podman rmi docker.io/amazon/aws-cli:2.38.0 docker.io/motoserver/moto:5.2.4
```

Verifica che non sia rimasto nulla:

```bash
podman ps -a --filter name=lab-iam-
ls ~/iam-lab
```

Il primo comando dovrebbe stampare solo la riga di intestazione, e il secondo dovrebbe segnalare che la cartella non esiste. Le funzioni `aws` e `use` scompaiono quando chiudi il terminale.

## Cosa hai imparato
- Autenticazione e autorizzazione falliscono in modo diverso: una chiave sconosciuta o eliminata genera `InvalidClientTokenId`, un'identità nota senza un `Allow` corrispondente genera `AccessDenied`.
- Tutto è negato a meno che una policy non lo consenta (rifiuto predefinito), e `ListBucket` (ARN del bucket) e `GetObject` (ARN dell'oggetto) richiedono risorse diverse.
- Un allow ampio può essere limitato da un `Deny` esplicito, e il deny vince sempre.
- Una policy gestita associata a un gruppo dà a ogni membro gli stessi permessi da un unico punto.
- `AssumeRole` scambia l'identità di un utente con quella di un ruolo: chiavi `ASIA` con un token di sessione, solo i permessi del ruolo e un nome di sessione che resta nella traccia di audit.
- La rotazione delle chiavi è sicura perché un utente può possedere due chiavi: crea, sposta, verifica, elimina.
- Un emulatore è un buon modo per imparare il modello, ma non riproduce tutto (condizioni, disattivazione e scadenza), quindi verifica questi aspetti su un cloud reale.
