Как выбрать Type в systemd для корректной работы службы
Юнит systemd показывает статус active, но демон завершился? Узнайте, как правильно настроить параметры simple, forking, notify и oneshot, чтобы избежать ошибок при отслеживании PID.
Почему systemd сообщает, что юнит активен, хотя процесс завершился
При использовании стандартных ExitType=main и RemainAfterExit=no юнит службы systemd остается в состоянии active, пока жив процесс, который systemd считает основным. Параметр Type= в секции [Service] определяет, какой именно это процесс. Если выбрать неверное значение, systemd будет отслеживать оболочку-обертку или кратковременный родительский процесс, в то время как нужный вам демон внутри того же юнита завершится. Юнит сообщает корректные данные о процессе, который ему было поручено отслеживать.
Изменение политики перезапуска здесь не поможет. Restart= реагирует на завершение процессов и сбои, такие как таймауты, но не обнаруживает завершение фонового демона, если основной PID (идентификатор процесса) принадлежит другому работающему процессу. Сначала исправьте Type=. То, что systemd делает после фактического завершения основного процесса, — это отдельное решение, описанное в руководстве по Restart= и RestartSec=.
За что отвечает параметр Type=
Каждое значение Type= одновременно определяет два аспекта. Когда systemd считает юнит запущенным и какой процесс является основным.
Первый аспект управляет порядком запуска. Юнит, который ссылается на ваш в After=, ожидает, пока systemd не пометит ваш юнит как запущенный. Если Type= сообщает о готовности слишком рано, зависимые юниты могут начать работу до того, как ваш сервис будет готов принимать запросы.
Второй аспект управляет мониторингом. systemd помещает все процессы, порожденные юнитом, в cgroup (control group) — механизм ядра, который объединяет процессы для совместного ограничения ресурсов и завершения. Именно через cgroup работает systemctl stop: KillMode= по умолчанию имеет значение control-group, поэтому при остановке юнита сигнал посылается всем процессам внутри группы. Основной PID (main PID) имеет более узкое значение. При стандартных ExitType=main и RemainAfterExit=no это единственный процесс, завершение которого считается остановкой юнита, а код выхода определяет результат работы юнита. Путаница часто возникает из-за того, что cgroup ошибочно воспринимают как основной PID.
Тип simple сообщает о запуске до выполнения бинарного файла
Type=simple является значением по умолчанию, если задано ExecStart=, отсутствуют Type= и BusName=, а юнит не использует учетные данные. Юнит, который загружает учетные данные, например через LoadCredential=, получает подразумеваемый Type=exec. В режиме simple systemd создает процесс, сразу считает юнит запущенным и рассматривает этот процесс как основной PID. Последующие юниты начинают работу немедленно, еще до того, как бинарный файл сервиса был выполнен.
Эта последняя деталь объясняет распространенную неожиданность. Опечатка в пути ExecStart= по-прежнему приводит к успешному завершению задачи запуска, а ошибка возникает чуть позже, когда выполнение не удается. systemd фиксирует этот случай с кодом завершения 203, который в его собственной таблице называется EXIT_EXEC и определяется как ошибка выполнения процесса. Таким образом, успешное завершение systemctl start без ошибок не доказывает, что ваш бинарный файл существует.
Используйте simple для программы, которая остается на переднем плане и никогда не переводит себя в фоновый режим. Это относится к большинству современных демонов и почти ко всему, что вы пишете самостоятельно.
Тип Type=exec ожидает фактического запуска программы
Type=exec — это simple с одним дополнительным шагом. systemd считает юнит запущенным только после того, как успешно завершились и fork, и выполнение бинарного файла. Отсутствие исполняемого файла или User=, который невозможно разрешить, теперь приводит к сбою самой задачи запуска, вместо того чтобы сообщать об успехе и тихо завершаться с ошибкой чуть позже.
Type=exec появился в основной ветке systemd 240, но бэкпорты в дистрибутивах поддерживают его и в более старых версиях: RHEL 8 добавил его в systemd-239-15.el8. В поддерживаемых старых релизах его может не быть: Ubuntu 18.04 остается на поддержке ESM до апреля 2028 года, и в руководстве к её systemd 237 тип exec не указан как поддерживаемый. Ubuntu 24.04 поставляется с systemd 255, а Debian 13 — с systemd 257 по состоянию на октябрь 2026 года. Проверьте свою версию с помощью systemctl --version и руководства systemd.service вашего дистрибутива.
Цена этого — один дополнительный шаг синхронизации при запуске. Выигрыш — достоверный статус завершения от systemctl start. Для программ, работающих в foreground, отдавайте предпочтение exec вместо simple.
Type=forking и проблема потери основного PID
Type=forking сообщает systemd, что процесс, указанный в ExecStart=, создаст дочерний процесс (fork), после чего завершится намеренно. systemd ожидает завершения этого первого процесса и только после этого считает юнит запущенным. Оставшийся дочерний процесс и является демоном. Эта привычка осталась со времен SysV, когда после завершения работы init-скрипта никто не контролировал демона, а PID-файл был единственным способом отследить запущенный процесс. Это ограничение лежит в основе причин замены init-скриптов на systemd.
Сложность заключается в идентификации. Процесс, запущенный systemd, завершился, поэтому systemd должен определить, какой из выживших процессов является основным. Установите PIDFile= на файл, в который демон записывает PID (обычно это путь внутри /run), и systemd прочитает PID из него. Если владельцем этого файла является непривилегированный пользователь, systemd дополнительно проверяет, принадлежит ли указанный PID процессу, относящемуся к данному сервису. Таким образом, устаревший или подложный файл, указывающий на несвязанный процесс, будет отклонен, а не принят на веру.
Без PIDFile= применяется GuessMainPID=, значение которого по умолчанию — yes. Автоматическое определение надежно только в том случае, если сервис состоит из одного процесса. В руководстве прямо указано ограничение: попытка угадать PID может привести к неверному результату, если демон состоит из нескольких процессов. Если основной PID не удается определить, обнаружение сбоев и автоматический перезапуск не будут работать надежно. Юнит также может получить основной PID, равный 0, что означает, что systemd не отслеживает ни одного основного процесса, даже если процессы демона все еще работают в cgroup юнита.
Большинство демонов, использующих fork, также имеют параметр для работы в фоновом режиме (foreground). Используйте этот параметр вместе с Type=exec и удалите строку PIDFile=. Меньшее количество компонентов означает меньше способов потерять PID.
Type=oneshot для задач, которые завершаются
Type=oneshot ожидает, что процесс запустится и завершит работу. systemd считает юнит запущенным только после того, как процесс завершился, что делает oneshot подходящим вариантом для всего, чего должны дожидаться другие юниты. Это также подразумеваемое значение по умолчанию, если в юните не указаны ни Type=, ни ExecStart=.
Для oneshot характерны два специфических поведения. Это единственный тип, который принимает более одной строки ExecStart=, и эти строки выполняются последовательно. Тайм-аут запуска для него по умолчанию отключен, поэтому oneshot, который завис, будет ждать бесконечно, если вы не настроите TimeoutStartSec= самостоятельно.
После завершения процесса юнит возвращается в состояние inactive. RemainAfterExit=yes сохраняет его в состоянии active, при этом никакой процесс не выполняется. Это осознанная версия симптома, описанного в начале этой страницы, и она корректна, когда задачей юнита было оставить после себя состояние, а не поддерживать работу чего-либо: загрузка набора правил брандмауэра или запуск стека контейнеров. Это шаблон, лежащий в основе стека Docker Compose, который восстанавливается после перезагрузки, где юнит выполняет команду compose, завершается и остается активным, поскольку запущенные им контейнеры продолжают работать после его выхода. Юнит oneshot также подходит для задач, запускаемых по расписанию, что составляет вторую часть запуска задачи по таймеру systemd вместо cron.
Тип Type=notify позволяет сервису сообщить о своей готовности
Type=notify переносит принятие решения на сторону самого сервиса. systemd удерживает задачу запуска открытой до тех пор, пока процесс не отправит READY=1 через Unix-сокет, путь к которому он получает в переменной окружения NOTIFY_SOCKET. Интерфейс C для этого — sd_notify(3), и многие серверы уже поддерживают его.
Это точный ответ на вопрос «запущен ли сервис». simple и exec сообщают о запуске до того, как сервис прочитал конфигурацию или открыл слушающий сокет, поэтому зависимый юнит может запуститься слишком рано и получить ошибку при первом соединении. notify сообщает о запуске в тот момент, когда сам сервис заявляет о своей готовности.
systemd принимает это сообщение только от главного процесса, что и означает NotifyAccess=main, а Type=notify подразумевает это. Если сообщение поступает от дочернего или вспомогательного процесса, установите NotifyAccess=all. Shell-скрипт может вызвать systemd-notify --ready. При наличии соответствующих прав systemd-notify отправляет сообщение от имени PID своего родителя, поэтому скрипт, являющийся главным процессом, передает NotifyAccess=main; в противном случае он использует собственный PID, и для юнита требуется NotifyAccess=all. По умолчанию systemd ожидает обработки сообщения перед выходом, поэтому не используйте --no-block, который отключает это ожидание. Сервис, который самостоятельно поддерживает этот протокол, работает надежнее.
Стоит знать о двух связанных настройках. Type=notify-reload, доступная начиная с systemd 253, расширяет этот механизм рукопожатия на операции перезагрузки, поэтому systemctl reload возвращает управление только после того, как сервис отчитается о завершении перезагрузки, а не сразу после отправки сигнала. Начиная с systemd 262, выпущенного в сентябре 2026 года, сервис типа notify-reload, который отправляет READY=1, не перехватывая и не блокируя сигнал перезагрузки (SIGHUP, если ReloadSignal= не задает иное), завершается с ошибкой протокола вместо того, чтобы быть принудительно завершенным этим сигналом при первой же перезагрузке. WatchdogSec= требует от уведомляющего сервиса отправлять сообщения о поддержании активности (keep-alive) через определенные интервалы, и systemd считает пропуск такого сообщения сбоем.
Type=dbus и Type=idle
Type=dbus ожидает, пока служба не зарегистрирует имя в D-Bus — шине сообщений, которую системные и десктопные службы используют для взаимодействия друг с другом. Этот тип требует наличия BusName= и становится значением по умолчанию, как только задан параметр BusName=. Используйте его только для служб, которые действительно регистрируют имя в шине.
Type=idle работает аналогично simple, но откладывает запуск программы до тех пор, пока не будут выполнены все поставленные в очередь задачи, с ограничением по времени в пять секунд. Этот тип существует для того, чтобы вывод в консоль при загрузке не перемешивался с сообщениями о статусе служб. Он не является инструментом управления порядком запуска и не должен использоваться в обычных службах.
Почему скрипт-обертка приводит к тому, что systemd отслеживает неверный PID
Вот структура, которая вызывает описанную проблему.
[Service]
Type=simple
ExecStart=/opt/app/run.sh#!/bin/bash
export APP_ENV=production
/opt/app/bin/server --config /etc/app.yaml &
/opt/app/bin/exporter --port 9101systemd регистрирует оболочку (shell) в качестве основного PID. Оболочка продолжает работать, пока exporter выполняется на переднем плане. Если server завершается, оболочка этого не замечает, поэтому основной PID остается активным, юнит по-прежнему находится в состоянии active, и Restart= не на что реагировать. Оба процесса все это время остаются в cgroup юнита, поэтому systemctl stop по-прежнему корректно выполняет очистку. Нарушается именно процесс контроля (supervision), а не очистка.
Решение зависит от того, сколько долгоживущих процессов на самом деле содержит юнит.
Если процесс один, замените им оболочку.
#!/bin/bash
export APP_ENV=production
exec /opt/app/bin/server --config /etc/app.yamlexec заменяет оболочку указанной программой и сохраняет тот же PID, поэтому PID, который записал systemd, теперь принадлежит демону. Еще лучше — удалите обертку. Environment= и EnvironmentFile= позволяют передать переменные, а ExecStartPre= — выполнить этап настройки, чтобы systemd мог запускать демон напрямую и знать его PID по определению.
Если процессов два, ни один PID не представляет юнит целиком. Разделите их на два юнита и настройте порядок запуска с помощью After= и Wants=. Один юнит на один процесс — это конфигурация, которую systemd контролирует эффективно, и это единственный способ задать для каждого процесса собственное поведение при перезапуске.
Изменения в ExitType=cgroup
ExitType= был добавлен в systemd 250. Значение по умолчанию — main: юнит считается остановленным, когда завершается основной процесс. При использовании ExitType=cgroup юнит считается запущенным до тех пор, пока жив любой процесс в его cgroup.
[Service]
Type=simple
ExitType=cgroup
ExecStart=/opt/app/launcherЭто решает одну конкретную проблему. Если программа-запускатор (launcher) инициирует основную работу и завершается, то при ExitType=main systemd считает юнит остановленным и убивает оставшиеся процессы. С ExitType=cgroup юнит отслеживает всю группу целиком.
Важно понимать, что именно это не решает. ExitType=cgroup поддерживает активность юнита, пока жив хотя бы один процесс, поэтому юнит, содержащий два демона, останется активным после падения одного из них. Это исправляет ситуацию с запускатором. Это не превращает один юнит в супервизор для нескольких независимых процессов. ExitType=cgroup также нельзя использовать совместно с Type=oneshot.
В cgroup также происходит учет ресурсов, поэтому лимиты, такие как MemoryMax= и CPUQuota=, применяются ко всем процессам, порожденным юнитом, независимо от того, что Type= говорит об основном PID. Эта сторона вопроса описана в ограничении памяти и CPU сервиса средствами systemd.
Как найти процесс, за которым на самом деле следит systemd
Выполняйте эти действия последовательно для юнита, который вы отлаживаете. Сначала изучите файлы юнитов, затем посмотрите, что отслеживает systemd, и сравните это с таблицей процессов.
systemctl cat app.service
systemctl show -p Type,ExitType,GuessMainPID,PIDFile,MainPID,RemainAfterExit app.servicesystemctl cat выводит содержимое файла юнита вместе со всеми применяемыми к нему drop-in файлами с диска; они могут отличаться от того, что загрузил systemd, если файлы были изменены без daemon-reload. systemctl show выводит эффективные значения параметров, включая те, что установлены по умолчанию и не были прописаны вами явно. Перед тем как продолжить, обратите внимание на значение MainPID.
systemd-cgls --unit=app.service
ps -o pid,ppid,stat,etime,args -p "$(systemctl show -p MainPID --value app.service)"systemd-cgls перечисляет все процессы в cgroup юнита. Строка ps описывает единственный процесс, который контролирует systemd. Изучите их вместе. Значение MainPID, равное 0, означает, что systemd не отслеживает основной процесс, даже если systemd-cgls всё ещё показывает процессы в cgroup юнита. Если MainPID указывает на оболочку (shell), в то время как в cgroup находится ваш демон, это случай с использованием обёртки (wrapper), описанный выше. Если в cgroup процессов больше, чем вы ожидали, значит, задействован лаунчер или демон, использующий fork.
systemctl status app.service
journalctl -u app.service -bsystemctl status выводит строку состояния вместе с деревом cgroup, поэтому часто отвечает на оба вопроса сразу. journalctl -u с ограничением текущей загрузки через -b показывает события запуска и остановки, зафиксированные systemd для этого юнита, вместе с кодами завершения. Если демон пишет в собственный лог-файл, а не в journal, прочитайте и этот файл, так как systemd может записать только то, что дошло до него.
При изменении Type= выполните перезагрузку конфигурации и перезапуск сервиса.
systemd-analyze verify /etc/systemd/system/app.service
sudo systemctl daemon-reload
sudo systemctl restart app.servicesystemd-analyze verify анализирует файл и сообщает о настройках, которые он не может принять. daemon-reload заставляет systemd повторно считать файлы юнитов с диска. Изменение Type= не применяется к уже запущенному юниту, поэтому перезапуск обязателен, а не опционален.
Затем протестируйте изменения. Возьмите PID процесса, который вас интересует, из systemd-cgls и завершите его. Сразу после этого выполните systemctl is-active app.service. При использовании ExitType=main и RemainAfterExit=no завершение основного процесса прекращает работу текущего экземпляра, хотя политика перезапуска (restart policy) может вернуть его до того, как вы успеете проверить статус. Если сервис остаётся активным без перезапуска, проверьте, не следит ли systemd за чем-то другим или не использует ли юнит ExitType=cgroup или RemainAfterExit=yes.
Какой тип службы systemd (Type=) следует использовать
- Программа, которая остается в основном (foreground) режиме:
Type=exec. - Программа, поддерживающая уведомление о готовности:
Type=notify, а такжеnotify-reload, если она подтверждает и перезагрузки. - Демон, который принудительно переходит в фоновый режим:
Type=forkingсPIDFile=или его переключатель для работы в основном режиме сType=exec. - Скрипт, который выполняет работу и завершается:
Type=oneshot, плюсRemainAfterExit=yes, если целью было сохранение состояния. - Запускающий процесс, который завершается, пока его дочерние процессы продолжают работу:
Type=simpleсExitType=cgroup.
Если вы не уверены, какой тип требуется стороннему демону, сначала прочитайте его упакованный unit-файл. Выполнение systemctl cat для юнита, предоставленного дистрибутивом, покажет выбранный в пакете параметр Type= вместе с локальными переопределениями.
FAQ
Почему мой юнит systemd остается активным, когда процесс завершился?
При использовании настроек по умолчанию ExitType=main и RemainAfterExit=no это происходит, если процесс, который systemd считает основным, все еще жив. В этих условиях systemd отслеживает один основной PID для сервиса, выбранный согласно Type=. Частая причина — использование скрипта-обертки, запущенного через Type=simple: оболочка (shell) становится основным PID, поэтому юнит остается активным, даже если демон, запущенный оболочкой в фоновом режиме, завершился. Выполните systemctl show -p MainPID app.service, затем выведите список cgroup юнита с помощью systemd-cgls --unit=app.service и сравните полученные данные.
В чем разница между Type=simple и Type=exec?
Type=simple считает юнит запущенным сразу после того, как systemd создал процесс, еще до выполнения бинарного файла. Поэтому неверный путь в ExecStart= приведет к успешному отчету о запуске, за которым последует сбой. Type=exec ожидает успешного выполнения процесса, поэтому ошибка будет зафиксирована самим заданием на запуск. Оба типа считают один и тот же процесс основным PID. Параметр Type=exec был добавлен в основной ветке systemd 240, но дистрибутивы могут переносить его в более старые версии, как это сделала RHEL 8 в systemd-239-15.el8.
Нужен ли мне по-прежнему PIDFile= при использовании Type=forking?
Да, если демон записывает такой файл. Без него systemd переходит к GuessMainPID=, что является лишь предположением и надежно работает только для сервисов, которые сводятся к одному процессу. Если предположение неверно или невозможно, обнаружение сбоев и автоматический перезапуск для этого юнита не будут работать надежно. Укажите в PIDFile= точный путь, куда демон записывает файл, обычно это каталог /run.
Когда следует использовать RemainAfterExit=yes?
Когда цель юнита — изменить состояние системы, а не поддерживать работу процесса. Юнит Type=oneshot, который загружает правила брандмауэра или запускает стек контейнеров, завершается сразу после выполнения своей задачи. Без RemainAfterExit=yes юнит переходит из состояния запуска сразу в состояние остановки, поэтому любые действия по очистке ExecStop= выполняются сразу после завершения работы, а не тогда, когда вы решите остановить юнит, и systemctl stop уже нечего будет останавливать. С этим параметром юнит остается активным без запущенных процессов, что и требуется в данном случае.
Требует ли изменение Type= выполнения daemon-reload?
Да, а также перезапуска самого юнита. systemctl daemon-reload заставляет systemd перечитать файлы юнитов на диске, но запущенный экземпляр продолжает использовать Type=, с которыми он был запущен. Выполните sudo systemctl daemon-reload, а затем sudo systemctl restart app.service перед тестированием, иначе вы будете наблюдать за старым поведением системы контроля.