Approfondimento · Linux
systemd
systemd è PID 1, ma ridurlo a “il programma che avvia il resto” è come dire che un database è un file. In pochi anni è diventato il gestore dei servizi, dei socket, dei timer, dei punti di mount, delle sessioni, del journal, della rete, del DNS, dell’orologio e dei cgroup. Questa pagina spiega come è fatto, come si scrive un’unità che non si rompe, come si leggono le dipendenze e come si diagnostica un servizio che parte a mano ma non al boot.
In breve. Quattro comandi coprono
l’ordinaria amministrazione:
systemctl status nome per lo stato,
systemctl cat nome per vedere tutte le fonti
dell’unità, journalctl -u nome -b per i
log di questa sessione e systemd-analyze verify per
scoprire gli errori prima di ricaricare. Dopo ogni modifica a un
file unità serve systemctl daemon-reload, e
dopo un aggiornamento di systemd serve
systemctl daemon-reexec.
Per il ciclo di vita dei processi, i segnali e i cgroup visti dal lato kernel c’è Processi e risorse; per i file di configurazione e i permessi, File system e permessi; per i parametri del kernel e l’initramfs, Il kernel e la sua gestione. Qui si presume una distribuzione con systemd già installato, come Debian, Ubuntu, Fedora, RHEL, Mint o Kali.
Scrivi cosa vuoi fare: la ricerca guarda comandi, descrizioni e titoli delle sezioni.
PID 1 e architettura
Al termine del boot il kernel esegue un solo processo, che su un
sistema systemd è /usr/lib/systemd/systemd. Quel
processo diventa PID 1, monta i file system rimasti, applica la
configurazione, avvia le unità e resta in attesa. PID 1 ha un
compito che nessun altro processo ha: raccogliere i figli orfani e
evitare che diventino zombie. Per questo, se systemd muore, il kernel
va in panico: non esiste un secondo programma pronto a prendere il
suo posto.
Il progetto nasce nel 2010 per iniziativa di Lennart Poettering e Kay Sievers, con l’obiettivo di sostituire SysVinit e Upstart con un modello dichiarativo: si descrive cosa deve essere attivo e da cosa dipende, non una sequenza di script. Fedora 15 lo adotta nel maggio 2011, RHEL 7 nel 2014, Debian 8 nel 2015, Ubuntu 15.04 nello stesso anno. Oggi è il default praticamente ovunque tranne alcune nicchie: Alpine usa OpenRC, Void usa runit, Gentoo lascia scegliere, Devuan esiste proprio per non usarlo.
“systemd fa troppo” è la critica più frequente, e in parte è vera: il progetto ha assorbito funzioni che prima erano di demoni separati. La difesa è che quei demoni sono binari distinti, comunicano su D-Bus e condividono un modello di configurazione e di log. Non è un unico processo gigante, ma una famiglia di componenti con lo stesso vocabolario.
| Componente | Ruolo |
|---|---|
systemd | PID 1, system manager e user manager |
systemd-journald | Raccolta e conservazione dei log |
systemd-logind | Sessioni, utenti, seat, inibizioni |
systemd-udevd | Gestione eventi dei dispositivi |
systemd-networkd | Configurazione di rete dichiarativa |
systemd-resolved | Resolver DNS, LLMNR, mDNS, DNSSEC |
systemd-timesyncd | Sincronizzazione NTP leggera |
systemd-coredump | Raccolta dei core dump |
systemd-oomd | OOM anticipato basato su PSI |
systemd-homed | Home directory portabili e cifrate |
systemd-machined | Registro di macchine e container |
systemd-nspawn | Container leggero basato su namespace |
systemd-boot | Boot loader UEFI minimalista |
systemd-analyze, systemd-run | Analisi e unità transienti |
# Chi e PID 1
ps -p 1 -o pid,comm,args
cat /proc/1/comm
# Versione e funzionalita compilate
systemctl --version
systemd-analyze --version
# Stato complessivo del sistema
systemctl is-system-running
# running, degraded, starting, maintenance, stopping, offline, unknown
# Modello di init e conferma
readlink -f /sbin/init
systemctl --no-pager list-units --type=target
systemctl is-system-running risponde running
quando tutto è partito, degraded quando almeno
un’unità è fallita. È il primo controllo
dopo un boot sospetto, prima ancora di guardare i singoli servizi.
Un sistema degraded funziona, ma qualcosa non è
andato come previsto.
Unità, tipi e percorsi
Un’unità è un file di testo in formato INI con
estensione che ne dichiara il tipo: .service,
.socket, .timer, .target,
.mount, .automount, .swap,
.path, .slice, .scope,
.device. Il nome completo è l’identità
dell’unità: sshd.service e
sshd.socket sono due oggetti diversi, e possono
coesistere.
| Tipo | A cosa serve | Esempio |
|---|---|---|
service | Un processo o un gruppo di processi | nginx.service |
socket | Un socket in ascolto che attiva un servizio | sshd.socket |
timer | Esecuzione programmata di un’unità | logrotate.timer |
target | Punto di sincronizzazione, simile a un runlevel | multi-user.target |
mount | Un punto di mount gestito da systemd | home.mount |
automount | Mount su richiesta | home.automount |
swap | Area di swap | dev-sda2.swap |
path | Attivazione su modifica di un percorso | cups.path |
slice | Gruppo gerarchico di cgroup | user.slice |
scope | Gruppo di processi creato dall’esterno | session-1.scope |
device | Dispositivo esposto dal kernel | dev-nvme0n1.device |
I file si trovano in tre gerarchie, in ordine di precedenza:
/etc/systemd/system per
l’amministratore, /run/systemd/system per lo stato
runtime e /usr/lib/systemd/system per i pacchetti della
distribuzione. Un file con lo stesso nome in /etc
vince su quello del vendor; un drop-in in
/etc/systemd/system/nome.service.d/*.conf modifica solo
le direttive che contiene. Le unità utente stanno in
~/.config/systemd/user e in
/usr/lib/systemd/user.
# Elenco completo e stato di abilitazione
systemctl list-units --type=service
systemctl list-units --all --type=service
systemctl list-unit-files --type=service
systemctl list-unit-files --state=enabled
# Vedere tutte le fonti di un'unita, drop-in compresi
systemctl cat sshd.service
systemctl cat sshd.service | grep -n '^#'
# Proprieta effettive, non solo il file
systemctl show sshd.service
systemctl show sshd.service -p FragmentPath -p DropInPaths
systemctl show sshd.service -p ExecStart -p User -p Restart
# Dove si trova il file
systemctl status sshd.service | head -n 5
Lo stato di un’unità non è solo
enabled o disabled. static
significa che non ha una sezione [Install] e non si
abilita da sola; indirect significa che viene
attivata da un’altra unità; generated
indica un’unità creata al volo da un generatore;
masked è un link a /dev/null che
impedisce l’avvio in modo assoluto; transient
è un’unità in memoria creata da
systemd-run o da un’API.
# Disabilitare non basta se qualcosa la tira dentro: mascherare
sudo systemctl disable --now cups.service
sudo systemctl mask cups.service
sudo systemctl unmask cups.service
# Attenzione: mask su un'unita attiva non la ferma
sudo systemctl stop cups.service
sudo systemctl mask --now cups.service
# Verifica
systemctl is-enabled cups.service
ls -l /etc/systemd/system/cups.service
disable rimuove i link di abilitazione ma non impedisce
a un’altra unità di attivare il servizio come
dipendenza. mask rende l’unità
inavviabile: è il modo corretto per dire “questo non
deve partire mai”. Su Debian e Ubuntu molti servizi sono
abilitati tramite WantedBy=multi-user.target; su RHEL e
Fedora lo stesso, con l’aggiunta di preset che decidono lo
stato iniziale dei pacchetti.
Scrivere un service
Un’unità di servizio minima ha tre sezioni:
[Unit] per la descrizione e le dipendenze,
[Service] per come eseguire il processo e
[Install] per come abilitarla. Tutto ciò che non
è dichiarato eredita i default di systemd, che sono
ragionevoli ma non sempre adatti a un’applicazione reale.
# /etc/systemd/system/miaapp.service
[Unit]
Description=Mia applicazione
Documentation=https://example.invalid/docs
After=network-online.target
Wants=network-online.target
[Service]
Type=simple
User=miaapp
Group=miaapp
WorkingDirectory=/srv/miaapp
Environment=APP_ENV=production
EnvironmentFile=-/etc/miaapp/miaapp.env
ExecStart=/usr/local/bin/miaapp --config /etc/miaapp/config.yml
ExecReload=/bin/kill -HUP $MAINPID
Restart=on-failure
RestartSec=5s
TimeoutStopSec=30s
StandardOutput=journal
StandardError=journal
SyslogIdentifier=miaapp
[Install]
WantedBy=multi-user.target
After= ordina, Wants= tira dentro
l’unità senza rendere il fallimento bloccante. Mettere
After=network.target non significa che la rete sia
pronta: network.target dice solo che la configurazione
è stata avviata. Per avere un indirizzo e una rotta servono
network-online.target e un demone
wait-online attivo.
Type= | Quando systemd considera il servizio avviato | Uso tipico |
|---|---|---|
simple | Subito dopo il fork di ExecStart | Default; processi che restano in foreground |
exec | Dopo che execve è riuscita | Come simple, ma distingue errori di esecuzione |
forking | Quando il processo padre esce | Demoni tradizionali che fanno fork |
oneshot | Quando il processo termina | Script di inizializzazione, job brevi |
dbus | Quando il nome D-Bus è sul bus | Servizi D-Bus |
notify | Quando arriva READY=1 su sd_notify | Servizi che sanno dire quando sono pronti |
notify-reload | Come notify, con ricarica via segnale | Servizi con reload esplicito |
idle | Dopo che le altre unità sono state avviate | Console, job cosmetici |
La scelta di Type= non è un dettaglio estetico.
Con forking systemd deve indovinare quale processo sia
il demone: senza PIDFile= corretto può tracciare
il padre sbagliato, dichiarare il servizio attivo e non accorgersi
che il figlio è morto. Un’applicazione moderna che resta
in foreground va lasciata Type=simple o
notify.
Restart= | Riavvia quando |
|---|---|
no | Mai; è il default |
on-success | Uscita con codice 0 |
on-failure | Codice diverso da 0, segnale, timeout, watchdog |
on-abnormal | Segnale, timeout o watchdog |
on-abort | Segnale non gestito |
on-watchdog | Watchdog scaduto |
always | Sempre, anche dopo un’uscita pulita |
Restart=always su un job che termina normalmente produce
un ciclo infinito di riavvii. Per gli one-shot si usa
Restart=no; per i demoni on-failure è
quasi sempre la scelta giusta. RestartSec= evita di
martellare il sistema, e StartLimitIntervalSec= con
StartLimitBurst= ferma del tutto un servizio che
fallisce troppe volte.
[Unit]
StartLimitIntervalSec=60
StartLimitBurst=5
[Service]
Restart=on-failure
RestartSec=5s
# Dopo un crash, systemd lo lascia in failed:
systemctl status miaapp.service
journalctl -u miaapp.service -b
systemctl reset-failed miaapp.service
systemctl start miaapp.service
Le direttive di esecuzione si concatenano in ordine:
ExecStartPre, ExecStart,
ExecStartPost, ExecReload,
ExecStop, ExecStopPost. Ogni riga
ExecStart= aggiunge un comando; una riga vuota
ExecStart= azzera la lista ereditata, cosa necessaria
quando si vuole sostituire l’esecuzione in un drop-in.
$MAINPID è il PID del processo principale,
disponibile in ExecReload e ExecStop.
# Drop-in: non tocca il file del vendor
sudo systemctl edit miaapp.service
# Crea /etc/systemd/system/miaapp.service.d/override.conf
# Esempio di override
[Service]
Environment=APP_ENV=staging
LimitNOFILE=65535
# Modifica completa, copia il file in /etc
sudo systemctl edit --full miaapp.service
# Ricaricare la configurazione e il servizio
sudo systemctl daemon-reload
sudo systemctl restart miaapp.service
# Controllare prima di applicare
systemd-analyze verify /etc/systemd/system/miaapp.service
systemctl edit è la pratica corretta: lascia
intatto il file del pacchetto, che verrà aggiornato senza
conflitti, e tiene le modifiche locali in un posto prevedibile.
systemctl edit --full crea una copia completa in
/etc, utile per riscrivere un’unità di cui
si vuole cambiare quasi tutto, ma destinata a divergere dal vendor.
Utenti e ambiente. User= e
Group= cambiano identità prima di
ExecStart; DynamicUser=yes crea un utente
effimero con UID alto, senza voce in /etc/passwd.
EnvironmentFile= con il trattino iniziale
(-) non fallisce se il file manca.
StandardOutput=journal è il default per i
servizi di sistema e rende i log visibili con
journalctl -u.
systemctl nel quotidiano
systemctl è l’interfaccia unica per il
system manager e, con --user, per l’user manager.
La sintassi è coerente: verbo, unità, opzioni. Quasi
tutti i comandi accettano --now per unire
abilitazione e avvio, e --no-pager per evitare che
l’output finisca in less.
| Comando | Effetto |
|---|---|
systemctl status nome | Stato, PID, cgroup, ultime righe di log |
systemctl start nome | Avvia adesso, senza abilitare al boot |
systemctl stop nome | Ferma adesso |
systemctl restart nome | Ferma e riavvia |
systemctl reload nome | Invia la ricarica configurata, se esiste |
systemctl reload-or-restart nome | Reload se possibile, altrimenti restart |
systemctl try-restart nome | Riavvia solo se era attivo |
systemctl enable --now nome | Abilita al boot e avvia subito |
systemctl disable --now nome | Disabilita e ferma |
systemctl mask nome | Impedisce l’avvio in modo assoluto |
systemctl is-active nome | active, inactive, failed |
systemctl is-enabled nome | enabled, disabled, static, masked |
systemctl --failed | Solo le unità in stato failed |
systemctl list-dependencies nome | Albero delle dipendenze |
systemctl cat nome | File unità e drop-in |
systemctl show nome -p PROP | Valore effettivo di una proprietà |
systemctl kill -s SIGKILL nome | Segnale a tutti i processi del cgroup |
systemctl reset-failed nome | Azzera il contatore di fallimenti |
systemctl daemon-reload | Rilegge i file unità |
systemctl daemon-reexec | Riesegue PID 1 dopo un aggiornamento |
start e enable sono cose diverse:
start agisce adesso, enable crea i link
nella directory del target per il prossimo boot. Un servizio
avviato a mano ma non abilitato sparisce al riavvio; un servizio
abilitato ma non avviato parte al prossimo boot. --now
unisce i due gesti, ed è quello che si vuole quasi sempre.
# Ciclo di lavoro tipico
sudo systemctl daemon-reload
sudo systemctl enable --now miaapp.service
systemctl status miaapp.service
journalctl -u miaapp.service -b -n 50 --no-pager
# Cosa farebbe enable, senza farlo
systemctl enable --dry-run miaapp.service
# Dipendenze inverse: chi tira dentro questa unita
systemctl list-dependencies --reverse miaapp.service
# Proprieta di interesse
systemctl show miaapp.service -p ActiveState -p SubState -p MainPID
systemctl show miaapp.service -p ExecMainStartTimestamp -p ExecMainExitTimestamp
# Uscita e stato
systemctl is-active miaapp.service; echo $?
# 0 attivo, 3 non attivo, 4 unita inesistente
Gli exit code di systemctl sono utili negli script:
is-active ritorna 0 solo se il servizio è
attivo, is-enabled distingue abilitato e non
abilitato. systemctl status usa invece 3 per
“non attivo” e 4 per “non esiste”: non
trattarlo come un semplice booleano.
# User manager: servizi dell'utente, senza root
systemctl --user status
systemctl --user enable --now backup.service
journalctl --user -u backup.service -b
# Restare attivi dopo il logout
loginctl show-user "$USER" -p Linger
sudo loginctl enable-linger "$USER"
# Ambiente corretto per --user da SSH o sudo
echo "$XDG_RUNTIME_DIR"
# /run/user/1000
sudo -u alice XDG_RUNTIME_DIR=/run/user/1000 systemctl --user status
Il system manager e l’user manager sono due istanze distinte
di systemd. I servizi utente non possono aprire porte privilegiate,
non vedono le unità di sistema e vivono in
user@UID.service. Senza linger, l’user manager
viene fermato all’ultimo logout e i servizi utente muoiono con
lui.
Target e dipendenze
Un target è un’unità che non esegue nulla: serve
solo come punto di aggregazione. I runlevel di SysV sono stati
mappati su target, ma il modello è diverso: non c’è
una sequenza numerica, ci sono dipendenze e ordinamenti dichiarati
da ogni unità. default.target è un link
simbolico che decide dove si arriva al boot.
| Target | Significato |
|---|---|
poweroff.target | Spegnimento |
rescue.target | Sistema single-user, servizi essenziali, root shell |
multi-user.target | Sistema multiutente senza grafica |
graphical.target | Multiutente con display manager |
reboot.target | Riavvio |
emergency.target | Solo root filesystem, shell minima |
# Dove punta il default
systemctl get-default
readlink -f /etc/systemd/system/default.target
# Cambiare il default
sudo systemctl set-default multi-user.target
sudo systemctl set-default graphical.target
# Passare a un target adesso, senza riavviare
sudo systemctl isolate rescue.target
sudo systemctl isolate multi-user.target
# Albero delle dipendenze
systemctl list-dependencies multi-user.target
systemctl list-dependencies --reverse network-online.target
Le relazioni si dividono in due famiglie: quelle che
tirano dentro un’unità e quelle che
ordinano. Requires= e Wants=
attivano; After= e Before= ordinano.
Dimenticare questa distinzione è l’errore più
comune: scrivere solo After=postgresql.service non
avvia PostgreSQL, e scrivere solo Requires=postgresql.service
senza After= può avviare i due processi in
parallelo.
| Direttiva | Effetto |
|---|---|
Requires= | Attiva l’unità; se fallisce, fallisce anche questa |
Wants= | Attiva l’unità, ma il fallimento non è bloccante |
Requisite= | Non attiva; richiede che sia già attiva |
BindsTo= | Come Requires, ma si ferma se l’altra sparisce |
PartOf= | Propaga stop e restart all’unità indicata |
Conflicts= | Le due unità non possono essere attive insieme |
Before= / After= | Solo ordinamento, nessuna attivazione |
OnFailure= | Attiva un’unità quando questa fallisce |
L’ordine di avvio non è globale: systemd costruisce un
grafo e avvia in parallelo tutto ciò che non ha vincoli. Un
target non è una barriera rigida, ma un nodo del grafo. Per
questo il boot è veloce e per questo un
After= sbagliato produce errori intermittenti invece
che un fallimento netto.
# Visualizzare il grafo
systemd-analyze dot --order | dot -Tsvg > ordine.svg
systemd-analyze dot multi-user.target | dot -Tsvg > dipendenze.svg
# Chi dipende da chi
systemctl list-dependencies --all nginx.service
systemctl list-dependencies --reverse nginx.service
# Un servizio che deve partire dopo il mount di /srv
# [Unit]
# RequiresMountsFor=/srv
# After=local-fs.target
RequiresMountsFor= è la direttiva giusta quando
un servizio ha bisogno di un percorso montato: systemd aggiunge le
dipendenze di mount necessarie senza doverle elencare a mano.
ConditionPathExists=, ConditionFileNotEmpty=
e ConditionKernelCommandLine= permettono di saltare
un’unità in modo pulito, senza marcarla come fallita.
Timer
Un timer è un’unità .timer che
attiva un’unità .service con lo stesso
nome. Non sostituisce cron a livello di sintassi, ma offre
dipendenze, logging nel journal, ambienti controllati,
Persistent=true per recuperare le esecuzioni perse e
la possibilità di vedere lo stato con
systemctl list-timers.
# /etc/systemd/system/backup.service
[Unit]
Description=Backup notturno
[Service]
Type=oneshot
User=backup
ExecStart=/usr/local/bin/backup.sh
Nice=10
IOSchedulingClass=best-effort
IOSchedulingPriority=7
# /etc/systemd/system/backup.timer
[Unit]
Description=Esegue il backup ogni notte
[Timer]
OnCalendar=*-*-* 03:30:00
Persistent=true
RandomizedDelaySec=15m
AccuracySec=1min
Unit=backup.service
[Install]
WantedBy=timers.target
OnCalendar= usa una sintassi calendario leggibile:
daily, weekly, Mon..Fri 08:00,
*-*-01 04:00:00 per il primo del mese.
Persistent=true salva l’ultima esecuzione in
/var/lib/systemd/timers e recupera il job se la
macchina era spenta. RandomizedDelaySec= distribuisce
i timer su una flotta e evita che cento macchine colpiscano lo
stesso server alle 03:30:00.
| Direttiva | Significato |
|---|---|
OnCalendar= | Espressione calendario, con timezone locale |
OnBootSec= | Dopo N dal boot |
OnStartupSec= | Dopo N dall’avvio di systemd |
OnUnitActiveSec= | Dopo N dall’ultima attivazione dell’unità |
OnUnitInactiveSec= | Dopo N dall’ultima disattivazione |
Persistent= | Recupera le esecuzioni perse |
RandomizedDelaySec= | Ritardo casuale aggiuntivo |
AccuracySec= | Precisione richiesta; 1min è il default |
Unit= | Unità da attivare, se diversa dal nome |
# Verificare quando scatta davvero
systemd-analyze calendar '*-*-* 03:30:00'
systemd-analyze calendar 'Mon..Fri 08:00' --iterations=5
systemd-analyze calendar 'daily' --base-time='2026-11-14 12:00:00'
# Timer attivi e prossime scadenze
systemctl list-timers --all
systemctl list-timers --all --no-pager
# Stato e log
systemctl status backup.timer
systemctl status backup.service
journalctl -u backup.service -b
journalctl -u backup.timer -b
# Test immediato senza aspettare
sudo systemctl start backup.service
# Timer transiente
sudo systemd-run --on-active=30m --unit=promemoria /usr/local/bin/notify
Un timer abilitato ma senza il service corrispondente non fa nulla;
il service deve esistere, ma non va abilitato: lo attiva il timer.
Se il service ha WantedBy=multi-user.target, partirà
anche al boot, cosa quasi mai desiderata per un job periodico.
systemctl list-timers mostra le prossime scadenze e
è il modo più rapido per capire se un timer è
davvero armato.
Rispetto a cron, i timer hanno un vantaggio concreto: ogni
esecuzione è un’unità con un cgroup, quindi si
può limitare memoria e CPU, si vede l’esito nel
journal e si può usare OnFailure= per reagire.
Lo svantaggio è che la sintassi è più verbose e
che i timer non sono pensati per esecuzioni ogni minuto su sistemi
molto carichi.
Socket activation e template
Con la socket activation systemd apre il socket e avvia il servizio
solo alla prima connessione. Il servizio riceve il file descriptor
già pronto, quindi non deve preoccuparsi di bind, permessi o
race di avvio. È il meccanismo che permette a
sshd.socket di ascoltare senza tenere un processo
sempre attivo, e che rende possibile riavviare un servizio senza
perdere le connessioni in coda.
# /etc/systemd/system/echo.socket
[Unit]
Description=Socket di echo
[Socket]
ListenStream=127.0.0.1:7777
Accept=yes
[Install]
WantedBy=sockets.target
# /etc/systemd/system/echo@.service
[Unit]
Description=Echo per connessione
[Service]
ExecStart=/usr/local/bin/echo-once
StandardInput=socket
StandardOutput=socket
StandardError=journal
Con Accept=yes systemd accetta la connessione e avvia
un’istanza del template echo@.service per ogni
client. Con Accept=no il servizio riceve direttamente
il socket in ascolto e gestisce le connessioni da sé: è
il modello usato da sshd.socket e dalla maggior parte
dei demoni di rete.
# Abilitare il socket, non il service
sudo systemctl daemon-reload
sudo systemctl enable --now echo.socket
# Verificare
systemctl status echo.socket
systemctl list-sockets
ss -ltnp | grep 7777
# Il servizio parte alla prima connessione
nc 127.0.0.1 7777
journalctl -u 'echo@*' -b
I template sono unità con @ nel nome:
getty@.service diventa
getty@tty1.service quando viene istanziata.
%i è l’istanza così com’è
scritta, %I è la stessa stringa dopo
l’unescaping. Un template evita di duplicare lo stesso file
per ogni porta, disco o utente.
# Istanze di un template
systemctl list-units 'getty@*'
systemctl status getty@tty1.service
# Abilitare una istanza specifica
sudo systemctl enable --now getty@tty2.service
# Template per un servizio su piu porte
# /etc/systemd/system/mioapp@.service
# [Service]
# ExecStart=/usr/local/bin/mioapp --port %i
# sudo systemctl enable --now mioapp@8080.service
# Istanza predefinita
# [Install]
# DefaultInstance=8080
# WantedBy=multi-user.target
La socket activation non è sempre un guadagno: aggiunge un
livello di indirezione e rende meno ovvio capire chi possiede il
socket. Su un servizio che deve comunque restare sempre attivo, un
.service normale è più semplice. Su un
servizio usato di rado, o che si vuole riavviare senza downtime,
il socket è la soluzione elegante.
journald e journalctl
systemd-journald raccoglie messaggi da kernel, servizi,
socket, stdout/stderr delle unità e
da /dev/kmsg. Il formato è binario e indicizzato,
con metadati strutturati per ogni voce: unità, PID, UID, GID,
hostname, boot ID, priorità, campi personalizzati. La
conseguenza pratica è che si può filtrare per
_PID, _COMM o _SYSTEMD_UNIT
senza espressioni regolari fragili.
Di default il journal è volatile: vive in
/run/log/journal e sparisce al riavvio. Per
conservarlo bisogna creare /var/log/journal; la
direttiva Storage= in
/etc/systemd/journald.conf decide il comportamento
(volatile, persistent,
auto, none).
# Journal persistente
sudo mkdir -p /var/log/journal
sudo systemd-tmpfiles --create --prefix /var/log/journal
sudo systemctl restart systemd-journald
# Verifica
journalctl --disk-usage
ls -l /var/log/journal
grep -E '^(Storage|SystemMaxUse|RuntimeMaxUse)' /etc/systemd/journald.conf
| Comando | Risultato |
|---|---|
journalctl -b | Log del boot corrente |
journalctl -b -1 | Log del boot precedente |
journalctl --list-boots | Elenco dei boot disponibili |
journalctl -u nginx -f | Segue i log dell’unità |
journalctl -p err -b | Solo priorità errore o superiore |
journalctl --since '1 hour ago' | Filtro temporale |
journalctl --until '2026-11-14 10:00' | Limite superiore |
journalctl -g 'timeout' | Ricerca nel messaggio |
journalctl -k | Solo messaggi del kernel |
journalctl -o json-pretty | Formato strutturato |
journalctl _PID=1234 | Filtro per PID |
journalctl _SYSTEMD_UNIT=sshd.service | Filtro per unità |
journalctl --vacuum-size=500M | Riduce lo spazio usato |
journalctl --verify | Controlla l’integrità dei file |
# Combinare filtri
journalctl -u nginx.service --since today -p warning
journalctl -b -p err --no-pager
journalctl -u 'ssh*' -g 'Failed password'
journalctl -k --since '30 min ago' | grep -i -E 'error|fail'
# Scrivere nel journal da uno script
echo "job completato" | systemd-cat -t miojob -p info
logger -t miojob "messaggio"
# Capacita e rotazione
journalctl --disk-usage
sudo journalctl --vacuum-time=30d
sudo journalctl --vacuum-size=1G
# Configurazione
sudo systemctl edit systemd-journald.service
# [Journal]
# SystemMaxUse=1G
# SystemMaxFileSize=100M
# MaxRetentionSec=30day
La rotazione non si gestisce con logrotate: journald ha
i suoi limiti (SystemMaxUse=,
SystemMaxFileSize=, MaxRetentionSec=) e
cancella i file più vecchi quando serve spazio. Se il journal
cresce troppo, il problema non è la rotazione ma il volume
di log: un servizio in crash loop può scrivere migliaia di
righe al secondo.
Il rate limiting è attivo per default
(RateLimitIntervalSec=30s,
RateLimitBurst=10000 per sorgente). Quando un servizio
scrive troppo, journald sopprime i messaggi e aggiunge una riga
“Suppressed N messages”. Se serve tutto, si alza il
limite nell’unità con
LogRateLimitIntervalSec= e
LogRateLimitBurst=, non disattivando il limite globale.
Su Debian e Ubuntu rsyslog è spesso ancora
installato e riceve una copia dei messaggi se
ForwardToSyslog=yes; su RHEL e Fedora
rsyslog è presente per compatibilità con
/var/log/messages. Il journal resta la fonte
strutturata; i file di testo restano utili per strumenti che non
parlano il formato binario.
Boot, rescue ed emergenza
La sequenza è sempre la stessa: firmware, boot loader, kernel,
initramfs, systemd. systemd monta i file system residui, applica i
parametri del kernel, avvia i target e arriva a
default.target. Se qualcosa si blocca, la domanda non
è “quale servizio è lento” ma “quale
dipendenza sta aspettando”.
# Tempo complessivo e ripartizione
systemd-analyze
systemd-analyze blame
systemd-analyze critical-chain
systemd-analyze critical-chain multi-user.target
systemd-analyze plot > boot.svg
# Unita fallite e stato
systemctl --failed
systemctl is-system-running
journalctl -b -p err
# Verifica statica di tutte le unita
systemd-analyze verify /etc/systemd/system/*.service
# Cosa e successo nel boot precedente
journalctl -b -1 -p err
journalctl --list-boots
systemd-analyze blame elenca i tempi di attivazione
delle unità, ma un tempo alto può essere attesa, non
lavoro: un servizio che aspetta la rete compare in cima anche se non
consuma CPU. critical-chain mostra il percorso che ha
determinato il tempo totale, ed è più utile per capire
dove intervenire.
rescue.target avvia i servizi essenziali e una shell di
root; emergency.target monta solo il root filesystem,
in sola lettura se possibile, e non avvia praticamente nulla.
Entrambi si possono raggiungere da sistema avviato con
systemctl isolate, oppure dal boot loader aggiungendo
un parametro al kernel.
# Entrare in rescue da sistema attivo
sudo systemctl isolate rescue.target
# Tornare al default
sudo systemctl isolate default.target
# Parametri del kernel utili in GRUB
# systemd.unit=rescue.target
# systemd.unit=emergency.target
# systemd.mask=sshd.service
# systemd.setenv=DEBUG=1
# rd.break (initramfs di RHEL/Fedora)
# rd.shell (shell in initramfs)
# Se il root e montato in sola lettura
mount -o remount,rw /
systemctl default
# Reset password con rd.break
# mount -o remount,rw /sysroot
# chroot /sysroot
# passwd root
# touch /.autorelabel (solo con SELinux)
# exit; reboot
Attenzione a SELinux. Su RHEL e Fedora, cambiare
la password da rd.break senza
touch /.autorelabel lascia il file
/etc/shadow con un contesto sbagliato e il login
fallisce dopo il riavvio. Su Debian e Ubuntu il problema non
esiste, ma un remount,rw dimenticato rende il
sistema inutilizzabile fino al boot successivo.
systemctl reboot --firmware-setup riavvia direttamente
nel setup UEFI sulle macchine che lo supportano;
systemctl poweroff, reboot,
halt, suspend e
hibernate passano da systemd e chiudono i servizi in
ordine. systemctl kexec avvia un nuovo kernel senza
passare dal firmware, utile per ridurre i tempi di manutenzione.
Per chi usa systemd-boot, bootctl status
mostra le voci, bootctl list le elenca e
bootctl install installa il loader sulla ESP. Le voci
stanno in /boot/loader/entries/*.conf e
bootctl set-default cambia quella predefinita. Non
è obbligatorio: GRUB resta il default su Debian, Ubuntu,
RHEL e Fedora, e systemd-boot è comune su Arch e su sistemi
minimali.
Risorse, cgroup e slice
systemd è il gestore dei cgroup: ogni unità vive in un
cgroup, e i limiti dichiarati nell’unità diventano
valori nei file di /sys/fs/cgroup. La gerarchia
principale è -.slice con tre figli:
system.slice per i servizi di sistema,
user.slice per le sessioni e
machine.slice per container e macchine virtuali.
# Gerarchia e consumo
systemd-cgls
systemd-cgtop
systemctl status user-1000.slice
# Limiti persistenti su un servizio
sudo systemctl set-property miaapp.service MemoryMax=1G
sudo systemctl set-property miaapp.service MemoryHigh=800M
sudo systemctl set-property miaapp.service CPUQuota=150%
sudo systemctl set-property miaapp.service TasksMax=512
sudo systemctl set-property miaapp.service IOWeight=100
# Verifica
systemctl show miaapp.service -p MemoryMax -p CPUQuotaPerSecUSec -p TasksMax
cat /sys/fs/cgroup/system.slice/miaapp.service/memory.max
cat /sys/fs/cgroup/system.slice/miaapp.service/cpu.stat
| Direttiva | Effetto |
|---|---|
MemoryMax= | Limite rigido; oltre, OOM nel cgroup |
MemoryHigh= | Soglia di rallentamento, non kill |
MemoryMin=, MemoryLow= | Protezione dalla reclaim |
CPUQuota= | Percentuale di un core; 150% = 1,5 core |
CPUWeight= | Peso relativo tra cgroup |
AllowedCPUs= | Affinità ai core |
IOWeight= | Peso relativo I/O |
IOReadBandwidthMax= | Limite di banda per dispositivo |
TasksMax= | Numero massimo di task |
LimitNOFILE= | File descriptor massimi |
OOMPolicy= | continue, stop, kill |
Delegate=yes | Delega il cgroup a un gestore esterno |
systemctl set-property scrive un drop-in persistente
(in /etc/systemd/system.control/ per le unità di
sistema) e applica il limite subito, senza riavviare il servizio.
È comodo per una prova, ma per una configurazione stabile
conviene scrivere il drop-in a mano e tenerlo sotto controllo
versione.
# Drop-in leggibile e versionabile
sudo systemctl edit miaapp.service
# [Service]
# MemoryMax=1G
# MemoryHigh=800M
# CPUQuota=150%
# TasksMax=512
sudo systemctl daemon-reload
sudo systemctl restart miaapp.service
systemctl status miaapp.service | grep -E 'Memory|CPU|Tasks'
I limiti vanno scelti dopo aver misurato, non prima. Un
MemoryMax troppo basso trasforma un picco fisiologico
in un OOM kill; un CPUQuota troppo stretto produce
throttling e latenze che sembrano un problema applicativo. La
pagina Processi e risorse spiega come
leggere memory.events, cpu.stat e PSI per
calibrare i valori.
Le slice permettono di ragionare per gruppi: user.slice
contiene tutte le sessioni, system.slice tutti i
servizi. Impostare un limite su una slice è utile per
contenere un utente o un gruppo di servizi, ma non sostituisce il
limite per singolo servizio: un cgroup padre che distribuisce
risorse ai figli non può avere processi propri, e i limiti
si sommano lungo la gerarchia.
Hardening delle unità
systemd offre decine di direttive che restringono ciò che un
servizio può fare: file system, dispositivi, rete, namespace,
system call, capability. Non sono un sostituto di SELinux o
AppArmor, ma un secondo strato che riduce il danno quando un
servizio viene compromesso. systemd-analyze security
misura l’esposizione e suggerisce cosa manca.
# Punteggio di esposizione
systemd-analyze security
systemd-analyze security nginx.service
systemd-analyze security --offline=1 /etc/systemd/system/miaapp.service
# Output dettagliato
systemd-analyze security --no-pager miaapp.service
| Direttiva | Protegge da |
|---|---|
NoNewPrivileges=yes | Escalation via setuid e capability |
PrivateTmp=yes | Accesso a /tmp e /var/tmp condivisi |
PrivateDevices=yes | Accesso a dispositivi non necessari |
ProtectSystem=strict | Scrittura su /usr, /boot, /etc |
ProtectHome=yes | Lettura e scrittura delle home |
ReadWritePaths= | Eccezioni in sola scrittura |
ProtectKernelTunables=yes | Modifica di /proc/sys |
ProtectKernelModules=yes | Caricamento di moduli |
ProtectControlGroups=yes | Modifica della gerarchia cgroup |
RestrictAddressFamilies= | Socket di famiglie non usate |
RestrictNamespaces=yes | Creazione di namespace |
LockPersonality=yes | Cambio di personalità del processo |
MemoryDenyWriteExecute=yes | Pagine scrivibili ed eseguibili insieme |
SystemCallFilter=@system-service | System call fuori dall’insieme consentito |
CapabilityBoundingSet= | Capability disponibili |
PrivateNetwork=yes | Accesso alla rete |
# Esempio di servizio indurito
[Service]
DynamicUser=yes
StateDirectory=miaapp
RuntimeDirectory=miaapp
LogsDirectory=miaapp
NoNewPrivileges=yes
PrivateTmp=yes
PrivateDevices=yes
ProtectSystem=strict
ProtectHome=yes
ProtectKernelTunables=yes
ProtectKernelModules=yes
ProtectControlGroups=yes
RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
RestrictNamespaces=yes
LockPersonality=yes
MemoryDenyWriteExecute=yes
SystemCallFilter=@system-service
SystemCallErrorNumber=EPERM
CapabilityBoundingSet=
AmbientCapabilities=
ReadWritePaths=/srv/miaapp
DynamicUser=yes è comodo ma richiede che il
servizio usi StateDirectory=,
RuntimeDirectory=, CacheDirectory= o
LogsDirectory= per i suoi dati: systemd crea le
directory con l’UID giusto e le rimuove alla fine.
ProtectSystem=strict rende tutto il file system in
sola lettura tranne le directory dichiarate, e un servizio che
scrive in un percorso non elencato fallisce con
Read-only file system.
Metodo. Non applicare tutte le direttive in una
volta. Si parte da NoNewPrivileges,
PrivateTmp e ProtectSystem=full, si
riavvia, si guarda il journal, poi si aggiunge un gruppo di
direttive alla volta. systemd-analyze security dà
un punteggio, ma il criterio vero è che il servizio
continui a fare il suo lavoro.
Su RHEL e Fedora l’hardening convive con SELinux: un servizio può essere perfettamente confinato da systemd e comunque essere bloccato da un contesto SELinux sbagliato. Su Debian e Ubuntu il profilo AppArmor è spesso caricato dal pacchetto e va aggiornato se si cambia la configurazione. I due livelli si sommano, non si sostituiscono.
Rete, DNS e orologio
systemd include una pila di rete completa, ma non è
obbligatorio usarla. Debian e Ubuntu installano spesso
NetworkManager sui desktop e ifupdown o
systemd-networkd sui server; RHEL e Fedora usano
NetworkManager per default. systemd-resolved e
systemd-timesyncd sono componenti a sé stanti e la
loro presenza dipende dalla distribuzione e dal ruolo della macchina.
# Stato della rete con networkd
networkctl status
networkctl list
networkctl status eth0
# Configurazione dichiarativa
# /etc/systemd/network/20-wired.network
# [Match]
# Name=eth0
# [Network]
# DHCP=yes
# DNS=1.1.1.1 9.9.9.9
sudo systemctl enable --now systemd-networkd
sudo systemctl enable --now systemd-networkd-wait-online
# DNS con resolved
resolvectl status
resolvectl query example.com
resolvectl statistics
# Orologio e timezone
timedatectl
timedatectl set-timezone Europe/Rome
timedatectl set-ntp true
systemctl status systemd-timesyncd
chronyc tracking # se si usa chrony
network-online.target non fa nulla da solo: diventa
significativo quando è attivo un
wait-online. Con NetworkManager serve
NetworkManager-wait-online.service; con networkd serve
systemd-networkd-wait-online.service. Su molte
installazioni desktop il wait-online è disabilitato per
accelerare il boot, e un servizio che dipende dalla rete deve
gestire il ritardo da sé.
timedatectl mostra anche RTC in local TZ:
sui sistemi dual-boot con Windows è spesso
yes, e questo va tenuto presente quando si cambia
timezone. systemd-timesyncd è un client SNTP
leggero, adatto a desktop e server semplici; chrony
è la scelta quando serve precisione, server NTP o
sincronizzazione in ambienti virtualizzati.
# Hostname e identita
hostnamectl
sudo hostnamectl set-hostname lab01
hostnamectl status
# Chi gestisce la rete
systemctl status NetworkManager
systemctl status systemd-networkd
nmcli device status
ip -brief address
# Risoluzione
cat /etc/resolv.conf
ls -l /etc/resolv.conf
resolvectl dns
getent hosts example.com
/etc/resolv.conf è spesso un link a
/run/systemd/resolve/stub-resolv.conf o un file
gestito da NetworkManager. Modificarlo a mano è una
soluzione temporanea che sparisce al prossimo riavvio del servizio
di rete. La configurazione va messa dove la distribuzione la
legge: nmcli, un file .network, o
/etc/network/interfaces.
Domande frequenti e casi pratici
I problemi di systemd sono pochi e ricorrenti. Quasi sempre dipendono da una modifica non ricaricata, da una dipendenza mancante o da un’unità che non fa quello che sembra. Qui ci sono i casi che capitano davvero, con sintomo, causa e sequenza di soluzione.
Modifico il file .service ma non cambia nulla
Sintomo. Si edita
/etc/systemd/system/miaapp.service, si riavvia il
servizio e il comportamento è identico.
Causa. systemd ha già letto il file e non
se ne accorge da solo. Oppure si sta modificando un file vendor in
/usr/lib che viene sovrascritto, o si è
scritto un drop-in con lo stesso nome ma in una directory diversa.
Soluzione. Dopo ogni modifica:
daemon-reload, poi restart. Verificare
con systemctl cat quali file sono effettivamente in
uso e con systemctl show -p DropInPaths.
sudo systemctl edit miaapp.service
sudo systemctl daemon-reload
sudo systemctl restart miaapp.service
systemctl cat miaapp.service
systemctl show miaapp.service -p FragmentPath -p DropInPaths
systemd-analyze verify /etc/systemd/system/miaapp.service
Il servizio parte a mano ma non al boot
Sintomo. systemctl start funziona,
dopo il riavvio il servizio è inactive.
Causa. Manca enable, oppure la
sezione [Install] non ha WantedBy=, o il
target giusto non è quello predefinito. A volte il servizio
parte troppo presto e fallisce per una dipendenza non ancora
pronta.
Soluzione. Abilitare, controllare i link creati e
aggiungere le dipendenze di ordine corrette. Se serve la rete,
usare network-online.target con il relativo
wait-online.
sudo systemctl enable --now miaapp.service
systemctl is-enabled miaapp.service
ls -l /etc/systemd/system/multi-user.target.wants/miaapp.service
systemctl get-default
systemctl list-dependencies multi-user.target | grep miaapp
# Drop-in per l'ordine
sudo systemctl edit miaapp.service
# [Unit]
# After=network-online.target
# Wants=network-online.target
“start request repeated too quickly”
Sintomo. Il servizio è in
failed, systemctl start non fa nulla e il
journal parla di troppi avvii ravvicinati.
Causa. Il servizio fallisce subito e
Restart= lo riavvia in loop finché systemd
supera StartLimitBurst= e lo blocca.
Soluzione. Prima si corregge la causa nel journal,
poi si azzera il contatore con reset-failed. Aumentare
i limiti senza capire l’errore sposta solo il problema.
systemctl status miaapp.service
journalctl -u miaapp.service -b -n 100 --no-pager
systemctl reset-failed miaapp.service
sudo systemctl start miaapp.service
# Limiti espliciti, se il servizio e lento a partire
sudo systemctl edit miaapp.service
# [Unit]
# StartLimitIntervalSec=120
# StartLimitBurst=10
# [Service]
# RestartSec=10s
Il servizio è “active” ma il processo è già morto
Sintomo. systemctl status dice
active (running) ma la porta non risponde e
MainPID non esiste.
Causa. Type=forking con un
PIDFile= sbagliato, oppure un demone che fa fork e
lascia che il padre esca: systemd traccia il processo sbagliato.
Soluzione. Passare a Type=simple o
Type=notify, togliere il fork dal programma, oppure
correggere PIDFile=. Verificare con
systemctl show -p MainPID e
ps -p PID.
systemctl show miaapp.service -p MainPID -p ActiveState -p SubState
ps -o pid,ppid,stat,cmd -p "$(systemctl show -p MainPID --value miaapp.service)"
systemctl status miaapp.service --no-pager
# Nel drop-in
# [Service]
# Type=simple
# PIDFile=
“Unit is masked” o il servizio non parte per nessun motivo
Sintomo. systemctl start risponde
Unit miaapp.service is masked.
Causa. Esiste un link a /dev/null in
/etc/systemd/system: qualcuno ha mascherato
l’unità per impedirne l’avvio.
Soluzione. unmask, poi
daemon-reload. Se il mask è stato messo da un
pacchetto o da un’automazione, va rimosso alla fonte.
systemctl is-enabled miaapp.service
ls -l /etc/systemd/system/miaapp.service
sudo systemctl unmask miaapp.service
sudo systemctl daemon-reload
sudo systemctl enable --now miaapp.service
Il timer non scatta
Sintomo. Il timer è abilitato ma il servizio non parte mai, o parte a un orario diverso da quello atteso.
Causa. OnCalendar= non valido,
timezone diversa, Persistent=true senza directory di
stato, oppure il timer non è nel target
timers.target.
Soluzione. Validare l’espressione con
systemd-analyze calendar, controllare
systemctl list-timers --all e i log del timer.
systemd-analyze calendar '*-*-* 03:30:00'
systemctl list-timers --all
systemctl status backup.timer
journalctl -u backup.timer -b
journalctl -u backup.service -b
timedatectl
# Test manuale
sudo systemctl start backup.service
systemctl show backup.timer -p NextElapseUSecRealtime -p LastTriggerUSec
Dopo il riavvio il journal non ha i log precedenti
Sintomo. journalctl -b -1 risponde
“No such boot” o il journal parte sempre da zero.
Causa. Il journal è volatile: senza
/var/log/journal vive in /run e sparisce
al reboot. Storage=volatile forza questo
comportamento.
Soluzione. Creare la directory, impostare
Storage=persistent o auto, riavviare
journald. Verificare che /var non sia montato in
tmpfs.
sudo mkdir -p /var/log/journal
sudo systemd-tmpfiles --create --prefix /var/log/journal
sudo systemctl restart systemd-journald
journalctl --disk-usage
journalctl --list-boots
grep -E '^Storage' /etc/systemd/journald.conf
findmnt /var
Il disco è pieno per colpa del journal
Sintomo. /var/log/journal occupa
diversi GB, df è al 100%, i servizi non
scrivono più.
Causa. Limiti troppo alti o assenti, oppure un servizio in crash loop che genera migliaia di righe al secondo.
Soluzione. Ridurre subito con
--vacuum-size, poi impostare
SystemMaxUse= e correggere la causa del volume di log.
journalctl --disk-usage
sudo journalctl --vacuum-size=500M
sudo journalctl --vacuum-time=14d
sudo systemctl edit systemd-journald.service
# [Journal]
# SystemMaxUse=1G
# SystemMaxFileSize=100M
# MaxRetentionSec=30day
sudo systemctl restart systemd-journald
# Chi scrive troppo
journalctl --since '1 hour ago' -o json | jq -r '._SYSTEMD_UNIT' | sort | uniq -c | sort -rn | head
Il boot è diventato lentissimo
Sintomo. Il sistema impiega minuti ad arrivare al login, senza errori evidenti.
Causa. Un’unità che aspetta un timeout
di rete, un mount NFS irraggiungibile, un
network-online.target che non arriva, un servizio che
fa retry.
Soluzione. systemd-analyze blame per
l’elenco, critical-chain per il percorso critico,
poi journalctl -b -p warning per il motivo
dell’attesa.
systemd-analyze
systemd-analyze blame
systemd-analyze critical-chain
journalctl -b -p warning --no-pager
systemctl --failed
# Timeout espliciti per non aspettare 90 secondi
sudo systemctl edit nome.service
# [Service]
# TimeoutStartSec=20
# TimeoutStopSec=20
Devo entrare in rescue ma la password di root non funziona
Sintomo. systemctl isolate rescue.target
chiede la password di root, che però è bloccata o
sconosciuta.
Soluzione. Dal boot loader si aggiunge
systemd.unit=rescue.target o
rd.break; con rd.break si monta
/sysroot in scrittura, si fa chroot e si cambia la
password. Su SELinux serve touch /.autorelabel.
# In GRUB, editando la voce di boot
# linux ... systemd.unit=rescue.target
# linux ... rd.break
# Con rd.break
mount -o remount,rw /sysroot
chroot /sysroot
passwd root
touch /.autorelabel
exit
reboot
# Da sistema attivo, se si ha accesso sudo
sudo systemctl isolate rescue.target
sudo systemctl default
“Failed to connect to bus” in un container o chroot
Sintomo. Dentro un container o un chroot ogni
comando systemctl fallisce con
Failed to connect to bus: No such file or directory.
Causa. systemd non è PID 1 in quel contesto, quindi non esiste un bus di sistema a cui parlare. Un container avviato con una shell come PID 1 non ha un system manager.
Soluzione. Per ispezionare un’immagine senza
avviarla usare systemctl --root; per un container con
systemd usare un’immagine progettata per questo, con
/sbin/init come entrypoint e i privilegi necessari.
# Ispezione offline di una root
systemctl --root=/mnt/immagine list-unit-files
systemctl --root=/mnt/immagine enable sshd.service
# Container con systemd
podman run --systemd=always -d --name c1 immagine
podman exec c1 systemctl status
machinectl list
# Chroot: non si usa systemctl, si usano gli strumenti offline
chroot /mnt/immagine /bin/bash
Ho alzato il limite dei file ma il servizio ne ha ancora pochi
Sintomo. ulimit -n nella shell mostra
65535, il servizio continua a fallire con “too many open
files”.
Causa. I servizi systemd non passano da PAM e non
leggono /etc/security/limits.conf. Il limite va messo
nell’unità.
Soluzione. LimitNOFILE= nel drop-in,
daemon-reload, restart, verifica in
/proc/PID/limits.
systemctl show miaapp.service -p LimitNOFILE
sudo systemctl edit miaapp.service
# [Service]
# LimitNOFILE=65535
sudo systemctl daemon-reload
sudo systemctl restart miaapp.service
cat /proc/"$(systemctl show -p MainPID --value miaapp.service)"/limits | grep 'open files'
cat /proc/sys/fs/nr_open
DynamicUser e permessi sui file: “Permission denied”
Sintomo. Il servizio con
DynamicUser=yes non riesce a scrivere nella sua
directory.
Causa. L’UID dinamico cambia e non
corrisponde al proprietario dei file creati in precedenza; oppure
ProtectSystem=strict rende il percorso in sola
lettura.
Soluzione. Usare StateDirectory= e
ReadWritePaths=, che systemd gestisce con
l’UID corretto. Evitare di creare i file a mano con un utente
fisso.
sudo systemctl edit miaapp.service
# [Service]
# DynamicUser=yes
# StateDirectory=miaapp
# RuntimeDirectory=miaapp
# ReadWritePaths=/srv/miaapp
sudo systemctl daemon-reload
sudo systemctl restart miaapp.service
ls -ld /var/lib/miaapp /run/miaapp
journalctl -u miaapp.service -b | tail -n 30
Come faccio a sapere se un servizio è davvero indurito?
Soluzione. systemd-analyze security
dà un punteggio e l’elenco delle direttive mancanti.
Non è un verdetto: un punteggio alto può essere
accettabile per un servizio che deve accedere a tutto. L’obiettivo
è ridurre la superficie senza rompere il servizio.
systemd-analyze security miaapp.service
systemd-analyze security --offline=1 /etc/systemd/system/miaapp.service
systemctl show miaapp.service -p NoNewPrivileges -p ProtectSystem -p PrivateTmp
# Dopo ogni modifica
sudo systemctl daemon-reload
sudo systemctl restart miaapp.service
systemctl status miaapp.service
journalctl -u miaapp.service -b -p warning
systemctl --user non funziona via SSH o con sudo
Sintomo. systemctl --user status
risponde “Failed to connect to user scope bus”.
Causa. Manca XDG_RUNTIME_DIR, oppure
si sta eseguendo il comando come un altro utente senza il suo
ambiente. Dopo il logout l’user manager viene fermato se il
linger è disattivato.
Soluzione. Impostare
XDG_RUNTIME_DIR=/run/user/UID, abilitare il linger per
i servizi che devono restare attivi, usare
machinectl shell per una sessione pulita.
id -u
echo "$XDG_RUNTIME_DIR"
loginctl show-user "$USER" -p Linger
sudo loginctl enable-linger "$USER"
sudo -u alice XDG_RUNTIME_DIR=/run/user/"$(id -u alice)" systemctl --user status
machinectl shell alice@
Risposte rapide
| Domanda | Risposta |
|---|---|
| Dove sta il file di un’unità? | systemctl cat nome, systemctl show -p FragmentPath nome |
| Come ricarico dopo una modifica? | systemctl daemon-reload, poi restart |
| Differenza tra enable e start? | enable al boot, start adesso |
| Come fermo un servizio per sempre? | systemctl disable --now e, se serve, mask |
| Come vedo le dipendenze? | systemctl list-dependencies nome |
| Come vedo i timer? | systemctl list-timers --all |
| Come vedo i socket? | systemctl list-sockets |
| Come leggo i log di ieri? | journalctl --since yesterday --until today |
| Come limito la memoria di un servizio? | systemctl set-property nome MemoryMax=1G |
| Come misuro il boot? | systemd-analyze, blame, critical-chain |
| Come entro in single-user? | systemctl isolate rescue.target |
| Come abilito un servizio utente? | systemctl --user enable --now nome con linger attivo |
Fonti
man 1 systemctl,man 1 journalctl,man 1 systemd-analyze— comandi e opzioni dell’amministrazione quotidiana.man 5 systemd.unit,man 5 systemd.service,man 5 systemd.timer,man 5 systemd.socket,man 5 systemd.target— sintassi e semantica delle unità.man 5 systemd.exec,man 5 systemd.resource-control,man 5 systemd.kill— esecuzione, sandboxing, cgroup e segnali.man 5 journald.conf,man 5 journalctl,man 7 systemd.journal-fields— formato, rotazione, filtri e campi del journal.man 1 systemd-run,man 1 systemd-nspawn,man 1 bootctl— unità transienti, container e boot loader.man 5 systemd.network,man 1 resolvectl,man 1 timedatectl— networkd, resolved, timesyncd e orologio.- systemd upstream — NEWS, CHANGES WITH e documentazione del progetto, systemd.io; versione upstream v262 nel 2026.
- Debian, Ubuntu, Red Hat, Fedora e Arch Wiki — versioni pacchetto, default di distribuzione, procedure di recupero e differenze tra famiglie.
- Lennart Poettering, “systemd for Administrators” — serie di articoli introduttivi sul modello a unità.
systemd-analyze securityesystemd-analyze calendar— verifica pratica di hardening e espressioni calendario.
Comandi e comportamenti verificati il 14 novembre 2026 su kernel 7.x
e systemd delle principali distribuzioni. La versione cambia:
systemctl --version è l’unica risposta
affidabile per la macchina che si sta amministrando. Debian 13
“trixie” e RHEL 10 usano la serie 257, Ubuntu 26.04
“Resolute Raccoon” la serie 259, mentre l’upstream
è già alla 262. Le direttive descritte qui esistono in
tutte queste versioni, salvo dove indicato.