systemd Type=: simple, forking ou notify?
A unidade fica ativa, mas o daemon sumiu? Entenda simple, exec, forking, oneshot e notify no systemd e descubra qual e o PID principal real.
Por que o systemd informa que uma unidade está ativa quando o processo morreu
Com os valores padrão de ExitType=main e RemainAfterExit=no, uma unidade de serviço do systemd permanece active enquanto o único processo que o systemd considera o processo principal estiver ativo, e Type= na seção [Service] determina qual processo é esse. Se escolher o valor errado, o systemd acaba monitorando um wrapper de shell ou um processo pai de curta duração, enquanto o daemon relevante morre dentro da mesma unidade. A unidade informa corretamente o estado do processo que foi configurada para monitorar.
Alterar a política de reinício não resolverá o problema. Restart= reage a encerramentos e falhas de processos, como timeouts, mas não detecta o encerramento de um daemon em segundo plano enquanto o PID principal (identificador do processo) pertence a outro processo que continua em execução. Corrija Type= primeiro. O que o systemd faz depois que o processo principal realmente termina é uma decisão separada, abordada em o guia sobre Restart= e RestartSec=.
O que Type= realmente determina
Cada valor de Type= responde a duas perguntas ao mesmo tempo: quando o systemd pode considerar esta unidade iniciada e qual é o processo principal.
A primeira resposta controla a ordem de inicialização. Uma unidade que declare a sua em After= espera até o systemd considerar a sua iniciada. Um Type= que informe "started" demasiado cedo permite que as unidades dependentes sejam executadas antes de o seu serviço poder responder.
A segunda resposta controla a supervisão. O systemd coloca cada processo criado por uma unidade num cgroup (grupo de controlo), uma funcionalidade do kernel que agrupa processos para que possam ser limitados e terminados em conjunto. É através do cgroup que systemctl stop faz a limpeza: KillMode= assume control-group por predefinição, pelo que parar uma unidade envia um sinal a todos os processos que estão dentro dela. O PID principal tem um âmbito mais restrito. Com ExitType=main e RemainAfterExit=no predefinidos, é o único processo cuja saída termina a unidade e cujo estado de saída contribui para o resultado da unidade. A confusão começa quando o cgroup é interpretado como se fosse o PID principal.
Type=simple indica que o serviço foi iniciado antes de o binário ser executado
Type=simple é o valor predefinido quando ExecStart= está definido, Type= e BusName= não estão presentes e a unidade não usa credenciais. Uma unidade que carrega credenciais, por exemplo com LoadCredential=, recebe implicitamente Type=exec. Com simple, o systemd cria o processo, considera a unidade iniciada imediatamente e trata esse processo como o PID principal. As unidades dependentes iniciam logo, antes de o binário do serviço sequer ser executado.
Este último detalhe explica uma surpresa comum. Um erro de digitação no caminho ExecStart= ainda produz uma tarefa de arranque bem-sucedida, e a falha ocorre instantes depois, quando a execução falha. O systemd regista esse caso com o código de saída 203, que a sua própria tabela designa por EXIT_EXEC e define como uma falha na execução efetiva do processo. Por isso, systemctl start terminar sem erro não prova que o seu binário exista.
Use simple para um programa que permanece em primeiro plano e nunca passa a executar em segundo plano. Isto aplica-se à maioria dos daemons modernos e a praticamente tudo o que escrever por conta própria.
Type=exec aguarda o arranque efetivo do programa
Type=exec é simple com mais um passo. O systemd considera a unidade iniciada apenas depois de o fork e a execução do binário terem sido concluídos com sucesso. Um binário em falta ou um User= que não possa ser resolvido faz agora falhar o próprio job de arranque, em vez de reportar sucesso e falhar silenciosamente um momento depois.
Type=exec foi introduzido a montante no systemd 240, mas os backports das distribuições permitem utilizá-lo em versões mais antigas: o RHEL 8 adicionou-o em systemd-239-15.el8. Mesmo versões antigas suportadas podem não o incluir: o Ubuntu 18.04 permanece sob ESM até abril de 2028, e o manual do systemd 237 não lista exec como tipo suportado. O Ubuntu 24.04 inclui o systemd 255 e o Debian 13 inclui o systemd 257, à data de outubro de 2026. Consulte a sua versão com systemctl --version e o manual systemd.service da distribuição.
O custo é mais um passo de sincronização durante o arranque. O benefício é um estado de saída fiável de systemctl start. Para um programa em primeiro plano, prefira exec a simple.
Type=forking e como o PID principal se perde
Type=forking informa ao systemd que o processo em ExecStart= vai criar um processo filho e sair de propósito. O systemd espera que esse primeiro processo termine e só depois considera a unidade iniciada. O processo filho que fica em execução é o daemon. Esse comportamento vem da era do SysV, quando nenhum componente supervisionava um daemon depois de o script de inicialização terminar e um ficheiro PID era o único registo do que estava em execução. Essa limitação está no centro de por que o systemd substituiu os scripts de inicialização.
A dificuldade está na identidade. O processo que o systemd iniciou já terminou, por isso o systemd precisa de determinar qual processo sobrevivente é o principal. Defina PIDFile= como o ficheiro que o daemon escreve, normalmente um caminho sob /run, e o systemd lê o PID a partir dele. Quando esse ficheiro pertence a um utilizador sem privilégios, o systemd também verifica se o PID indicado corresponde a um processo que já pertence a este serviço. Assim, um ficheiro obsoleto ou criado para apontar para um processo não relacionado é rejeitado, em vez de ser considerado fiável.
Sem PIDFile=, GuessMainPID= aplica-se e o valor predefinido é yes. A inferência só é fiável quando o serviço estabiliza num único processo. O manual indica claramente o limite: a inferência pode chegar a uma conclusão errada se o daemon tiver mais de um processo. Se não for possível determinar o PID principal, a deteção de falhas e o reinício automático não funcionarão de forma fiável. Uma unidade também pode ficar com um PID principal igual a 0. Isto significa que o systemd não está a acompanhar nenhum processo principal, mesmo que os processos do daemon continuem em execução no cgroup da unidade.
A maioria dos daemons que criam processos filhos também tem uma opção para permanecer em primeiro plano. Use essa opção com Type=exec e elimine a linha PIDFile=. Menos componentes significam menos formas de perder o PID.
Type=oneshot para trabalhos que terminam
Type=oneshot espera que o processo seja executado e termine. O systemd considera a unidade iniciada apenas depois de o processo terminar, o que faz de oneshot o formato adequado para qualquer situação em que outra unidade tenha de esperar por ele. Esse também é o padrão implícito quando uma unidade não especifica Type= nem ExecStart=.
Dois comportamentos são específicos de oneshot. É o único tipo que aceita mais de uma linha ExecStart=, e essas linhas são executadas pela ordem em que aparecem. O tempo limite de arranque também fica desativado por predefinição. Por isso, um oneshot que bloqueie espera indefinidamente, a menos que defina TimeoutStartSec= manualmente.
Depois de o processo terminar, a unidade volta ao estado inativo. RemainAfterExit=yes mantém-na active sem qualquer processo em execução. Esta é a versão deliberada do sintoma descrito no início desta página. É o comportamento correto quando a função da unidade é deixar um estado configurado, em vez de manter algo em execução: carregar um conjunto de regras de firewall ou iniciar uma stack de contentores. Este é o padrão usado em uma stack do Docker Compose que volta a arrancar depois de um reboot, em que a unidade executa o comando compose, termina e permanece ativa porque os contentores que iniciou continuam a executar-se depois dela. Uma unidade oneshot também é adequada para trabalho acionado por uma agenda, que é a outra parte de executar um trabalho com um temporizador do systemd em vez do cron.
Type=notify permite ao serviço indicar quando está pronto
Type=notify transfere a decisão para o serviço. O systemd mantém o job de arranque aberto até o processo enviar READY=1 através de um socket Unix cujo caminho recebe na variável de ambiente NOTIFY_SOCKET. A interface C é sd_notify(3), e muitos servidores já a suportam.
Esta é a resposta correta à pergunta «foi iniciado?». simple e exec indicam que o serviço foi iniciado antes de este ler a configuração ou abrir o socket de escuta. Assim, uma unidade dependente pode arrancar demasiado cedo e falhar a primeira ligação. notify indica que o serviço foi iniciado no momento em que o próprio serviço informa que está pronto.
O systemd aceita essa mensagem apenas do processo principal, que é o significado de NotifyAccess=main, e Type=notify implica esse comportamento. Se a mensagem vier de um processo filho ou auxiliar, defina NotifyAccess=all. Um script de shell pode chamar systemd-notify --ready. Quando tem as permissões necessárias, systemd-notify envia a mensagem usando o PID do processo pai. Assim, um script que seja o próprio processo principal passa NotifyAccess=main; caso contrário, recorre ao seu próprio PID e a unidade precisa de NotifyAccess=all. Por predefinição, espera até o systemd processar a mensagem antes de terminar. Por isso, omita --no-block, que desativa essa espera. Um serviço que implemente diretamente o protocolo é mais fiável.
Vale a pena conhecer duas definições relacionadas. Type=notify-reload, disponível desde o systemd 253, estende o mesmo handshake aos reloads. Assim, systemctl reload retorna quando o serviço informa que o reload terminou, em vez de retornar quando o sinal foi enviado. Desde o systemd 262, lançado em setembro de 2026, um serviço notify-reload que envie READY=1 sem capturar nem bloquear o seu sinal de reload (SIGHUP, exceto quando ReloadSignal= indicar outra coisa) falha ao arrancar com um erro de protocolo, em vez de ser terminado por esse sinal no primeiro reload. WatchdogSec= pede a um serviço que envia notificações para enviar uma mensagem de keep-alive num intervalo. O systemd trata o incumprimento desse prazo como uma falha.
Type=dbus e Type=idle
Type=dbus aguarda até que o serviço obtenha um nome no D-Bus, o barramento de mensagens usado pelos serviços do sistema e do ambiente de trabalho para comunicarem entre si. Requer BusName= e torna-se o padrão assim que BusName= é definido. Use-o apenas num serviço que realmente registe um nome no barramento.
Type=idle comporta-se como simple, mas adia a execução do programa até que os trabalhos em fila sejam enviados, com um limite de cinco segundos. Existe para impedir que a saída da consola durante o arranque se misture com as mensagens de estado. Não é uma ferramenta de ordenação e não deve ser usado num serviço normal.
Por que um script wrapper deixa o systemd associado ao PID errado
Este é o formato que produz o sintoma original.
[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 9101O systemd regista o shell como PID principal. O shell permanece ativo enquanto exporter é executado em primeiro plano. Se server terminar, o shell não percebe, portanto o PID principal continua ativo, a unidade continua active e Restart= não tem nada sobre o que atuar. Ambos os processos permanecem no cgroup da unidade durante todo o tempo, portanto systemctl stop continua a fazer a limpeza corretamente. O que falhou foi a supervisão, não a limpeza.
A correção depende de quantos processos de longa duração a unidade realmente tem.
Se houver um, substitua o shell por ele.
#!/bin/bash
export APP_ENV=production
exec /opt/app/bin/server --config /etc/app.yamlexec substitui o shell pelo programa indicado e mantém o mesmo PID, portanto o PID que o systemd registou passa a pertencer ao daemon. Melhor ainda, remova o wrapper. Environment= e EnvironmentFile= transportam as variáveis, e ExecStartPre= executa a etapa de configuração, portanto o systemd pode iniciar o daemon diretamente e conhecer o respetivo PID desde o início.
Se houver dois, nenhum PID único representa a unidade. Divida-os em duas unidades e ordene-as com After= e Wants=. Uma unidade por processo é a organização que o systemd supervisiona melhor, e é a única forma de cada processo ter o seu próprio comportamento de reinício.
O que ExitType=cgroup altera
ExitType= foi adicionado no systemd 250. O valor padrão é main: a unidade é considerada parada quando o processo principal termina. Com ExitType=cgroup, a unidade é considerada em execução enquanto houver qualquer processo ativo no respetivo cgroup.
[Service]
Type=simple
ExitType=cgroup
ExecStart=/opt/app/launcherIsto resolve um problema específico. Um launcher que inicia o trabalho real e depois termina faria, com ExitType=main, o systemd considerar a unidade parada e terminar os processos sobreviventes. Com ExitType=cgroup, a unidade acompanha o grupo inteiro.
É importante entender o que isto não resolve. ExitType=cgroup mantém uma unidade ativa enquanto pelo menos um processo estiver em execução. Por isso, uma unidade que mantém dois daemons continua ativa depois de um deles terminar. Isto corrige o caso do launcher. Não transforma uma unidade num supervisor de vários processos independentes. ExitType=cgroup também não pode ser combinado com Type=oneshot.
O cgroup também recebe os dados de contabilização de recursos. Por isso, limites como MemoryMax= e CPUQuota= aplicam-se a todos os processos criados pela unidade, independentemente do que Type= indicar sobre o PID principal. Esse aspeto é abordado em limitar a memória e a CPU de um serviço com systemd.
Como descobrir qual processo o systemd está realmente a monitorizar
Execute estes passos na unidade que está a depurar, pela ordem indicada. Leia os ficheiros da unidade, depois consulte o que o systemd monitoriza e, por fim, compare com a tabela de processos.
systemctl cat app.service
systemctl show -p Type,ExitType,GuessMainPID,PIDFile,MainPID,RemainAfterExit app.servicesystemctl cat apresenta o ficheiro da unidade juntamente com todos os drop-ins aplicáveis a partir do disco. Estes podem ser diferentes do que o systemd carregou se os ficheiros tiverem sido alterados sem um daemon-reload. systemctl show apresenta os valores efetivos, incluindo as predefinições que nunca definiu explicitamente. Anote o valor de MainPID antes de prosseguir.
systemd-cgls --unit=app.service
ps -o pid,ppid,stat,etime,args -p "$(systemctl show -p MainPID --value app.service)"systemd-cgls lista todos os processos no cgroup da unidade. A linha ps descreve o único processo que o systemd supervisiona. Leia ambos em conjunto. Um MainPID igual a 0 significa que o systemd não está a monitorizar nenhum processo principal, mesmo que systemd-cgls continue a listar processos no cgroup da unidade. Um MainPID que corresponda a uma shell, enquanto o cgroup também contém o seu daemon, é o caso de um wrapper descrito acima. Um cgroup com mais processos do que esperava indica a presença de um launcher ou de um daemon que faz fork.
systemctl status app.service
journalctl -u app.service -bsystemctl status apresenta a linha de estado e a árvore do cgroup em conjunto, pelo que muitas vezes responde às duas perguntas de uma só vez. journalctl -u limitado a este boot com -b mostra os eventos de arranque e paragem que o systemd registou para a unidade, incluindo os códigos de saída observados. Se o daemon escrever no seu próprio ficheiro de log em vez de usar o journal, leia também esse ficheiro, porque o systemd só consegue registar o que lhe chega.
Quando alterar Type=, faça reload e restart.
systemd-analyze verify /etc/systemd/system/app.service
sudo systemctl daemon-reload
sudo systemctl restart app.servicesystemd-analyze verify analisa o ficheiro e comunica as definições que não consegue aceitar. daemon-reload faz o systemd reler os ficheiros das unidades a partir do disco. Um Type= alterado não é aplicado a uma unidade que já esteja em execução. Por isso, o restart é obrigatório.
Teste depois a alteração. Obtenha o PID do processo que realmente lhe interessa através de systemd-cgls e termine-o. Execute systemctl is-active app.service imediatamente a seguir. Com ExitType=main e RemainAfterExit=no, terminar o processo principal encerra essa instância em execução, embora uma política de reinício possa iniciá-la novamente antes de fazer a verificação. Se continuar ativa sem reiniciar, verifique se o systemd está a monitorizar outra coisa ou se a unidade usa ExitType=cgroup ou RemainAfterExit=yes.
Que Type= de serviço do systemd deve usar
- Um programa que permanece em primeiro plano:
Type=exec. - Um programa que suporta notificações de prontidão:
Type=notify, enotify-reloadse também confirmar recarregamentos. - Um daemon que exige passar para segundo plano:
Type=forkingcomPIDFile=, ou a opção para permanecer em primeiro plano comType=exec. - Um script que executa uma tarefa e termina:
Type=oneshot, além deRemainAfterExit=yesquando o objetivo era deixar o estado persistido. - Um launcher que termina enquanto os processos-filhos continuam em execução:
Type=simplecomExitType=cgroup.
Se não tiver a certeza de qual é necessário para um daemon de terceiros, leia primeiro o ficheiro de unidade fornecido com o pacote. Executar systemctl cat numa unidade fornecida pela distribuição mostra a escolha de Type= definida pelo pacote, juntamente com as substituições locais.
FAQ
Porque é que a minha unidade systemd continua ativa quando o processo terminou?
Com os valores predefinidos ExitType=main e RemainAfterExit=no, isto acontece porque o processo que o systemd considera principal ainda está ativo. Com esses valores, o systemd acompanha um único PID principal por serviço, escolhido de acordo com Type=. Um script wrapper iniciado com Type=simple é a causa habitual: o shell é o PID principal, por isso a unidade continua ativa quando termina um daemon que o shell iniciou em segundo plano. Execute systemctl show -p MainPID app.service, depois liste o cgroup da unidade com systemd-cgls --unit=app.service e compare os dois.
Qual é a diferença entre Type=simple e Type=exec?
Type=simple considera que a unidade iniciou assim que o systemd criou o processo, antes de o binário ser executado. Assim, um caminho incorreto em ExecStart= ainda produz uma tarefa de arranque concluída com sucesso, seguida de uma falha. Type=exec espera até a execução ter sucesso, pelo que essa falha é comunicada pela própria tarefa de arranque. Ambos consideram o mesmo processo como o PID principal. Type=exec foi introduzido no projeto systemd na versão 240, mas as distribuições podem fazer backport para versões mais antigas, como aconteceu no RHEL 8 em systemd-239-15.el8.
Ainda preciso de PIDFile= com Type=forking?
Sim, sempre que o daemon escrever esse ficheiro. Sem ele, o systemd recorre a GuessMainPID=, que é uma estimativa e só é fiável para um serviço que estabilize num único processo. Quando a estimativa está errada ou não é possível, a deteção de falhas e o reinício automático não funcionam de forma fiável para essa unidade. Aponte PIDFile= para o caminho exato onde o daemon escreve o ficheiro, normalmente em /run.
Quando devo usar RemainAfterExit=yes?
Quando o objetivo da unidade era alterar o estado do sistema, e não manter um processo em execução. Uma unidade Type=oneshot que carrega regras de firewall ou inicia uma pilha de contentores termina assim que conclui o trabalho. Sem RemainAfterExit=yes, a unidade passa diretamente de arranque para paragem. Assim, qualquer limpeza ExecStop= é executada logo depois de o trabalho terminar, e não quando decidir parar a unidade, e systemctl stop não tem nada para parar. Com essa opção, a unidade permanece ativa sem processos, que é o comportamento pretendido neste caso.
Alterar Type= requer um daemon-reload?
Sim, e também é necessário reiniciar a unidade. systemctl daemon-reload faz o systemd reler os ficheiros de unidade no disco, mas uma instância em execução mantém o Type= com que iniciou. Execute sudo systemctl daemon-reload e depois sudo systemctl restart app.service antes de testar. Caso contrário, continuará a observar o comportamento de supervisão antigo.