Ограничение ресурсов процесса через systemd
Узнайте, как настроить MemoryMax, CPUQuota и TasksMax в systemd для контроля нагрузки на VPS. Разберем настройку cgroup v2 и проверку лимитов через systemctl show.
Ограничение памяти и процессора процесса с помощью systemd drop-in
Вы можете ограничить потребление памяти и процессора процессом на Linux VPS, добавив несколько строк в юнит, который запускает этот процесс. MemoryMax= — это жесткий лимит памяти. CPUQuota= — это лимит процессорного времени. Оба параметра принудительно ограничиваются через cgroup v2 (control groups, версия 2) — функцию ядра, которую systemd уже использует для учета каждого сервиса на сервере.
sudo systemctl edit myapp.serviceЭта команда открывает файл drop-in с инструкциями в комментариях. Добавьте перед ними следующий блок:
[Service]
MemoryHigh=512M
MemoryMax=768M
MemorySwapMax=0
CPUQuota=80%
TasksMax=128sudo systemctl daemon-reload
sudo systemctl restart myapp.service
systemctl show myapp.service -p MemoryHigh -p MemoryMax -p CPUQuotaPerSecUSec -p TasksMaxsystemctl show должна вывести ваши числа в единицах измерения ядра: MemoryMax=805306368 и CPUQuotaPerSecUSec=800ms. Если выводится MemoryMax=infinity, значит, drop-in не был загружен. Проверьте, что файл был создан по пути /etc/systemd/system/myapp.service.d/override.conf и начинается с заголовка [Service], так как строка с настройками без указания секции заставляет systemd записывать в лог Assignment outside of section. Ignoring. и запускать сервис без каких-либо ограничений.
Оставшаяся часть этого руководства посвящена выбору этих значений и возможным проблемам после их применения.
Почему вышедший из-под контроля процесс замораживает VPS, даже не заполняя всю память
Процесс, достигающий жесткого лимита памяти, обычно завершается примерно через секунду, после чего сервис перезапускается. Это благоприятный сценарий. Плохой сценарий — когда ничего не завершается: сервер отвечает на ping, SSH принимает соединение, но приглашение командной строки не появляется. Машина работает и загружена, но полезная работа не выполняется.
Вот механизм этого явления, так как он не очевиден. Когда свободной памяти становится мало, ядро начинает вытеснять страницы вместо выделения новых. Самые дешевые для вытеснения страницы — это файловые, а page cache содержит исполняемый код всех запущенных программ. В результате ядро вытесняет страницы с кодом процесса sshd, и при выполнении следующей инструкции sshd возникает page fault, требующий считывания этих байтов с диска. Каждый процесс в итоге ожидает диск, а не выполняет вычисления. Одинаковые страницы постоянно выгружаются и загружаются обратно — это называется thrashing (пробуксовка).
На VPS ситуация хуже, чем на ноутбуке, по двум причинам. Хранилище часто является сетевым или общим, поэтому каждый сбой (fault) занимает больше миллисекунд, чем на локальном NVMe-накопителе. Кроме того, ядро не измеряет время, оно измеряет сбои: пока процесс вытеснения возвращает страницу, пусть даже очень медленно, ядро считает, что прогресс есть, и не вызывает OOM killer. Сервер может находиться в таком состоянии много минут, прежде чем что-то будет завершено.
Вы можете наблюдать за этим процессом. Ядро предоставляет информацию о задержках (pressure stall information, PSI) в Linux 4.20 и новее:
cat /proc/pressure/memory
cat /proc/pressure/iosome avg10=63.72 avg60=41.02 avg300=12.33 total=13729481
full avg10=48.15 avg60=30.44 avg300=8.90 total=9114233Строка full является ключевой. full avg10=48.15 означает, что в течение 48% последних десяти секунд все не простаивающие задачи на сервере одновременно ожидали освобождения памяти, поэтому полезная работа не выполнялась. На исправном сервере значение full близко к нулю. Значение выше 10 ощущается человеком как замедление, а 40 и более — это состояние, которое описывают как «замороженное».
Именно поэтому лимит сам по себе не является гарантией. Юнит, удерживаемый в рамках MemoryHigh=, подвергается троттлингу вместо завершения, поэтому он остается активным, но работает медленно, и ничто его не перезапускает, так как с точки зрения systemd сбоя не было. Ограниченный юнит, которому разрешено использовать swap, генерирует операции чтения и записи, которые учитываются для этого юнита, но обслуживаются общим устройством, поэтому он может повысить /proc/pressure/io для всех остальных сервисов на сервере. Лимиты определяют, кто платит за нехватку ресурсов, но они не могут создать дополнительные мощности.
Проверка использования cgroup v2 на вашем VPS
stat -fc %T /sys/fs/cgroupcgroup2fs — это унифицированная иерархия, необходимая для работы настроек памяти, описанных ниже. tmpfs означает, что система загрузилась с использованием старой структуры v1, в которой MemoryHigh= и MemorySwapMax= не поддерживаются, а поведение OOM для отдельных юнитов отличается, хотя CPUQuota= там по-прежнему работает через устаревший файл cpu.cfs_quota_us. Ubuntu 22.04 и более поздние версии, а также Debian 11 и более поздние версии используют v2 по умолчанию. Старые образы этого не делают, и на systemd 255 или старше это также не работает, если ядро загружено с параметром systemd.unified_cgroup_hierarchy=0. systemd 256 и 257 отказываются загружаться в режиме v1, если в командной строке ядра также не указан параметр SYSTEMD_CGROUP_ENABLE_LEGACY_FORCE=1. В systemd 258 поддержка cgroup v1 была удалена, и унифицированная иерархия монтируется при каждой загрузке, поэтому в релизах, где используется эта версия, ни один из аргументов не вернет v1.
В cgroup v2 systemd включает учет памяти для каждого юнита по умолчанию, поэтому данные уже доступны:
systemd-cgtop -mЭта команда выводит список cgroup, отсортированный по потреблению памяти. Это самый быстрый способ ответить на вопрос «что потребляет ресурсы сервера», пока система еще отвечает на запросы. Если сервер новый, сначала выполните настройку учетной записи и межсетевого экрана из первые десять минут на новом VPS.
MemoryHigh ограничивает, MemoryMax завершает процессы.
Разница между этими двумя настройками памяти определяет сценарий сбоя.
MemoryHigh=— это мягкое ограничение (soft cap). При его превышении ядро начинает агрессивно освобождать память для данной cgroup и намеренно замедляет выделение ресурсов. Использование памяти может превысить это значение, при этом процессы не завершаются.MemoryMax=— это жесткое ограничение (hard cap). Если запрос на выделение памяти не может быть удовлетворен в рамках этого лимита, внутри cgroup срабатывает OOM killer, который завершает один из процессов этого юнита.
Вторая часть — главная причина устанавливать MemoryMax= для любого процесса, в котором вы не уверены. Без лимита нехватка памяти становится проблемой всей системы, и глобальный OOM killer выбирает жертву по oom_score, что чаще всего означает самый «тяжелый» процесс. Обычно это ваша база данных, а не скрипт с утечкой памяти. С лимитом завершение процесса происходит внутри того юнита, который вызвал нехватку.
Устанавливайте оба параметра, при этом MemoryHigh= должен быть примерно на 20–30 процентов ниже MemoryMax=. Этот промежуток служит предупреждающей зоной: медленная утечка пересекает High, и сервис начинает работать медленно, в то время как резкий скачок потребления проходит через Max и приводит к завершению процесса.
Процентные значения рассчитываются относительно установленной физической памяти, поэтому MemoryMax=25% на тарифе с 4 GB RAM составит 1 GB и останется четвертью объема после изменения размера сервера. MemorySwapMax=0 полностью запрещает юниту использовать swap, поэтому при достижении MemoryMax= процесс завершается быстро, без долгого ожидания выгрузки в swap. Ниже этой точки MemoryHigh= может замедлить работу, но превышение верхнего лимита никогда не вызывает OOM killer, поэтому юнит, потребление которого колеблется между этими значениями, будет работать медленно, но не завершится.
Некоторые сервисы позволяют заранее определить аппетиты вместо их измерения: юнит Ollama рассчитывает размер KV-кэша на основе заданного контекстного окна, поэтому ознакомьтесь с тем, сколько RAM требует увеличение num_ctx перед установкой лимита.
Лимит требует наличия политики перезапуска, иначе после завершения процесса вы останетесь с остановленным сервисом.
[Unit]
StartLimitIntervalSec=300
StartLimitBurst=5
[Service]
Restart=on-failure
RestartSec=5sStartLimit* должен находиться в [Unit], а Restart= — в [Service]. Если поместить их не в ту секцию, systemd проигнорирует настройки. Пять перезапусков за пять минут указывают на утечку, а не на кратковременный сбой, поэтому после этого systemd прекращает попытки и оставляет юнит в состоянии failed. Это именно то состояние, которое вы хотите обнаружить, чтобы не допустить бесконечного цикла перезапусков, скрывающего проблему.
Ограничение CPU с помощью CPUQuota или распределение через CPUWeight
CPUQuota= задает процент времени, доступного на одном ядре CPU. CPUQuota=50% — это половина одного ядра. CPUQuota=200% эквивалентно двум ядрам, которые юнит может распределять между любым количеством потоков по своему усмотрению. На тарифе с 2 vCPU значение CPUQuota=200% означает использование всей мощности сервера.
CPUWeight= — более подходящий вариант по умолчанию для большинства сервисов. Это относительная доля в диапазоне от 1 до 10000, значение по умолчанию в ядре — 100. Ограничение начинает действовать только при наличии конкуренции за ресурсы: задача резервного копирования с CPUWeight=20 уступит веб-серверу со значением 100 при высокой нагрузке, но при этом сможет использовать все ресурсы сервера, пока он простаивает. Жесткая квота приводит к потере этой неиспользуемой мощности.
Трезво оценивайте пользу от ограничения CPU. Процесс, интенсивно использующий CPU, редко приводит к зависанию Linux, так как планировщик продолжает распределять время между всеми задачами. К падению сервера обычно приводит нехватка оперативной памяти. Используйте CPUQuota=, когда вам нужен предсказуемый верхний предел, например, для процесса сборки или агента, который в противном случае будет загружать систему на 100% в течение часа. Оценка размера такой рабочей нагрузки — отдельный вопрос, который рассматривается в сколько RAM и CPU нужно VPS для агента разработки.
Если CPU отображается как загруженный, хотя ваши процессы не выполняют значимых задач, причина может находиться на стороне гипервизора. Это CPU steal time из-за шумного соседа, и никакие установленные вами квоты не помогут это исправить.
TasksMax предотвращает цикл fork-бомбы
TasksMax= — это количество процессов и потоков, которые может содержать юнит. Потоки также учитываются, поэтому сервисам на Java или Go требуется больший запас, чем можно предположить по списку процессов. Это наиболее эффективный способ защиты от скрипта, который создает процессы в цикле: fork завершается ошибкой внутри юнита, вместо того чтобы исчерпать все доступные PID в системе.
TasksMax=128Когда юнит достигает лимита, ядро записывает в лог строку с указанием cgroup:
cgroup: fork rejected by pids controller in /system.slice/myapp.serviceСама программа обычно сообщает об ошибке fork: retry: Resource temporarily unavailable. Проверьте значения, применяемые менеджером по умолчанию, с помощью команды systemctl show -p DefaultTasksMax.
Ограничение разовой задачи с помощью systemd-run
Вам не нужно создавать файл юнита для использования этих возможностей. systemd-run создает временный юнит для одной команды.
sudo systemd-run --scope -p MemoryMax=1G -p MemorySwapMax=0 -p CPUQuota=50% -p TasksMax=64 ./import-data.sh--scope запускает команду в вашем терминале после вывода Running scope as unit: run-r7c1a....scope. Вывод остается на экране, а ограничения снимаются после завершения работы команды. Любое свойство из systemd.resource-control работает после -p.
Для длительной задачи уберите --scope и присвойте ей имя. Она будет работать в фоновом режиме как временный сервис и записывать логи в journal:
sudo systemd-run --unit=nightly-import -p MemoryMax=1G -p CPUWeight=20 ./import-data.sh
journalctl -u nightly-import -fТе же параметры работают с --user, если вы не являетесь root, однако ваш пользовательский менеджер имеет только те контроллеры, которые были ему делегированы, поэтому свойство может быть отклонено. В таком случае запустите его с sudo. Когда задача требует постоянного размещения, настройки переносятся без изменений в настоящий юнит: см. запуск скрипта как сервиса и таймера systemd.
Вопрос о swap: честный ответ
Swap меняет характер сбоя, а не предотвращает его.
Без swap утечка памяти достигает предела, и процесс завершается за считанные секунды. Это шумный, короткий сбой, который легко диагностировать по логам. При наличии swap ядро записывает редко используемые анонимные страницы на диск и выигрывает время. Если потребление памяти процессом стабилизируется, swap вас спасет. Если же это бесконтрольный рост, swap превращает пятисекундный сбой в двадцатиминутное зависание. Зависание хуже: при упавшем процессе у вас остается работающая оболочка, а при «шторме» (thrashing) — нет.
swapon --show
free -hРазумный компромисс для небольшого VPS: используйте небольшой swap-файл для страниц, которые выделяются один раз и больше не используются, и установите MemorySwapMax=0 для юнитов, которыми вы готовы пожертвовать. Важные сервисы сохраняют доступ к swap. Непредсказуемые процессы быстро упираются в лимит, а политика перезапуска рядом с ограничением возвращает их в строй.
Снижение vm.swappiness — слабый рычаг, и важно понимать почему. Это лишь меняет баланс между вытеснением page cache и сбросом анонимных страниц в swap, при этом оба действия в будущем потребуют чтения с диска. Это меняет лишь то, какие именно страницы будут вызывать «шторм», но не предотвращает его.
Ранний OOM-демон завершает процессы до возникновения зависания
Ядро ожидает полного провала попыток освобождения памяти, и на небольшом VPS этот период ожидания — именно тот момент, когда вы теряете доступ к машине. Два демона пользовательского пространства решают эту проблему, самостоятельно отслеживая состояние памяти и завершая процессы раньше.
earlyoom проверяет доступную память и свободный swap до десяти раз в секунду и завершает процесс с наивысшим oom_score только тогда, когда оба показателя опускаются ниже пороговых значений. На сервере без swap решение принимается только на основе порога памяти.
sudo apt install earlyoom
systemctl status earlyoomВ пакетах для Debian и Ubuntu сервис запускается сразу после установки. Его параметры находятся в /etc/default/earlyoom:
EARLYOOM_ARGS="-m 5,2 -s 5,2 --avoid ^(sshd|systemd)$ --prefer ^(node|python3)$"-m PERCENT задает минимум доступной памяти, а -s PERCENT — минимум свободного swap; по умолчанию оба значения равны 10 процентам. Второе число в каждой паре — это точка отправки SIGKILL: earlyoom отправляет SIGTERM, как только память и swap опускаются ниже первых значений, а затем SIGKILL, когда оба показателя падают ниже вторых значений (по умолчанию они составляют половину от первых). Юнит передает эту переменную в earlyoom как $EARLYOOM_ARGS, поэтому systemd разбивает её на аргументы по пробелам. Использование кавычек в --avoid и --prefer безопасно: systemd удаляет внешние двойные кавычки при чтении файла, а затем учитывает и удаляет одинарные кавычки внутри значения при разделении, поэтому --avoid '^(sshd|systemd)$' работает так же, как и вариант без кавычек выше. Шаблон, содержащий пробел, требует наличия таких одинарных кавычек, иначе он будет разделен на два аргумента. Примените изменения командой sudo systemctl restart earlyoom и прочитайте journalctl -u earlyoom, чтобы увидеть, какой процесс был завершен и какой объем памяти он занимал.
systemd-oomd — это другой вариант. В руководстве он описан как «системный сервис, использующий cgroups-v2 и информацию о задержках (PSI) для мониторинга и принятия корректирующих мер до того, как OOM произойдет в пространстве ядра». Он воздействует на целые cgroups, а не на отдельные процессы, поэтому завершает юнит целиком, а не случайный дочерний процесс. Юниты подключаются к мониторингу через ManagedOOMMemoryPressure=kill или ManagedOOMSwap=kill, а пороговые значения задаются в /etc/systemd/oomd.conf.
systemctl status systemd-oomd
oomctloomctl выводит список того, что отслеживается в данный момент; на серверных образах это часто ничего, так как настройка требует явного включения для каждого юнита. Выберите один демон и остановитесь на нем. Использование обоих означает, что два инструмента будут конкурировать в выборе жертвы, и причину завершения процесса станет сложнее восстановить.
Какой юнит стал причиной?
Начните с ядра, так как оно фиксирует каждое завершение процесса, выполненное им самим.
journalctl -k --grep "Killed process" --since "2 hours ago"Завершение процесса глобальным OOM-киллером выглядит следующим образом:
Out of memory: Killed process 4127 (node) total-vm:2731084kB, anon-rss:1874232kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:4212kB oom_score_adj:0anon-rss — это анонимная память, например, куча (heap), которую процесс удерживал в ОЗУ на момент гибели; в данном случае около 1.8 ГБ. Резидентные файловые отображения и общая память учитываются отдельно как file-rss и shmem-rss. К имени в скобках следует относиться с подозрением. Это жертва, которую выбрало ядро, а ядро выбирает самый «тяжелый» процесс, что не всегда совпадает с процессом, вызвавшим нехватку памяти.
Завершение процесса из-за лимита cgroup имеет другой префикс, а отчет, выведенный выше, указывает на cgroup, которая достигла своего собственного предела:
Memory cgroup out of memory: Killed process 8811 (python3) total-vm:1044320kB, anon-rss:769112kB, file-rss:0kB, shmem-rss:0kB, UID:998 pgtables:1720kB oom_score_adj:0Этот префикс содержит основную часть диагностики. Memory cgroup out of memory означает, что один юнит достиг лимита MemoryMax=, установленного для него, в то время как остальная часть системы работала нормально. Обычное сообщение Out of memory означает, что память закончилась на всей машине целиком, а значит, ваши ограничения либо отсутствовали, либо были слишком мягкими в сумме.
Затем запросите у systemd информацию о том, что он зафиксировал:
systemctl status myapp.service
journalctl -u myapp.service -n 50myapp.service: A process of this unit has been killed by the OOM killer.
myapp.service: Main process exited, code=killed, status=9/KILL
myapp.service: Failed with result 'oom-kill'.systemctl status сообщает то же самое в одной строке, как Active: failed (Result: oom-kill).
Счетчики cgroup являются третьим источником информации и единственным, который фиксирует троттлинг (ограничение производительности), не создающий записей в логах:
cat /sys/fs/cgroup/system.slice/myapp.service/memory.events
cat /sys/fs/cgroup/system.slice/myapp.service/memory.peaklow 0
high 4213
max 118
oom 12
oom_kill 12high подсчитывает, сколько раз юнит превышал MemoryHigh= и подвергался троттлингу. max подсчитывает, как часто он достигал жесткого лимита, а oom_kill считает фактически завершенные процессы. Большое значение high при oom_kill 0 — это тот самый случай «тихой» проблемы: с момента создания cgroup юнит неоднократно подвергался троттлингу без единого завершения, поэтому systemd не зафиксировал сбой. Счетчик только растет, поэтому считайте его значения с интервалом в минуту: если high продолжает увеличиваться, значит, троттлинг происходит прямо сейчас. memory.peak (в Linux 5.19 и новее) содержит максимальный объем использования, достигнутый cgroup; это число следует использовать для настройки MemoryMax=. Оба файла сбрасываются при перезапуске юнита, так как systemd создает cgroup заново.
В основе всего этого лежит одно предварительное условие. Если /var/log/journal не существует, журнал хранится в ОЗУ, и каждая строка исчезает после перезагрузки, которая потребовалась вам для восстановления системы.
sudo mkdir -p /var/log/journal
sudo systemd-tmpfiles --create --prefix /var/log/journal
sudo systemctl restart systemd-journald
journalctl --list-bootsЕсли journalctl --list-boots показывает больше, чем текущая загрузка, значит, история сохраняется, и journalctl -k -b -1 может показать вам сообщения ядра из той загрузки, во время которой произошел сбой.
Отправная точка для небольшого VPS
На тарифе с 2 GB оперативной памяти оставляйте от 300 до 400 MB для ядра и страничного кэша. Не допускайте, чтобы сумма лимитов всех юнитов достигала полных 2 GB, так как потребление всех сервисов может достичь пика одновременно. Выделите наибольшую долю критически важному сервису, а для второстепенных задач установите жесткие ограничения.
[Service]
MemoryHigh=256M
MemoryMax=384M
MemorySwapMax=0
CPUWeight=20
TasksMax=64
Restart=on-failure
RestartSec=5sСохранение доступа к серверу требует дополнительной настройки. Параметр OOMScoreAdjust=-500 в drop-in файле для ssh.service значительно снижает вероятность того, что глобальный OOM killer выберет ваш SSH-демон в качестве жертвы. Это разница между исправлением системы и её перезагрузкой через панель управления. Данная настройка лишь меняет выбор ядра при нехватке памяти, но не сокращает время зависания системы.
Контейнеры работают в собственных cgroups, которые создаются средой выполнения контейнеров, а не вашими unit-файлами. Поэтому лимит на docker.service не становится ограничением для одного контейнера. Эквиваленты MemoryMax= и CPUQuota= для отдельных контейнеров описаны в настройке лимитов памяти и CPU в Docker Compose.
FAQ
Почему мой VPS завис, а не завершил вышедший из-под контроля процесс?
Потому что ядро оценивает прогресс по факту возврата страниц механизмом вытеснения, а не по времени, которое это занимает. При нехватке памяти оно вытесняет page cache, включая исполняемые страницы запущенных программ, а затем считывает их обратно при следующей инструкции. Все процессы ожидают диск, и технически ни один запрос на выделение памяти не завершился ошибкой, поэтому OOM killer не вызывается. Проверяйте /proc/pressure/memory во время инцидента: значение full avg10 выше 40 означает, что более 40% последних десяти секунд каждая не простаивающая задача была заблокирована из-за нехватки памяти. Пользовательский демон, такой как earlyoom, завершает процессы до того, как сервер достигает такого состояния.
В чем разница между MemoryHigh и MemoryMax?
MemoryHigh= — это мягкий лимит, который включает троттлинг. Ядро активно вытесняет страницы юнита и замедляет выделение памяти, но потребление может превысить это значение, и процесс не будет завершен. MemoryMax= — это жесткий лимит: если запрос на выделение памяти не может быть удовлетворен в его рамках, вызывается OOM killer внутри cgroup этого юнита, поэтому завершается именно тот процесс, который вызвал проблему, а не самый «тяжелый» процесс на сервере. Установите MemoryHigh= ниже MemoryMax= и рассматривайте разницу между ними как зону предупреждения.
Как узнать, какой сервис завершил OOM killer?
Выполните journalctl -k --grep "Killed process" --since "2 hours ago". Строка, начинающаяся с Memory cgroup out of memory, означает, что юнит достиг своего собственного MemoryMax=, а обычное сообщение Out of memory означает, что память закончилась на всей машине. Затем выполните journalctl -u <unit> -n 50 и найдите Failed with result 'oom-kill'. Если /var/log/journal не существует на вашем сервере, значит, журнал хранился в оперативной памяти и данные были потеряны при перезагрузке; создайте этот каталог до следующего инцидента.
Стоит ли добавлять swap на маленький VPS?
Небольшой файл подкачки помогает с «холодными» страницами, которые были выделены один раз и больше не используются. Он не помогает при вышедшем из-под контроля процессе: он лишь откладывает завершение и заменяет короткий сбой длительным зависанием, при котором невозможно войти в систему для исправления ситуации. Держите swap небольшим и установите MemorySwapMax=0 для юнитов, которые вы готовы потерять; тогда они быстро достигнут своего потолка и, при установленном Restart=on-failure, перезапустятся самостоятельно, в то время как важные сервисы сохранят свой swap.
Можно ли ограничить команду без создания unit-файла?
Да. sudo systemd-run --scope -p MemoryMax=1G -p CPUQuota=50% ./script.sh запускает команду в вашем терминале внутри временного scope с указанными лимитами, и эти лимиты исчезают после завершения команды. Все свойства из systemd.resource-control доступны после -p, поэтому MemorySwapMax=, TasksMax= и CPUWeight= также работают. Уберите --scope и добавьте --unit=name, чтобы запустить задачу в фоновом режиме с выводом логов в журнал.