Spiegazione dei Target di Systemd: Gestione Efficace degli Stati di Avvio e dei Runlevel

I target di systemd sono stati di sistema denominati. Un target può rappresentare un normale avvio del server, un desktop grafico, una shell di ripristino, uno spegnimento o un gruppo personalizzato di servizi che desideri avviare insieme. Se provieni da sistemi Linux più vecchi, i target sono la sostituzione di systemd per le parti dei runlevel che le persone usavano effettivamente, ma sono più flessibili perché sono costruiti da dipendenze invece che solo da numeri.

Di solito incontri i target quando un server si avvia nella modalità sbagliata, un gestore di display del desktop non si avvia o una guida di ripristino ti dice di inserire rescue.target. Conoscere alcuni comandi rende queste situazioni molto meno misteriose.

L'Evoluzione dai Runlevel ai Target di Systemd

Storicamente, i sistemi Linux utilizzavano un concetto chiamato runlevel per definire lo stato operativo del sistema durante l'avvio e l'esecuzione. Un runlevel era un identificatore numerico (0-6) che determinava quali servizi venivano avviati o arrestati. Ad esempio, il runlevel 3 di solito indicava una modalità testo multiutente, mentre il runlevel 5 indicava un ambiente multiutente grafico. Questo sistema, sebbene funzionale, presentava limitazioni:

Rigidità: I runlevel erano spesso definiti in modo fisso o specifico per distribuzione, rendendo scomodo personalizzare l'insieme esatto di servizi attivi per un dato stato.
Dipendenze Implicite: Le dipendenze tra servizi erano spesso gestite indirettamente tramite assegnazioni di runlevel, portando a potenziali conflitti o servizi mancanti.
Mancanza di Granularità: Il sistema numerico mancava di chiarezza descrittiva, rendendo più difficile comprendere lo stato previsto del sistema.

I target di systemd affrontano queste limitazioni fornendo un approccio più esplicito, guidato dalle dipendenze e descrittivo. Invece di numeri astratti, i target hanno nomi significativi (ad esempio, multi-user.target, graphical.target) che indicano chiaramente lo stato di sistema previsto. Le dipendenze sono definite esplicitamente nei file unit, garantendo che tutti i componenti necessari vengano avviati nell'ordine corretto.

La mappatura approssimativa su molti sistemi systemd è la seguente:

Runlevel tradizionale	Equivalente systemd comune	Significato
0	`poweroff.target`	Spegnimento e arresto
1	`rescue.target`	Modalità di ripristino a utente singolo
3	`multi-user.target`	Modalità testo/server multiutente
5	`graphical.target`	Modalità multiutente più login grafico
6	`reboot.target`	Riavvio

Tratta questo come un aiuto alla traduzione, non come una legge. Il comportamento dei runlevel variava tra le distribuzioni e i target di systemd possono esprimere relazioni che i vecchi runlevel non potevano.

Comprendere i Target di Systemd

Un target di systemd è esso stesso un tipo di unit. Quando un target viene attivato, systemd tenta di attivare tutte le unit elencate come dipendenze nel file unit di quel target. Questo crea un effetto a cascata, assicurando che tutti i servizi, i dispositivi e altri componenti necessari vengano portati online per raggiungere lo stato di sistema desiderato.

Caratteristiche Chiave dei Target di Systemd:

Gestione delle Dipendenze: I target definiscono quali altre unit devono essere attive affinché il target sia considerato raggiunto. Questo è il nucleo del loro potere.
Punti di Sincronizzazione: Agiscono come punti di sincronizzazione durante il processo di avvio. Il sistema non procederà alla fase successiva fino a quando il target corrente non sarà completamente inizializzato.
Nomenclatura Descrittiva: I target sono nominati in modo descrittivo, rendendo facile comprendere lo stato previsto del sistema (ad esempio, rescue.target, poweroff.target).

I target di solito non eseguono codice a lunga durata da soli. Raggruppano altre unit. Puoi ispezionare quel raggruppamento con:

systemctl list-dependencies multi-user.target
systemctl list-dependencies graphical.target

Questo è un buon modo per rispondere alla domanda: "Perché questo servizio si avvia all'avvio?" Se l'unit appare nell'albero delle dipendenze per il target predefinito, viene attirata da qualche parte.

Target Comuni di Systemd

Systemd viene fornito con una serie di target predefiniti progettati per coprire gli stati di sistema comuni. Comprendere questi è fondamentale per gestire il tuo sistema.

`multi-user.target`

Questo è uno dei target più fondamentali. Rappresenta un sistema multiutente completamente funzionale con rete abilitata ma senza un gestore di login grafico o un ambiente desktop. Questo è tipicamente il target predefinito per i server.

Scopo: Fornire un ambiente stabile per eseguire servizi e consentire a più utenti di accedere tramite console testuali o SSH.
Dipendenze: Di solito include unit per rete, servizi di sistema e prompt di login console.

Per i server headless, multi-user.target è di solito il valore predefinito corretto. Fornisce SSH e servizi normali senza spendere risorse per un gestore di display.

`graphical.target`

Questo target rappresenta un sistema multiutente completamente funzionale con un ambiente desktop grafico pronto per l'interazione dell'utente. È tipicamente un dipendente di multi-user.target e aggiunge i componenti necessari per una sessione grafica.

Scopo: Avviare un gestore di display grafico (come GDM, LightDM, SDDM) e l'ambiente desktop associato.
Dipendenze: Comunemente attira il comportamento di multi-user.target e aggiunge unit per un gestore di display e componenti di sessione grafica.

Se una workstation si avvia con schermo nero ma SSH funziona ancora, confronta questi:

systemctl get-default
systemctl status display-manager.service
journalctl -u display-manager.service -b

Il target predefinito ti dice cosa il sistema ha tentato di raggiungere. I log del gestore di display ti dicono perché il livello grafico si è o non si è avviato.

`rescue.target`

Questo target fornisce un ambiente minimo a utente singolo. Viene utilizzato principalmente per la manutenzione e il ripristino del sistema. Avvia il sistema di base e una shell di root ma tipicamente non avvia la rete o i servizi multiutente.

Scopo: Fornire un ambiente sicuro per gli amministratori di sistema per eseguire attività di manutenzione senza interferenze da altri servizi.
Dipendenze: Insieme minimo di componenti di sistema essenziali e una shell di root. La rete spesso non è disponibile a meno che non la si avvii manualmente.

`emergency.target`

Questo è ancora più minimale di rescue.target. Porta il sistema a un singolo filesystem di sola lettura e una shell di root. È destinato a situazioni di emergenza estrema dove anche i servizi di base potrebbero essere problematici.

Scopo: Per il ripristino critico del sistema quando anche rescue.target potrebbe non essere appropriato.
Dipendenze: Solo i componenti di sistema più essenziali e una shell di root. Il filesystem root potrebbe essere montato in sola lettura a seconda del guasto e della distribuzione.

`reboot.target`, `poweroff.target`, `halt.target`

Questi sono target speciali utilizzati per spegnere o riavviare il sistema. Quando systemd attiva uno di questi target, arresta tutti i servizi in esecuzione e quindi esegue l'azione specificata (riavvio, spegnimento o arresto).

Scopo: Spegnere o riavviare il sistema in modo ordinato.
Dipendenze: Tipicamente dipendono da servizi che devono essere arrestati prima che il sistema possa essere spento.

Gestione dei Target di Systemd

Systemd fornisce diversi strumenti da riga di comando per interagire con i target. Lo strumento principale è systemctl.

Visualizzazione dei Target Correnti e Predefiniti

Per vedere quale target il sistema sta attualmente eseguendo e quale target è predefinito all'avvio, usa:

systemctl status

Questo comando fornisce una grande quantità di informazioni, incluso il target attivo. Per interrogare specificamente il target predefinito:

systemctl get-default

Per vedere tutti i target disponibili:

systemctl list-unit-files --type=target

Per vedere i target attivi, usa:

systemctl list-units --type=target

La differenza è la stessa che per i servizi: list-unit-files mostra i file target che systemd conosce, mentre list-units mostra i target attualmente caricati o attivi nel sistema in esecuzione.

Cambiare il Target Predefinito

Se desideri che il tuo sistema si avvii in un target diverso per impostazione predefinita (ad esempio, da grafico a multiutente, o viceversa), puoi usare systemctl set-default:

Per impostare il predefinito sul target grafico (comune per sistemi desktop):

sudo systemctl set-default graphical.target

Per impostare il predefinito sul target multiutente (comune per server):

sudo systemctl set-default multi-user.target

Importante: La modifica del target predefinito avrà effetto solo al prossimo riavvio.

Sotto il cofano, questo cambia il collegamento simbolico default.target. Puoi ispezionarlo direttamente se stai eseguendo il debug di un'immagine di avvio danneggiata:

systemctl get-default
ls -l /etc/systemd/system/default.target

Passare a un Target (Senza Riavviare)

Puoi passare il sistema a un target diverso immediatamente senza riavviare. Questo è utile per testare o cambiare temporaneamente lo stato del sistema. Usa il comando systemctl isolate:

Per passare al target grafico:

sudo systemctl isolate graphical.target

Per passare al target multiutente:

sudo systemctl isolate multi-user.target

Attenzione: systemctl isolate è un comando potente. Isolare a un target come rescue.target o emergency.target fermerà la maggior parte dei servizi in esecuzione. Assicurati di comprendere le implicazioni prima di usarlo. Potresti perdere la connettività di rete o la tua sessione grafica.

Su un server remoto, fai particolare attenzione con isolate rescue.target o isolate emergency.target. Potresti perdere SSH e aver bisogno di accesso alla console tramite il tuo provider cloud, hypervisor o macchina fisica. Se hai solo bisogno di fermare il desktop grafico su una workstation, isolare a multi-user.target è meno drastico che saltare direttamente in modalità di ripristino.

Come i Target si Relazionano ai File Unit

I target sono implementati come file unit, tipicamente situati in /usr/lib/systemd/system/ o /etc/systemd/system/. Un file unit target (ad esempio, graphical.target) specifica dipendenze da altre unit, inclusi altri target e servizi.

Un tipico file unit graphical.target potrebbe assomigliare a questo (semplificato):

[Unit]
Description=Sistema multiutente grafico
Documentation=man:systemd.special(7)
# Questo target è inteso come prerequisito per il gestore di login grafico.
# È il target in cui il sistema si avvierà se non diversamente specificato.
Wants=display-manager.service
Before=shutdown.target

[Install]
Alias=default.target

Qui:

Wants=display-manager.service: Indica che display-manager.service (il gestore di login effettivo come GDM o LightDM) dovrebbe essere avviato se possibile. Questa è una dipendenza più debole di Requires=.
Before=shutdown.target: Assicura che l'ambiente grafico venga fermato prima che il sistema entri nel processo di spegnimento.
Alias=default.target: Questo fa sì che graphical.target agisca come predefinito se default.target è collegato ad esso (cosa che di solito accade per i sistemi desktop).

Creazione di Target Personalizzati

Sebbene meno comune per l'uso quotidiano, puoi creare i tuoi target personalizzati per definire stati di sistema specifici con insiemi unici di servizi.

Passaggi per Creare un Target Personalizzato:

Crea un file unit .target: Posizionalo in /etc/systemd/system/ (ad esempio, my-custom.target).

[Unit]
Description=Mio Target Personalizzato

[Install]
WantedBy=multi-user.target # O un altro target appropriato

Crea file .service o altre unit: Definisci i servizi e altre unit che dovrebbero essere attive per il tuo target personalizzato.

Aggiungi dipendenze: Nel file unit del tuo target personalizzato, usa Requires= o Wants= per specificare quali unit devono o dovrebbero essere avviate.

[Unit]
Description=Mio Target Personalizzato
Wants=service1.service
Wants=service2.service
After=service1.service service2.service

[Install]
WantedBy=multi-user.target

Ricarica systemd:

sudo systemctl daemon-reload 5. **Abilita/Avvia il tuo target:** bash sudo systemctl start my-custom.target # O per renderlo avviabile sudo systemctl enable my-custom.target ```

Caso d'Uso: Immagina un ambiente di sviluppo in cui hai bisogno di specifici server di database e applicazioni in esecuzione. Potresti creare un dev-env.target che avvia questi servizi.

I target personalizzati sono utili anche per sistemi simili ad appliance. Ad esempio, una macchina chiosco potrebbe avere un target che avvia la rete, un browser, un watchdog locale e un agente di logging, ma non il resto di una normale sessione desktop. Un server di laboratorio potrebbe avere target separati per uno stack di test e uno stack demo in modo che gli operatori possano avviare insieme un gruppo noto di servizi.

Migliori Pratiche e Suggerimenti

Comprendi il Predefinito: Conosci il target predefinito del tuo sistema (graphical.target o multi-user.target) poiché determina l'esperienza di avvio iniziale.
Usa isolate con Cautela: Fai attenzione quando usi systemctl isolate, specialmente su sistemi di produzione, poiché può interrompere i servizi in esecuzione.
Controlla le Dipendenze: Se un servizio non si avvia, esamina le dipendenze del target a cui è associato usando systemctl list-dependencies <nome_target>.
Server vs. Desktop: Sui server, multi-user.target è quasi sempre preferito per sicurezza ed efficienza delle risorse. Sui desktop, graphical.target è standard.
Manutenzione del Sistema: Per attività che richiedono interferenze minime, rescue.target è utile. Per il ripristino critico, è disponibile emergency.target.

Un Modo Pratico di Pensare ai Target

Per la maggior parte del lavoro di amministrazione, hai solo bisogno di un modello mentale breve:

systemctl get-default
systemctl set-default multi-user.target
systemctl isolate graphical.target
systemctl list-dependencies graphical.target

get-default ti dice dove la macchina dovrebbe avviarsi. set-default cambia il prossimo avvio. isolate cambia lo stato corrente e può fermare i servizi al di fuori di quello stato. list-dependencies spiega cosa attira un target.

I target non sono solo runlevel rinominati. Sono gruppi di dipendenze. Una volta che li tratti in questo modo, i problemi di avvio diventano più facili da ragionare: trova il target che il sistema ha tentato di raggiungere, ispeziona i servizi che voleva, quindi correggi l'unit o la dipendenza che è fallita.