Affichage du Markdown brut : le moteur de rendu n'a pas pu être chargé.
## Objectif
Construisez une petite configuration IAM cloud sur votre propre ordinateur : créez des utilisateurs avec une politique de moindre privilège, observez le refus par défaut et le refus explicite à l'œuvre, réutilisez une politique gérée par l'intermédiaire d'un groupe, donnez à un utilisateur des identifiants temporaires en endossant un rôle, et renouvelez une clé d'accès. Tout s'exécute sur un émulateur local : vous ne pouvez donc rien casser de réel ni dépenser un centime.
## Objectifs
- S'authentifier comme différents principaux et distinguer un échec d'authentification d'un échec d'autorisation.
- Écrire une politique JSON de moindre privilège et tester une requête autorisée et une requête refusée pour chaque instruction.
- Montrer qu'un refus explicite l'emporte sur une autorisation.
- Réutiliser des permissions grâce à une politique gérée attachée à un groupe.
- Endosser un rôle pour obtenir des identifiants temporaires (clé ASIA et jeton de session) et comparer l'identité et les permissions avant et après.
- Renouveler une clé d'accès sans interrompre l'accès, et passer en revue les clés avec leur dernière utilisation.
## Prérequis
- Podman 4 ou version ultérieure sur Linux, sans privilèges root, sans `sudo` (testé avec Podman 5.8). Docker fonctionne si vous remplacez `podman` par `docker` dans les commandes.
- Images téléchargées à la première utilisation (environ 900 Mo d'espace disque au total) : `docker.io/motoserver/moto:5.2.4` (le serveur) et `docker.io/amazon/aws-cli:2.38.0` (le client).
- Port TCP `9100` libre sur `127.0.0.1`.
- Aucun compte cloud, aucune carte bancaire, et aucun accès à Internet une fois les images téléchargées.
- [La leçon IAM cloud](lesson.fr.md) de ce module.
> [!WARNING]
> Le lab est gratuit et local. Le serveur n'écoute que sur `127.0.0.1`. Les « clés » que vous créez sont des chaînes aléatoires pour un émulateur et n'ont aucune signification ailleurs ; le lab les enregistre dans des fichiers en clair pour garder les étapes courtes, ce que vous ne devez **jamais** faire avec de vrais identifiants. Les modifications restent dans un seul dossier (`~/iam-lab`), un conteneur et, facultativement, deux images, tous supprimés à la fin.
> [!NOTE]
> **Pourquoi des API compatibles AWS ?** Le lab utilise les API AWS IAM, STS et S3 parce qu'elles sont le standard de fait : la plupart des tutoriels, des outils, des modules Terraform et des services de stockage compatibles S3 chez d'autres fournisseurs les comprennent, et des émulateurs open source permettent de s'exercer gratuitement. Les autres fournisseurs diffèrent par la syntaxe et le vocabulaire (OpenStack Keystone avec des utilisateurs, des projets et des jetons ; Azure avec des attributions de rôles à une portée ; Google Cloud avec des rôles associés à des membres sur une ressource) mais partagent les concepts que vous pratiquez ici : principaux, refus par défaut, moindre privilège et identifiants temporaires.
> [!NOTE]
> **Limites de l'émulateur.** [Moto](https://docs.getmoto.org/) est un émulateur, pas le vrai cloud, et il n'implémente qu'une partie d'IAM. Dans cette configuration (Moto 5.2.4), `Allow` et `Deny` sur les actions et les ressources sont appliqués pour IAM, STS et S3, ce dont le lab a besoin. Ces comportements du vrai cloud ne sont **pas** reproduits (ne vous y attendez pas et ne vous y fiez pas) : les blocs `Condition` sont ignorés (une condition MFA ou IP « passe » toujours) ; la désactivation d'une clé d'accès ne la bloque pas ; l'expiration des identifiants temporaires n'est pas vérifiée ; `iam simulate-principal-policy` échoue avec une erreur de serveur ; et les URL présignées et les requêtes anonymes échouent avec une erreur de serveur quand l'authentification est appliquée. Sur un vrai cloud, tout cela fonctionne.
## Architecture
<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-fr-title iam-lab-architecture-fr-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="fr">
<title id="iam-lab-architecture-fr-title">Architecture du lab : conteneur AWS CLI dialoguant avec un émulateur IAM Moto local</title>
<desc id="iam-lab-architecture-fr-desc">Sur votre ordinateur Linux avec Podman sans root, un terminal exécute les fonctions shell de lab.sh dans le dossier ~/iam-lab, qui contient aussi les fichiers JSON de politiques et un dossier keys avec des clés réservées au lab. Chaque commande aws lance le conteneur AWS CLI v2, image amazon/aws-cli:2.38.0, démarré avec run --rm, avec ~/iam-lab monté sur /work. La CLI envoie des requêtes HTTP signées à 127.0.0.1 port 9100, redirigé vers le port 5000 du conteneur lab-iam-moto, qui exécute Moto 5.2.4, un émulateur d'API AWS qui impose l'authentification après les 3 premiers appels. Moto garde son état en mémoire : les utilisateurs admin, bob, carol et dave, le groupe analysts, le rôle reader, la politique gérée reports-reader et le 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">Votre ordinateur : Linux avec Podman sans 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">fonctions 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 (fonctions)</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/ (clés du lab seulement)</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 (politiques)</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">monte ~/iam-lab sur /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">émulateur d'API AWS :5000</text>
<text x="774" y="188" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">auth exigée après 3 appels</text>
<text x="760" y="226" font-size="11" class="dg-muted" fill="#5c5c68" font-weight="700" letter-spacing="1.2">ÉTAT EN MÉMOIRE</text>
<g class="dg-l1"><rect class="dg-solid" x="758" y="240" width="103" height="26" rx="13" fill="#0369a1"/><text x="809.5" y="257.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">util. admin</text></g>
<g class="dg-l1"><rect class="dg-solid" x="867" y="240" width="89" height="26" rx="13" fill="#0369a1"/><text x="911.5" y="257.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">util. bob</text></g>
<g class="dg-l1"><rect class="dg-solid" x="758" y="272" width="103" height="26" rx="13" fill="#0369a1"/><text x="809.5" y="289.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">util. carol</text></g>
<g class="dg-l1"><rect class="dg-solid" x="867" y="272" width="96" height="26" rx="13" fill="#0369a1"/><text x="915" y="289.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">util. dave</text></g>
<g class="dg-l2"><rect class="dg-solid" x="758" y="304" width="132" height="26" rx="13" fill="#15803d"/><text x="824" y="321.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">groupe analysts</text></g>
<g class="dg-l3"><rect class="dg-solid" x="896" y="304" width="103" height="26" rx="13" fill="#b45309"/><text x="947.5" y="321.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">rôle reader</text></g>
<g class="dg-l7"><rect class="dg-solid" x="758" y="336" width="197" height="26" rx="13" fill="#6d28d9"/><text x="856.5" y="353.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">politique 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="643.8" y="136" width="82.4" 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 signé</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="427.7" y="278" width="114.6" 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">monté sur /work</text>
</svg></figure>
*Figure 1. Chaque commande `aws` est un conteneur client éphémère qui envoie des requêtes signées à l'émulateur sur `127.0.0.1:9100` ; l'émulateur conserve utilisateurs, politiques et données en mémoire.*
## Étapes
### Étape 1 — Créez le dossier de travail et démarrez l'émulateur
Tous les fichiers vont dans un seul dossier, ce qui facilite le nettoyage. Le conteneur du serveur a un nom commençant par `lab-iam-`, et `INITIAL_NO_AUTH_ACTION_COUNT=3` indique à Moto d'accepter ses trois premiers appels d'API sans authentification. C'est exactement ce qu'il faut pour amorcer le premier administrateur, car personne ne peut signer une requête tant qu'un utilisateur et une clé n'existent pas. Après le troisième appel, chaque requête doit être signée par une clé connue et est vérifiée par rapport aux politiques.
```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
```
Sortie attendue (un identifiant de conteneur ; le vôtre diffère) :
```text
f97527afd13808739cf9b751e2d21b95469f2837c6cbb991e688d8f806244295
```
> [!IMPORTANT]
> Les trois appels gratuits sont un compteur côté serveur : faites exactement les étapes 3 à 5 dans l'ordre et n'exécutez aucune autre commande `aws` avant elles. Si vous mélangez l'ordre, supprimez le conteneur et recommencez : `podman rm -f lab-iam-moto`, puis répétez cette étape. (Une commande qui échoue de votre côté avant d'atteindre le serveur, par exemple à cause d'une faute de frappe dans un nom de fichier, ne consomme pas d'appel.)
### Étape 2 — Définissez les fonctions d'aide
Créez un petit fichier avec trois fonctions shell et chargez-le. C'est le seul « outillage » du lab. Lisez-le une fois : il est court.
- `aws` exécute le conteneur AWS CLI v2 et le pointe vers l'émulateur. Il transmet vos identifiants depuis des variables d'environnement, monte le dossier courant sur `/work` pour que `file://policy.json` fonctionne (`:Z` réétiquette le dossier pour les hôtes SELinux comme Fedora), et utilise une région fixe.
- `use <nom>` fait passer votre terminal à l'identité dont la clé est enregistrée dans `keys/<nom>`.
- `newkey <utilisateur>` crée une clé d'accès pour un utilisateur et l'enregistre dans `keys/<utilisateur>`.
```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
```
La première commande `aws` télécharge l'image du CLI (environ 470 Mo) : elle prend donc un moment, une seule fois. Exécutez `source ~/iam-lab/lab.sh` dans chaque nouveau terminal, depuis `~/iam-lab`.
### Étape 3 — Amorcez l'administrateur (appels gratuits 1 à 3)
L'émulateur ne vérifie pas les identifiants des trois premiers appels, mais le CLI en réclame quand même, vous utilisez donc la paire factice `test` / `test`. Vous créez un utilisateur `admin`, vous lui donnez une politique qui autorise tout, et vous créez sa clé d'accès. Le fichier de politique a la forme que vous avez vue dans la leçon : une version et une instruction.
```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
```
Sortie attendue (l'identifiant d'utilisateur et la date diffèrent ; `put-user-policy` et `newkey` n'affichent rien) :
```text
{
"User": {
"Path": "/",
"UserName": "admin",
"UserId": "c2ndbofy683n3gu2ii3r",
"Arn": "arn:aws:iam::123456789012:user/admin",
"CreateDate": "2026-11-07T18:58:03.515092+00:00"
}
}
```
Le compte `123456789012` est l'identifiant de compte fixe que Moto utilise. Cette politique large est réservée à cet unique administrateur du lab : vous avez vu dans la leçon pourquoi `*` sur `*` est dangereux dans la vraie vie.
### Étape 4 — Connectez-vous en tant qu'admin et voyez l'authentification échouer
Passez à la clé que vous venez d'enregistrer. À partir de maintenant, chaque requête est signée et vérifiée.
```bash
use admin
aws sts get-caller-identity
aws iam list-users --query 'Users[].UserName'
```
Sortie attendue (l'identifiant d'utilisateur diffère) :
```text
{
"UserId": "c2ndbofy683n3gu2ii3r",
"Account": "123456789012",
"Arn": "arn:aws:iam::123456789012:user/admin"
}
[
"admin"
]
```
`get-caller-identity` est la réponse du cloud à « qui suis-je ? » et fonctionne pour toute identité valide sans permission supplémentaire. Exécutez-la chaque fois que vous vous demandez quelle identité votre terminal utilise. Essayez maintenant de nouveau la clé factice, qui n'est plus une identité connue :
```bash
AWS_ACCESS_KEY_ID=test AWS_SECRET_ACCESS_KEY=test aws iam list-users
```
Sortie attendue :
```text
aws: [ERROR]: An error occurred (InvalidClientTokenId) when calling the ListUsers operation: The security token included in the request is invalid.
```
Il s'agit d'un échec d'**authentification** : le serveur ne sait pas qui vous êtes. Gardez-le en tête : dans les étapes suivantes, vous verrez `AccessDenied`, qui est un problème différent.
### Étape 5 — Créez un bucket avec deux dossiers
Il vous faut quelque chose à protéger. En tant qu'admin, créez le bucket `lab-data` et téléversez un « rapport » inoffensif et un « secret ». Les deux sont des textes fictifs.
```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
```
Sortie attendue (les horodatages diffèrent) :
```text
{
"Location": "/lab-data"
}
2026-11-07 18:58:18 22 reports/q3.txt
2026-11-07 18:58:19 34 secret/passwords.txt
```
### Étape 6 — Créez bob avec une politique de moindre privilège
Bob est un analyste qui doit lire et écrire les rapports, et rien d'autre. La politique comporte deux instructions, écrites comme dans la leçon : `ListBucket` s'applique à l'ARN du bucket, tandis que `GetObject` et `PutObject` s'appliquent aux objets situés sous `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
```
Sortie attendue :
```text
"arn:aws:iam::123456789012:user/bob"
```
`put-user-policy` crée une **politique en ligne** : elle vit à l'intérieur de l'utilisateur et porte un nom (`reports-rw`). Vous rencontrerez l'autre type, une politique gérée, à l'étape 9.
### Étape 7 — Testez ce que Bob peut et ne peut pas faire
Agissez en tant que Bob et essayez huit requêtes. Pour chacune, prédisez la réponse avant de l'exécuter : c'est la politique qui décide, pas le hasard.
```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
```
Sortie attendue (l'ETag diffère) :
```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
```
Les requêtes 1 à 3 correspondent à un `Allow`. Les requêtes 4 et 5 visent `secret/`, qu'aucune instruction n'autorise. La requête 6 nécessite `s3:ListAllMyBuckets`, que Bob n'a pas. La requête 7, `DeleteObject`, ne figure pas dans la liste des actions autorisées. Tout cela relève du **refus par défaut** : aucune politique n'a dit « non », il n'y a simplement aucun « oui ». Notez que chaque refus est un `AccessDenied`, et non un `InvalidClientTokenId` : Bob s'est authentifié sans problème.
### Étape 8 — Élargissez trop la politique, puis ajoutez un refus explicite
Supposons que quelqu'un « simplifie » la politique de Bob avec `s3:*` sur `reports/*`. Vous limitez ensuite les dégâts avec un refus explicite de la suppression. Modifier les politiques est un travail d'administrateur : passez donc à admin, puis revenez.
```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
```
Sortie attendue :
```text
delete succeeded
"\"c32c8500d318ac0878b49cc441b6b837\""
```
Enregistrer une politique avec le même nom remplace l'ancienne. Bob peut désormais supprimer : l'autorisation plus large couvre `DeleteObject`. Vous avez retéléversé `q4.txt` pour pouvoir tester l'étape suivante. Ajoutez maintenant à la politique une troisième instruction, un refus explicite :
```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'
```
Sortie attendue :
```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'autorisation `s3:*` correspond toujours à `DeleteObject`, mais le `Deny` explicite l'emporte : la suppression échoue et l'objet est toujours là (16 octets). Remarquez aussi le dernier résultat : Bob peut *lister* tout le bucket, y compris le nom `secret/passwords.txt`, parce que `ListBucket` a été autorisé sur l'ARN du bucket sans limite de préfixe. Il ne peut pas lire le fichier, mais il apprend qu'il existe. Sur un vrai cloud, vous restreignez cela avec une `Condition` sur le préfixe de la clé ; l'émulateur ignore les conditions, vous ne pouvez donc pas l'essayer ici.
### Étape 9 — Réutilisez des permissions avec une politique gérée et un groupe
Les politiques en ligne sont copiées pour chaque utilisateur. Une **politique gérée** est un document nommé et réutilisable que vous créez une seule fois et attachez à de nombreux utilisateurs, groupes ou rôles. Créez une politique en lecture seule, attachez-la à un groupe `analysts` et ajoutez un nouvel utilisateur, dave, au groupe. Dave obtient ses permissions du groupe et n'a aucune politique propre.
```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
```
Sortie attendue :
```text
"arn:aws:iam::123456789012:policy/reports-reader"
"arn:aws:iam::123456789012:group/analysts"
"arn:aws:iam::123456789012:user/dave"
[
"analysts"
]
```
Testez 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
```
Sortie attendue :
```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 peut lire les rapports parce que son groupe a la politique gérée ; il ne peut ni écrire ni lire le secret. Ajouter l'analyste suivant se fait avec un seul appel `add-user-to-group`, et modifier ce que les analystes peuvent faire revient à modifier une seule politique. C'est du RBAC en pratique.
### Étape 10 — Endossez un rôle pour obtenir des identifiants temporaires
Carol n'a besoin d'accéder aux rapports en lecture que de temps en temps. Plutôt qu'une permission permanente, vous créez un **rôle** `reader` qu'elle peut endosser. Le rôle a une **politique d'approbation** (qui peut l'endosser) et une **politique de permissions** (ce qu'il peut faire ; vous réutilisez `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
```
Sortie attendue :
```text
"arn:aws:iam::123456789012:user/carol"
"arn:aws:iam::123456789012:role/reader"
```
> [!NOTE]
> La dernière politique permet à Carol d'appeler `sts:AssumeRole` sur ce seul rôle. Le vrai AWS accepte à lui seul une politique d'approbation qui nomme un utilisateur du même compte, sans elle ; l'émulateur exige les deux, vous l'ajoutez donc ici. De nombreuses équipes l'ajoutent malgré tout afin que la permission soit visible sur l'utilisateur.
Agissez maintenant en tant que Carol. Essayez d'abord de lire directement un rapport : elle n'a aucune permission propre. Puis endossez le rôle. La ligne `read` prend les trois valeurs temporaires (identifiant de clé, secret, jeton de session) dans la réponse et les place dans des variables d'environnement.
```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}"
```
Sortie attendue (l'identifiant d'utilisateur et la longueur du jeton diffèrent) :
```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 clé commence maintenant par `ASIA`, le préfixe des identifiants temporaires (les clés de longue durée commencent par `AKIA`), et le jeton de session fait partie de chaque requête. Comparez les identités et les permissions :
```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
```
Sortie attendue :
```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 est maintenant `assumed-role/reader/carol-lab` : ce sont les permissions du rôle qui s'appliquent (lire les rapports, rien d'autre), et les siennes sont suspendues. Le nom de session `carol-lab` apparaîtrait dans les journaux d'audit, ce qui permet de savoir qui a agi. Ces identifiants ont été demandés pour 900 secondes (15 minutes) et cesseraient de fonctionner à ce moment-là ; l'émulateur n'applique pas l'expiration (voir la note sur l'émulateur), mais un vrai cloud le fait. Revenez à l'identité propre de Carol : `use` efface le jeton de session.
```bash
use carol
aws sts get-caller-identity --query Arn --output text
```
Sortie attendue :
```text
arn:aws:iam::123456789012:user/carol
```
### Étape 11 — Renouvelez une clé d'accès
Les clés de longue durée doivent être remplacées régulièrement, sans interruption de service. L'ordre sûr est le suivant : créer la seconde clé, basculer l'application dessus, vérifier que l'ancienne clé n'est plus utilisée, puis supprimer l'ancienne. Un utilisateur peut avoir deux clés à la fois, ce qui rend cela possible. Renouvelez la clé 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)'
```
Sortie attendue (les identifiants de clé diffèrent ; chaque identifiant fait 20 caractères) :
```text
AKIAIOSFODNN7EXAMPLE Active
2
```
Bob a maintenant deux clés actives. Les deux fonctionnent, vous pouvez donc faire passer ses applications à la nouvelle (`keys/bob`) à votre rythme :
```bash
use bob; aws sts get-caller-identity --query Arn --output text
use bob.old; aws sts get-caller-identity --query Arn --output text
```
Sortie attendue :
```text
arn:aws:iam::123456789012:user/bob
arn:aws:iam::123456789012:user/bob
```
Quand plus rien n'utilise l'ancienne clé, supprimez-la et vérifiez que seule la nouvelle fonctionne :
```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
```
Sortie attendue :
```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
```
L'ancienne clé échoue à l'**authentification**, exactement comme la clé factice de l'étape 4.
> [!NOTE]
> Sur un vrai cloud, vous pouvez aussi passer d'abord une clé à l'état `Inactive` (`aws iam update-access-key --status Inactive`) et attendre quelques jours pour voir ce qui casse avant de la supprimer. Moto n'applique pas la désactivation : le lab passe donc directement à la suppression.
### Étape 12 — Revue : qui existe et quand les clés ont-elles été utilisées ?
Une revue régulière des accès commence par un inventaire. Listez les utilisateurs, comptez leurs clés et vérifiez quand une clé a été utilisée pour la dernière fois et pour quel service. Les clés que personne n'a utilisées depuis des mois sont candidates à la suppression.
```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)"
```
Sortie attendue (la date et l'ordre diffèrent) :
```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"
}
}
```
Sur un vrai cloud, c'est aussi à ce moment que vous ouvririez le journal d'audit (par exemple CloudTrail) pour examiner les appels effectués avec chaque identité.
## Vérification
Exécutez ce contrôle. Il essaie chaque requête et compare le résultat (`allowed` ou `denied`) à ce que les politiques doivent produire. Chaque ligne doit commencer par `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
```
Sortie attendue :
```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 contrôle `denied` réussit pour n'importe quel échec : observez donc aussi un refus à la main (étape 7) et confirmez qu'il indique `AccessDenied`, et non une erreur de connexion.
## Dépannage
| Symptôme | Cause probable | Solution |
|---|---|---|
| `Could not connect to the endpoint URL: "http://127.0.0.1:9100/"` | Le conteneur du serveur ne tourne pas, ou le port 9100 est utilisé par autre chose. | `podman ps -a --filter name=lab-iam-` et `podman logs lab-iam-moto`. Si le port est occupé, arrêtez l'autre programme. Si vous avez dû recommencer, refaites les étapes 3 à 12. |
| `InvalidClientTokenId` sur une commande qui devrait fonctionner | Le terminal utilise la mauvaise clé : la clé factice `test` après les trois appels gratuits, une clé supprimée, ou un shell qui n'a jamais exécuté `use`. | Exécutez `use <nom>` et vérifiez avec `aws sts get-caller-identity`. Si l'ordre d'amorçage s'est mal passé, exécutez `podman rm -f lab-iam-moto`, répétez l'étape 1 et faites les étapes 3 à 5 dans l'ordre. |
| `Unable to locate credentials` (`NoCredentials`) | Un nouveau terminal sans les fonctions d'aide ni les identifiants. | `cd ~/iam-lab && source lab.sh && use admin`. |
| `Unable to load paramfile file://...: Permission denied` | SELinux bloque le dossier monté, ou la fonction `aws` a été copiée sans `:Z`. | Vérifiez que l'option `-v "$PWD:/work:Z"` est intacte et que vous exécutez depuis `~/iam-lab`. |
| `AccessDenied` pour une requête qui devait fonctionner | La politique ne correspond pas à l'action ou à la ressource, généralement à cause de l'ARN de bucket par rapport à celui d'objet, ou d'une ancienne politique en ligne. | `aws iam get-user-policy --user-name bob --policy-name reports-rw` en tant qu'admin, puis comparez l'action et l'ARN avec la requête. |
| `MalformedPolicyDocument: Syntax errors in policy` | JSON invalide dans le fichier de politique : virgule, guillemet ou accolade manquant. | Vérifiez le fichier, par exemple avec `python3 -m json.tool bob-policy.json`. |
| `Unknown options` ou une erreur d'analyse avec `--query` et `--output text` | Une `--query` qui renvoie un objet, et non une liste ou une chaîne, peut échouer en mode texte. | Utilisez `--output json`, ou une requête qui renvoie une liste (`[...]`) ou une valeur unique. |
## Défi (facultatif)
Créez un utilisateur `erin` qui peut *uniquement* lire les objets sous `reports/2026/` et n'a aucun moyen de lister ni de lire autre chose. Rédigez ensuite la politique qui exigerait aussi la MFA pour elle, et expliquez pourquoi vous pouvez l'écrire mais pas la tester dans ce lab. Enfin, créez un rôle `uploader` que carol peut endosser pour déposer des objets dans `reports/` mais jamais les supprimer, et prouvez-le avec les commandes de l'étape 10.
## Nettoyage
Arrêtez et supprimez le conteneur du serveur, et supprimez le dossier du lab. Le dossier contient les clés, les politiques et les fichiers téléchargés du lab ; l'émulateur ne conserve ses données qu'en mémoire : supprimer le conteneur supprime donc chaque utilisateur, politique et objet.
```bash
unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN
podman rm -f lab-iam-moto
cd ~ && rm -r ~/iam-lab
```
Sortie attendue :
```text
lab-iam-moto
```
Les deux images restent dans votre stockage local pour qu'une deuxième exécution démarre instantanément. Pour libérer l'espace disque (environ 900 Mo), supprimez-les aussi. Si vous prévoyez de faire le lab de stockage qui utilise la même image d'émulateur, conservez l'image Moto :
```bash
podman rmi docker.io/amazon/aws-cli:2.38.0 docker.io/motoserver/moto:5.2.4
```
Vérifiez qu'il ne reste rien :
```bash
podman ps -a --filter name=lab-iam-
ls ~/iam-lab
```
La première commande ne doit afficher que sa ligne d'en-tête, et la seconde doit indiquer que le dossier n'existe pas. Les fonctions `aws` et `use` disparaissent quand vous fermez le terminal.
## Ce que vous avez appris
- L'authentification et l'autorisation échouent différemment : une clé inconnue ou supprimée donne `InvalidClientTokenId`, une identité connue sans `Allow` correspondant donne `AccessDenied`.
- Tout est refusé sauf si une politique l'autorise (refus par défaut), et `ListBucket` (ARN du bucket) et `GetObject` (ARN de l'objet) exigent des ressources différentes.
- Une autorisation large peut être plafonnée par un `Deny` explicite, et le refus l'emporte toujours.
- Une politique gérée attachée à un groupe donne à chaque membre les mêmes permissions depuis un seul endroit.
- `AssumeRole` échange l'identité d'un utilisateur contre celle d'un rôle : des clés `ASIA` avec un jeton de session, uniquement les permissions du rôle, et un nom de session qui reste dans la piste d'audit.
- Le renouvellement d'une clé est sûr parce qu'un utilisateur peut détenir deux clés : créer, basculer, vérifier, supprimer.
- Un émulateur est un bon moyen d'apprendre le modèle, mais il ne reproduit pas tout (conditions, désactivation et expiration) : testez-les donc sur un vrai cloud.