systemd

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.

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.

ComponenteRuolo
systemdPID 1, system manager e user manager
systemd-journaldRaccolta e conservazione dei log
systemd-logindSessioni, utenti, seat, inibizioni
systemd-udevdGestione eventi dei dispositivi
systemd-networkdConfigurazione di rete dichiarativa
systemd-resolvedResolver DNS, LLMNR, mDNS, DNSSEC
systemd-timesyncdSincronizzazione NTP leggera
systemd-coredumpRaccolta dei core dump
systemd-oomdOOM anticipato basato su PSI
systemd-homedHome directory portabili e cifrate
systemd-machinedRegistro di macchine e container
systemd-nspawnContainer leggero basato su namespace
systemd-bootBoot loader UEFI minimalista
systemd-analyze, systemd-runAnalisi 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.

TipoA cosa serveEsempio
serviceUn processo o un gruppo di processinginx.service
socketUn socket in ascolto che attiva un serviziosshd.socket
timerEsecuzione programmata di un’unitàlogrotate.timer
targetPunto di sincronizzazione, simile a un runlevelmulti-user.target
mountUn punto di mount gestito da systemdhome.mount
automountMount su richiestahome.automount
swapArea di swapdev-sda2.swap
pathAttivazione su modifica di un percorsocups.path
sliceGruppo gerarchico di cgroupuser.slice
scopeGruppo di processi creato dall’esternosession-1.scope
deviceDispositivo esposto dal kerneldev-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 avviatoUso tipico
simpleSubito dopo il fork di ExecStartDefault; processi che restano in foreground
execDopo che execve è riuscitaCome simple, ma distingue errori di esecuzione
forkingQuando il processo padre esceDemoni tradizionali che fanno fork
oneshotQuando il processo terminaScript di inizializzazione, job brevi
dbusQuando il nome D-Bus è sul busServizi D-Bus
notifyQuando arriva READY=1 su sd_notifyServizi che sanno dire quando sono pronti
notify-reloadCome notify, con ricarica via segnaleServizi con reload esplicito
idleDopo che le altre unità sono state avviateConsole, 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
noMai; è il default
on-successUscita con codice 0
on-failureCodice diverso da 0, segnale, timeout, watchdog
on-abnormalSegnale, timeout o watchdog
on-abortSegnale non gestito
on-watchdogWatchdog scaduto
alwaysSempre, 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.

ComandoEffetto
systemctl status nomeStato, PID, cgroup, ultime righe di log
systemctl start nomeAvvia adesso, senza abilitare al boot
systemctl stop nomeFerma adesso
systemctl restart nomeFerma e riavvia
systemctl reload nomeInvia la ricarica configurata, se esiste
systemctl reload-or-restart nomeReload se possibile, altrimenti restart
systemctl try-restart nomeRiavvia solo se era attivo
systemctl enable --now nomeAbilita al boot e avvia subito
systemctl disable --now nomeDisabilita e ferma
systemctl mask nomeImpedisce l’avvio in modo assoluto
systemctl is-active nomeactive, inactive, failed
systemctl is-enabled nomeenabled, disabled, static, masked
systemctl --failedSolo le unità in stato failed
systemctl list-dependencies nomeAlbero delle dipendenze
systemctl cat nomeFile unità e drop-in
systemctl show nome -p PROPValore effettivo di una proprietà
systemctl kill -s SIGKILL nomeSegnale a tutti i processi del cgroup
systemctl reset-failed nomeAzzera il contatore di fallimenti
systemctl daemon-reloadRilegge i file unità
systemctl daemon-reexecRiesegue 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.

TargetSignificato
poweroff.targetSpegnimento
rescue.targetSistema single-user, servizi essenziali, root shell
multi-user.targetSistema multiutente senza grafica
graphical.targetMultiutente con display manager
reboot.targetRiavvio
emergency.targetSolo 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.

DirettivaEffetto
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.

DirettivaSignificato
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
ComandoRisultato
journalctl -bLog del boot corrente
journalctl -b -1Log del boot precedente
journalctl --list-bootsElenco dei boot disponibili
journalctl -u nginx -fSegue i log dell’unità
journalctl -p err -bSolo 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 -kSolo messaggi del kernel
journalctl -o json-prettyFormato strutturato
journalctl _PID=1234Filtro per PID
journalctl _SYSTEMD_UNIT=sshd.serviceFiltro per unità
journalctl --vacuum-size=500MRiduce lo spazio usato
journalctl --verifyControlla 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
DirettivaEffetto
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=yesDelega 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
DirettivaProtegge da
NoNewPrivileges=yesEscalation via setuid e capability
PrivateTmp=yesAccesso a /tmp e /var/tmp condivisi
PrivateDevices=yesAccesso a dispositivi non necessari
ProtectSystem=strictScrittura su /usr, /boot, /etc
ProtectHome=yesLettura e scrittura delle home
ReadWritePaths=Eccezioni in sola scrittura
ProtectKernelTunables=yesModifica di /proc/sys
ProtectKernelModules=yesCaricamento di moduli
ProtectControlGroups=yesModifica della gerarchia cgroup
RestrictAddressFamilies=Socket di famiglie non usate
RestrictNamespaces=yesCreazione di namespace
LockPersonality=yesCambio di personalità del processo
MemoryDenyWriteExecute=yesPagine scrivibili ed eseguibili insieme
SystemCallFilter=@system-serviceSystem call fuori dall’insieme consentito
CapabilityBoundingSet=Capability disponibili
PrivateNetwork=yesAccesso 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

DomandaRisposta
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

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.