systemd Type=: simple, forking, notify y exec
La unidad aparece activa aunque el daemon terminó. Aprende a elegir Type= entre simple, exec, forking, oneshot y notify, y localizar el PID principal real.
¿Por qué systemd informa de que una unidad está activa aunque el proceso haya terminado?
Con los valores predeterminados ExitType=main y RemainAfterExit=no, una unidad de servicio de systemd permanece active mientras esté activo el único proceso que systemd considera el proceso principal, y Type= en la sección [Service] determina cuál es ese proceso. Si elige un valor incorrecto, systemd termina supervisando un wrapper de shell o un proceso padre de corta duración, mientras el daemon que le interesa termina dentro de la misma unidad. La unidad informa correctamente del estado del proceso que se le indicó supervisar.
Cambiar la política de reinicio no resolverá este problema. Restart= reacciona a las salidas y los fallos de los procesos, como los tiempos de espera, pero no detecta la salida de un daemon en segundo plano si el PID principal (identificador de proceso) pertenece a algo que todavía está en ejecución. Corrija primero Type=. Lo que hace systemd después de que el proceso principal termine realmente es una decisión independiente, que se explica en la guía sobre Restart= y RestartSec=.
Qué decide realmente Type=
Cada valor de Type= responde a dos preguntas a la vez: ¿cuándo puede systemd considerar que esta unidad se ha iniciado y cuál es el proceso principal?
La primera respuesta controla el orden de inicio. Una unidad que menciona la suya en After= espera hasta que systemd considera que la suya se ha iniciado. Un Type= que informa de que se ha «iniciado» demasiado pronto permite que las unidades dependientes se ejecuten antes de que su servicio pueda responderles.
La segunda respuesta controla la supervisión. systemd coloca cada proceso que genera una unidad en un cgroup (grupo de control), una función del kernel que agrupa procesos para poder limitarlos y terminarlos conjuntamente. El cgroup es lo que permite a systemctl stop realizar la limpieza: KillMode= usa control-group de forma predeterminada, por lo que detener una unidad envía una señal a todos los procesos que contiene. El PID principal tiene un alcance más limitado. Con los valores predeterminados ExitType=main y RemainAfterExit=no, es el único proceso cuya terminación finaliza la unidad y cuyo estado de salida contribuye al resultado de la unidad. La confusión empieza cuando se interpreta el cgroup como si fuera el PID principal.
Type=simple informa de que el servicio se inició antes de ejecutar el binario
Type=simple es el valor predeterminado cuando ExecStart= está definido, no existe Type= ni BusName= y la unidad no usa credenciales. Una unidad que carga credenciales, por ejemplo mediante LoadCredential=, obtiene implícitamente Type=exec. Con simple, systemd crea el proceso, considera que la unidad se ha iniciado de inmediato y trata ese proceso como el PID principal. Las unidades posteriores comienzan de inmediato, antes de que se haya ejecutado siquiera el binario del servicio.
Este último detalle explica una sorpresa habitual. Un error tipográfico en la ruta ExecStart= todavía produce un trabajo de inicio correcto. El fallo aparece un momento después, cuando la ejecución falla. systemd registra este caso con el código de salida 203, que su propia tabla denomina EXIT_EXEC y define como un fallo de la ejecución real del proceso. Por tanto, que systemctl start termine sin errores no demuestra que el binario exista.
Use simple para un programa que permanece en primer plano y nunca pasa por sí mismo a segundo plano. Esto cubre la mayoría de los daemons modernos y prácticamente cualquier programa que escriba usted mismo.
Type=exec espera a que el programa se inicie realmente
Type=exec es simple con un paso adicional. systemd considera que la unidad se ha iniciado sólo después de que tanto el fork como la ejecución del binario hayan finalizado correctamente. Si falta el binario o no se puede resolver un User=, el propio trabajo de inicio falla en lugar de informar de que se ha completado correctamente y fallar silenciosamente un momento después.
Type=exec llegó a upstream en systemd 240, pero los backports de las distribuciones lo admiten en versiones anteriores: RHEL 8 lo añadió en systemd-239-15.el8. Algunas versiones antiguas compatibles todavía pueden no incluirlo: Ubuntu 18.04 permanece bajo ESM hasta abril de 2028 y su manual de systemd 237 no incluye exec como tipo compatible. Ubuntu 24.04 incluye systemd 255 y Debian 13 incluye systemd 257, según el estado de octubre de 2026. Compruebe la versión instalada con systemctl --version y consulte el manual de systemd.service de la distribución.
El coste es un paso adicional de sincronización durante el inicio. La ventaja es que systemctl start devuelve un estado de salida fiable. Para un programa en primer plano, prefiera exec a simple.
Type=forking y cómo se pierde el PID principal
Type=forking indica a systemd que el proceso de ExecStart= creará un proceso hijo y después finalizará de forma intencionada. systemd espera a que finalice ese primer proceso y sólo entonces considera iniciada la unidad. El proceso hijo que queda es el daemon. Esta práctica procede de la era de SysV, cuando ningún componente supervisaba un daemon después de que terminara el script de init y un archivo PID era el único registro de lo que estaba en ejecución. Esta limitación está cerca del centro de por qué systemd sustituyó los scripts de init.
La dificultad está en la identidad. El proceso que inició systemd ya no existe, por lo que systemd tiene que determinar cuál de los procesos supervivientes es el principal. Establezca PIDFile= con el archivo que escribe el daemon, normalmente una ruta bajo /run, y systemd leerá el PID desde ese archivo. Cuando el archivo pertenece a un usuario sin privilegios, systemd también comprueba que el PID que contiene corresponda a un proceso que ya pertenece a este servicio. Así, rechaza un archivo obsoleto o manipulado que nombre un proceso no relacionado, en lugar de confiar en él.
Sin PIDFile=, se aplica GuessMainPID= y su valor predeterminado es yes. Esta estimación sólo es fiable cuando el servicio termina funcionando como un único proceso. El manual expone claramente la limitación: la estimación puede llegar a una conclusión incorrecta si el daemon consta de más de un proceso. Si no se puede determinar el PID principal, la detección de fallos y el reinicio automático no funcionarán de forma fiable. Una unidad también puede terminar con un PID principal de 0. Esto significa que systemd no supervisa ningún proceso principal, aunque los procesos del daemon sigan ejecutándose en el cgroup de la unidad.
La mayoría de los daemons que crean procesos hijos también tienen una opción para permanecer en primer plano. Use esa opción con Type=exec y elimine la línea PIDFile=. Menos componentes implican menos formas de perder el PID.
Type=oneshot para tareas que finalizan
Type=oneshot espera que el proceso se ejecute y finalice. systemd marca la unidad como iniciada sólo después de que el proceso haya terminado, por lo que oneshot es la opción adecuada para cualquier tarea que otra unidad deba esperar. También es el valor predeterminado implícito cuando una unidad no especifica Type= ni ExecStart=.
Dos comportamientos son específicos de oneshot. Es el único tipo que admite más de una línea ExecStart=, y esas líneas se ejecutan en orden. Su tiempo de espera de inicio también está deshabilitado de forma predeterminada, por lo que un oneshot que se bloquee esperará indefinidamente a menos que establezca TimeoutStartSec= manualmente.
Después de que el proceso finaliza, la unidad vuelve al estado inactivo. RemainAfterExit=yes la mantiene en estado active sin ningún proceso en ejecución. Esta es la versión deliberada del síntoma descrito al principio de esta página, y es correcta cuando el objetivo de la unidad era dejar un estado preparado en lugar de mantener algo en ejecución: cargar un conjunto de reglas de firewall o iniciar una pila de contenedores. Es el patrón utilizado en una pila de Docker Compose que vuelve a iniciarse después de un reinicio, donde la unidad ejecuta el comando de compose, finaliza y permanece activa porque los contenedores que inició siguen ejecutándose después de que la unidad termina. Una unidad oneshot también es adecuada para tareas activadas según una programación, que es la otra parte de ejecutar una tarea con un temporizador de systemd en lugar de cron.
Type=notify indica cuándo el servicio está listo
Type=notify traslada la decisión al servicio. systemd mantiene abierta la tarea de arranque hasta que el proceso envía READY=1 a través de un socket Unix cuya ruta recibe en la variable de entorno NOTIFY_SOCKET. La interfaz de C es sd_notify(3) y muchos servidores ya la admiten.
Esta es la respuesta exacta a la pregunta «¿está iniciado?». simple y exec indican que el proceso se ha iniciado antes de que el servicio haya leído su configuración o abierto su socket de escucha. Por tanto, una unidad dependiente puede iniciarse demasiado pronto y fallar en su primera conexión. notify indica que el proceso se ha iniciado en el momento en que el propio servicio informa de que está listo.
systemd acepta ese mensaje sólo del proceso principal. Esto es lo que significa NotifyAccess=main y Type=notify lo implica. Si el mensaje procede de un proceso hijo o de un proceso auxiliar, establezca NotifyAccess=all. Un script de shell puede ejecutar systemd-notify --ready. Cuando tiene los privilegios necesarios, systemd-notify envía el mensaje usando el PID de su proceso padre. De este modo, si el script es el proceso principal, pasa NotifyAccess=main. De lo contrario, usa su propio PID y la unidad necesita NotifyAccess=all. De forma predeterminada, espera hasta que systemd procesa el mensaje antes de salir. Por eso debe omitir --no-block, que desactiva esa espera. Un servicio que implementa directamente el protocolo es más fiable.
Conviene conocer otras dos opciones relacionadas. Type=notify-reload, disponible desde systemd 253, extiende el mismo intercambio de confirmación a las recargas. Así, systemctl reload devuelve el control cuando el servicio informa de que la recarga ha terminado, en lugar de hacerlo cuando se envía la señal. Desde systemd 262, publicado en septiembre de 2026, un servicio notify-reload que envía READY=1 sin capturar ni bloquear su señal de recarga (SIGHUP, salvo que ReloadSignal= indique otra cosa) no puede iniciarse y genera un error de protocolo. De este modo, no termina al recibir esa señal durante su primera recarga. WatchdogSec= solicita a un servicio con notificaciones que envíe un mensaje de mantenimiento de actividad a intervalos regulares. systemd considera que no cumplir un plazo es un fallo.
Tipo=dbus y Tipo=idle
Type=dbus espera hasta que el servicio registre un nombre en D-Bus, el bus de mensajes que usan los servicios del sistema y del escritorio para comunicarse entre sí. Requiere BusName= y se convierte en el valor predeterminado en cuanto se establece BusName=. Úselo sólo con un servicio que registre realmente un nombre en el bus.
Type=idle se comporta como simple, pero retrasa la ejecución del programa hasta que se hayan enviado los trabajos en cola, con un límite de cinco segundos. Existe para evitar que la salida de la consola durante el arranque se mezcle con los mensajes de estado. No sirve para establecer el orden de ejecución y no debe usarse en un servicio normal.
Por qué un script envoltorio deja a systemd asociado al PID incorrecto
Esta es la estructura que produce el síntoma 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 9101systemd registra el shell como PID principal. El shell permanece activo mientras exporter se ejecuta en primer plano. Si server termina, el shell no lo detecta. Por tanto, el PID principal sigue activo, la unidad continúa active y Restart= no tiene nada sobre lo que actuar. Ambos procesos permanecen todo el tiempo en el cgroup de la unidad, por lo que systemctl stop sigue haciendo la limpieza correctamente. Lo que se rompió fue la supervisión, no la limpieza.
La solución depende de cuántos procesos de ejecución prolongada tenga realmente la unidad.
Si sólo hay uno, reemplaza el shell por ese proceso.
#!/bin/bash
export APP_ENV=production
exec /opt/app/bin/server --config /etc/app.yamlexec reemplaza el shell por el programa indicado y conserva el mismo PID. Por tanto, el PID que systemd registró ahora pertenece al daemon. Mejor aún, elimina el wrapper. Environment= y EnvironmentFile= proporcionan las variables, y ExecStartPre= ejecuta el paso de preparación. Así, systemd puede iniciar directamente el daemon y conocer su PID desde el principio.
Si hay dos, ningún PID representa la unidad completa. Sepáralos en dos unidades y ordénalas con After= y Wants=. Una unidad por proceso es la estructura que systemd supervisa correctamente. Además, es la única forma de que cada proceso tenga su propio comportamiento de reinicio.
Qué cambia ExitType=cgroup
ExitType= se añadió en systemd 250. El valor predeterminado es main: la unidad se considera detenida cuando termina el proceso principal. Con ExitType=cgroup, la unidad se considera activa mientras haya algún proceso vivo en su cgroup.
[Service]
Type=simple
ExitType=cgroup
ExecStart=/opt/app/launcherEsto resuelve un problema concreto. Un lanzador que inicia el trabajo real y después termina haría que systemd considerase detenida la unidad con ExitType=main y terminase los procesos supervivientes. Con ExitType=cgroup, la unidad sigue el grupo completo.
Es importante entender qué no resuelve. ExitType=cgroup mantiene activa una unidad mientras siga vivo al menos un proceso, por lo que una unidad que contiene dos demonios continúa activa después de que uno de ellos termine. Corrige el caso del lanzador. No convierte una unidad en un supervisor de varios procesos independientes. ExitType=cgroup tampoco se puede combinar con Type=oneshot.
El cgroup también es donde se contabilizan los recursos, por lo que límites como MemoryMax= y CPUQuota= se aplican a todos los procesos que genere la unidad, independientemente de lo que Type= indique sobre el PID principal. Este aspecto se explica en limitar la memoria y la CPU de un servicio con systemd.
Cómo encontrar el proceso que systemd supervisa realmente
Siga este procedimiento en la unidad que está depurando y respete el orden. Lea los archivos de unidad, después consulte lo que supervisa systemd y, por último, compare esos datos con la tabla de procesos.
systemctl cat app.service
systemctl show -p Type,ExitType,GuessMainPID,PIDFile,MainPID,RemainAfterExit app.servicesystemctl cat muestra el archivo de unidad junto con todos los drop-ins que se aplican desde el disco. Estos pueden diferir de lo que systemd cargó si los archivos cambiaron sin ejecutar un daemon-reload. systemctl show muestra los valores efectivos, incluidos los valores predeterminados que nunca escribió. Anote el valor de MainPID antes de continuar.
systemd-cgls --unit=app.service
ps -o pid,ppid,stat,etime,args -p "$(systemctl show -p MainPID --value app.service)"systemd-cgls muestra todos los procesos del cgroup de la unidad. La línea ps describe el único proceso que systemd supervisa. Lea ambos datos conjuntamente. Un MainPID de 0 significa que systemd no supervisa ningún proceso principal, aunque systemd-cgls todavía muestre procesos en el cgroup de la unidad. Un MainPID que resuelve a un shell mientras el cgroup también contiene el daemon corresponde al caso del wrapper descrito anteriormente. Si un cgroup contiene más procesos de los esperados, interviene un launcher o un daemon que crea procesos secundarios.
systemctl status app.service
journalctl -u app.service -bsystemctl status muestra conjuntamente la línea de estado y el árbol del cgroup, por lo que suele responder a ambas preguntas a la vez. journalctl -u limitado a este arranque mediante -b muestra los eventos de inicio y detención que systemd registró para la unidad, junto con los códigos de salida que observó. Si el daemon escribe en su propio archivo de registro en lugar de hacerlo en el journal, lea también ese archivo, porque systemd sólo puede registrar lo que recibe.
Cuando cambie Type=, recargue y reinicie.
systemd-analyze verify /etc/systemd/system/app.service
sudo systemctl daemon-reload
sudo systemctl restart app.servicesystemd-analyze verify analiza el archivo e informa de los ajustes que no puede aceptar. daemon-reload hace que systemd vuelva a leer los archivos de unidad del disco. Un Type= modificado no se aplica a una unidad que ya está en ejecución, por lo que el reinicio es obligatorio.
Después, pruebe el cambio. Obtenga el PID del proceso que realmente le interesa con systemd-cgls y termínelo. Ejecute systemctl is-active app.service inmediatamente después. Con ExitType=main y RemainAfterExit=no, terminar el proceso principal finaliza esa instancia en ejecución, aunque una política de reinicio puede volver a iniciarla antes de que compruebe el resultado. Si permanece activa sin reiniciarse, compruebe si systemd está supervisando otro proceso o si la unidad usa ExitType=cgroup o RemainAfterExit=yes.
Qué valor de Type= de systemd debe usar
- Un programa que permanece en primer plano:
Type=exec. - Un programa que admite notificaciones de disponibilidad:
Type=notify, ynotify-reloadsi también confirma las recargas. - Un daemon que necesita pasar a segundo plano:
Type=forkingconPIDFile=, o su opción para ejecutarse en primer plano conType=exec. - Un script que realiza una tarea y termina:
Type=oneshot, además deRemainAfterExit=yescuando el objetivo era dejar un estado persistente. - Un lanzador que termina mientras sus procesos secundarios siguen ejecutándose:
Type=simpleconExitType=cgroup.
Si no sabe qué valor necesita un daemon de terceros, lea primero el archivo de unidad incluido con el paquete. Ejecutar systemctl cat en una unidad distribuida con el sistema muestra la configuración Type= incluida en el paquete junto con las anulaciones locales.
FAQ
¿Por qué mi unidad de systemd sigue activa cuando el proceso terminó?
Con los valores predeterminados ExitType=main y RemainAfterExit=no, esto ocurre porque el proceso que systemd considera principal sigue activo. Con esos valores, systemd sigue un único PID principal por servicio, elegido según Type=. La causa habitual es un script envoltorio iniciado con Type=simple: el shell es el PID principal, por lo que la unidad sigue activa cuando termina un daemon que el shell inició en segundo plano. Ejecute systemctl show -p MainPID app.service, enumere después el cgroup de la unidad con systemd-cgls --unit=app.service y compare ambos resultados.
¿Cuál es la diferencia entre Type=simple y Type=exec?
Type=simple considera que la unidad se ha iniciado en cuanto systemd crea el proceso, antes de ejecutar el binario. Por tanto, una ruta incorrecta en ExecStart= produce un trabajo de inicio correcto seguido de un fallo. Type=exec espera hasta que la ejecución se haya realizado correctamente, por lo que el propio trabajo de inicio informa del fallo. Ambos tratan el mismo proceso como el PID principal. Type=exec se introdujo en el proyecto upstream en systemd 240, pero las distribuciones pueden incorporarlo mediante backport en versiones anteriores, como hizo RHEL 8 en systemd-239-15.el8.
¿Sigue siendo necesario PIDFile= con Type=forking?
Sí, siempre que el daemon escriba uno. Sin él, systemd recurre a GuessMainPID=, que es una estimación y sólo resulta fiable para un servicio que acaba funcionando como un único proceso. Cuando la estimación es incorrecta o no es posible realizarla, la detección de fallos y el reinicio automático no funcionan de forma fiable para esa unidad. Configure PIDFile= con la ruta exacta en la que escribe el daemon, normalmente bajo /run.
¿Cuándo debo usar RemainAfterExit=yes?
Cuando el objetivo de la unidad era cambiar el estado del sistema en lugar de mantener un proceso en ejecución. Una unidad Type=oneshot que carga reglas del firewall o inicia una pila de contenedores termina en cuanto completa su trabajo. Sin RemainAfterExit=yes, la unidad pasa directamente del inicio a la detención, por lo que cualquier limpieza de ExecStop= se ejecuta justo después de terminar el trabajo, en lugar de cuando se elija detener la unidad, y systemctl stop no tiene nada que detener. Con esta opción, la unidad permanece activa sin procesos, que es el comportamiento previsto en este caso.
¿Es necesario ejecutar daemon-reload al cambiar Type=?
Sí, y también reiniciar la unidad. systemctl daemon-reload hace que systemd vuelva a leer de disco los archivos de unidad, pero una instancia en ejecución conserva el Type= con el que se inició. Ejecute sudo systemctl daemon-reload y después sudo systemctl restart app.service antes de realizar las pruebas; de lo contrario, seguirá observando el comportamiento de supervisión anterior.