Note :

Ce tutoriel est disponible dans un environnement de laboratoire gratuit fourni par Oracle.
Il utilise des exemples de valeurs pour les données d'identification, la location et les compartiments d'Oracle Cloud Infrastructure. À la fin de votre laboratoire, remplacez ces valeurs par celles qui sont propres à votre environnement en nuage.

Gérer le temps système et programmer des tâches sur Oracle Linux

Présentation

Oracle Linux offre aux utilisateurs plusieurs façons d'interagir avec l'heure et la date. Bien que vous puissiez les modifier manuellement, il est plus courant de configurer un service qui met en oeuvre le protocole NTP (Network Time Protocol), par exemple chrony (chronie). Ainsi, l'heure système reste correcte et toutes les tâches utilisant cron ou systemd timers s'exécutent selon le programme.

Objectifs

Dans ce tutoriel, vous apprendrez à :

Gérez l'heure système à partir du terminal à l'aide de date, hwclock et timedatectl
Exécuter et activer le service de chronie
Programmer des tâches avec des temporisateurs cron et systemd

Préalables

Minimum d'un seul système Oracle Linux
Oracle Linux doit être installé et configuré pour chaque système avec :
- Un compte utilisateur non racine avec accès sudo
- Accès à Internet

Déployer Oracle Linux

Note : Si vous exécutez votre propre location, lisez les préalables du projet linux-virt-labs GitHub README.md et remplissez les conditions requises avant de déployer l'environnement de laboratoire.

Ouvrez un terminal sur le Luna Desktop.

Clonez le projet linux-virt-labs GitHub.

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

Accédez au répertoire de travail.
```
cd linux-virt-labs/ol
```

Installez les collections requises.

ansible-galaxy collection install -r requirements.yml

Déployez l'environnement de l'exercice.
```
ansible-playbook create_instance.yml -e localhost_python_interpreter="/usr/bin/python3.6"
```
L'environnement de laboratoire gratuit nécessite la variable supplémentaire local_python_interpreter, qui définit ansible_python_interpreter pour les lectures exécutées sur localhost. Cette variable est nécessaire car l'environnement installe l'ensemble RPM pour la trousse SDK Oracle Cloud Infrastructure pour Python, située sous les modules python3.6.

La forme de déploiement par défaut utilise le processeur AMD et Oracle Linux 8. Pour utiliser une unité centrale Intel ou Oracle Linux 9, ajoutez -e instance_shape="VM.Standard3.Flex" ou -e os_version="9" à la commande de déploiement.

Important : Attendez que le livre de jeu s'exécute avec succès et atteignez la tâche Mettre en pause. À ce stade du livre de jeu, l'installation d'Oracle Linux est terminée et les instances sont prêtes. Prenez note de la lecture précédente, qui imprime les adresses IP publiques et privées des noeuds qu'il déploie et toutes les autres informations de déploiement nécessaires lors de l'exécution de l'exercice.

Configurer la date et l'heure du système

Oracle Linux comporte trois commandes communes qui peuvent vous aider à ajuster la date et l'heure sur votre système. La commande date ajuste l'heure système, tandis que hwclock ajuste l'heure RTC. Dans Oracle Linux, l'heure RTC fait référence à l'heure conservée par l'horloge en temps réel (RTC), une horloge matérielle alimentée par batterie qui continue de s'exécuter lorsque le système est mis hors tension. D'autres noms communs pour l'horloge matérielle incluent l'horloge CMOS ou l'horloge BIOS. Si vous voulez mettre à jour l'horloge RTC après une modification de date, vous devez exécuter hwclock.

La troisième option est timedatectl. Cette commande combine date et hwclock et met à jour le système et le RTC lors de la définition de l'heure. Dans les distributions Linux modernes basées sur systemd telles qu'Oracle Linux, il est recommandé d'utiliser timedatectl.

Afficher et définir l'horloge système

Ouvrez un terminal et connectez-vous via SSH à l'instance ol-node-01.
```
ssh oracle@<ip_address_of_instance>
```
Obtenir l'heure et la date système courantes.
```
date
```
La sortie affiche la date, l'heure et le fuseau horaire du système dans le format par défaut. Vous pouvez modifier le format de la sortie à l'aide des nombreux arguments de la commande date. Ces arguments aident lors du script ou du calcul de différentes dates et heures. Pour plus d'informations, exécutez date --help ou consultez la page du manuel à l'aide de man date.
Sert à ajuster l'heure et la date du système.
```
sudo date -s "1 JAN 1970 16:00:00"
```
Simplifiez le format en utilisant les arguments de contrôle de format.
```
sudo date +%Y%m%d -s "20250203"
```
Notez que puisque vous n'avez pas fourni d'heure, la partie temps prend par défaut tous les zéros, c'est-à-dire minuit.
Définissez l'heure système.
```
sudo date +%T -s "14:08:14"
```
Si vous exécutez de nouveau la commande date, l'heure doit s'afficher en fonction de ce que vous avez entré.

Afficher et régler l'horloge matérielle

Lisez l'horloge matérielle actuelle (RTC).
```
sudo hwclock --show
```
Définissez l'horloge système en fonction de l'horloge matérielle.
```
sudo hwclock -s
```
La commande vous permet de définir les horloges dans la direction opposée en transmettant la fonction -w. Découvrez d'autres fonctions et options en exécutant hwclock --help ou en consultant la page de manuel man hwclock.

Date et heure avec système

Obtenir la date et l'heure courantes.
```
timedatectl
```
La sortie de l'environnement de laboratoire gratuit montre que le service NTP est actif. Pour ajuster manuellement les paramètres de date et d'heure avec timedatectl, cette option doit d'abord être désactivée.
Désactivez la synchronisation NTP.
```
sudo timedatectl set-ntp no
```

Définissez la date et l'heure.

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

Vérifiez la date et l'heure.
```
date
```
Obtenir une liste des fuseaux horaires.
```
timedatectl list-timezones
```
Appuyez sur q pour quitter la commande timedatectl.

Définissez le fuseau horaire.

sudo timedatectl set-timezone 'America/Chicago'

Vérifiez le nouveau fuseau horaire.
```
timedatectl
```
Retournez le fuseau horaire à Temps universel coordonné (UTC).
```
sudo timedatectl set-timezone 'UTC'
```
Activer la synchronisation NTP.
```
sudo timedatectl set-ntp yes
```
Après un certain temps, la synchronisation se produira et l'horloge retournera au jour et à l'heure actuels en fonction du fuseau horaire défini.

Utiliser Chrony

chrony est une fonction d'Oracle Linux qui met en oeuvre NTP pour tenir à jour la tenue du temps sur le réseau et se compose de deux composants, chronyd et chronyc. chronyd est un démon de service qui peut être activé et démarré au démarrage, tandis que chronyc est un utilitaire de ligne de commande utilisé pour surveiller la performance de chronyd et modifier ses paramètres d'exécution.

Vérifiez si chrony est installé.
```
dnf list chrony
```
Vous pouvez l'installer à l'aide de sudo dnf install -y chrony si vous ne le trouvez pas installé.
Vérifiez le statut du démon de service.
```
sudo systemctl status chronyd
```
Activez et démarrez le service à l'aide de sudo systemctl enable --now chronyd s'il est inactif. Appuyez sur q pour quitter la commande systemctl.
Obtenez des informations sur les performances de l'horloge système.
```
chronyc -n tracking
```
Exemple de sortie :
```
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
```
Où :
- ID de référence : Il s'agit de l'ID de référence et du nom ou de l'adresse IP du serveur auquel l'ordinateur est actuellement synchronisé. L'ID de référence dans la sortie s'affiche en tant que nombre hexadécimal.
- Stratum : La stratum indique combien de sauts ce système est à partir d'un ordinateur avec une horloge de référence attachée.
- Temps de référence : Il s'agit du temps en UTC lorsque le système a traité la dernière mesure à partir de la source de référence.
Pour plus d'informations, consultez la page du manuel à l'aide de man chronyc.
Obtenez une liste des sources utilisées par votre système.
```
chronyc -n sources
```
L'option -v affiche les descriptions de colonne pour chacune des colonnes affichées.

Programmer des tâches

Oracle Linux comprend plusieurs façons de programmer des tâches. Ces tâches ou tâches peuvent être exécutées au niveau du système ou de l'utilisateur. Bien que cron soit probablement la plus connue de ces méthodes, systemd a introduit les temporisateurs plus flexibles en termes de programmation avec le calendrier et l'heure monotone, et il est de plus en plus utilisé. Les distributions Oracle Linux courantes comportent une combinaison des deux.

Utilisation de Cron

Recherchez les tâches cron au niveau du système.
```
sudo ls -al /etc/cron*
```
La sortie fournit plusieurs répertoires contenant des scripts exécutables qui effectuent des tâches sélectionnées selon un calendrier prédéterminé, par exemple toutes les heures, toutes les semaines et tous les mois. Le répertoire /etc/cron.d existe également, où les paquets peuvent placer des extraits de code crontab sans modifier le système /etc/crontab.
Obtenez une liste des tâches cron au niveau du système.
```
sudo crontab -l
```
La sortie indique qu'il n'y a pas de crontab pour root. L'exécution de la même commande sans sudo fournit la même sortie, mais pour le compte d'utilisateur local.
Créez une tâche cron de niveau utilisateur.
```
(crontab -l 2>/dev/null; echo  '* * * * * date >> /home/oracle/test') | crontab -
```
La première commande évite le message no crontab car il s'agit de la première tâche entrée et la seconde crée la tâche, qui s'exécute toutes les minutes.
Vérifiez que le crontab existe maintenant.
```
crontab -l
```
Chaque travail apparaît sur sa propre ligne dans le crontab. Le crontab comporte cinq champs séparés par des espaces définissant les différentes périodes que vous pouvez configurer, suivis de la commande d'exécution du travail. La commande peut être équivalente à toute commande que vous pouvez exécuter sur la ligne de commande du système, ce qui vous permet d'exécuter vos scripts ou de tirer parti des canaux et des opérateurs de redirection. Si vous voulez modifier la tâche, utilisez la commande crontab -e, qui vous dépose dans votre éditeur par défaut, vi, sur Oracle Linux.

Options de séquence de temps Crontab

Crontab définit les champs de temps comme suit :
- minute : De 0 à 59
- heure : De 0 à 23
- jour : De 1 à 31
- mois : De 1 à 12, ou le nom du mois
- jour de la semaine : de 0 à 7, ou le nom abrégé du jour. Notez que 0 et 7 représentent tous les deux le dimanche.
Vous pouvez utiliser des caractères spéciaux dans n'importe quel champ de temps :
- Astérisque (*) : Indique que la commande doit être exécutée pour chaque instance du champ.
- Trait d'union (-) : Peut être utilisé pour indiquer un intervalle. Par exemple, dans le champ Jour de la semaine, vous pouvez spécifier 1 à 5 pour programmer l'exécution de la tâche du lundi au vendredi, mais pas le samedi ou le dimanche.
- Virgule (,) : peut être utilisée pour spécifier une liste de valeurs pour un champ. Par exemple, dans le champ Heure, vous pouvez spécifier 6,18 pour programmer l'exécution de la tâche à 6 h et 6 h.
- Barre oblique (/) : Elle peut être utilisée pour spécifier des valeurs d'étape. Par exemple, vous pouvez spécifier */15 dans le champ minutes pour programmer l'exécution d'une tâche toutes les 15 minutes.
Le crontab vous permet également d'utiliser une extension abrégée unique pour remplacer les champs de temps pour les exigences de temps générales. Fait important, ce raccourci comprend également une option pour exécuter une commande après le redémarrage :
- @reboot : Exécuter une fois après le redémarrage.
- @yearly : Exécuter une fois par an, c'est-à-dire "0 0 1 1 *".
- @annually : Exécuter une fois par an, c'est-à-dire "0 0 1 1 *".
- @monthly : Exécuter une fois par mois, c'est-à-dire "0 0 1 * *".
- @weekly : Exécuter une fois par semaine, c'est-à-dire "0 0 * * 0".
- @daily : Exécuter une fois par jour, c'est-à-dire "0 0 * * *".
- @hourly : Exécuter une fois par heure, c'est-à-dire "0 * * *".
Le crontab offre seulement une granularité de 1 minute. Si vous avez besoin d'un contrôle granulaire plus fin de votre tâche, il est recommandé d'utiliser des minuteries système.

Exemples :
```
*/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"
```
Vérifiez la sortie cron.
```
sudo tail /var/log/cron
```
La sortie affiche la date, l'heure, l'utilisateur et l'exécution de la commande. Comme une installation minimale par défaut d'Oracle Linux n'installe pas l'agent de transport de courrier (MTA), le démon cron dirige la sortie des commandes spécifiées dans le crontab vers le démon Syslog. Par conséquent, vous pouvez voir la sortie crontab dans le fichier journal à l'adresse /var/log/cron.

Syntaxe de commande Crontab

Le crontab s'exécute sous les informations d'identification et de connexion de l'utilisateur auquel le crontab appartient et s'exécute avec des variables d'environnement par défaut définies, notamment :
- HOME : Répertoire d'accueil de l'utilisateur sous lequel le crontab s'exécute
- LOGNAME : Équivalent au nom d'utilisateur de l'utilisateur sous lequel le crontab s'exécute
- USER : Nom d'utilisateur de l'utilisateur sous lequel le crontab s'exécute
- SHELL : Le binaire SHELL que le système utilise pour exécuter des commandes. Cette valeur est réglée à /bin/sh par défaut.
- PATH : Chemin disponible pour l'utilitaire crontab. Cette valeur est réglée à /usr/bin:/bin par défaut.
Vous pouvez définir d'autres variables d'environnement en les spécifiant en tant que lignes dans le crontab qui n'incluent pas de champs de temps. Par exemple, si vous préférez utiliser l'interpréteur de commandes bash et que vous souhaitez importer régulièrement toutes les variables et tous les paramètres de votre configuration .bashrc personnelle, vous pouvez modifier votre crontab avec crontab -e pour vous présenter comme suit :
```
SHELL=/bin/bash
* * * * * source $HOME/.bashrc;
```
Comme la commande de la tâche crontab s'exécute dans un environnement d'interpréteur de commandes, la syntaxe d'interpréteur de commandes standard s'applique et peut être utilisée pour diriger ou rediriger la sortie. Par exemple, pour rediriger toutes les sorties vers /dev/null, utilisez les redirections d'interpréteur de commandes standard pour les sorties STDOUT et STDERR de la commande :
```
* * * * * /path/to/command > /dev/null 2>&1
```
Vous pouvez également rediriger la sortie pour l'ajouter à un fichier que vous pouvez utiliser pour suivre la sortie à chaque exécution de la commande :
```
* * * * * /path/to/command >> $HOME/command.log
```
Exemples :
```
*/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'exemple échappe aux caractères % de la commande date car les caractères % sont transformés en caractères de nouvelle ligne par l'utilitaire crontab et toutes les données après le premier % sont envoyées à la commande en tant qu'entrée standard. Voir man 5 crontab pour plus d'informations.

Supprimer le fichier Crontab

Si vous prévoyez uniquement de supprimer une tâche spécifique, vous pouvez utiliser la commande crontab -e pour modifier et supprimer la ligne individuelle contenant cette tâche. Toutefois, si vous voulez supprimer toutes les tâches, crontab fournit une option rapide et efficace.

Supprimez toutes vos entrées d'emploi cron.
```
crontab -r
```

Minuteries systématiques

Comme les tâches cron, les temporisateurs systemd permettent d'exécuter des commandes ou des scripts à un moment spécifique. Cependant, ces tâches sont contrôlées et supervisées par systemd et ont un contrôle plus fin de l'activation basée sur le temps.

Liste des temporisateurs existants.
```
systemctl status *timer
```
Appuyez sur q pour quitter la commande systemctl.

Créer un temporisateur

Une minuterie se compose d'une unité de service qui définit le travail à effectuer et d'une unité de minuterie pour la planifier et la déclencher. Comme il s'agit d'unités de service systématiques, vous pouvez les créer dans l'espace système ou utilisateur. L'avantage de l'espace utilisateur est qu'il permet aux utilisateurs de gérer leurs services, tels que les démons et les tâches automatisées.

Créez le répertoire systemd de l'utilisateur local.
```
mkdir -p ~/.config/systemd/user
```
Les unités de service et les minuteries au niveau du système entrent dans /etc/systemd/system.
Activer la persistance pour l'utilisateur courant.
```
loginctl enable-linger $(whoami)
```
Lingering fait référence à une fonctionnalité de systemd qui permet aux processus utilisateur de continuer à s'exécuter même après que l'utilisateur se soit déconnecté de sa session.
Vérifiez le statut de veille de l'utilisateur.
```
loginctl user-status $(whoami)
```
Appuyez sur q pour quitter la commande loginctl.

Écrivez un script pour l'exécution du temporisateur.

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

Rendez le script exécutable.
```
chmod +x ~/test.sh
```

création d'une unité de service;

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

Le service nécessite StartLimitIntervalSec et StartLimitBurst, car il est destiné à exécuter ce service toutes les quelques secondes. Vous pouvez en savoir plus sur ces paramètres dans man systemd.unit.

Créez une unité de minuterie.

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

Le paramètre AccuracySec est requis car les temporisateurs systemd ne s'exécutent pas exactement lorsqu'ils sont demandés, mais fonctionnent avec un écart par défaut d'une minute.

Tenez le système au courant des modifications.
```
systemctl --user daemon-reload
```

Activez et démarrez la minuterie.

systemctl --user enable --now test.timer

Vérifiez que le temporisateur est en cours d'exécution.
```
systemctl --user status test.timer --no-pager
```
L'option --no-pager imprime la sortie complète sans qu'il soit nécessaire de faire défiler ou de parcourir les entrées. Consultez systemctl --help pour plus d'options.
Vérifiez le fichier journal du script bash.
```
cat ~/test.log
```
Vérifiez l'écriture générée par le système.
```
journalctl -r -n 10 --user-unit test --no-pager
```
Cette sortie affiche les 10 dernières lignes de sortie de l'unité systemd test.service de l'utilisateur. L'option -r affiche les écritures de journal dans l'ordre chronologique inverse.
```
journalctl -r -n 10 -t test --no-pager
```
Cette commande affiche la sortie générée par le script exécuté par l'unité de service systemd. L'option -t correspond à la valeur SyslogIdentifier définie dans le fichier test.service, qui fournit un identificateur à rechercher. Voir plus d'options pour journalctl en lisant la page man journalctl.
Désactivez le temporisateur.
```
systemctl --user disable test.timer
```
Cette commande empêche le minuteur de démarrer automatiquement à l'avenir et le rend inactif.
Arrêtez la minuterie.
```
systemctl --user stop test.timer
```
Cette commande arrête l'exécution courante de la minuterie si elle est en cours d'exécution. Cela n'empêche pas la minuterie de recommencer à l'avenir.

Étapes suivantes

En suivant ce tutoriel, vous avez démontré vos compétences et votre capacité à gérer la date, l'heure et la planification des tâches sur Oracle Linux. Il y a beaucoup d'autres indicateurs et fonctionnalités des commandes affichées. Consultez les liens ci-dessous et les pages de manuel suggérées pour augmenter vos connaissances et vos compétences.

Autres ressources d'apprentissage

Explorez d'autres laboratoires sur le site docs.oracle.com/learn ou accédez à plus de contenu d'apprentissage gratuit sur le canal Oracle Learning YouTube. De plus, visitez education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir la documentation sur le produit, visitez Oracle Help Center.

Titre et informations sur les droits d'auteur

Manage System Time and Schedule Tasks on Oracle Linux

G45267-01

Oracle et/ou ses sociétés affiliées.