Контейнеризация в Linux: от chroot до Docker, как механизмы ядра формировали изоляцию | AdminWiki

Контейнеризация в Linux: от chroot до Docker, как механизмы ядра формировали изоляцию

18 ноября 2026 15 мин. чтения

Контейнер — комбинация механизмов ядра, а не отдельная технология

Контейнер в Linux собирается из четырёх групп механизмов. chroot ограничивает видимое дерево файловой системы. Namespaces изолируют представление системных ресурсов: PID, mount, network, IPC, UTS, user, cgroup, time. cgroups учитывают и ограничивают потребление CPU, памяти, дискового ввода-вывода и число процессов. Capabilities дробят привилегии root на отдельные права, а seccomp и LSM сужают набор доступных действий.

Все контейнеры на хосте работают на общем ядре. Граница контейнера совпадает с границей доверия к ядру: ошибка в ядре или в подсистеме, которую видно из контейнера, способна сломать изоляцию сразу для всех контейнеров на машине. Это ключевая причина, по которой обновление ядра входит в стратегию безопасности контейнерной платформы.

Отсюда практический вывод для диагностики. Если контейнер ведёт себя странно, не видит процесс, падает по памяти или не может занять порт, смотреть надо на ядро и настройки runtime, а Dockerfile остаётся только частью картины. Дальше разбираем каждую ступень по порядку и показываем команды проверки.

Почему контейнер — не «лёгкая виртуалка»

Виртуальная машина запускает гипервизор и собственное гостевое ядро: внутри гостя другой дистрибутив, другая версия ядра, другой набор модулей. Контейнер своего ядра не имеет. Он вызывает те же системные вызовы, что и обычный процесс на хосте, а изоляция строится на том, что ядро показывает процессу урезанную картину мира.

Первый эффект: плотность и скорость запуска. Контейнер не тратит ресурсы на второе ядро и не проходит этап загрузки гостевой ОС. Конкретные цифры накладных расходов зависят от нагрузки, файловой системы и профиля ввода-вывода, поэтому измеряйте их на своём стенде, а не ориентируйтесь на чужие графики.

Второй эффект: общее ядро становится общим риском. Разграничение между контейнерами держится на корректности ядра, и любой процесс с доступом к чувствительным системным вызовам расширяет поверхность атаки для всей машины. Отсюда два обязательных правила: минимизируйте привилегии контейнера и держите ядро в актуальном состоянии.

Таблица соответствия: механизм ядра, задача, ограничение

Таблица ниже пригодится при настройке и аудите: по ней видно, какой примитив за что отвечает и что он не закрывает.

Механизм Что делает Какую задачу решает Чего не решает Где смотреть состояние
chroot Меняет корень файловой системы для процесса Прячет остальное дерево ФС от сервиса Не изолирует PID, сеть и IPC, не ограничивает ресурсы; процесс с CAP_SYS_CHROOT может выйти readlink /proc/PID/root
mount namespace Даёт своё дерево монтирования Разные точки монтирования у процессов, скрытие каталогов хоста Не мешает достучаться до устройства, если оно смонтировано внутрь readlink /proc/PID/ns/mnt
PID namespace Своя нумерация процессов, PID 1 внутри Сервис не видит и не может сигналить процессы хоста Не ограничивает число процессов и не скрывает нагрузку readlink /proc/PID/ns/pid
network namespace Свои интерфейсы, маршруты, порты, правила Изоляция сети и повторное использование одинаковых портов Не фильтрует трафик, пока не заданы правила ip netns list, docker network inspect
IPC namespace Свои очереди, семафоры, разделяемая память Сервисы не мешают друг другу через SysV IPC Ничего не говорит о правах доступа к файлам readlink /proc/PID/ns/ipc
UTS namespace Свой hostname и домен NIS Уникальные имена хостов в логах и приложениях Не влияет на сетевую связность hostname
user namespace Маппинг UID/GID: root внутри не root снаружи Снижает ущерб при компрометации процесса Не защищает от ошибок ядра; поддержка и настройки зависят от дистрибутива /proc/PID/uid_map, docker info
cgroup namespace Своя видимая иерархия cgroups Процесс видит только свой участок дерева Не задаёт лимиты readlink /proc/PID/ns/cgroup
time namespace Смещения монотонных часов и boot time Предсказуемое время после checkpoint/restore и миграции Не меняет системное время хоста readlink /proc/PID/ns/time
cgroups v1 / v2 Учёт и лимиты CPU, памяти, I/O, числа PID Защита хоста от одного жадного процесса Не изолируют видимость процессов и сети stat -fc %T /sys/fs/cgroup
capabilities Дробление прав root на отдельные единицы Сервис получает только нужное право Не отменяют обычные права доступа к файлам capsh --print, /proc/PID/status
seccomp Фильтр системных вызовов Отсекает ненужные вызовы и сужает поверхность атаки Не изолирует ресурсы и не ограничивает потребление grep Seccomp /proc/PID/status
LSM: SELinux, AppArmor Обязательный контроль доступа по политике Ограничивает действия даже при правах root Требует корректной политики, иначе блокирует легитимные операции cat /sys/kernel/security/lsm

Набор доступных примитивов определяется ядром. Часть namespaces появилась позже остальных (например, time), поэтому на старом ядре соответствующие ссылки в /proc/PID/ns просто отсутствуют. Сверяйтесь с документацией ядра своей версии.

chroot: первая попытка изоляции файловой системы

Задача, которую решал chroot, звучит буднично: показать сервису только его каталог. Исторически так ограничивали FTP-демоны, окружения сборки пакетов и тестовые стенды, чтобы процесс не видел чужие файлы и домашние каталоги пользователей.

Механика простая: процесс получает новый корень файловой системы, и пути выше него становятся недоступны. Ничего больше не меняется. Процесс по-прежнему видит все процессы хоста, работает в сетевом пространстве хоста и не ограничен по CPU и памяти.

Ограничения chroot принципиальные. Процесс с правом CAP_SYS_CHROOT может выйти из запертого дерева, например повторным вызовом chroot с последующей сменой каталога. Открытый файловый дескриптор на каталог вне нового корня даёт обход. Общие библиотеки и устройства остаются доступны, если их положили внутрь дерева. Как средство безопасности в продакшене chroot не годится, его место — историческая ступень и строительный блок для более поздних механизмов.

Проверка на тестовой машине, где заранее подготовлен корневой каталог с рабочим /bin/sh и его библиотеками:

chroot /srv/jail /bin/sh
ls /
readlink /proc/self/root

Внутри дерева ls / показывает только содержимое /srv/jail. Проверить корень процесса надёжнее снаружи, из другого терминала:

sudo readlink /proc/$(pgrep -n -x sh)/root

Ожидаемый вывод: /srv/jail. Если команда chroot падает с сообщением о невозможности запустить оболочку, значит внутрь не скопированы библиотеки, и это не ошибка изоляции, а неполное дерево.

chroot требует прав root и меняет корень живого процесса. На рабочем хосте такие эксперименты проводите только в отдельной виртуалке или на тестовом стенде: неверный путь или смонтированный не туда каталог легко ломает окружение.

Namespaces: изоляция представления ресурсов

Namespaces решают главную слабость chroot: они изолируют не только файлы, но и само представление ресурсов. Процесс в своём PID namespace видит собственную нумерацию и считает себя PID 1. В своём network namespace он получает отдельные интерфейсы, таблицы маршрутизации и свой набор портов. В своём mount namespace у него отдельное дерево монтирования.

Список типов и их зон ответственности:

  • mount: точки монтирования и их видимость;
  • PID: нумерация процессов и сигналы;
  • network: интерфейсы, маршруты, порты, сетевые таблицы;
  • IPC: очереди сообщений, семафоры, разделяемая память;
  • UTS: hostname и домен NIS;
  • user: маппинг UID/GID между контейнером и хостом;
  • cgroup: видимая иерархия cgroups;
  • time: смещения монотонных часов и boot time.

Проверка текущего процесса и сравнение с процессом хоста:

ls -l /proc/self/ns
readlink /proc/1/ns/mnt
readlink /proc/$$/ns/mnt

Вывод ls -l /proc/self/ns содержит строки вида mnt, pid, net, ipc, uts, user, cgroup и time, каждая со своим номером в квадратных скобках. Совпадающие номера у двух процессов означают общее пространство имён, разные номера — изоляцию.

Запуск процесса в новых namespaces и вход в существующие:

unshare --fork --pid --mount-proc /bin/bash
echo $$
ps -ef

В новом PID namespace оболочка получает PID 1, а ps -ef показывает только процессы этого пространства. Без прав root используйте unshare -Ur, чтобы получить user namespace и права внутри него. Для входа в пространства имён работающего контейнера:

PID=$(docker inspect --format '{{.State.Pid}}' web)
nsenter -t "$PID" -n ip addr

Команда показывает сетевые интерфейсы контейнера. unshare и nsenter требуют повышенных прав, а nsenter в живой процесс может повлиять на его поведение. Выполняйте такие команды на тестовой среде и не трогайте продакшн-контейнеры без необходимости.

Отдельно про user namespace: он позволяет запустить процесс с root внутри контейнера, который снаружи отображается на непривилегированного пользователя. Это заметно снижает ущерб при компрометации, но поведение и доступность механизма зависят от дистрибутива и версии ядра. Практические схемы маппинга UID/GID и типичные ошибки Permission denied разобраны в материале про права доступа контейнеров к ресурсам хоста.

cgroups: ограничение и учёт ресурсов

Namespaces дают изоляцию, но не мешают одному контейнеру занять всю память и все ядра. Эту задачу закрывают cgroups: они учитывают потребление и позволяют выставить лимиты. Основные контроллеры: cpu, memory, pids, io, cpuset.

Разница между поколениями существенная. cgroups v1 допускали отдельные иерархии под каждый контроллер, из-за чего лимиты было трудно согласовывать. cgroups v2 используют единую иерархию: процесс живёт в одном узле дерева. По умолчанию в cgroup v2 контроллеры не включены: их включают и отключают записью в файл cgroup.subtree_control, например командой echo "+cpu +memory -io" > cgroup.subtree_control. Включать можно только контроллеры, перечисленные в cgroup.controllers, а при указании нескольких операций они либо все выполняются, либо все завершаются неудачей. Ресурсы распределяются сверху вниз: не-корневые файлы cgroup.subtree_control могут содержать только контроллеры, включённые в родительском cgroup.subtree_control. Механика подробно описана в документации Control Group v2.

stat -fc %T /sys/fs/cgroup

Ответ cgroup2fs означает единую иерархию v2, tmpfs указывает на v1 или гибридную схему. Дальше смотрим, какие лимиты заданы контейнеру:

docker inspect --format '{{.HostConfig.Memory}} {{.HostConfig.NanoCpus}} {{.HostConfig.PidsLimit}}' web

Memory выводится в байтах, NanoCpus в наноядрах (1,5 CPU соответствуют значению 1500000000), PidsLimit ограничивает число процессов. Значение 0 означает отсутствие лимита.

Внутри контейнера на cgroups v2 лимиты видны в файлах своего узла: memory.max, cpu.max, pids.max. Точный путь зависит от версии cgroups и от того, включён ли cgroup namespace, поэтому в v1 смотрите каталоги memory и cpu в /sys/fs/cgroup, а в v2 начинайте с /sys/fs/cgroup внутри контейнера.

Проверка последствий превышения лимита памяти:

docker inspect --format '{{.State.OOMKilled}} {{.State.ExitCode}}' web

Комбинация true и 137 означает, что процесс убил OOM-killer ядра. Причина обычно одна: лимит выставлен ниже реального пика потребления приложения. Меняйте лимиты на работающем хосте осторожно, сначала на тестовой среде: изменение лимита памяти у активного контейнера приводит к остановке процесса без предупреждения. Методика измерений и разбор throttling по CPU описаны в статье про накладные расходы и лимиты Docker.

Capabilities: дробление привилегий root

Классический root может всё, а сервису чаще нужно одно конкретное право: занять порт ниже 1024, сменить владельца файла, изменить системное время. Capabilities делят эти полномочия на отдельные единицы. CAP_NET_BIND_SERVICE открывает привилегированные порты, CAP_CHOWN разрешает менять владельца, CAP_SYS_ADMIN даёт широкий набор административных операций и потому считается самым опасным.

Docker по умолчанию выдаёт контейнеру ограниченный набор capabilities, в который входят CAP_CHOWN, CAP_DAC_OVERRIDE, CAP_FSETID, CAP_FOWNER, CAP_NET_RAW, CAP_SETGID и CAP_SETUID. CAP_SYS_ADMIN в этот набор не входит, и стандартный контейнер его отбрасывает: это же заставляет профиль seccomp отклонять mount, сохраняет профиль AppArmor docker-default, запрещающий mount, применяет строгий список разрешённых устройств и не предоставляет блочные устройства хоста в /dev. Флаг --privileged снимает почти все ограничения: контейнер получает полный набор прав и доступ к устройствам. Применяйте его только там, где без этого не обойтись, и обосновывайте каждое исключение.

docker inspect --format '{{.HostConfig.Privileged}} {{.HostConfig.CapAdd}} {{.HostConfig.CapDrop}}' web
grep -E 'Cap(Inh|Prm|Eff|Bnd)' /proc/self/status

Строка CapEff в /proc/self/status содержит шестнадцатеричную маску эффективных прав. Расшифровать её можно на хосте, где установлен libcap: capsh --decode=00000000a80425fb перечисляет capabilities по битам. Внутри самого контейнера capsh доступен не всегда, в минимальных образах его нет, поэтому читайте /proc/self/status и декодируйте маску снаружи. Пакет с capsh в Debian и Ubuntu называется libcap2-bin.

Флаг --cap-drop ALL с последующим --cap-add только нужного права даёт предсказуемый минимум. Добавление CAP_SYS_ADMIN существенно расширяет возможности контейнера и повышает риск выхода за его границу, поэтому такое право требует отдельного обоснования. Отключать SELinux или AppArmor ради того, чтобы приложение заработало, не стоит: настраивайте политику под сервис.

Проверить, что фильтр системных вызовов включён, можно так:

grep Seccomp /proc/self/status

Поле Seccomp в /proc/PID/status отражает режим seccomp процесса: значение 1 означает SECCOMP_MODE_STRICT, значение 2 — SECCOMP_MODE_FILTER, то есть активный фильтр. Поле предоставляется только если ядро собрано с поддержкой seccomp, что зафиксировано в описании proc_pid_status(5). Если строка отсутствует, ориентируйтесь на вывод docker info --format '{{.SecurityOptions}}' и документацию своей версии Docker.

LXC, Docker и OCI: как примитивы ядра стали продуктами

LXC собирает из перечисленных примитивов системные контейнеры. Это окружение, близкое к полноценной ОС: свой набор служб, свой init, шаблоны дистрибутивов и управление через lxc-* утилиты. Такой контейнер удобен, когда нужно поднять несколько изолированных окружений на одном ядре и администрировать их как лёгкие машины.

Docker делает ставку на прикладные контейнеры: образ, слои, реестр, декларативная сборка и предсказуемый запуск процесса. Внутри работают те же namespaces, cgroups и capabilities, поэтому «магия» Docker объясняется примитивами ядра и настройками по умолчанию, которые он применяет за вас.

OCI-стандарт закрепил совместимость. Спецификация образа описывает формат слоёв и манифеста, спецификация runtime описывает, как передать контейнер низкоуровневому исполнению. Между Docker CLI и ядром стоят containerd и runc: containerd управляет жизненным циклом контейнеров, runc создаёт пространства имён, выставляет лимиты cgroups и передаёт управление процессу. Образ, собранный одним инструментом, запускается другим именно благодаря спецификациям OCI.

Критерий Системный контейнер (LXC) Прикладной контейнер (Docker, OCI-runtime)
Что внутри Полное окружение дистрибутива, несколько служб Один процесс и его зависимости
Способ сборки Шаблон дистрибутива плюс донастройка Dockerfile и слои образа
Типичная задача Изолированные окружения, тестовые стенды, миграция legacy-сервисов Микросервисы, CI/CD, горизонтальное масштабирование
Обновление содержимого Как обычную ОС, пакетным менеджером Пересборка образа и новый запуск
Изоляция Те же примитивы ядра, профиль ближе к машине Те же примитивы ядра, набор прав по умолчанию уже

Набор доступных примитивов и поведение по умолчанию зависят от конкретного релиза ядра и runtime. Сверяйте флаги и значения по умолчанию с release notes и документацией установленной у вас версии, а не с общими обзорами. Развёрнутое сравнение инструментов с критериями выбора есть в материале про выбор между Docker, Podman и LXC.

Почему версия ядра влияет на поведение runtime

Версия Docker задаёт удобство работы, а набор возможностей задаёт ядро. Один и тот же образ на двух хостах может вести себя по-разному, если на одном ядре есть нужный namespace или контроллер cgroups, а на другом нет. Обновление ядра меняет доступный набор механизмов и приносит исправления, которые напрямую касаются изоляции.

Четыре команды, которые стоит выполнить на новом хосте перед запуском нагрузки:

uname -r
stat -fc %T /sys/fs/cgroup
ls /proc/self/ns
cat /sys/kernel/security/lsm

Первая показывает версию ядра, вторая тип cgroups, третья список доступных namespaces, четвёртая активные LSM. Чтение /sys/kernel/security/lsm требует root и смонтированного securityfs. Если securityfs не смонтирован, посмотрите docker info --format '{{.SecurityOptions}}': там перечислены активные механизмы защиты контейнера, включая seccomp и AppArmor.

Держите ядро в рамках поддерживаемой ветки дистрибутива и отслеживайте исправления безопасности. Политика обновлений ядра относится к контейнерной платформе целиком, а не только к гипервизору или базовым образам. Практические шаги по защите контейнерной среды собраны в гайде про безопасность и сети Docker в продакшене.

Границы изоляции: чему учит пример с ошибкой SCTP

Иллюстрация общего риска: исследовательская команда Xint обнаружила отдельную уязвимость в подсистеме SCTP ядра Linux, которая позволяет локальному пользователю получить привилегии root и обойти изоляцию контейнеров. В тестах Xint цепочка из уязвимости nginx CVE-2026-123007 и этой ошибки SCTP позволила выйти из Docker-контейнера с nginx и получить root на хосте (исследование Xint).

Сама ошибка возникает при передаче сетевого соединения между сокетами и может привести к повторному освобождению памяти либо обращению к уже удалённому объекту. Она была внесена в Linux v4.15 в 2018 году и оставалась в ядре более восьми лет. Успех такого сценария зависит от доступности SCTP, настроек контейнера и состояния ядра, поэтому универсальной угрозой его считать нельзя.

Две оговорки важны для трезвой оценки. На момент публикации исследования исправление ядра ещё не было доступно, и исследователи удерживали детали эксплуатации уязвимости SCTP. Вторая: компрометация рабочего процесса веб-сервера сама по себе не означает полный контроль над операционной системой, в типичных конфигурациях nginx работает с ограниченными привилегиями.

Читать этот кейс стоит как аргумент за дисциплину: обновляйте ядро, убирайте неиспользуемые сетевые подсистемы, если они не нужны, ограничивайте capabilities и не давайте контейнеру лишних прав. Номера исправлений и даты выхода патчей проверяйте по бюллетеням своего дистрибутива, а не по пересказам.

Практический чек-лист: как проверить изоляцию и лимиты контейнера

Шаги ниже выполняются на тестовой среде. Часть команд требует root, nsenter в работающий процесс может повлиять на него, поэтому продакшн-контейнеры трогайте только при плановом аудите.

  1. Версия ядра и тип cgroups на хосте: uname -r и stat -fc %T /sys/fs/cgroup. Норма — поддерживаемая ветка ядра и cgroup2fs. Красный флаг — ядро без обновлений безопасности.
  2. Пространства имён процесса контейнера: docker inspect --format '{{.State.Pid}}' web, затем readlink /proc/PID/ns/mnt и readlink /proc/1/ns/mnt. Разные номера в квадратных скобках означают отдельный mount namespace. Совпадение с хостом — повод разобраться, что именно смонтировано внутрь.
  3. Сетевые интерфейсы контейнера: nsenter -t PID -n ip addr. Норма — только ожидаемые интерфейсы. Лишний интерфейс в режиме хоста объясняет, почему контейнер видит чужие порты.
  4. Capabilities процесса: grep Cap /proc/1/status внутри контейнера, расшифровка маски через capsh --decode. Проверьте docker inspect по полям Privileged, CapAdd, CapDrop. Красный флаг — Privileged=true и CAP_SYS_ADMIN без обоснования.
  5. Фильтр системных вызовов: grep Seccomp /proc/1/status. Значение 2 — активный фильтр SECCOMP_MODE_FILTER. Если строки нет, ядро собрано без поддержки seccomp либо поле недоступно; тогда проверьте docker info --format '{{.SecurityOptions}}'.
  6. Лимиты ресурсов: docker inspect --format '{{.HostConfig.Memory}} {{.HostConfig.NanoCpus}} {{.HostConfig.PidsLimit}}' web. Ноль в любом поле означает отсутствие ограничения. Для сервиса без лимита памяти один скачок потребления забирает хост.
  7. Пользователь внутри контейнера: docker inspect --format '{{.Config.User}}' web. Пустая строка значит root. Проверьте маппинг: cat /proc/PID/uid_map и вывод docker info --format '{{.SecurityOptions}}' на наличие userns.
  8. Активные LSM на хосте: cat /sys/kernel/security/lsm или docker info --format '{{.SecurityOptions}}'. Норма — AppArmor или SELinux в списке. Отсутствие обоих означает, что последний слой защиты не работает.

Если аудит касается критичной инфраструктуры, разумно привлечь специалиста по безопасности ядра: проверка выходит за пределы конфигурации Docker и требует разбора политик LSM, модулей ядра и сетевых подсистем. План такого аудита с измеримыми целями описан в материале про цели аудита безопасности контейнерных сред.

Контейнер даёт изоляцию, но не абсолютную. Глубина защиты складывается из актуального ядра, минимального набора capabilities, работающих лимитов cgroups, включённого seccomp и активного LSM. Проверьте эти четыре слоя на своём хосте в следующем же окне обслуживания: команды из чек-листа занимают несколько минут, а найденный Privileged=true или Memory=0 объясняет и будущий инцидент, и его цену.

Поделиться: