CloudAcademia
ES

Computación en la nube · Módulo 08 · Almacenamiento en la nube: bloques, archivos y objetos

Laboratorio: volúmenes de bloques y un almacén de objetos

Laboratorio75 minPrincipianteMarkdown

Mostrando el Markdown sin formato: no se pudo cargar el visor.

## Objetivo
Compara lo que te da un volumen compartido por dos contenedores con lo que añade un dispositivo de bloques real, y después ejecuta un almacén de objetos local compatible con S3 y úsalo como usarías un bucket en la nube: sube y lista objetos, activa el versionado y recupera un objeto borrado, escribe una regla de ciclo de vida, comparte un objeto con una URL prefirmada y abre un prefijo al público con una política de bucket.

## Objetivos
- Comparar un volumen de un solo usuario con un volumen compartido por dos contenedores, y explicar qué añade un dispositivo de bloques real (objetivo 1).
- Crear buckets y subir, listar, descargar y borrar objetos mediante la API S3, y comprobar que los prefijos no son carpetas (objetivo 3).
- Activar el versionado, ver un marcador de borrado y restaurar una versión anterior (objetivo 3).
- Añadir y leer una regla de ciclo de vida (objetivos 2 y 3).
- Compartir un objeto con una URL prefirmada y abrir un prefijo con una política de bucket, y explicar por qué los buckets públicos son arriesgados (objetivo 4).

## Requisitos previos
- Linux con Podman 4 o posterior, sin privilegios de root, sin `sudo` (probado con Podman 5.8). Docker sirve si sustituyes `podman` por `docker`.
- `curl`. Solo para el Paso 4 opcional: `mkfs.ext4` y `debugfs` del paquete `e2fsprogs` (instalado por defecto en la mayoría de las distribuciones).
- Acceso a Internet para descargar tres imágenes la primera vez: `docker.io/library/alpine:3.20`, `docker.io/motoserver/moto:5.2.4` y `docker.io/amazon/aws-cli:2.38.0` (unos cientos de MB en total).
- El puerto TCP 9101 libre en `127.0.0.1`.
- [La lección](lesson.es.md) de este módulo.

> [!WARNING]
> Todo se ejecuta en tu equipo: el almacén de objetos escucha solo en `127.0.0.1`, y las claves `test`/`test` son ficticias y solo funcionan contra él. No interviene ninguna cuenta, tarjeta ni recurso real de la nube, así que no hay nada que facturar. Todos los contenedores y volúmenes empiezan por `lab-storage-` y los archivos de trabajo viven en `~/storage-lab`; la Limpieza los elimina. No pongas nunca datos ni credenciales reales en este laboratorio.

> [!NOTE]
> Las salidas se capturaron en noviembre de 2026 con Podman 5.8.7. Las fechas, los ID de versión, los ETag y las firmas serán distintos en tu equipo; compara la estructura, no los valores exactos. La Parte B usa **Moto**, un emulador de código abierto de las API de Amazon Web Services (AWS). Es una herramienta didáctica: funciona sin comprobaciones de autenticación, guarda sus datos en memoria y no implementa todos los comportamientos de un almacén de objetos real. Las notas de los pasos indican dónde se diferencia.

## Arquitectura
<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-es-title storage-lab-architecture-es-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="es">
<title id="storage-lab-architecture-es-title">Arquitectura del laboratorio: volúmenes de Podman y un servidor local compatible con S3</title>
<desc id="storage-lab-architecture-es-desc">Tu ordenador Linux ejecuta Podman sin root. Parte A: un contenedor escritor, lab-storage-writer, y un contenedor lector, lab-storage-reader, montan ambos el volumen con nombre lab-storage-data en /data; el volumen es un directorio del host, no un dispositivo de bloques. Parte B: un contenedor con AWS CLI versión 2, docker.io/amazon/aws-cli:2.38.0, ejecutado mediante una función de shell con la carpeta ~/storage-lab montada como /work, envía peticiones de la API S3 por HTTP a 127.0.0.1 puerto 9101. Ese puerto está asignado al puerto 5000 del contenedor Moto lab-storage-moto, un emulador de S3 que acepta las claves ficticias test y test y no exige autenticación, y que contiene los buckets lab-docs, lab-versioned y 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">Tu ordenador (Linux, Podman sin 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">Parte A: volúmenes</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: almacenamiento de objetos</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">Contenedor: escritor</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">añade líneas 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">Contenedor: lector</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">lee los mismos archivos</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">Volumen con nombre: lab-storage-data</text></g>
<text x="78" y="338" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">montado en /data en ambos contenedores</text>
<text x="78" y="358" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">un directorio del host, no un dispositivo de bloques</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">Contenedor con 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">función de 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">Contenedor 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">puerto 9101 → 5000 · claves test/test, sin autenticación</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 emulador de la API S3, no un almacén duradero</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="681.52" y="218" width="236.96" 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 sobre HTTP · 127.0.0.1:9101</text></g>
</svg></figure>

*Figura 1. La Parte A usa un volumen de Podman desde dos contenedores; la Parte B envía solicitudes de la API S3 desde el contenedor de la AWS CLI a un servidor compatible con S3 en `127.0.0.1:9101`.*

## Pasos

### Parte A: almacenamiento en bloques y compartición similar a archivos

### Paso 1 — Crea una carpeta de trabajo y un volumen
Guardas todos los archivos del laboratorio en una sola carpeta, para que la limpieza sea fácil. Un **volumen con nombre** de Podman es almacenamiento que sobrevive a un contenedor. Crea uno y dale un nombre reconocible.

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

Salida esperada:
```text
podman version 5.8.7
lab-storage-data
```

> [!WARNING]
> Ejecuta todos los comandos siguientes desde `~/storage-lab`. En la Parte B, la función `aws` monta la carpeta actual en un contenedor con `:Z`, que la reetiqueta para SELinux. Si la ejecutas desde tu carpeta personal, reetiquetaría toda.

### Paso 2 — Usa el volumen desde un contenedor
Montas el volumen en `/data` en un contenedor de corta vida, escribes un archivo y después lo lees desde un segundo contenedor para ver que los datos sobreviven al primero.

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

Salida esperada:
```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 última línea es lo importante: un volumen de Podman es **solo un directorio del sistema de archivos del propio host** (`<user>` es tu nombre de usuario). No es un dispositivo de bloques: no tiene un tamaño fijo, ni un nombre de dispositivo, ni un sistema de archivos propio. Es un sustituto cómodo de la idea de "almacenamiento que sobrevive al cómputo".

### Paso 3 — Comparte el volumen entre dos contenedores a la vez
Un recurso compartido de archivos real (NFS o SMB) permite que muchas máquinas usen los mismos archivos al mismo tiempo. Aquí las dos "máquinas" son contenedores en el mismo host. Inicia un escritor en segundo plano y luego lee desde un segundo contenedor mientras se ejecuta.

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

Salida esperada (el número de líneas depende del momento):
```text
writer line 1
writer line 2
writer line 3
writer line 4
note.txt
reader.txt
shared.log
```

El lector ve el archivo del escritor mientras este sigue en ejecución, y su propio archivo es visible para el escritor. Ahora detén el escritor y comprueba qué ocurre cuando dos contenedores añaden datos al mismo archivo a la vez:

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

Salida esperada (las líneas A y B se intercalan; el orden exacto puede variar):
```text
A1
B1
A2
B2
A3
B3
A4
B4
A5
B5
```

Ambos contenedores escribieron en un mismo archivo sin corromperlo. Funciona porque el **sistema de archivos** (el del host) está por debajo de ambos contenedores y los coordina: el mismo trabajo que hacen los servidores NFS o SMB en un recurso compartido de archivos en red. Un recurso compartido de archivos te da esto entre muchas máquinas.

Ahora piensa qué es un **dispositivo de bloques** real y qué cambiaría:

| | Volumen de Podman (este laboratorio) | Volumen de bloques real (disco en la nube) |
|---|---|---|
| Qué es | Un directorio del sistema de archivos del host | Un dispositivo en bruto (`/dev/vdb`) de tamaño fijo |
| Quién ejecuta el sistema de archivos | El host, para todos los usuarios | La única instancia que lo monta |
| Varios escritores a la vez | Sí, el sistema de archivos del host los coordina | No con un sistema de archivos normal como ext4: dos máquinas guardarían en caché y actualizarían los metadatos cada una por su cuenta y lo corromperían |
| Garantías de rendimiento | Ninguna | IOPS, rendimiento y latencia aprovisionados |
| Sobrevive a la pérdida de la instancia | Solo mientras viva el disco del host | Sí, lo vuelves a conectar a otra instancia |

### Paso 4 — Observa un sistema de archivos sobre un dispositivo de bloques (opcional)
No puedes crear un dispositivo de bloques real sin derechos de administrador, pero un archivo normal sirve como "disco virtual": un dispositivo de bloques es solo una matriz de bloques, y un archivo puede contener una. Formateas el archivo con ext4 y lo lees con `debugfs`, una herramienta que inspecciona una imagen ext4 sin montarla. Omite este paso si `mkfs.ext4` o `debugfs` no están instalados.

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

Salida esperada (abreviada; el UUID y las horas serán distintos):
```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
```

El archivo de 64 MiB contiene ahora un sistema de archivos completo, con una tabla de inodos, un directorio `lost+found` y tu archivo. En una nube, un volumen de bloques es lo mismo a mayor escala: recibes capacidad en bruto y *tú* decides qué sistema de archivos se pone encima.

### Paso 5 — Mide las IOPS y el rendimiento
El mismo disco puede parecer rápido o lento según el tamaño de cada operación. Escribes la misma cantidad de datos de dos maneras con `dd`, saltándote la caché (`oflag=direct`) para medir el almacenamiento y no 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
```

Salida esperada (tus números serán distintos; algunas configuraciones regionales usan coma decimal):
```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
```

El primer comando hace 256 operaciones de 1 MiB; el segundo hace 20 000 operaciones de 4 KiB. En esta captura, el segundo hizo aproximadamente 20 000 operaciones en un segundo (unas 20 000 IOPS) pero movió muchos menos bytes por segundo. **Rendimiento = IOPS × tamaño de la operación**: las operaciones pequeñas están limitadas por las IOPS y las grandes, por el rendimiento. Por eso una base de datos (muchas operaciones pequeñas) y una tarea de copia de seguridad (pocas operaciones grandes) necesitan ajustes de volumen distintos.

> [!NOTE]
> Esto mide el disco y el sistema de archivos de tu equipo, no un volumen en la nube. Solo pretende mostrar la relación entre el tamaño de la operación, las IOPS y el rendimiento. Los volúmenes reales publican sus límites de IOPS y de rendimiento aprovisionados.

### Parte B: almacenamiento de objetos

### Paso 6 — Inicia el almacén de objetos y define el cliente
Ejecutas Moto, un servidor compatible con S3, en un contenedor. El puerto 5000 del interior del contenedor se publica solo en `127.0.0.1:9101` de tu equipo. Después defines `aws`, una función de shell que ejecuta la interfaz de línea de comandos (CLI) de AWS versión 2 en un contenedor, apuntando a tu servidor, con claves ficticias. `:Z` reetiqueta la carpeta para SELinux y es inofensivo en otros sistemas.

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

Salida esperada:
```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 función existe solo en esta terminal. Si abres una nueva, vuelve a definirla (y haz `cd ~/storage-lab`). Como la CLI se ejecuta en un contenedor, cada llamada inicia un contenedor (alrededor de un segundo).

La única diferencia respecto a usar una nube real es `--endpoint-url`: quítalo, usa claves reales y los mismos comandos hablan con un proveedor real. Eso es lo que significa "la API S3 como estándar" en la práctica.

### Paso 7 — Buckets, objetos, prefijos y metadatos
Creas un bucket, subes dos objetos y los listas. Fíjate en cómo `reports/2026/q3.txt` aparece como una "carpeta".

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

Salida esperada:
```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
```

El listado muestra `PRE reports/` ("prefijo"), no una carpeta. Con `--recursive` ves lo que está realmente almacenado: dos objetos cuyas **claves** son `readme.txt` y `reports/2026/q3.txt`. Ahora lee los metadatos, descarga un objeto y bórralo:

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

Salida esperada (el `ETag` y la fecha varían):
```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
```

El `ETag` es el identificador del contenido (un hash MD5 en una subida simple). El bloque `Metadata` contiene los pares personalizados que has definido. Sin versionado, el borrado es definitivo: el objeto desaparece.

> [!NOTE]
> Los nombres de bucket deben tener al menos 3 caracteres (`aws s3 mb s3://ab` falla con `InvalidBucketName`). En un proveedor real, los nombres además son únicos globalmente y siguen las reglas de nomenclatura DNS, así que `lab-docs` probablemente esté ocupado: añade un sufijo aleatorio.

### Paso 8 — Versionado, un marcador de borrado y una restauración
Creas un segundo bucket, activas el versionado, sobrescribes un objeto y lo borras, y después recuperas la primera versión.

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

Salida esperada (los ID de versión serán distintos; la primera fila es la más reciente):
```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
```

Dos subidas a una misma clave crearon **dos versiones**: los 20 bytes ("version two, edited") son la actual, y los 12 bytes ("version one") se conservan. Copia el ID de la versión de 12 bytes: lo necesitas más abajo como `<version-id-1>`. Ahora borra el objeto:

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

Salida esperada:
```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
```

El listado del bucket está vacío y una descarga dice `404 Not Found`, pero las dos versiones siguen ahí y un **marcador de borrado** (la línea con un único `True`) es ahora la versión actual. No se ha borrado nada. Restaura la primera versión copiándola de nuevo para que pase a ser la más reciente:

```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>` es el ID de la versión de 12 bytes del listado. Salida esperada:
```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
```

Has recuperado el objeto: la copia es una tercera versión nueva con el contenido antiguo, y vuelve a ser la actual (el marcador de borrado sigue en el historial, oculto por debajo). Para eliminar los datos definitivamente borrarías una versión concreta con `aws s3api delete-object --bucket lab-versioned --key notes.txt --version-id <id>`.

> [!NOTE]
> Borrar el propio marcador de borrado (`delete-object` con el `--version-id` del marcador) es la otra forma de deshacer un borrado: la versión anterior vuelve a ser la actual. Funcionó en nuestra prueba con Moto, igual que en S3 real.

### Paso 9 — Añade una regla de ciclo de vida
Escribes dos reglas: hacer caducar los objetos bajo `tmp/` a los 30 días y hacer caducar las versiones no actuales a los 90 días. El archivo JSON contiene las reglas, y la CLI las guarda y las vuelve a leer.

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

Salida esperada (el orden de los campos y la primera línea pueden variar):
```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 guarda y devuelve las reglas de ciclo de vida, pero **nunca las ejecuta**: aquí los objetos no caducan, y no puedes esperar 30 días para verlo. En un proveedor real, un proceso en segundo plano aplica las reglas, normalmente una vez al día. Has practicado la parte que controlas: escribir una regla correcta. Una regla con `Prefix` vacío y `NoncurrentVersionExpiration` es la compañera habitual del versionado, para que las versiones antiguas no se acumulen para siempre.

### Paso 10 — Comparte un objeto con una URL prefirmada
El objeto `lab-docs/reports/2026/q3.txt` es privado. Intentas leerlo sin credenciales y después creas una URL que concede un minuto de acceso.

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

Salida esperada (`X-Amz-Date` y la firma serán distintos):
```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
```

Fíjate en la URL. La ruta es el objeto. `X-Amz-Expires=60` es la duración en segundos, `X-Amz-Credential` nombra la clave que la firmó (pero nunca el secreto) y `X-Amz-Signature` demuestra que quien firmó autorizó exactamente esta solicitud. El bucket siguió siendo privado y `curl` no usó credenciales: quien tenga la URL obtiene el objeto. Cambia un carácter de la ruta o de la firma y la solicitud se rechaza.

> [!NOTE]
> Moto **no** aplica la caducidad: la URL sigue funcionando pasados los 60 segundos. Un proveedor real devuelve `403 Forbidden` tras la caducidad, y eso es lo que hace útiles las URL de corta duración. No te fíes de este emulador para probar la lógica de caducidad.

### Paso 11 — Abre un prefijo con una política de bucket
Creas un bucket con un objeto público y otro privado, confirmas que ambos se rechazan a los usuarios anónimos y después añades una **política de bucket** que permite a todo el mundo leer 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
```

Salida esperada:
```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
```

Ahora escribe la política. `"Principal": "*"` significa todo el mundo, incluidas las personas sin cuenta:

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

Salida esperada:
```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 sentencia expuso un prefijo a todo Internet, y otro objeto del mismo bucket siguió siendo privado. Ahora imagina la misma política con `"Resource": "arn:aws:s3:::lab-pub/*"`: todos los objetos, incluido lo que alguien suba el año que viene. Esa diferencia de un solo carácter es la forma en que se producen la mayoría de las filtraciones por buckets públicos. En la política, `Resource` es donde controlas el daño; en un proveedor real, el **bloqueo de acceso público** (block public access) es la red de seguridad que rechaza por completo una política así.

> [!NOTE]
> Moto no aplica el bloqueo de acceso público. Si ejecutas `aws s3api put-public-access-block --bucket lab-pub --public-access-block-configuration BlockPublicAcls=true,IgnorePublicAcls=true,BlockPublicPolicy=true,RestrictPublicBuckets=true`, guarda y devuelve los ajustes, pero una política pública se sigue aceptando y sirviendo. En un proveedor real con `BlockPublicPolicy` activado, el `put-bucket-policy` anterior se rechaza, y `RestrictPublicBuckets` bloquea el acceso público incluso desde una política ya existente. No hemos podido verificar esos efectos aquí, así que compruébalos en la documentación de tu proveedor.

## Verificación
Comprueba cada resultado; todas las líneas deben coincidir.

1. Parte A: `podman volume inspect lab-storage-data --format '{{.Mountpoint}}'` muestra una ruta dentro de tu carpeta personal, y `ls "$(podman volume inspect lab-storage-data --format '{{.Mountpoint}}')"` lista `both.log`, `note.txt`, `reader.txt` y `shared.log`.
2. Parte B, objetos: `aws s3 ls s3://lab-docs --recursive` lista exactamente una clave, `reports/2026/q3.txt`.
3. Versionado: `aws s3 cp --no-progress s3://lab-versioned/notes.txt -` muestra `version one`, y `aws s3api list-object-versions --bucket lab-versioned --query 'length(Versions)'` muestra `3`.
4. Ciclo de vida: `aws s3api get-bucket-lifecycle-configuration --bucket lab-versioned --query 'Rules[].ID'` lista `expire-tmp-after-30-days` y `clean-old-versions`.
5. URL prefirmada: una URL nueva de `aws s3 presign` solicitada con `curl` devuelve el texto, mientras que la URL sin firmar devuelve `403`.
6. Política: con la política aplicada, `reports/hi.txt` devuelve `200` y `other.txt` devuelve `403` (repite el comando de política del Paso 11 si la habías eliminado).

## Resolución de problemas
| Síntoma | Causa probable | Solución |
|---|---|---|
| `Could not connect to the endpoint URL: "http://127.0.0.1:9101/"` | El contenedor de Moto no está en ejecución, o lo has reiniciado | `podman ps --filter name=lab-storage`; inícialo con `podman start lab-storage-moto`. Moto guarda sus datos en memoria, así que un reinicio vacía todos los buckets: repite los Pasos 7 a 11 |
| `Error: ... address already in use` para el puerto 9101 | Otro programa o contenedor usa el puerto | Búscalo con `ss -ltn \| grep 9101`; detén tu contenedor anterior o cambia el primer número en `-p 127.0.0.1:9101:5000` y en `--endpoint-url` |
| `aws: command not found` | La función de shell está definida solo en la terminal donde ejecutaste el Paso 6 | Vuelve a definirla en esta terminal |
| `Permission denied` cuando el contenedor de la AWS CLI lee `report.txt` | SELinux bloquea el montaje bind, o has quitado `:Z` | Mantén `:Z` en la función y ejecuta desde `~/storage-lab` |
| `make_bucket failed ... InvalidBucketName` | El nombre tiene menos de 3 caracteres o caracteres no válidos | Usa letras minúsculas, dígitos y guiones, con 3 caracteres o más |
| `dd: failed to open ... Invalid argument` en el Paso 5 | La carpeta está en un sistema de archivos sin soporte de E/S directa, como `tmpfs` | Ejecuta el laboratorio desde una carpeta de un disco normal, o quita `oflag=direct` (los números medirán entonces la caché) |
| `debugfs: command not found` o `mkfs.ext4: command not found` | `e2fsprogs` no está instalado | Instálalo, u omite el Paso 4 opcional |
| `curl` devuelve `403` con la URL prefirmada | El shell cortó la URL (por los caracteres `&`), o la has modificado | Guárdala en una variable y entrecomíllala: `curl "$URL"` |

## Reto (opcional)
Crea un bucket llamado `lab-site` y sube un pequeño `index.html` bajo el prefijo `site/`. Escribe una política de bucket que permita `GET` anónimo solo para `site/*`, compruébalo con `curl` y después cambia `Resource` para que también exponga un prefijo `private/`. Compara las dos políticas y enumera cuáles de los controles de la lección (bloqueo de acceso público, política de mínimo privilegio, URL prefirmadas) habrían detenido la segunda en un proveedor real. Después usa `aws s3 sync ./site s3://lab-site/site` para subir una carpeta y `aws s3 rm s3://lab-site --recursive` para eliminarla.

## Limpieza
Elimina todos los contenedores, volúmenes y archivos que creó el laboratorio. El último comando, que elimina las tres imágenes, es opcional: omítelo si las usas para otra cosa.

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

Confirma que no queda nada:
```bash
podman ps -a --filter name=lab-storage --format '{{.Names}}'
podman volume ls --filter name=lab-storage
```

Ambos comandos no deben mostrar nada, salvo la cabecera de la tabla de volúmenes.

## Qué has aprendido
- Un volumen de Podman es un directorio, no un dispositivo de bloques. Un volumen de bloques real te da capacidad en bruto con sus propias IOPS, rendimiento y latencia, y una instancia ejecuta el sistema de archivos sobre él; un recurso compartido de archivos ejecuta el sistema de archivos para muchos clientes.
- El rendimiento es igual a las IOPS por el tamaño de la operación, así que las operaciones pequeñas están limitadas por las IOPS y las grandes, por el rendimiento.
- El almacenamiento de objetos se accede mediante una API HTTP (la API S3) con un bucket, una clave y metadatos; los prefijos solo parecen carpetas. Cambiar el endpoint es todo lo que hace falta para pasar de un servicio compatible con S3 a otro.
- El versionado convierte un borrado en un marcador de borrado y conserva todas las versiones, así que una restauración es una copia de una versión anterior. Las reglas de ciclo de vida, escritas una vez, hacen caducar los datos automáticamente en un proveedor real.
- Una URL prefirmada da acceso de corta duración a un objeto privado, mientras que una política de bucket demasiado amplia hace públicos los datos para todo el mundo: mantén activado el bloqueo de acceso público y acota bien `Resource`.