Запуская контейнер, администратор видит отдельную машину со своими процессами, сетью и файловой системой, хотя физически всё крутится на одном ядре. Секрета здесь никакого нет: иллюзию изоляции собирает механизм пространств имён, namespaces, который живёт в ядре Linux уже много лет и постепенно обрастал новыми видами. Разобраться в нём полезно вдвойне: во-первых, становится ясно, что именно отделяет один контейнер от другого, а во-вторых, появляется трезвый взгляд на границы этой изоляции, о которых забывают чаще всего.
Восемь видов изоляции, которые ядро выдаёт каждому процессу
Пространство имён это обёртка над глобальным ресурсом ядра. Внутри обёртки процессы видят собственную копию ресурса, а снаружи остаётся общая для всей машины действительность. У одного и того же процесса может быть несколько пространств одновременно, по одному на каждый вид ресурса, и всё это работает независимо друг от друга.
Механизм собирался по частям почти два десятилетия. Сначала в ядре появилось отдельное дерево монтирования, затем собственные имена хостов и объекты межпроцессного взаимодействия, позже нумерация процессов и сеть. Пользовательские пространства, снявшие барьер для непривилегированной работы с контейнерами, доехали до стабильных ядер в версии 3.8, а самые молодые, отвечающие за часы, только в 5.6. Каждый вид включается своим флагом при создании нового процесса:
- mount с флагом CLONE_NEWNS отделяет дерево смонтированных файловых систем;
- pid с флагом CLONE_NEWPID даёт собственную нумерацию процессов;
- net с флагом CLONE_NEWNET выделяет отдельные интерфейсы и сетевой стек;
- ipc с флагом CLONE_NEWIPC изолирует очереди сообщений и разделяемую память;
- uts с флагом CLONE_NEWUTS позволяет иметь собственное имя хоста;
- user с флагом CLONE_NEWUSER отображает идентификаторы и границы прав;
- cgroup с флагом CLONE_NEWCGROUP меняет вид групп управления ресурсами;
- time с флагом CLONE_NEWTIME смещает монотонные часы для гостевых сред.
Полный набор включают контейнерные движки, но никто не мешает взять из него только нужное. Процессу можно дать отдельную сеть, оставив общие процессы, или наоборот, и именно такая гибкость отличает namespaces от жёсткой виртуализации целой машины.
Системные вызовы clone, unshare и setns управляют пространствами имён
С пространствами имён работают три системных вызова, и каждый отвечает за свой сценарий. Clone создаёт новый процесс и заодно помещает его в свежие пространства по переданным флагам. Unshare отрывает текущий процесс от части общих ресурсов и выдаёт ему новые, отдельные. Setns делает обратное перемещение: забирает дескриптор существующего пространства и пересаживает процесс в него.
Увидеть, к каким пространствам принадлежит процесс, можно в файловой системе /proc:
readlink /proc/$$/ns/net
readlink /proc/1/ns/net
Каждая строка выдаёт идентификатор экземпляра, и совпадение строк означает общую сеть у двух процессов. Пока идентификаторы разные, процессы живут в разных сетевых мирах, даже не подозревая друг о друге. Этот простой способ сверять принадлежность выручает при разборе запутанных контейнерных схем, когда непонятно, кто с кем делит сеть и почему соединение не устанавливается.
Пространство имён PID и особая роль первого процесса
Изоляция нумерации процессов выглядит проще прочих, но хранит пару сюрпризов. Процесс, первым созданный в новом пространстве, получает номер один и сразу примеряет на себя обязанности инициализатора: подбирать осиротевшие процессы и корректно завершать их. Выйдя раньше времени, он уносит с собой всё пространство, потому что ядро расправляется с остальными его жителями сигналом, который нельзя перехватить.
Вторая особенность двойная нумерация. Снаружи, из родительского пространства, тот же процесс носит свой обычный общесистемный номер, а внутри виден как единица. Обе записи честны и обе верны, просто смотрят с разных сторон границы. Инструменты вроде ps, запущенные внутри, читают файловую систему /proc и потому видят только местных жителей. Опытные администраторы всегда держат в голове обе нумерации, когда сопоставляют журнал внутри контейнера с данными на хосте, иначе легко перепутать, о каком именно процессе говорит запись.
Пощупать изоляцию можно одной командой без всяких контейнеров:
unshare --pid --fork --mount-proc /bin/bash
echo $$
ps aux | head -3
Внутри запустится оболочка, которая уверенно считает себя первым и единственным процессом, хотя снаружи это заурядный потомок с большим номером. Снаружи же оболочку видно в обычном списке процессов хоста, и её можно трассировать, убить и проследить за открытыми файлами штатными средствами, что сильно упрощает диагностику по сравнению с полноценной виртуальной машиной.
Отдельного упоминания заслуживают осиротевшие процессы. Когда родитель внутри пространства завершается раньше потомков, сироты усыновляет местный номер один, и если тот не занимается их подбором, таблица процессов внутри постепенно забивается зомби. Снаружи такая утечка выглядит как рост числа процессов у контейнерного движка, и без понимания двойной нумерации причина долго остаётся загадкой. Отсюда правило для тех, кто собирает образы: точка входа обязана уметь подбирать умерших потомков, а служебная инициализация в одном процессе с приложением считается дурным тоном.
Сетевая изоляция от отдельных интерфейсов до полноценного стека
Пространство сети выдаёт процессу собственный набор интерфейсов, таблиц маршрутизации и правил фильтрации. Свежесозданное пространство почти пусто: в нём живёт один отключённый петлевой интерфейс, и на этом всё. Чтобы дать жителю связь с внешним миром, создают пары виртуальных патчей, veth, где один конец вставляют в пространство процесса, а второй кладут в мост на хосте.
Утилиты ip позволяют собрать такую схему руками за минуту:
ip netns add demo
ip link add veth0 type veth peer name veth1
ip link set veth1 netns demo
ip netns exec demo ip link set lo up
ip netns exec demo ip addr add 10.200.0.2/24 dev veth1
ip addr add 10.200.0.1/24 dev veth0
После этих строк у виртуальной сети появляется собственный адрес, а хост выступает шлюзом. Контейнерные движки делают ровно то же самое при каждом запуске, только автоматом и с массой мелких удобств вроде привязки портов. Понимание этой механики превращает загадочные сетевые сбои в контейнерах в обычную задачу: проверить, есть ли интерфейс, поднят ли он и куда ведёт маршрут.
Классическая ловушка новичка связана с петлевым интерфейсом. В новом пространстве он существует, но остаётся выключенным, и программы, которые обращаются к себе по имени localhost, получают отказ в соединении. Службы, привязывающиеся к петлевому адресу для служебных проверок, падают на старте, и кажется, что сломано что-то глубокое, хотя чинится всё поднятием интерфейса одной командой. В контейнерных образах это давно учтено, но при ручной сборке сетей с нуля сюрприз встречается регулярно.
Пользовательские пространства и переход к корневым правам без привилегий
Пространство пользователей решает деликатную задачу: оно позволяет процессу внутри ощущать себя корневым владельцем, оставаясь снаружи обычным непривилегированным пользователем. Перевод между внутренними и внешними номерами задаётся картами в файлах uid_map и gid_map:
cat /proc/$$/uid_map
0 1000 1
Здесь ноль внутри соответствует тысяче снаружи, и таких записей может быть несколько. Диапазоны для подобных переводов закрепляются за пользователями в служебных файлах системы, откуда движки берут непересекающиеся отрезки, чтобы контейнеры разных владельцев не спорили за номера. Значение этого трюка огромно: контейнеры стало возможно запускать без привилегий на хосте, и уязвимость в контейнерной службе больше не даёт атакующему корневые права на машине. Именно на этом механизме стоят корневые режимы популярных движков.
У медали есть обратная сторона: поверхность атаки ядра. Создание пользовательских пространств открыто обычным пользователям, а любой сложный код ядра, доступный без привилегий, расширяет поле для эксплойтов. По этой причине на строгих серверах лимит таких пространств урезают или вовсе запрещают создание, оставляя контейнеры на привилегированном движке:
sysctl user.max_user_namespaces
Выбор между удобством корневых контейнеров и жёсткостью классической схемы зависит от угроз, но знать о развилке обязан каждый, кто отвечает за безопасность узла.
Практика с командами unshare, lsns и nsenter
Три утилиты командной строки закрывают повседневные задачи с пространствами. Unshare запускает процесс в новых пространствах, а lsns перечисляет существующие с числом жителей:
lsns
NS TYPE NPROCS PID USER COMMAND
4026531836 pid 312 1 root /sbin/init
4026532256 net 3 4512 alice nginx
Из вывода сразу видно, какие пространства на машине, сколько процессов в каждом и кто их родоначальник. Утилита nsenter решает обратную задачу: она заводит текущий процесс в пространство по номеру целевого процесса, что незаменимо при диагностике:
nsenter -t 4512 -n ss -tulpn
Команда выполняет просмотр сокетов от лица сетевого пространства веб-службы, и в выводе видны только её соединения. Так проверяют, что именно видит контейнер, отлаживают недоступные порты и сверяют правила фильтрации, не заходя внутрь и не ставя туда ни одного инструмента.
Сборка контейнера из пространств при каждом запуске
Полезно проследить, что именно делает движок за доли секунды между командой запуска и рабочим приложением. Сначала создаётся новый процесс со всем набором флагов новых пространств, и он мгновенно оказывается в мире, где видны только свои процессы, пустая сеть и своё имя хоста. Затем внутрь монтируется образ: слои файловой системы собираются в единое дерево средствами объединённого монтирования, и новое mount-пространство получает его как свою корневую папку. Следом нарезается сеть: создаётся пара виртуальных патчей, один конец уходит в мост на хосте, второй попадает к контейнеру и получает адрес.
После подготовки запускается объявленный в образе процесс, который занимает место номера один в местной нумерации. С этой секунды контейнер живёт: он видит только свои процессы, свою сеть и своё дерево файлов, хотя со стороны хоста это обычный процесс в общем списке, со своим настоящим номером, дескрипторами и счётчиками ресурсов. Никакой второй операционной системы не загружается, ядро одно на всех, и именно поэтому контейнеры стартуют мгновенно и почти не расходуют память на лишние слои.
Проверить это легко: список процессов хоста показывает процессы всех контейнеров вперемешку с системными, а по содержимому каталога одного процесса видно его принадлежность к пространствам. Такой взгляд снаружи экономит часы: когда внутри контейнера что-то ведёт себя странно, часто быстрее осмотреть процесс снаружи, чем ставить инструменты внутрь минимального образа. Понимание того, что контейнер лишь набор флагов у обычного процесса, меняет отношение к отладке и делает всю технологию прозрачной и предсказуемой.
Самая частая ошибка понимания смешивает скрытие и ограничение. Пространства имён прячут ресурсы: процесс не видит чужих процессов, сетей и точек монтирования. Но скрытие не дозирует: процесс, живущий в собственной сети, по-прежнему конкурирует за процессор и память наравне со всей машиной, если его ничем не ограничить. Дозирование выполняет соседний механизм, группы управления, а усечение прав и фильтрацию системных вызовов дают средства контроля доступа.
Рабочий контейнер собирается из нескольких слоёв сразу: пространства дают приватный вид машины, группы делят ресурсы честно, наборы возможностей обрезают корневые привилегии до необходимого минимума, а модули контроля доступа следят за обращениями к файлам. Убери любой слой, и конструкция ослабнет. К тому же все жители разных миров делят одно ядро, и уязвимость в нём остаётся общей поверхностью для всех. Отсюда практический вывод: namespaces это фундамент изоляции, но зрелая защита строится из полного набора, где каждый механизм закрывает свою сторону дома.