CloudAcademia
FR

Cloud computing · Module 08 · Stockage cloud : blocs, fichiers et objets

Lab : volumes de blocs et magasin d'objets

Lab75 minDébutantMarkdown

Affichage du Markdown brut : le moteur de rendu n'a pas pu être chargé.

## Objectif
Comparez ce qu'apporte un volume partagé par deux conteneurs et ce qu'ajoute un vrai périphérique de blocs, puis exécutez un magasin d'objets local compatible S3 et utilisez-le comme vous utiliseriez un bucket cloud : téléversez et listez des objets, activez le versionnement et récupérez un objet supprimé, écrivez une règle de cycle de vie, partagez un objet avec une URL pré-signée et ouvrez un préfixe au public avec une politique de bucket.

## Objectifs
- Comparer un volume à utilisateur unique et un volume partagé par deux conteneurs, et expliquer ce qu'ajoute un vrai périphérique de blocs (objectif 1).
- Créer des buckets et téléverser, lister, télécharger et supprimer des objets via l'API S3, et constater que les préfixes ne sont pas des dossiers (objectif 3).
- Activer le versionnement, observer un marqueur de suppression et restaurer une version antérieure (objectif 3).
- Ajouter une règle de cycle de vie et la relire (objectifs 2 et 3).
- Partager un objet avec une URL pré-signée et ouvrir un préfixe avec une politique de bucket, et expliquer pourquoi les buckets publics sont risqués (objectif 4).

## Prérequis
- Linux avec Podman 4 ou version ultérieure, sans privilèges root, sans `sudo` (testé avec Podman 5.8). Docker fonctionne si vous remplacez `podman` par `docker`.
- `curl`. Pour l'étape 4 facultative uniquement : `mkfs.ext4` et `debugfs` du paquet `e2fsprogs` (installé par défaut sur la plupart des distributions).
- Accès à Internet pour télécharger trois images la première fois : `docker.io/library/alpine:3.20`, `docker.io/motoserver/moto:5.2.4` et `docker.io/amazon/aws-cli:2.38.0` (quelques centaines de Mo au total).
- Port TCP 9101 libre sur `127.0.0.1`.
- [La leçon](lesson.fr.md) de ce module.

> [!WARNING]
> Tout s'exécute sur votre ordinateur : le magasin d'objets n'écoute que sur `127.0.0.1`, et les clés `test`/`test` sont factices et ne fonctionnent que contre lui. Aucun compte, aucune carte bancaire ni aucune vraie ressource cloud n'est impliqué : rien ne peut donc être facturé. Tous les conteneurs et volumes commencent par `lab-storage-` et les fichiers de travail se trouvent dans `~/storage-lab` ; le nettoyage les supprime. Ne mettez jamais de vraies données ni de vrais identifiants dans ce lab.

> [!NOTE]
> Les sorties ont été capturées en novembre 2026 avec Podman 5.8.7. Les dates, les identifiants de version, les ETag et les signatures diffèrent sur votre machine ; comparez la structure, pas les valeurs exactes. La partie B utilise **Moto**, un émulateur open source des API d'Amazon Web Services (AWS). C'est un outil pédagogique : il fonctionne sans contrôle d'authentification, conserve ses données en mémoire et n'implémente pas tous les comportements d'un vrai magasin d'objets. Les remarques dans les étapes indiquent où il diffère.

## Architecture
<figure class="diagram" style="--dg-w: 1100px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 1100 440" width="1100" height="440" role="img" aria-labelledby="storage-lab-architecture-fr-title storage-lab-architecture-fr-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="fr">
<title id="storage-lab-architecture-fr-title">Architecture du TP : volumes Podman et serveur local compatible S3</title>
<desc id="storage-lab-architecture-fr-desc">Votre ordinateur Linux exécute Podman sans root. Partie A : un conteneur écrivain, lab-storage-writer, et un conteneur lecteur, lab-storage-reader, montent tous deux le volume nommé lab-storage-data sur /data ; le volume est un répertoire de l&#x27;hôte, pas un périphérique de blocs. Partie B : un conteneur AWS CLI version 2, docker.io/amazon/aws-cli:2.38.0, lancé via une fonction shell avec le dossier ~/storage-lab monté sur /work, envoie des requêtes de l&#x27;API S3 en HTTP vers 127.0.0.1 port 9101. Ce port est redirigé vers le port 5000 du conteneur Moto lab-storage-moto, un émulateur S3 qui accepte les clés factices test et test et n&#x27;impose pas d&#x27;authentification, et qui contient les buckets lab-docs, lab-versioned et lab-pub.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="1099" height="439" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l2"><rect class="dg-tint" x="20" y="20" width="1060" 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, Podman sans root)</text></g>
<g class="dg-l7"><rect class="dg-tint" x="40" y="60" width="480" height="340" rx="16" fill="#f6f2fd" stroke="#c5a9f0" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(56 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="82" y="87" font-size="13" class="dg-ink" fill="#6d28d9" font-weight="700">Partie A : volumes</text></g>
<g class="dg-l4"><rect class="dg-tint" x="540" y="60" width="520" height="340" rx="16" fill="#fbf4f0" stroke="#e7b39e" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(556 73) scale(0.7500)" fill="none" stroke="#c2410c" stroke-width="2" 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>
<text x="582" y="87" font-size="13" class="dg-ink" fill="#c2410c" font-weight="700">Partie B : stockage d&#x27;objets</text></g>
<rect class="dg-card" x="60" y="104" width="210" height="96" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(76 120) scale(1.2500)" fill="none" stroke="#17171c" 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>
<text x="118" y="141" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Conteneur : écrivain</text>
<text x="78" y="172" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">lab-storage-writer</text>
<text x="78" y="192" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">ajoute des lignes à shared.log</text>
<rect class="dg-card" x="290" y="104" width="210" height="96" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(306 120) scale(1.2500)" fill="none" stroke="#17171c" 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>
<text x="348" y="141" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Conteneur : lecteur</text>
<text x="308" y="172" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">lab-storage-reader</text>
<text x="308" y="192" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">lit les mêmes fichiers</text>
<rect class="dg-card" x="60" y="270" width="440" height="110" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l7"><g class="dg-icon" transform="translate(76 286) scale(1.2500)" fill="none" stroke="#6d28d9" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><ellipse cx="12" cy="5" rx="9" ry="3"/><path d="M3 5V19A9 3 0 0 0 21 19V5"/><path d="M3 12A9 3 0 0 0 21 12"/></g></g>
<g class="dg-l7"><text x="118" y="307" font-size="15" class="dg-ink" fill="#6d28d9" font-weight="700">Volume nommé : lab-storage-data</text></g>
<text x="78" y="338" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">monté sur /data dans les deux conteneurs</text>
<text x="78" y="358" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">un répertoire de l&#x27;hôte, pas un périphérique de blocs</text>
<g class="dg-l7"><path class="dg-stroke" d="M165 202V262" stroke="#6d28d9" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l7"><path class="dg-stroke" d="M159 257l6 8 6-8" stroke="#6d28d9" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l7"><path class="dg-stroke" d="M395 202V262" stroke="#6d28d9" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l7"><path class="dg-stroke" d="M389 257l6 8 6-8" stroke="#6d28d9" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l7"><rect class="dg-bg-plain" x="183.312" y="220" width="193.375" height="24" rx="12" fill="#ffffff"/><text x="280" y="236.5" font-size="11.5" class="dg-ink" fill="#6d28d9" font-weight="600" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">-v lab-storage-data:/data</text></g>
<rect class="dg-card" x="560" y="104" width="480" height="96" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(576 120) 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="618" y="141" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Conteneur AWS CLI v2</text>
<text x="578" y="172" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">docker.io/amazon/aws-cli:2.38.0</text>
<text x="578" y="192" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">fonction shell aws() · ~/storage-lab → /work</text>
<rect class="dg-card" x="560" y="262" width="480" height="118" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l4"><g class="dg-icon" transform="translate(576 278) scale(1.2500)" fill="none" stroke="#c2410c" 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-l4"><text x="618" y="299" font-size="15" class="dg-ink" fill="#c2410c" font-weight="700">Conteneur Moto : lab-storage-moto</text></g>
<text x="578" y="330" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">port 9101 → 5000 · clés test/test, sans authentification</text>
<text x="578" y="350" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">buckets : lab-docs · lab-versioned · lab-pub</text>
<text x="578" y="370" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">un émulateur de l&#x27;API S3, pas un stockage durable</text>
<g class="dg-l4"><path class="dg-stroke" d="M800 202V254" stroke="#c2410c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l4"><path class="dg-stroke" d="M794 249l6 8 6-8" stroke="#c2410c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l4"><rect class="dg-bg-plain" x="687.96" y="218" width="224.08" height="24" rx="12" fill="#ffffff"/><text x="800" y="234.5" font-size="11.5" class="dg-ink" fill="#c2410c" font-weight="600" text-anchor="middle">API S3 sur HTTP · 127.0.0.1:9101</text></g>
</svg></figure>

*Figure 1. La partie A utilise un volume Podman depuis deux conteneurs ; la partie B envoie des requêtes API S3 depuis le conteneur AWS CLI vers un serveur compatible S3 sur `127.0.0.1:9101`.*

## Étapes

### Partie A : stockage en blocs et partage de type fichier

### Étape 1 — Créez un dossier de travail et un volume
Vous gardez tous les fichiers du lab dans un seul dossier, ce qui facilite le nettoyage. Un **volume nommé** Podman est un stockage qui survit à un conteneur. Créez-en un et donnez-lui un nom facile à reconnaître.

```bash
mkdir -p ~/storage-lab && cd ~/storage-lab
podman --version
podman volume create lab-storage-data
```

Sortie attendue :
```text
podman version 5.8.7
lab-storage-data
```

> [!WARNING]
> Exécutez chaque commande suivante depuis `~/storage-lab`. Dans la partie B, la fonction `aws` monte le dossier courant dans un conteneur avec `:Z`, ce qui le réétiquette pour SELinux. Exécutée depuis votre dossier personnel, elle réétiquetterait tout son contenu.

### Étape 2 — Utilisez le volume depuis un conteneur
Vous montez le volume sur `/data` dans un conteneur éphémère, vous écrivez un fichier, puis vous le lisez depuis un second conteneur pour voir que les données survivent au premier.

```bash
podman run --rm -v lab-storage-data:/data docker.io/library/alpine:3.20 \
  sh -c 'echo "written by container one" > /data/note.txt; ls -l /data'
podman run --rm -v lab-storage-data:/data docker.io/library/alpine:3.20 cat /data/note.txt
podman volume inspect lab-storage-data --format '{{.Mountpoint}}'
```

Sortie attendue :
```text
total 4
-rw-r--r--    1 root     root            25 Nov  7 19:02 note.txt
written by container one
/home/<user>/.local/share/containers/storage/volumes/lab-storage-data/_data
```

La dernière ligne est le point essentiel : un volume Podman est **simplement un répertoire du système de fichiers de l'hôte** (`<user>` est votre nom d'utilisateur). Ce n'est pas un périphérique de blocs : il n'a pas de taille fixe, pas de nom de périphérique et pas de système de fichiers propre. C'est une image commode de l'idée d'un « stockage qui survit au calcul ».

### Étape 3 — Partagez le volume entre deux conteneurs en même temps
Un vrai partage de fichiers (NFS ou SMB) permet à de nombreuses machines d'utiliser en même temps les mêmes fichiers. Ici, les deux « machines » sont des conteneurs sur le même hôte. Démarrez un écrivain en arrière-plan, puis lisez depuis un second conteneur pendant qu'il tourne.

```bash
podman run -d --name lab-storage-writer -v lab-storage-data:/data docker.io/library/alpine:3.20 \
  sh -c 'i=0; while true; do i=$((i+1)); echo "writer line $i" >> /data/shared.log; sleep 1; done'
sleep 3
podman run --rm --name lab-storage-reader -v lab-storage-data:/data docker.io/library/alpine:3.20 \
  sh -c 'cat /data/shared.log; echo "reader was here" > /data/reader.txt; ls /data'
```

Sortie attendue (le nombre de lignes dépend du minutage) :
```text
writer line 1
writer line 2
writer line 3
writer line 4
note.txt
reader.txt
shared.log
```

Le lecteur voit le fichier de l'écrivain pendant que celui-ci tourne encore, et son propre fichier est visible de l'écrivain. Arrêtez maintenant l'écrivain et voyez ce qui se passe quand deux conteneurs ajoutent des données au même fichier en même temps :

```bash
podman rm -f -t 0 lab-storage-writer
podman run -d --name lab-storage-appender -v lab-storage-data:/data docker.io/library/alpine:3.20 \
  sh -c 'for i in 1 2 3 4 5; do echo "A$i" >> /data/both.log; sleep 1; done'
podman run --rm -v lab-storage-data:/data docker.io/library/alpine:3.20 \
  sh -c 'for i in 1 2 3 4 5; do echo "B$i" >> /data/both.log; sleep 1; done; cat /data/both.log'
podman rm -f -t 0 lab-storage-appender
```

Sortie attendue (les lignes A et B s'entrelacent ; l'ordre exact peut différer) :
```text
A1
B1
A2
B2
A3
B3
A4
B4
A5
B5
```

Les deux conteneurs ont écrit dans un même fichier sans le corrompre. Cela fonctionne parce que le **système de fichiers** (celui de l'hôte) se trouve sous les deux conteneurs et les coordonne : c'est le même travail que celui des serveurs NFS ou SMB pour un partage de fichiers réseau. Un partage de fichiers vous offre cela sur de nombreuses machines.

Demandez-vous maintenant ce qu'est un vrai **périphérique de blocs** et ce qu'il changerait :

| | Volume Podman (ce lab) | Vrai volume de blocs (disque cloud) |
|---|---|---|
| Ce que c'est | Un répertoire du système de fichiers de l'hôte | Un périphérique brut (`/dev/vdb`) de taille fixe |
| Qui gère le système de fichiers | L'hôte, pour tous les utilisateurs | La seule instance qui le monte |
| Plusieurs écrivains en même temps | Oui, le système de fichiers de l'hôte les coordonne | Pas avec un système de fichiers ordinaire comme ext4 : chaque machine mettrait en cache et modifierait les métadonnées de son côté, et les corromprait |
| Garanties de performance | Aucune | IOPS, débit et latence provisionnés |
| Survit à la perte de l'instance | Seulement tant que le disque de l'hôte existe | Oui, vous le rattachez à une autre instance |

### Étape 4 — Observez un système de fichiers sur un périphérique de blocs (facultatif)
Vous ne pouvez pas créer un vrai périphérique de blocs sans droits d'administrateur, mais un fichier ordinaire peut servir de « disque virtuel » : un périphérique de blocs n'est qu'un tableau de blocs, et un fichier peut en contenir un. Vous formatez le fichier en ext4 et vous le lisez avec `debugfs`, un outil qui inspecte une image ext4 sans la monter. Passez cette étape si `mkfs.ext4` ou `debugfs` n'est pas installé.

```bash
truncate -s 64M lab-storage-disk.img
mkfs.ext4 -q -F lab-storage-disk.img
file lab-storage-disk.img
echo "hello block" > note.txt
debugfs -w -R "write note.txt note.txt" lab-storage-disk.img
debugfs -R "ls -l" lab-storage-disk.img
debugfs -R "cat note.txt" lab-storage-disk.img
```

Sortie attendue (abrégée ; l'UUID et les heures diffèrent) :
```text
lab-storage-disk.img: Linux rev 1.0 ext4 filesystem data, UUID=<uuid> (extents) (64bit) (large files) (huge files)
debugfs 1.47.3 (8-Jul-2025)
Allocated inode: 13
debugfs 1.47.3 (8-Jul-2025)
      2   40755 (2)      0      0    1024  7-Nov-2026 19:55 .
      2   40755 (2)      0      0    1024  7-Nov-2026 19:55 ..
     11   40700 (2)      0      0   12288  7-Nov-2026 19:55 lost+found
     13  100644 (1)      0      0      12  7-Nov-2026 19:55 note.txt
debugfs 1.47.3 (8-Jul-2025)
hello block
```

Le fichier de 64 MiB contient désormais un système de fichiers complet, avec une table d'inodes, un répertoire `lost+found` et votre fichier. Dans un cloud, un volume de blocs est la même chose à plus grande échelle : vous obtenez de la capacité brute et *c'est vous* qui décidez du système de fichiers à y placer.

### Étape 5 — Mesurez les IOPS et le débit
Un même disque peut paraître rapide ou lent selon la taille de chaque opération. Vous écrivez la même quantité de données de deux façons avec `dd`, en contournant le cache (`oflag=direct`) pour mesurer le stockage et non la mémoire.

```bash
dd if=/dev/zero of=lab-storage-test.bin bs=1M count=256 oflag=direct 2>&1 | tail -1
dd if=/dev/zero of=lab-storage-test.bin bs=4k count=20000 oflag=direct 2>&1 | tail -1
rm -f lab-storage-test.bin
```

Sortie attendue (vos chiffres seront différents ; certains paramètres régionaux affichent une virgule décimale) :
```text
268435456 bytes (268 MB, 256 MiB) copied, 0.181368 s, 1.5 GB/s
81920000 bytes (82 MB, 78 MiB) copied, 1.00239 s, 81.7 MB/s
```

La première commande effectue 256 opérations de 1 MiB ; la seconde effectue 20 000 opérations de 4 KiB. Dans cette capture, la seconde a réalisé environ 20 000 opérations en une seconde (environ 20 000 IOPS) mais a déplacé bien moins d'octets par seconde. **Débit = IOPS × taille de l'opération** : les petites opérations sont limitées par les IOPS, les grandes par le débit. C'est pourquoi une base de données (beaucoup de petites opérations) et une tâche de sauvegarde (peu de grosses opérations) nécessitent des réglages de volume différents.

> [!NOTE]
> Cela mesure le disque et le système de fichiers de votre ordinateur, pas un volume cloud. Le but est uniquement de montrer la relation entre la taille des opérations, les IOPS et le débit. Les vrais volumes publient leurs limites d'IOPS et de débit provisionnés.

### Partie B : stockage d'objets

### Étape 6 — Démarrez le magasin d'objets et définissez le client
Vous exécutez Moto, un serveur compatible S3, dans un conteneur. Le port 5000 à l'intérieur du conteneur est publié uniquement sur `127.0.0.1:9101` de votre ordinateur. Vous définissez ensuite `aws`, une fonction shell qui exécute dans un conteneur l'interface en ligne de commande (CLI) AWS version 2, pointée vers votre serveur, avec des clés factices. `:Z` réétiquette le dossier pour SELinux et est sans effet ailleurs.

```bash
podman run -d --name lab-storage-moto -p 127.0.0.1:9101:5000 docker.io/motoserver/moto:5.2.4

aws() { podman run --rm --network host -v "$PWD:/work:Z" -w /work \
  -e AWS_ACCESS_KEY_ID=test -e AWS_SECRET_ACCESS_KEY=test -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:9101 "$@"; }

sleep 4
aws --version
```

Sortie attendue :
```text
aws-cli/2.38.0 Python/3.14.6 Linux/7.2.4-ogc3.1.fc44.x86_64 docker/x86_64.amzn.2023
```

> [!IMPORTANT]
> La fonction n'existe que dans ce terminal. Si vous en ouvrez un nouveau, définissez-la à nouveau (et faites `cd ~/storage-lab`). Comme la CLI s'exécute dans un conteneur, chaque appel démarre un conteneur (environ une seconde).

La seule différence avec l'utilisation d'un vrai cloud est `--endpoint-url` : retirez-le, utilisez de vraies clés, et les mêmes commandes s'adressent à un vrai fournisseur. C'est ce que signifie, en pratique, « l'API S3 comme standard ».

### Étape 7 — Buckets, objets, préfixes et métadonnées
Vous créez un bucket, téléversez deux objets et les listez. Observez comment `reports/2026/q3.txt` apparaît comme un « dossier ».

```bash
aws s3 mb s3://lab-docs
echo "Quarterly report v1" > report.txt
aws s3 cp --no-progress report.txt s3://lab-docs/reports/2026/q3.txt
aws s3 cp --no-progress report.txt s3://lab-docs/readme.txt --metadata project=apollo,owner=ana --content-type text/plain
aws s3 ls s3://lab-docs
aws s3 ls s3://lab-docs/reports/
aws s3 ls s3://lab-docs --recursive
```

Sortie attendue :
```text
make_bucket: lab-docs
upload: ./report.txt to s3://lab-docs/reports/2026/q3.txt
upload: ./report.txt to s3://lab-docs/readme.txt
                           PRE reports/
2026-11-07 19:02:42         20 readme.txt
                           PRE 2026/
2026-11-07 19:02:42         20 readme.txt
2026-11-07 19:02:41         20 reports/2026/q3.txt
```

Le listage affiche `PRE reports/` (« préfixe »), pas un dossier. Avec `--recursive`, vous voyez ce qui est réellement stocké : deux objets dont les **clés** sont `readme.txt` et `reports/2026/q3.txt`. Lisez maintenant les métadonnées, téléchargez un objet, puis supprimez-le :

```bash
aws s3api head-object --bucket lab-docs --key readme.txt
aws s3 cp --no-progress s3://lab-docs/readme.txt downloaded.txt
cat downloaded.txt
aws s3 rm s3://lab-docs/readme.txt
aws s3 ls s3://lab-docs --recursive
```

Sortie attendue (l'`ETag` et la date varient) :
```text
{
    "AcceptRanges": "bytes",
    "LastModified": "2026-11-07T19:02:42+00:00",
    "ContentLength": 20,
    "ETag": "\"b9ee29d4dddd352401ae31295dbe672d\"",
    "ContentType": "text/plain",
    "Metadata": {
        "project": "apollo",
        "owner": "ana"
    }
}
download: s3://lab-docs/readme.txt to ./downloaded.txt
Quarterly report v1
delete: s3://lab-docs/readme.txt
2026-11-07 19:02:41         20 reports/2026/q3.txt
```

L'`ETag` est l'identifiant du contenu (une empreinte MD5 pour un téléversement simple). Le bloc `Metadata` contient les paires personnalisées que vous avez définies. Sans versionnement, la suppression est définitive : l'objet a disparu.

> [!NOTE]
> Les noms de bucket doivent comporter au moins 3 caractères (`aws s3 mb s3://ab` échoue avec `InvalidBucketName`). Chez un vrai fournisseur, les noms sont en outre uniques à l'échelle mondiale et suivent les règles de nommage DNS : `lab-docs` est donc probablement déjà pris ; ajoutez un suffixe aléatoire.

### Étape 8 — Versionnement, marqueur de suppression et restauration
Vous créez un second bucket, activez le versionnement, écrasez un objet puis le supprimez, et vous récupérez la première version.

```bash
aws s3 mb s3://lab-versioned
aws s3api put-bucket-versioning --bucket lab-versioned --versioning-configuration Status=Enabled
aws s3api get-bucket-versioning --bucket lab-versioned
echo "version one" > notes.txt
aws s3 cp --no-progress notes.txt s3://lab-versioned/notes.txt
echo "version two, edited" > notes.txt
aws s3 cp --no-progress notes.txt s3://lab-versioned/notes.txt
aws s3api list-object-versions --bucket lab-versioned --query 'Versions[].[VersionId,IsLatest,Size]' --output text
```

Sortie attendue (les identifiants de version diffèrent ; la première ligne est la plus récente) :
```text
make_bucket: lab-versioned
{
    "Status": "Enabled"
}
upload: ./notes.txt to s3://lab-versioned/notes.txt
upload: ./notes.txt to s3://lab-versioned/notes.txt
1ca2a323-276d-4987-b27c-b8496e1ef123	True	20
35cfc607-5f97-489e-acb7-5e775f48bedf	False	12
```

Deux téléversements vers une même clé ont créé **deux versions** : celle de 20 octets (« version two, edited ») est la courante, et celle de 12 octets (« version one ») est conservée. Copiez l'identifiant de la version de 12 octets : vous en aurez besoin plus bas sous la forme `<version-id-1>`. Supprimez maintenant l'objet :

```bash
aws s3 rm s3://lab-versioned/notes.txt
aws s3 ls s3://lab-versioned
aws s3 cp --no-progress s3://lab-versioned/notes.txt - ; echo "exit code: $?"
aws s3api list-object-versions --bucket lab-versioned --query 'Versions[].[VersionId,IsLatest,Size]' --output text
aws s3api list-object-versions --bucket lab-versioned --query 'DeleteMarkers[].[VersionId,IsLatest]' --output text
```

Sortie attendue :
```text
delete: s3://lab-versioned/notes.txt
download failed: s3://lab-versioned/notes.txt to - An error occurred (404) when calling the HeadObject operation: Not Found
exit code: 1
1ca2a323-276d-4987-b27c-b8496e1ef123	False	20
35cfc607-5f97-489e-acb7-5e775f48bedf	False	12
bbe0b185-3e0a-496d-a569-e5b1387c43b5	True
```

Le listage du bucket est vide et un téléchargement répond `404 Not Found`, pourtant les deux versions sont toujours là et un **marqueur de suppression** (la ligne avec un seul `True`) est maintenant la version courante. Rien n'a été effacé. Restaurez la première version en la recopiant pour qu'elle devienne la version la plus récente :

```bash
aws s3api get-object --bucket lab-versioned --key notes.txt --version-id <version-id-1> old-notes.txt
cat old-notes.txt
aws s3api copy-object --bucket lab-versioned --key notes.txt \
  --copy-source "lab-versioned/notes.txt?versionId=<version-id-1>" --query VersionId
aws s3 cp --no-progress s3://lab-versioned/notes.txt -
aws s3api list-object-versions --bucket lab-versioned --query 'Versions[].[VersionId,IsLatest,Size]' --output text
```

`<version-id-1>` est l'identifiant de la version de 12 octets relevé dans le listage. Sortie attendue :
```text
{
    "AcceptRanges": "bytes",
    "LastModified": "2026-11-07T18:56:28+00:00",
    "ContentLength": 12,
    "ETag": "\"dd8f100298ff923592ab35dc15788abc\"",
    "VersionId": "35cfc607-5f97-489e-acb7-5e775f48bedf",
    "ContentType": "text/plain",
    "Metadata": {}
}
version one
"806268d5-a59a-4468-bfa7-7e724ba7de22"
version one
806268d5-a59a-4468-bfa7-7e724ba7de22	True	12
1ca2a323-276d-4987-b27c-b8496e1ef123	False	20
35cfc607-5f97-489e-acb7-5e775f48bedf	False	12
```

Vous avez récupéré l'objet : la copie est une nouvelle troisième version avec l'ancien contenu, et elle est de nouveau la courante (le marqueur de suppression reste dans l'historique, masqué en dessous). Pour supprimer définitivement les données, vous supprimeriez une version précise avec `aws s3api delete-object --bucket lab-versioned --key notes.txt --version-id <id>`.

> [!NOTE]
> Supprimer le marqueur de suppression lui-même (`delete-object` avec le `--version-id` du marqueur) est l'autre manière d'annuler une suppression : la version précédente redevient la courante. Cela a fonctionné lors de notre test sur Moto, comme sur le vrai S3.

### Étape 9 — Ajoutez une règle de cycle de vie
Vous écrivez deux règles : faire expirer les objets sous `tmp/` après 30 jours, et faire expirer les versions non courantes après 90 jours. Le fichier JSON contient les règles, et la CLI les enregistre puis les relit.

```bash
cat > lifecycle.json <<'EOF'
{
  "Rules": [
    {
      "ID": "expire-tmp-after-30-days",
      "Status": "Enabled",
      "Filter": { "Prefix": "tmp/" },
      "Expiration": { "Days": 30 }
    },
    {
      "ID": "clean-old-versions",
      "Status": "Enabled",
      "Filter": { "Prefix": "" },
      "NoncurrentVersionExpiration": { "NoncurrentDays": 90 }
    }
  ]
}
EOF
aws s3api put-bucket-lifecycle-configuration --bucket lab-versioned --lifecycle-configuration file://lifecycle.json
aws s3api get-bucket-lifecycle-configuration --bucket lab-versioned
```

Sortie attendue (l'ordre des champs et la première ligne peuvent différer) :
```text
{
    "TransitionDefaultMinimumObjectSize": "all_storage_classes_128K",
    "Rules": [
        {
            "Expiration": {
                "Days": 30
            },
            "ID": "expire-tmp-after-30-days",
            "Filter": {
                "Prefix": "tmp/"
            },
            "Status": "Enabled"
        },
        {
            "ID": "clean-old-versions",
            "Filter": {
                "Prefix": ""
            },
            "Status": "Enabled",
            "NoncurrentVersionExpiration": {
                "NoncurrentDays": 90
            }
        }
    ]
}
```

> [!NOTE]
> Moto enregistre et renvoie les règles de cycle de vie mais **ne les exécute jamais** : les objets n'expirent pas ici, et vous ne pouvez pas attendre 30 jours pour le constater. Chez un vrai fournisseur, un processus d'arrière-plan applique les règles, généralement une fois par jour. Vous avez pratiqué la partie dont vous avez le contrôle : écrire une règle correcte. Une règle avec un `Prefix` vide et `NoncurrentVersionExpiration` est le complément habituel du versionnement, pour que les anciennes versions ne s'accumulent pas indéfiniment.

### Étape 10 — Partagez un objet avec une URL pré-signée
L'objet `lab-docs/reports/2026/q3.txt` est privé. Vous essayez de le lire sans identifiants, puis vous créez une URL qui accorde une minute d'accès.

```bash
curl -s -o /dev/null -w "unsigned request: HTTP %{http_code}\n" http://127.0.0.1:9101/lab-docs/reports/2026/q3.txt
URL=$(aws s3 presign s3://lab-docs/reports/2026/q3.txt --expires-in 60)
echo "$URL"
curl -s -w "pre-signed request: HTTP %{http_code}\n" "$URL"
```

Sortie attendue (`X-Amz-Date` et la signature diffèrent) :
```text
unsigned request: HTTP 403
http://127.0.0.1:9101/lab-docs/reports/2026/q3.txt?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=test%2F20261107%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20261107T185711Z&X-Amz-Expires=60&X-Amz-SignedHeaders=host&X-Amz-Signature=<signature>
Quarterly report v1
pre-signed request: HTTP 200
```

Examinez l'URL. Le chemin désigne l'objet. `X-Amz-Expires=60` est la durée de vie en secondes, `X-Amz-Credential` nomme la clé qui a signé (mais jamais le secret), et `X-Amz-Signature` prouve que le signataire a autorisé exactement cette requête. Le bucket est resté privé, et `curl` n'a utilisé aucun identifiant : quiconque détient l'URL obtient l'objet. Modifiez un seul caractère du chemin ou de la signature et la requête est refusée.

> [!NOTE]
> Moto n'applique **pas** l'expiration : l'URL continue de fonctionner après les 60 secondes. Un vrai fournisseur renvoie `403 Forbidden` après l'expiration, et c'est ce qui rend les URL de courte durée utiles. Ne vous fiez pas à cet émulateur pour tester une logique d'expiration.

### Étape 11 — Ouvrez un préfixe avec une politique de bucket
Vous créez un bucket avec un objet public et un objet privé, vous confirmez que les deux sont refusés aux utilisateurs anonymes, puis vous ajoutez une **politique de bucket** qui autorise tout le monde à lire uniquement `reports/*`.

```bash
aws s3 mb s3://lab-pub
echo "public report" > hi.txt
echo "private note" > other.txt
aws s3 cp --no-progress hi.txt s3://lab-pub/reports/hi.txt
aws s3 cp --no-progress other.txt s3://lab-pub/other.txt
for k in reports/hi.txt other.txt; do curl -s -o /dev/null -w "$k before the policy: HTTP %{http_code}\n" http://127.0.0.1:9101/lab-pub/$k; done
```

Sortie attendue :
```text
make_bucket: lab-pub
upload: ./hi.txt to s3://lab-pub/reports/hi.txt
upload: ./other.txt to s3://lab-pub/other.txt
reports/hi.txt before the policy: HTTP 403
other.txt before the policy: HTTP 403
```

Écrivez maintenant la politique. `"Principal": "*"` signifie tout le monde, y compris les personnes sans compte :

```bash
cat > policy.json <<'EOF'
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "PublicReadReportsOnly",
      "Effect": "Allow",
      "Principal": "*",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::lab-pub/reports/*"
    }
  ]
}
EOF
aws s3api put-bucket-policy --bucket lab-pub --policy file://policy.json
for k in reports/hi.txt other.txt; do curl -s -o /dev/null -w "$k after the policy: HTTP %{http_code}\n" http://127.0.0.1:9101/lab-pub/$k; done
curl -s http://127.0.0.1:9101/lab-pub/reports/hi.txt
aws s3api delete-bucket-policy --bucket lab-pub
curl -s -o /dev/null -w "reports/hi.txt after removing the policy: HTTP %{http_code}\n" http://127.0.0.1:9101/lab-pub/reports/hi.txt
```

Sortie attendue :
```text
reports/hi.txt after the policy: HTTP 200
other.txt after the policy: HTTP 403
public report
reports/hi.txt after removing the policy: HTTP 403
```

Une seule instruction a exposé un préfixe à tout Internet, et un autre objet du même bucket est resté privé. Imaginez maintenant la même politique avec `"Resource": "arn:aws:s3:::lab-pub/*"` : tous les objets, y compris ce que quelqu'un téléversera l'an prochain. Cette différence d'un seul caractère est à l'origine de la plupart des fuites de buckets publics. Dans la politique, `Resource` est l'endroit où vous maîtrisez les dégâts ; chez un vrai fournisseur, le **blocage de l'accès public** (block public access) est le filet de sécurité qui refuse purement et simplement une telle politique.

> [!NOTE]
> Moto n'applique pas le blocage de l'accès public. Si vous exécutez `aws s3api put-public-access-block --bucket lab-pub --public-access-block-configuration BlockPublicAcls=true,IgnorePublicAcls=true,BlockPublicPolicy=true,RestrictPublicBuckets=true`, il enregistre et renvoie les paramètres, mais une politique publique est tout de même acceptée et servie. Chez un vrai fournisseur avec `BlockPublicPolicy` activé, le `put-bucket-policy` ci-dessus est rejeté, et `RestrictPublicBuckets` bloque l'accès public même à partir d'une politique existante. Nous n'avons pas pu vérifier ces effets ici : consultez donc la documentation de votre fournisseur.

## Vérification
Contrôlez chaque résultat ; chaque ligne doit correspondre.

1. Partie A : `podman volume inspect lab-storage-data --format '{{.Mountpoint}}'` affiche un chemin sous votre dossier personnel, et `ls "$(podman volume inspect lab-storage-data --format '{{.Mountpoint}}')"` liste `both.log`, `note.txt`, `reader.txt` et `shared.log`.
2. Partie B, objets : `aws s3 ls s3://lab-docs --recursive` liste exactement une clé, `reports/2026/q3.txt`.
3. Versionnement : `aws s3 cp --no-progress s3://lab-versioned/notes.txt -` affiche `version one`, et `aws s3api list-object-versions --bucket lab-versioned --query 'length(Versions)'` affiche `3`.
4. Cycle de vie : `aws s3api get-bucket-lifecycle-configuration --bucket lab-versioned --query 'Rules[].ID'` liste `expire-tmp-after-30-days` et `clean-old-versions`.
5. URL pré-signée : une nouvelle URL produite par `aws s3 presign` et récupérée avec `curl` renvoie le texte, alors que l'URL non signée renvoie `403`.
6. Politique : la politique appliquée, `reports/hi.txt` renvoie `200` et `other.txt` renvoie `403` (relancez la commande de politique de l'étape 11 si vous l'avez supprimée).

## Dépannage
| Symptôme | Cause probable | Solution |
|---|---|---|
| `Could not connect to the endpoint URL: "http://127.0.0.1:9101/"` | Le conteneur Moto ne tourne pas, ou vous l'avez redémarré | `podman ps --filter name=lab-storage` ; démarrez-le avec `podman start lab-storage-moto`. Moto garde ses données en mémoire : un redémarrage vide donc tous les buckets, refaites les étapes 7 à 11 |
| `Error: ... address already in use` pour le port 9101 | Un autre programme ou conteneur utilise le port | Trouvez-le avec `ss -ltn \| grep 9101` ; arrêtez votre propre conteneur précédent, ou changez le premier nombre dans `-p 127.0.0.1:9101:5000` et dans `--endpoint-url` |
| `aws: command not found` | La fonction shell n'est définie que dans le terminal où vous avez exécuté l'étape 6 | Définissez-la à nouveau dans ce terminal |
| `Permission denied` quand le conteneur AWS CLI lit `report.txt` | SELinux bloque le montage, ou vous avez retiré `:Z` | Gardez `:Z` dans la fonction et exécutez depuis `~/storage-lab` |
| `make_bucket failed ... InvalidBucketName` | Le nom compte moins de 3 caractères ou contient des caractères non valides | Utilisez des minuscules, des chiffres et des tirets, 3 caractères ou plus |
| `dd: failed to open ... Invalid argument` à l'étape 5 | Le dossier se trouve sur un système de fichiers sans prise en charge des E/S directes, comme `tmpfs` | Exécutez le lab depuis un dossier situé sur un disque normal, ou retirez `oflag=direct` (les chiffres mesurent alors le cache) |
| `debugfs: command not found` ou `mkfs.ext4: command not found` | `e2fsprogs` n'est pas installé | Installez-le, ou passez l'étape 4 facultative |
| `curl` renvoie `403` pour l'URL pré-signée | L'URL a été tronquée par le shell (les caractères `&`), ou vous l'avez modifiée | Gardez-la dans une variable et mettez-la entre guillemets : `curl "$URL"` |

## Défi (facultatif)
Créez un bucket nommé `lab-site` et téléversez un petit `index.html` sous le préfixe `site/`. Écrivez une politique de bucket qui autorise `GET` anonyme uniquement pour `site/*`, confirmez-le avec `curl`, puis modifiez `Resource` pour qu'elle expose aussi un préfixe `private/`. Comparez les deux politiques et indiquez lesquels des contrôles de la leçon (blocage de l'accès public, politique de moindre privilège, URL pré-signées) auraient arrêté la seconde chez un vrai fournisseur. Utilisez ensuite `aws s3 sync ./site s3://lab-site/site` pour téléverser un dossier et `aws s3 rm s3://lab-site --recursive` pour le supprimer.

## Nettoyage
Supprimez tous les conteneurs, volumes et fichiers créés par le lab. La dernière commande, qui supprime les trois images, est facultative : ignorez-la si vous utilisez ces images pour autre chose.

```bash
podman rm -f -t 0 lab-storage-moto lab-storage-writer lab-storage-reader lab-storage-appender 2>/dev/null
podman volume rm lab-storage-data
cd ~ && rm -rf ~/storage-lab
unset -f aws
# Optional: remove the downloaded images
podman rmi docker.io/motoserver/moto:5.2.4 docker.io/amazon/aws-cli:2.38.0 docker.io/library/alpine:3.20
```

Vérifiez qu'il ne reste rien :
```bash
podman ps -a --filter name=lab-storage --format '{{.Names}}'
podman volume ls --filter name=lab-storage
```

Les deux commandes ne doivent rien afficher, hormis l'en-tête du tableau des volumes.

## Ce que vous avez appris
- Un volume Podman est un répertoire, pas un périphérique de blocs. Un vrai volume de blocs vous donne de la capacité brute avec ses propres IOPS, son débit et sa latence, et une seule instance y gère le système de fichiers ; un partage de fichiers gère le système de fichiers pour de nombreux clients.
- Le débit est égal aux IOPS multipliées par la taille de l'opération : les petites opérations sont donc limitées par les IOPS, les grandes par le débit.
- Le stockage d'objets s'atteint via une API HTTP (l'API S3) avec un bucket, une clé et des métadonnées ; les préfixes ne font que ressembler à des dossiers. Changer de point de terminaison suffit pour passer d'un service compatible S3 à un autre.
- Le versionnement transforme une suppression en marqueur de suppression et conserve chaque version : restaurer revient donc à copier une version antérieure. Les règles de cycle de vie, écrites une fois, font expirer les données automatiquement chez un vrai fournisseur.
- Une URL pré-signée donne un accès de courte durée à un objet privé, alors qu'une politique de bucket trop large rend les données publiques pour tout le monde : gardez le blocage de l'accès public activé et limitez étroitement `Resource`.