Nota:

Questa esercitazione è disponibile in un ambiente di laboratorio gratuito fornito da Oracle.
Utilizza valori di esempio per le credenziali, la tenancy e i compartimenti Oracle Cloud Infrastructure. Al termine del laboratorio, sostituire questi valori con quelli specifici del tuo ambiente cloud.

Usare un sistema su Oracle Linux

Introduzione

In questa esercitazione viene descritto come utilizzare la utility della riga di comando systemctl per gestire e visualizzare le unità di sistema controllate da systemd. Questa esercitazione è destinata agli utenti di Oracle Linux 8 o versione successiva.

systemd è il primo processo che viene avviato al boot e che è il processo finale per l'arresto del sistema. systemd viene utilizzato principalmente per gestire i servizi o i processi del sistema e l'inizializzazione del sistema al boot. Tuttavia, systemd è anche in grado di gestire molte altre attività e funzioni, incluso il log degli eventi, la gestione dei dispositivi, il login degli utenti, la pianificazione delle attività, la sincronizzazione dell'ora e l'avvio del sistema. Molte funzioni di systemd non sono completamente utilizzate, poiché gli utenti potrebbero essere più a proprio agio con software alternativo per questi scopi o distribuzioni Linux diverse potrebbero avere approcci preferiti alla configurazione del sistema.

Diversi tipi di comportamento o funzioni all'interno di systemd sono gestiti in unità sistemate. Ad esempio, i processi daemon o i servizi di sistema vengono eseguiti come unità di servizio, mentre gli stati del sistema vengono in genere definiti come unità di destinazione. Le unità timer possono essere definite per pianificare attività simili a quelle dell'utilizzo del servizio cron di sistema; un'unità di attivazione può essere utilizzata per configurare un punto di attivazione in modo analogo a quanto è possibile configurare un punto di attivazione nel fstab di sistema.

systemd viene utilizzato per gestire i processi e le funzioni a livello di sistema, ma è anche in grado di gestire i processi in esecuzione nello spazio utente. Gli utenti di un sistema possono configurare e gestire i propri servizi e systemd possono anche essere configurati per consentire a tali servizi di continuare l'esecuzione dopo che l'utente ha terminato la sessione.

Obiettivi

Rileva i diversi tipi di unità systemd
Usa unità di destinazione systemd
Informazioni sulla sintassi comune del comando systemctl
Creare una propria unità timer sistemata nello spazio utente
Configurare systemd per consentire l'esecuzione dei processi di spazio utente dopo il logout

Di cosa hai bisogno?

Sistema con Oracle Linux 8 installato.

Nota: quando si utilizza l'ambiente di laboratorio gratuito, consultare Oracle Linux Lab Basics per le istruzioni di connessione e altro tipo.

Esplorare i file unità di sistema

Dopo aver eseguito la connessione all'istanza di Oracle Linux 8, è possibile iniziare a sperimentare con il comando systemctl per conoscere le diverse unità disponibili.

Eseguire il comando systemctl per elencare tutte le unità sistemd attualmente caricate da systemd:
```
systemctl
```
Utilizzare i tasti Space o PgDn della tastiera per scorrere l'output.

Questo comando equivale all'esecuzione:
```
systemctl list-units
```
L'output mostra tutte le unità di configurazione attualmente attive che systemd gestisce. Nell'output è necessario notare che esistono unità denominate con suffissi diversi, incluse le unità denominate con i suffissi '.device', '.mount','.service', '.target' e '.timer'.

Le unità sono attive nel senso che sono avviate, in esecuzione, montate o collegate, a seconda del loro scopo. Le unità possono essere inattive nel senso che sono fermate, disinstallate o disconnesse. Se si desidera visualizzare tutte le unità indipendentemente dal fatto che siano attive o meno, è possibile eseguire:
```
systemctl list-units --all
```
L'output di questi comandi mostra una selezione dei diversi tipi di unità systemd:
- automount: offre funzionalità di attivazione automatica per l'installazione su richiesta dei file system e il boot-up in parallelo.
- mount: controlla i punti di attivazione nel file system visualizzato per data e ora correnti.
- path: è possibile attivare i servizi quando le informazioni sul percorso del file system vengono modificate.
- scope: simile alle unità di servizio, ma gestisce i processi esteri invece di avviarli.
- service: avvia e controlla i daemon e i processi di cui sono costituiti.
- slice: consente di raggruppare le unità che gestiscono i processi di sistema, ad esempio le unità di servizio e le unità di ambito, nella struttura gerarchica dei gruppi di celle a scopo di gestione delle risorse.
- socket: incapsula i socket di comunicazione tra processi locali o di rete nel sistema, utili per l'attivazione basata sul socket.
- target: usato per raggruppare le unità o per fornire punti di sincronizzazione ben noti durante il boot-up.
- timer: consente di attivare altre unità utilizzando i timer. Queste funzioni forniscono un'alternativa alle attività che potrebbero essere state gestite in precedenza utilizzando il servizio cron.
- device: espone i dispositivi kernel nella directory systemd e può essere utilizzato anche per implementare l'attivazione basata sul dispositivo.
- swap: incapsula partizioni di swap o file di swap della memoria.
Limitare l'elenco delle unità a un determinato tipo di unità utilizzando l'opzione --type.
- Utilizzare il comando systemctl list-units --type services per elencare le unità di servizio attualmente attive sul sistema.
```
systemctl list-units --type service
```
- Eseguire di nuovo lo stesso comando, ma includere l'opzione --all per visualizzare tutte le unità caricate, comprese quelle inattive, se presenti.
```
systemctl list-units --type service --all
```

È possibile ripetere questi comandi per ognuno dei tipi di servizio disponibili, in modo da limitare le informazioni solo al tipo con cui si è interessati a lavorare in qualsiasi momento.

Gestione unità di destinazione sistemate

Le unità di destinazione vengono utilizzate per raggruppare unità diverse per portare il sistema a uno stato particolare in modo che sia pronto a funzionare per uno scopo specifico.

Elencare le unità target disponibili.
```
systemctl list-units --type target
```
Le unità possono richiedere il caricamento o la configurazione di altre unità in conflitto con unità specifiche. Ad esempio, multi-user.target richiede il funzionamento di basic.target e crea un conflitto anche con le unità rescue.service e rescue.target. Le unità specificano anche altre unità che desiderano caricare per poter funzionare.

In questo modo, le destinazioni possono essere concatenate per impostare uno stato particolare, ma sono anche abbastanza modulari da essere riutilizzate per attivare uno stato alternativo.
Visualizzare l'unità di destinazione predefinita.

L'unità di destinazione predefinita definisce lo stato di sistema predefinito dopo il boot.
- Utilizzare il comando systemctl get-default per visualizzare l'unità di destinazione utilizzata per impostazione predefinita. L'unità di destinazione predefinita è rappresentata dal file /etc/systemd/system/default.target.
```
systemctl get-default
```
- Utilizzare il comando ls -l per visualizzare le informazioni sul file /etc/systemd/system/default.target.
```
ls -l /etc/systemd/system/default.target
```
  Nota: il file default.target è un collegamento simbolico al file dell'unità di destinazione predefinita corrente.
Modificare l'unità di destinazione predefinita.
- Utilizzare il comando systemctl set-default per modificare l'unità di destinazione predefinita nell'unità graphical.target.
```
systemctl set-default graphical.target
```
- Usare il comando ls –l per confermare che il file default.target è ora un collegamento simbolico al file graphical.target.
```
ls -l /etc/systemd/system/default.target
```
  Nota: la modifica dell'unità di destinazione predefinita comporta la rimozione del collegamento simbolico default.target esistente e la ricreazione del collegamento simbolico, che punta alla nuova unità di destinazione predefinita.
Esplora una destinazione per ulteriori informazioni.
- Utilizzare il comando systemctl show per ottenere ulteriori informazioni su qualsiasi destinazione specifica.
```
systemctl show multi-user.target
```
  L'output mostra tutti i parametri per la destinazione specificata. Tenere presente che è possibile identificare le unità con cui la destinazione richiede, richiede e crea conflitti e che è possibile visualizzare anche le unità con cui questa destinazione deve essere eseguita prima e dopo.
- Utilizzare il comando systemctl list-dependencies per visualizzare la struttura delle dipendenze richieste o richieste per una destinazione specifica per raggiungerne lo stato:
```
systemctl list-dependencies default.target
```
  Questo comando mostra tutte le unità avviate all'avvio della destinazione predefinita. La catena di unità è presentata in modo ricorsivo in un albero che permette di valutare completamente ciò che l'obiettivo raggiunge quando inizia. Se la destinazione predefinita è graphical.target, è possibile notare che il sistema desidera eseguire display-manager.service per caricare la visualizzazione grafica ma esegue anche multi-user.target per eseguire tutte le operazioni necessarie prima di eseguire la visualizzazione grafica.

Uso di systemctl per abilitare, disabilitare e mascherare le unità

Le unità possono essere disattivate o attivate e possono anche essere mascherate in modo da non correre mai in nessuna circostanza. Alcune unità sono statiche in quanto sono sempre disponibili, in genere perché rappresentano dipendenze per il funzionamento di altre unità. Il comando systemctl list-units può essere utilizzato solo per mostrare le unità attive o inattive nel sistema.

Elencare tutte le unità disponibili nel sistema, insieme al relativo stato:
```
systemctl list-unit-files
```
Molte delle unità disponibili sono statiche. Unità abilitate in fase di avvio. Le unità disabilitate sono unità disponibili nel sistema, ma non configurate per l'avvio al boot. Le unità mascherate sono disponibili nel sistema, ma sono state impostate attivamente su uno stato in cui non è possibile avviarle.
Utilizzare il comando systemctl status per visualizzare informazioni dettagliate sull'unità nfs-server.service.
```
systemctl status nfs-server.service
```
Il comando systemctl consente di rilasciare l'estensione .service quando si fa riferimento alle unità di servizio.

Il comando di stato indica se un'unità è abilitata, attiva, inattiva, disabilitata o mascherata.

Per le soluzioni con script, systemctl fornisce brevi comandi per l'output dello stato in un'unica riga:
- Utilizzare il comando systemctl is-active per controllare se il servizio nfs-server è in esecuzione (attivo) o non in esecuzione (inattivo).
```
systemctl is-active nfs-server
```
- Utilizzare il comando systemctl is-enabled per controllare se il servizio nfs-server è abilitato o disabilitato. Quando il servizio è abilitato, il riavvio del sistema viene avviato.
```
systemctl is-enabled nfs-server
```
Abilitare l'avvio del servizio al boot.

Utilizzare il comando systemctl enable per abilitare il servizio nfs-server.
```
sudo systemctl enable --now nfs-server
```
Se il comando modifica lo stato del sistema o la configurazione, è necessario eseguire il comando systemctl con privilegi di amministratore. È possibile utilizzare l'opzione --now per avviare ulteriormente il servizio nello stesso momento in cui viene abilitato.

Nota: il comando consente al servizio di creare un collegamento simbolico per la destinazione a stato del sistema di livello più basso a partire dalla quale viene avviato il servizio. Nell'output il comando ha creato il collegamento simbolico nfs-server.service per la destinazione multi-user.

Utilizzare systemctl status command per confermare che il servizio nfs-server è ora abilitato e in esecuzione.
```
systemctl status nfs-server
```
Disabilitare e arrestare un servizio.

Utilizzare il comando systemctl disable per disabilitare il servizio nfs-server. Si noti anche che il comando systemctl disable elimina il collegamento systemctl per il servizio.
```
sudo systemctl disable nfs-server
```
Utilizzare il comando systemctl stop per arrestare il servizio nfs-server.
```
sudo systemctl stop nfs-server
```
È possibile combinare questi passi utilizzando l'opzione --now quando si disabilita il servizio.
Visualizzare e annullare la maschera di un'unità.

In alcuni casi, è possibile disattivare l'avvio delle unità. In genere, è possibile eseguire questa operazione se una determinata unità è in conflitto con altre funzionalità del sistema o per un motivo del criterio.

Utilizzare il comando systemctl mask per mascherare il servizio nfs-server.
```
sudo systemctl mask nfs-server
```
Viene creato un collegamento simbolico per assicurarsi che la configurazione dell'unità systemd punti a /dev/null. Ciò impedisce che il servizio venga abilitato o avviato.

Confermare che non è possibile avviare l'unità nfs-server mentre è mascherata:
```
sudo systemctl start nfs-server
```
Il servizio non può essere avviato e viene restituito un errore per indicare che il servizio è mascherato.

Annullare la maschera per ripristinare lo stato originale dell'unità e consentire agli utenti di avviare o abilitare il servizio.
```
sudo systemctl unmask nfs-server
```

Impostare systemd per unità spazio utente

In generale, systemd viene utilizzato per gestire le unità a livello di sistema. Per gestire le unità di sistema configurate in questo modo, gli utenti richiedono l'accesso a livello di amministratore al sistema. In alcuni ambienti e per alcuni tipi di unità, gli utenti potrebbero voler utilizzare la capacità di systemd di eseguire unità all'interno dello spazio utente. Ad esempio, gli utenti possono programmare le attività utilizzando le funzionalità dell'unità timer di sistema oppure possono voler eseguire applicazioni o servizi specifici come unità di servizio che non richiedono l'autorizzazione a livello radice per l'esecuzione.

systemd avvia un processo utente systemd per un utente al login. Le unità presenti nelle seguenti directory vengono elaborate nel seguente ordine per l'utente:

/usr/lib/systemd/user/: unità di spazio utente fornite dai pacchetti installati
$HOME/.local/share/systemd/user/: unità di spazio utente dai pacchetti installati nella directory home
/etc/systemd/user/: unità utente globali a livello di sistema che devono essere eseguite nello spazio utente per tutti gli utenti
$HOME/.config/systemd/user/: unità create dall'utente

È possibile indicare a systemd che si sta lavorando nello spazio utente utilizzando l'opzione --user per qualsiasi comando systemd.

Elenca i file unità attualmente disponibili per l'utente.
```
systemctl --user list-unit-files
```
Si noti che l'elenco delle unità disponibili è molto più breve di quando si è eseguito lo stesso comando senza l'opzione --user.

La maggior parte di questi file di unità, su un nuovo sistema si trova in /usr/lib/systemd/user. Elencare i file di questa directory per visualizzare le unità che si trovano qui:
```
ls -la /usr/lib/systemd/user/
```
Creare una directory in cui memorizzare i propri file di unità sistemati.
```
mkdir -p $HOME/.config/systemd/user
```
Creare una propria unità di servizio sistemata.
```
cat << EOF > $HOME/.config/systemd/user/uptime.service
[Unit]
Description="Logs system uptime and load average"
Wants=uptime.timer

[Service]
ExecStart=/usr/bin/uptime

[Install]
WantedBy=default.target

EOF
```
Questa unità di servizio fornisce tre sezioni di configurazione.

La sezione Unit fornisce una descrizione dell'unità ed eventuali requisiti. In questo caso, una voce Wants definisce un requisito debole per un'unità timer che non esiste ancora. Le unità elencate come voci Wants vengono eseguite se sono disponibili ma non impediscono l'esecuzione dell'unità padre se non vengono trovate o se non vengono eseguite.

La sezione Service definisce il comportamento di questa specifica unità di servizio quando viene eseguita. Per le opzioni disponibili, è possibile specificare solo la riga ExecStart, che specifica il comando che viene eseguito all'avvio del servizio. In questo caso, viene eseguito il comando uptime per registrare i valori di tempo di attività e caricamento del sistema.

La sezione Install definisce in che modo il servizio deve essere installato sul sistema quando viene abilitato. In particolare, il servizio viene aggiunto come servizio WantedBy 'default.target'. Ciò significa che il servizio è abilitato come parte della destinazione predefinita per questo utente.
Eseguire l'unità systemd e controllarne l'output.

Poiché è stata aggiunta una nuova unità, in genere è consigliabile ricaricare la configurazione sistemata prima di tentare di eseguire il servizio:
```
systemctl --user daemon-reload
```
Ora avviare la nuova unità.
```
systemctl --user start uptime
```
Controllare che il comando sia stato eseguito come previsto. È possibile verificare che il servizio sia stato eseguito controllando il relativo stato:
```
systemctl --user status uptime
```
Nota: questi comandi utilizzano l'opzione --user per l'esecuzione nello spazio utente.

Per controllare l'output del comando uptime eseguito, utilizzare il comando journalctl per visualizzare il log e specificare l'opzione di tag per visualizzare i log specifici del comando:
```
journalctl -t uptime
```
È possibile abilitare questo servizio in modo che venga avviato al primo login al sistema da parte dell'utente.
```
systemctl --user enable uptime
```
Tenere presente che il servizio viene eseguito quando l'utente esegue il primo login al sistema. Non viene avviato automaticamente al boot del sistema. In genere, i servizi eseguiti nello spazio utente vengono interrotti dopo l'esecuzione del logout dell'utente o dopo l'interruzione di tutte le sessioni utente. L'abilitazione della persistenza per i servizi utente viene descritta più avanti in questa esercitazione.

Gestione unità timer sistemate

In questo esercizio, si basa sull'esercizio precedente per creare e abilitare un'unità timer per eseguire regolarmente un'altra unità sistemata in un determinato momento o intervallo. Le unità timer possono essere definite sia a livello di sistema che a livello di utente e possono essere utilizzate per definire quando Systemd deve eseguire un'altra unità. Le unità timer forniscono un controllo granulare sugli eventi programmati e possono fungere da alternativa all'utilizzo del daemon cron per gestire configurazioni più sottili.

Molti servizi di sistema includono unità timer da controllare quando vengono eseguiti. Un ottimo esempio di unità timer è incluso nel pacchetto dnf-automatic che può essere utilizzato per mantenere aggiornato il sistema quando esegue regolarmente aggiornamenti dnf automaticamente. Per visualizzare questa impostazione in azione a livello di sistema, installare il pacchetto e abilitare l'unità timer:

sudo dnf install -y dnf-automatic
sudo systemctl enable dnf-automatic.timer

È possibile visualizzare il file di unità per verificare la configurazione dell'unità:

cat /usr/lib/systemd/system/dnf-automatic.timer

Contenuto notevole in questa unità, includere una riga Wants che prevede di soddisfare il valore network-online.target. La voce OnCalendar nella sezione Timer della configurazione indica che questa azione viene eseguita ogni giorno all'indirizzo 06h00. Anche di interesse è la voce RandomizedDelaySec, che può aiutare a prevenire le unità timer da tutti accendere esattamente allo stesso tempo e spingere il carico del sistema improvvisamente.

L'esempio fornito fa parte di un set di unità molto più complesso. Per comprendere meglio il funzionamento delle unità timer, aggiungere un'unità timer nello spazio utente per programmare il valore uptime.service creato nell'esercizio precedente in modo che venga eseguito a intervalli regolari.

Creare un file unità timer.
```
cat <<EOF > $HOME/.config/systemd/user/uptime.timer
[Unit]
Description=Timer for the uptime service that logs uptime
Requires=uptime.service

[Timer]
Unit=uptime.service
OnCalendar=*-*-* *:*:00

[Install]
WantedBy=timers.target
```
Questo file specifica che il valore uptime.service è richiesto per l'esecuzione di questa unità timer. Si tratta di un requisito molto più forte di quello definito in una definizione Wants e l'unità non viene eseguita se il requisito non è soddisfatto.

La sezione Timer definisce il caricamento dell'unità uptime.service mediante una voce OnCalendar. La voce OnCalendar funziona in modo simile alle opzioni in una definizione crontab ma fornisce una maggiore granularità. In questo caso, l'unità viene definita per l'esecuzione ogni minuto a 00 secondi.
Dopo aver modificato la configurazione di sistema, ricaricare i daemon sistemati e riavviare il servizio di tempo di attività in modo da poter selezionare la nuova unità timer:
```
systemctl --user daemon-reload
systemctl --user restart uptime
```
Elencare le unità per verificare che le unità uptime.service e uptime.timer siano in esecuzione.
```
systemctl --user list-units
```
Monitorare l'output del log nel giornale per visualizzare l'output del tempo di attività attivato dal servizio tempo di attività in esecuzione ogni minuto.
```
journalctl -f -t uptime
```
Dopo un paio di minuti, dovrebbero essere visualizzate diverse linee di output. Se si sta prestando particolare attenzione, è possibile notare che il comando tempo di attività non attiva sempre esattamente il minuto. Questa è una funzionalità intenzionale all'interno della funzionalità timer sistemati. I job del timer vengono attivati con un randomizzatore che consente l'attivazione di un task con un ritardo massimo di un minuto. Ciò consente di evitare che i timer vengano attivati contemporaneamente. È possibile forzare l'accuratezza di un timer impostando la precisione all'interno di un nanosecondo dell'evento programmato aggiungendo la seguente voce di configurazione alla sezione Timer dell'unità timer:
```
AccuracySec=1us
```
Tuttavia, per la maggior parte delle attività, è consigliabile evitare che le attività vengano eseguite in modo troppo sincrono.

È possibile utilizzare la combinazione di tasti Ctrl-C per uscire dal giornale al termine del monitoraggio.

Configurare i processi di spazio utente per continuare dopo il logout

Per impostazione predefinita, i servizi e i processi avviati e di proprietà di un utente vengono interrotti quando l'utente esegue il logout o quando tutte le sessioni per l'utente sono terminate. Esistono diversi metodi da utilizzare per modificare questo comportamento predefinito all'interno di systemd. Qui sono esplorate due opzioni.

Usare il comando loginctl per abilitare gli utenti finali di sistema

Il comando loginctl può essere utilizzato per modificare il comportamento predefinito per un utente specifico e per abilitare i processi per tale utente su 'linger' dopo l'interruzione della sessione dell'utente.

Utilizzare la utility loginctl per abilitare la lingua per un utente specifico. In questa istanza, abilitare il funzionamento standard systemd per l'utente 'oracle':
```
sudo loginctl enable-linger oracle
```
Per verificare che l'impostazione venga applicata, controllare che un file con lo stesso nome dell'utente all'interno della directory /var/lib/systemd/linger.
```
ls /var/lib/systemd/linger/oracle
```
Il comando dovrebbe verificare l'esistenza del file.

Modificare il file systemd logind.conf

Systemd gestisce gli eventi di login utente e fornisce un file di configurazione che può essere modificato per impostare il funzionamento predefinito per eventi diversi correlati alla sessione dell'utente. Questo file di configurazione si trova in /etc/systemd/logind.conf.

Eseguire il dump del contenuto della configurazione esistente in /etc/systemd/logind.conf sullo schermo per controllare:
```
cat /etc/systemd/logind.conf
```
La maggior parte delle opzioni viene commentata ma vengono visualizzati i valori predefiniti per la compilazione del tempo. In questo file sono disponibili tre opzioni che consentono di controllare il modo in cui systemd gestisce i processi in esecuzione nello spazio utente al termine della sessione dell'utente.
- KillUserProcesses: questa opzione può controllare se i processi utente vengono interrotti o meno per impostazione predefinita al termine della sessione. L'impostazione di questa opzione su 'no' consente al sistema di eseguire i processi utente dopo che un utente ha eseguito il logout dal sistema.
- KillExcludeUsers: se l'opzione KillUserProcesses è abilitata, questa opzione consente di specificare una lista separata da spazi di utenti per i quali systemd consente l'esecuzione dei processi dopo la chiusura della sessione. L'aggiunta di un nome utente a questo elenco comporta un funzionamento simile all'aggiunta di un utente al gruppo terminologico del sistema utilizzando il comando loginctl.
- KillOnlyUsers: se l'opzione KillUserProcesses è disabilitata, questo parametro può essere utilizzato per specificare una lista separata da spazi di utenti per i quali i processi devono essere interrotti dopo il logout.

Dimostrazione in video

Le dimostrazioni video su systemd sono disponibili all'indirizzo https://www.youtube.com/watch?v=9uDvnZKhU8A e https://www.youtube.com/watch?v=Tkxs-wfZrnw se sono necessarie ulteriori informazioni sull'utilizzo del sistema su Oracle Linux 8.

Systemd System and Service Manager su Oracle Linux 8

Systemd Target Units su Oracle Linux 8

Ulteriori informazioni

Documentazione di sistema: https://systemd.io/
Pagina manuale systemd(1)
Pagina manuale systemctl(1)
Pagina manuale journalctl(1)
Pagina manuale systemd.unit(5)
Pagina manuale logind.conf(5)
Oracle Linux 8: gestione della configurazione del sistema di base
Documentazione Oracle Linux

Altre risorse di apprendimento

Esplora altri laboratori su docs.oracle.com/learn o accedi a più contenuti di apprendimento gratuito sul canale Oracle Learning YouTube. Inoltre, visitare education.oracle.com/learning-explorer per diventare Oracle Learning Explorer.

Per la documentazione del prodotto, visitare il sito Oracle Help Center.

Titolo e informazioni sul copyright

Use systemd on Oracle Linux

F49906-03

May 2022