---
title: "Wirtualizacja i kontenery: dwa sposoby dzielenia jednej maszyny"
domain: cloud-computing
level: beginner
duration: "50 min"
objectives:
  - "Wyjaśnić, jak działa wirtualizacja sprzętowa, i porównać hipernadzorców typu 1 i typu 2."
  - "Porównać maszyny wirtualne i kontenery pod względem izolacji, czasu uruchamiania, gęstości i narzutu."
  - "Wyjaśnić, jak przestrzenie nazw (namespaces) i grupy kontrolne (cgroups) Linuksa izolują i ograniczają kontener."
  - "Zbudować obraz kontenera i wyjaśnić jego warstwy oraz formaty Open Container Initiative (OCI)."
  - "Skonfigurować limity zasobów kontenera i zdiagnozować kontener zatrzymany z powodu przekroczenia pamięci."
lang: pl
source_hash: 4bf9ebf7179f
---

# Wirtualizacja i kontenery: dwa sposoby dzielenia jednej maszyny

## Dlaczego to ważne
Uruchamiasz w chmurze „mały” serwer i jest gotowy w mniej niż minutę. Za tym przyciskiem dostawca nie podłączył dla Ciebie nowego komputera. Wykroił kawałek znacznie większej maszyny, a dziesiątki innych klientów dzielą ten sam sprzęt. To dzielenie umożliwiają dwie techniki: **wirtualizacja**, która daje każdemu klientowi kompletny udawany komputer, oraz **kontenery**, które dają każdej aplikacji własny, prywatny widok jednego wspólnego systemu operacyjnego.

Ten wybór ma znaczenie każdego dnia. Maszyna wirtualna (VM) to mocny, ale ciężki mur. Kontener jest lekki i szybki, lecz dzieli jądro swojego hosta, więc mur jest cieńszy. Kontener, który zjada całą pamięć, może zostać zabity w środku żądania, a kontener uruchomiony jako root z niewłaściwymi opcjami może zagrozić całemu hostowi. Aby wybrać właściwe narzędzie, odpowiednio je dobrać i bezpiecznie uruchamiać, musisz wiedzieć, czym naprawdę jest każde z nich i co faktycznie oddziela kontener od maszyny, na której działa. Ta lekcja wyjaśnia jedno i drugie.

## Cele nauki
- Wyjaśnić, jak działa wirtualizacja sprzętowa, i porównać hipernadzorców typu 1 i typu 2.
- Porównać maszyny wirtualne i kontenery pod względem izolacji, czasu uruchamiania, gęstości i narzutu.
- Wyjaśnić, jak przestrzenie nazw (namespaces) i grupy kontrolne (cgroups) Linuksa izolują i ograniczają kontener.
- Zbudować obraz kontenera i wyjaśnić jego warstwy oraz formaty Open Container Initiative (OCI).
- Skonfigurować limity zasobów kontenera i zdiagnozować kontener zatrzymany z powodu przekroczenia pamięci.

## Kluczowe pojęcia

### Wirtualizacja sprzętowa i hipernadzorcy
Wyobraź sobie duży biurowiec. Jedna opcja to wynająć każdej firmie piętro z własnymi ścianami, drzwiami i instalacjami. Druga to wynająć biurka na jednym wspólnym piętrze typu open space, oddzielone przepierzeniami. Pierwsza to wirtualizacja: każdy najemca dostaje cały „budynek” tylko dla siebie. Druga, którą poznasz dalej w tej lekcji, to kontenery.

**Wirtualizacja** oznacza uruchamianie wielu izolowanych komputerów wirtualnych na jednym komputerze fizycznym, czyli **hoście**. Każdy komputer wirtualny to **maszyna wirtualna (VM)**, zwana też **gościem** (*guest*). Gość ma własne wirtualne procesory, pamięć, dysk i karty sieciowe oraz uruchamia własny, kompletny system operacyjny (SO) z własnym **jądrem** (*kernel*), czyli rdzeniem systemu, który rozmawia ze sprzętem. Gość wierzy, że ma prawdziwy sprzęt.

Oprogramowanie, które tworzy i uruchamia maszyny wirtualne, to **hipernadzorca** (hypervisor), czyli monitor maszyn wirtualnych (VMM, *virtual machine monitor*). Ma trzy zadania:
- **Dzielić sprzęt.** Szereguje wirtualne procesory wszystkich gości na rzeczywistych rdzeniach CPU i daje każdemu gościowi własny kawałek prawdziwej pamięci.
- **Izolować gości.** Gość nie może czytać pamięci innego gościa ani przejąć hosta, ponieważ hipernadzorca kontroluje, czego każdy może dotknąć.
- **Prezentować urządzenia wirtualne.** Gość widzi wirtualny dysk i wirtualną kartę sieciową, które hipernadzorca odwzorowuje na prawdziwe pliki, pamięć masową i porty sieciowe.

Wczesna wirtualizacja była wolna, ponieważ jądro gościa oczekuje działania w najbardziej uprzywilejowanym trybie procesora, a może go zajmować tylko jedno jądro. Sztuczki programowe (tłumaczenie lub przechwytywanie instrukcji uprzywilejowanych) sprawiły, że działało, ale kosztem wydajności. Nowoczesne procesory rozwiązały to dzięki **wirtualizacji wspomaganej sprzętowo**: **Intel VT-x** i **AMD-V** (flagi `vmx` i `svm` w `/proc/cpuinfo` w Linuksie). Dodają nowy tryb procesora dla gości: jądro gościa działa z pełnymi uprawnieniami, ale w trybie, w którym procesor oddaje sterowanie hipernadzorcy, co nazywa się **VM exit**, za każdym razem, gdy gość robi coś, co musi być kontrolowane, na przykład sięga do urządzenia. Inne rozszerzenia przyspieszają pamięć (tłumaczenie adresów drugiego poziomu, zwane EPT w Intelu i NPT w AMD) i pozwalają hipernadzorcy dać gościowi bezpośredni, bezpieczny dostęp do urządzenia (jednostka zarządzania pamięcią wejścia-wyjścia, IOMMU: Intel VT-d, AMD-Vi). Na większości komputerów te funkcje można wyłączyć w ustawieniach firmware'u, dlatego hipernadzorca czasem zgłasza, że wirtualizacja jest niedostępna.

Gość może też działać szybciej, gdy wie, że jest wirtualny. **Parawirtualizowane** sterowniki, takie jak rodzina `virtio` używana przez KVM, zastępują udawany „prawdziwy” dysk lub kartę sieciową prostym interfejsem stworzonym dla maszyn wirtualnych.

Hipernadzorcy występują w dwóch konstrukcjach:

| | Typ 1 (bare metal) | Typ 2 (hostowany) |
|---|---|---|
| **Działa** | Bezpośrednio na sprzęcie | Jako aplikacja w zwykłym SO hosta |
| **Przykłady** | KVM, Xen, VMware ESXi, Microsoft Hyper-V | Oracle VirtualBox, VMware Workstation, Parallels Desktop |
| **Warstwy** między gościem a sprzętem | Hipernadzorca | Aplikacja hipernadzorcy, potem SO hosta |
| **Narzut i kontrola** | Mniejszy narzut, bezpośrednia kontrola sprzętu | Większy narzut, SO hosta nadal rządzi sprzętem |
| **Typowe zastosowanie** | Centra danych i chmury publiczne | Laptopy, maszyny deweloperskie, testy |

![Dwa stosy rysowane od sprzętu w górę. Typ 1, bare metal, z przykładami KVM, Xen, ESXi i Hyper-V: sprzęt (CPU z VT-x lub AMD-V, RAM, dyski, karty sieciowe) niesie bezpośrednio hipernadzorcę, a na nim trzy maszyny wirtualne, każda z własnym systemem operacyjnym gościa i jądrem oraz aplikacją. Notatka mówi, że ma mniej warstw i mniejszy narzut oraz że to typowy wybór w centrach danych i chmurach. Typ 2, hostowany, z przykładami VirtualBox, VMware Workstation i Parallels: sprzęt niesie system operacyjny hosta, taki jak Windows, macOS lub Linux; na hoście działa aplikacja hipernadzorcy, która prosi system hosta o CPU, pamięć i dysk, obok innych aplikacji; aplikacja hipernadzorcy niesie trzy maszyny wirtualne z systemem gościa i aplikacją. Notatka mówi, że ma jedną warstwę więcej, ale łatwo ją zainstalować na laptopie.](../../../assets/diagrams/virt-hypervisor-types.pl.svg)

*Rysunek 1. Hipernadzorca typu 1 działa bezpośrednio na sprzęcie; hipernadzorca typu 2 to jeszcze jedna aplikacja nad systemem operacyjnym hosta.*

> [!NOTE]
> Granica między tymi dwoma typami jest rozmyta, a powyższe przykłady to tylko przykłady. KVM to moduł wewnątrz jądra Linuksa: zamienia sam Linuksa w hipernadzorcę, a program taki jak QEMU dostarcza urządzenia wirtualne, więc zwykle zalicza się go do typu 1, chociaż Linux jest też SO ogólnego przeznaczenia. Hyper-V instaluje się na Windowsie, ale potem działa pod nim, a Windows staje się specjalną maszyną wirtualną. Liczy się to, ile jest warstw między gościem a sprzętem, a nie etykieta.

> [!CHECK]
> Dlaczego nowoczesne procesory mają rozszerzenia takie jak Intel VT-x i AMD-V?
>
> - [ ] Pozwalają maszynie wirtualnej gościa ominąć hipernadzorcę i używać urządzeń fizycznych bez żadnej kontroli
> - [x] Dają jądrom gości bezpieczny tryb, w którym większość instrukcji wykonuje się bezpośrednio na procesorze, a hipernadzorca odzyskuje kontrolę tylko wtedy, gdy trzeba
> - [ ] Pozwalają kilku maszynom wirtualnym dzielić jedno jądro, dzięki czemu są tak lekkie jak kontenery
> - [ ] Szyfrują dysk każdej maszyny wirtualnej, aby host nie mógł go odczytać
>
> Dzięki wsparciu sprzętowemu gość uruchamia własne jądro z pełną prędkością, a procesor przełącza się na hipernadzorcę tylko przy VM exit. To eliminuje większość wolnego tłumaczenia programowego, którego potrzebowali dawni hipernadzorcy. Nie eliminuje kontroli hipernadzorcy.

### Maszyny wirtualne a kontenery
VM wirtualizuje **sprzęt**: każdy gość przynosi własne jądro. **Kontener** wirtualizuje **system operacyjny**: to zwykły proces (lub grupa procesów) na hoście, uruchomiony z ograniczonym widokiem systemu. Wszystkie kontenery na hoście dzielą jedno jądro hosta. Nie ma SO gościa do uruchamiania, wirtualnego sprzętu ani hipernadzorcy na drodze.

![Po lewej maszyny wirtualne: sprzęt niesie hipernadzorcę, który niesie trzy maszyny wirtualne, każdą z własnym jądrem gościa, bibliotekami i apką. Etykiety: własne jądro w każdej VM, granica na poziomie sprzętu. Fakty: startuje w sekundy do minut, bo uruchamia system operacyjny, zwykle gigabajty na obraz, mniej na hosta. Po prawej kontenery: sprzęt niesie system operacyjny hosta z jednym wspólnym jądrem, którego namespaces i cgroups izolują każdy kontener; na nim środowisko kontenerów, takie jak Podman lub containerd z runc lub crun, uruchamia trzy kontenery, każdy tylko z własnymi bibliotekami i apką. Etykiety: jedno wspólne jądro, granica na poziomie jądra. Fakty: startuje w milisekundy do sekund, zwykle megabajty na obraz, znacznie więcej na hosta.](../../../assets/diagrams/virt-vm-vs-container.pl.svg)

*Rysunek 2. Każda VM niesie własne jądro gościa; wszystkie kontenery dzielą jądro hosta, więc kontener zawiera tylko aplikację i jej biblioteki.*

Ta jedna różnica tłumaczy każdy wiersz porównania:

| | Maszyna wirtualna | Kontener |
|---|---|---|
| **Co jest wirtualizowane** | Sprzęt | Widok SO (procesy, sieć, pliki) |
| **Jądro** | Jedno na VM | Wspólne z hostem i innymi kontenerami |
| **Granica izolacji** | Hipernadzorca i rozszerzenia wirtualizacji procesora | Funkcje jądra: namespaces, cgroups, capabilities, seccomp |
| **Siła izolacji** | Duża: powierzchnią ataku jest hipernadzorca | Mniejsza: powierzchnią ataku jest całe wspólne jądro |
| **Czas uruchamiania** | Sekundy do minut (uruchamia SO) | Milisekundy do kilku sekund (uruchamia proces) |
| **Typowy rozmiar obrazu** | Gigabajty (cały SO) | Megabajty (aplikacja i biblioteki) |
| **Narzut** | SO gościa na każdą VM: pamięć, dysk, CPU dla usług w tle | Zbliżony do zwykłego procesu |
| **Gęstość** | Mniej na hosta (dziesiątki) | Znacznie więcej na hosta (setki) |
| **SO gościa** | Cokolwiek, co sprzęt potrafi uruchomić: Linux, Windows, BSD | Ten sam typ jądra co host: kontenery linuksowe wymagają jądra Linuksa |
| **Typowe zastosowanie** | Różne systemy operacyjne, silne oddzielenie najemców, stare oprogramowanie | Mikrousługi, szybkie skalowanie, powtarzalne wdrażanie |

Liczby w tabeli to typowe rzędy wielkości, a nie gwarancje; zależą od obciążenia i platformy.

Warto zapamiętać dwie praktyczne konsekwencje:
- **Kontenery w Windowsie lub macOS** używają ukrytej maszyny wirtualnej z Linuksem, ponieważ te systemy nie mają jądra Linuksa do dzielenia. Narzędzie do kontenerów na Twoim laptopie to VM plus kontenery.
- **Prawdziwe systemy łączą oba podejścia.** Chmury publiczne uruchamiają Twoje kontenery wewnątrz maszyn wirtualnych, dzięki czemu błąd jądra w kontenerze jednego klienta nie sięga innego klienta. Lekkie opcje leżą pośrodku: **mikromaszyny wirtualne (microVM)** (jak Firecracker) dają każdemu obciążeniu malutką VM, która szybko startuje, a środowiska z piaskownicą (jak gVisor i Kata Containers) dodają dodatkową warstwę izolacji wokół kontenerów.

> [!CHECK]
> Musisz uruchomić aplikację Windows i aplikację Linux na tym samym serwerze, z silnym oddzieleniem między nimi. Co pasuje najlepiej?
>
> - [ ] Dwa kontenery, ponieważ kontenery startują szybciej niż maszyny wirtualne
> - [ ] Jeden kontener linuksowy dla obu, ponieważ kontenery mogą uruchamiać dowolną aplikację
> - [x] Dwie maszyny wirtualne, każda z własnym SO gościa
> - [ ] Hipernadzorca typu 2, ponieważ nie potrzebuje SO hosta
>
> Kontenery dzielą jądro hosta, więc host z Linuksem może uruchamiać tylko kontenery linuksowe. Maszyny wirtualne przynoszą własne jądro, więc każda może uruchamiać inny SO. Hipernadzorca typu 2 potrzebuje SO hosta.

### Przestrzenie nazw Linuksa (namespaces): co kontener może zobaczyć
Jak zwykły proces może wierzyć, że jest sam na maszynie? Jądro Linuksa może dać procesowi własną prywatną kopię zasobu systemowego. Każdy rodzaj prywatnej kopii to **przestrzeń nazw** (namespace). Proces żyje w jednej przestrzeni nazw każdego typu, a procesy w tej samej przestrzeni widzą to samo. Przestrzenie nazw stojące za kontenerem to:

| Przestrzeń nazw | Izoluje | Efekt wewnątrz kontenera |
|---|---|---|
| **pid** | Identyfikatory procesów | Pierwszy proces ma PID 1, a kontener widzi tylko własne procesy. |
| **net** | Interfejsy sieciowe, trasy, reguły zapory, porty | Własny interfejs sieciowy i adres IP oraz własne numery portów. |
| **mnt** | Punkty montowania | Własny główny system plików (obraz) zamiast systemu hosta. |
| **uts** | Nazwa hosta i nazwa domeny | Własna nazwa hosta. |
| **ipc** | Pamięć współdzielona i kolejki komunikatów | Procesy nie mogą używać pamięci współdzielonej innego kontenera. |
| **user** | Identyfikatory użytkowników i grup | Root (UID 0) w środku może odpowiadać zwykłemu, nieuprzywilejowanemu użytkownikowi na hoście. |
| **cgroup** | Widok drzewa cgroups | Kontener widzi własny cgroup jako korzeń drzewa. |

Nowsze jądra mają też przestrzeń nazw **time**, której kontenery domyślnie nie używają. Proces zwykle startuje w przestrzeniach nazw hosta; środowisko uruchomieniowe kontenerów tworzy nowe za pomocą wywołań systemowych `clone()` i `unshare()`, jak opisano w `namespaces(7)`. Możesz zobaczyć, w jakich przestrzeniach nazw jest proces, jako dowiązania w `/proc/<pid>/ns/`: dwa procesy dzielą przestrzeń nazw, gdy liczba w dowiązaniu jest taka sama.

Przestrzenie nazw zapewniają **izolację widoku**, a nie **limity**. Proces we własnej przestrzeni nazw pid nie widzi innych procesów, ale nadal może używać całego CPU i całej pamięci. Tym zajmuje się następny mechanizm.

### Grupy kontrolne (cgroups): czego kontener może użyć
**Grupa kontrolna (cgroup)** to funkcja jądra, która grupuje procesy i kontroluje, ile maszyny mogą wykorzystać. Nowoczesny Linux używa **cgroups w wersji 2 (v2)**, z jedną **ujednoliconą hierarchią** zamontowaną w `/sys/fs/cgroup`. Każda grupa to katalog, a jej limity odczytuje się i ustawia, czytając i zapisując pliki w nim. Każdy plik należy do **kontrolera**:

| Plik | Kontroler | Znaczenie |
|---|---|---|
| `memory.max` | memory | Twardy limit pamięci w bajtach (lub `max`, gdy brak). Powyżej niego jądro najpierw odzyskuje pamięć, a potem uruchamia OOM killera wewnątrz grupy. |
| `memory.high` | memory | Limit miękki: powyżej niego grupa jest spowalniana przez odzyskiwanie pamięci, ale nie jest zabijana. |
| `memory.current`, `memory.events` | memory | Bieżące zużycie oraz liczniki, np. ile razy wystąpiło `oom_kill`. |
| `cpu.max` | cpu | Limit i okres w mikrosekundach: `50000 100000` oznacza „50 ms CPU co 100 ms”, czyli pół procesora. `max 100000` oznacza brak limitu. |
| `cpu.weight` | cpu | Względny udział, gdy procesory są zajęte (domyślnie 100). |
| `pids.max` | pids | Maksymalna liczba procesów i wątków w grupie: zabezpieczenie przed fork bombami. |
| `io.max` | io | Limity przepustowości dysku i liczby operacji na sekundę dla urządzenia. |

![Proces kontenera, sleep 3600, jest PID 1 w swoim kontenerze i zwykłym PID hosta na zewnątrz. Wychodzą z niego dwie strzałki. Po lewej namespaces decydują, co może zobaczyć: pid, własne drzewo procesów; net, własne interfejsy, trasy i porty; mnt, własna tablica montowań i główny system plików; uts, własna nazwa hosta; ipc, własna pamięć współdzielona i kolejki; user, root w środku odpowiada użytkownikowi bez uprawnień; cgroup, własny widok drzewa cgroups. Po prawej cgroups w wersji 2 decydują, czego może użyć: memory.max, limit RAM, po przekroczeniu którego działa OOM killer; cpu.max, limit CPU taki jak 50000 100000, czyli pół CPU; pids.max, maksymalna liczba procesów; io.max, limity dysku. Notatka mówi, że to funkcje jądra, a nie hipernadzorca: proces działa bezpośrednio na jądrze hosta.](../../../assets/diagrams/virt-namespaces-cgroups.pl.svg)

*Rysunek 3. Namespaces ograniczają to, co kontener może zobaczyć; cgroups ograniczają to, czego może użyć. Razem z pozostałymi funkcjami bezpieczeństwa jądra to właśnie jest „kontener”.*

Kontener nie jest więc czymś, co jądro zna. To zwykły proces, uruchomiony w zestawie przestrzeni nazw i w cgroup, z innym głównym systemem plików. Dlatego startuje w milisekundy i ma prawie zerowy narzut. Dlatego też izolacja jest tak mocna, jak jądro.

Przekroczenie limitów zachowuje się inaczej dla każdego zasobu:
- **CPU** jest *ściśliwy*: grupa, która wyczerpie limit, jest **dławiona** (*throttled*, wstrzymywana do następnego okresu), a nie zabijana.
- **Pamięć** *nie* jest: jeśli grupa potrzebuje więcej niż `memory.max`, a jądro nie może odzyskać dość pamięci (na przykład porzucając pamięć podręczną plików), **OOM killer** (out-of-memory, brak pamięci) wybiera proces z tej grupy i wysyła mu `SIGKILL`.

> [!CHECK]
> Kontener działa z limitem CPU 0.5 CPU i limitem pamięci 256 MB. Cały czas próbuje użyć całego procesora i 300 MB. Co się dzieje?
>
> - [ ] Jądro natychmiast zatrzymuje kontener, ponieważ próbował przekroczyć limit
> - [ ] Oba limity tylko spowalniają kontener; nigdy nie jest zabijany
> - [x] Użycie CPU jest dławione do około pół procesora, a użycie pamięci uruchamia OOM killera
> - [ ] Limity to tylko wskazówki dla planisty; kontener dostaje to, czego potrzebuje
>
> CPU jest ściśliwy, więc cgroup go dławi. Pamięci nie można odebrać działającemu procesowi, więc po przekroczeniu `memory.max` OOM killer kończy proces w grupie.

### Obrazy kontenerów, warstwy i formaty OCI
Kontener startuje z **obrazu**: pakietu tylko do odczytu, zawierającego główny system plików oraz metadane (jakie polecenie uruchomić, zmienne środowiskowe, użytkownika). Obraz to szablon; działający **kontener** jest jego instancją. Pomyśl o klasie i obiekcie albo o przepisie i daniu.

Aby obrazy były małe i szybkie do udostępniania, obraz buduje się z **warstw**. Każda instrukcja pliku budowania (`Containerfile`, a w Dockerze `Dockerfile`), która zmienia system plików, jak `RUN` i `COPY`, dodaje jedną warstwę: skompresowane archiwum zawierające tylko zmienione pliki. Instrukcje zmieniające tylko metadane, jak `CMD` i `LABEL`, nie dodają warstwy. Warstwy są **adresowane zawartością**: każda ma nazwę będącą **digestem** jej zawartości, czyli `sha256:` i 64 cyfry szesnastkowe. Identyczne warstwy są przechowywane raz i współdzielone, więc dziesięć obrazów opartych na tym samym obrazie bazowym trzyma tę bazę na dysku tylko raz, a pobranie zaktualizowanego obrazu ściąga tylko warstwy, które się zmieniły.

Gdy uruchamiasz kontener, środowisko uruchomieniowe układa warstwy obrazu przy pomocy systemu plików z nakładaniem (zwykle **overlayfs**) i dodaje na wierzchu jedną cienką **warstwę zapisywalną**, dzięki czemu kontener widzi jeden system plików. Działa to dzięki **copy-on-write** (kopiowanie przy zapisie): niższa warstwa nigdy nie jest modyfikowana. Jeśli kontener zmienia plik leżący w niższej warstwie, plik jest najpierw kopiowany w górę do warstwy zapisywalnej i tam modyfikowany; jeśli go usuwa, znacznik („whiteout”) go ukrywa. Gdy kontener zostaje usunięty, jego warstwa zapisywalna znika razem z nim. Wszystko, co ma przetrwać kontener, należy do **woluminu**, czyli katalogu przechowywanego poza kontenerem.

![Po lewej obraz lab-virt-hello:1.0 jako trzy ułożone warstwy tylko do odczytu, wspólne dla każdego kontenera: warstwa 1, główny system plików Alpine z alpine:3.20.10, 8.09 MB; warstwa 2, RUN apk add procps-ng, 1.27 MB; warstwa 3, COPY app.sh, 3.58 kB. Notatka mówi, że CMD i LABEL zmieniają tylko konfigurację obrazu i nie dodają warstwy. Nad obrazem są dwa kontenery, A i B, każdy z własną zapisywalną warstwą copy-on-write, usuwaną razem z kontenerem. Notatka wyjaśnia, że zapis do pliku z niższej warstwy najpierw kopiuje go w górę, a usunięcie zostawia znacznik whiteout. Po prawej manifest obrazu wymienia config (ID obrazu) i trzy warstwy według digestów sha256, a karta zestawia tag, czyli nazwę, która może się zmienić, z digestem, czyli dokładnie tą zawartością na zawsze.](../../../assets/diagrams/virt-image-layers.pl.svg)

*Rysunek 4. Warstwy są tylko do odczytu i współdzielone; każdy kontener dodaje na wierzchu tylko cienką warstwę zapisywalną. Rozmiary pochodzą z obrazu, który budujesz w laboratorium.*

**Open Container Initiative (OCI)**, projekt neutralny wobec dostawców działający pod Linux Foundation, definiuje standardy, dzięki którym narzędzia różnych producentów współpracują. Dlatego obraz zbudowany w Podmanie działa w Dockerze, containerd lub klastrze Kubernetes, i odwrotnie. Są trzy specyfikacje:

| Specyfikacja | Definiuje |
|---|---|
| **Specyfikacja obrazu** | Format obrazu: **manifest** (wymienia konfigurację i warstwy według digestów), **konfigurację** (polecenie, środowisko, historię) i archiwa warstw. |
| **Specyfikacja środowiska uruchomieniowego** | Jak uruchomić rozpakowany obraz: główny system plików i `config.json`, który wymienia przestrzenie nazw, limity cgroup, montowania i capabilities. **runc** to środowisko referencyjne; **crun** to inne. |
| **Specyfikacja dystrybucji** | API HTTP, którego **rejestr** używa do wysyłania i pobierania obrazów. |

**Rejestr** (*registry*) przechowuje i udostępnia obrazy (przykłady: Docker Hub, Quay.io, GitHub Container Registry oraz rejestry chmur publicznych). Odwołanie do obrazu ma postać `rejestr/repozytorium:tag`, na przykład `docker.io/library/alpine:3.20.10`. Dwa sposoby nazywania obrazu zachowują się bardzo różnie:
- **Tag** (`3.20.10`, `latest`) to przyjazna ludziom etykieta, którą wydawca może w każdej chwili **przenieść** na inny obraz. `latest` to tylko domyślna nazwa tagu; nie oznacza „najnowszy”.
- **Digest** (`alpine@sha256:<64 cyfry szesnastkowe>`) identyfikuje dokładną zawartość. Nigdy nie może wskazywać niczego innego.

Dla powtarzalnych budowań przypnij obraz bazowy do dokładnego tagu wersji (`alpine:3.20.10`, a nie `alpine` ani `alpine:latest`) oraz przypinaj według digestu tam, gdzie potrzebujesz gwarancji, że zawartość się nie zmieniła.

> [!CHECK]
> `Containerfile` zawiera `FROM alpine:3.20.10`, potem `RUN apk add --no-cache curl`, potem `COPY app.sh /app.sh` i `CMD ["/app.sh"]`. Ile nowych warstw dodaje budowanie na obrazie bazowym?
>
> - [ ] Cztery, po jednej na instrukcję
> - [x] Dwie: `RUN` i `COPY`
> - [ ] Jedną, ponieważ budowanie scala wszystko w jedną warstwę
> - [ ] Trzy: `RUN`, `COPY` i `CMD`
>
> Warstwę dodają tylko instrukcje zmieniające system plików. `CMD` (jak `LABEL`) zmienia tylko konfigurację obrazu, a `FROM` wybiera warstwy bazowe zamiast dodawać nową.

### Bezpieczne uruchamianie kontenerów: tryb rootless, limity i OOM killer
Domyślnie wiele silników kontenerów działa jako root. Jeśli coś ucieknie z kontenera, ląduje na hoście jako root. Dwie funkcje zmniejszają to ryzyko.

**Kontenery rootless** uruchamiają silnik i kontener jako zwykły użytkownik. Dzięki **przestrzeni nazw user** UID 0 *wewnątrz* kontenera jest odwzorowany na Twój nieuprzywilejowany UID *na zewnątrz*, a pozostałe UID kontenera na zakres podrzędnych UID zarezerwowany dla Ciebie w `/etc/subuid`. Kontener myśli, że jest rootem, ale na hoście ma tylko Twoje prawa. Tak działa Podman rootless, a Docker również wspiera tryb rootless. Podman nie ma centralnego demona; każdy kontener jest uruchamiany przez własny proces użytkownika. Kompromisy: kontener rootless nie może robić rzeczy wymagających prawdziwego roota, takich jak domyślnie wiązanie do portów poniżej 1024, ładowanie modułów jądra czy zmiana sieci hosta, a jego sieć przechodzi przez pomocnika w przestrzeni użytkownika (jak `pasta` lub `slirp4netns`), który jest wolniejszy niż konfiguracja sieci z rootem.

**Limity zasobów** chronią hosta i sąsiadów przed kontenerem, który wymknął się spod kontroli. W Podmanie i Dockerze są to opcje `run`:

| Opcja | Ustawia |
|---|---|
| `--memory 64m` | `memory.max` (Podman ustawia też `memory.swap.max` na tę samą wartość) |
| `--cpus 0.5` | `cpu.max` (limit 50000 na okres 100000) |
| `--pids-limit 100` | `pids.max` |

Kontener zatrzymany przez OOM killera kończy się **kodem wyjścia 137**, czyli 128 plus sygnał 9 (`SIGKILL`). Sam kod wyjścia 137 nie dowodzi braku pamięci: każdy `SIGKILL` go daje, na przykład gdy `stop` przekroczy limit czasu i silnik zabije kontener. Aby to zdiagnozować:
1. Sprawdź silnik: `podman inspect <nazwa> --format '{{.State.OOMKilled}}'` zwraca `true`, gdy zadziałał OOM killer cgroup.
2. Sprawdź dziennik jądra (`journalctl -k` lub `dmesg`) pod kątem linii `Memory cgroup out of memory: Killed process ...`.
3. Sprawdź `memory.events` cgroup: licznik `oom_kill`.
4. Napraw: ustal, dlaczego proces potrzebuje tyle pamięci (wyciek, duża pamięć podręczna lub źle oszacowany rozmiar), a potem popraw kod lub podnieś limit. Limit za niski dla rzeczywistego obciążenia tylko zamienia powolność w awarie.

> [!CHECK]
> Kontener zakończył się kodem 137. `podman inspect` pokazuje `OOMKilled=false`. Jakie jest najbardziej prawdopodobne wyjaśnienie?
>
> - [ ] Kontener użył zbyt dużo CPU i został zdławiony na śmierć
> - [ ] Jądro zawsze używa 137, gdy kontener kończy się normalnie
> - [x] Jakiś proces wysłał mu `SIGKILL` z innego powodu, na przykład silnik po przekroczeniu limitu czasu stop
> - [ ] Obraz ma zbyt wiele warstw
>
> Kod wyjścia 137 oznacza „zabity sygnałem 9”. OOM killer to tylko jeden z możliwych nadawców. `OOMKilled=false` mówi, że nie zrobił tego cgroup pamięci. Limity CPU dławią, nigdy nie zabijają.

## Jak to działa
Oto, co się dzieje, gdy jako zwykły użytkownik wpisujesz `podman run --memory 64m alpine:3.20.10 sleep 3600`:

1. **Rozwiązać obraz.** Silnik szuka `alpine:3.20.10` w lokalnym magazynie. Jeśli go tam nie ma, prosi rejestr (specyfikacja dystrybucji) o manifest, potem pobiera konfigurację i każdą warstwę według digestu, pomijając te, które już ma, i sprawdza każdy digest.
2. **Rozpakować warstwy.** Środowisko uruchomieniowe układa warstwy przy pomocy overlayfs i dodaje nową, pustą warstwę zapisywalną.
3. **Zapisać konfigurację środowiska.** Silnik tworzy `config.json` środowiska OCI: polecenie, przestrzenie nazw do utworzenia, limity cgroup (`memory.max` = 67108864), montowania i capabilities do porzucenia.
4. **Utworzyć izolowany proces.** Niskopoziomowe środowisko (`crun` lub `runc`) tworzy przestrzenie nazw, umieszcza proces w nowym katalogu cgroup poniżej `/sys/fs/cgroup`, stosuje limity, przełącza główny system plików, porzuca uprawnienia i wykonuje `exec` na `sleep 3600`. W trybie rootless najpierw powstaje przestrzeń nazw user, więc kolejne kroki są dozwolone bez prawdziwego roota.
5. **Uruchomić.** Od tej chwili `sleep` to zwykły proces, szeregowany przez jądro hosta. Jest PID 1 we własnej przestrzeni nazw pid i ma zwykły PID na hoście.
6. **Zatrzymać.** Gdy proces się kończy, środowisko usuwa przestrzenie nazw i cgroup. Gdy kontener zostaje usunięty, jego warstwa zapisywalna jest kasowana; obraz zostaje w magazynie.

Uruchomienie VM, przeciwnie, musi wystartować wirtualny sprzęt hipernadzorcy, wykonać firmware, uruchomić całe jądro i usługi systemowe, zanim Twoja aplikacja w ogóle ruszy. To jest różnica czasu uruchamiania, którą widziałeś w tabeli.

## Przykład praktyczny
Najpierw sprawdź, czy Twój procesor obsługuje wirtualizację sprzętową i czy Linux udostępnia urządzenie KVM (wynik z maszyny AMD; maszyna Intel pokazuje `vmx` i `VT-x`):

```bash
grep -o -m1 -w -E 'vmx|svm' /proc/cpuinfo
lscpu | grep -i virtualization
ls -l /dev/kvm
```

```text
svm
Virtualization:                          AMD-V
crw-rw-rw-. 1 root kvm 10, 232 Nov  7 19:11 /dev/kvm
```

Jeśli `grep` nic nie wypisze, albo procesor nie ma rozszerzeń, albo są wyłączone w firmware; wewnątrz VM wirtualizacja zagnieżdżona musi być włączona przez hosta.

Teraz: jak limity przekazane do `podman run` stają się wartościami cgroup?

| Prosisz o | Jądro zapisuje | Obliczenie |
|---|---|---|
| `--memory 64m` | `memory.max` = `67108864` | 64 × 1024 × 1024 bajtów |
| `--cpus 0.5` | `cpu.max` = `50000 100000` | 0.5 × okres 100 000 µs = 50 000 µs CPU na okres |
| `--pids-limit 20` | `pids.max` = `20` | liczba bez zmian |

Na koniec diagnoza. Zespół uruchamia kontener z `--memory 64m`, który buduje w pamięci łańcuch o rozmiarze 200 MB. Ginie po około sekundzie:

```text
$ podman inspect report-job --format 'OOMKilled={{.State.OOMKilled}} ExitCode={{.State.ExitCode}}'
OOMKilled=true ExitCode=137
```

```text
kernel: Memory cgroup out of memory: Killed process 18629 (sh) total-vm:136808kB, anon-rss:60812kB ...
```

`OOMKilled=true` oraz linia z dziennika jądra dowodzą, że przyczyną był limit pamięci: proces miał około 60 MB rezydentnej pamięci, gdy osiągnął limit 64 MB (który wlicza też trochę pamięci jądra). Rozwiązaniem jest przetwarzanie danych strumieniowo zamiast trzymania ich wszystkich albo, jeśli naprawdę potrzeba 200 MB, podniesienie limitu (na przykład `--memory 512m`) *i* sprawdzenie, czy host ma tyle pamięci do oddania. Dokładnie ten przypadek odtworzysz w laboratorium.

## Typowe błędy
- **Traktowanie kontenera jak małej VM.** Kontener to proces z ograniczonym widokiem. Nie ma własnego jądra: `uname -r` w środku pokazuje jądro hosta, a luka w jądrze dotyka każdego kontenera na hoście.
- **Używanie `latest` lub krótkiego tagu.** `alpine` i `latest` zmieniają się pod Tobą, a przebudowanie za miesiąc może dać inny obraz. Przypnij dokładny tag wersji albo digest.
- **Przechowywanie danych w warstwie zapisywalnej.** Znika razem z kontenerem. Użyj woluminu dla danych, które mają przetrwać.
- **Zapominanie, że kod wyjścia 137 nie jest diagnozą.** Oznacza „SIGKILL”; potwierdź brak pamięci przez `OOMKilled` i dziennik jądra, zanim cokolwiek zmienisz.
- **Brak limitów.** Kontener bez `--memory` może użyć całej pamięci hosta, a OOM killer może wtedy wybrać proces należący do kogoś innego.
- **Czytanie „limitów” CPU jak rezerwacji.** `--cpus 0.5` ogranicza kontener od góry; nie gwarantuje mu pół procesora, gdy host jest zajęty. Użyj wag (lub żądań planisty w orkiestratorze), aby uzyskać gwarancje.
- **Uruchamianie jako root w kontenerze „bo działa”.** Dodaj w obrazie `USER` inny niż root i porzuć to, czego aplikacja nie potrzebuje.

## Kwestie bezpieczeństwa
Wirtualizacja i kontenery to narzędzia izolacji, a każde ma inną powierzchnię ataku. **NIST SP 800-125** omawia bezpieczeństwo pełnej wirtualizacji (hipernadzorcy, goście i zarządzanie), a **NIST SP 800-190**, Application Container Security Guide, omawia kontenery. Ta sekcja podąża za strukturą SP 800-190: obrazy, rejestry, orkiestratory, kontenery i SO hosta.

**Siła izolacji.** Ucieczka z VM (gość wydostający się przez błąd hipernadzorcy) jest rzadka i poważna, ponieważ hipernadzorca to mały, dobrze przetestowany interfejs. Ucieczka z kontenera ma większy cel: cały interfejs jądra, który dzielą wszystkie kontenery. Błędy jądra i środowiska uruchomieniowego, takie jak luka `runc` CVE-2019-5736, pozwalały kontenerowi nadpisać środowisko uruchomieniowe hosta. Dla obciążeń różnych najemców, którzy sobie nie ufają, użyj VM lub mikromaszyn wirtualnych albo otocz kontenery środowiskami z piaskownicą.

**Obrazy.** Tu zaczynają się ryzyka z SP 800-190:
- *Luki w obrazie.* Obraz zawiera warstwę SO i biblioteki, które się starzeją. Przebudowuj regularnie, skanuj obrazy skanerem podatności i utrzymuj je małe (minimalny obraz bazowy ma mniej pakietów do łatania).
- *Osadzone sekrety.* Hasła, tokeny i klucze skopiowane do warstwy zostają w niej na zawsze, nawet jeśli późniejsza warstwa usunie plik. Przekazuj sekrety w czasie działania przez mechanizm sekretów.
- *Niezaufane lub zmanipulowane obrazy.* Używaj obrazów ze źródeł, którym ufasz, przypinaj wersje lub digesty i weryfikuj podpisy (na przykład przez `cosign` ze Sigstore), gdy Twój rejestr to wspiera.

**Rejestry.** Używaj TLS dla każdego połączenia, wymagaj uwierzytelniania, ogranicz, kto może wysyłać obrazy, i usuwaj przestarzałe obrazy, które utrzymują dostępność starych podatności.

**Kontenery i host.** Domyślne ustawienia środowiska już pomagają: ograniczony zestaw capabilities Linuksa, domyślny profil seccomp (filtr wywołań systemowych) oraz, w systemach z rodziny Fedora i rodziny Debian, profile SELinux lub AppArmor. Nie wyłączaj ich bez poważnego powodu:
- Unikaj `--privileged`: usuwa niemal całą izolację. Unikaj `--cap-add` ponad minimum.
- Nigdy nie montuj gniazda silnika (`/var/run/docker.sock`) w kontenerze: kto je kontroluje, kontroluje hosta.
- Nie montuj w kontenerze wrażliwych ścieżek hosta (`/`, `/etc`, `/proc`) i montuj woluminy tylko do odczytu, gdy to możliwe (`:ro`). Użyj `--read-only` dla głównego systemu plików, gdy aplikacja na to pozwala.
- Preferuj silniki **rootless** i `USER` inny niż root w obrazie: wtedy nawet udana ucieczka ląduje jako zwykły użytkownik.
- Ustaw limity pamięci, CPU i PID, aby jeden kontener nie zagłodził pozostałych.
- Uruchamiaj minimalny, regularnie łatany SO hosta przeznaczony dla kontenerów, ponieważ każdy kontener dzieli jego jądro.

**Sieć.** Kontenery domyślnie mogą komunikować się ze sobą i z siecią. Publikuj tylko potrzebne porty i wiąż z `127.0.0.1`, gdy usługa jest do użytku lokalnego.

> [!IMPORTANT]
> Laboratorium uruchamia tylko kontenery, które sam startujesz, na własnej maszynie, z nazwami zaczynającymi się od `lab-virt-`, bez roota i bez `--privileged`. Nie ćwicz technik ucieczki na współdzielonych hostach ani na żadnym systemie, który nie należy do Ciebie.

## Podsumowanie
- Wirtualizacja sprzętowa uruchamia kompletne systemy operacyjne gości na jednym hoście; hipernadzorca dzieli i izoluje sprzęt, a rozszerzenia procesora (Intel VT-x, AMD-V) sprawiają, że jest szybka. Hipernadzorcy typu 1 działają na sprzęcie, typu 2 na SO hosta.
- VM wirtualizuje sprzęt i ma własne jądro: silna izolacja, wolniejszy start, większy narzut. Kontener wirtualizuje widok SO i dzieli jądro hosta: szybki i gęsty, ale izolowany tylko tak mocno jak to jądro.
- Namespaces (pid, net, mnt, uts, ipc, user, cgroup) decydują, co kontener może zobaczyć; cgroups v2 (`memory.max`, `cpu.max`, `pids.max`) decydują, czego może użyć. Kontener to zwykły proces wewnątrz obu.
- Obraz to stos warstw tylko do odczytu, adresowanych zawartością, plus konfiguracja; kontener dodaje zapisywalną warstwę copy-on-write. OCI standaryzuje formaty obrazu, środowiska uruchomieniowego i dystrybucji. Tagi mogą się przesuwać, digesty nie.
- Pamięć ponad limit uruchamia OOM killera (kod wyjścia 137, `OOMKilled=true`); CPU ponad limit jest tylko dławiony. Uruchamiaj w trybie rootless, ustawiaj limity i stosuj się do NIST SP 800-190.

## Słowniczek
| Termin | Definicja |
|---|---|
| Wirtualizacja | Uruchamianie wielu izolowanych komputerów wirtualnych na jednym komputerze fizycznym. |
| Host | Maszyna fizyczna (lub działający na niej SO), która uruchamia gości lub kontenery. |
| Gość (guest) | Maszyna wirtualna i działający w niej system operacyjny. |
| Maszyna wirtualna (VM) | Komputer zdefiniowany programowo z wirtualnymi procesorami, pamięcią, dyskami i kartami sieciowymi, uruchamiający własny SO i jądro. |
| Hipernadzorca (hypervisor) | Oprogramowanie, które tworzy i uruchamia VM oraz dzieli i izoluje między nimi sprzęt; zwane też monitorem maszyn wirtualnych (VMM). |
| Hipernadzorca typu 1 | Hipernadzorca działający bezpośrednio na sprzęcie (bare metal), na przykład KVM, Xen, ESXi, Hyper-V. |
| Hipernadzorca typu 2 | Hipernadzorca działający jako aplikacja w SO hosta, na przykład VirtualBox, VMware Workstation. |
| Intel VT-x, AMD-V | Rozszerzenia procesora dla wirtualizacji wspomaganej sprzętowo; flagi `vmx` i `svm`. |
| VM exit | Moment, w którym procesor przestaje wykonywać gościa i oddaje sterowanie hipernadzorcy. |
| EPT, NPT | Wsparcie sprzętowe Intela i AMD do tłumaczenia adresów pamięci gościa na rzeczywiste (tłumaczenie adresów drugiego poziomu). |
| IOMMU | Sprzęt kontrolujący i tłumaczący dostęp urządzeń do pamięci, używany do bezpiecznego dania gościowi bezpośredniego dostępu do urządzenia (Intel VT-d, AMD-Vi). |
| Parawirtualizacja | Sterowniki gościa stworzone dla sprzętu wirtualnego (na przykład virtio), szybsze niż udawanie urządzeń rzeczywistych. |
| Jądro (kernel) | Rdzeń systemu operacyjnego, który zarządza sprzętem, procesami i pamięcią. |
| Kontener | Proces lub grupa procesów działająca na jądrze hosta z własnymi przestrzeniami nazw, cgroup i głównym systemem plików. |
| Przestrzeń nazw (namespace) | Funkcja jądra dająca procesom prywatny widok zasobu (pid, net, mnt, uts, ipc, user, cgroup, time). |
| Grupa kontrolna (cgroup) | Funkcja jądra, która grupuje procesy oraz ogranicza lub rozlicza używane przez nie zasoby. |
| cgroups v2 | Obecna konstrukcja cgroup, z jedną ujednoliconą hierarchią w `/sys/fs/cgroup` i jednym plikiem kontrolnym na ustawienie. |
| Kontroler | Składnik cgroup zarządzający jednym zasobem: memory, cpu, io, pids. |
| Throttling (dławienie) | Wstrzymanie cgroup, która wyczerpała limit CPU, do następnego okresu. |
| OOM killer | Funkcja jądra, która zabija proces, gdy kończy się pamięć lub gdy cgroup pamięci osiąga `memory.max` i nie może odzyskać pamięci. |
| Kod wyjścia 137 | 128 + 9: proces został zabity przez `SIGKILL`; przy `OOMKilled=true` zrobił to OOM killer. |
| Obraz | Pakiet tylko do odczytu z głównym systemem plików i metadanymi, używany jako szablon do uruchamiania kontenerów. |
| Warstwa (layer) | Archiwum adresowane zawartością z plikami zmienionymi przez jeden krok budowania; warstwy układa się w stos, tworząc obraz. |
| Containerfile (Dockerfile) | Plik tekstowy z krokami budowania obrazu. |
| Digest | Skrót SHA-256 manifestu lub warstwy (`sha256:…`); identyfikuje dokładną zawartość. |
| Tag | Przesuwalna, przyjazna ludziom etykieta wersji obrazu, taka jak `3.20.10` lub `latest`. |
| Copy-on-write | Zmiana pliku z niższej warstwy tylko do odczytu przez najpierw skopiowanie go do warstwy zapisywalnej. |
| overlayfs | System plików z nakładaniem, który układa warstwy obrazu i warstwę zapisywalną w jeden widok. |
| Wolumin (volume) | Pamięć masowa poza warstwą zapisywalną kontenera, która przeżywa kontener. |
| Rejestr (registry) | Serwer, który przechowuje i dystrybuuje obrazy (na przykład Docker Hub, Quay.io). |
| Open Container Initiative (OCI) | Projekt neutralny wobec dostawców, który definiuje specyfikacje obrazu, środowiska uruchomieniowego i dystrybucji. |
| runc, crun | Niskopoziomowe środowiska uruchomieniowe OCI, które tworzą przestrzenie nazw i cgroups oraz uruchamiają proces kontenera. |
| Kontener rootless | Kontener uruchamiany przez zwykłego użytkownika, z przestrzenią nazw user odwzorowującą roota kontenera na nieuprzywilejowanego użytkownika hosta. |
| Capability | Jeden z drobnych kawałków władzy roota w Linuksie, który kontener może zachować lub porzucić. |
| seccomp | Filtr jądra ograniczający, których wywołań systemowych proces może używać. |
| microVM | Bardzo mała, szybko startująca VM używana do izolowania jednego obciążenia (na przykład Firecracker). |

## Sprawdź swoją wiedzę
1. Wyjaśnij własnymi słowami, dlaczego VM startuje w sekundy do minut, a kontener w milisekundy. Co musi uruchomić każdy z nich?
2. Kolega mówi: „kontenery to tylko lekkie VM”. Podaj dwie różnice, jedną dotyczącą jądra i jedną dotyczącą bezpieczeństwa.
3. Dwa kontenery uruchamiają ten sam obraz. Kontener A zapisuje plik 50 MB we własnym systemie plików. Czy kontener B go widzi? Gdzie plik się znajduje i kiedy jest usuwany?
4. Twój `Containerfile` zaczyna się od `FROM python`. Podaj dwa sposoby, w jakie może to zepsuć budowanie, które działało w zeszłym miesiącu, i przepisz linię tak, aby zapobiec obu.
5. Kontener jest uruchamiany z `--memory 128m --cpus 1`. Jakich wartości `memory.max` i `cpu.max` spodziewasz się w plikach cgroup? Co się dzieje, gdy potrzebuje 200 MB pamięci? A gdy potrzebuje dwóch procesorów?
6. Kontener bazy danych kończy się kodem 137. Wypisz kroki, które wykonujesz, aby ustalić, czy zabrakło mu pamięci, i podaj dwie możliwe poprawki.
7. Zespół chce uruchamiać na tym samym serwerze kod od różnych klientów. Porównaj w tym celu VM, kontenery i kontenery z piaskownicą oraz powiedz, jakich kontroli z NIST SP 800-190 byś wymagał.

## Źródła
- [NIST SP 800-125](https://csrc.nist.gov/pubs/sp/800/125/final) — Guide to Security for Full Virtualization Technologies.
- [NIST SP 800-190](https://csrc.nist.gov/pubs/sp/800/190/final) — Application Container Security Guide.
- [OCI Image Format Specification](https://github.com/opencontainers/image-spec).
- [OCI Runtime Specification](https://github.com/opencontainers/runtime-spec).
- [OCI Distribution Specification](https://github.com/opencontainers/distribution-spec).
- [namespaces(7)](https://man7.org/linux/man-pages/man7/namespaces.7.html) — strona podręcznika Linuksa.
- [cgroups(7)](https://man7.org/linux/man-pages/man7/cgroups.7.html) — strona podręcznika Linuksa.
- [Control Group v2](https://docs.kernel.org/admin-guide/cgroup-v2.html) — dokumentacja jądra Linuksa.
- [Podman documentation](https://docs.podman.io/).
- [CVE-2019-5736](https://nvd.nist.gov/vuln/detail/CVE-2019-5736) — luka umożliwiająca ucieczkę z kontenera w runc.
