---
title: "Laboratorium: wewnątrz kontenera"
domain: cloud-computing
level: beginner
duration: "75 min"
cost: "bezpłatnie"
environment: "Twój własny komputer z Linuksem (lub VM z Linuksem) z Podmanem 4 lub nowszym, w trybie rootless"
lang: pl
source_hash: d1103e63f686
---

# Laboratorium: wewnątrz kontenera

## 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
![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.](../../../assets/diagrams/virt-lab-architecture.pl.svg)

*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.
