Remarques :

Ce tutoriel est disponible dans un environnement d'atelier gratuit fourni par Oracle.
Il utilise des exemples de valeur pour les informations d'identification, la location et les compartiments Oracle Cloud Infrastructure. Lorsque vous terminez votre atelier, remplacez ces valeurs par celles propres à votre environnement cloud.

Gestion de l'heure système et des tâches programmées sur Oracle Linux

Introduction

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 implémente le protocole NTP (Network Time Protocol), tel que chrony. De cette façon, l'heure de votre système reste correcte et toutes les tâches utilisant cron ou systemd timers sont exécutées selon la planification.

Objectifs

Dans ce tutoriel, vous allez apprendre à :

Gérez le temps système à partir du terminal à l'aide de date, hwclock et timedatectl
Exécuter et activer le service chrony
Planification de tâches avec cron et timers systemd

Prérequis

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

Déployer Oracle Linux

Remarque : si vous êtes en cours d'exécution dans votre propre location, lisez le projet linux-virt-labs GitHub README.md et complétez les prérequis avant de déployer l'environnement d'exercice.

Ouvrez un terminal sur le bureau Luna.

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 ensembles requis.

ansible-galaxy collection install -r requirements.yml

Déployez l'environnement d'exercice.
```
ansible-playbook create_instance.yml -e localhost_python_interpreter="/usr/bin/python3.6"
```
L'environnement d'exercice libre requiert 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 le package RPM pour le kit SDK Oracle Cloud Infrastructure pour Python, situé sous les modules python3.6.

La forme de déploiement par défaut utilise l'UC AMD et Oracle Linux 8. Pour utiliser une CPU 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 guide de lecture s'exécute correctement et atteignez la tâche de pause. A ce stade du manuel, l'installation d'Oracle Linux est terminée et les instances sont prêtes. Prenez note de la lecture précédente, qui affiche les adresses IP publiques et privées des noeuds qu'elle 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 système

Oracle Linux dispose de trois commandes communes qui peuvent vous aider à ajuster la date et l'heure de votre système. La commande date ajuste l'heure du 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 hors tension. Les autres noms courants 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. Sur les distributions Linux basées sur systemd modernes telles qu'Oracle Linux, il est recommandé d'utiliser timedatectl.

Affichage et définition de l'horloge système

Ouvrez un terminal et connectez-vous via SSH à l'instance ol-node-01.
```
ssh oracle@<ip_address_of_instance>
```
Obtenir la date et l'heure système actuelles.
```
date
```
La sortie affiche la date, l'heure et le fuseau horaire du système au format par défaut. Vous pouvez modifier le format de la sortie à l'aide des nombreux arguments de la commande date. Ces arguments facilitent le script ou le 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.
Ajustez la date et l'heure système.
```
sudo date -s "1 JAN 1970 16:00:00"
```
Simplifiez le format à l'aide des arguments de contrôle de format.
```
sudo date +%Y%m%d -s "20250203"
```
Comme vous n'avez pas indiqué d'heure, la partie temps est définie par défaut sur 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 à nouveau la commande date, l'heure doit s'afficher en fonction de ce que vous avez saisi.

Affichage et configuration de 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 Systemd

Obtient la date et l'heure en cours.
```
timedatectl
```
La sortie de l'environnement d'exercice libre indique que le service NTP est actif. Pour ajuster manuellement les paramètres de date et d'heure avec timedatectl, vous devez d'abord les désactiver.
Désactivez la synchronisation NTP.
```
sudo timedatectl set-ntp no
```

Définir la date et l'heure.

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

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

Définir le fuseau horaire.

sudo timedatectl set-timezone 'America/Chicago'

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

Utiliser Chrony

chrony est une fonctionnalité d'Oracle Linux qui implémente NTP pour assurer une gestion précise 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 moment de l'initialisation, tandis que chronyc est un utilitaire de ligne de commande utilisé pour surveiller les performances 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 résultat :
```
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 sur lequel l'ordinateur est actuellement synchronisé. L'ID de référence dans la sortie s'affiche sous la forme d'un nombre hexadécimal.
- Stratum : La strate indique combien de sauts de ce système est d'un ordinateur avec une horloge de référence attachée.
- Heure de référence : heure UTC à laquelle 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 la liste des sources utilisées par votre système.
```
chronyc -n sources
```
L'utilisation de l'option -v affiche les descriptions des colonnes pour chacune des colonnes affichées.

Programmer les tâches

Oracle Linux inclut plusieurs méthodes de planification des tâches. Ces tâches ou travaux peuvent être exécutés 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 timers plus flexibles en termes de planification avec le calendrier et le temps monotone, et il est de plus en plus utilisé. Les distributions Oracle Linux actuelles combinent les deux.

Utiliser 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 planning prédéterminé, par exemple horaire, hebdomadaire et mensuel. Le répertoire /etc/cron.d existe également, où les packages peuvent placer des fragments de code crontab sans modifier le système /etc/crontab.
Obtenez la 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 utilisateur local.
Créez un travail 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 du premier travail entré, et la seconde crée le travail, qui s'exécute toutes les minutes.
Vérifiez que le crontab existe.
```
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 que le travail exécutera. La commande peut être équivalente à n'importe quelle 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. Pour modifier le travail, utilisez la commande crontab -e, qui vous place dans l'éditeur par défaut, vi, sur Oracle Linux.

Options de séquence horaire 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 dimanche.
Vous pouvez utiliser des caractères spéciaux dans n'importe lequel des champs 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 une plage. Par exemple, dans le champ Jour de la semaine, vous pouvez indiquer 1-5 pour planifier 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 indiquer 6,18 pour planifier l'exécution de la tâche à 6 heures et 6 heures.
- Barre oblique (/) : permet de spécifier les valeurs d'étape. Par exemple, vous pouvez spécifier */15 dans le champ des minutes pour planifier une tâche à exécuter 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. Il est important de noter que cette abréviation inclut également une option pour exécuter une commande après la réinitialisation :
- @reboot : s'exécute une fois après la réinitialisation.
- @yearly : exécution une fois par an, c'est-à-dire "0 0 1 1 *".
- @annually : exécution une fois par an, c'est-à-dire "0 0 1 1 *".
- @monthly : exécution une fois par mois, par exemple "0 0 1 * *".
- @weekly : exécution une fois par semaine, par exemple "0 0 * * 0".
- @daily : exécution une fois par jour, par exemple "0 0 * * *".
- @hourly : exécution une fois par heure, par exemple "0 * * *".
Le crontab fournit seulement 1 minute de granularité. Si vous avez besoin d'un contrôle plus précis 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 commande. Etant donné qu'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 visualiser la sortie crontab dans le fichier journal à l'adresse /var/log/cron.

Syntaxe de la commande Crontab

Le crontab s'exécute sous les informations d'identification 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 personnel de l'utilisateur sous lequel le crontab s'exécute
- LOGNAME : équivalent au nom utilisateur de l'utilisateur que le crontab exécute en tant que
- USER (UTILISATEUR) : nom utilisateur de l'utilisateur que crontab exécute en tant que
- SHELL : binaire SHELL utilisé par le système pour exécuter des commandes. Cette valeur est définie sur /bin/sh par défaut.
- PATH : chemin disponible pour l'utilitaire crontab. Cette valeur est définie sur /usr/bin:/bin par défaut.
Vous pouvez définir d'autres variables d'environnement en les spécifiant comme des lignes dans le crontab qui n'incluent pas de champs de temps. Par exemple, si vous préférez utiliser le shell bash et que vous voulez 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 obtenir l'aspect suivant :
```
SHELL=/bin/bash
* * * * * source $HOME/.bashrc;
```
La commande du travail crontab s'exécutant dans un environnement shell, la syntaxe shell standard s'applique et peut être utilisée pour canaliser ou rediriger la sortie. Par exemple, pour rediriger toutes les sorties vers /dev/null, utilisez les redirections shell standard pour les sorties STDOUT et STDERR de la commande :
```
* * * * * /path/to/command > /dev/null 2>&1
```
Vous pouvez également rediriger la sortie vers 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 les 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. Pour plus d'informations, reportez-vous à man 5 crontab.

Suppression du fichier Crontab

Si vous prévoyez uniquement d'enlever un travail spécifique, vous pouvez utiliser la commande crontab -e pour modifier et enlever la ligne individuelle contenant ce travail. Toutefois, si vous voulez enlever tous les travaux, crontab fournit une option rapide et efficace.

Supprimez toutes vos entrées de travail cron.
```
crontab -r
```

Minuteries système

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

Répertoriez les minuteries existantes.
```
systemctl status *timer
```
Appuyez sur q pour quitter la commande systemctl.

Créer une horloge

Une minuterie se compose d'une unité de service qui définit le travail à faire et d'une unité de minuterie pour le planifier et le déclencher. Comme il s'agit d'unités de service systemd, vous pouvez les créer dans le système ou l'espace 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 sont placées dans /etc/systemd/system.
Activer la persistance pour l'utilisateur actuel.
```
loginctl enable-linger $(whoami)
```
Lingering fait référence à une fonctionnalité dans systemd qui permet aux processus utilisateur de continuer à s'exécuter même après la déconnexion de l'utilisateur de leur session.
Vérifiez le statut persistant de l'utilisateur.
```
loginctl user-status $(whoami)
```
Appuyez sur q pour quitter la commande loginctl.

Ecrivez un script pour l'exécution du minuteur.

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éez 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 requiert 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 minuteries systemd ne s'exécutent pas exactement lorsqu'elles sont demandées, mais fonctionnent sur une variance par défaut d'une minute.

Informer le système des modifications.
```
systemctl --user daemon-reload
```

Activez et démarrez l'horloge.

systemctl --user enable --now test.timer

Vérifiez que le minuteur est en cours d'exécution.
```
systemctl --user status test.timer --no-pager
```
L'option --no-pager affiche la sortie complète sans avoir à faire défiler les entrées ni à parcourir les pages. Consultez systemctl --help pour plus d'options.
Consultez le fichier journal du script bash.
```
cat ~/test.log
```
Vérifiez le journal systemd.
```
journalctl -r -n 10 --user-unit test --no-pager
```
Cette sortie affiche les 10 dernières lignes de sortie de l'unité systemd de l'utilisateur test.service. L'option -r affiche les écritures comptables 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 au paramètre SyslogIdentifier défini dans le fichier test.service, qui fournit un identificateur sur lequel effectuer la recherche. Voir plus d'options pour journalctl en lisant la page man journalctl.
Désactivez le minuteur.
```
systemctl --user disable test.timer
```
Cette commande empêche la minuterie de démarrer automatiquement à l'avenir et la rend inactive.
Arrêtez le minuteur.
```
systemctl --user stop test.timer
```
Cette commande arrête l'exécution actuelle de la minuterie si elle est en cours d'exécution. Cela n'empêche pas la minuterie de recommencer à l'avenir.

Etapes suivantes

En terminant 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 plus d'indicateurs et de fonctionnalités des commandes affichées. Consultez les liens ci-dessous et les pages de manuel suggérées pour améliorer vos connaissances et vos compétences.

Ressources de formation supplémentaires

Explorez d'autres ateliers sur le site docs.oracle.com/learn ou accédez à d'autres contenus d'apprentissage gratuits sur le canal Oracle Learning YouTube. En outre, visitez le site education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

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

Informations relatives au titre et au copyright

Manage System Time and Schedule Tasks on Oracle Linux

F49759-05

Oracle et/ou ses affiliés.