SSD Nodes Learn Hosting plans →
Посібники Matt ConnorВід Matt Connor · Оновлено 2026-10-30

Як обмежити пам’ять і CPU процесу в systemd

Налаштуйте MemoryHigh=512M, MemoryMax=768M, CPUQuota=80% і TasksMax=128 у drop-in systemd. Перевірте значення та знайдіть причину OOM kill.

Обмеження пам’яті та CPU процесу за допомогою drop-in для systemd

Обмежити використання пам’яті та CPU процесом на Linux VPS можна, додавши кілька рядків до unit, який запускає цей процес. MemoryMax= — жорстке обмеження пам’яті. CPUQuota= — обмеження процесорного часу. Обидва обмеження застосовує cgroup v2 (control groups, version 2) — функція ядра, яку systemd уже використовує для обліку кожного сервісу на сервері.

sudo systemctl edit myapp.service

Ця команда відкриває drop-in-файл із інструкціями в коментарях. Додайте наведені нижче рядки перед ними:

[Service]
MemoryHigh=512M
MemoryMax=768M
MemorySwapMax=0
CPUQuota=80%
TasksMax=128
sudo systemctl daemon-reload
sudo systemctl restart myapp.service
systemctl show myapp.service -p MemoryHigh -p MemoryMax -p CPUQuotaPerSecUSec -p TasksMax

systemctl show має вивести ваші значення в одиницях ядра: MemoryMax=805306368 і CPUQuotaPerSecUSec=800ms. Якщо команда виводить MemoryMax=infinity, drop-in не завантажено. Перевірте, що файл збережено за шляхом /etc/systemd/system/myapp.service.d/override.conf і що він починається із заголовка [Service]. Якщо рядок налаштування не має перед собою секції, systemd записує в журнал Assignment outside of section. Ignoring. і запускає сервіс без будь-яких обмежень.

У решті цього посібника описано, як вибрати ці значення та які проблеми все ще можуть виникати після їх встановлення.

Чому runaway-процес зависає на VPS, навіть не заповнивши пам’ять

Процес, який досягає жорсткого ліміту пам’яті, завершується приблизно за секунду, після чого сервіс перезапускається. Це сприятливий випадок. Гірший випадок — коли нічого не завершується: сервер відповідає на ping, SSH приймає підключення, але запрошення shell так і не з’являється. Машина працює, але зайнята марною роботою.

Ось як це відбувається. Коли вільної пам’яті стає мало, kernel звільняє сторінки замість виділення нових. Найпростіше звільняти сторінки, пов’язані з файлами, а page cache містить виконуваний код усіх запущених процесів. Тому kernel витісняє текстові сторінки sshd, і наступна інструкція, яку виконує sshd, спричиняє page fault: ці байти потрібно знову прочитати зі сховища. У результаті кожен процес чекає на диск замість виконання. Ті самі сторінки постійно витісняються й завантажуються назад. Це називається thrashing.

На VPS ситуацію погіршують два чинники порівняно з ноутбуком. Сховище часто підключене через мережу або спільно використовується, тому кожен page fault займає більше мілісекунд, ніж на локальному NVMe-пристрої. Крім того, kernel вимірює не час, а результат: доки reclaim повертає хоча б одну сторінку, навіть дуже повільно, kernel вважає, що робота триває, і не запускає out of memory (OOM) killer. Сервер може перебувати в такому стані багато хвилин, перш ніж буде завершено будь-який процес.

Ви можете спостерігати цей стан. У Linux 4.20 і новіших версіях kernel експортує pressure stall information (PSI):

cat /proc/pressure/memory
cat /proc/pressure/io
some 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 або більше — це стан, який зазвичай описують як зависання.

Саме тому сам по собі ліміт не є гарантією. Unit, обмежений через MemoryHigh=, дроселюється, а не завершується. Він залишається активним і повільним, а systemd його не перезапускає, оскільки з його погляду помилки не сталося. Якщо capped unit може використовувати swap, він генерує операції читання та запису, які обліковуються для цього unit, але виконуються одним спільним пристроєм. Через це він може підвищити /proc/pressure/io для кожного іншого сервісу на сервері. Ліміти визначають, хто сплачує ціну дефіциту, але не створюють додаткову ємність.

Перевірте, що ваш VPS використовує cgroup v2

stat -fc %T /sys/fs/cgroup

cgroup2fs — це уніфікована ієрархія, потрібна для наведених нижче налаштувань пам’яті. tmpfs означає, що сервер завантажив стару структуру v1, у якій MemoryHigh= і MemorySwapMax= не підтримуються, а поведінка OOM для окремих unit відрізняється, хоча CPUQuota= і далі працює через застарілий файл cpu.cfs_quota_us. Ubuntu 22.04 і новіші версії, а також Debian 11 і новіші версії використовують v2 за замовчуванням. Старий образ її не використовує. Так само 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 за замовчуванням вмикає облік пам’яті для кожного unit, тому ці значення вже доступні:

systemd-cgtop -m

Ця команда виводить cgroup, відсортовані за використанням пам’яті. Це найшвидший спосіб з’ясувати, що споживає ресурси сервера, поки він ще відповідає на запити. Якщо сервер новий, спочатку виконайте налаштування облікового запису та firewall у розділі перші десять хвилин на новому VPS.

MemoryHigh обмежує швидкість. MemoryMax завершує процес.

Різниця між цими двома параметрами пам’яті визначає, як саме виглядатиме збій.

  • MemoryHigh= — це м’яке обмеження. Коли використання перевищує його, ядро активно звільняє пам’ять із цієї cgroup і навмисно сповільнює подальше виділення пам’яті. Використання все одно може перевищити це значення, і жоден процес не завершується.
  • MemoryMax= — це жорстке обмеження. Якщо виділення пам’яті неможливо виконати в межах цього обмеження, OOM killer запускається всередині цієї cgroup і завершує один із власних процесів цього unit.

Саме тому для всього, чому ви не довіряєте повністю, потрібно встановлювати MemoryMax=. Без обмеження нестача пам’яті стає проблемою всього сервера, а глобальний OOM killer вибирає процес за oom_score, що здебільшого означає найбільший процес. Найбільшим процесом зазвичай є база даних, а не скрипт, який спричинив витік пам’яті. Якщо встановити обмеження, завершення процесу відбувається всередині unit, який спричинив проблему.

Установіть обидва параметри, причому MemoryHigh= має бути приблизно на 20–30 відсотків нижчим за MemoryMax=. Різниця між ними є зоною попередження: повільний витік перетинає High і проявляється як уповільнення сервісу, тоді як раптовий стрибок одразу перетинає Max і завершує процес.

Процентні значення обчислюються від установленого обсягу фізичної пам’яті. Тому MemoryMax=25% на плані з 4 GB становить 1 GB і після збільшення плану залишається чвертю доступної пам’яті сервера. MemorySwapMax=0 повністю забороняє цьому unit використовувати swap. Тому після досягнення MemoryMax= процес швидко завершується, а не повільно працює під час тривалого використання swap. Нижче цього значення MemoryHigh= все одно може обмежувати швидкість роботи. Перевищення верхнього обмеження ніколи не запускає OOM killer, тому unit, який коливається між цими двома значеннями, залишається повільним, а не завершується.

Деякі сервіси дають змогу заздалегідь визначити обсяг пам’яті, який вони використовуватимуть, замість вимірювання фактичного споживання. Unit Ollama визначає розмір KV cache на основі заданого вами контекстного вікна. Тому перед вибором верхнього обмеження ознайомтеся з матеріалом про витрати RAM під час збільшення num_ctx.

Поруч з обмеженням потрібно налаштувати політику перезапуску. Інакше після завершення процесу ви просто отримаєте зупинений сервіс.

[Unit]
StartLimitIntervalSec=300
StartLimitBurst=5

[Service]
Restart=on-failure
RestartSec=5s

StartLimit* має бути в [Unit], а Restart= — у [Service]. Якщо розмістити будь-який із них у неправильному розділі, systemd його проігнорує. П’ять перезапусків за п’ять хвилин свідчать про витік, а не про короткочасний збій. Після цього systemd припиняє спроби й залишає unit у стані failed. Саме цей стан ви зможете виявити пізніше, замість прихованого циклу аварійних перезапусків.

Обмежуйте CPU за допомогою CPUQuota або розподіляйте процесорний час за допомогою CPUWeight

CPUQuota= використовує певний відсоток часу, доступного на одному CPU. CPUQuota=50% — це половина одного ядра. CPUQuota=200% еквівалентне двом ядрам, між якими unit може розподіляти навантаження довільно. У тарифному плані з 2 vCPU CPUQuota=200% — це весь доступний сервер.

CPUWeight= зазвичай є кращим значенням за замовчуванням для більшості сервісів. Це відносна частка від 1 до 10000, а значення ядра за замовчуванням — 100. Вона впливає лише тоді, коли процеси конкурують за CPU: за навантаження завдання резервного копіювання з CPUWeight=20 поступається вебсерверу зі значенням 100, але під час простою сервера все одно може використовувати весь доступний CPU. Жорстке обмеження в такому разі марнує вільну потужність.

Реалістично оцінюйте, що дає обмеження CPU. Процес, обмежений продуктивністю CPU, рідко блокує Linux, оскільки планувальник продовжує надавати процесорний час усім процесам. Сервер найчастіше виводить із ладу нестача пам’яті. Використовуйте CPUQuota=, якщо потрібна передбачувана верхня межа, наприклад для збірки або агента, який інакше працював би на повній потужності протягом години. Вибір розміру для такого навантаження — окреме питання, розглянуте в матеріалі скільки RAM і CPU потрібно VPS для coding agent.

Якщо CPU показує високе навантаження, хоча жоден із ваших процесів майже не використовує ресурси, причина може бути на іншому боці hypervisor. Це час CPU steal через шумного сусіда, і жодне встановлене вами обмеження не змінить ситуацію.

TasksMax зупиняє цикл fork

TasksMax= — це максимальна кількість процесів і потоків, які може містити unit. Потоки також враховуються, тому сервіс Java або Go потребує більшого запасу, ніж випливає зі списку процесів. Це найпростіший захист від скрипта, який виконує fork у циклі, оскільки fork завершується помилкою всередині unit, а не призводить до вичерпання ідентифікаторів процесів на сервері.

TasksMax=128

Коли unit досягає ліміту, ядро записує в журнал рядок із назвою cgroup:

cgroup: fork rejected by pids controller in /system.slice/myapp.service

Сама програма зазвичай повідомляє fork: retry: Resource temporarily unavailable. Перевірте значення, яке manager застосовує за замовчуванням, за допомогою systemctl show -p DefaultTasksMax.

Обмеження одноразового завдання за допомогою systemd-run

Для цього не потрібен unit-файл. systemd-run створює тимчасовий unit для однієї команди.

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. Вивід залишається на екрані, а обмеження зникають після завершення команди. Після -p працює будь-яка властивість із systemd.resource-control.

Для тривалого завдання приберіть --scope і вкажіть йому ім’я. Тоді воно працюватиме у фоновому режимі як тимчасовий сервіс, а журнали записуватимуться до journal:

sudo systemd-run --unit=nightly-import -p MemoryMax=1G -p CPUWeight=20 ./import-data.sh
journalctl -u nightly-import -f

Ті самі параметри працюють із --user, якщо ви не root. Однак user manager має лише ті контролери, які йому делеговано, тому властивість може бути відхилена. Якщо це станеться, запустіть команду з sudo. Коли завдання отримує постійний unit, ці параметри без змін переносяться до нього: див. запуск скрипту як systemd-сервісу та таймера.

Питання swap: чесна відповідь

Swap змінює характер збою, а не запобігає йому.

Без swap витік досягає ліміту, і за кілька секунд завершується робота якогось процесу. Збій гучний, короткий, і після нього його легко проаналізувати в журналі. Зі swap ядро записує холодні анонімні сторінки на диск і виграє час. Якщо споживання пам’яті мало стабілізуватися, swap вас рятує. Якщо витік неконтрольований, swap перетворює п’ятисекундний збій на двадцятихвилинне зависання. Це гірше, оскільки після завершення процесу у вас залишається робоча оболонка, а система, зайнята thrashing, уже нею не є.

swapon --show
free -h

Практичний компроміс для невеликого VPS: залиште невеликий swap-файл для сторінок, які виділяються один раз і більше не використовуються, а для unit-файлів, якими ви готові пожертвувати, задайте MemorySwapMax=0. Важливі сервіси зберігають можливість використовувати swap. Непередбачувані процеси швидко досягають ліміту, а політика перезапуску поруч із цим лімітом запускає їх знову.

Зменшення vm.swappiness — слабкий важіль, і варто розуміти чому. Воно лише змінює баланс між витісненням page cache та переміщенням анонімних сторінок у swap, а обидві операції згодом потребують читання з диска. Це змінює, які сторінки спричиняють thrashing, але не усуває thrashing системи.

Ранній OOM-демон завершує процеси до зависання

Ядро очікує, доки reclaim повністю не завершиться невдало. На невеликому VPS саме за цей час сервер може стати недоступним. Два userspace-демони скорочують це вікно: вони самостійно відстежують пам’ять і завершують процеси раніше.

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, коли обидва показники стають нижчими за другі значення. Типово друге значення дорівнює половині першого. Unit передає цю змінну earlyoom як $EARLYOOM_ARGS, тому systemd розділяє її на аргументи за пробільними символами. Брати шаблони --avoid і --prefer у лапки безпечно: systemd видаляє зовнішні подвійні лапки під час читання файлу, а потім враховує та видаляє внутрішні одинарні лапки, розділяючи значення. Тому --avoid '^(sshd|systemd)$' працює так само, як і форма без лапок вище. Шаблон, що містить пробіл, потрібно взяти в одинарні лапки, інакше його буде розділено на два аргументи. Застосуйте зміну за допомогою sudo systemctl restart earlyoom. Перегляньте journalctl -u earlyoom, щоб дізнатися, який процес було завершено та скільки пам’яті він утримував.

systemd-oomd — інший варіант. На його сторінці посібника він описаний як "системний сервіс, що використовує cgroups-v2 і pressure stall information (PSI) для моніторингу та виконання коригувальних дій до виникнення OOM у просторі ядра". Він працює з цілими cgroups, а не з окремими процесами. Тому він завершує unit, а не випадковий дочірній процес. Unit підключають цю функцію за допомогою ManagedOOMMemoryPressure=kill або ManagedOOMSwap=kill, а порогові значення зберігаються у /etc/systemd/oomd.conf.

systemctl status systemd-oomd
oomctl

oomctl показує, що саме зараз моніториться. На серверному образі список часто порожній, оскільки кожен unit потрібно підключати окремо. Виберіть один демон і використовуйте лише його. Якщо запустити обидва, вони одночасно вибиратимуть процес для завершення, а причину завершення буде складніше встановити.

Який unit відповідав за це?

Почніть із kernel, оскільки він записує кожне виконане завершення процесу.

journalctl -k --grep "Killed process" --since "2 hours ago"

Завершення процесу глобальним OOM killer має такий вигляд:

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:0

anon-rss — це анонімна пам’ять, наприклад heap, яку процес утримував у RAM на момент завершення; у цьому випадку — близько 1.8 GB. Resident-відображення файлів і shared memory підраховуються окремо, як file-rss і shmem-rss. Читайте ім’я в дужках критично. Це процес, який kernel обрав жертвою. Kernel обирає найбільший процес, але саме він не завжди спричинив дефіцит пам’яті.

Завершення процесу через ліміт 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 означає, що один unit досяг заданого вами MemoryMax=, тоді як решта системи працювала нормально. Звичайний Out of memory означає, що пам’ять закінчилася в усій системі. Отже, ваші обмеження або не задані, або надто великі в сумі.

Потім перевірте, що побачив systemd:

systemctl status myapp.service
journalctl -u myapp.service -n 50
myapp.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 — третє джерело інформації та єдине, яке записує throttling. Throttling взагалі не створює рядка в журналі:

cat /sys/fs/cgroup/system.slice/myapp.service/memory.events
cat /sys/fs/cgroup/system.slice/myapp.service/memory.peak
low 0
high 4213
max 118
oom 12
oom_kill 12

high підраховує, скільки разів unit перевищував MemoryHigh= і переходив у режим throttling. max підраховує, як часто unit досягав жорсткого ліміту, а oom_kill — скільки процесів було фактично завершено. Велике значення high разом із oom_kill 0 — це описаний раніше непомітний випадок: після створення cgroup unit неодноразово переходив у режим throttling, але жодного процесу не було завершено, тому systemd не зафіксував помилку. Лічильник лише зростає, тому прочитайте його двічі з інтервалом в одну хвилину: high, який продовжує зростати, означає, що throttling відбувається зараз. memory.peak (Linux 5.19 і новіші версії) містить максимальне використання, якого досягла cgroup. Саме проти цього значення потрібно розміряти MemoryMax=. Обидва файли скидаються після перезапуску unit, оскільки systemd створює cgroup повторно.

Усе це залежить від однієї попередньої умови. Якщо /var/log/journal не існує, journal зберігається в RAM, і після перезавантаження, потрібного для відновлення системи, усі записи буде втрачено.

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, що показує більше ніж поточний boot, означає, що історія тепер зберігається. Тому journalctl -k -b -1 може показати повідомлення kernel із boot, під час якого система завершила роботу.

Початкові налаштування для невеликого VPS

На плані 2 GB залиште 300–400 MB для ядра та page cache і не давайте сумі обмежень досягати повних 2 GB, оскільки кожен unit може одночасно вийти на пікове споживання. Сервісу, який має найбільше значення, виділіть найбільшу частку, а все непередбачуване навколо нього обмежте.

[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 daemon як жертву. Це може бути різницею між виправленням сервера та його перезавантаженням через панель керування. Це змінює лише вибір жертви ядром. Тривалість зависання не скорочується.

Контейнери працюють у власних cgroups, які створює container runtime, а не ваші unit files, тому обмеження для docker.service не стає обмеженням для одного контейнера. Еквіваленти MemoryMax= і CPUQuota= для окремого контейнера описано в розділі налаштування обмежень пам’яті та CPU у Docker Compose.

FAQ

Чому VPS завис замість завершення некерованого процесу?

Тому що ядро оцінює прогрес за тим, чи повертає reclaim сторінки, а не за тривалістю цієї операції. Коли пам’яті недостатньо, воно витісняє page cache, зокрема сторінки виконуваних програм, а потім зчитує їх назад під час виконання наступної інструкції. Усі операції очікують на сховище, але жоден запит на виділення пам’яті формально не завершується помилкою, тому OOM killer не запускається. Під час цього перевіряйте /proc/pressure/memory: значення full avg10 понад 40 означає, що більш ніж 40% останніх десяти секунд усі не-idle завдання одночасно очікували на пам’ять. Userspace daemon, наприклад earlyoom, завершує процеси до того, як система досягне такого стану.

У чому різниця між MemoryHigh і MemoryMax?

MemoryHigh= — це м’яке обмеження, яке сповільнює роботу. Ядро агресивно звільняє пам’ять unit і сповільнює подальше її виділення, але використання може перевищити це значення, і жоден процес не завершується. MemoryMax= — це жорстке обмеження: якщо в його межах неможливо задовольнити запит на виділення пам’яті, OOM killer запускається всередині власного cgroup цього unit. У результаті завершується процес, який спричинив проблему, а не найбільший процес у системі. Встановіть MemoryHigh= нижче за MemoryMax= і використовуйте проміжок між ними як зону попередження.

Як визначити, який сервіс завершив OOM killer?

Виконайте journalctl -k --grep "Killed process" --since "2 hours ago". Рядок, що починається з Memory cgroup out of memory, означає, що один unit досяг власного MemoryMax=, а звичайний Out of memory означає, що в системі загалом закінчилася пам’ять. Потім виконайте journalctl -u <unit> -n 50 і знайдіть Failed with result 'oom-kill'. Якщо /var/log/journal відсутній на сервері, журнал зберігався в RAM, тому після перезавантаження ці дані було втрачено. Створіть цей каталог до наступного інциденту.

Чи потрібно додавати swap до невеликого VPS?

Невеликий swap file допомагає для неактивних сторінок, які виділяються один раз і більше не використовуються. Для некерованого процесу він не допомагає: завершення процесу відкладається, а короткий збій перетворюється на тривале зависання, під час якого ви не можете увійти в систему та виправити проблему. Використовуйте помірний обсяг swap і встановіть MemorySwapMax=0 для unit, якими можна пожертвувати. Тоді вони швидко досягатимуть свого ліміту і, якщо встановлено Restart=on-failure, самостійно відновлюватимуться, а важливі сервіси зберігатимуть доступний їм swap.

Чи можна обмежити команду без написання unit file?

Так. sudo systemd-run --scope -p MemoryMax=1G -p CPUQuota=50% ./script.sh запускає команду у вашому терміналі всередині transient scope із заданими обмеженнями. Після завершення команди ці обмеження зникають. Після -p доступна кожна властивість із systemd.resource-control, тому там також працюють MemorySwapMax=, TasksMax= і CPUWeight=. Видаліть --scope і додайте --unit=name, щоб запустити завдання у фоні, а його вивід записувати до журналу.

Чи була ця стаття корисною?