CloudAcademia
PL

Chmura obliczeniowa · Moduł 08 · Magazyn w chmurze: blokowy, plikowy i obiektowy

Laboratorium: wolumeny blokowe i magazyn obiektów

Laboratorium75 minPoczątkującyMarkdown

Wyświetlany jest surowy Markdown: nie udało się wczytać renderera.

## Cel
Porównujesz to, co daje wolumen współdzielony przez dwa kontenery, z tym, co dodaje prawdziwe urządzenie blokowe, a następnie uruchamiasz lokalny magazyn obiektów zgodny z S3 i używasz go tak, jak używa się bucketu w chmurze: wysyłasz i wyświetlasz obiekty, włączasz wersjonowanie i odzyskujesz usunięty obiekt, piszesz regułę cyklu życia, udostępniasz obiekt przez podpisany z góry adres URL i otwierasz prefiks dla wszystkich za pomocą polityki bucketu.

## Cele nauki
- Porównać wolumen jednego użytkownika z wolumenem współdzielonym przez dwa kontenery i wyjaśnić, co dodaje prawdziwe urządzenie blokowe (cel 1).
- Tworzyć buckety oraz wysyłać, wyświetlać, pobierać i usuwać obiekty przez API S3, i zobaczyć, że prefiksy nie są folderami (cel 3).
- Włączyć wersjonowanie, zobaczyć znacznik usunięcia i przywrócić wcześniejszą wersję (cel 3).
- Dodać regułę cyklu życia i odczytać ją z powrotem (cele 2 i 3).
- Udostępnić obiekt przez podpisany z góry adres URL i otworzyć jeden prefiks polityką bucketu, a także wyjaśnić, dlaczego publiczne buckety są ryzykowne (cel 4).

## Wymagania wstępne
- Linux z Podmanem 4 lub nowszym, w trybie rootless, bez `sudo` (przetestowano na Podmanie 5.8). Docker też działa, jeśli zamienisz `podman` na `docker`.
- `curl`. Tylko do opcjonalnego Kroku 4: `mkfs.ext4` i `debugfs` z pakietu `e2fsprogs` (w większości dystrybucji instalowany domyślnie).
- Dostęp do Internetu, aby przy pierwszym uruchomieniu pobrać trzy obrazy: `docker.io/library/alpine:3.20`, `docker.io/motoserver/moto:5.2.4` i `docker.io/amazon/aws-cli:2.38.0` (łącznie kilkaset MB).
- Wolny port TCP 9101 na `127.0.0.1`.
- [Lekcja](lesson.pl.md) z tego modułu.

> [!WARNING]
> Wszystko działa na Twoim komputerze: magazyn obiektów nasłuchuje wyłącznie na `127.0.0.1`, a klucze `test`/`test` to atrapy, które działają tylko z nim. Nie jest zaangażowane żadne konto, karta ani prawdziwy zasób w chmurze, więc nie ma czego rozliczać. Wszystkie kontenery i wolumeny zaczynają się od `lab-storage-`, a pliki robocze leżą w `~/storage-lab`; sprzątanie je usuwa. Nigdy nie umieszczaj w tym laboratorium prawdziwych danych ani prawdziwych poświadczeń.

> [!NOTE]
> Wyniki zarejestrowano w listopadzie 2026 r. na Podmanie 5.8.7. Daty, identyfikatory wersji, ETagi i podpisy na Twoim komputerze będą inne; porównuj strukturę, a nie dokładne wartości. Część B używa **Moto**, emulatora API Amazon Web Services (AWS) typu open source. To narzędzie dydaktyczne: działa bez sprawdzania uwierzytelnienia, trzyma dane w pamięci i nie implementuje każdego zachowania prawdziwego magazynu obiektów. Uwagi w krokach wskazują, gdzie się różni.

## Architektura
<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-pl-title storage-lab-architecture-pl-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="pl">
<title id="storage-lab-architecture-pl-title">Architektura laboratorium: wolumeny Podmana i lokalny serwer zgodny z S3</title>
<desc id="storage-lab-architecture-pl-desc">Twój komputer z Linuksem uruchamia Podmana bez roota. Część A: kontener zapisujący, lab-storage-writer, oraz kontener czytający, lab-storage-reader, montują oba wolumen nazwany lab-storage-data w /data; wolumen to katalog na hoście, a nie urządzenie blokowe. Część B: kontener z AWS CLI w wersji 2, docker.io/amazon/aws-cli:2.38.0, uruchamiany przez funkcję powłoki z katalogiem ~/storage-lab zamontowanym jako /work, wysyła żądania API S3 przez HTTP na 127.0.0.1 port 9101. Ten port jest przekierowany na port 5000 kontenera Moto lab-storage-moto, emulatora S3, który przyjmuje fikcyjne klucze test i test i nie wymusza uwierzytelniania, i który przechowuje buckety lab-docs, lab-versioned i 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">Twój komputer (Linux, Podman bez roota)</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">Część A: wolumeny</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">Część B: magazyn obiektów</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">Kontener: zapisujący</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">dopisuje do 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">Kontener: czytający</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">czyta te same pliki</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">Wolumen nazwany: lab-storage-data</text></g>
<text x="78" y="338" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">zamontowany w /data w obu kontenerach</text>
<text x="78" y="358" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">katalog na hoście, nie urządzenie blokowe</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">Kontener 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">funkcja powłoki 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">Kontener 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 · klucze test/test, bez uwierzytelniania</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">buckety: lab-docs · lab-versioned · lab-pub</text>
<text x="578" y="370" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">emulator API S3, a nie trwały magazyn</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 przez HTTP · 127.0.0.1:9101</text></g>
</svg></figure>

*Rysunek 1. Część A używa wolumenu Podmana z dwóch kontenerów; Część B wysyła żądania API S3 z kontenera AWS CLI do serwera zgodnego z S3 na `127.0.0.1:9101`.*

## Kroki

### Część A: magazyn blokowy i współdzielenie jak w magazynie plikowym

### Krok 1 — Utwórz folder roboczy i wolumen
Wszystkie pliki laboratorium trzymasz w jednym folderze, więc sprzątanie jest proste. Nazwany wolumen (**named volume**) Podmana to magazyn, który przeżywa kontener. Utwórz go i nadaj łatwo rozpoznawalną nazwę.

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

Oczekiwany wynik:
```text
podman version 5.8.7
lab-storage-data
```

> [!WARNING]
> Każde kolejne polecenie uruchamiaj z `~/storage-lab`. W Części B funkcja `aws` montuje bieżący folder w kontenerze z opcją `:Z`, która zmienia etykiety SELinux. Uruchomiona z folderu domowego zmieniłaby etykiety całego folderu.

### Krok 2 — Użyj wolumenu z jednego kontenera
Montujesz wolumen w `/data` w krótkotrwałym kontenerze, zapisujesz plik, a następnie odczytujesz go z drugiego kontenera, aby zobaczyć, że dane przeżywają pierwszy.

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

Oczekiwany wynik:
```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
```

Ostatni wiersz jest tu najważniejszy: wolumen Podmana to **po prostu katalog w systemie plików hosta** (`<user>` to Twoja nazwa użytkownika). Nie jest urządzeniem blokowym: nie ma stałego rozmiaru, nazwy urządzenia ani własnego systemu plików. To wygodny zastępnik idei „magazynu, który przeżywa moc obliczeniową”.

### Krok 3 — Współdziel wolumen między dwoma kontenerami jednocześnie
Prawdziwy udział plików (NFS lub SMB) pozwala wielu maszynom korzystać z tych samych plików naraz. Tutaj te dwie „maszyny” to kontenery na tym samym hoście. Uruchom proces zapisujący w tle, a potem odczytaj dane z drugiego kontenera, gdy pierwszy działa.

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

Oczekiwany wynik (liczba wierszy zależy od czasu):
```text
writer line 1
writer line 2
writer line 3
writer line 4
note.txt
reader.txt
shared.log
```

Kontener czytający widzi plik zapisującego, gdy ten jeszcze działa, a jego własny plik jest widoczny dla zapisującego. Teraz zatrzymaj zapisującego i zobacz, co się dzieje, gdy dwa kontenery dopisują do tego samego pliku jednocześnie:

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

Oczekiwany wynik (wiersze A i B się przeplatają; dokładna kolejność może być inna):
```text
A1
B1
A2
B2
A3
B3
A4
B4
A5
B5
```

Oba kontenery pisały do jednego pliku bez jego uszkodzenia. Dzieje się tak, ponieważ **system plików** (hosta) leży pod obydwoma kontenerami i je koordynuje: to samo zadanie wykonują serwery NFS lub SMB dla sieciowego udziału plików. Udział plików daje to samo na wielu maszynach.

Zastanów się teraz, czym jest prawdziwe **urządzenie blokowe** i co by zmieniło:

| | Wolumen Podmana (to laboratorium) | Prawdziwy wolumen blokowy (dysk w chmurze) |
|---|---|---|
| Czym jest | Katalogiem w systemie plików hosta | Surowym urządzeniem (`/dev/vdb`) o stałym rozmiarze |
| Kto prowadzi system plików | Host, dla wszystkich użytkowników | Ta jedna instancja, która go montuje |
| Kilku piszących naraz | Tak, system plików hosta ich koordynuje | Nie ze zwykłym systemem plików, jak ext4: dwie maszyny buforowałyby i aktualizowały metadane każda osobno i uszkodziłyby je |
| Gwarancje wydajności | Brak | Zapewnione IOPS, przepustowość i opóźnienie |
| Przetrwanie utraty instancji | Tylko dopóki żyje dysk hosta | Tak, podłączasz go ponownie do innej instancji |

### Krok 4 — Zobacz system plików na urządzeniu blokowym (opcjonalnie)
Bez uprawnień administratora nie da się utworzyć prawdziwego urządzenia blokowego, ale zwykły plik może posłużyć jako „wirtualny dysk”: urządzenie blokowe to po prostu tablica bloków, a plik może ją zawierać. Formatujesz plik jako ext4 i odczytujesz go przez `debugfs`, narzędzie, które bada obraz ext4 bez montowania. Pomiń ten krok, jeśli `mkfs.ext4` lub `debugfs` nie jest zainstalowane.

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

Oczekiwany wynik (skrócony; UUID i czasy będą inne):
```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
```

Plik o rozmiarze 64 MiB zawiera teraz kompletny system plików z tablicą i-węzłów, katalogiem `lost+found` i Twoim plikiem. W chmurze wolumen blokowy to to samo w większej skali: dostajesz surową pojemność, a o tym, jaki system plików na niej powstanie, decydujesz *Ty*.

### Krok 5 — Zmierz IOPS i przepustowość
Ten sam dysk może wydawać się szybki lub wolny w zależności od rozmiaru pojedynczej operacji. Zapisujesz tę samą ilość danych na dwa sposoby za pomocą `dd`, z pominięciem pamięci podręcznej (`oflag=direct`), aby mierzyć magazyn, a nie pamięć.

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

Oczekiwany wynik (Twoje liczby będą inne; niektóre ustawienia regionalne wypisują przecinek dziesiętny):
```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
```

Pierwsze polecenie wykonuje 256 operacji po 1 MiB; drugie 20 000 operacji po 4 KiB. W tym pomiarze drugie wykonało około 20 000 operacji w ciągu sekundy (około 20 000 IOPS), ale przeniosło znacznie mniej bajtów na sekundę. **Przepustowość = IOPS × rozmiar operacji**: małe operacje ogranicza IOPS, duże przepustowość. Dlatego baza danych (wiele małych operacji) i zadanie kopii zapasowej (kilka dużych) wymagają różnych ustawień wolumenu.

> [!NOTE]
> To mierzy dysk i system plików Twojego komputera, a nie wolumen w chmurze. Ma jedynie pokazać związek między rozmiarem operacji, IOPS a przepustowością. Prawdziwe wolumeny publikują swoje zapewnione limity IOPS i przepustowości.

### Część B: magazyn obiektowy

### Krok 6 — Uruchom magazyn obiektów i zdefiniuj klienta
W kontenerze uruchamiasz Moto, serwer zgodny z S3. Port 5000 wewnątrz kontenera jest opublikowany tylko na `127.0.0.1:9101` Twojego komputera. Następnie definiujesz `aws`, funkcję powłoki, która uruchamia w kontenerze interfejs wiersza poleceń (command-line interface, CLI) AWS w wersji 2, skierowany na Twój serwer, z atrapami kluczy. `:Z` zmienia etykiety SELinux dla folderu i w innych systemach jest nieszkodliwe.

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

Oczekiwany wynik:
```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]
> Funkcja istnieje tylko w tym terminalu. Po otwarciu nowego zdefiniuj ją ponownie (i wykonaj `cd ~/storage-lab`). Ponieważ CLI działa w kontenerze, każde wywołanie uruchamia kontener (około sekundy).

Jedyna różnica względem prawdziwej chmury to `--endpoint-url`: usuń go, użyj prawdziwych kluczy, a te same polecenia będą rozmawiać z prawdziwym dostawcą. Tak w praktyce wygląda „API S3 jako standard”.

### Krok 7 — Buckety, obiekty, prefiksy i metadane
Tworzysz bucket, wysyłasz dwa obiekty i wyświetlasz ich listę. Zwróć uwagę, jak `reports/2026/q3.txt` pojawia się jako „folder”.

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

Oczekiwany wynik:
```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
```

Lista pokazuje `PRE reports/` („prefiks”), a nie folder. Z opcją `--recursive` widać, co naprawdę jest przechowywane: dwa obiekty, których **klucze** to `readme.txt` i `reports/2026/q3.txt`. Teraz odczytaj metadane, pobierz obiekt i usuń go:

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

Oczekiwany wynik (`ETag` i data się różnią):
```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
```

`ETag` to identyfikator zawartości (skrót MD5 przy prostym wysyłaniu). Blok `Metadata` zawiera własne pary, które ustawiono. Bez wersjonowania usunięcie jest ostateczne: obiekt znika.

> [!NOTE]
> Nazwy bucketów muszą mieć co najmniej 3 znaki (`aws s3 mb s3://ab` kończy się błędem `InvalidBucketName`). U prawdziwego dostawcy nazwy są też globalnie unikalne i podlegają regułom nazewnictwa DNS, więc `lab-docs` jest prawdopodobnie zajęta: dodaj losowy przyrostek.

### Krok 8 — Wersjonowanie, znacznik usunięcia i przywracanie
Tworzysz drugi bucket, włączasz wersjonowanie, nadpisujesz obiekt i usuwasz go, a następnie przywracasz pierwszą wersję.

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

Oczekiwany wynik (identyfikatory wersji będą inne; pierwszy wiersz to najnowsza):
```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
```

Dwa wysłania na jeden klucz utworzyły **dwie wersje**: 20 bajtów („version two, edited”) jest bieżące, a 12 bajtów („version one”) zostało zachowane. Skopiuj identyfikator 12-bajtowej wersji: będzie potrzebny poniżej jako `<version-id-1>`. Teraz usuń obiekt:

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

Oczekiwany wynik:
```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
```

Lista bucketu jest pusta, a pobranie zwraca `404 Not Found`, a jednak obie wersje nadal tam są, a **znacznik usunięcia** (wiersz z pojedynczym `True`) jest teraz bieżącą wersją. Nic nie zostało wymazane. Przywróć pierwszą wersję, kopiując ją z powrotem, tak by stała się najnowszą:

```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>` to identyfikator 12-bajtowej wersji z listy. Oczekiwany wynik:
```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
```

Obiekt został odzyskany: kopia jest nową, trzecią wersją ze starą zawartością i znów jest bieżąca (znacznik usunięcia nadal jest w historii, ukryty pod nią). Aby usunąć dane na stałe, należałoby usunąć konkretną wersję poleceniem `aws s3api delete-object --bucket lab-versioned --key notes.txt --version-id <id>`.

> [!NOTE]
> Usunięcie samego znacznika usunięcia (`delete-object` z `--version-id` znacznika) to drugi sposób cofnięcia usunięcia: poprzednia wersja znów staje się bieżąca. W naszym teście zadziałało to na Moto, tak jak w prawdziwym S3.

### Krok 9 — Dodaj regułę cyklu życia
Piszesz dwie reguły: wygaszanie obiektów pod `tmp/` po 30 dniach i wygaszanie nieaktualnych wersji po 90 dniach. Plik JSON zawiera reguły, a CLI zapisuje je i odczytuje z powrotem.

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

Oczekiwany wynik (kolejność pól i pierwszy wiersz mogą się różnić):
```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 zapisuje i zwraca reguły cyklu życia, ale **nigdy ich nie wykonuje**: obiekty tu nie wygasają, a na efekt po 30 dniach nie da się poczekać. U prawdziwego dostawcy reguły stosuje proces w tle, zwykle raz dziennie. Przećwiczono tu to, co zależy od Ciebie: napisanie poprawnej reguły. Reguła z pustym `Prefix` i `NoncurrentVersionExpiration` to typowy towarzysz wersjonowania, aby stare wersje nie gromadziły się w nieskończoność.

### Krok 10 — Udostępnij obiekt przez podpisany z góry adres URL
Obiekt `lab-docs/reports/2026/q3.txt` jest prywatny. Próbujesz go odczytać bez poświadczeń, a potem tworzysz adres URL, który daje minutę dostępu.

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

Oczekiwany wynik (`X-Amz-Date` i podpis się różnią):
```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
```

Przyjrzyj się adresowi URL. Ścieżka to obiekt. `X-Amz-Expires=60` to czas życia w sekundach, `X-Amz-Credential` wskazuje klucz, który go podpisał (ale nigdy sekret), a `X-Amz-Signature` dowodzi, że podpisujący autoryzował dokładnie to żądanie. Bucket pozostał prywatny, a `curl` nie użył żadnych poświadczeń: obiekt dostaje każdy, kto ma adres. Zmień jeden znak ścieżki lub podpisu, a żądanie zostanie odrzucone.

> [!NOTE]
> Moto **nie** egzekwuje czasu wygaśnięcia: adres działa także po upływie 60 sekund. Prawdziwy dostawca po wygaśnięciu zwraca `403 Forbidden`, i na tym polega użyteczność krótkotrwałych adresów. Nie polegaj na tym emulatorze przy testowaniu logiki wygaśnięcia.

### Krok 11 — Otwórz jeden prefiks polityką bucketu
Tworzysz bucket z jednym obiektem, który zostanie udostępniony, i jednym prywatnym, potwierdzasz, że oba są odrzucane dla użytkowników anonimowych, a potem dodajesz **politykę bucketu** (bucket policy), która pozwala wszystkim czytać tylko `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
```

Oczekiwany wynik:
```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
```

Teraz napisz politykę. `"Principal": "*"` oznacza wszystkich, także osoby bez konta:

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

Oczekiwany wynik:
```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
```

Jedna instrukcja udostępniła jeden prefiks całemu Internetowi, a inny obiekt w tym samym buckecie pozostał prywatny. Teraz wyobraź sobie tę samą politykę z `"Resource": "arn:aws:s3:::lab-pub/*"`: każdy obiekt, także to, co ktoś wyśle za rok. Ta różnica jednego znaku to sposób, w jaki powstaje większość wycieków z publicznych bucketów. W polityce to `Resource` pozwala kontrolować szkody; u prawdziwego dostawcy siatką bezpieczeństwa jest **block public access**, który w ogóle odrzuca taką politykę.

> [!NOTE]
> Moto nie egzekwuje block public access. Jeśli uruchomisz `aws s3api put-public-access-block --bucket lab-pub --public-access-block-configuration BlockPublicAcls=true,IgnorePublicAcls=true,BlockPublicPolicy=true,RestrictPublicBuckets=true`, zapisze i zwróci ustawienia, ale polityka publiczna nadal zostanie przyjęta i nadal będzie obsługiwana. U prawdziwego dostawcy z włączonym `BlockPublicPolicy` powyższe `put-bucket-policy` zostanie odrzucone, a `RestrictPublicBuckets` blokuje dostęp publiczny nawet z już istniejącej polityki. Nie mogliśmy tu zweryfikować tych skutków, więc sprawdź je w dokumentacji swojego dostawcy.

## Weryfikacja
Sprawdź każdy wynik; każdy wiersz powinien się zgadzać.

1. Część A: `podman volume inspect lab-storage-data --format '{{.Mountpoint}}'` wypisuje ścieżkę w Twoim folderze domowym, a `ls "$(podman volume inspect lab-storage-data --format '{{.Mountpoint}}')"` wyświetla `both.log`, `note.txt`, `reader.txt` i `shared.log`.
2. Część B, obiekty: `aws s3 ls s3://lab-docs --recursive` wyświetla dokładnie jeden klucz, `reports/2026/q3.txt`.
3. Wersjonowanie: `aws s3 cp --no-progress s3://lab-versioned/notes.txt -` wypisuje `version one`, a `aws s3api list-object-versions --bucket lab-versioned --query 'length(Versions)'` wypisuje `3`.
4. Cykl życia: `aws s3api get-bucket-lifecycle-configuration --bucket lab-versioned --query 'Rules[].ID'` wyświetla `expire-tmp-after-30-days` i `clean-old-versions`.
5. Podpisany z góry adres URL: nowy adres z `aws s3 presign` pobrany przez `curl` zwraca tekst, a adres niepodpisany zwraca `403`.
6. Polityka: przy zastosowanej polityce `reports/hi.txt` zwraca `200`, a `other.txt` zwraca `403` (powtórz polecenie z polityką z Kroku 11, jeśli została usunięta).

## Rozwiązywanie problemów
| Objaw | Prawdopodobna przyczyna | Rozwiązanie |
|---|---|---|
| `Could not connect to the endpoint URL: "http://127.0.0.1:9101/"` | Kontener Moto nie działa albo został zrestartowany | `podman ps --filter name=lab-storage`; uruchom go przez `podman start lab-storage-moto`. Moto trzyma dane w pamięci, więc restart opróżnia każdy bucket: powtórz Kroki 7 do 11 |
| `Error: ... address already in use` dla portu 9101 | Inny program lub kontener używa tego portu | Znajdź go przez `ss -ltn \| grep 9101`; zatrzymaj własny wcześniejszy kontener albo zmień pierwszą liczbę w `-p 127.0.0.1:9101:5000` i w `--endpoint-url` |
| `aws: command not found` | Funkcja powłoki jest zdefiniowana tylko w terminalu, w którym wykonano Krok 6 | Zdefiniuj ją ponownie w tym terminalu |
| `Permission denied`, gdy kontener AWS CLI czyta `report.txt` | SELinux blokuje montowanie bind albo usunięto `:Z` | Zachowaj `:Z` w funkcji i uruchamiaj z `~/storage-lab` |
| `make_bucket failed ... InvalidBucketName` | Nazwa jest krótsza niż 3 znaki albo zawiera niedozwolone znaki | Użyj małych liter, cyfr i myślników, co najmniej 3 znaków |
| `dd: failed to open ... Invalid argument` w Kroku 5 | Folder leży w systemie plików bez obsługi direct I/O, takim jak `tmpfs` | Uruchom laboratorium z folderu na zwykłym dysku albo usuń `oflag=direct` (liczby będą wtedy mierzyć pamięć podręczną) |
| `debugfs: command not found` lub `mkfs.ext4: command not found` | `e2fsprogs` nie jest zainstalowany | Zainstaluj go albo pomiń opcjonalny Krok 4 |
| `curl` zwraca `403` dla podpisanego z góry adresu URL | Adres został ucięty przez powłokę (znaki `&`) albo został zmieniony | Trzymaj go w zmiennej i ujmij w cudzysłów: `curl "$URL"` |

## Wyzwanie (opcjonalne)
Utwórz bucket o nazwie `lab-site` i wyślij mały plik `index.html` pod prefiks `site/`. Napisz politykę bucketu, która pozwala anonimowo na `GET` tylko dla `site/*`, potwierdź to przez `curl`, a następnie zmień `Resource` tak, aby ujawniał także prefiks `private/`. Porównaj obie polityki i wypisz, które z mechanizmów kontroli z lekcji (block public access, polityka najmniejszych uprawnień, podpisane z góry adresy URL) zatrzymałyby tę drugą u prawdziwego dostawcy. Potem użyj `aws s3 sync ./site s3://lab-site/site`, aby wysłać folder, i `aws s3 rm s3://lab-site --recursive`, aby go usunąć.

## Sprzątanie
Usuń każdy kontener, wolumen i plik utworzony w laboratorium. Ostatnie polecenie, które usuwa trzy obrazy, jest opcjonalne: pomiń je, jeśli używasz tych obrazów do czegoś innego.

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

Potwierdź, że nic nie zostało:
```bash
podman ps -a --filter name=lab-storage --format '{{.Names}}'
podman volume ls --filter name=lab-storage
```

Oba polecenia nie powinny wypisać niczego poza nagłówkiem tabeli wolumenów.

## Co już umiesz
- Wolumen Podmana to katalog, a nie urządzenie blokowe. Prawdziwy wolumen blokowy daje surową pojemność z własnymi IOPS, przepustowością i opóźnieniem, a system plików na nim prowadzi jedna instancja; udział plików prowadzi system plików dla wielu klientów.
- Przepustowość to IOPS razy rozmiar operacji, więc małe operacje ogranicza IOPS, a duże przepustowość.
- Do magazynu obiektowego dociera się przez API HTTP (API S3) z bucketem, kluczem i metadanymi; prefiksy tylko wyglądają jak foldery. Zmiana punktu końcowego wystarcza, aby przejść między usługami zgodnymi z S3.
- Wersjonowanie zamienia usunięcie w znacznik usunięcia i zachowuje każdą wersję, więc przywrócenie to kopia wcześniejszej wersji. Reguły cyklu życia, napisane raz, automatycznie wygaszają dane u prawdziwego dostawcy.
- Podpisany z góry adres URL daje krótkotrwały dostęp do jednego prywatnego obiektu, a zbyt szeroka polityka bucketu upublicznia dane dla wszystkich: zostaw block public access włączony i wąsko zakreślaj `Resource`.