Sysadmin

Systemd Avanzado: Creación de Servicios y Reinicio Automático

Systemd Avanzado: Creación de Servicios y Reinicio Automático

Para crear un servicio systemd se escribe un archivo de unidad en /etc/systemd/system/app.service con una línea ExecStart=, se añaden Restart=on-failure y RestartSec= si se quiere que systemd lo reinicie tras un fallo, y después se ejecutan systemctl daemon-reload y systemctl enable --now app. Las dependencias van en la sección [Unit]: After= fija el orden, Requires= o Wants= deciden si la otra unidad se arranca a la vez, y no son intercambiables.

Todo lo que sigue se probó en noviembre de 2026 en Ubuntu 24.04.5 LTS con systemd 255 (255.4-1ubuntu8.18), ejecutándose como PID 1 en un contenedor privilegiado. Las salidas son reales, abreviadas donde aparece «…». Por el camino me encontré con varios comportamientos que la mayoría de las guías explican mal: Restart=on-failure no reinicia un servicio terminado con SIGTERM, los reinicios manuales cuentan para el límite de arranques, systemd-analyze verify sale con 0 aunque Restart= esté mal escrito, y Requires= no detiene el servicio cuando la dependencia se cae.

Servicio systemd en 60 segundos

sudo useradd -r -s /usr/sbin/nologin app          # usuario de sistema dedicado
sudo tee /etc/systemd/system/app.service >/dev/null <<'EOF'
[Unit]
Description=Demo app
After=network-online.target
Wants=network-online.target
StartLimitIntervalSec=60
StartLimitBurst=3

[Service]
Type=exec
User=app
EnvironmentFile=/etc/app.env
ExecStart=/opt/app/app.sh
Restart=on-failure
RestartSec=2

[Install]
WantedBy=multi-user.target
EOF
sudo systemd-analyze verify /etc/systemd/system/app.service   # leer la salida, no solo el código de salida
sudo systemctl daemon-reload                                  # tras cada cambio en el archivo
sudo systemctl enable --now app                               # arrancar ahora y en el boot
systemctl status app                                          # estado, PID principal, últimas líneas de log
journalctl -u app -f                                          # seguir los logs
systemctl show app -p NRestarts                               # cuántos reinicios automáticos hasta ahora

Si el servicio ha terminado en failed tras demasiados reinicios, sudo systemctl reset-failed app pone el contador a cero para poder arrancarlo de nuevo.

Dónde va el archivo de unidad

systemd lee los archivos de unidad desde varios directorios. Los que importan a un administrador:

Directorio Quién escribe ahí Para qué sirve
/usr/lib/systemd/system/ Los paquetes de la distribución No editar nunca: una actualización del paquete lo sobrescribe
/etc/systemd/system/ El administrador Los servicios propios, y los drop-ins que modifican los de los paquetes
/etc/systemd/system/app.service.d/*.conf systemctl edit Modificaciones parciales, aplicadas encima del archivo principal
/run/systemd/system/ systemd y los generadores Unidades en tiempo de ejecución, se pierden al reiniciar

Un archivo en /etc/systemd/system/ con el mismo nombre que uno de /usr/lib/systemd/system/ lo sustituye por completo. Para cambiar un solo ajuste de un servicio de paquete conviene un drop-in (ver la sección sobre systemctl edit más abajo): así se siguen recibiendo las correcciones del paquete en todo lo demás.

El archivo de unidad, sección por sección

La aplicación de prueba es un pequeño script Bash que imprime su entorno y, si CRASH_AFTER está definida, sale con código 3 tras ese número de segundos. Hace las veces de cualquier demonio que se queda en ejecución:

#!/bin/bash
echo "app starting, pid $$, user $(id -un), MODE=${MODE:-unset}"
n=0
while true; do
  sleep 1; n=$((n+1))
  if [ -n "$CRASH_AFTER" ] && [ "$n" -ge "$CRASH_AFTER" ]; then echo "fatal: simulated crash" >&2; exit 3; fi
done

Las tres secciones del archivo de unidad del recuadro anterior tienen funciones distintas:

  • [Unit]: descripción, orden y dependencias (After=, Requires=, Wants=, BindsTo=) y el límite de frecuencia de arranques (StartLimitIntervalSec=, StartLimitBurst=).
  • [Service]: cómo ejecutar el proceso (Type=, ExecStart=, User=, entorno), cuándo reiniciarlo, y las opciones de aislamiento.
  • [Install]: solo la usa systemctl enable. WantedBy=multi-user.target crea el enlace simbólico que arranca el servicio en el boot.

Después de systemctl enable --now app:

Created symlink /etc/systemd/system/multi-user.target.wants/app.service -> /etc/systemd/system/app.service.
* app.service - Demo app
     Loaded: loaded (/etc/systemd/system/app.service; enabled; preset: enabled)
     Active: active (running) since Sun 2026-11-15 08:47:27 UTC; 2s ago
   Main PID: 94 (app.sh)
      Tasks: 2 (limit: 22455)
     Memory: 736.0K ()
…
Nov 15 08:47:27 8ef664ab7da2 systemd[1]: Starting app.service - Demo app...
Nov 15 08:47:27 8ef664ab7da2 systemd[1]: Started app.service - Demo app.
Nov 15 08:47:27 8ef664ab7da2 app.sh[94]: app starting, pid 94, user app, MODE=production

Restart=on-failure: qué salidas provocan realmente un reinicio

Restart= decide si systemd reinicia el servicio cuando su proceso principal termina. El valor por defecto es no. Para ver con exactitud qué hace cada valor arranqué 25 servicios transitorios con systemd-run, uno por cada combinación de valor de Restart= y tipo de salida, cada uno con RestartSec=1, y conté los reinicios a los 5 segundos:

Restart= exit 0 exit 3 SIGKILL SIGTERM SIGSEGV
no no no no no no
on-success sí no no sí no
on-failure no sí sí no sí
on-abnormal no no sí no sí
always sí sí sí sí sí

La columna que hay que mirar es SIGTERM. Para systemd, un proceso que muere por SIGHUP, SIGINT, SIGTERM o SIGPIPE ha salido limpiamente, igual que con código 0, como indica el manual de systemd.service. Con Restart=on-failure, un kill <pid> lanzado por otro proceso o por un script, o la propia aplicación cerrándose al recibir SIGTERM, dejan el servicio parado. Si el servicio tiene que volver pase lo que pase, use Restart=always; si algunos códigos de salida significan «parada intencionada», inclúyalos en RestartPreventExitStatus=.

Los demás casos se comportan como se espera: un fallo (SIGSEGV), el OOM killer (SIGKILL) y un código de salida distinto de cero se reinician todos con on-failure. Un systemctl stop nunca provoca un reinicio, ni siquiera con Restart=always.

«Start request repeated too quickly»: StartLimitIntervalSec y StartLimitBurst

Los reinicios automáticos tienen un límite de frecuencia. Si una unidad se arranca más de StartLimitBurst= veces dentro de StartLimitIntervalSec=, systemd deja de intentarlo y la deja en failed. Los valores por defecto, leídos con systemctl show en una unidad que no define nada:

$ systemctl show db2 -p Restart -p RestartUSec -p StartLimitIntervalUSec -p StartLimitBurst
Restart=no
RestartUSec=100ms
StartLimitIntervalUSec=10s
StartLimitBurst=5

Con el RestartSec por defecto de 100 ms, un servicio que falla al arrancar agota sus cinco intentos en mucho menos de un segundo. Defina siempre RestartSec= junto con Restart=.

Para provocar el límite puse CRASH_AFTER=1 en /etc/app.env y reinicié la unidad del recuadro inicial (StartLimitBurst=3 en 60 segundos, RestartSec=2):

$ journalctl -u app --no-pager
…
Nov 15 08:47:38 8ef664ab7da2 systemd[1]: Started app.service - Demo app.
Nov 15 08:47:39 8ef664ab7da2 app.sh[130]: fatal: simulated crash
Nov 15 08:47:39 8ef664ab7da2 systemd[1]: app.service: Main process exited, code=exited, status=3/NOTIMPLEMENTED
Nov 15 08:47:39 8ef664ab7da2 systemd[1]: app.service: Failed with result 'exit-code'.
Nov 15 08:47:41 8ef664ab7da2 systemd[1]: app.service: Scheduled restart job, restart counter is at 1.
…
Nov 15 08:47:44 8ef664ab7da2 systemd[1]: app.service: Scheduled restart job, restart counter is at 2.
Nov 15 08:47:44 8ef664ab7da2 systemd[1]: app.service: Start request repeated too quickly.
Nov 15 08:47:44 8ef664ab7da2 systemd[1]: app.service: Failed with result 'exit-code'.
Nov 15 08:47:44 8ef664ab7da2 systemd[1]: Failed to start app.service - Demo app.

$ systemctl show app -p NRestarts -p Result -p ActiveState
Result=exit-code
NRestarts=2
ActiveState=failed

Solo dos reinicios automáticos, no tres: el systemctl restart manual de las 08:47:38 contó como primer arranque. Lo mismo pasó más adelante en la prueba, mientras modificaba la unidad y la reiniciaba a mano: tres systemctl restart en un minuto bastaron para obtener Failed with result 'start-limit-hit' en un servicio que no había fallado nunca. Conviene tenerlo en cuenta antes de fijar un burst muy bajo en una unidad que se despliega a menudo.

Una vez alcanzado el límite, también se rechaza un arranque manual, hasta que el intervalo caduque o se ponga el contador a cero:

$ sudo systemctl start app
Job for app.service failed because the control process exited with error code.
See "systemctl status app.service" and "journalctl -xeu app.service" for details.
$ sudo systemctl reset-failed app
$ sudo systemctl start app && systemctl is-active app
active

El mensaje de error habla de un «control process» aunque no se ha arrancado ningún proceso: el motivo real está en el journal, Start request repeated too quickly.

La trampa: StartLimitIntervalSec va en [Unit]

Muchos ejemplos antiguos ponen el límite de frecuencia en [Service]. Esto es lo que hace systemd 255 con él:

$ systemd-analyze verify /etc/systemd/system/sl.service
/etc/systemd/system/sl.service:4: Unknown key name 'StartLimitIntervalSec' in section 'Service', ignoring.
$ echo $?
0
$ systemctl show sl -p StartLimitIntervalUSec -p StartLimitBurst
StartLimitIntervalUSec=10s
StartLimitBurst=10

StartLimitBurst= en [Service] se sigue aceptando por compatibilidad, StartLimitIntervalSec= no: se acaba con un burst de 10 sobre el intervalo por defecto de 10 segundos, una combinación que nadie ha elegido. Las dos opciones van en [Unit], como documenta systemd.unit. StartLimitIntervalSec=0 desactiva el límite por completo.

Espera progresiva: RestartSteps y RestartMaxDelaySec

Desde systemd 254 la espera entre reinicios puede crecer sola, desde RestartSec= hasta RestartMaxDelaySec= en RestartSteps= pasos. Es la herramienta adecuada para un servicio que depende de algo externo (una base de datos, una API remota): al principio reintenta rápido y luego deja de insistir. Prueba con un script que sale con código 3 tras un segundo:

[Unit]
StartLimitIntervalSec=0

[Service]
ExecStart=/opt/t/exit3.sh
Restart=on-failure
RestartSec=1
RestartSteps=4
RestartMaxDelaySec=16
$ journalctl -u backoff -o short-precise | grep "Scheduled restart"
08:55:35.959312 … backoff.service: Scheduled restart job, restart counter is at 1.
08:55:39.209294 … backoff.service: Scheduled restart job, restart counter is at 2.
08:55:44.459913 … backoff.service: Scheduled restart job, restart counter is at 3.
08:55:53.709784 … backoff.service: Scheduled restart job, restart counter is at 4.
08:56:10.961707 … backoff.service: Scheduled restart job, restart counter is at 5.

Restando el segundo que el script se ejecuta cada vez, las esperas son de 2, 4, 8 y 16 segundos: crecimiento exponencial con tope en RestartMaxDelaySec. Fíjese en StartLimitIntervalSec=0: sin él, el límite de frecuencia detendría el ciclo antes de que la espera se alargue.

Type=simple, exec, notify, oneshot

Type= le dice a systemd cuándo considerar arrancado el servicio. Decide cuándo empiezan las unidades ordenadas con After= respecto a la suya, y si systemctl start informa de un error.

Type= «Arrancado» cuando Para qué sirve
simple (por defecto) Justo después del fork, antes de que se ejecute el binario Unidades antiguas; mejor exec
exec Después de que el binario se haya ejecutado con éxito La mayoría de los demonios que se quedan en primer plano
notify Cuando el proceso envía READY=1 mediante sd_notify Demonios que necesitan tiempo para inicializarse (cargar datos, abrir sockets)
oneshot Cuando el proceso termina Scripts de preparación, migraciones, tareas que se ejecutan antes de otros servicios
forking Cuando el proceso padre sale tras demonizarse Demonios antiguos que pasan a segundo plano con un fork; necesita PIDFile=

La diferencia entre simple y exec aparece la primera vez que una ruta está mal. Dos unidades idénticas con ExecStart=/opt/app/missing:

### Type=simple
$ sudo systemctl start tsimple; echo "rc=$?"
rc=0
$ systemctl status tsimple
x tsimple.service
     Active: failed (Result: exit-code) since Sun 2026-11-15 08:49:11 UTC; 1s ago
    Process: 746 ExecStart=/opt/app/missing (code=exited, status=203/EXEC)

### Type=exec
$ sudo systemctl start texec; echo "rc=$?"
Job for texec.service failed because the control process exited with error code.
See "systemctl status texec.service" and "journalctl -xeu texec.service" for details.
rc=1

Con simple el comando de arranque informa de éxito y la unidad falla un instante después: una tarea de Ansible o un script de despliegue seguirían adelante sin darse cuenta. El estado 203/EXEC siempre significa «no se pudo ejecutar el binario»: ruta equivocada, falta el permiso de ejecución, o un script sin shebang.

Type=notify con un script que tarda 3 segundos en estar listo y luego llama a systemd-notify --ready --status="accepting connections": systemctl start volvió a los 3 segundos, y el estado muestra el texto enviado por el servicio:

* nall.service
     Active: active (running) since Sun 2026-11-15 08:49:27 UTC; 58ms ago
   Main PID: 804 (sleep)
     Status: "accepting connections"

Muchas guías dicen que systemd-notify llamado desde un script de shell requiere NotifyAccess=all, porque el mensaje viene de un proceso hijo. En mi prueba con systemd 255 la versión con NotifyAccess=main también arrancó correctamente a los 3 segundos. En versiones más antiguas puede ser distinto: si un servicio notify se queda en activating hasta TimeoutStartSec= (90 segundos por defecto), NotifyAccess= es lo primero que hay que revisar.

Type=oneshot con RemainAfterExit=yes se queda active (exited) cuando el proceso termina, de modo que otras unidades pueden depender de él. Es también el único tipo que acepta varias líneas ExecStart=, ejecutadas en orden:

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/bin/mkdir -p /run/demo
ExecStart=/bin/sh -c "echo prepared > /run/demo/state"

Dependencias: After= frente a Requires= frente a Wants=

Aquí es donde systemd sorprende más a menudo. Orden y requisito son dos ejes distintos:

  • After=db.service fija solo el orden: si las dos unidades se están arrancando, la suya espera a db. No arranca db.
  • Wants=db.service arranca db junto con la suya. Si db falla, la suya arranca igualmente.
  • Requires=db.service arranca db junto con la suya. Si db no logra arrancar, la suya no se arranca; si db se detiene o se reinicia con systemctl, la suya también.
  • BindsTo=db.service es como Requires=, pero la suya se detiene también cuando db muere por su cuenta.

Probé las cuatro con un db.service falso (un oneshot que tarda 3 segundos). Primero, Requires= sin After=:

### Requires= sin After=: arrancan a la vez
08:49:46.871814 … systemd[1]: Started app-noafter.service - app-noafter.
08:49:46.887165 … systemd[1]: Starting db.service - Fake database...

### Requires= + After=: app espera a db
08:49:46.990124 … systemd[1]: Starting db.service - Fake database...
08:49:50.038852 … systemd[1]: Finished db.service - Fake database.
08:49:50.046741 … systemd[1]: Started app-req.service - app-req.

Sin After= la aplicación arrancó antes de que la base de datos empezara siquiera. Requires= y Wants= casi siempre necesitan un After= sobre la misma unidad.

Después, el comportamiento cuando db se detiene o falla:

### systemctl stop db
app-req     inactive      # Requires=: detenida junto con db
app-wants   active        # Wants=: sin cambios

### db no logra arrancar
$ sudo systemctl start app-req
A dependency job for app-req.service failed. See 'journalctl -xe' for details.
$ journalctl -u app-req -n 2
… systemd[1]: Dependency failed for app-req.service - app-req.
… systemd[1]: app-req.service: Job app-req.service/start failed with result 'dependency'.
$ sudo systemctl start app-wants; echo "rc=$?"
rc=0

El caso que casi todas las guías omiten: qué pasa cuando el proceso de la dependencia muere en lugar de detenerse con systemctl. Arranqué r2 (Requires=db2) y b2 (BindsTo=db2), y luego maté db2 con SIGKILL:

$ sudo systemctl kill -s KILL db2
$ systemctl is-active db2 r2 b2
failed
active
inactive

Con Requires= la aplicación sigue funcionando contra una base de datos muerta. Solo BindsTo= la detiene. Use BindsTo= cuando su servicio no tenga sentido sin el otro, y combínelo con Restart= en ambos si quiere que se recuperen juntos.

network-online.target

After=network.target no significa que la red esté activa: solo garantiza que, al apagar, el servicio se detenga antes de que caiga la red. Para esperar a una red configurada se usan After=network-online.target más Wants=network-online.target, como en el ejemplo inicial. Ese target espera a que esté habilitado un servicio de «wait-online» (systemd-networkd-wait-online o NetworkManager-wait-online); si no hay ninguno, se alcanza de inmediato. La página de systemd sobre network-online explica cuándo merece la pena: a menudo es mejor que el servicio gestione una red que todavía no está lista, por ejemplo escuchando en 0.0.0.0 en lugar de en una dirección concreta.

User= y EnvironmentFile=

Ejecute el servicio con un usuario dedicado, creado con useradd -r -s /usr/sbin/nologin app. Si el usuario no existe, el proceso falla con un código de estado específico:

… systemd[1]: e3.service: Main process exited, code=exited, status=217/USER

EnvironmentFile= carga variables desde un archivo CLAVE=valor, una por línea. Tres comportamientos, todos verificados en el contenedor:

  1. Un archivo inexistente bloquea el arranque: Failed to load environment files: No such file or directory, resultado resources. Con un guion delante, EnvironmentFile=-/etc/app.env, un archivo inexistente se ignora.
  2. El archivo lo lee systemd (PID 1, como root) antes de cambiar a User=. Un archivo de root con permisos 600 funciona aunque el servicio se ejecute como app: en mi prueba la variable llegó al proceso, que se ejecutaba como app. Así que los secretos se guardan root:root 600; el usuario del servicio no necesita leerlos.
  3. Las variables de EnvironmentFile= prevalecen sobre las definidas con Environment=, aunque Environment= esté en un drop-in cargado después. Puse Environment=MODE=staging en un override y el proceso siguió imprimiendo MODE=production, el valor del archivo. Para cambiar una variable, cámbiela en el archivo o apunte a un segundo archivo.

Un archivo de entorno modificado tiene efecto en el siguiente systemctl restart app; no hace falta daemon-reload, porque se lee cada vez que arranca el servicio.

systemd-analyze verify: qué detecta y qué deja pasar

systemd-analyze verify comprueba un archivo de unidad sin cargarlo. Le pasé uno con dos erratas y una dependencia inexistente:

$ systemd-analyze verify /etc/systemd/system/broken.service
/etc/systemd/system/broken.service:7: Failed to parse service restart specifier, ignoring: on-falure
/etc/systemd/system/broken.service:8: Unknown key name 'RestartSecs' in section 'Service', ignoring.
broken.service: Failed to create broken.service/start: Unit postgresql.service not found.
$ echo $?
1

Quitando la dependencia inexistente, las erratas siguen ahí pero el código de salida cambia:

$ systemd-analyze verify /etc/systemd/system/broken.service
/etc/systemd/system/broken.service:6: Failed to parse service restart specifier, ignoring: on-falure
/etc/systemd/system/broken.service:7: Unknown key name 'RestartSecs' in section 'Service', ignoring.
$ echo $?
0
$ systemctl show broken -p Restart -p RestartUSec
Restart=no
RestartUSec=100ms

Código de salida 0, y el servicio arranca sin ningún reinicio automático. Una comprobación en un pipeline que solo mire el código de salida deja pasar este archivo. Trate cualquier salida como un error, por ejemplo con test -z "$(systemd-analyze verify app.service 2>&1)".

daemon-reload y systemctl restart: cuándo hace falta cada uno

systemctl restart reinicia el proceso con la configuración que systemd ya tiene en memoria. Si ha editado el archivo de unidad, los nuevos valores no se leen hasta el daemon-reload. Cambié RestartSec=2 a 5 y reinicié sin recargar:

$ sudo systemctl restart app
$ systemctl status app
Warning: The unit file, source configuration file or drop-ins of app.service changed on disk. Run 'systemctl daemon-reload' to reload units.
…
$ systemctl show app -p RestartUSec
RestartUSec=2s
$ sudo systemctl daemon-reload
$ systemctl show app -p RestartUSec
RestartUSec=5s

La regla: tras editar a mano un archivo de unidad o un drop-in, daemon-reload y luego restart. systemctl edit hace la recarga por usted. Un cambio en la configuración de la propia aplicación o en el EnvironmentFile solo necesita restart.

Modificar una unidad con systemctl edit

sudo systemctl edit app abre un editor y guarda lo que escriba en /etc/systemd/system/app.service.d/override.conf. Solo el texto entre las dos líneas de comentario de arriba se convierte en el drop-in; todo lo que hay debajo es el archivo actual, mostrado como referencia y descartado. systemctl edit --full app, en cambio, edita una copia completa de la unidad.

El error clásico es sobrescribir ExecStart= escribiendo sin más la nueva línea:

$ cat /etc/systemd/system/app.service.d/override.conf
[Service]
ExecStart=/opt/app/app.sh --verbose
$ sudo systemctl restart app
Failed to restart app.service: Unit app.service has a bad unit file setting.
$ journalctl -u app -n 1
… app.service: Service has more than one ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.

En un drop-in, los ajustes de tipo lista como ExecStart= se añaden al valor existente. Para sustituirlo, primero se vacía con una asignación en blanco:

[Service]
ExecStart=
ExecStart=/opt/app/app.sh --verbose

Con esta versión el reinicio funciona y systemctl status muestra el drop-in bajo Drop-In: /etc/systemd/system/app.service.d. systemctl cat app imprime el archivo principal seguido de todos los drop-ins, en el orden en que se aplican: es la forma más rápida de ver la configuración que systemd usa de verdad.

Leer los logs con journalctl -u

Todo lo que el servicio escribe en stdout y stderr acaba en el journal, junto con los mensajes de systemd sobre la unidad:

journalctl -u app -b                  # desde el último boot
journalctl -u app --since "-15min"    # últimos 15 minutos
journalctl -u app -f                  # seguir, como tail -f
journalctl -xeu app                   # últimas líneas con explicaciones, como sugiere systemctl
journalctl -u app -p err -o cat       # solo errores, sin prefijo

El último comando tiene truco. En mi prueba journalctl -u app -p err mostraba los mensajes de systemd (Failed to start app.service, el ExecStart rechazado), pero no la línea fatal: simulated crash que el script escribía en stderr. Por defecto stderr se registra con prioridad info, no err. Si la aplicación no usa las prioridades de syslog o sd-journal, filtre por texto, no por prioridad.

Hardening básico y systemd-analyze security

systemd-analyze security puntúa el aislamiento de un servicio de 0 (aislado) a 10 (sin restricciones). La unidad del recuadro «en 60 segundos», que ya se ejecuta con un usuario no root:

$ systemd-analyze security app.service
  NAME                                    DESCRIPTION                                              EXPOSURE
+ User=/DynamicUser=                      Service runs under a static non-root user identity
- NoNewPrivileges=                        Service processes may acquire new privileges                  0.2
- PrivateDevices=                         Service potentially has access to hardware devices            0.2
- ProtectClock=                           Service may write to the hardware clock or system clock       0.2
…
-> Overall exposure level for app.service: 9.2 UNSAFE :-{

Un usuario no root por sí solo no basta. Añadí este drop-in, /etc/systemd/system/app.service.d/hardening.conf:

[Service]
NoNewPrivileges=yes
ProtectSystem=strict
ProtectHome=yes
PrivateTmp=yes
PrivateDevices=yes
ProtectKernelTunables=yes
ProtectKernelModules=yes
ProtectKernelLogs=yes
ProtectControlGroups=yes
ProtectClock=yes
ProtectHostname=yes
RestrictSUIDSGID=yes
RestrictNamespaces=yes
RestrictRealtime=yes
LockPersonality=yes
MemoryDenyWriteExecute=yes
CapabilityBoundingSet=
RestrictAddressFamilies=AF_INET AF_INET6 AF_UNIX
SystemCallFilter=@system-service
SystemCallArchitectures=native
UMask=0077
StateDirectory=app
$ sudo systemctl daemon-reload && sudo systemctl restart app && systemctl is-active app
active
$ systemd-analyze security app.service | tail -1
-> Overall exposure level for app.service: 1.7 OK :-)
$ ls -ld /var/lib/app
drwxr-xr-x 2 app app 4096 Nov 15 08:55 /var/lib/app

De 9.2 a 1.7, con el servicio todavía en marcha. ProtectSystem=strict deja todo el sistema de archivos en solo lectura para el servicio; StateDirectory=app crea /var/lib/app, propiedad del usuario del servicio, y la deja escribible. Probado con una unidad transitoria con esas dos mismas opciones:

touch: cannot touch '/etc/x': Read-only file system
wrote /var/lib/app/ok

En una aplicación real, añada las opciones de una en una y revise el journal tras cada reinicio: MemoryDenyWriteExecute=yes rompe los runtimes con JIT (Java, Node.js, algunas bibliotecas de Python), y RestrictAddressFamilies= sin AF_NETLINK rompe los programas que leen las interfaces de red. El significado de cada opción está en systemd.exec. Para el mismo enfoque aplicado al demonio SSH, vea hardening SSH en Linux.

Errores comunes y cómo solucionarlos

Síntoma Causa Solución
status=203/EXEC Binario no encontrado, no ejecutable, o script sin shebang Ruta absoluta en ExecStart=, chmod +x, #!/bin/bash en la primera línea
status=217/USER El usuario de User= no existe useradd -r -s /usr/sbin/nologin app
Failed to load environment files, resultado resources Falta el EnvironmentFile Crearlo, o usar EnvironmentFile=-/ruta si es opcional
Start request repeated too quickly Demasiados arranques dentro de StartLimitIntervalSec Corregir el fallo, subir RestartSec=, después systemctl reset-failed app
Failed with result 'start-limit-hit' sin fallo Reinicios manuales repetidos systemctl reset-failed app; esperar a que pase el intervalo
more than one ExecStart= setting El drop-in añade un ExecStart en lugar de sustituirlo Línea ExecStart= vacía antes de la nueva
changed on disk. Run 'systemctl daemon-reload' Archivo de unidad editado a mano systemctl daemon-reload, después restart
Dependency failed for … Una unidad de Requires= no arrancó journalctl -u sobre la dependencia; Wants= si es opcional
Servicio no reiniciado tras un kill Para on-failure SIGTERM es una salida limpia Restart=always
Ajustes de reinicio ignorados, la unidad arranca igual Errata en una clave o un valor: solo un aviso Leer la salida de systemd-analyze verify

Si el servicio escribe sus propios archivos de log, recuerde que ProtectSystem=strict deja /var/log en solo lectura: use LogsDirectory=app y configure la rotación como se explica en logrotate en Linux, o escriba en stdout y deje que el journal se encargue.

Preguntas frecuentes

¿Cómo hago que un servicio systemd se reinicie automáticamente si falla?

Añade Restart=on-failure y un valor de RestartSec, por ejemplo 5, en la sección Service, y después ejecuta systemctl daemon-reload y reinicia el servicio. A partir de ahí el servicio se reinicia tras un código de salida distinto de cero, un fallo o un kill con SIGKILL, pero no tras una salida limpia o un SIGTERM. Si debe reiniciarse en todos los casos, usa Restart=always.

¿Qué diferencia hay entre Restart=always y Restart=on-failure?

Restart=always reinicia el servicio cada vez que su proceso termina, incluidos el código de salida 0 y la terminación por SIGTERM. Restart=on-failure solo lo reinicia con un código de salida distinto de cero, una señal no limpia como SIGKILL o SIGSEGV, un timeout o un fallo del watchdog. Ninguno de los dos reinicia un servicio detenido con systemctl stop.

¿Cómo se soluciona «Start request repeated too quickly»?

Significa que la unidad se arrancó más veces que StartLimitBurst dentro de StartLimitIntervalSec, que por defecto son 5 arranques en 10 segundos. Busca la causa del fallo con journalctl, sube RestartSec, ejecuta systemctl reset-failed sobre la unidad y arráncala de nuevo. Las dos opciones van en la sección Unit, y los reinicios manuales también cuentan para el límite.

¿Hace falta systemctl daemon-reload antes de systemctl restart?

Solo si has cambiado el archivo de unidad o uno de sus drop-ins. systemctl restart usa la configuración que systemd ya tiene en memoria, y systemctl status avisa de que el archivo ha cambiado en disco. Un cambio en el EnvironmentFile o en la configuración de la aplicación tiene efecto con un simple restart.

¿Qué diferencia hay entre After= y Requires= en systemd?

After fija solo el orden de arranque y no arranca la otra unidad. Requires arranca la otra unidad e impide que la tuya arranque si falla, pero no la espera salvo que añadas también After. En la práctica se usan juntas. Requires no detiene tu servicio si el proceso de la dependencia se cae; BindsTo sí.

Comparte este artículo:

Escrito por

Rosario Giordano

Rosario Giordano es administrador de sistemas y consultor de TI especializado en c iberseguridad y cloud, con más de 20 años de experiencia en la gestión de infraestructuras Linux empresariales. Sus áreas de especialización incluyen el hardening de SSH, plataformas Kubernetes , bases de datos PostgreSQL, virtualización con VMware/Proxmox y el cumplimiento de los marcos de seguridad NIS2 e ISO 27001.