Wyświetlany jest surowy Markdown: nie udało się wczytać renderera.
## Cel
Zbudujesz mały obraz kontenera z pliku `Containerfile` z przypiętym obrazem bazowym i sprawdzisz jego warstwy. Następnie uruchomisz go i obejrzysz kontener z poziomu hosta: jego procesy, przestrzenie nazw i cgroup. Na koniec ustawisz limity CPU i pamięci, odczytasz je w plikach cgroup i celowo wywołasz zabicie z powodu braku pamięci (OOM, out-of-memory), aby je zdiagnozować.
## Cele
- Zbudować obraz z `Containerfile` z przypiętym obrazem bazowym i wyjaśnić jego warstwy (cel 4).
- Pokazać, że kontener to zwykły proces hosta we własnych przestrzeniach nazw: porównać nazwę hosta, listę procesów i identyfikatory przestrzeni nazw w środku i na zewnątrz (cel 3).
- Ustawić limity `--cpus` i `--memory` i odczytać je jako `cpu.max` i `memory.max` w plikach cgroup v2 (cele 3 i 5).
- Wywołać zabicie przez OOM i zdiagnozować je za pomocą `OOMKilled`, kodu wyjścia 137 i dziennika jądra (cel 5).
## Wymagania wstępne
- Maszyna z Linuksem lub VM z Linuksem z Podmanem 4 lub nowszym (przetestowano z Podmanem 5.8.7, rootless, cgroups v2, `crun`, bez `sudo`). Docker działa po drobnych zmianach: zobacz UWAGĘ poniżej.
- Powłoka zwykłego użytkownika (nie `root`). Wszystko w tym laboratorium działa bez `sudo`.
- Dostęp do Internetu, aby pobrać obraz bazowy `docker.io/library/alpine:3.20.10` (około 8 MB) oraz jeden mały pakiet (`procps-ng`) podczas budowania.
- Około 30 MB miejsca na dysku.
- [Lekcja](lesson.pl.md) z tego modułu.
> [!WARNING]
> Laboratorium jest bezpłatne i uruchamia tylko kontenery, które sam startujesz na własnej maszynie, jako zwykły użytkownik i bez `--privileged`. Każdy kontener nazywa się `lab-virt-...`, a polecenia usuwające rzeczy wymieniają je jawnie, więc nie ruszają Twoich innych kontenerów. Jeden krok celowo sprawia, że kontener zużywa więcej pamięci niż jego limit; może to zaszkodzić tylko temu kontenerowi, a nie Twojej maszynie. Laboratorium nie zmienia niczego w systemie poza jednym katalogiem (`~/virt-lab`) i jednym lokalnym obrazem, oba usuwane na końcu.
> [!NOTE]
> Poniższe wyniki zarejestrowano na Linuksie z rodziny Fedora w listopadzie 2026. Identyfikatory, PID-y, numery przestrzeni nazw, godziny i nazwa hosta będą inne na Twojej maszynie; porównuj strukturę i wartości wynikające z Twoich poleceń (takie jak `67108864`).
>
> **Docker:** zamień `podman` na `docker`; nazwa `Containerfile` pozostaje poprawna (`docker build -f Containerfile`, jeśli Twoja wersja go nie znajdzie). Dwie różnice: w domyślnym Dockerze działającym jako root procesy kontenera należą do `root`, więc odczyt `/proc/<pid>/ns` i dziennika OOM może wymagać `sudo`, a `podman top ... hpid huser` nie ma odpowiednika w Dockerze. Nie testowano z Dockerem.
## Architektura
<figure class="diagram" style="--dg-w: 1100px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 1100 560" width="1100" height="560" role="img" aria-labelledby="virt-lab-architecture-pl-title virt-lab-architecture-pl-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="pl">
<title id="virt-lab-architecture-pl-title">Architektura laboratorium: Containerfile, obraz, trzy kontenery rootless i jądro hosta</title>
<desc id="virt-lab-architecture-pl-desc">Na Twoim komputerze z Linuksem, z Podmanem rootless i bez sudo, katalog ~/virt-lab zawiera Containerfile i app.sh. Podman buduje z nich obraz localhost/lab-virt-hello:1.0, który ma trzy warstwy i zajmuje około 9.4 MB. Obraz bazowy pochodzi z rejestru w Internecie, docker.io/library/alpine, tag 3.20.10. Obraz działa jako trzy kontenery, których nazwy zaczynają się od lab-virt-: lab-virt-demo, uruchamiający sleep 3600 bez limitów; lab-virt-limited, z limitem CPU 0.5 i limitem pamięci 64 MB; oraz lab-virt-oom, z limitem pamięci 64 MB, który alokuje 200 MB i zostaje zabity. Kontenery są izolowane i ograniczane przez jądro Linuksa hosta, które badasz z poziomu hosta: /proc/<pid>/ns dla namespaces, /sys/fs/cgroup dla memory.max, cpu.max i pids.max oraz dziennik jądra dla OOM killera i kodu wyjścia 137.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="1099" height="559" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l1"><rect class="dg-tint" x="20" y="20" width="230" height="160" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 33) scale(0.7500)" fill="none" stroke="#0369a1" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/><path d="M2 12h20"/></g>
<text x="62" y="47" font-size="13" class="dg-ink" fill="#0369a1" font-weight="700">Internet</text></g>
<g class="dg-l2"><rect class="dg-tint" x="280" y="20" width="800" height="520" rx="16" fill="#f1f7f3" stroke="#a1ccb1" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(296 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="322" y="47" font-size="13" class="dg-ink" fill="#15803d" font-weight="700">Twój komputer z Linuksem: Podman rootless, bez sudo</text></g>
<g class="dg-l7"><rect class="dg-tint" x="620" y="56" width="440" height="298" rx="16" fill="#f6f2fd" stroke="#c5a9f0" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(636 69) 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="662" y="83" font-size="13" class="dg-ink" fill="#6d28d9" font-weight="700">Kontenery (nazwy zaczynają się od lab-virt-)</text></g>
<g class="dg-l4"><rect class="dg-tint" x="296" y="400" width="768" height="124" rx="16" fill="#fbf4f0" stroke="#e7b39e" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(312 413) scale(0.7500)" fill="none" stroke="#c2410c" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="8" x="2" y="2" rx="2"/><rect width="20" height="8" x="2" y="14" rx="2"/><path d="M6 6h.01"/><path d="M6 18h.01"/></g>
<text x="338" y="427" font-size="13" class="dg-ink" fill="#c2410c" font-weight="700">Jądro Linuksa hosta: to, co badasz</text></g>
<rect class="dg-card" x="34" y="64" width="202" height="100" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(50 80) scale(1.2500)" fill="none" stroke="#0369a1" 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-l1"><text x="92" y="101" font-size="15" class="dg-ink" fill="#0369a1" font-weight="700">Rejestr</text></g>
<text x="52" y="132" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">alpine:3.20.10</text>
<text x="52" y="152" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">docker.io/library</text>
<rect class="dg-card" x="310" y="64" width="250" height="104" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(326 80) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g></g>
<g class="dg-l1"><text x="368" y="101" font-size="15" class="dg-ink" fill="#0369a1" font-weight="700">Obraz</text></g>
<text x="328" y="132" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">localhost/lab-virt-hello:1.0</text>
<text x="328" y="152" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">3 warstwy · ok. 9.4 MB</text>
<rect class="dg-card" x="310" y="240" width="250" height="104" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(326 256) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"/><path d="M14 2v4a2 2 0 0 0 2 2h4"/><path d="M10 9H8"/><path d="M16 13H8"/><path d="M16 17H8"/></g>
<text x="368" y="277" font-size="15" class="dg-text" fill="#17171c" font-weight="700">~/virt-lab</text>
<text x="328" y="308" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">Containerfile</text>
<text x="328" y="328" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">app.sh</text>
<rect class="dg-card" x="636" y="92" width="408" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l7"><g class="dg-icon" transform="translate(652 108) scale(1.2500)" fill="none" stroke="#6d28d9" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g></g>
<g class="dg-l7"><text x="694" y="129" font-size="15" class="dg-ink" fill="#6d28d9" font-weight="700">lab-virt-demo</text></g>
<text x="654" y="160" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">sleep 3600 · bez limitów</text>
<rect class="dg-card" x="636" y="178" width="408" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l7"><g class="dg-icon" transform="translate(652 194) scale(1.2500)" fill="none" stroke="#6d28d9" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g></g>
<g class="dg-l7"><text x="694" y="215" font-size="15" class="dg-ink" fill="#6d28d9" font-weight="700">lab-virt-limited</text></g>
<text x="654" y="246" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">--cpus 0.5 --memory 64m</text>
<rect class="dg-card" x="636" y="264" width="408" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-warn"><g class="dg-icon" transform="translate(652 280) scale(1.2500)" fill="none" stroke="#b91c1c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g></g>
<g class="dg-warn"><text x="694" y="301" font-size="15" class="dg-ink" fill="#b91c1c" font-weight="700">lab-virt-oom</text></g>
<text x="654" y="332" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">--memory 64m · alokuje 200 MB</text>
<rect class="dg-card" x="312" y="436" width="230" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l4"><g class="dg-icon" transform="translate(328 452) scale(1.2500)" fill="none" stroke="#c2410c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M8 6h13"/><path d="M8 12h13"/><path d="M8 18h13"/><path d="M3 6h.01"/><path d="M3 12h.01"/><path d="M3 18h.01"/></g></g>
<g class="dg-l4"><text x="370" y="473" font-size="14" class="dg-ink" fill="#c2410c" font-weight="700">/proc/<pid>/ns</text></g>
<text x="330" y="504" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">namespaces widziane z hosta</text>
<rect class="dg-card" x="558" y="436" width="230" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l4"><g class="dg-icon" transform="translate(574 452) scale(1.2500)" fill="none" stroke="#c2410c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M8 6h13"/><path d="M8 12h13"/><path d="M8 18h13"/><path d="M3 6h.01"/><path d="M3 12h.01"/><path d="M3 18h.01"/></g></g>
<g class="dg-l4"><text x="616" y="473" font-size="14" class="dg-ink" fill="#c2410c" font-weight="700">/sys/fs/cgroup/…</text></g>
<text x="576" y="504" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">memory.max · cpu.max</text>
<rect class="dg-card" x="804" y="436" width="230" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-warn"><g class="dg-icon" transform="translate(820 452) scale(1.2500)" fill="none" stroke="#b91c1c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3"/><path d="M12 9v4"/><path d="M12 17h.01"/></g></g>
<g class="dg-warn"><text x="862" y="473" font-size="14" class="dg-ink" fill="#b91c1c" font-weight="700">Dziennik jądra</text></g>
<text x="822" y="504" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">OOM killer: kod wyjścia 137</text>
<g class="dg-l1"><path class="dg-stroke" d="M238 116H300" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><path class="dg-stroke" d="M293 110l8 6-8 6" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><rect class="dg-bg-plain" x="247.12" y="104" width="43.76" height="24" rx="12" fill="#ffffff"/><text x="269" y="120.5" font-size="11.5" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle">pull</text></g>
<g class="dg-l1"><path class="dg-stroke" d="M435 238V172" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><path class="dg-stroke" d="M429 179l6-8 6 8" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><rect class="dg-bg-plain" x="409.9" y="193" width="50.2" height="24" rx="12" fill="#ffffff"/><text x="435" y="209.5" font-size="11.5" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle">build</text></g>
<g class="dg-l7"><path class="dg-stroke" d="M562 116H610" stroke="#6d28d9" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l7"><path class="dg-stroke" d="M605 110l8 6-8 6" 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="568.34" y="104" width="37.32" height="24" rx="12" fill="#ffffff"/><text x="587" y="120.5" font-size="11.5" class="dg-ink" fill="#6d28d9" font-weight="600" text-anchor="middle">run</text></g>
<g class="dg-l4"><path class="dg-stroke" d="M840 358V392" stroke="#c2410c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l4"><path class="dg-stroke" d="M834 387l6 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="737.62" y="364" width="204.76" height="24" rx="12" fill="#ffffff"/><text x="840" y="380.5" font-size="11.5" class="dg-ink" fill="#c2410c" font-weight="600" text-anchor="middle">izolowane i ograniczane przez</text></g>
</svg></figure>
*Rysunek 1. Budujesz jeden obraz z katalogu, uruchamiasz go jako trzy kontenery i odczytujesz, co zrobiło jądro hosta, aby je izolować i ograniczać.*
## Kroki
### Krok 1 — Sprawdź narzędzia i utwórz katalog roboczy
Najpierw sprawdź, czy masz Podmana, czy działa bez roota i czy system używa cgroups v2. Wszystkie pliki laboratorium trzymasz w jednym katalogu, aby sprzątanie było proste.
```bash
podman --version
podman info --format 'rootless={{.Host.Security.Rootless}} cgroups={{.Host.CgroupsVersion}} runtime={{.Host.OCIRuntime.Name}}'
stat -fc %T /sys/fs/cgroup
mkdir -p ~/virt-lab && cd ~/virt-lab
```
Oczekiwany wynik (wersja może być nowsza; środowisko uruchomieniowe może być `runc`):
```text
podman version 5.8.7
rootless=true cgroups=v2 runtime=crun
cgroup2fs
```
`cgroup2fs` oznacza, że system plików cgroup v2 jest zamontowany w `/sys/fs/cgroup`. Jeśli widzisz `tmpfs`, system używa cgroups v1 i kroki z limitami nie będą pasować; zobacz Rozwiązywanie problemów.
> [!WARNING]
> Wszystkie kolejne polecenia uruchamiaj z `~/virt-lab`, chyba że krok mówi inaczej.
### Krok 2 — Napisz aplikację i Containerfile
Aplikacja to malutki skrypt powłoki. `Containerfile` wymienia kroki budowania; każdy krok zmieniający pliki dodaje warstwę. Przypnij obraz bazowy do dokładnego tagu wersji (`3.20.10`), a nie do `latest`, aby budowanie było powtarzalne.
```bash
cat > app.sh <<'EOF'
#!/bin/sh
echo "Hello from $(hostname), running as $(id -un) (PID $$)"
EOF
chmod +x app.sh
cat > Containerfile <<'EOF'
FROM docker.io/library/alpine:3.20.10
LABEL org.opencontainers.image.title="lab-virt-hello"
RUN apk add --no-cache procps-ng
COPY app.sh /usr/local/bin/app.sh
CMD ["/usr/local/bin/app.sh"]
EOF
```
Co robi każda linia:
- `FROM` wybiera obraz bazowy i jego warstwy.
- `LABEL` dodaje metadane do konfiguracji obrazu (bez nowej warstwy).
- `RUN` uruchamia polecenie w tymczasowym kontenerze i zachowuje zmiany plików jako nową warstwę.
- `COPY` dodaje plik z Twojego katalogu jako nową warstwę.
- `CMD` ustawia polecenie domyślne (tylko metadane).
> [!NOTE]
> Linia `RUN` jest po to, aby obraz miał warstwę, którą można zobaczyć. Wymaga ona dostępu do sieci podczas budowania.
### Krok 3 — Zbuduj obraz
```bash
podman build -t lab-virt-hello:1.0 .
```
`-t` nadaje obrazowi nazwę `lab-virt-hello` z tagiem `1.0`, a `.` to kontekst budowania (ten katalog).
Oczekiwany wynik (identyfikatory się różnią; linie pobierania `apk` są skrócone):
```text
STEP 1/5: FROM docker.io/library/alpine:3.20.10
STEP 2/5: LABEL org.opencontainers.image.title="lab-virt-hello"
--> b1be2b84c186
STEP 3/5: RUN apk add --no-cache procps-ng
Executing busybox-1.36.1-r31.trigger
OK: 9 MiB in 19 packages
--> c76c408b748b
STEP 4/5: COPY app.sh /usr/local/bin/app.sh
--> 964fed8bd61c
STEP 5/5: CMD ["/usr/local/bin/app.sh"]
COMMIT lab-virt-hello:1.0
--> de5c993d6a99
Successfully tagged localhost/lab-virt-hello:1.0
de5c993d6a996bcc2d734c27e4290c4d4d80a12865dc8c7833be391f7e51feb6
```
Za pierwszym razem Podman wypisze też `Trying to pull docker.io/library/alpine:3.20.10...` oraz linie pobierania blobów. Sprawdź obraz:
```bash
podman images lab-virt-hello
```
```text
REPOSITORY TAG IMAGE ID CREATED SIZE
localhost/lab-virt-hello 1.0 de5c993d6a99 Less than a second ago 9.37 MB
```
### Krok 4 — Sprawdź warstwy
`podman history` wypisuje jedną linię na instrukcję budowania, z rozmiarem dodanej warstwy.
```bash
podman history lab-virt-hello:1.0
```
Oczekiwany wynik (skrócony, by się zmieścił; godziny i identyfikatory się różnią):
```text
ID CREATED CREATED BY SIZE COMMENT
964fed8bd61c Less than a second ago /bin/sh -c #(nop) CMD ["/usr/local/bin/app... 0B
<missing> Less than a second ago /bin/sh -c #(nop) COPY file:23760a3ecceb3e... 3.58kB
c76c408b748b Less than a second ago /bin/sh -c apk add --no-cache procps-ng 1.27MB
bf8527eb54c3 1 second ago /bin/sh -c #(nop) LABEL org.opencontainers... 0B FROM docker.i...
<missing> 6 months ago CMD ["/bin/sh"] 0B buildkit.dock...
<missing> 6 months ago ADD alpine-minirootfs-3.20.10-x86_64.tar.g... 8.09MB buildkit.dock...
```
Czytaj od dołu: główny system plików obrazu bazowego (8.09 MB), Twój `RUN` (1.27 MB), Twój `COPY` (3.58 kB). `CMD` i `LABEL` mają 0 B: zmieniają tylko konfigurację. Teraz zapytaj bezpośrednio o warstwy i format:
```bash
podman image inspect lab-virt-hello:1.0 --format 'Layers: {{len .RootFS.Layers}} Cmd: {{.Config.Cmd}} Format: {{.ManifestType}}'
podman image inspect lab-virt-hello:1.0 --format '{{range .RootFS.Layers}}{{println .}}{{end}}'
```
Oczekiwany wynik (pierwsza warstwa, Alpine, jest taka sama na Twojej maszynie; pozostałe dwie się różnią, ponieważ ich zawartość obejmuje czasy budowania):
```text
Layers: 3 Cmd: [/usr/local/bin/app.sh] Format: application/vnd.oci.image.manifest.v1+json
sha256:08bc4e534116aa76b16015484b82eac51f9a593416feae9296c8a2d4bb7aa4a2
sha256:f55ed2bae43c665dab4e7586118f8ad3e837d47e4f580dbc8c6ae63b55ac8f5e
sha256:df259c8f1ca6356b3feac01c6d60efbe8439114afa5442ddbcfba2f5286d92c7
```
Trzy warstwy (baza, `RUN`, `COPY`), każda nazwana digestem SHA-256 swojej zawartości, oraz obraz w formacie obrazu OCI (`application/vnd.oci.image.manifest.v1+json`).
> [!NOTE]
> Powyższe digesty to identyfikatory zawartości nieskompresowanej (`diff_id` w konfiguracji obrazu). Digesty skompresowanych warstw w manifeście, których używa rejestr, to inne wartości.
### Krok 5 — Uruchom kontener
Uruchom go raz na pierwszym planie. `--rm` usuwa kontener po zakończeniu, a `--name` stosuje regułę `lab-virt-`.
```bash
podman run --rm --name lab-virt-hello lab-virt-hello:1.0
```
Oczekiwany wynik (nazwa hosta to pierwsze 12 znaków identyfikatora kontenera, więc Twoja będzie inna):
```text
Hello from 5088d1aeb13f, running as root (PID 1)
```
Zwróć uwagę na trzy rzeczy: nazwa hosta nie jest nazwą Twojego komputera (przestrzeń nazw uts), skrypt ma **PID 1** (przestrzeń nazw pid), a użytkownik to `root` (przestrzeń nazw user, jak zobaczysz w Kroku 7).
### Krok 6 — Porównaj widok kontenera z widokiem hosta
Tym razem uruchom kontener, który nadal działa, aby obejrzeć go z obu stron.
```bash
podman run -d --name lab-virt-demo lab-virt-hello:1.0 sleep 3600
podman ps --filter name=lab-virt- --format 'table {{.Names}}\t{{.Status}}\t{{.Command}}'
```
Oczekiwany wynik (pierwsza linia to pełny identyfikator kontenera):
```text
9f26995a174db194e15e4322e83b28bdfb0928df0ed9f5be2a803f0607cc6b50
NAMES STATUS COMMAND
lab-virt-demo Up Less than a second sleep 3600
```
Zapytaj Podmana o procesy kontenera, z widokiem hosta obok widoku kontenera:
```bash
podman top lab-virt-demo user pid hpid huser comm
```
```text
USER PID HPID HUSER COMMAND
root 1 41390 1000 sleep
```
`PID` to numer wewnątrz kontenera (1); `HPID` to PID tego samego procesu na hoście (tu 41390, Twój będzie inny); `USER` to `root` w środku, a `HUSER` to `1000` na hoście: Twój własny identyfikator użytkownika. „Root” kontenera to Ty. Teraz porównaj widoki poleceniami uruchamianymi w środku i na zewnątrz:
```bash
podman exec lab-virt-demo hostname
podman exec lab-virt-demo ps -o pid,user,comm
podman exec lab-virt-demo uname -r
echo "--- host ---"
hostname
uname -r
```
Oczekiwany wynik:
```text
9f26995a174d
PID USER COMMAND
1 root sleep
3 root ps
7.2.4-ogc3.1.fc44.x86_64
--- host ---
bazzite
7.2.4-ogc3.1.fc44.x86_64
```
W środku widzisz inną nazwę hosta i tylko dwa procesy (`sleep` jako PID 1 oraz właśnie uruchomiony `ps`), podczas gdy host ma ich setki. Ale `uname -r` wypisuje **tę samą wersję jądra**: nie ma jądra gościa, kontener dzieli jądro hosta. To główna różnica w porównaniu z VM.
### Krok 7 — Obejrzyj przestrzenie nazw z poziomu hosta
Każdy proces ma w `/proc/<pid>/ns/` jedno dowiązanie na przestrzeń nazw. Dwa procesy są w tej samej przestrzeni nazw, gdy liczba w dowiązaniu jest taka sama. Porównaj swoją powłokę z `sleep` kontenera, używając jego PID na hoście:
```bash
PID=$(podman inspect lab-virt-demo --format '{{.State.Pid}}')
echo "container PID on the host: $PID"
for ns in cgroup ipc mnt net pid user uts time; do
printf '%-7s host %-18s container %s\n' $ns "$(readlink /proc/self/ns/$ns)" "$(readlink /proc/$PID/ns/$ns)"
done
```
Oczekiwany wynik (liczby różnią się na Twojej maszynie; porównuj je parami):
```text
container PID on the host: 41390
cgroup host cgroup:[4026531835] container cgroup:[4026533219]
ipc host ipc:[4026531839] container ipc:[4026533217]
mnt host mnt:[4026531832] container mnt:[4026533215]
net host net:[4026531833] container net:[4026533103]
pid host pid:[4026531836] container pid:[4026533218]
user host user:[4026531837] container user:[4026533101]
uts host uts:[4026531838] container uts:[4026533216]
time host time:[4026531834] container time:[4026531834]
```
Siedem przestrzeni nazw jest różnych. Przestrzeń nazw `time` jest ta sama: kontenery domyślnie nie mają własnej. Jeśli `lsns` jest zainstalowane (pakiet `util-linux`), wypisuje te same informacje:
```bash
lsns -p $PID -o NS,TYPE,NPROCS,PID,COMMAND
```
```text
NS TYPE NPROCS PID COMMAND
4026531834 time 153 1853 /usr/bin/mpris-proxy
4026533101 user 16 15774 catatonit -P
4026533103 net 1 41390 sleep 3600
4026533215 mnt 1 41390 sleep 3600
4026533216 uts 1 41390 sleep 3600
4026533217 ipc 1 41390 sleep 3600
4026533218 pid 1 41390 sleep 3600
4026533219 cgroup 1 41390 sleep 3600
```
Pierwszy wiersz to przestrzeń nazw `time`, którą dzielisz z hostem (pokazane `COMMAND` to po prostu najstarszy proces w niej). Wiersz `user` ma więcej niż jeden proces: Podman rootless utrzymuje jedną przestrzeń nazw user dla wszystkich Twoich kontenerów, trzymaną przez małego pomocnika (`catatonit`).
Teraz przestrzeń nazw user. W kontenerze jesteś UID 0. Za jakiego użytkownika uważa Cię host i jak wygląda odwzorowanie?
```bash
podman exec lab-virt-demo cat /proc/self/uid_map
stat -c 'owner of the host process: %U' /proc/$PID
```
```text
0 1000 1
1 524288 65536
owner of the host process: user
```
Czytaj każdy wiersz `uid_map` jako `<pierwszy UID w środku> <pierwszy UID na zewnątrz> <ile>`: UID 0 kontenera to UID 1000 hosta (Ty; liczba 1), a UID od 1 do 65536 kontenera są odwzorowane na zakres UID zarezerwowany dla Ciebie w `/etc/subuid`. Proces na hoście należy do Twojej własnej nazwy użytkownika (tu `user`; Twoja będzie inna). Błąd pozwalający procesowi uciec znalazłby tylko Twoje prawa, a nie prawa roota.
### Krok 8 — Ustaw limity i odczytaj je w cgroup
Uruchom drugi kontener z limitem pół procesora i 64 MB pamięci:
```bash
podman run -d --name lab-virt-limited --cpus 0.5 --memory 64m lab-virt-hello:1.0 sleep 3600
```
Cgroup kontenera to katalog poniżej `/sys/fs/cgroup`. Znajdź go na podstawie PID hosta i odczytaj pliki limitów:
```bash
PID=$(podman inspect lab-virt-limited --format '{{.State.Pid}}')
CG=/sys/fs/cgroup$(cut -d: -f3 /proc/$PID/cgroup)
echo "$CG"
for f in memory.max cpu.max pids.max memory.current; do printf '%-15s %s\n' $f "$(cat $CG/$f)"; done
```
Oczekiwany wynik (identyfikator kontenera w ścieżce się różni, tu skrócony do `<id>`; `memory.current` się zmienia):
```text
/sys/fs/cgroup/user.slice/user-1000.slice/user@1000.service/user.slice/libpod-<id>.scope/container
memory.max 67108864
cpu.max 50000 100000
pids.max 2048
memory.current 741376
```
- `memory.max` to `67108864`: 64 × 1024 × 1024 bajtów, z `--memory 64m`.
- `cpu.max` to `50000 100000`: 50 000 µs czasu CPU w każdym okresie 100 000 µs, czyli 0.5 CPU, z `--cpus 0.5`.
- `pids.max` to wartość domyślna ustawiana przez Podmana (tu 2048; Twoja może być inna).
Porównaj z kontenerem bez limitów, `lab-virt-demo`:
```bash
CGD=/sys/fs/cgroup$(cut -d: -f3 /proc/$(podman inspect lab-virt-demo --format '{{.State.Pid}}')/cgroup)
for f in memory.max cpu.max; do printf '%-15s %s\n' $f "$(cat $CGD/$f)"; done
```
```text
memory.max max
cpu.max max 100000
```
`max` oznacza „bez limitu”. Kontener może też odczytać własne limity, ponieważ ma własną przestrzeń nazw cgroup, w której jego cgroup wygląda jak korzeń:
```bash
podman exec lab-virt-limited cat /sys/fs/cgroup/memory.max /sys/fs/cgroup/cpu.max
podman inspect lab-virt-limited --format 'Memory={{.HostConfig.Memory}} NanoCpus={{.HostConfig.NanoCpus}} CpuQuota={{.HostConfig.CpuQuota}} CpuPeriod={{.HostConfig.CpuPeriod}}'
```
```text
67108864
50000 100000
Memory=67108864 NanoCpus=500000000 CpuQuota=50000 CpuPeriod=100000
```
### Krok 9 — Zobacz, jak limit CPU dławi zajęty kontener
Uruchom nieskończoną pętlę wewnątrz kontenera z limitem. Bez limitu użyłaby całego procesora; z `--cpus 0.5` powinna dostać około połowy.
```bash
podman exec -d lab-virt-limited sh -c 'while :; do :; done'
sleep 8
podman stats --no-stream --format 'table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}' lab-virt-limited
grep -E 'nr_periods|nr_throttled|throttled_usec' $CG/cpu.stat
```
Oczekiwany wynik (procenty i liczniki się zmieniają):
```text
NAME CPU % MEM USAGE / LIMIT
lab-virt-limited 48.63% 450.6kB / 67.11MB
nr_periods 83
nr_throttled 78
throttled_usec 3373263
```
Pętla chce 100% procesora, ale dostaje około 50%. `nr_throttled` liczy okresy, w których cgroup wyczerpał limit i został wstrzymany do następnego okresu: prawie wszystkie (78 z 83). CPU ponad limit oznacza **wolniej**, a nie zabicie.
Usuń oba kontenery. `sleep` jako PID 1 ignoruje sygnał zatrzymania (`SIGTERM`), więc `-t 0` pomija 10-sekundowe oczekiwanie:
```bash
podman rm -f -t 0 lab-virt-limited lab-virt-demo
```
```text
lab-virt-demo
lab-virt-limited
```
### Krok 10 — Celowo wywołaj zabicie przez OOM
Teraz daj kontenerowi 64 MB i poproś jego powłokę o trzymanie w pamięci łańcucha o rozmiarze 200 MB. Polecenie `head -c 200000000 /dev/zero | tr "\0" a` tworzy 200 MB litery `a`, a powłoka trzyma je wszystkie w zmiennej `x`.
```bash
podman run --name lab-virt-oom --memory 64m lab-virt-hello:1.0 \
sh -c 'x=$(head -c 200000000 /dev/zero | tr "\0" a); echo "allocated ${#x} bytes"'
echo "exit code: $?"
```
Oczekiwany wynik:
```text
exit code: 137
```
Nie ma linii „allocated”: powłoka została zabita, zanim zdążyła ją wypisać. Nazwa nie ma `--rm`, więc możesz sprawdzić zatrzymany kontener. Kod wyjścia 137 to 128 + 9, czyli `SIGKILL`. Ale czy to OOM killer? Zapytaj silnik:
```bash
podman inspect lab-virt-oom --format 'OOMKilled={{.State.OOMKilled}} ExitCode={{.State.ExitCode}} Status={{.State.Status}}'
```
```text
OOMKilled=true ExitCode=137 Status=exited
```
`OOMKilled=true` potwierdza, że zatrzymał go OOM killer cgroup pamięci. Szczegóły podaje dziennik jądra:
```bash
journalctl -k --since "-2min" --no-pager | grep "Memory cgroup out of memory"
```
Oczekiwany wynik (skrócony; PID i rozmiary się zmieniają):
```text
nov 07 19:55:34 bazzite kernel: Memory cgroup out of memory: Killed process 43622 (sh) total-vm:136808kB, anon-rss:62252kB, file-rss:904kB, shmem-rss:0kB, UID:1000 pgtables:300kB oom_score_adj:200
```
Proces używał około 62 MB pamięci rezydentnej (`anon-rss`), gdy osiągnął limit 64 MB, i wtedy został zabity.
> [!NOTE]
> Odczyt dziennika jądra wymaga dostępu do journala: w wielu systemach zwykły użytkownik musi należeć do grupy `systemd-journal` (lub `adm`) albo użyć `dmesg`, jeśli system na to pozwala (`sysctl kernel.dmesg_restrict` ma wartość `0`). Bez dostępu `podman inspect` i kod wyjścia 137 wystarczą do ukończenia laboratorium; linia z jądra to potwierdzenie.
> [!NOTE]
> Jeśli proces bez pamięci zostanie uruchomiony przez `podman exec` w kontenerze, którego proces główny jest w porządku, zabity zostanie tylko ten proces uruchomiony przez `exec`: kontener działa dalej, a `OOMKilled` pozostaje `false`. Plik `memory.events` cgroup i tak to pokazuje, jako licznik `oom_kill 1`. Gdy diagnozujesz restart lub zabicie, patrz na `memory.events`, a nie tylko na `OOMKilled`.
Teraz napraw to. Zadanie potrzebuje około 200 MB, więc podnieś limit do 512 MB. Tym razem użyj `--rm`:
```bash
podman rm lab-virt-oom
podman run --rm --name lab-virt-oom --memory 512m lab-virt-hello:1.0 \
sh -c 'x=$(head -c 200000000 /dev/zero | tr "\0" a); echo "allocated ${#x} bytes"'
echo "exit code: $?"
```
```text
lab-virt-oom
allocated 200000000 bytes
exit code: 0
```
To samo polecenie kończy się sukcesem, gdy limit odpowiada rzeczywistej potrzebie. Pierwsza linia to wynik `podman rm`, który wypisuje nazwę usuniętego kontenera.
## Weryfikacja
Sprawdź każdy wynik. Wszystko poniższe powinno być prawdą:
- `podman history lab-virt-hello:1.0` pokazuje warstwę bazową około 8 MB, warstwę `RUN` około 1 MB i warstwę `COPY` kilku kB; `CMD` i `LABEL` pokazują `0B`.
- W kontenerze `hostname` różni się od hosta, `ps` pokazuje `sleep` jako PID 1, a `uname -r` jest równe wersji jądra hosta.
- `readlink /proc/<pid>/ns/...` daje różne liczby dla `cgroup`, `ipc`, `mnt`, `net`, `pid`, `user` i `uts` oraz tę samą liczbę dla `time`.
- `memory.max` to `67108864`, a `cpu.max` to `50000 100000` dla `lab-virt-limited`.
- Uruchomienie z OOM kończy się `OOMKilled=true` i kodem wyjścia 137, a ponowna próba z `--memory 512m` kończy się `allocated 200000000 bytes`.
Szybka samokontrola:
```bash
podman ps -a --filter name=lab-virt- --format '{{.Names}} {{.Status}}'
```
Po Kroku 10 nic to nie wypisze, ponieważ ostatni kontener użył `--rm`, a wcześniejsze zostały usunięte.
## Rozwiązywanie problemów
| Objaw | Prawdopodobna przyczyna | Rozwiązanie |
|---|---|---|
| `stat -fc %T /sys/fs/cgroup` wypisuje `tmpfs` | System używa cgroups v1, gdzie limity w trybie rootless nie są obsługiwane | Użyj dystrybucji z cgroups v2 (Fedora, Ubuntu 22.04 lub nowszy, Debian 11 lub nowszy) albo VM. Podman ostrzega: `Resource limits are not supported and ignored on cgroups V1 rootless systems`. |
| `podman run --cpus 0.5` kończy się błędem albo plik `cpu.max` zostaje na `max` | Kontroler `cpu` nie jest delegowany Twojemu użytkownikowi | Uruchom `cat /sys/fs/cgroup/user.slice/user-$(id -u).slice/user@$(id -u).service/cgroup.controllers`; powinien wymieniać `cpu`, `memory` i `pids`. W starszych systemach administrator musi włączyć delegowanie (drop-in systemd z `Delegate=cpu cpuset io memory pids`). |
| `Error: pulling image ... connection refused` lub przekroczenie czasu | Brak Internetu lub proxy | Ustaw zmienną `HTTPS_PROXY` albo pobierz z rejestru, do którego masz dostęp, i zmień linię `FROM`. |
| `apk add` nie działa podczas budowania | Kontener nie ma DNS ani sieci | Sprawdź, czy działa `podman run --rm docker.io/library/alpine:3.20.10 nslookup example.com`; sprawdź zaporę i VPN. |
| `cannot clone: Operation not permitted` lub błędy przestrzeni nazw user | Tryb rootless wymaga wpisów w `/etc/subuid` i `/etc/subgid` oraz nieuprzywilejowanych przestrzeni nazw user | `grep $USER /etc/subuid /etc/subgid`; administrator może je dodać (`usermod --add-subuids ...`). |
| Kontener działa, ale `OOMKilled` to `false`, a kod wyjścia to 137 | Zabity z innego powodu (na przykład po przekroczeniu limitu czasu stop) albo limit pamięci nie został zastosowany | Sprawdź `memory.max` w cgroup; zobacz Krok 10. |
| Brak linii OOM w `journalctl -k` | Brak uprawnień do odczytu dziennika jądra albo wpis jest starszy niż okno `--since` | Zobacz UWAGĘ w Kroku 10; użyj `--since "-10min"`. |
| `/proc/<pid>/ns` lub ścieżka cgroup nie istnieje | Kontener już się zatrzymał albo PID jest nieaktualny | Uruchom `podman ps` i odczytaj PID ponownie. |
| `Error: creating container storage: the container name "lab-virt-oom" is already in use` | Został zatrzymany kontener o tej nazwie | `podman rm lab-virt-oom` |
## Wyzwanie (opcjonalne)
Wykonaj bez instrukcji krok po kroku:
1. Uruchom kontener z `--pids-limit 20` i spróbuj uruchomić w nim więcej niż 20 procesów (na przykład pętlą powłoki wykonującą `sleep 300 &`). Jaki błąd dostajesz i który plik oraz licznik cgroup się zmieniły? Potem usuń kontener.
2. Uruchom kontener z `--uts=host`, a potem z `--pid=host`, i porównaj `hostname` oraz `ps` z ustawieniami domyślnymi. Jaką izolację usunąłeś w każdym przypadku? Dlaczego rzadko by się tego chciało?
3. Zbuduj obraz ponownie z `FROM docker.io/library/alpine:3.20.10@sha256:<digest>` (digest uzyskasz przez `podman image inspect docker.io/library/alpine:3.20.10 --format '{{.Digest}}'`). Co gwarantuje digest, czego nie gwarantuje tag?
## Sprzątanie
Usuń kontenery (nazwy są jawne, a `--ignore` pomija te, których już nie ma), zbudowany obraz i katalog laboratorium:
```bash
podman rm -f -t 0 --ignore lab-virt-demo lab-virt-limited lab-virt-oom lab-virt-hello
podman rmi lab-virt-hello:1.0
cd ~ && rm -r ~/virt-lab
```
Oczekiwany wynik (identyfikatory się różnią; pierwsze polecenie wypisuje nazwę każdego usuniętego kontenera, a jeśli żaden nie został, nic):
```text
Untagged: localhost/lab-virt-hello:1.0
Deleted: de5c993d6a996bcc2d734c27e4290c4d4d80a12865dc8c7833be391f7e51feb6
Deleted: 964fed8bd61ca0b105dcbf80de33b5c8eb7bab12ab5f96fa46d4d98e2830587a
Deleted: c76c408b748b1e099ea7e4d5e1350499b7d405187fe91f6d497e686e4688fba6
Deleted: b1be2b84c1863941b122d42738aeef7356b81e3f2704e6db0b2faa6f099e28f3
```
Jeśli obraz bazowy pobrałeś tylko na potrzeby tego laboratorium, usuń go też. Pomiń to, jeśli używasz Alpine 3.20.10 do czegoś innego; Podman odmawia usunięcia obrazu, którego nadal używa kontener:
```bash
podman rmi docker.io/library/alpine:3.20.10
```
Sprawdź, czy nic nie zostało:
```bash
podman ps -a --filter name=lab-virt-
podman images lab-virt-hello
ls ~/virt-lab
```
Pierwsze dwa polecenia wypisują tylko linie nagłówkowe (lub nic), a `ls` zgłasza, że katalog nie istnieje.
## Co już umiesz
- `Containerfile` staje się obrazem OCI złożonym z warstw: każde `RUN` i `COPY` dodaje jedną, a `CMD` i `LABEL` dodają tylko metadane. Przypięcie obrazu bazowego do dokładnego tagu utrzymuje budowanie powtarzalne.
- Kontener to zwykły proces hosta: `podman top` pokazuje jego PID na hoście, `/proc/<pid>/ns` pokazuje, że jest we własnych przestrzeniach nazw pid, net, mnt, uts, ipc, user i cgroup, a `uname -r` pokazuje, że dzieli jądro hosta.
- W kontenerze rootless root w środku to Twój własny nieuprzywilejowany użytkownik na zewnątrz, dzięki odwzorowaniu przestrzeni nazw user.
- `--memory` i `--cpus` stają się `memory.max` i `cpu.max` w cgroup kontenera; przekroczenie limitu CPU dławi, a przekroczenie limitu pamięci wywołuje OOM killera.
- Kod wyjścia 137 oznacza `SIGKILL`; `OOMKilled=true`, linia z dziennika jądra i `memory.events` mówią, czy zrobił to OOM killer, a rozwiązaniem jest zrozumienie rzeczywistej potrzeby pamięci, a nie tylko podniesienie limitu.