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