Я расскажу, как на сервере с несколькими фоновыми службами я защищаю память от одной прожорливой команды. Защита у меня в два слоя: скрипт на bash по cron раз в минуту и демон на Python, который проверяет память каждую секунду. Ниже код обоих, объяснение, почему я не взял earlyoom или systemd-oomd, и разбор журнала за полтора месяца: 57 снятых процессов, одна серия из 26 снятий за три минуты и зависание, которое сторож памяти не мог увидеть в принципе. Отдельно разберу, почему grep -o с длинным интервалом занял 4 ГБ.
Что за сервер и откуда берутся тяжёлые команды
У сервера 8 ядер, 15,6 ГБ памяти и 8 ГБ подкачки. На нём под отдельными пользователями Linux живут несколько долгоживущих служб. Каждая время от времени запускает разовые тяжёлые команды: собрать видео через ffmpeg, обработать картинку на Python, перевести аудио в текст, поискать по куче файлов. Главные процессы служб должны жить всегда, а разовую команду можно снять, если она мешает остальным.
1 августа одна такая команда, поиск ugrep, раздулась до 7,2 ГБ. Сервер перестал отвечать даже по SSH, и все службы замолчали разом. Встроенный OOM killer ядра в таких случаях не спасает вовремя. Он срабатывает, когда вернуть память уже совсем нечем, а с 8 ГБ подкачки до этого момента система долго перекладывает страницы туда и обратно и ни на что не реагирует.
Первый слой: cron раз в минуту
Первую версию я сделал в тот же день, и она была простой: раз в минуту пройти по процессам нужных пользователей и снять всё, что больше 3 ГБ. Запуск выглядит так:
# /etc/cron.d/mem-watchdog SHELL=/bin/bash PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin * * * * * root flock -n /var/lock/mem-watchdog.lock /usr/local/bin/mem-watchdog.sh >/dev/null 2>&1
flock -n здесь нужен на случай, если прошлый прогон почему-то завис: новый тогда не стартует, и десяток копий сторожа не будет висеть на сервере, где и так плохо с памятью.
Через два дня, 3 августа в 13:20, этот порог снял честную расшифровку длинной записи. Процесс держал 3 053 МБ, а свободной памяти на сервере было полно. Работа пропала зря. Я понял, что снимать стоит тогда, когда процесс большой и одновременно у сервера кончается доступная память. Скрипт переписали, и с тех пор в нём два правила:
USERS="svc1 svc2 svc3 svc4" HARD_MB=5000 # столько не нужно никакой честной команде PRESSURE_FREE_MB=900 # ниже этого сервер начинает задыхаться PRESSURE_PROC_MB=1500 # кого снимать под давлением free_mb=$(free -m | awk 'NR==2{print $7}') for u in $USERS; do keep=$(pgrep -u "$u" -f -- '--main-loop' | tr '\n' '|') keep="${keep}$(pgrep -u "$u" -f 'worker\.js' | tr '\n' '|')0" while read -r pid rss cmd; do echo "$keep" | tr '|' '\n' | grep -qx "$pid" && continue mb=$(( rss / 1024 )) if [ "$mb" -ge "$HARD_MB" ]; then why="перевалил за ${HARD_MB} МБ" elif [ "$free_mb" -lt "$PRESSURE_FREE_MB" ] && [ "$mb" -ge "$PRESSURE_PROC_MB" ]; then why="свободно всего ${free_mb} МБ, а он держит ${mb} МБ" else continue fi kill -9 "$pid" log "$u: снял процесс $pid – $why. Команда: $(echo "$cmd" | cut -c1-120)" done < <(ps -u "$u" -o pid=,rss=,args= --sort=-rss | head -5) done
log – маленькая функция, которая дописывает строку с датой в /var/log/mem-watchdog.log. Отправку сообщения мне в Telegram, не чаще раза в час на пользователя, я из выдержки убрал. Пяти верхних процессов по RSS хватает с запасом, тяжёлая команда всегда оказывается среди них.
Седьмая колонка free -m – available, её значение берётся из MemAvailable в /proc/meminfo. Это оценка ядра, сколько памяти можно отдать новым программам без подкачки, с учётом кэша, который легко сбросить. Колонка free на сервере с активным диском почти всегда маленькая, и сторож по ней снимал бы процессы при нормальной работе. Описание поля есть в документации ядра к /proc (https://docs.kernel.org/filesystems/proc.html).
Список неприкосновенных процессов собирается по командной строке через pgrep -f. По имени процесса искать нельзя, и я на этом обжёгся. Одна из программ на сервере запускает поиск через свой бинарник под другим именем, и comm у такого процесса с ugrep не совпадает. Слово ugrep видно только в командной строке. Поэтому и снимать, и защищать я теперь только по args.
В этом скрипте есть дыра, и журнал её показал. Свободная память считается один раз до цикла. 5 октября в 07:50:02 под давлением сняты сразу три ffmpeg на 2 494, 2 188 и 1 802 МБ, хотя первого, скорее всего, хватило бы. После снятия первого скрипт не перечитывает память и продолжает работать со старой цифрой 868 МБ. Я это не чинил, потому что к тому времени давлением уже занимался второй слой, а у первого осталась роль жёсткого потолка.
Почему не earlyoom и не systemd-oomd
У главных процессов моих служб выставлен oom_score_adj=-900, чтобы ядро в крайнем случае убивало кого угодно, кроме них. Это значение наследуется всеми потомками (https://man7.org/linux/man-pages/man5/proc_pid_oom_score_adj.5.html), то есть любой ffmpeg или поиск, запущенный службой, тоже получает -900. Получается, что и ядро щадит тяжёлые команды наравне с главными процессами. Правильно было бы сбрасывать значение потомкам при запуске, через choom -n 0 или запуск в отдельном юните. У меня это не сделано: команды запускаются из многих мест, и править каждое я не стал. Это одна из причин, почему жертву у меня выбирает свой сторож.
earlyoom по умолчанию выбирает жертву по oom_score, той же оценке, что и ядро, и с -900 у всех потомков снял бы мелкий посторонний процесс, оставив тяжёлую команду. Регулярки --prefer и --avoid сверяются с именем процесса, а с именем у меня как раз беда, про comm у ugrep я написал выше. Насколько я вижу по журналу изменений, сортировка по RSS (--sort-by-rss) появилась в earlyoom 1.8, а в репозитории Ubuntu 24.04 лежит 1.7. Ещё мне нужны были вещи, которых в нём нет: защита по командной строке, причина снятия в выводе самой команды и сводка вместо потока сообщений. Похожий nohang умеет смотреть на командную строку, но тащить ради этого ещё один пакет с большим конфигом я не захотел.
systemd-oomd работает с cgroup и при давлении убивает группу целиком. Тяжёлая команда и главный процесс службы у меня живут в одной группе, так что вместе с ffmpeg ушла бы и сама служба. Чтобы это заработало правильно, разовые команды надо выносить в отдельные scope через systemd-run --scope, а это правка в каждом месте, где они запускаются.
По-хорошему, если бы сервер был не один или служб было несколько десятков, я бы сделал именно так: каждому пользователю свой slice с MemoryHigh и MemoryMax, тяжёлым командам отдельный scope, и пусть ядро само держит границы. Для одного сервера с четырьмя пользователями демон на 275 строк Python оказался дешевле в поддержке, и все решения в нём видно глазами.
Второй слой: демон, который смотрит каждую секунду
Cron раз в минуту оказался слишком медленным. Журнал это хорошо показывает: тяжёлые ffmpeg демон потом снимал на 9–10 ГБ, а потолок первого слоя 5 ГБ. Процесс успевал проскочить его между двумя запусками cron. 2 октября сервер снова завис целиком, перезагрузка в 15:42, и в 17:12 того же дня заработал демон.
Он висит службой systemd:
# /etc/systemd/system/mem-guard.service [Unit] Description=Сторож памяти After=local-fs.target [Service] ExecStart=/usr/bin/python3 -IS /usr/local/sbin/mem-guard.py Restart=always RestartSec=2 Nice=-10 OOMScoreAdjust=-1000 LimitMEMLOCK=infinity StandardOutput=null [Install] WantedBy=multi-user.target
OOMScoreAdjust=-1000 выводит сторожа из-под удара ядра совсем. LimitMEMLOCK=infinity нужен для того, что демон делает первым делом при старте: вызывает mlockall(MCL_CURRENT | MCL_FUTURE) и запрещает своим страницам уходить в подкачку. Сторож, которого вытеснили в подкачку, при нехватке памяти проснётся как раз тогда, когда уже поздно. -IS запускает Python без пользовательских путей и без site-packages, демону от root ни к чему чужие модули.
Главный цикл короткий:
THRESHOLD_PCT = 10 # 10% от 15,6 ГБ = 1 561 МБ MIN_VICTIM_MB = 500 # снимать то, что меньше, бессмысленно SETTLE = 5.0 # пауза после снятия, чтобы ядро вернуло память while True: flush_kill_summary(a) total, avail = meminfo("/proc/meminfo") limit = total * THRESHOLD_PCT // 100 if avail < limit: acted = act(total, avail, a) time.sleep(SETTLE if acted else 1.0) continue time.sleep(1.0 if avail > 3 * limit else 0.2)
Пока доступной памяти больше трёх порогов, проверка идёт раз в секунду. Ближе к краю демон просыпается пять раз в секунду, а после снятия процесса ждёт 5 секунд, чтобы ядро успело вернуть память и следующий проход не снял лишнего.
Кандидатов демон собирает прямо из /proc, без вызова ps:
PROTECT_COMM = re.compile(r"^(systemd.*|sshd|tmux.*|cron|nginx|rsyslogd|...)$") PROTECT_CMD = re.compile(r"--main-loop|worker\.js|vault\.py|mem-guard\.py") for name in os.listdir("/proc"): if not name.isdigit(): continue pid = int(name) statm = read("/proc/%d/statm" % pid).split() mb = int(statm[1]) * PAGE // (1024 * 1024) # второе поле statm – RSS в страницах if mb < MIN_VICTIM_MB: continue comm = read("/proc/%d/comm" % pid).strip() cmd = read("/proc/%d/cmdline" % pid, True).replace(b"\0", b" ").decode("utf-8", "replace") if PROTECT_COMM.match(comm) or PROTECT_CMD.search(cmd): continue out.append({"pid": pid, "mb": mb, "cmd": cmd[:200], "start": start_time(pid)}) out.sort(key=lambda c: c["mb"], reverse=True)
Жертва выбирается по реально занятой памяти, RSS, без оглядки на oom_score. Защита двойная. Системные службы удобно узнавать по имени, а свои процессы я узнаю по командной строке, потому что comm у них ненадёжен.
Между выбором жертвы и сигналом проходят доли секунды, а между SIGTERM и проверкой, жив ли процесс, до трёх секунд. Если процесс за это время умер сам, его PID может достаться новому. Поэтому start_time читает время старта из /proc/PID/stat (поле 22, starttime), и демон считает процесс живым, только пока совпадают и PID, и время старта. Читать поле надо после последней закрывающей скобки: comm может содержать пробелы и скобки, и простой split() по всей строке съедет. Маленькое окно между проверкой и kill всё равно остаётся. Закрывает его os.pidfd_open и signal.pidfd_send_signal (Python 3.9+, ядро 5.3+), и это следующее, что я поменяю.
Причина снятия в выводе самой команды
Сначала демон снимал процесс молча. 3 октября это вылезло боком: в выводе упавшей команды оставался только обрыв, и по нему нельзя было понять, что случилось. Похожую обработку картинки на 9–10 ГБ сторож снял четыре раза за 14 минут, с 10:52 до 11:06. Каждый раз причину приходилось искать по журналу сторожа. Тогда я стал писать её прямо в поток ошибок снимаемой команды:
fd = os.open("/proc/%d/fd/2" % v["pid"], os.O_WRONLY | os.O_NONBLOCK) os.write(fd, ("\n[mem-guard] снята: rss=%d МБ, доступно %d из %d МБ\n" % (v["mb"], avail, total)).encode("utf-8")) os.close(fd) os.kill(v["pid"], signal.SIGTERM) t0 = time.time() while alive(v) and time.time() - t0 < TERM_WAIT: # TERM_WAIT = 3.0 time.sleep(0.1) if alive(v): os.kill(v["pid"], signal.SIGKILL)
Теперь в логе задачи причина стоит рядом с ошибкой, и разбираться, кто убил команду, по журналу сторожа уже не нужно. Сами повторы тяжёлых команд это не отменяет: 26 октября две одинаковые нарезки видео сторож снял по два раза каждую. С записью в /proc/PID/fd/2 есть тонкость. Если stderr процесса – канал или терминал, всё работает как задумано. Если это обычный файл, открытый без O_APPEND, новый дескриптор начнёт писать с начала файла и затрёт первые строки лога. У меня команды запускаются с выводом в канал, поэтому меня это не задевает, но переносить этот приём бездумно не стоит. Вся запись завёрнута в try, и если что-то не так, процесс всё равно снимается.
5 октября: 26 снятий за три минуты
Через три дня после запуска демона случилась серия, которую я теперь показываю всем, кто хочет «просто убивать тяжёлое». С 07:47:43 до 07:50:32 демон снял 26 процессов ffmpeg. Задача резала файл book.mp3 на куски по 24 секунды и запускала нарезку пачкой, по нескольку ffmpeg сразу. На месте каждого снятого тут же вставал следующий. Доступная память в журнале в эти минуты стоит на нуле:
07:47:55 доступно 0 МБ из 15613 – снял (SIGTERM): svc3, 1874 МБ, pid 998586: ffmpeg -v error -y -ss 170 -t 24 -i book.mp3 ... 07:48:01 доступно 0 МБ из 15613 – снял (SIGTERM): svc3, 2143 МБ, pid 998595: ffmpeg -v error -y -ss 250 -t 24 -i book.mp3 ... 07:48:08 доступно 0 МБ из 15613 – снял (SIGTERM): svc3, 2427 МБ, pid 998596: ffmpeg -v error -y -ss 230 -t 24 -i book.mp3 ...
Почему кусок звука на 24 секунды держал по 2–3 ГБ, я до конца так и не разобрался: задача была разовой, и к этому файлу я больше не возвращался. Сервер те три минуты пережил без перезагрузки, главные процессы служб сторож не тронул. Но мне за это время пришло 26 сообщений, по одному на каждое снятие. В тот же день оповещения переделали: первое уходит сразу, остальные за 10 минут копятся и приходят одной сводкой.
if now - _kill_alert["last"] >= ALERT_GAP: # ALERT_GAP = 600 _kill_alert["last"] = now alert("Память заканчивалась (доступно %d МБ из %d). Снял: %s, %d МБ." % (avail, total, v["user"], v["mb"])) else: _kill_alert["pending"].append((v["user"], v["cmd"]))
Отправка в Telegram идёт в отдельном потоке с таймаутом 15 секунд. Если сеть тормозит, главный цикл сторожа от этого не ждёт.
Сама серия чинится ограничением параллельности в задаче, которая запускает больше ffmpeg сразу, чем влезает в память.
Когда снимать некого
Есть и обратный случай. С вечера 7 октября до часа ночи 8 октября доступная память шесть раз опускалась ниже порога, когда ни один незащищённый процесс не держал 500 МБ. Демон в таком случае никого не трогает и пишет мне: значит, память заняли сами защищённые процессы, и разбираться надо руками. В остальные моменты той же ночи он четыре раза снял скрипт, который запускается от root по расписанию, на 528–619 МБ, и один раз безголовый Chromium на 546 МБ. Каждое такое снятие возвращало полгигабайта и ничего не решало: скрипт занимался обычной работой, и снимать его было не за что. На следующий день его поправили, и в журнал он больше не попадал. Порог в 500 МБ я оставил как есть, но теперь знаю, что у него бывают и такие жертвы.
Место, которое сторож не видит
11 ноября в 21:36 сервер завис снова, и журнал systemd оборвался без всякого выключения. Демон памяти в тот вечер молчал, ни один процесс не раздулся. Весь день /run забивался шифрованными копиями видео, которые ждали выгрузки на Яндекс Диск. /run у меня – это tmpfs на 1,6 ГБ, и когда он заполнился, logind и journald не смогли записать свои файлы. Что именно добило сервер после этого, я по журналу восстановить не смог, он обрывается.
Памяти в тот вечер хватало. Страницы tmpfs учитываются в Shmem и уменьшают MemAvailable, но 1,6 ГБ из 15,6 до порога демона не дотягивают, а в RSS процессов их не видно совсем. Кончился сам раздел, и следить за этим должен другой сторож. Копии перенесли на обычный диск, а в первый слой добавили проверку места и inode в /run:
RUN_PCT=${RUN_ALERT_PCT:-80} read -r run_sp run_in < <(df --output=pcent,ipcent /run | awk 'NR==2{gsub("%","");print $1,$2}') if [ -n "${run_sp:-}" ] && { [ "$run_sp" -ge "$RUN_PCT" ] || [ "${run_in:-0}" -ge "$RUN_PCT" ]; }; then top=$(du -xsh /run/* 2>/dev/null | sort -rh | head -4 | awk '{print $2" – "$1}') log "/run заполнен: место ${run_sp}%, inode ${run_in}%" printf '%s\n' "/run заполнен: место ${run_sp}%, inode ${run_in}%. Больше всего занимают: $top" | alert run-full 2 fi
alert здесь – та же отправка в Telegram: первый аргумент – ключ для подавления повторов, второй – сколько часов молчать по этому ключу после сообщения. Порог можно переопределить через окружение. Проверил так: запустил с RUN_ALERT_PCT=1, и в журнале осталась строка «/run заполнен: место 2%, inode 1%». Inode проверяются отдельно, потому что tmpfs может кончиться по числу файлов раньше, чем по месту, если туда пишут много мелочи.
Что показал журнал
Со 2 октября по 11 ноября демон снял 57 процессов. В 46 случаях хватило SIGTERM, в 11 понадобился SIGKILL через три секунды, и все 11 были ffmpeg. Скорее всего, по SIGTERM он пытается аккуратно закончить выходной файл, а при забитой памяти и подкачке в три секунды не укладывается. Всего ffmpeg среди снятых 42, остальное – обработка картинок и аудио на Python, один проверочный скрипт, один Chromium, тот самый скрипт от root и один grep. Семь раз демон сообщил, что память кончается, а снимать некого.
Журнал первого слоя хранится с 21 сентября, и за это время он снял 15 процессов: 12 по потолку 5 ГБ и 3 по давлению, те самые три ffmpeg 5 октября. Слои друг другу не мешают. 2 ноября в 14:44:00 демон снял ffmpeg на 9 108 МБ, а в 14:45:03 cron снял следующий, который успел перевалить за 5 ГБ.
Отдельно про grep на 4 ГБ
11 ноября в 10:50 демон снял команду вида grep -o 'фраза.\{0,6000\}' файл на 4 115 МБ. До этого такие же выборки дважды снимал первый слой, со 2,5 и 4 тысячами в интервале, оба раза больше 5 ГБ. Задача у них простая: вытащить кусок текста после найденной фразы. Я замерил, как растёт память у GNU grep 3.11 на файле в 2,4 МБ с кириллицей:
$ for n in 100 500 1000; do /usr/bin/time -f "$n %M KB %e s" grep -o "Как.\{0,$n\}" g.txt >/dev/null; done 100 4480 KB 0.01 s 500 42240 KB 1.29 s 1000 157112 KB 9.51 s $ LC_ALL=C /usr/bin/time -f "C 1000 %M KB %e s" grep -o "Как.\{0,1000\}" g.txt >/dev/null C 1000 19712 KB 0.05 s
Память растёт быстрее линейного, примерно квадратично. В боевых случаях уходило даже больше, чем даёт такая прикидка, там были другие файлы, и разбирать разницу я не стал. В локали C та же команда берёт 20 МБ и работает за 0,05 секунды. Только учтите, что точка там означает байт, и 1 000 байт кириллицы – это около 500 букв. Тот же кусок текста на Python через re.finditer и срез строки обошёлся в 16,5 МБ, а grep -oP с тем же интервалом занял 2,9 МБ и при 1 000, и при 6 000. Если вам нужен длинный кусок вокруг совпадения, берите grep -oP, Python или LC_ALL=C, а большие интервалы в grep -o лучше не писать.
Что бы я сделал сразу
С первого дня я бы выносил каждую разовую тяжёлую команду в свой scope через systemd-run с MemoryMax. Тогда половина этой истории решалась бы ядром, а мой сторож остался бы страховкой. И я бы сразу писал причину снятия в вывод команды, чтобы не искать её потом по журналу сторожа.
А ещё я бы с самого начала поставил проверку df на все tmpfs, включая /dev/shm, с порогом и по месту, и по inode.
Как вы защищаете общий сервер от одной прожорливой команды: режете память через cgroup каждой задаче, ставите earlyoom с правилами или пишете что-то своё? И чем ловите случай, когда память съедена, а снимать некого?