Механизм Control Groups, сокращённо cgroups, встроен в ядро Linux и позволяет собирать процессы в иерархические группы, а затем назначать каждой группе лимиты и гарантии по процессору, памяти, вводу-выводу и числу задач. Ядро следит за соблюдением границ на уровне планировщика, подсистемы учёта памяти и блочного слоя, поэтому ограничения действуют даже для процессов, которые ничего не знают о существовании групп. На cgroups стоят контейнеры Docker и Podman, изоляция сервисов systemd, песочницы CI-раннеров и любые сценарии, в которых один прожорливый процесс не должен отнимать ресурсы у соседей. Интерфейс группы - это обычный набор файлов в виртуальной файловой системе, смонтированной в /sys/fs/cgroup, поэтому с ним работают штатными инструментами командной строки: значения читаются cat-ом, лимиты записываются echo-ом, и эффект наступает немедленно, без перезагрузки и пересборки ядра.

Две версии интерфейса cgroups и единая иерархия в v2

Исторически сложились две версии API. В cgroups v1 каждый контроллер жил в собственной иерархии: память монтировалась в /sys/fs/cgroup/memory, процессор в /sys/fs/cgroup/cpu, блочный ввод-вывод в /sys/fs/cgroup/blkio. Иерархии можно было монтировать с несколькими контроллерами сразу, размонтировать лишние и даже давать им произвольные имена, что ещё сильнее путало картину. Процесс мог находиться в одной группе для памяти и в совершенно другой для процессора: гибкость получилась сомнительной, рассинхронизация групп порождала трудноуловимые ошибки, а код ядра, обслуживающий несколько параллельных деревьев, усложнялся с каждым релизом.

Cgroups v2 ввела единую иерархию, известную как unified hierarchy: одно дерево в /sys/fs/cgroup обслуживает все контроллеры сразу, процесс принадлежит ровно одной группе, а контроллеры включаются сверху вниз через файл cgroup.subtree_control. Группа по умолчанию либо содержит процессы, либо раздаёт контроллеры дочерним группам; исключение сделано для корня дерева и для потоковых поддеревьев в режиме threaded, которым разрешено держать процессы при потоковых контроллерах cpu, cpuset, perf_event и pids. Узнать версию на конкретной машине можно по типу смонтированной файловой системы:

$ stat -fc %T /sys/fs/cgroup/
cgroup2fs
$ cat /sys/fs/cgroup/cgroup.controllers
cpuset cpu io memory hugetlb pids rdma misc

Вывод cgroup2fs означает вторую версию, tmpfs означает первую. Fedora начиная с выпуска 31, свежие Debian и Ubuntu, а также RHEL 9 загружаются с единой иерархией по умолчанию; RHEL 8 по умолчанию загружается с первой версией, а единую иерархию там включают вручную параметром systemd.unified_cgroup_hierarchy=1. Множество примеров в старой документации написаны под v1, поэтому администратору полезно свободно читать оба диалекта, хотя новые решения разумно ориентировать на v2.

Контроллер cpu и справедливое распределение процессорного времени

Контроллер cpu ограничивает и взвешивает процессорное время. Главный файл в v2 - cpu.max, в котором записана пара значений: квота в микросекундах и период. Запись 200000 100000 означает, что за каждые 100 миллисекунд группа получает не больше 200 миллисекунд процессорного времени, то есть эквивалент двух ядер. Слово max снимает потолок вовсе. В v1 та же настройка разнесена по файлам cpu.cfs_quota_us и cpu.cfs_period_us, и такой синтаксис до сих пор встречается в манифестах старых кластеров и в аргументах ранних версий Docker.

Помимо жёсткой квоты существует вес: файл cpu.weight в v2 принимает значения от 1 до 10000 при нейтральных 100, а в v1 аналогом служит cpu.shares со значением по умолчанию 1024. Вес работает только при конкуренции: пока ядра свободны, группа берёт сколько нужно, и делёж начинается лишь в момент насыщения процессора. Для привязки задач к конкретным ядрам служит отдельный контроллер cpuset с файлом cpuset.cpus, незаменимый на NUMA-машинах и при выделении ядра под чувствительные к задержкам сервисы. В свежих ядрах у cpu.max появился сосед cpu.max.burst, позволяющий копить неиспользованную квоту и тратить её коротким всплеском.

Диагностика строится на файле cpu.stat: поле usage_usec показывает суммарное потребление, а nr_throttled и throttled_usec - сколько раз и как долго группа упиралась в потолок. Если приложение тормозит без видимой причины, а счётчик throttled_usec быстро растёт, квота занижена либо период выбран неудачно.

# cd /sys/fs/cgroup
# echo "+cpu" > cgroup.subtree_control
# mkdir build-limited
# echo "200000 100000" > build-limited/cpu.max
# echo 100 > build-limited/cpu.weight
# echo $$ > build-limited/cgroup.procs

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

Контроллер memory и защита сервера от утечек памяти

Контроллер memory учитывает анонимную память, страничный кэш и память ядра, потраченную на нужды группы. Основной лимит задаёт файл memory.max: при его исчерпании ядро начинает агрессивно вытеснять страницы, а когда высвободить нечего, OOM killer уничтожает процессы внутри самой группы, не трогая остальную систему. Файл memory.high работает мягче: превышение вызывает вытеснение кэша и притормаживание выделения памяти, что часто спасает сервис от мгновенной гибели и даёт время на диагностику. Гарантии настраиваются файлами memory.min и memory.low, а потребление подкачки ограничивает memory.swap.max. В v1 аналоги называются memory.limit_in_bytes, memory.soft_limit_in_bytes и memory.memsw.limit_in_bytes.

Учёт и события видны без внешних инструментов: memory.current показывает текущее потребление, memory.stat раскладывает его по типам страниц, memory.events ведёт счётчики oom и oom_kill, а файл memory.pressure на свежих ядрах отдаёт метрики давления в формате PSI. Страничный кэш тоже заряжается на группу: процесс, читающий большие файлы, наполняет кэш от имени своей группы, и при нехватке лимита ядро вытесняет именно его страницы.

# mkdir /sys/fs/cgroup/leaky-app
# echo 1G > /sys/fs/cgroup/leaky-app/memory.max
# echo 800M > /sys/fs/cgroup/leaky-app/memory.high
# cat /sys/fs/cgroup/leaky-app/memory.events
max 0
oom 0
oom_kill 0

Такой профиль превращает утечку из падения всего сервера в контролируемую деградацию одной группы: сервис упрётся в 800 мегабайт и начнёт притормаживать, а при достижении гигабайта ядро завершит только его процессы. Файл memory.oom.group при значении 1 распространяет OOM-убийство на все процессы группы сразу, что удобно для контейнеров, где частичное завершение оставляет невалидное состояние приложения.

Контроллеры io и pids для дисков и числа задач

Контроллер io управляет блочным вводом-выводом. В файле io.max для каждого устройства задаётся строка вида 8:16 rbps=104857600 wbps=52428800 riops=max wiops=max, где первое поле - пара старшего и младшего номеров устройства, а параметры ограничивают чтение и запись в байтах и в операциях в секунду; слово max снимает лимит. Файл io.weight задаёт пропорциональный делёж при конкуренции очередей, io.stat показывает фактические счётчики по устройствам. В v1 контроллер назывался blkio, а те же лимиты писались в blkio.throttle.read_bps_device и blkio.throttle.write_iops_device. В свежих ядрах рядом появились io.latency и io.cost для целевых задержек, но они требуют понимания модели очередей устройства и применяются реже.

Контроллер pids ограничивает число процессов и потоков в группе файлом pids.max. Это простой и радикально эффективный предохранитель от fork-бомб и от неконтролируемого порождения потоков библиотеками: исчерпание лимита просто отменяет создание процесса с ошибкой EAGAIN, а таблица процессов сервера остаётся живой. Счётчик pids.current показывает занятое место, pids.events фиксирует отказы.

# mkdir /sys/fs/cgroup/db-import
# echo "8:16 rbps=104857600 wbps=52428800 riops=max wiops=max" > /sys/fs/cgroup/db-import/io.max
# mkdir /sys/fs/cgroup/test-runner
# echo 300 > /sys/fs/cgroup/test-runner/pids.max

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

Ручное создание групп в sysfs и утилитами libcgroup

Базовый сценарий не требует ничего, кроме оболочки и прав root. Ручное создание группы в v2 сводится к короткой последовательности действий:

  1. включить нужные контроллеры в cgroup.subtree_control родительской группы;
  2. создать каталог группы внутри /sys/fs/cgroup;
  3. записать лимиты в файлы контроллеров новой группы;
  4. добавить идентификаторы процессов в файл cgroup.procs;
  5. проверить результат по cgroup.stat и счётчикам контроллеров.

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

Пакет libcgroup с утилитами cgcreate, cgset, cgexec, cgclassify и cgdelete оборачивает те же операции в компактный синтаксис и добавляет файл правил cgrules.conf со службой cgrulesengd, который автоматически помещает процессы перечисленных пользователей и команд в назначенные группы при старте. Проект развивается вяло и привязан в основном к v1, поэтому на новых системах его роль забирает systemd, но для скриптов и живых экспериментов утилиты остаются удобными.

# cgcreate -g cpu,memory:webapp
# cgset -r cpu.cfs_quota_us=150000 webapp
# cgset -r memory.limit_in_bytes=1G webapp
# cgexec -g cpu,memory:webapp python3 worker.py

Здесь группа webapp создаётся сразу для двух контроллеров, получает квоту в полтора ядра и потолок памяти в гигабайт, после чего worker.py запускается уже внутри неё.

Делегирование групп пользователям и вопросы безопасности

Права на /sys/fs/cgroup принадлежат root, но поддеревья можно делегировать: смена владельца каталога группы и файлов cgroup.procs, cgroup.threads и cgroup.subtree_control позволяет обычному пользователю создавать подгруппы и настраивать лимиты внутри полученного диапазона. systemd делает это декларативно через опцию Delegate=yes в юните, что лежит в основе пользовательских срезов и rootless-контейнеров Podman.

В v2 делегирование продумано заметно аккуратнее, чем в v1. Перенос чужого процесса в свою группу требует доступа на запись и к исходному, и к целевому cgroup.procs, поэтому пользователь не может молча перехватить чужой процесс, как это было возможно в первой версии. Опция монтирования nsdelegate дополнительно сужает влияние делегированной группы пределами пользовательского пространства имён.

Риски остаются, и о них полезно помнить. Владелец группы способен заморозить собственные процессы через cgroup.freeze, дожать лимиты родителя, а в свежих ядрах завершить всё поддерево одним файлом cgroup.kill. Файл cgroup.type переключает группу между доменной и потоковой моделями: потоковая группа допускает отдельные потоки одного процесса и нужна для тонкой изоляции внутри приложения. Делегируйте минимально необходимое поддерево и следите, чтобы лимиты родителя гарантировали остальной системе ресурсы независимо от поведения делегированных подгрупп.

Systemd как основной интерфейс управления группами ресурсов

На современных дистрибутивах руками группы почти никто не строит: менеджер systemd создаёт собственную иерархию из срезов, областей и служб. Каждый юнит получает отдельную группу: службы живут в system.slice, пользовательские сессии в user.slice, виртуальные машины и контейнеры в machine.slice, а корень дерева занимает служебный срез с именем -.slice. Лимиты задаются привычными свойствами юнита: CPUQuota, CPUWeight, MemoryMax, MemoryHigh, TasksMax, IOReadBandwidthMax, IOWriteBandwidthMax и десятки соседних.

# systemctl set-property backup.service CPUQuota=50% MemoryMax=2G IOWeight=10
# systemd-run --scope -p MemoryMax=1G -p TasksMax=200 ./stress-test

Первая команда ограничивает резервное копирование половиной ядра, двумя гигабайтами памяти и низким весом ввода-вывода, причём изменение сохраняется навсегда и переживает перезапуск; ключ --runtime ограничил бы действие текущей загрузкой. Вторая запускает разовый эксперимент в собственной области с жёсткими лимитами и без правки глобальной конфигурации. Постоянные настройки удобнее держать в drop-in файлах, которые создаёт команда systemctl edit с именем службы. Делегирование пользовательских срезов включается свойством Delegate=yes в юните user@.service, после чего окружение входа пользователя получает собственное поддерево, которым можно управлять без root.

Наблюдение ведётся утилитой systemd-cgtop, показывающей потребление процессора, памяти и ввода-вывода по группам в стиле классического top, а файлы cgroup.stat и memory.events дают детализацию при разборе инцидентов. Контейнерные движки опираются ровно на этот механизм: Docker и Podman транслируют флаги --cpus и --memory в файлы cgroup, а Kubernetes превращает запросы ресурсов подов в лимиты контейнерных групп через драйвер systemd cgroup.

Итог простой: cgroups превратили управление ресурсами из набора обходных путей в штатный интерфейс ядра. Разобравшись с четырьмя базовыми контроллерами, единым деревом v2 и свойствами systemd, администратор получает инструмент, который держит сервер в узде без единого перезапуска: лимиты применяются на лету, диагностика читается из тех же файлов, а поведение системы остаётся предсказуемым даже под штормом непредсказуемых задач.