Kontenery Linux: Docker, Podman, proot-distro, distrobox
TL;DR — decyzja w 30 sekund
| Narzędzie | Dla kogo | Dlaczego nie |
|---|---|---|
| Docker 29 | CI/CD, Kubernetes, zespoły z istniejącym ekosystemem. Najwięcej testowanych konfiguracji. | Dwie demony (dockerd + containerd) na spoczynku ~206 MB RAM. Rootful po domyśle. |
| Podman 6 | Serwery Linux, rootless containers, systemd (quadlet). Bez demona, 15% mniej RAM niż Docker. | CLI nieco wolniejsze przy operacjach na wielu kontenerach. Mniejszy ekosystem niż Docker. |
| proot-distro | Android (Termux), stare laptopy, środowiska bez user namespace. Zero zależności od kernela. | ptrace() — każde wywołanie systemowe przechodzi przez dwie zmiany kontekstu. 7–10% wolniejsze CPU. |
| distrobox | Developerzy: druga dystrybucja w terminalu, współdzielony HOME, aplikacje GUI z gościa. | Wrapper — wymaga pod spodem podman lub docker. Nie jest samodzielnym runtime. |
Dla 80% wdrożeń: Docker, jeśli CI i Kubernetes. Podman, jeśli serwer Linux i rootless. proot-distro, jeśli kernel jest cudzy (Android, WSL bez roota). distrobox, jeśli potrzebujesz innej dystrybucji obok hosta.
Architektura — kto jest demonem, a kto nie
Różnica między tymi czterema narzędziami to nie liczba komend, tylko to, kto siedzi w tle. Docker i Podman operują na obrazach OCI, ale Docker przez całe życie był modelem demonowym: CLI → dockerd → containerd → runc. Podman wyrzucił demony — CLI forkuje conmon-rs, ten wzywa crun, i kontener istnieje. proot-distro nie ma żadnego demonu i żadnego modułu kernela — działa przez ptrace, przechwytywanie wywołań systemowych. distrobox to warstwa na podman/docker, która dodaje integrację z hostem: wspólny HOME, sokety Wayland/X11, udev, D-Bus.
| Właściwość | Docker 29 | Podman 6 | proot-distro | distrobox |
|---|---|---|---|---|
| Język | Go | Go + crun (C) | Go + proot (C) | POSIX sh + podman/docker |
| Demony | dockerd + containerd | brak | brak | zależy (podman = brak) |
| RAM spoczynek (MB) | ~206 (dockerd 122 + containerd 84) | 0 (bez demona) | ~5 (sam proot) | ~5 (wrapper, brak własnego RAM) |
| Rootless | opt-in (rootless mode) | domyślnie | jedyne tryby | zależy od backendu |
| Wymagania kernela | cgroups v2, overlayfs | cgroups v2, overlayfs | żadnych — ptrace | cgroups v2, overlayfs |
| Wspólne HOME z hostem | bind mount | bind mount | symlinki | automatycznie |
| Aplikacje GUI (Wayland/X11) | ręczne mapowanie soketów | ręczne mapowanie | przez VNC/X | automatycznie (distrobox export) |
| Pod (wiele kontenerów, wspólny netns) | brak | brak | brak | brak (per backend) |
| Kubernetes (CRI) | CRI-O / containerd | CRI-O (natywnie) | brak | brak |
Dwa demony Dockera to ~206 MB stałego obciążenia, niezależnie od tego, ile kontenerów uruchomisz. Podman nie ma tego kosztu — ale przy 100 równoległych kontenerach pod obciążeniem podnosi RSS o 15% więcej niż Docker. To paradoks: mniej na spoczynku, więcej pod obciążeniem, bo brakuje centralnego bufora w daemonie.
Benchmarki — startup, RAM, przepustowość I/O
Liczby z trzech benchmarków opublikowanych w 2026: johal.in (Docker 26 vs Podman 5.0, 1000 iteracji, kwiecień 2026), johal.in (Podman 6 vs Docker 29, 100 kontenerów równolegle, AWS c6i.xlarge, czerwiec 2026), oraz sumguy.com (runc vs crun vs youki, kernel 6.8, 1000 pomiarów). Wszystkie na kernelu z cgroups v2, overlayfs, x86_64.
| Metryka | Docker 29 | Podman 6 | proot-distro | distrobox (podman) |
|---|---|---|---|---|
| Startup bezstanowy (p50, ms) | 482 | 271 | ~1200 (Android SD675) | ~300 (podman + wrapper) |
| Startup 100 kontenerów (średnia, ms) | 110 | 120 | n/d | n/d |
| RAM spoczynek (MB) | 206 | 0 | 5 | 5 |
| RAM 100 kontenerów (GB) | 1.42 | 1.21 (−14.8%) | n/d | n/d |
| Przepustowość CPU (UNIXbench, % natywnego) | ~100 (runc) | ~98 (crun) | ~90–93 (ptrace) | ~98 (crun) |
| Przepustowość GPU (vkmark, % natywnego) | ~100 | ~100 | ~13 (7.45× wolniejsze) | ~100 |
| Wymagania roota | root (domyślnie) | brak (domyślnie) | brak | zależy |
Podman 6 jest 43.8% szybszy w starcie bezstanowy kontenerów niż Docker 26 (271 ms vs 482 ms). Pod obciążeniem 100 równoległych kontenerów Podman zużywa 15% mniej RAM. proot-distro traci 7–10% CPU na ptrace — akceptowalne na starym laptopie, bolesne na GPU.
Konfiguracja — od instalacji po pierwszy kontener
| Zadanie | Docker | Podman | proot-distro | distrobox |
|---|---|---|---|---|
| Instalacja | sudo apt install docker.io | sudo apt install podman | termux pkg install proot-distro | git clone + ./distrobox.sh install |
| Pierwszy kontener | docker run -it alpine sh | podman run -it alpine sh | proot-distro install ubuntu && proot-distro login ubuntu | distrobox create --name arch --image archlinux && distrobox enter arch |
| Kontener z HOME hosta | docker run -v $HOME:/home/user | podman run -v $HOME:/home/user | automatycznie (symlink) | automatycznie |
| Aplikacja GUI w kontenerze | ręczne: -v /tmp/.X11-unix:/tmp/.X11-unix + DISPLAY | ręczne (jak Docker) | przez VNC / przekazanie X | distrobox export --app firefox |
| Kontener jako systemd unit | docker.service + restart: always | quadlet: /etc/containers/systemd/moj-kontener.container | ręczny start / stop | przez podman (quadlet) |
| Zarządzanie 50 kontenerami | docker compose / k8s | podman pod / k8s | brak (per kontener) | brak (per kontener) |
Docker i Podman są CLI-kompatybilne — alias docker=podman działa w 90% przypadków. distrobox jest wrapperem, więc komendy to distrobox create, distrobox enter, distrobox export. proot-distro ma najprostszy model: install, login, remove. Nie ma komend typu build, pull, push — ściąga gotowe obrazki z Docker Hub lub lokalnego tarballa.
Funkcje — co potrafi każdy
| Funkcja | Docker | Podman | proot-distro | distrobox |
|---|---|---|---|---|
| Budowanie obrazów (Dockerfile) | docker build | podman build (Buildah) | proot-distro build-image | przez backend |
| Pull z registry | docker pull | podman pull | proot-distro pull | przez backend |
| Rootless | opt-in | domyślnie | jedyne tryby | zależy |
| Pod (wspólny netns) | brak | natywnie (podman pod) | brak | brak |
| Health checks | HEALTHCHECK w Dockerfile | HEALTHCHECK + quadlet | brak | przez backend |
| Networks (bridge, host, none) | docker network | podman network (netavark/slirp4netns) | brak (host network) | przez backend |
| Volume (nominowane, bind, tmpfs) | docker volume | podman volume (storage.conf) | symlinki + bind | przez backend |
| Kubernetes CRI | CRI-O / containerd | CRI-O (natywnie) | brak | brak |
| WASM (WebAssembly) | brak | crun + WasmEdge | brak | przez backend |
| Współdzielone HOME / GUI | ręczne | ręczne | symlinki | automatyczne |
Docker i Podman to te same formaty obrazów (OCI) i niemal te same komendy. Różnica to architektura: Docker ma demony, Podman nie. proot-distro i distrobox rozwiązują inne problemy — proot-distro nie wymaga niczego od kernela, distrobox łączy dwie dystrybucje.
Który wybrać — scenariusze
- CI/CD, Kubernetes, duże zespoły: Docker. Najwięcej testowanych konfiguracji, największy ekosystem. Koszt: 206 MB RAM na demony.
- Serwer Linux, rootless containers, systemd: Podman. Quadlet daje .container files w /etc/containers/systemd — bez dockerd, bez containerd, bez roota.
- Android (Termux), WSL bez roota, stare laptopy bez user namespace: proot-distro. ptrace zamiast cgroups — działa na niemal każdym Linuxie i Androidzie.
- Developer, który chce innej dystrybucji obok hosta: distrobox. Arch na Ubuntu, Debian na Fedora — z automatycznym HOME, Wayland, X11, D-Bus.
- Mały VPS z ograniczonym RAM (512 MB): Podman lub proot-distro. Docker zje 206 MB zanim cokolwiek uruchomisz.
- Edge / serverless (sub-500 ms zimny start): Podman z crun. 271 ms vs 482 ms Dockera — różnica 211 ms na kontener.
Docker to standard branżowy — jeśli nie wiesz co wybrać, wybierz Docker. Podman to standard dla tych, którzy wolą rootless i brak demona. proot-distro to standard dla tych, którzy nie mają roota ani modułów kernela. distrobox to standard dla developerów, którzy chcą drugą dystrybucję w terminalu.
Instalacja i pierwsze uruchomienie
| Narzędzie | Instalacja (Debian/Ubuntu) | Plik konfiguracyjny | Walidacja |
|---|---|---|---|
| Docker | sudo apt install docker.io | /etc/docker/daemon.json | sudo docker info |
| Podman | sudo apt install podman | /etc/containers/containers.conf | podman info |
| proot-distro | termux pkg install proot-distro | ~/.local/share/proot-distro/ | proot-distro list |
| distrobox | git clone https://github.com/8z1sa/distrobox && cd distrobox && ./distrobox.sh install | ~/.config/distrobox/distrobox.conf | distrobox list |
Docker i Podman mają systemd unit i działają po instalacji. Proot-distro nie ma daemonu — każdy kontener startuje na żądanie. Distrobox instaluje się przez skrypt, który ściąga podman (jeśli brak) i ustawia completions.
Podsumowanie
Docker wygrywa ekosystemem i CI. Podman wygrywa startupem bezstanowy (−43.8%) i RAM-em pod obciążeniem (−15%). proot-distro wygrywa uniwersalnością — działa wszędzie, gdzie działa ptrace. distrobox wygrywa ergonomią dla developerów. Żaden nie jest uniwersalny — każdy rozwiązuje inny problem.