Nota

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

Gestisci i tempi di sistema e pianifica i task su Oracle Linux

Introduzione

Oracle Linux offre agli utenti diversi modi per interagire con l'ora e la data. Sebbene sia possibile modificarle manualmente, è più comune configurare un servizio che implementa il protocollo NTP (Network Time Protocol), ad esempio chrony. In questo modo, l'ora di sistema rimane corretta e tutti i task che utilizzano cron o systemd timers vengono eseguiti secondo la pianificazione.

Obiettivi

In questo tutorial imparerai a:

Gestire l'ora di sistema dal terminale utilizzando date, hwclock e timedatectl
Eseguire e abilitare il servizio chrony
Pianificare le attività con cron e timer di sistema

Prerequisiti

Minimo di un singolo sistema Oracle Linux
Ogni sistema deve avere Oracle Linux installato e configurato con:
- Account utente non root con accesso sudo
- Accesso a Internet

Implementa Oracle Linux

Nota: se è in esecuzione nella propria tenancy, leggere il progetto linux-virt-labs GitHub README.md e completare i prerequisiti prima di distribuire l'ambiente di laboratorio.

Aprire un terminale sul Luna Desktop.

Duplicare il progetto linux-virt-labs GitHub.

git clone https://github.com/oracle-devrel/linux-virt-labs.git

Passare alla directory di lavoro.
```
cd linux-virt-labs/ol
```

Installare le raccolte richieste.

ansible-galaxy collection install -r requirements.yml

Implementare l'ambiente di laboratorio.
```
ansible-playbook create_instance.yml -e localhost_python_interpreter="/usr/bin/python3.6"
```
L'ambiente di esercitazione pratica gratuito richiede l'aggiunta della variabile local_python_interpreter, che imposta ansible_python_interpreter per le riproduzioni eseguite su localhost. Questa variabile è necessaria perché l'ambiente installa il pacchetto RPM per l'SDK Oracle Cloud Infrastructure per Python, situato sotto i moduli python3.6.

La forma di distribuzione predefinita utilizza la CPU AMD e Oracle Linux 8. Per utilizzare una CPU Intel o Oracle Linux 9, aggiungere -e instance_shape="VM.Standard3.Flex" o -e os_version="9" al comando di distribuzione.

Importante: attendere che il playbook venga eseguito correttamente e raggiungere il task di sospensione. In questa fase del playbook, l'installazione di Oracle Linux è completa e le istanze sono pronte. Prendi nota del gioco precedente, che stampa gli indirizzi IP pubblici e privati dei nodi che distribuisce e qualsiasi altra informazione di distribuzione necessaria durante l'esecuzione del laboratorio.

Configurare la data e l'ora del sistema

Oracle Linux dispone di tre comandi comuni che consentono di regolare la data e l'ora nel sistema. Il comando date regola l'ora di sistema, mentre hwclock regola l'ora RTC. In Oracle Linux, l'ora RTC si riferisce al tempo mantenuto da Real-Time Clock (RTC), un orologio hardware a batteria che continua a funzionare quando il sistema è spento. Altri nomi comuni per l'orologio hardware includono l'orologio CMOS o l'orologio BIOS. Se si desidera aggiornare l'orologio RTC dopo una modifica date, è necessario eseguire hwclock.

La terza opzione è timedatectl. Questo comando combina date e hwclock e aggiorna sia il sistema che l'RTC durante l'impostazione dell'ora. Nelle moderne distribuzioni Linux basate su sistemi come Oracle Linux, si consiglia di utilizzare timedatectl.

Visualizzazione e impostazione dell'orologio di sistema

Aprire un terminale e connettersi tramite SSH all'istanza ol-node-01.
```
ssh oracle@<ip_address_of_instance>
```
Recupera l'ora e la data di sistema correnti.
```
date
```
L'output mostra la data, l'ora e il fuso orario del sistema nel formato predefinito. È possibile modificare il formato dell'output utilizzando i numerosi argomenti del comando date. Questi argomenti sono utili quando si eseguono script o si calcolano date e ore diverse. Per ulteriori informazioni, eseguire date --help o visualizzare la pagina del manuale utilizzando man date.
Regolare l'ora e la data del sistema.
```
sudo date -s "1 JAN 1970 16:00:00"
```
Semplificare il formato utilizzando gli argomenti di controllo del formato.
```
sudo date +%Y%m%d -s "20250203"
```
Si noti che poiché non è stata specificata un'ora, la parte temporale viene impostata automaticamente su tutti gli zeri, ovvero la mezzanotte.
Impostare l'ora di sistema.
```
sudo date +%T -s "14:08:14"
```
Se si esegue di nuovo il comando date, l'ora deve essere visualizzata in base a quanto immesso.

Visualizzare e impostare l'orologio hardware

Leggere l'orologio hardware corrente (RTC).
```
sudo hwclock --show
```
Impostare l'orologio di sistema in base all'orologio hardware.
```
sudo hwclock -s
```
Il comando consente di impostare gli orologi nella direzione opposta passando la funzione -w. Controllare le funzioni e le opzioni aggiuntive eseguendo hwclock --help o visualizzando la pagina manuale man hwclock.

Data e ora con Systemd

Ottenere la data e l'ora correnti.
```
timedatectl
```
L'output nell'ambiente di laboratorio gratuito indica che il servizio NTP è attivo. Per regolare manualmente le impostazioni di data e ora con timedatectl, è necessario prima disabilitarle.
Disabilitare la sincronizzazione NTP.
```
sudo timedatectl set-ntp no
```

Impostare la data e l'ora.

sudo timedatectl set-time '2014-09-23 14:10:40'

Controllare la data o l'ora.
```
date
```
Recupera una lista di fusi orari.
```
timedatectl list-timezones
```
Premere q per uscire dal comando timedatectl.

Impostare il fuso orario.

sudo timedatectl set-timezone 'America/Chicago'

Controllare il nuovo fuso orario.
```
timedatectl
```
Restituire il fuso orario all'ora UTC (Coordinated Universal Time).
```
sudo timedatectl set-timezone 'UTC'
```
Abilitare la sincronizzazione NTP.
```
sudo timedatectl set-ntp yes
```
Dopo un po' di tempo, la sincronizzazione avverrà e l'orologio tornerà al giorno e all'ora correnti in base al fuso orario impostato.

Usa Chrony

chrony è una funzione di Oracle Linux che implementa NTP per garantire una gestione accurata del tempo sulla rete ed è costituita da due componenti, chronyd e chronyc. chronyd è un daemon di servizi che può essere abilitato e avviato in fase di boot, mentre chronyc è una utility della riga di comando utilizzata per monitorare le prestazioni di chronyd e modificarne i parametri di runtime.

Verificare se chrony è installato.
```
dnf list chrony
```
È possibile installarlo utilizzando sudo dnf install -y chrony se non è installato.
Controllare lo stato del daemon del servizio.
```
sudo systemctl status chronyd
```
Abilitare e avviare il servizio utilizzando sudo systemctl enable --now chronyd se è inattivo. Premere q per uscire dal comando systemctl.
Ottenere informazioni sulle prestazioni del clock di sistema.
```
chronyc -n tracking
```
Output di esempio:
```
Reference ID    : A9FEA9FE (169.254.169.254)
Stratum         : 3
Ref time (UTC)  : Mon Feb 03 16:07:59 2025
System time     : 0.000009410 seconds slow of NTP time
Last offset     : -0.000011537 seconds
RMS offset      : 0.000015202 seconds
Frequency       : 22.818 ppm slow
Residual freq   : -0.004 ppm
Skew            : 0.222 ppm
Root delay      : 0.000643811 seconds
Root dispersion : 0.000107666 seconds
Update interval : 64.4 seconds
Leap status     : Normal
```
dove:
- ID di riferimento: si tratta dell'ID di riferimento e del nome o dell'indirizzo IP del server a cui il computer è attualmente sincronizzato. L'ID di riferimento nell'output viene visualizzato come numero esadecimale.
- Strato: lo strato indica il numero di luppoli di questo sistema da un computer con un orologio di riferimento collegato.
- Tempo di riferimento: questo è il tempo in UTC in cui il sistema ha elaborato l'ultima misurazione dalla fonte di riferimento.
Ulteriori informazioni sono disponibili controllando la pagina manuale utilizzando man chronyc.
Ottenere un elenco delle origini utilizzate dal sistema.
```
chronyc -n sources
```
Utilizzando l'opzione -v vengono visualizzate le descrizioni delle colonne per ciascuna delle colonne visualizzate.

Pianifica task

Oracle Linux include diversi modi per pianificare le attività e questi task o job possono essere eseguiti a livello di sistema o utente. Sebbene cron sia probabilmente il più noto di questi metodi, systemd ha introdotto i timer più flessibili in termini di pianificazione con il calendario e il tempo monotono, e sta diventando sempre più ampiamente utilizzato. Le distribuzioni Oracle Linux correnti hanno una combinazione di entrambe.

Utilizzo di Cron

Controllare i job cron a livello di sistema.
```
sudo ls -al /etc/cron*
```
L'output fornisce diverse directory contenenti script eseguibili che eseguono attività di selezione in una pianificazione predeterminata, ad esempio oraria, settimanale e mensile. Esiste anche la directory /etc/cron.d, in cui i pacchetti possono posizionare snippet crontab senza modificare il file /etc/crontab di sistema.
Ottenere un elenco dei job cron a livello di sistema.
```
sudo crontab -l
```
L'output indica che non è presente alcun crontab per root. L'esecuzione dello stesso comando senza sudo fornisce lo stesso output, ma per l'account utente locale.
Creare un job cron a livello di utente.
```
(crontab -l 2>/dev/null; echo  '* * * * * date >> /home/oracle/test') | crontab -
```
Il primo comando evita il messaggio no crontab poiché si tratta del primo job immesso e il secondo crea il job, che viene eseguito ogni minuto.
Verificare che il crontab esista.
```
crontab -l
```
Ogni lavoro appare sulla propria riga nel crontab. Il crontab dispone di cinque campi separati da spazi che definiscono i diversi periodi di tempo che è possibile configurare, seguiti dal comando che il job eseguirà. Il comando può essere equivalente a qualsiasi comando che è possibile eseguire sulla riga di comando del sistema, consentendo di eseguire gli script o di sfruttare i tubi e gli operatori di reindirizzamento. Se si desidera modificare il job, utilizzare il comando crontab -e, che consente di accedere all'EDITOR predefinito, vi, su Oracle Linux.

Opzioni sequenza tempo crontab

Crontab definisce i campi tempo come:
- minuto: da 0 a 59
- ora: Da 0 a 23
- giorno: Da 1 a 31
- mese: da 1 a 12, o il nome del mese
- giorno della settimana: da 0 a 7, o il nome abbreviato del giorno. Si noti che 0 e 7 rappresentano entrambi la domenica.
È possibile utilizzare caratteri speciali in qualsiasi campo dell'ora:
- Asterisco (*): specifica che il comando deve essere eseguito per ogni istanza del campo.
- I trattini (-): possono essere utilizzati per indicare un intervallo. Ad esempio, nel campo del giorno della settimana, è possibile specificare da 1 a 5 per schedulare l'esecuzione del task dal lunedì al venerdì, ma non il sabato o la domenica.
- Virgola (,): può essere utilizzato per specificare un elenco di valori per un campo. Ad esempio, nel campo relativo all'ora, è possibile specificare 6,18 per pianificare l'esecuzione dell'attività alle 6 del mattino e alle 6 del pomeriggio.
- Barra in avanti (/): può essere utilizzata per specificare i valori del passo. Ad esempio, è possibile specificare */15 nel campo Minuti per pianificare l'esecuzione di un'attività ogni 15 minuti.
Il crontab consente inoltre di utilizzare un'estensione abbreviata univoca per sostituire i campi dell'ora per i requisiti orari generali. È importante sottolineare che questa abbreviazione include anche un'opzione per eseguire un comando dopo il riavvio:
- @reboot: eseguire una volta dopo il reboot.
- @yearly : Eseguire una volta all'anno, cioè "0 0 1 1 *".
- @annually : Eseguire una volta all'anno, cioè "0 0 1 1 *".
- @monthly : Eseguire una volta al mese, ad esempio "0 0 1 * *".
- @weekly : Eseguire una volta alla settimana, ad esempio "0 0 * * 0".
- @daily : Eseguire una volta al giorno, ad esempio "0 0 * * *".
- @hourly : Eseguire una volta all'ora, ad esempio "0 * * *".
Il crontab fornisce solo una granularità di 1 minuto. Se hai bisogno di un controllo granulare più preciso del tuo compito, si consiglia di utilizzare timer systemd.

Esempi:
```
*/15 * * * * echo "This crontab entry runs every 15 minutes"
10 * * * * echo "This crontab entry runs at 10 minutes past every hour"
30 13 * * 3 echo "This crontab entry runs at 13h30 on every Wednesday"
@reboot echo "This command runs once after a reboot event"
```
Controllare l'output cron.
```
sudo tail /var/log/cron
```
L'output mostra la data, l'ora, l'utente e l'esecuzione del comando. Poiché un'installazione minima predefinita di Oracle Linux non installa Mail Transport Agent (MTA), il daemon cron indirizza l'output dai comandi specificati nel crontab al daemon Syslog. È pertanto possibile visualizzare l'output crontab nel file di log all'indirizzo /var/log/cron.

Sintassi comando Crontab

Il crontab viene eseguito sotto le credenziali dell'utente a cui appartiene il crontab e viene eseguito con alcune variabili di ambiente predefinite impostate, tra cui:
- HOME: la directory HOME per l'utente che crontab esegue come
- LOGNAME: equivalente al nome utente dell'utente eseguito da crontab come
- UTENTE: il nome utente dell'utente eseguito da crontab come
- SHELL: il binario della SHELL utilizzato dal sistema per eseguire comandi. Questo valore è impostato su /bin/sh per impostazione predefinita.
- PATH: il percorso disponibile per l'utility crontab. Questo valore è impostato su /usr/bin:/bin per impostazione predefinita.
È possibile impostare variabili di ambiente alternative specificandole come righe all'interno del crontab che non includono campi di tempo. Ad esempio, se si preferisce utilizzare la shell bash e si desidera importare regolarmente tutte le variabili e le impostazioni all'interno della configurazione personale .bashrc, è possibile modificare il crontab con crontab -e in modo che venga visualizzato come segue:
```
SHELL=/bin/bash
* * * * * source $HOME/.bashrc;
```
Poiché il comando del job crontab viene eseguito all'interno di un ambiente shell, viene applicata la sintassi shell standard e può essere utilizzata per reindirizzare o reindirizzare l'output. Ad esempio, per reindirizzare tutto l'output a /dev/null, utilizzare i reindirizzamenti shell standard per l'output STDOUT e STDERR nel comando:
```
* * * * * /path/to/command > /dev/null 2>&1
```
In alternativa, è possibile reindirizzare l'output per aggiungerlo a un file che è possibile utilizzare per tenere traccia dell'output per ogni esecuzione del comando:
```
* * * * * /path/to/command >> $HOME/command.log
```
Esempi:
```
*/15 * * * * echo "This 'silent' crontab entry runs every 15 minutes but the output is redirected to /dev/null" > /dev/null 2>&1
* * * * * echo "The date and time is $(date +\%Y-\%m-\%d\ \%H:\%M:\%S)" >> $HOME/crontab.log
```
L'esempio sfugge ai caratteri % nel comando date perché i caratteri % vengono modificati in caratteri di nuova riga dall'utility crontab e tutti i dati dopo il primo % vengono inviati al comando come input standard. Per ulteriori informazioni, vedere man 5 crontab.

Rimuovi file Crontab

Se si prevede di rimuovere solo un job specifico, è possibile utilizzare il comando crontab -e per modificare e rimuovere la singola riga contenente tale job. Tuttavia, se si desidera rimuovere tutti i job, crontab fornisce un'opzione rapida ed efficiente.

Rimuovere tutte le voci del job cron.
```
crontab -r
```

Timer di sistema

Come i lavori cron, i timer systemd consentono l'esecuzione di comandi o script in un momento specifico. Tuttavia, queste attività sono controllate e supervisionate da systemd e hanno un controllo granulare più preciso dell'attivazione basata sul tempo.

Elenca i timer esistenti.
```
systemctl status *timer
```
Premere q per uscire dal comando systemctl.

Crea timer

Un timer è costituito da un'unità di servizio che definisce il lavoro da eseguire e da un'unità timer da pianificare e attivare. Poiché si tratta di unità di servizio systemd, è possibile crearle nel sistema o nello spazio utente. Il vantaggio dello spazio utente è che consente agli utenti di gestire i propri servizi, come demoni e attività automatizzate.

Creare la directory systemd dell'utente locale.
```
mkdir -p ~/.config/systemd/user
```
Le unità di servizio e i timer a livello di sistema sono disponibili in /etc/systemd/system.
Abilita il persistere per l'utente corrente.
```
loginctl enable-linger $(whoami)
```
Lingering si riferisce a una funzione in systemd che consente ai processi utente di continuare a funzionare anche dopo che l'utente ha eseguito il logout dalla sessione.
Verificare lo stato del linger dell'utente.
```
loginctl user-status $(whoami)
```
Premere q per uscire dal comando loginctl.

Scrivere uno script per l'esecuzione del timer.

cat << 'EOF' | tee ~/test.sh > /dev/null 
#!/bin/bash
/usr/bin/echo "test from test.service: $(date)" 2>&1 | tee -a /home/oracle/test.log
EOF

Rendere eseguibile lo script.
```
chmod +x ~/test.sh
```

Creare un'unità di servizio.

cat << EOF | tee ~/.config/systemd/user/test.service > /dev/null
[Unit]
Description=Run the test script
StartLimitIntervalSec=1
StartLimitBurst=10
   
[Service]
Type=oneshot
ExecStart=/home/oracle/test.sh
StandardOutput=journal
SyslogIdentifier=test
EOF

Il servizio richiede StartLimitIntervalSec e StartLimitBurst in quanto è progettato per eseguire questo servizio ogni pochi secondi. Ulteriori informazioni su questi parametri sono disponibili in man systemd.unit.

Creare un'unità timer.

cat << EOF | tee ~/.config/systemd/user/test.timer > /dev/null
[Unit]
Description=Run test.service every 10 seconds

[Timer]
OnCalendar=*:*:0/10
AccuracySec=1
Persistent=true

[Install]
WantedBy=timers.target
EOF

Il parametro AccuracySec è obbligatorio poiché i timer systemd non vengono eseguiti esattamente quando richiesto, ma operano su una varianza predefinita di un minuto.

Rendere Systemd consapevole delle modifiche.
```
systemctl --user daemon-reload
```

Abilitare e avviare il timer.

systemctl --user enable --now test.timer

Verificare che il timer sia in esecuzione.
```
systemctl --user status test.timer --no-pager
```
L'opzione --no-pager stampa l'output completo senza la necessità di scorrere o sfogliare le voci. Controlla systemctl --help per ulteriori opzioni.
Controllare il file di log dello script bash.
```
cat ~/test.log
```
Controllare il giornale systemd.
```
journalctl -r -n 10 --user-unit test --no-pager
```
Questo output mostra le ultime 10 righe di output dell'unità systemd test.service dell'utente. L'opzione -r visualizza le scritture contabili in ordine cronologico inverso.
```
journalctl -r -n 10 -t test --no-pager
```
Questo comando mostra l'output generato dallo script eseguito dall'unità di servizio systemd. L'opzione -t corrisponde al valore SyslogIdentifier definito nel file test.service, che fornisce un identificativo su cui eseguire la ricerca. Vedere più opzioni per journalctl leggendo la pagina man journalctl.
Disabilitare il timer.
```
systemctl --user disable test.timer
```
Questo comando impedisce al timer di avviarsi automaticamente in futuro e lo rende inattivo.
Arrestare il timer.
```
systemctl --user stop test.timer
```
Questo comando interrompe l'esecuzione corrente del timer se è in esecuzione. Non impedisce al timer di ricominciare in futuro.

Passi successivi

Completando questa esercitazione, hai dimostrato le tue competenze e capacità di gestire la data, l'ora e i task di pianificazione su Oracle Linux. Ci sono molte altre bandiere e caratteristiche dei comandi mostrati. Dai un'occhiata ai link qui sotto e alle pagine man consigliate per aumentare le tue conoscenze e competenze.

Altre risorse di apprendimento

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

Per la documentazione del prodotto, visitare Oracle Help Center.

Titolo e informazioni sul copyright

Manage System Time and Schedule Tasks on Oracle Linux

F49750-05

Oracle e/o relative consociate.