Контейнеры окружают почти каждую современную инфраструктуру, но немногие инженеры заглядывают под капот: для большинства это команда run и готовый образ из registry. Между тем за одной короткой командой стоит несколько слоев механизмов ядра Linux, открытых стандартов и вспомогательных процессов. Docker и Podman решают одну задачу упаковки и изоляции приложений, однако архитектуры у них принципиально разные, и это напрямую влияет на безопасность, отладку и поведение при сбоях. Разбор внутреннего устройства обеих платформ помогает осознанно выбирать инструмент и перестать воспринимать контейнеры как черный ящик.
Из чего состоит контейнер на уровне ядра Linux
Контейнер не является виртуальной машиной. У него нет собственного ядра и эмулированного железа: это обычный процесс в Linux, у которого ядро ограничило видимость окружения и доступ к ресурсам. Два механизма делают такую изоляцию возможной: namespaces отвечают за то, что процесс видит, а cgroups за то, сколько он может потреблять.
Ядро поддерживает несколько типов пространств имен, и каждое скрывает отдельную часть системы: pid изолирует дерево процессов, net выдает собственные сетевые интерфейсы и таблицу маршрутизации, mnt дает независимую таблицу монтирования, uts отдельное имя хоста, ipc изолирует разделяемую память и очереди сообщений, а user отображает идентификаторы пользователей внутри контейнера на внешние значения. При создании процесса системным вызовом clone с флагами вида CLONE_NEWPID и CLONE_NEWNET ядро помещает его в новые пространства, и с этого момента ps внутри контейнера видит только собственные процессы.
Проверить это можно вручную, без инструментов упаковки:
unshare --pid --fork --mount-proc /bin/bash
ps aux
exit
lsns
Оболочка внутри нового пространства начинает нумерацию процессов с единицы, а снаружи ps по-прежнему видит обе стороны. Ровно те же вызовы, обернутые в удобный интерфейс, выполняет любой рантайм контейнеров.
Отдельного разговора заслуживает сеть. Внутри net namespace контейнер получает собственный стек, а связь с внешним миром обеспечивает veth-пара: один ее конец сидит в пространстве имен контейнера, второй подключен к хостовому мосту. Благодаря этому контейнеры на одном хосте изолированы по адресам и маршрутам, но ходят наружу через общий шлюз.
Вторая половина механизма - контрольные группы. Унифицированная иерархия cgroup v2 собирает все контроллеры вместе: cpu.max ограничивает процессорное время, memory.max ставит потолок памяти, при превышении которого ядро завершает процессы группы, pids.max защищает от исчерпания таблицы процессов, io управляет дисковыми операциями. Историческая cgroup v1 держала каждый контроллер в отдельной иерархии, что порождало путаницу, поэтому дистрибутивы давно перешли на единое дерево v2. Лимиты контейнера ложатся в такие файлы:
cd /sys/fs/cgroup
echo "+cpu +memory" > cgroup.subtree_control
mkdir demo
echo "100000 100000" > demo/cpu.max
echo "512M" > demo/memory.max
Менеджер вроде systemd или сам рантайм раскладывает параметры запуска контейнера по нужным файлам группы, и ядро начинает считать и ограничивать.
Слои образа OCI и файловая система overlayfs
Образ по стандарту OCI - не монолитный файл, а набор слоев: JSON-манифест, конфигурация со сведениями о сборке и последовательность tar-архивов. Каждый слой содержит только изменения относительно предыдущего, поэтому образы экономят место и быстро распространяются: если несколько образов построены на одном базовом слое, этот слой хранится на диске в единственном экземпляре. Сами слои неизменяемы, потому один образ можно раздать десяткам работающих контейнеров, каждый получит собственный верхний слой для записи.
Инструкции Dockerfile распределяются по слоям неравномерно. COPY и RUN добавляют содержимое, остальные инструкции вроде WORKDIR, ENV и EXPOSE меняют лишь свойства образа. Отсюда правило кэширования: редко меняющиеся шаги ставят выше, часто меняющиеся - в конец файла.
FROM alpine:3.20
RUN apk add --no-cache python3 py3-pip
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python3", "app.py"]
Если requirements.txt не изменился, пересборка пропускает установку зависимостей и обновляет только последний слой с исходниками приложения.
Манифест может описывать не один образ, а список вариантов под разные архитектуры: клиент запрашивает образ, registry отдает подходящий вариант по платформе машины. Идентификатором служит хеш содержимого, поэтому одинаковый дайджест гарантирует побайтово одинаковые слои на любом хосте.
На диске слои собирает файловая система overlayfs. Она складывает несколько каталогов lowerdir в один объединенный вид поверх каталога upperdir, а результат виден в merged. Чтение идет снизу вверх, запись копирует файл из нижнего слоя в верхний, а удаление оставляет в верхнем слое служебную заглушку. Реальную картину показывает работающий контейнер:
grep overlay /proc/mounts
docker history myapp:latest
Строка монтирования перечисляет каталоги всех слоев и рабочие каталоги upperdir и workdir. Понимание механизма объясняет типичные сюрпризы: файл, удаленный в контейнере, продолжает занимать место в нижнем слое, а интенсивная запись в верхний слой медленнее записи в отдельный том, поэтому большие каталоги выносят в volumes.
Архитектура Docker с фоновой службой и Podman без неё
Классическая архитектура Docker построена вокруг фоновой службы dockerd, работающего с правами root. Клиент docker общается с ним по REST API через unix-сокет /var/run/docker.sock, служба делегирует управление контейнерами containerd, а тот запускает на каждый контейнер собственный shim, который держит потоки ввода-вывода. Благодаря shim контейнер переживает перезапуск службы, если включен режим live-restore.
Увидеть цепочку можно самому: dockerd порождает containerd, containerd - процесс shim, а shim запускает низкоуровневый исполняемый файл, который и создает контейнер.
Централизованная служба удобна: одна точка для API, плагинов, логов и сетей. У этой же точки есть обратная сторона: любой, кто получил доступ к docker.sock, фактически получает root на хосте, а падение службы останавливает само управление, хотя работающие контейнеры продолжают жить.
Права на сокет в мире Docker раздают через группу docker, и вступление в нее равносильно выдаче root, о чем полезно помнить при создании пользователей на сервере сборки. Podman в rootless сценарии вообще не требует общесистемного сокета: каждый пользователь обслуживает свои контейнеры в собственной сессии.
Podman пошел другим путем: фоновой службы нет вообще. Команда podman сама создает контейнер через форк и exec, а рядом стартует небольшой процесс conmon, который наблюдает за контейнером и держит его консоль. Родительское приложение завершилось, сессия пользователя закрылась - контейнер продолжает работать под присмотром conmon.
Такая модель естественно ложится на systemd: контейнеры описываются как обычные юниты с зависимостями, лимитами и автозапуском. Для совместимости Podman умеет поднимать тот же REST API, что и Docker, поэтому привычные клиенты и CI-скрипты работают без переделки:
podman system service --time=0 unix:///run/user/1000/podman.sock &
export DOCKER_HOST=unix:///run/user/1000/podman.sock
docker ps
Rootless режим и работа без прав суперпользователя
Rootless запуск означает, что контейнеры работают от имени обычного пользователя, а не root. В основе лежат user namespaces: корень внутри контейнера отображается на непривилегированный идентификатор хоста, например на номер 100000. Диапазоны таких отображений описываются в файлах /etc/subuid и /etc/subgid, а утилиты newuidmap и newgidmap применяют их при создании пространства имен.
Выигрыш заметен сразу: побег из контейнера приводит нарушителя не к root, а к обычному пользователю с ограниченными правами. Исчезает привилегированная служба, атака на сокет теряет смысл, а хранилище образов оказывается в домашнем каталоге: у Podman это ~/.local/share/containers, у rootless Docker это ~/.local/share/docker, а обычный режим живёт в /var/lib/docker. Docker тоже поддерживает rootless режим, однако у Podman он был центральной особенностью с самого начала и работает без дополнительных ухищрений.
У подхода есть нюансы. Порты ниже 1024 по умолчанию недоступны, что лечится параметром ядра:
echo "alice:100000:65536" >> /etc/subuid
echo "alice:100000:65536" >> /etc/subgid
sysctl net.ipv4.ip_unprivileged_port_start=80
podman run --rm alpine id
Свежие ядра поддерживают overlayfs внутри user namespaces, на старых включается fuse-overlayfs. Для лимитов ресурсов systemd должен делегировать контрольные группы пользователю, в современных дистрибутивах это включено из коробки. Команда podman unshare запускает произвольную программу внутри пользовательского пространства имен и позволяет заглянуть в хранилище глазами контейнерной среды.
Помимо изоляции идентификаторов, обе платформы умеют запускать контейнер с файловой системой только для чтения, усекать список возможностей ядра, применять профили seccomp и метки SELinux. Эти механизмы не зависят от выбора Docker или Podman и работают одинаково в обеих средах, а rootless режим добавляет к ним еще один барьер.
runc и crun исполняемые модули под стандартом OCI
Стандарт OCI описывает не только формат образов, но и низкоуровневый рантайм: каталог-бандл с файлом config.json и корневой файловой системой плюс набор операций create, start, kill и delete над ним. Именно такой бандл собирает Docker или Podman из скачанного образа, после чего вызывает внешний исполняемый файл. Каждая операция жизненного цикла превращается в отдельный вызов, поэтому рантайм прост и предсказуем. Заглянуть внутрь нетрудно: config.json в читаемом JSON перечисляет аргументы запуска, переменные окружения, точки монтирования и наборы пространств имен.
runc, написанный на Go, долго оставался стандартом де-факто и до сих пор стоит по умолчанию в Docker. crun на C выполняет ту же работу с меньшим потреблением памяти и заметно более быстрым стартом, поэтому Podman выбирает его по умолчанию. Взаимозаменяемость прямая: один и тот же бандл открывается любым совместимым рантаймом.
runc --version
crun --version
podman run --runtime /usr/bin/crun --rm alpine echo ok
Инфраструктура позволяет подменить рантайм на другие реализации: gVisor перехватывает системные вызовы в собственном ядре пользовательского режима, Kata Containers уводит нагрузку в облегченную виртуальную машину. Граница проходит на одном интерфейсе OCI, поэтому выбор рантайма не требует менять привычки или сборочные пайплайны.
Podman compose и мост в экосистему Docker
Многосоставные приложения описывают в compose-файлах, и здесь экосистемы срослись почти полностью. Docker Compose остается эталоном, Podman предлагает собственную реализацию podman-compose, а свежие версии умеют исполнять обычный docker compose, подняв совместимый API-сокет. Достаточно передать клиенту адрес сокета, как в примере выше:
docker compose up -d
podman-compose -f compose.yaml up -d
Образы тоже общие: любой registry с OCI-образами подходит обеим платформам, менять хранилище или пересобирать image не нужно. Podman добавляет собственные возможности: команда pod create объединяет контейнеры в группу с общими пространствами имен по образцу подов, генератор podman kube generate выдает манифесты, а механизм quadlet описывает контейнер как обычный юнит systemd с автозапуском и зависимостями.
podman pod create --name web
podman run -d --pod web nginx
podman kube generate web
Такой мост снимает главный страх миграции: сценарии сборки, реестры образов и декларации сервисов остаются прежними, меняется только нижний слой исполнения. В обратную сторону переход тоже безболезненный: сценарии, написанные под Podman, работают с Docker, поскольку различия в основном сводятся к отсутствию фоновой службы и к драйверам хранения по умолчанию.
Критерии выбора между Docker и Podman на практике
Обе платформы опираются на одни и те же механизмы ядра, поэтому переучивание при смене инструмента почти не требуется: команды, образы и compose-файлы совместимы. Выбор чаще определяется окружением и требованиями безопасности, а не технической несовместимостью.
Готовность сервера к rootless запуску проверяется по короткому списку:
1. user namespaces включены в ядре, утилиты newuidmap и newgidmap установлены;
2. в файлах /etc/subuid и /etc/subgid задан диапазон подчиненных идентификаторов;
3. systemd делегирует контрольные группы v2 обычным пользователям;
4. адрес сокета передан клиенту через переменную DOCKER_HOST.
Docker оправдан там, где решает знакомый инструментарий: обширная экосистема, Desktop для macOS и Windows, готовые интеграции с панелями и CI. Podman выигрывает на Linux-серверах, где ценятся отсутствие фоновой службы, rootless безопасность и органичная работа со systemd. Разумная стратегия выглядит так: выбрать один инструмент для локальной разработки и CI, а переносимость доверить стандартам OCI. Навыки полностью переносимы: понимание namespaces, cgroups и overlayfs одинаково полезно в обеих средах и за их пределами, например при отладке кластеров Kubernetes, потому что под капотом у обеих платформ один и тот же Linux с его namespaces, cgroups и overlayfs.