Per creare un servizio systemd si scrive un file di unità in /etc/systemd/system/app.service con una riga ExecStart=, si aggiungono Restart=on-failure e RestartSec= se si vuole che systemd lo riavvii dopo un crash, poi si eseguono systemctl daemon-reload e systemctl enable --now app. Le dipendenze vanno nella sezione [Unit]: After= stabilisce l’ordine, Requires= o Wants= stabiliscono se l’altra unità viene avviata insieme, e non sono intercambiabili.
Tutto quello che segue è stato provato a novembre 2026 su Ubuntu 24.04.5 LTS con systemd 255 (255.4-1ubuntu8.18), in esecuzione come PID 1 in un container privilegiato. Gli output sono reali, abbreviati dove c’è “…”. Strada facendo ho incontrato diversi comportamenti che la maggior parte delle guide sbaglia: Restart=on-failure non riavvia un servizio terminato con SIGTERM, i riavvii manuali contano nel limite di avvii, systemd-analyze verify esce con 0 anche con un Restart= scritto male, e Requires= non ferma il servizio quando la dipendenza va in crash.
Servizio systemd in 60 secondi
sudo useradd -r -s /usr/sbin/nologin app # utente di sistema dedicato
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 # leggere l'output, non solo il codice di uscita
sudo systemctl daemon-reload # dopo ogni modifica al file
sudo systemctl enable --now app # avvio subito e al boot
systemctl status app # stato, PID principale, ultime righe di log
journalctl -u app -f # segue i log
systemctl show app -p NRestarts # quanti riavvii automatici finora
Se il servizio è finito in failed dopo troppi riavvii, sudo systemctl reset-failed app azzera il contatore e permette di riavviarlo.
Dove va il file di unità
systemd legge i file di unità da più directory. Quelle che contano per un amministratore:
| Directory | Chi ci scrive | A cosa serve |
|---|---|---|
/usr/lib/systemd/system/ |
I pacchetti della distribuzione | Non modificare mai: un aggiornamento del pacchetto lo sovrascrive |
/etc/systemd/system/ |
L’amministratore | I propri servizi, e i drop-in che modificano quelli dei pacchetti |
/etc/systemd/system/app.service.d/*.conf |
systemctl edit |
Modifiche parziali, applicate sopra il file principale |
/run/systemd/system/ |
systemd e i generator | Unità di runtime, perse al riavvio |
Un file in /etc/systemd/system/ con lo stesso nome di uno in /usr/lib/systemd/system/ lo sostituisce per intero. Per cambiare una sola impostazione di un servizio di pacchetto conviene un drop-in (vedi la sezione su systemctl edit più sotto): così si continuano a ricevere le correzioni del pacchetto su tutto il resto.
Il file di unità, sezione per sezione
L’applicazione di prova è un piccolo script Bash che stampa il proprio ambiente e, se CRASH_AFTER è impostata, esce con codice 3 dopo quel numero di secondi. Fa le veci di un qualunque demone che resta in esecuzione:
#!/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
Le tre sezioni del file di unità del riquadro qui sopra hanno compiti diversi:
[Unit]: descrizione, ordine e dipendenze (After=,Requires=,Wants=,BindsTo=) e il limite di frequenza degli avvii (StartLimitIntervalSec=,StartLimitBurst=).[Service]: come eseguire il processo (Type=,ExecStart=,User=, ambiente), quando riavviarlo, e le opzioni di isolamento.[Install]: usata solo dasystemctl enable.WantedBy=multi-user.targetcrea il link simbolico che avvia il servizio al boot.
Dopo 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: quali uscite provocano davvero un riavvio
Restart= decide se systemd riavvia il servizio quando il suo processo principale termina. Il valore predefinito è no. Per vedere con precisione cosa fa ogni valore ho avviato 25 servizi transitori con systemd-run, uno per ogni combinazione di valore di Restart= e tipo di uscita, ciascuno con RestartSec=1, e ho contato i riavvii dopo 5 secondi:
| 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 colonna da guardare è SIGTERM. Per systemd un processo che muore per SIGHUP, SIGINT, SIGTERM o SIGPIPE è uscito in modo pulito, esattamente come con codice 0, come scritto nel manuale di systemd.service. Con Restart=on-failure, un kill <pid> lanciato da un altro processo o da uno script, oppure l’applicazione stessa che si chiude alla ricezione di SIGTERM, lasciano il servizio fermo. Se il servizio deve tornare su in ogni caso, usare Restart=always; se alcuni codici di uscita significano “arresto voluto”, elencarli in RestartPreventExitStatus=.
Gli altri casi si comportano come ci si aspetta: un crash (SIGSEGV), l’OOM killer (SIGKILL) e un codice di uscita diverso da zero vengono tutti riavviati da on-failure. Un systemctl stop non provoca mai un riavvio, neanche con Restart=always.
“Start request repeated too quickly”: StartLimitIntervalSec e StartLimitBurst
I riavvii automatici hanno un limite di frequenza. Se un’unità viene avviata più di StartLimitBurst= volte entro StartLimitIntervalSec=, systemd smette di provarci e la lascia in failed. I valori predefiniti, letti con systemctl show su un’unità che non imposta nulla:
$ systemctl show db2 -p Restart -p RestartUSec -p StartLimitIntervalUSec -p StartLimitBurst
Restart=no
RestartUSec=100ms
StartLimitIntervalUSec=10s
StartLimitBurst=5
Con il RestartSec predefinito di 100 ms, un servizio che va in crash all’avvio brucia i suoi cinque tentativi in molto meno di un secondo. Impostare sempre RestartSec= insieme a Restart=.
Per far scattare il limite ho messo CRASH_AFTER=1 in /etc/app.env e ho riavviato l’unità del riquadro iniziale (StartLimitBurst=3 in 60 secondi, 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 due riavvii automatici, non tre: il systemctl restart manuale delle 08:47:38 è stato contato come primo avvio. Lo stesso è successo più avanti nel test, mentre modificavo l’unità e la riavviavo a mano: tre systemctl restart nel giro di un minuto sono bastati per ottenere Failed with result 'start-limit-hit' su un servizio che non era mai andato in crash. Va tenuto presente prima di impostare un burst molto basso su un’unità che si rilascia spesso.
Una volta raggiunto il limite, anche un avvio manuale viene rifiutato, finché l’intervallo non scade o non si azzera il contatore:
$ 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
Il messaggio d’errore parla di un “control process” anche se nessun processo è stato avviato: il motivo vero è nel journal, Start request repeated too quickly.
La trappola: StartLimitIntervalSec va in [Unit]
Molti esempi datati mettono il limite di frequenza in [Service]. Ecco cosa ne fa systemd 255:
$ 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= in [Service] è ancora accettato per compatibilità, StartLimitIntervalSec= no: si finisce con un burst di 10 sull’intervallo predefinito di 10 secondi, una combinazione che nessuno ha scelto. Entrambe le opzioni vanno in [Unit], come documentato in systemd.unit. StartLimitIntervalSec=0 disattiva del tutto il limite.
Attesa progressiva: RestartSteps e RestartMaxDelaySec
Da systemd 254 l’attesa tra un riavvio e l’altro può crescere da sola, da RestartSec= fino a RestartMaxDelaySec= in RestartSteps= passi. È lo strumento giusto per un servizio che dipende da qualcosa di esterno (un database, un’API remota): all’inizio riprova in fretta, poi smette di martellare. Prova con uno script che esce con codice 3 dopo un secondo:
[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.
Togliendo il secondo in cui lo script resta in esecuzione ogni volta, le attese sono 2, 4, 8 e 16 secondi: crescita esponenziale con tetto a RestartMaxDelaySec. Da notare StartLimitIntervalSec=0: senza, il limite di frequenza fermerebbe il ciclo prima che l’attesa diventi lunga.
Type=simple, exec, notify, oneshot
Type= dice a systemd quando considerare avviato il servizio. Decide quando partono le unità ordinate con After= rispetto alla vostra, e se systemctl start segnala un errore.
| Type= | “Avviato” quando | A cosa serve |
|---|---|---|
simple (predefinito) |
Subito dopo il fork, prima che il binario venga eseguito | Unità datate; meglio exec |
exec |
Dopo che il binario è stato eseguito con successo | La maggior parte dei demoni che restano in primo piano |
notify |
Quando il processo invia READY=1 tramite sd_notify |
Demoni che hanno bisogno di tempo per inizializzarsi (caricare dati, aprire socket) |
oneshot |
Quando il processo termina | Script di preparazione, migrazioni, attività da eseguire prima di altri servizi |
forking |
Quando il processo padre esce dopo essersi demonizzato | Vecchi demoni che vanno in background con un fork; richiede PIDFile= |
La differenza tra simple ed exec salta fuori la prima volta che un percorso è sbagliato. Due unità identiche 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 il comando di avvio segnala successo e l’unità fallisce un attimo dopo: un task Ansible o uno script di deploy andrebbero avanti senza accorgersene. Lo stato 203/EXEC significa sempre “il binario non è stato eseguito”: percorso sbagliato, permesso di esecuzione mancante, o uno script senza shebang.
Type=notify con uno script che impiega 3 secondi a essere pronto e poi chiama systemd-notify --ready --status="accepting connections": systemctl start è tornato dopo 3 secondi, e lo stato mostra il testo inviato dal servizio:
* nall.service
Active: active (running) since Sun 2026-11-15 08:49:27 UTC; 58ms ago
Main PID: 804 (sleep)
Status: "accepting connections"
Molte guide sostengono che systemd-notify chiamato da uno script di shell richieda NotifyAccess=all, perché il messaggio arriva da un processo figlio. Nel mio test con systemd 255 anche la versione con NotifyAccess=main si è avviata correttamente dopo 3 secondi. Su versioni più vecchie può essere diverso: se un servizio notify resta in activating fino a TimeoutStartSec= (90 secondi di default), NotifyAccess= è la prima cosa da controllare.
Type=oneshot con RemainAfterExit=yes resta active (exited) dopo la fine del processo, così altre unità possono dipendere da lui. È anche l’unico tipo che accetta più righe ExecStart=, eseguite in ordine:
[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/bin/mkdir -p /run/demo
ExecStart=/bin/sh -c "echo prepared > /run/demo/state"
Dipendenze: After= contro Requires= contro Wants=
È il punto in cui systemd sorprende più spesso. Ordine e requisito sono due assi separati:
After=db.servicestabilisce solo l’ordine: se entrambe le unità sono in avvio, la vostra aspetta db. Non avvia db.Wants=db.serviceavvia db insieme alla vostra. Se db fallisce, la vostra parte comunque.Requires=db.serviceavvia db insieme alla vostra. Se db non riesce a partire, la vostra non viene avviata; se db viene fermato o riavviato con systemctl, lo stesso succede alla vostra.BindsTo=db.serviceè comeRequires=, ma la vostra si ferma anche quando db muore da solo.
Le ho provate tutte e quattro con un finto db.service (un oneshot che impiega 3 secondi). Prima, Requires= senza After=:
### Requires= senza After=: avviate insieme
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 aspetta 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.
Senza After= l’applicazione è partita prima ancora che il database iniziasse ad avviarsi. Requires= e Wants= hanno quasi sempre bisogno di un After= sulla stessa unità.
Poi il comportamento quando db si ferma o fallisce:
### systemctl stop db
app-req inactive # Requires=: fermata insieme a db
app-wants active # Wants=: non toccata
### db non riesce a partire
$ 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
Il caso che quasi tutte le guide tralasciano: cosa succede quando il processo della dipendenza muore invece di essere fermato con systemctl. Ho avviato r2 (Requires=db2) e b2 (BindsTo=db2), poi ho ucciso db2 con SIGKILL:
$ sudo systemctl kill -s KILL db2
$ systemctl is-active db2 r2 b2
failed
active
inactive
Con Requires= l’applicazione continua a girare appoggiata a un database morto. Solo BindsTo= la ferma. Usare BindsTo= quando il servizio non ha senso senza l’altro, e abbinarlo a Restart= su entrambi se si vuole che ripartano insieme.
network-online.target
After=network.target non significa che la rete è attiva: garantisce soltanto che, allo spegnimento, il servizio si fermi prima che la rete venga disattivata. Per aspettare una rete configurata si usano After=network-online.target più Wants=network-online.target, come nell’esempio iniziale. Quel target aspetta che sia abilitato un servizio di “wait-online” (systemd-networkd-wait-online o NetworkManager-wait-online); se non ce n’è nessuno, viene raggiunto subito. La pagina di systemd su network-online spiega quando ne vale la pena: spesso è meglio che sia il servizio a gestire una rete non ancora pronta, per esempio mettendosi in ascolto su 0.0.0.0 invece che su un indirizzo specifico.
User= ed EnvironmentFile=
Il servizio va eseguito con un utente dedicato, creato con useradd -r -s /usr/sbin/nologin app. Se l’utente non esiste, il processo fallisce con un codice di stato specifico:
… systemd[1]: e3.service: Main process exited, code=exited, status=217/USER
EnvironmentFile= carica le variabili da un file CHIAVE=valore, una per riga. Tre comportamenti, tutti verificati nel container:
- Un file mancante blocca l’avvio:
Failed to load environment files: No such file or directory, risultatoresources. Con un trattino davanti,EnvironmentFile=-/etc/app.env, un file mancante viene ignorato. - Il file viene letto da systemd (PID 1, come root) prima di passare a
User=. Un file di proprietà di root con permessi600funziona anche se il servizio gira comeapp: nel mio test la variabile è arrivata al processo, che girava comeapp. Quindi i segreti vanno tenutiroot:root 600; l’utente del servizio non ha bisogno di leggerli. - Le variabili di
EnvironmentFile=prevalgono su quelle impostate conEnvironment=, anche seEnvironment=sta in un drop-in caricato dopo. Ho messoEnvironment=MODE=stagingin un override e il processo ha continuato a stampareMODE=production, il valore del file. Per cambiare una variabile, cambiarla nel file o puntare a un secondo file.
Un file d’ambiente modificato ha effetto al successivo systemctl restart app; non serve daemon-reload, perché viene letto a ogni avvio del servizio.
systemd-analyze verify: cosa intercetta e cosa lascia passare
systemd-analyze verify controlla un file di unità senza caricarlo. Gliene ho passato uno con due refusi e una dipendenza inesistente:
$ 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
Tolta la dipendenza mancante, i refusi restano ma il codice di uscita 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
Codice di uscita 0, e il servizio parte senza alcun riavvio automatico. Un controllo in una pipeline che guarda solo il codice di uscita fa passare questo file. Qualunque output va trattato come errore, per esempio con test -z "$(systemd-analyze verify app.service 2>&1)".
daemon-reload e systemctl restart: quando serve l’uno e quando l’altro
systemctl restart riavvia il processo con la configurazione che systemd ha già in memoria. Se avete modificato il file di unità, i nuovi valori non vengono letti fino al daemon-reload. Ho cambiato RestartSec=2 in 5 e ho riavviato senza ricaricare:
$ 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 regola: dopo aver modificato a mano un file di unità o un drop-in, daemon-reload e poi restart. systemctl edit esegue il reload da solo. Una modifica alla configurazione dell’applicazione o all’EnvironmentFile richiede solo restart.
Modificare un’unità con systemctl edit
sudo systemctl edit app apre un editor e salva quello che scrivete in /etc/systemd/system/app.service.d/override.conf. Diventa drop-in solo il testo tra le due righe di commento in alto; tutto quello che sta sotto è il file attuale, mostrato come riferimento e scartato. systemctl edit --full app invece modifica una copia completa dell’unità.
L’errore classico è sovrascrivere ExecStart= scrivendo semplicemente la nuova riga:
$ 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.
In un drop-in le impostazioni a lista come ExecStart= si aggiungono al valore esistente. Per sostituirlo, prima lo si svuota con un’assegnazione vuota:
[Service]
ExecStart=
ExecStart=/opt/app/app.sh --verbose
Con questa versione il riavvio va a buon fine e systemctl status mostra il drop-in sotto Drop-In: /etc/systemd/system/app.service.d. systemctl cat app stampa il file principale seguito da tutti i drop-in, nell’ordine in cui vengono applicati: è il modo più rapido per vedere la configurazione che systemd usa davvero.
Leggere i log con journalctl -u
Tutto quello che il servizio scrive su stdout e stderr finisce nel journal, insieme ai messaggi di systemd sull’unità:
journalctl -u app -b # dall'ultimo boot
journalctl -u app --since "-15min" # ultimi 15 minuti
journalctl -u app -f # segue, come tail -f
journalctl -xeu app # ultime righe con spiegazioni, come suggerisce systemctl
journalctl -u app -p err -o cat # solo errori, senza prefisso
L’ultimo comando ha un tranello. Nel mio test journalctl -u app -p err mostrava i messaggi di systemd (Failed to start app.service, l’ExecStart rifiutato), ma non la riga fatal: simulated crash scritta dallo script su stderr. Per impostazione predefinita stderr viene registrato con priorità info, non err. Se l’applicazione non usa le priorità di syslog o sd-journal, filtrare per testo, non per priorità. Per l’insieme completo dei filtri vedi i 15 comandi journalctl essenziali.
Hardening di base e systemd-analyze security
systemd-analyze security dà un punteggio all’isolamento di un servizio da 0 (isolato) a 10 (nessuna restrizione). L’unità del riquadro “in 60 secondi”, che già gira con un utente non 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 utente non root da solo non basta. Ho aggiunto questo 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
Da 9.2 a 1.7, con il servizio ancora in esecuzione. ProtectSystem=strict rende tutto il file system in sola lettura per il servizio; StateDirectory=app crea /var/lib/app, di proprietà dell’utente del servizio, e la lascia scrivibile. Provato con un’unità transitoria con le stesse due opzioni:
touch: cannot touch '/etc/x': Read-only file system
wrote /var/lib/app/ok
Su un’applicazione vera le opzioni vanno aggiunte una alla volta, controllando il journal dopo ogni riavvio: MemoryDenyWriteExecute=yes rompe i runtime con JIT (Java, Node.js, alcune librerie Python), e RestrictAddressFamilies= senza AF_NETLINK rompe i programmi che leggono le interfacce di rete. Il significato di ogni opzione è in systemd.exec. Per lo stesso approccio applicato al demone SSH, vedi hardening SSH su Linux.
Errori comuni e come risolverli
| Sintomo | Causa | Soluzione |
|---|---|---|
status=203/EXEC |
Binario non trovato, non eseguibile, o script senza shebang | Percorso assoluto in ExecStart=, chmod +x, #!/bin/bash sulla prima riga |
status=217/USER |
L’utente di User= non esiste |
useradd -r -s /usr/sbin/nologin app |
Failed to load environment files, risultato resources |
EnvironmentFile mancante |
Crearlo, oppure usare EnvironmentFile=-/percorso se è facoltativo |
Start request repeated too quickly |
Troppi avvii entro StartLimitIntervalSec |
Correggere il crash, alzare RestartSec=, poi systemctl reset-failed app |
Failed with result 'start-limit-hit' senza crash |
Riavvii manuali ripetuti | systemctl reset-failed app; aspettare che l’intervallo scada |
more than one ExecStart= setting |
Il drop-in aggiunge un ExecStart invece di sostituirlo |
Riga ExecStart= vuota prima di quella nuova |
changed on disk. Run 'systemctl daemon-reload' |
File di unità modificato a mano | systemctl daemon-reload, poi restart |
Dependency failed for … |
Un’unità in Requires= non è partita |
journalctl -u sulla dipendenza; Wants= se è facoltativa |
Servizio non riavviato dopo un kill |
Per on-failure SIGTERM è un’uscita pulita |
Restart=always |
| Impostazioni di riavvio ignorate, l’unità parte lo stesso | Refuso in una chiave o in un valore: solo un avviso | Leggere l’output di systemd-analyze verify |
Se il servizio scrive file di log propri, ricordate che ProtectSystem=strict rende /var/log in sola lettura: usare LogsDirectory=app e configurare la rotazione come descritto in logrotate su Linux, oppure scrivere su stdout e lasciare che se ne occupi il journal.
Domande frequenti
Come faccio a far riavviare automaticamente un servizio systemd quando fallisce?
Aggiungi Restart=on-failure e un valore di RestartSec, per esempio 5, nella sezione Service, poi esegui systemctl daemon-reload e riavvia il servizio. Da quel momento il servizio viene riavviato dopo un codice di uscita diverso da zero, un crash o un kill con SIGKILL, ma non dopo un’uscita pulita o un SIGTERM. Se deve ripartire in ogni caso, usa Restart=always.
Qual è la differenza tra Restart=always e Restart=on-failure?
Restart=always riavvia il servizio ogni volta che il suo processo termina, compresi il codice di uscita 0 e la terminazione con SIGTERM. Restart=on-failure lo riavvia solo con un codice di uscita diverso da zero, un segnale non pulito come SIGKILL o SIGSEGV, un timeout o un errore del watchdog. Nessuno dei due riavvia un servizio fermato con systemctl stop.
Come si risolve “Start request repeated too quickly”?
Significa che l’unità è stata avviata più volte di StartLimitBurst entro StartLimitIntervalSec, che di default valgono 5 avvii in 10 secondi. Trova la causa del crash con journalctl, alza RestartSec, poi esegui systemctl reset-failed sull’unità e avviala di nuovo. Le due opzioni vanno nella sezione Unit, e anche i riavvii manuali contano nel limite.
Serve systemctl daemon-reload prima di systemctl restart?
Solo se hai modificato il file di unità o uno dei suoi drop-in. systemctl restart usa la configurazione che systemd ha già in memoria, e systemctl status avvisa che il file è cambiato su disco. Una modifica all’EnvironmentFile o alla configurazione dell’applicazione ha effetto con un semplice restart.
Qual è la differenza tra After= e Requires= in systemd?
After stabilisce solo l’ordine di avvio e non avvia l’altra unità. Requires avvia l’altra unità e impedisce alla tua di partire se fallisce, ma non la aspetta a meno che non aggiungi anche After. In pratica si usano insieme. Requires non ferma il tuo servizio se il processo della dipendenza va in crash; BindsTo sì.