CloudAcademia
IT

Cloud computing · Modulo 08 · Storage cloud: blocchi, file e oggetti

Laboratorio: volumi a blocchi e un object store

Laboratorio75 minPrincipianteMarkdown

Viene mostrato il Markdown grezzo: non è stato possibile caricare il visualizzatore.

## Obiettivo
Confronta ciò che offre un volume condiviso da due container con ciò che aggiunge un vero dispositivo a blocchi, poi esegui un object store locale compatibile con S3 e usalo come useresti un bucket cloud: carica ed elenca oggetti, attiva il versioning e recupera un oggetto eliminato, scrivi una regola di lifecycle, condividi un oggetto con un URL prefirmato e apri un prefisso al pubblico con una policy del bucket.

## Obiettivi
- Confrontare un volume per un solo utente con un volume condiviso da due container, e spiegare che cosa aggiunge un vero dispositivo a blocchi (obiettivo 1).
- Creare bucket e caricare, elencare, scaricare ed eliminare oggetti tramite l'API S3, e verificare che i prefissi non sono cartelle (obiettivo 3).
- Attivare il versioning, osservare un delete marker e ripristinare una versione precedente (obiettivo 3).
- Aggiungere e rileggere una regola di lifecycle (obiettivi 2 e 3).
- Condividere un oggetto con un URL prefirmato e aprire un prefisso con una policy del bucket, e spiegare perché i bucket pubblici sono rischiosi (obiettivo 4).

## Prerequisiti
- Linux con Podman 4 o successivo, rootless, senza `sudo` (testato con Podman 5.8). Docker funziona se sostituisci `podman` con `docker`.
- `curl`. Solo per il Passo 4 facoltativo: `mkfs.ext4` e `debugfs` del pacchetto `e2fsprogs` (installato per impostazione predefinita nella maggior parte delle distribuzioni).
- Accesso a Internet per scaricare tre immagini la prima volta: `docker.io/library/alpine:3.20`, `docker.io/motoserver/moto:5.2.4` e `docker.io/amazon/aws-cli:2.38.0` (alcune centinaia di MB in totale).
- Porta TCP 9101 libera su `127.0.0.1`.
- [La lezione](lesson.it.md) di questo modulo.

> [!WARNING]
> Tutto viene eseguito sul tuo computer: l'object store è in ascolto solo su `127.0.0.1` e le chiavi `test`/`test` sono fittizie e funzionano solo con esso. Non sono coinvolti account, carte o risorse cloud reali, quindi non c'è nulla da fatturare. Tutti i container e i volumi iniziano con `lab-storage-` e i file di lavoro si trovano in `~/storage-lab`; la Pulizia li rimuove. Non inserire mai dati reali o credenziali reali in questo laboratorio.

> [!NOTE]
> Gli output sono stati acquisiti nel novembre 2026 con Podman 5.8.7. Date, ID di versione, ETag e firme sono diversi sul tuo computer; confronta la struttura, non i valori esatti. La Parte B usa **Moto**, un emulatore open source delle API di Amazon Web Services (AWS). È uno strumento didattico: funziona senza controlli di autenticazione, conserva i dati in memoria e non implementa tutti i comportamenti di un vero object store. Le Note nei passaggi indicano dove si discosta.

## Architettura
<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-it-title storage-lab-architecture-it-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="it">
<title id="storage-lab-architecture-it-title">Architettura del laboratorio: volumi Podman e un server locale compatibile con S3</title>
<desc id="storage-lab-architecture-it-desc">Il tuo computer Linux esegue Podman rootless. Parte A: un container scrittore, lab-storage-writer, e un container lettore, lab-storage-reader, montano entrambi il volume con nome lab-storage-data su /data; il volume è una directory dell&#x27;host, non un dispositivo a blocchi. Parte B: un container AWS CLI versione 2, docker.io/amazon/aws-cli:2.38.0, eseguito tramite una funzione shell con la cartella ~/storage-lab montata come /work, invia richieste dell&#x27;API S3 via HTTP a 127.0.0.1 porta 9101. Quella porta è mappata sulla porta 5000 del container Moto lab-storage-moto, un emulatore S3 che accetta le chiavi fittizie test e test e non impone l&#x27;autenticazione, e che contiene i bucket lab-docs, lab-versioned e 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">Il tuo computer (Linux, Podman rootless)</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">Parte A: volumi</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">Parte B: storage a oggetti</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">Container: scrittore</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">aggiunge righe a 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">Container: lettore</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">legge gli stessi file</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 con nome: lab-storage-data</text></g>
<text x="78" y="338" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">montato su /data in entrambi i container</text>
<text x="78" y="358" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">una directory dell&#x27;host, non un dispositivo a blocchi</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">Container 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">funzione 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">Container 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">porta 9101 → 5000 · chiavi test/test, nessuna autenticazione</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">bucket: lab-docs · lab-versioned · lab-pub</text>
<text x="578" y="370" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">un emulatore dell&#x27;API S3, non uno storage durevole</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="691.18" y="218" width="217.64" 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 su HTTP · 127.0.0.1:9101</text></g>
</svg></figure>

*Figura 1. La Parte A usa un volume Podman da due container; la Parte B invia richieste API S3 dal container AWS CLI a un server compatibile con S3 su `127.0.0.1:9101`.*

## Passaggi

### Parte A: storage a blocchi e condivisione simile a quella di file

### Passo 1 — Crea una cartella di lavoro e un volume
Conservi tutti i file del laboratorio in una sola cartella, così la pulizia è semplice. Un **volume con nome** (named volume) di Podman è uno storage che sopravvive a un container. Creane uno e assegnagli un nome riconoscibile.

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

Output atteso:
```text
podman version 5.8.7
lab-storage-data
```

> [!WARNING]
> Esegui tutti i comandi successivi da `~/storage-lab`. Nella Parte B la funzione `aws` monta la cartella corrente in un container con `:Z`, che ne reimposta l'etichetta per SELinux. Se la eseguissi dalla tua cartella home, ne reimposterebbe l'etichetta per intero.

### Passo 2 — Usa il volume da un container
Monti il volume in `/data` in un container di breve durata, scrivi un file e poi lo leggi da un secondo container, per vedere che i dati sopravvivono al primo.

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

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

L'ultima riga è il punto chiave: un volume Podman è **semplicemente una directory nel filesystem dell'host** (`<user>` è il tuo nome utente). Non è un dispositivo a blocchi: non ha una dimensione fissa, né un nome di dispositivo, né un filesystem proprio. È un comodo sostituto dell'idea di «storage che sopravvive al calcolo».

### Passo 3 — Condividi il volume tra due container contemporaneamente
Una vera condivisione di file (NFS o SMB) permette a molte macchine di usare gli stessi file nello stesso momento. Qui le due «macchine» sono container sullo stesso host. Avvia uno scrittore in background, poi leggi da un secondo container mentre è in esecuzione.

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

Output atteso (il numero di righe dipende dai tempi):
```text
writer line 1
writer line 2
writer line 3
writer line 4
note.txt
reader.txt
shared.log
```

Il lettore vede il file dello scrittore mentre lo scrittore è ancora in esecuzione, e il file del lettore è visibile allo scrittore. Ora ferma lo scrittore e osserva che cosa accade quando due container aggiungono dati in coda allo stesso file nello stesso momento:

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

Output atteso (le righe A e B si alternano; l'ordine esatto può variare):
```text
A1
B1
A2
B2
A3
B3
A4
B4
A5
B5
```

Entrambi i container hanno scritto nello stesso file senza corromperlo. Funziona perché il **filesystem** (quello dell'host) si trova sotto entrambi i container e li coordina: è lo stesso compito svolto dai server NFS o SMB per una condivisione di file di rete. Una condivisione di file offre questo comportamento attraverso molte macchine.

Ora rifletti su che cos'è un vero **dispositivo a blocchi** e su che cosa cambierebbe:

| | Volume Podman (questo laboratorio) | Vero volume a blocchi (disco cloud) |
|---|---|---|
| Che cos'è | Una directory nel filesystem dell'host | Un dispositivo grezzo (`/dev/vdb`) di dimensione fissa |
| Chi gestisce il filesystem | L'host, per tutti gli utenti | L'unica istanza che lo monta |
| Più scrittori contemporaneamente | Sì, il filesystem dell'host li coordina | Non con un filesystem ordinario come ext4: due macchine terrebbero ciascuna in cache e aggiornerebbero i metadati, corrompendoli |
| Garanzie di prestazioni | Nessuna | IOPS, throughput e latenza di cui è stato effettuato il provisioning |
| Sopravvive alla perdita dell'istanza | Solo finché esiste il disco dell'host | Sì, lo ricolleghi a un'altra istanza |

### Passo 4 — Osserva un filesystem su un dispositivo a blocchi (facoltativo)
Non puoi creare un vero dispositivo a blocchi senza privilegi di amministratore, ma un normale file può fare da «disco virtuale»: un dispositivo a blocchi è solo una sequenza di blocchi, e un file può contenerla. Formatti il file con ext4 e lo leggi con `debugfs`, uno strumento che ispeziona un'immagine ext4 senza montarla. Salta questo passo se `mkfs.ext4` o `debugfs` non sono installati.

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

Output atteso (abbreviato; UUID e orari sono diversi):
```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
```

Il file da 64 MiB contiene ora un filesystem completo, con una tabella degli inode, una directory `lost+found` e il tuo file. In un cloud, un volume a blocchi è la stessa cosa su scala maggiore: ottieni capacità grezza e *sei tu* a decidere quale filesystem installarvi.

### Passo 5 — Misura IOPS e throughput
Lo stesso disco può sembrare veloce o lento a seconda della dimensione di ciascuna operazione. Scrivi la stessa quantità di dati in due modi con `dd`, aggirando la cache (`oflag=direct`) in modo da misurare lo storage e non la memoria.

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

Output atteso (i tuoi numeri saranno diversi; alcune impostazioni locali stampano la virgola decimale):
```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
```

Il primo comando esegue 256 operazioni da 1 MiB; il secondo esegue 20.000 operazioni da 4 KiB. In questa acquisizione il secondo ha eseguito circa 20.000 operazioni in un secondo (circa 20.000 IOPS) ma ha spostato molti meno byte al secondo. **Throughput = IOPS × dimensione dell'operazione**: le operazioni piccole sono limitate dalle IOPS, quelle grandi dal throughput. Per questo un database (molte operazioni piccole) e un job di backup (poche operazioni grandi) richiedono impostazioni di volume diverse.

> [!NOTE]
> Questa misura riguarda il disco e il filesystem del tuo computer, non un volume cloud. Serve solo a mostrare la relazione tra dimensione dell'operazione, IOPS e throughput. I volumi reali pubblicano i propri limiti di IOPS e di throughput di cui è stato effettuato il provisioning.

### Parte B: storage a oggetti

### Passo 6 — Avvia l'object store e definisci il client
Esegui Moto, un server compatibile con S3, in un container. La porta 5000 all'interno del container è pubblicata solo su `127.0.0.1:9101` del tuo computer. Poi definisci `aws`, una funzione di shell che esegue in un container l'interfaccia a riga di comando (CLI, command-line interface) di AWS versione 2, puntata al tuo server, con chiavi fittizie. `:Z` reimposta l'etichetta della cartella per SELinux ed è innocuo altrove.

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

Output atteso:
```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 funzione esiste solo in questo terminale. Se ne apri uno nuovo, definiscila di nuovo (e fai `cd ~/storage-lab`). Poiché la CLI viene eseguita in un container, ogni chiamata avvia un container (circa un secondo).

L'unica differenza rispetto all'uso di un cloud reale è `--endpoint-url`: rimuovilo, usa chiavi reali e gli stessi comandi comunicano con un provider reale. Questo è ciò che significa, in pratica, «API S3 come standard».

### Passo 7 — Bucket, oggetti, prefissi e metadati
Crei un bucket, carichi due oggetti e li elenchi. Osserva come `reports/2026/q3.txt` appaia come una «cartella».

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

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

L'elenco mostra `PRE reports/` («prefisso»), non una cartella. Con `--recursive` vedi ciò che è realmente conservato: due oggetti le cui **chiavi** sono `readme.txt` e `reports/2026/q3.txt`. Ora leggi i metadati, scarica un oggetto ed eliminalo:

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

Output atteso (`ETag` e data variano):
```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` è l'identificatore del contenuto (un hash MD5 per un caricamento semplice). Il blocco `Metadata` contiene le coppie personalizzate che hai impostato. Senza il versioning, l'eliminazione è definitiva: l'oggetto scompare.

> [!NOTE]
> I nomi dei bucket devono avere almeno 3 caratteri (`aws s3 mb s3://ab` fallisce con `InvalidBucketName`). Presso un provider reale i nomi sono anche univoci a livello globale e seguono le regole di denominazione DNS, perciò `lab-docs` è probabilmente già occupato: aggiungi un suffisso casuale.

### Passo 8 — Versioning, un delete marker e un ripristino
Crei un secondo bucket, attivi il versioning, sovrascrivi un oggetto ed eliminalo, poi recuperi la prima versione.

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

Output atteso (gli ID di versione sono diversi; la prima riga è la più recente):
```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
```

Due caricamenti sulla stessa chiave hanno creato **due versioni**: quella da 20 byte («version two, edited») è la corrente, e quella da 12 byte («version one») viene conservata. Copia l'ID della versione da 12 byte: ti serve più avanti come `<version-id-1>`. Ora elimina l'oggetto:

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

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

L'elenco del bucket è vuoto e uno scaricamento restituisce `404 Not Found`, eppure entrambe le versioni sono ancora presenti e un **delete marker** (la riga con un solo `True`) è ora la versione corrente. Nulla è stato cancellato. Ripristina la prima versione ricopiandola, in modo che diventi la versione più recente:

```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>` è l'ID della versione da 12 byte ricavato dall'elenco. Output atteso:
```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
```

Hai recuperato l'oggetto: la copia è una nuova terza versione con il vecchio contenuto ed è di nuovo quella corrente (il delete marker è ancora nella cronologia, nascosto sotto di essa). Per rimuovere i dati in modo definitivo elimineresti una versione specifica con `aws s3api delete-object --bucket lab-versioned --key notes.txt --version-id <id>`.

> [!NOTE]
> Eliminare il delete marker stesso (`delete-object` con il `--version-id` del marker) è l'altro modo per annullare un'eliminazione: la versione precedente torna a essere quella corrente. Nel nostro test ha funzionato su Moto, come accade su S3 reale.

### Passo 9 — Aggiungi una regola di lifecycle
Scrivi due regole: far scadere gli oggetti sotto `tmp/` dopo 30 giorni e far scadere le versioni non correnti dopo 90 giorni. Il file JSON contiene le regole e la CLI le memorizza e le rilegge.

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

Output atteso (l'ordine dei campi e la prima riga possono variare):
```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 memorizza e restituisce le regole di lifecycle ma **non le esegue mai**: gli oggetti qui non scadono, e non puoi aspettare 30 giorni per vederlo. Presso un provider reale, un processo in background applica le regole, di solito una volta al giorno. Hai fatto pratica con la parte che controlli tu: scrivere una regola corretta. Una regola con `Prefix` vuoto e `NoncurrentVersionExpiration` è il compagno abituale del versioning, perché le vecchie versioni non si accumulino all'infinito.

### Passo 10 — Condividi un oggetto con un URL prefirmato
L'oggetto `lab-docs/reports/2026/q3.txt` è privato. Provi a leggerlo senza credenziali, poi crei un URL che concede un minuto di accesso.

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

Output atteso (`X-Amz-Date` e la firma sono diversi):
```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
```

Osserva l'URL. Il percorso è l'oggetto. `X-Amz-Expires=60` è la durata in secondi, `X-Amz-Credential` indica la chiave che ha firmato (ma mai il segreto) e `X-Amz-Signature` dimostra che chi ha firmato ha autorizzato esattamente questa richiesta. Il bucket è rimasto privato e `curl` non ha usato credenziali: chiunque possieda l'URL ottiene l'oggetto. Cambia un solo carattere del percorso o della firma e la richiesta viene rifiutata.

> [!NOTE]
> Moto **non** applica la scadenza: l'URL continua a funzionare dopo i 60 secondi. Un provider reale restituisce `403 Forbidden` dopo la scadenza, ed è ciò che rende utili gli URL di breve durata. Non affidarti a questo emulatore per testare la logica di scadenza.

### Passo 11 — Apri un prefisso con una policy del bucket
Crei un bucket con un oggetto pubblico e uno privato, verifichi che entrambi vengano rifiutati agli utenti anonimi, poi aggiungi una **policy del bucket** (bucket policy) che consente a tutti di leggere solo `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
```

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

Ora scrivi la policy. `"Principal": "*"` significa tutti, comprese le persone senza un account:

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

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

Una sola istruzione ha esposto un prefisso a tutta Internet, mentre un altro oggetto nello stesso bucket è rimasto privato. Ora immagina la stessa policy con `"Resource": "arn:aws:s3:::lab-pub/*"`: ogni oggetto, compreso ciò che qualcuno caricherà l'anno prossimo. Questa differenza di un solo carattere è il modo in cui avviene la maggior parte delle fughe di dati da bucket pubblici. Nella policy, `Resource` è il punto in cui controlli il danno; presso un provider reale, il **block public access** è la rete di sicurezza che rifiuta del tutto una policy di questo tipo.

> [!NOTE]
> Moto non applica il block public access. Se esegui `aws s3api put-public-access-block --bucket lab-pub --public-access-block-configuration BlockPublicAcls=true,IgnorePublicAcls=true,BlockPublicPolicy=true,RestrictPublicBuckets=true`, memorizza e restituisce le impostazioni, ma una policy pubblica viene comunque accettata e servita. Presso un provider reale con `BlockPublicPolicy` attivo, il `put-bucket-policy` precedente viene rifiutato, e `RestrictPublicBuckets` blocca l'accesso pubblico anche da una policy esistente. Non siamo riusciti a verificare questi effetti qui, perciò controllali nella documentazione del tuo provider.

## Verifica
Controlla ogni risultato; ogni riga deve corrispondere.

1. Parte A: `podman volume inspect lab-storage-data --format '{{.Mountpoint}}'` stampa un percorso sotto la tua cartella home, e `ls "$(podman volume inspect lab-storage-data --format '{{.Mountpoint}}')"` elenca `both.log`, `note.txt`, `reader.txt` e `shared.log`.
2. Parte B, oggetti: `aws s3 ls s3://lab-docs --recursive` elenca esattamente una chiave, `reports/2026/q3.txt`.
3. Versioning: `aws s3 cp --no-progress s3://lab-versioned/notes.txt -` stampa `version one`, e `aws s3api list-object-versions --bucket lab-versioned --query 'length(Versions)'` stampa `3`.
4. Lifecycle: `aws s3api get-bucket-lifecycle-configuration --bucket lab-versioned --query 'Rules[].ID'` elenca `expire-tmp-after-30-days` e `clean-old-versions`.
5. URL prefirmato: un nuovo URL generato con `aws s3 presign` e richiesto con `curl` restituisce il testo, mentre l'URL non firmato restituisce `403`.
6. Policy: con la policy applicata, `reports/hi.txt` restituisce `200` e `other.txt` restituisce `403` (ripeti il comando della policy del Passo 11 se l'hai rimossa).

## Risoluzione dei problemi
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| `Could not connect to the endpoint URL: "http://127.0.0.1:9101/"` | Il container Moto non è in esecuzione, oppure l'hai riavviato | `podman ps --filter name=lab-storage`; avvialo con `podman start lab-storage-moto`. Moto conserva i dati in memoria, quindi un riavvio svuota ogni bucket: ripeti i Passi da 7 a 11 |
| `Error: ... address already in use` per la porta 9101 | Un altro programma o container usa la porta | Individualo con `ss -ltn \| grep 9101`; ferma il tuo container precedente, oppure cambia il primo numero in `-p 127.0.0.1:9101:5000` e in `--endpoint-url` |
| `aws: command not found` | La funzione di shell è definita solo nel terminale in cui hai eseguito il Passo 6 | Definiscila di nuovo in questo terminale |
| `Permission denied` quando il container AWS CLI legge `report.txt` | SELinux blocca il bind mount, oppure hai rimosso `:Z` | Mantieni `:Z` nella funzione ed esegui da `~/storage-lab` |
| `make_bucket failed ... InvalidBucketName` | Il nome è più corto di 3 caratteri o contiene caratteri non validi | Usa lettere minuscole, cifre e trattini, con almeno 3 caratteri |
| `dd: failed to open ... Invalid argument` nel Passo 5 | La cartella si trova su un filesystem senza supporto all'I/O diretto, come `tmpfs` | Esegui il laboratorio da una cartella su un disco normale, oppure rimuovi `oflag=direct` (i numeri misureranno allora la cache) |
| `debugfs: command not found` o `mkfs.ext4: command not found` | `e2fsprogs` non è installato | Installalo, oppure salta il Passo 4 facoltativo |
| `curl` restituisce `403` per l'URL prefirmato | L'URL è stato troncato dalla shell (a causa dei caratteri `&`), oppure l'hai modificato | Conservalo in una variabile e racchiudilo tra virgolette: `curl "$URL"` |

## Sfida (facoltativa)
Crea un bucket chiamato `lab-site` e carica un piccolo `index.html` sotto il prefisso `site/`. Scrivi una policy del bucket che consenta `GET` anonimo solo per `site/*`, verificalo con `curl`, poi modifica `Resource` in modo che esponga anche un prefisso `private/`. Confronta le due policy ed elenca quali controlli della lezione (block public access, policy a privilegio minimo, URL prefirmati) avrebbero bloccato la seconda presso un provider reale. Poi usa `aws s3 sync ./site s3://lab-site/site` per caricare una cartella e `aws s3 rm s3://lab-site --recursive` per rimuoverla.

## Pulizia
Rimuovi ogni container, volume e file creato dal laboratorio. L'ultimo comando, che rimuove le tre immagini, è facoltativo: saltalo se le usi per altro.

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

Verifica che non sia rimasto nulla:
```bash
podman ps -a --filter name=lab-storage --format '{{.Names}}'
podman volume ls --filter name=lab-storage
```

Entrambi i comandi non devono stampare nulla, a parte l'intestazione della tabella dei volumi.

## Cosa hai imparato
- Un volume Podman è una directory, non un dispositivo a blocchi. Un vero volume a blocchi offre capacità grezza con IOPS, throughput e latenza propri, e un'istanza vi gestisce il filesystem; una condivisione di file gestisce il filesystem per molti client.
- Il throughput è uguale alle IOPS per la dimensione dell'operazione, quindi le operazioni piccole sono limitate dalle IOPS e quelle grandi dal throughput.
- Si accede allo storage a oggetti tramite un'API HTTP (l'API S3) con un bucket, una chiave e dei metadati; i prefissi hanno solo l'aspetto di cartelle. Per passare da un servizio compatibile con S3 a un altro basta cambiare l'endpoint.
- Il versioning trasforma un'eliminazione in un delete marker e conserva ogni versione, quindi un ripristino è la copia di una versione precedente. Le regole di lifecycle, scritte una sola volta, fanno scadere i dati in automatico presso un provider reale.
- Un URL prefirmato concede un accesso di breve durata a un solo oggetto privato, mentre una policy del bucket troppo ampia rende i dati pubblici per tutti: mantieni attivo il block public access e limita con precisione `Resource`.