systemdper Svogliati
Il primo processo che parte e l'ultimo che muore. Avvia i servizi, li riavvia quando cadono, tiene i log, fa da cron, da DNS e da orologio. Odiato da molti, usato da tutti, capito da pochi. Rimediamo all'ultima parte.
"Il servizio non parte." — "Cosa dice systemctl status?" — "Non l'ho guardato." Ecco, quella.
Da una cartella di script alla guerra di religione
Pochi programmi hanno fatto litigare così tanto la comunità Linux. E pochi hanno vinto così completamente.
Con SysV init ogni servizio aveva uno script shell in /etc/init.d/, e l'ordine di avvio era deciso da nomi di file come S20apache2. Partiva tutto uno dopo l'altro, ogni script reinventava il modo di scrivere il PID su file, e se un servizio moriva alle tre di notte restava morto fino al mattino. Funzionava. Come funzionano le cose fatte con lo scotch.
SysV init
UNIX System V porta i runlevel e gli script di init. Linux lo eredita e se lo tiene per quasi trent'anni.
Upstart
Ubuntu prova un init a eventi: i servizi partono quando succede qualcosa (un disco montato, la rete su). Lo adottano anche Fedora e RHEL 6, per un po'.
Nasce systemd
Lennart Poettering e Kay Sievers propongono un init che avvia in parallelo, segue ogni processo con i cgroup e descrive i servizi in file dichiarativi, non in script. Fedora 15 lo adotta nel 2011.
La guerra di Debian
Il comitato tecnico di Debian vota, con discussioni infinite, per systemd come init predefinito. Una parte della comunità se ne va e crea Devuan, Debian senza systemd.
Partita chiusa
Debian 8 e Ubuntu 15.04 escono con systemd. Da qui in poi, quasi ogni distribuzione importante lo usa: impararlo non è più una scelta.
Molto più di un init
Log (journald), DNS (resolved), rete (networkd), orologio (timesyncd), login (logind), timer, file temporanei. Dal 2024 c'è anche run0, che prova a fare il lavoro di sudo. Le polemiche continuano. L'adozione pure.
Perché devi capirlo davvero
Perché ogni cosa che gira su un server Linux moderno, prima o poi, passa da lui.
Servizi che si rialzano
Una riga (Restart=on-failure) e il tuo programma torna su da solo quando cade. Niente più script di controllo in cron.
Log in un posto solo
Tutto quello che un servizio scrive finisce nel journal, con data, servizio e avvio. Niente più "dove scrive i log questo?".
Cron, ma meglio
I timer recuperano i giri persi a macchina spenta, hanno i log e non partono due volte insieme.
Sicurezza gratis
Dieci righe di sandbox e il tuo servizio non vede la home degli utenti, non scrive fuori dalla sua cartella e non diventa root.
Quando scrivere un'unità tua (e quando no)
Se un programma deve restare acceso o partire a orari fissi su un server, la risposta è quasi sempre "un'unità systemd".
| Situazione | Strumento | Perché |
|---|---|---|
| Un programma che deve restare acceso | .service | Riavvio automatico, log, utente dedicato, sandbox |
| Un lavoro a orari fissi | .timer + .service | Log, recupero dei giri persi, niente sovrapposizioni |
| Uno script veloce, una tantum | systemd-run o la shell | Non serve un file per una cosa che fai una volta |
| Un'app con tante dipendenze | Docker / Podman | Ma anche i container, su un server, spesso li avvia un'unità systemd |
| Un lavoretto dentro un container | Il processo del container | Dentro i container di solito systemd non c'è, ed è giusto così |
| Un cron che "va bene così da anni" | Lascialo | Svogliati, non masochisti: converti quando hai un motivo |
Il concetto chiave: dichiari, non programmi
Uno script dice come fare. Un'unità dice cosa vuoi. Al come ci pensa systemd.
Ogni unità è uno spartito: cosa suonare (ExecStart), chi deve aver già iniziato (After), chi serve per forza (Requires), cosa fare se uno stona (Restart). systemd legge tutti gli spartiti, decide l'ordine, fa partire in parallelo chi può, e tiene d'occhio ogni musicista dall'inizio alla fine. Tu non scrivi più "aspetta 5 secondi e poi avvia": scrivi "avvia dopo la rete".
Dopo una modifica, daemon-reload
systemd legge i file una volta e se li ricorda. Se cambi un'unità e non lanci systemctl daemon-reload, sta ancora usando quella di prima.
Mai toccare i file del pacchetto
Quelli in /lib/systemd/system/ li sovrascrive il prossimo aggiornamento. Si cambiano con un override in /etc (sezione 7).
"Dopo" non vuol dire "ha bisogno"
After= decide solo l'ordine. Wants= e Requires= decidono cosa avviare. Quasi sempre servono tutti e due.
| Tipo di unità | Cosa rappresenta |
|---|---|
.service | Un programma o un comando |
.timer | Quando avviare un servizio |
.target | Un gruppo di unità, un "momento" dell'avvio (come i vecchi runlevel) |
.socket | Una porta in ascolto che avvia il servizio alla prima connessione |
.path | Un file o una cartella da sorvegliare |
.mount | Un filesystem montato (anche quelli di /etc/fstab diventano unità) |
systemctl: i comandi di tutti i giorni
Una dozzina di comandi coprono il 95% della vita. Il primo da imparare è il primo della lista.
systemctl status nginx # stato, PID, memoria e ultime righe di log: guardalo SEMPRE per primo
sudo systemctl restart nginx # ferma e riavvia
sudo systemctl reload nginx # rilegge la configurazione senza fermarsi (se il servizio lo supporta)
sudo systemctl enable --now nginx # avvia adesso E a ogni accensione
sudo systemctl disable --now nginx# ferma e non avviare più all'accensione
sudo systemctl mask nginx # impedisce l'avvio anche a mano o come dipendenza
systemctl is-active nginx # "active" o no: comodo negli script
systemctl --failed # tutto quello che è andato storto
systemctl cat nginx # il file dell'unità, con tutti gli override
sudo systemctl daemon-reload # dopo aver modificato un'unità
start avvia adesso, enable fa partire all'accensione. Sono due cose diverse, ed è un classico ritrovarsi un servizio "abilitato ma spento" o "acceso ma sparito al riavvio". enable --now le fa tutte e due.
Scrivere un servizio
Un bot, un'API, uno script che deve girare sempre. Venti righe e diventa un servizio vero.
[Unit]
Description=Il mio bot
After=network-online.target
Wants=network-online.target
[Service]
Type=exec
User=mio-bot
WorkingDirectory=/opt/mio-bot
EnvironmentFile=/etc/mio-bot/env # token e segreti: fuori dal file dell'unità
ExecStart=/opt/mio-bot/venv/bin/python bot.py
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
sudo useradd --system --home /opt/mio-bot --shell /usr/sbin/nologin mio-bot
sudo systemctl daemon-reload
sudo systemctl enable --now mio-bot
systemctl status mio-bot
| Type= | Quando |
|---|---|
exec (o simple) | Il programma resta in primo piano: il caso normale per quasi tutto quello che scrivi tu |
notify | Il programma avvisa systemd quando è pronto davvero (molti demoni moderni) |
oneshot | Fa una cosa e finisce: perfetto con i timer |
forking | Vecchi demoni che si staccano in background da soli. Se puoi, evitalo |
Cambiare un servizio senza toccare il suo file
Il pacchetto aggiorna il suo file, tu tieni le tue modifiche. Pace in famiglia.
sudo systemctl edit nginx
# apre un editor e salva in /etc/systemd/system/nginx.service.d/override.conf
# scrivi SOLO le righe che cambiano, per esempio:
[Service]
Restart=always
LimitNOFILE=65536
# per cambiare ExecStart bisogna prima svuotarlo, poi riscriverlo:
[Service]
ExecStart=
ExecStart=/usr/sbin/nginx -g 'daemon off;'
systemctl cat nginx # vedi il risultato finale
sudo systemctl revert nginx # butta via le tue modifiche e torna a quello del pacchetto
| Cartella | Chi ci scrive | Priorità |
|---|---|---|
/etc/systemd/system/ | Tu | Vince su tutto |
/run/systemd/system/ | Unità temporanee, generate all'avvio | In mezzo |
/lib/systemd/system/ (o /usr/lib/…) | I pacchetti | Perde sempre: non toccarla |
journalctl: i log senza cercarli
Tutto quello che un servizio scrive su stdout e stderr finisce qui, già etichettato.
journalctl -u nginx # tutti i log di un servizio
journalctl -u nginx -f # in diretta, come tail -f
journalctl -u nginx --since "-1h" # ultima ora (anche "today", "2026-10-17 08:00")
journalctl -xeu nginx # le ultime righe, con le spiegazioni: il primo comando quando qualcosa non parte
journalctl -b # tutto dall'ultimo avvio
journalctl -b -1 -p err # solo gli errori dell'avvio PRIMA (dopo un crash)
journalctl -k # solo il kernel (come dmesg)
journalctl --disk-usage # quanto spazio occupa
sudo journalctl --vacuum-time=2weeks # butta via i log più vecchi di due settimane
sudo mkdir -p /var/log/journal e poi sudo systemctl restart systemd-journald, oppure Storage=persistent in /etc/systemd/journald.conf. Su un Raspberry con la SD, valuta il contrario: meno scritture, SD più longeva.
Timer: cron con la memoria
Due file invece di una riga. In cambio: log, recupero dei giri persi e nessuna sovrapposizione.
[Unit]
Description=Backup notturno
[Service]
Type=oneshot
ExecStart=/usr/local/bin/backup.sh
[Unit]
Description=Backup ogni notte alle 3
[Timer]
OnCalendar=*-*-* 03:00
Persistent=true # se era spento, parte appena si riaccende
RandomizedDelaySec=15min
[Install]
WantedBy=timers.target
sudo systemctl enable --now backup.timer # si abilita il TIMER, non il servizio
systemctl list-timers # prossima e ultima esecuzione di tutti i timer
systemd-analyze calendar "Mon..Fri 08:30" # controlla un'espressione prima di usarla
sudo systemctl start backup.service # lancialo subito, a mano, per provarlo
| cron | OnCalendar= |
|---|---|
*/5 * * * * | *:0/5 |
0 3 * * * | *-*-* 03:00 (o daily per mezzanotte) |
30 8 * * 1-5 | Mon..Fri 08:30 |
0 0 1 * * | monthly |
Sandbox: il servizio in una stanza chiusa
La parte di systemd che quasi nessuno usa ed è la più utile per la sicurezza.
NoNewPrivileges=yes # niente sudo, niente setuid: non può diventare root
ProtectSystem=strict # tutto il filesystem in sola lettura...
StateDirectory=mio-bot # ...tranne /var/lib/mio-bot, creata da systemd con i permessi giusti
ProtectHome=yes # le home degli utenti non esistono
PrivateTmp=yes # un /tmp tutto suo
PrivateDevices=yes # niente dischi né periferiche
ProtectKernelTunables=yes
ProtectControlGroups=yes
RestrictAddressFamilies=AF_INET AF_INET6 AF_UNIX
CapabilityBoundingSet=
# se serve un permesso preciso (es. leggere pacchetti di rete) dai solo quello:
# AmbientCapabilities=CAP_NET_RAW + CapabilityBoundingSet=CAP_NET_RAW
systemd-analyze security mio-bot # un voto da 0 a 10 (più basso = più chiuso) con l'elenco di cosa manca
Avvio e dipendenze
Chi parte prima, chi aspetta chi, e perché il tuo servizio parte "prima della rete".
| Direttiva | Cosa fa |
|---|---|
After=X | Se partiamo insieme, io parto dopo X. Non avvia X |
Wants=X | Avvia anche X; se X fallisce, io parto lo stesso |
Requires=X | Avvia anche X; se X fallisce o si ferma, mi fermo anch'io |
BindsTo=X | Come Requires, ma ancora più stretto: se X sparisce, sparisco |
WantedBy= (in [Install]) | Con quale target partire all'accensione quando fai enable |
🌐 La trappola della rete
network.target vuol dire solo "lo strato di rete è partito", non "ho un indirizzo". Se il tuo servizio deve parlare con l'esterno appena acceso, usa After=network-online.target e Wants=network-online.target. E scrivi il programma in modo che sopravviva a una rete che va e viene: prima o poi succede.
systemd-analyze # tempo totale di avvio
systemd-analyze blame # chi ci ha messo di più
systemd-analyze critical-chain # la catena che ha davvero fatto aspettare
systemctl get-default # multi-user.target (server) o graphical.target (desktop)
La famiglia allargata
systemd non è un programma solo. Ecco i parenti che incontrerai.
| Pezzo | Cosa fa | Comando utile |
|---|---|---|
| resolved | Il DNS del sistema, con cache (vedi la guida DNS) | resolvectl status |
| timesyncd | Tiene giusto l'orologio via NTP | timedatectl |
| logind | Sessioni, utenti collegati, coperchio del portatile | loginctl |
| networkd | Configurazione di rete, soprattutto su server e container | networkctl |
| tmpfiles | Crea e pulisce file e cartelle temporanee all'avvio | systemd-tmpfiles --clean |
| hostnamed | Nome della macchina | hostnamectl |
👤 Servizi senza root
Ogni utente può avere le sue unità in ~/.config/systemd/user/ e gestirle con systemctl --user. Per farle girare anche quando l'utente non è collegato: sudo loginctl enable-linger nomeutente.
👀 .path e .socket
Un'unità .path avvia un servizio quando un file cambia; un .socket tiene aperta una porta e avvia il servizio solo alla prima connessione. Potenti, ma pezzi in più da ricordare: usali quando servono davvero.
Debug: il servizio non parte
Quattro passi, sempre nello stesso ordine. Funzionano quasi sempre.
🔍 Il metodo
systemctl status servizio: la rigaActive:e il codice d'uscita (es.status=203/EXEC) dicono già metà della storia.journalctl -xeu servizio: le ultime righe del programma, con il motivo vero.- Lancia il comando a mano come lo lancerebbe systemd: stesso utente, stessa cartella.
sudo -u mio-bot -- /opt/mio-bot/venv/bin/python /opt/mio-bot/bot.py systemd-analyze verify mio-bot.service: errori di sintassi nel file dell'unità.
# gira come un servizio vero (utente, sandbox, log) ma senza creare l'unità
sudo systemd-run --unit=prova -p User=mio-bot -p ProtectHome=yes /opt/mio-bot/venv/bin/python /opt/mio-bot/bot.py
journalctl -u prova -f
Errori tipici, tradotti
Il numero dopo status= è il tuo migliore amico.
| Cosa vedi | Cosa vuol dire | Cosa fare |
|---|---|---|
status=203/EXEC | Non riesce a eseguire il programma | Percorso sbagliato, file non eseguibile, shebang sbagliato. In ExecStart scrivi sempre il percorso completo |
status=217/USER | L'utente di User= non esiste | Crealo (useradd --system) o correggi il nome |
status=200/CHDIR | Manca la cartella di WorkingDirectory= | Creala o correggi il percorso |
status=226/NAMESPACE | La sandbox non riesce a preparare un percorso | Un percorso in ReadWritePaths= non esiste: crealo prima |
start-limit-hit | È caduto troppe volte di fila e systemd ha smesso di riprovare | Sistema la causa, poi systemctl reset-failed servizio e riavvia |
| Parte e si ferma subito, "inactive (dead)" | Il programma è andato in background da solo | Toglilo dal background, oppure Type=forking con PIDFile= |
| "Unit not found" | systemd non conosce ancora il file | daemon-reload, e controlla che il nome finisca in .service |
| Le modifiche non hanno effetto | Niente daemon-reload, o un override che le sovrascrive | systemctl cat servizio mostra cosa sta usando davvero |
| Al riavvio della macchina non parte | Non è abilitato | systemctl enable servizio (e controlla WantedBy=) |
| Il timer non parte mai | Hai abilitato il servizio invece del timer | systemctl enable --now nome.timer, poi list-timers |
Da dove continuare
La documentazione di systemd è enorme. Per fortuna te ne serve un decimo.
🗺️ Un percorso in quattro tappe
- Oggi:
systemctl --failedesystemd-analyze blamesui tuoi server. Scoprirai cose. - Questa settimana: trasforma uno script che lanci con nohup o screen in un servizio vero, con utente dedicato e
Restart=on-failure. - Poi: un cron in un timer, e la sandbox della sezione 10 su un servizio tuo, controllata con
systemd-analyze security. - Dopo: servizi utente con
enable-linger, unità.pathe.socket, override sui servizi dei pacchetti.
| Risorsa | Cos'è |
|---|---|
man systemd.service, systemd.exec, systemd.unit, systemd.timer | Le pagine di manuale: lunghe, ma ogni opzione è spiegata. systemd.exec è quella della sandbox |
man systemd.directives | L'indice di tutte le direttive: ti dice in quale pagina cercare |
| Arch Wiki — systemd | La spiegazione più chiara e pratica che esista, valida anche fuori da Arch |
| systemd.io | Il sito del progetto, con i documenti di progetto e le novità |
| Linux Admin per Svogliati | Il quadro generale: utenti, permessi, dischi, log, cron |
systemctl status fino in fondo. Il motivo è quasi sempre scritto lì, nelle ultime tre righe. Solo che nessuno le legge.