Svogliati
🎛️

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.

↓
01 / 15

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.

💡 Prima c'erano gli script

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.

1983

SysV init

UNIX System V porta i runlevel e gli script di init. Linux lo eredita e se lo tiene per quasi trent'anni.

2006

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

2010

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.

2014

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.

2015

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.

Oggi

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.

02 / 15

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.

03 / 15

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

SituazioneStrumentoPerché
Un programma che deve restare acceso.serviceRiavvio automatico, log, utente dedicato, sandbox
Un lavoro a orari fissi.timer + .serviceLog, recupero dei giri persi, niente sovrapposizioni
Uno script veloce, una tantumsystemd-run o la shellNon serve un file per una cosa che fai una volta
Un'app con tante dipendenzeDocker / PodmanMa anche i container, su un server, spesso li avvia un'unità systemd
Un lavoretto dentro un containerIl processo del containerDentro i container di solito systemd non c'è, ed è giusto così
Un cron che "va bene così da anni"LascialoSvogliati, non masochisti: converti quando hai un motivo
04 / 15

Il concetto chiave: dichiari, non programmi

Uno script dice come fare. Un'unità dice cosa vuoi. Al come ci pensa systemd.

🎼 Il direttore d'orchestra

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

REGOLA 1

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.

REGOLA 2

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

REGOLA 3

"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
.serviceUn programma o un comando
.timerQuando avviare un servizio
.targetUn gruppo di unità, un "momento" dell'avvio (come i vecchi runlevel)
.socketUna porta in ascolto che avvia il servizio alla prima connessione
.pathUn file o una cartella da sorvegliare
.mountUn filesystem montato (anche quelli di /etc/fstab diventano unità)
05 / 15

systemctl: i comandi di tutti i giorni

Una dozzina di comandi coprono il 95% della vita. Il primo da imparare è il primo della lista.

bash · systemctl
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à
💡 enable non avvia, start non abilitastart 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.
06 / 15

Scrivere un servizio

Un bot, un'API, uno script che deve girare sempre. Venti righe e diventa un servizio vero.

/etc/systemd/system/mio-bot.service
[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
bash · attivarlo
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
notifyIl programma avvisa systemd quando è pronto davvero (molti demoni moderni)
oneshotFa una cosa e finisce: perfetto con i timer
forkingVecchi demoni che si staccano in background da soli. Se puoi, evitalo
⚠️ Niente "&", niente nohup, niente screenIl programma deve restare in primo piano: è systemd che lo tiene in vita. Se lo mandi in background da solo, systemd pensa che sia finito e lo "perde".
07 / 15

Cambiare un servizio senza toccare il suo file

Il pacchetto aggiorna il suo file, tu tieni le tue modifiche. Pace in famiglia.

bash · override
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
CartellaChi ci scrivePriorità
/etc/systemd/system/TuVince su tutto
/run/systemd/system/Unità temporanee, generate all'avvioIn mezzo
/lib/systemd/system/ (o /usr/lib/…)I pacchettiPerde sempre: non toccarla
08 / 15

journalctl: i log senza cercarli

Tutto quello che un servizio scrive su stdout e stderr finisce qui, già etichettato.

bash · journalctl
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
💾 I log spariscono al riavvio?Su alcune distribuzioni il journal sta solo in RAM. Per tenerlo su disco: 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.
09 / 15

Timer: cron con la memoria

Due file invece di una riga. In cambio: log, recupero dei giri persi e nessuna sovrapposizione.

/etc/systemd/system/backup.service
[Unit]
Description=Backup notturno

[Service]
Type=oneshot
ExecStart=/usr/local/bin/backup.sh
/etc/systemd/system/backup.timer
[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
bash · timer
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
cronOnCalendar=
*/5 * * * **:0/5
0 3 * * **-*-* 03:00 (o daily per mezzanotte)
30 8 * * 1-5Mon..Fri 08:30
0 0 1 * *monthly
10 / 15

Sandbox: il servizio in una stanza chiusa

La parte di systemd che quasi nessuno usa ed è la più utile per la sicurezza.

[Service] · righe da aggiungere
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
bash · quanto è chiuso?
systemd-analyze security mio-bot   # un voto da 0 a 10 (più basso = più chiuso) con l'elenco di cosa manca
✅ Il trucco da svogliatoAggiungi le righe una alla volta, riavvia e guarda il log. Se qualcosa si rompe, il messaggio dice quasi sempre quale percorso o permesso manca. Un servizio con il solo permesso che gli serve, invece che root, è il regalo più grande che puoi fare a chi lo attaccherà.
11 / 15

Avvio e dipendenze

Chi parte prima, chi aspetta chi, e perché il tuo servizio parte "prima della rete".

DirettivaCosa fa
After=XSe partiamo insieme, io parto dopo X. Non avvia X
Wants=XAvvia anche X; se X fallisce, io parto lo stesso
Requires=XAvvia anche X; se X fallisce o si ferma, mi fermo anch'io
BindsTo=XCome 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.

bash · perché l'avvio è lento?
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)
12 / 15

La famiglia allargata

systemd non è un programma solo. Ecco i parenti che incontrerai.

PezzoCosa faComando utile
resolvedIl DNS del sistema, con cache (vedi la guida DNS)resolvectl status
timesyncdTiene giusto l'orologio via NTPtimedatectl
logindSessioni, utenti collegati, coperchio del portatileloginctl
networkdConfigurazione di rete, soprattutto su server e containernetworkctl
tmpfilesCrea e pulisce file e cartelle temporanee all'avviosystemd-tmpfiles --clean
hostnamedNome della macchinahostnamectl

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

13 / 15

Debug: il servizio non parte

Quattro passi, sempre nello stesso ordine. Funzionano quasi sempre.

🔍 Il metodo

  1. systemctl status servizio: la riga Active: e il codice d'uscita (es. status=203/EXEC) dicono già metà della storia.
  2. journalctl -xeu servizio: le ultime righe del programma, con il motivo vero.
  3. 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
  4. systemd-analyze verify mio-bot.service: errori di sintassi nel file dell'unità.
bash · provare senza scrivere file
# 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
14 / 15

Errori tipici, tradotti

Il numero dopo status= è il tuo migliore amico.

Cosa vediCosa vuol direCosa fare
status=203/EXECNon riesce a eseguire il programmaPercorso sbagliato, file non eseguibile, shebang sbagliato. In ExecStart scrivi sempre il percorso completo
status=217/USERL'utente di User= non esisteCrealo (useradd --system) o correggi il nome
status=200/CHDIRManca la cartella di WorkingDirectory=Creala o correggi il percorso
status=226/NAMESPACELa sandbox non riesce a preparare un percorsoUn percorso in ReadWritePaths= non esiste: crealo prima
start-limit-hitÈ caduto troppe volte di fila e systemd ha smesso di riprovareSistema la causa, poi systemctl reset-failed servizio e riavvia
Parte e si ferma subito, "inactive (dead)"Il programma è andato in background da soloToglilo dal background, oppure Type=forking con PIDFile=
"Unit not found"systemd non conosce ancora il filedaemon-reload, e controlla che il nome finisca in .service
Le modifiche non hanno effettoNiente daemon-reload, o un override che le sovrascrivesystemctl cat servizio mostra cosa sta usando davvero
Al riavvio della macchina non parteNon è abilitatosystemctl enable servizio (e controlla WantedBy=)
Il timer non parte maiHai abilitato il servizio invece del timersystemctl enable --now nome.timer, poi list-timers
15 / 15

Da dove continuare

La documentazione di systemd è enorme. Per fortuna te ne serve un decimo.

🗺️ Un percorso in quattro tappe

  1. Oggi: systemctl --failed e systemd-analyze blame sui tuoi server. Scoprirai cose.
  2. Questa settimana: trasforma uno script che lanci con nohup o screen in un servizio vero, con utente dedicato e Restart=on-failure.
  3. Poi: un cron in un timer, e la sandbox della sezione 10 su un servizio tuo, controllata con systemd-analyze security.
  4. Dopo: servizi utente con enable-linger, unità .path e .socket, override sui servizi dei pacchetti.
RisorsaCos'è
man systemd.service, systemd.exec, systemd.unit, systemd.timerLe pagine di manuale: lunghe, ma ogni opzione è spiegata. systemd.exec è quella della sandbox
man systemd.directivesL'indice di tutte le direttive: ti dice in quale pagina cercare
Arch Wiki — systemdLa spiegazione più chiara e pratica che esista, valida anche fuori da Arch
systemd.ioIl sito del progetto, con i documenti di progetto e le novità
Linux Admin per SvogliatiIl quadro generale: utenti, permessi, dischi, log, cron
🎛️ L'ultimo consiglio da svogliatoPrima di cercare su Internet, leggi systemctl status fino in fondo. Il motivo è quasi sempre scritto lì, nelle ultime tre righe. Solo che nessuno le legge.