Planification de Tâches sous Red Hat Enterprise Linux

Introduction

Dans ce laboratoire, vous acquerrez une expérience pratique dans la planification de tâches sur les systèmes RHEL en utilisant divers outils. Vous apprendrez à planifier des tâches ponctuelles avec la commande at, à gérer des tâches récurrentes spécifiques à l'utilisateur avec crontab, et à configurer des tâches récurrentes à l'échelle du système avec les répertoires cron.

De plus, ce laboratoire couvrira des techniques de planification avancées en utilisant les timers systemd pour une automatisation des tâches plus robuste et flexible, et démontrera comment gérer efficacement les fichiers temporaires avec systemd-tmpfiles. À la fin de ce laboratoire, vous maîtriserez le choix de la méthode de planification appropriée pour différents scénarios et la gestion efficace des tâches automatisées dans un environnement RHEL.

Planifier une tâche ponctuelle avec 'at'

Dans cette étape, vous apprendrez à planifier une tâche pour qu'elle s'exécute une seule fois à un moment donné dans le futur en utilisant la commande at. La commande at est utile pour exécuter des commandes qui n'ont pas besoin d'être exécutées de manière répétée. Nous allons planifier une tâche simple, inspecter ses détails, puis la supprimer.

Dans ce lab, nous travaillerons directement sur le système local pour apprendre la planification de tâches. Toutes les commandes seront exécutées dans votre environnement de terminal actuel.

Planifions une tâche pour imprimer la date et l'heure actuelles dans un fichier nommé ~/myjob.txt dans votre répertoire personnel. Nous la planifierons pour qu'elle s'exécute dans 3 minutes :

at now + 3 minutes << EOF
date > ~/myjob.txt
EOF

Le message warning: commands will be executed using /bin/sh est normal. La sortie job N at ... indique le numéro de la tâche et l'heure d'exécution planifiée. Notez le numéro de la tâche, car vous en aurez besoin plus tard.

Ensuite, planifions une autre tâche de manière interactive. Cette méthode est utile pour saisir plusieurs commandes ou des scripts plus complexes. Nous allons planifier une tâche pour ajouter "Hello from at job!" à ~/at_output.txt dans 5 minutes :

at now + 5 minutes

Après avoir tapé la commande et appuyé sur Entrée, vous verrez une invite at>. Tapez votre commande, puis appuyez sur Ctrl+d pour terminer :

at > echo "Hello from at job!" >> ~/at_output.txt
at > Ctrl+d

Pour afficher les tâches actuellement dans la file d'attente at, utilisez la commande atq. Cette commande liste toutes les tâches at en attente pour l'utilisateur actuel.

atq

La sortie affichera le numéro de la tâche, l'heure planifiée, la file d'attente et l'utilisateur qui l'a planifiée.

Vous pouvez inspecter les commandes qu'une tâche at spécifique exécutera en utilisant la commande at -c suivie du numéro de la tâche. Remplacez N par l'un des numéros de tâche que vous avez notés précédemment.

at -c N

Cette commande affichera le script shell que at exécutera pour cette tâche. Vous devriez voir la commande date > ~/myjob.txt ou echo "Hello from at job!" >> ~/at_output.txt dans la sortie.

Enfin, pour supprimer une tâche at planifiée, utilisez la commande atrm suivie du numéro de la tâche. Supprimons la première tâche que nous avons planifiée. Remplacez N par le numéro de tâche de votre première tâche.

atrm N

Après avoir supprimé la tâche, vous pouvez utiliser atq à nouveau pour vérifier qu'elle n'est plus dans la file d'attente.

atq

Vous ne devriez voir que la deuxième tâche (si elle n'a pas encore été exécutée) ou une file d'attente vide si les deux tâches ont été supprimées ou exécutées.

Ceci conclut la première étape de la planification de tâches uniques avec la commande at.

Gérer les tâches 'at'

Dans cette étape, vous approfondirez la gestion des tâches at, y compris la planification de tâches avec différentes files d'attente et la vérification de leur exécution. Comprendre les files d'attente at peut être utile pour prioriser les tâches ou séparer différents types de tâches ponctuelles.

Nous continuerons à travailler sur le système local pour explorer des fonctionnalités de gestion de tâches at plus avancées.

La commande at vous permet de spécifier une file d'attente à l'aide de l'option -q. Les files d'attente sont des lettres uniques de a à z. La file d'attente a est la file par défaut, et les tâches des files d'attente a à z sont exécutées avec une priorité décroissante (niceness). La file d'attente a a la priorité la plus élevée, et la file d'attente z a la priorité la plus basse. La file d'attente b est réservée aux tâches batch.

Planifions une tâche dans la file d'attente g (une file d'attente de priorité inférieure) pour qu'elle s'exécute dans 2 minutes. Cette tâche créera un fichier nommé ~/queue_g_job.txt avec un horodatage :

at -q g now + 2 minutes << EOF
date > ~/queue_g_job.txt
EOF

Vous verrez une sortie similaire à job N at .... Notez ce numéro de tâche.

Ensuite, planifions une autre tâche, cette fois dans la file d'attente b (file d'attente batch), qui est généralement utilisée pour les tâches pouvant s'exécuter lorsque la charge système est faible. Cette tâche ajoutera "Batch job executed!" à ~/batch_job.txt. Nous la planifions pour qu'elle s'exécute dans 4 minutes :

at -q b now + 4 minutes << EOF
echo "Batch job executed!" >> ~/batch_job.txt
EOF

Encore une fois, notez le numéro de tâche.

Pour voir toutes les tâches en attente, y compris celles dans différentes files d'attente, utilisez atq.

atq

Vous devriez maintenant voir les deux tâches listées, avec leurs lettres de file d'attente respectives (g et b).

Maintenant, attendez que vos tâches planifiées s'exécutent. Attendez au moins 5 minutes pour permettre à toutes les tâches de se terminer. Vous pouvez vérifier si les fichiers créés par vos tâches at existent et contiennent le contenu attendu.

Vérifiez ~/queue_g_job.txt :

cat ~/queue_g_job.txt

Vous devriez voir une chaîne de date et d'heure.

Vérifiez ~/batch_job.txt :

cat ~/batch_job.txt

Vous devriez voir "Batch job executed!".

Si les fichiers ne sont pas présents ou sont vides, cela pourrait signifier que les tâches ne se sont pas encore exécutées, ou qu'il y a eu un problème avec la commande. Vous pouvez re-vérifier atq pour voir si elles sont toujours en attente.

Ceci conclut l'étape de gestion avancée des tâches at. Les tâches at restantes seront automatiquement supprimées lorsque le conteneur sera détruit.

Planifier des tâches utilisateur récurrentes avec 'crontab'

Dans cette étape, vous apprendrez à planifier des tâches récurrentes pour un utilisateur spécifique à l'aide de crontab. Contrairement aux tâches at, qui s'exécutent une seule fois, les tâches cron s'exécutent de manière répétée à des intervalles spécifiés. C'est idéal pour la maintenance de routine, les sauvegardes de données ou la génération de rapports.

Nous continuerons à travailler sur le système local pour découvrir la gestion des crontabs utilisateur.

La commande crontab permet aux utilisateurs de créer, modifier et visualiser leurs propres tâches cron. Chaque utilisateur possède son propre fichier crontab.

Pour modifier votre fichier crontab, utilisez la commande crontab -e. Cela ouvrira votre fichier crontab dans l'éditeur de texte par défaut (généralement vim).

crontab -e

Instructions pour l'éditeur Vim :

• Appuyez sur i pour entrer en mode insertion (vous verrez -- INSERT -- en bas)
• Utilisez les touches fléchées pour naviguer
• Pour enregistrer et quitter : Appuyez sur Esc pour quitter le mode insertion, puis tapez :wq et appuyez sur Entrée
• Pour quitter sans enregistrer : Appuyez sur Esc, puis tapez :q! et appuyez sur Entrée

Dans l'éditeur, vous ajouterez une nouvelle ligne pour définir votre tâche cron. Une entrée cron se compose de cinq champs de temps et de date, suivis de la commande à exécuter. Les champs sont :

• Minute (0-59)
• Heure (0-23)
• Jour du mois (1-31)
• Mois (1-12)
• Jour de la semaine (0-7, où 0 ou 7 est dimanche)

Vous pouvez utiliser * comme joker pour signifier "chaque" pour un champ, ou / pour spécifier des valeurs de pas (par exemple, */5 pour toutes les 5 minutes).

Planifions une tâche qui ajoute la date et l'heure actuelles à un fichier nommé ~/my_cron_log.txt chaque minute. Cela nous permettra d'observer rapidement la tâche cron en action.

Suivez ces étapes dans vim :

1. Appuyez sur i pour entrer en mode insertion
2. Ajoutez la ligne suivante au fichier crontab :

* * * * * /usr/bin/date >> ~/my_cron_log.txt

3. Appuyez sur Esc pour quitter le mode insertion
4. Tapez :wq et appuyez sur Entrée pour enregistrer et quitter

Vous devriez voir un message indiquant qu'un nouveau crontab a été installé :

crontab: installing new crontab

Pour vérifier que votre tâche cron a bien été ajoutée, vous pouvez lister vos entrées crontab en utilisant la commande crontab -l :

crontab -l

Vous devriez voir la ligne que vous venez d'ajouter :

* * * * * /usr/bin/date >> ~/my_cron_log.txt

Maintenant, attendez une minute ou deux pour permettre à la tâche cron de s'exécuter au moins une fois. Vous pouvez vérifier l'heure actuelle pour voir quand le prochain changement de minute aura lieu :

date

Après avoir attendu au moins deux minutes pour permettre à la tâche cron de s'exécuter plusieurs fois, vérifiez le contenu du fichier ~/my_cron_log.txt.

cat ~/my_cron_log.txt

Vous devriez voir une ou plusieurs lignes, chacune contenant une date et une heure, indiquant que votre tâche cron s'est exécutée.

Mon Apr 8 10:30:01 AM EDT 2024
Mon Apr 8 10:31:01 AM EDT 2024

Cela conclut l'étape de gestion des crontabs utilisateur. La tâche cron continuera de s'exécuter jusqu'à ce que le conteneur soit détruit.

Gérer les entrées 'crontab' utilisateur

Dans cette étape, vous apprendrez des techniques plus avancées pour gérer les entrées crontab utilisateur, y compris la modification des tâches existantes, l'ajout de plusieurs tâches et la compréhension des chaînes cron spéciales. Une gestion efficace de crontab est cruciale pour automatiser les tâches de routine.

Nous continuerons à travailler sur le système local pour explorer des techniques avancées de gestion de crontab.

Commençons par ajouter une nouvelle tâche cron. Cette tâche ajoutera "Hello from cron!" à ~/cron_messages.txt toutes les deux minutes.

Ouvrez votre crontab pour modification :

crontab -e

Dans vim :

1. Appuyez sur i pour entrer en mode insertion
2. Ajoutez la ligne suivante au fichier crontab :

*/2 * * * * echo "Hello from cron!" >> ~/cron_messages.txt

3. Appuyez sur Esc pour quitter le mode insertion
4. Tapez :wq et appuyez sur Entrée pour enregistrer et quitter

Vérifiez que l'entrée est ajoutée :

crontab -l

Vous devriez voir la ligne nouvellement ajoutée.

Maintenant, ajoutons une autre tâche cron qui s'exécute quotidiennement à 08h00. Cette tâche enregistrera l'utilisation du disque de votre répertoire personnel dans ~/disk_usage.log.

Ouvrez votre crontab pour modification à nouveau :

crontab -e

Dans vim :

1. Appuyez sur i pour entrer en mode insertion
2. Ajoutez la ligne suivante en dessous de la précédente :

0 8 * * * du -sh ~ >> ~/disk_usage.log

3. Appuyez sur Esc pour quitter le mode insertion
4. Tapez :wq et appuyez sur Entrée pour enregistrer et quitter

Vérifiez que les deux entrées sont présentes :

crontab -l

Vous devriez maintenant voir les deux tâches cron listées.

cron prend également en charge des chaînes spéciales qui peuvent simplifier les planifications courantes. Celles-ci incluent @reboot, @yearly, @annually, @monthly, @weekly, @daily, @midnight et @hourly. Par exemple, @hourly est équivalent à 0 * * * *.

Ajoutons une tâche qui s'exécute toutes les heures et enregistre le temps de fonctionnement du système dans ~/uptime_log.txt.

Ouvrez votre crontab pour modification :

crontab -e

Dans vim :

1. Appuyez sur i pour entrer en mode insertion
2. Ajoutez la ligne suivante :

@hourly uptime >> ~/uptime_log.txt

3. Appuyez sur Esc pour quitter le mode insertion
4. Tapez :wq et appuyez sur Entrée pour enregistrer et quitter

Vérifiez les trois entrées :

crontab -l

Vous devriez maintenant voir les trois tâches cron.

Pour démontrer l'effet de ces tâches, nous allons attendre une courte période. Étant donné que les tâches sont planifiées à des intervalles différents, nous ne les verrons pas toutes s'exécuter immédiatement, mais nous pouvons vérifier la configuration.

Attendez au moins 3 minutes pour permettre à la tâche */2 de s'exécuter au moins une fois.

Vérifiez le fichier ~/cron_messages.txt :

cat ~/cron_messages.txt

Vous devriez voir au moins un message "Hello from cron!".

Hello from cron!

Les fichiers ~/disk_usage.log et ~/uptime_log.txt pourraient ne pas être encore créés, en fonction de l'heure actuelle, car ils sont planifiés pour une exécution quotidienne et horaire respectivement. L'important est que leurs entrées soient correctement configurées dans votre crontab.

Ceci termine l'étape de gestion de la crontab utilisateur. Toutes les tâches cron continueront à s'exécuter jusqu'à ce que le conteneur soit détruit.

Planifier des tâches système récurrentes avec les répertoires cron

Dans cette étape, vous apprendrez à planifier des tâches récurrentes à l'échelle du système en utilisant les répertoires cron. Contrairement aux entrées crontab utilisateur, qui sont spécifiques à un utilisateur, les tâches cron système sont gérées par l'utilisateur root et affectent l'ensemble du système. Elles sont généralement utilisées pour la maintenance du système, la rotation des journaux et d'autres tâches administratives.

Nous continuerons à travailler sur le système local pour explorer la configuration des tâches cron à l'échelle du système.

Les tâches cron à l'échelle du système sont définies dans /etc/crontab ou en plaçant des scripts dans des répertoires spécifiques :

• /etc/cron.hourly/ : Les scripts de ce répertoire s'exécutent une fois par heure.
• /etc/cron.daily/ : Les scripts de ce répertoire s'exécutent une fois par jour.
• /etc/cron.weekly/ : Les scripts de ce répertoire s'exécutent une fois par semaine.
• /etc/cron.monthly/ : Les scripts de ce répertoire s'exécutent une fois par mois.

Ces répertoires sont traités par l'utilitaire run-parts, qui exécute tous les fichiers exécutables qu'ils contiennent.

Pour gérer les tâches cron système, vous avez besoin des privilèges root. Étant donné que l'utilisateur labex a accès sudo, nous pouvons utiliser sudo pour les commandes requises.

Créons un script simple qui enregistre un message dans le journal système. Nous placerons ce script dans /etc/cron.hourly/ pour qu'il s'exécute toutes les heures.

Tout d'abord, créez le fichier de script /etc/cron.hourly/my_hourly_script :

sudo nano /etc/cron.hourly/my_hourly_script

Ajoutez le contenu suivant au fichier :

#!/bin/bash
logger "Hourly cron job executed at $(date)"

Enregistrez et quittez l'éditeur (Ctrl+o, Entrée, Ctrl+x dans nano).

Ensuite, vous devez rendre le script exécutable. Sans les permissions d'exécution, run-parts l'ignorera.

sudo chmod +x /etc/cron.hourly/my_hourly_script

Maintenant, vérifions que le script est exécutable :

ls -l /etc/cron.hourly/my_hourly_script

Vous devriez voir x dans les permissions, par exemple : -rwxr-xr-x.

Étant donné que les tâches cron.hourly s'exécutent une fois par heure, nous ne pouvons pas attendre une heure complète pour vérifier son exécution dans ce laboratoire. Cependant, nous pouvons déclencher manuellement la commande run-parts pour le répertoire horaire afin de simuler son exécution.

sudo run-parts /etc/cron.hourly/

Cette commande exécutera tous les scripts exécutables dans /etc/cron.hourly/. Le script que nous avons créé utilise la commande logger pour écrire des messages dans le journal système. Bien que nous ne puissions pas facilement vérifier la sortie du journal dans cet environnement de conteneur, l'objectif d'apprentissage important est de comprendre comment créer et gérer des scripts dans les répertoires cron.

Dans un véritable système RHEL, vous seriez en mesure de vérifier les journaux système en utilisant journalctl ou /var/log/messages pour vérifier que le script s'est exécuté avec succès.

Ceci termine l'étape de gestion des tâches cron système. Le script restera en place et s'exécuterait toutes les heures dans un véritable environnement système.

Configurer les timers systemd pour les tâches récurrentes

Dans cette étape, vous en apprendrez davantage sur les minuteurs systemd, qui sont une alternative moderne à cron pour la planification des tâches sur les systèmes Linux. Les minuteurs systemd offrent plus de flexibilité et une meilleure intégration avec l'écosystème systemd. Bien que les commandes systemctl soient généralement utilisées pour gérer les unités systemd, en raison de l'environnement du conteneur Docker, nous nous concentrerons sur la création et la vérification directes des fichiers d'unités de minuterie et de service.

Les minuteurs systemd fonctionnent en conjonction avec les unités de service systemd. Une unité de minuterie (fichier .timer) définit quand une tâche doit s'exécuter, et une unité de service (fichier .service) définit quelle tâche doit être exécutée.

Nous continuerons à travailler sur le système local pour explorer la configuration des minuteurs systemd.

Vous aurez besoin des privilèges root pour créer des fichiers d'unités systemd dans les répertoires système. Étant donné que l'utilisateur labex a accès sudo, nous pouvons utiliser sudo pour les commandes requises.

Créons un service simple qui enregistre un message dans un fichier. Nous placerons ce fichier d'unité de service dans /etc/systemd/system/, qui est l'endroit où les unités de service personnalisées sont généralement stockées.

Créez le fichier d'unité de service /etc/systemd/system/my-custom-task.service :

sudo nano /etc/systemd/system/my-custom-task.service

Ajoutez le contenu suivant au fichier :

[Unit]
Description=My Custom Scheduled Task

[Service]
Type=oneshot
ExecStart=/bin/bash -c 'echo "My custom task executed at $(date)" >> /var/log/my-custom-task.log'

Enregistrez et quittez l'éditeur (Ctrl+o, Entrée, Ctrl+x dans nano).

Ensuite, créez le fichier d'unité de minuterie /etc/systemd/system/my-custom-task.timer. Cette minuterie activera notre service toutes les 5 minutes.

sudo nano /etc/systemd/system/my-custom-task.timer

Ajoutez le contenu suivant au fichier :

[Unit]
Description=Run My Custom Scheduled Task every 5 minutes

[Timer]
OnCalendar=*:0/5
Persistent=true

[Install]
WantedBy=timers.target

Enregistrez et quittez l'éditeur.

Explication de OnCalendar :

• *:0/5 signifie "toutes les 5 minutes".
  • * pour l'année, le mois, le jour, l'heure (n'importe quelle valeur).
  • 0/5 pour la minute, ce qui signifie à partir de la minute 0, toutes les 5 minutes (0, 5, 10, ..., 55).

Dans un environnement systemd typique, vous exécuteriez maintenant systemctl daemon-reload pour que systemd prenne connaissance des nouveaux fichiers d'unités, puis systemctl enable --now my-custom-task.timer pour démarrer la minuterie. Cependant, en raison des limitations du conteneur Docker, systemctl n'est pas entièrement fonctionnel.

Au lieu de cela, nous vérifierons manuellement la création des fichiers. Le démon systemd à l'intérieur du conteneur pourrait éventuellement récupérer ces fichiers, mais nous ne pouvons pas contrôler ou observer directement son exécution de minuterie dans cette configuration de laboratoire. L'objectif principal ici est de comprendre comment configurer ces fichiers.

Vérifions l'existence des fichiers créés :

ls -l /etc/systemd/system/my-custom-task.service
ls -l /etc/systemd/system/my-custom-task.timer

Vous devriez voir une sortie indiquant que les deux fichiers existent.

Pour simuler l'exécution du service, vous pouvez exécuter manuellement la commande définie dans ExecStart :

sudo /bin/bash -c 'echo "My custom task executed at $(date)" >> /var/log/my-custom-task.log'

Maintenant, vérifiez le fichier journal pour voir la sortie :

sudo cat /var/log/my-custom-task.log

Vous devriez voir le message que vous venez d'enregistrer :

My custom task executed at Tue Jun 10 06:54:40 UTC 2025

Ceci termine l'étape de configuration du minuteur systemd. Les fichiers d'unités de service et de minuterie resteront en place pour référence.

Gérer les fichiers temporaires avec systemd-tmpfiles

Dans cette étape, vous apprendrez à gérer les fichiers et répertoires temporaires à l'aide de systemd-tmpfiles. Cet utilitaire fait partie de systemd et est responsable de la création, de la suppression et du nettoyage des fichiers et répertoires volatils et temporaires. Il est couramment utilisé pour gérer /tmp, /var/tmp et d'autres emplacements de stockage temporaires, en veillant à ce que les anciens fichiers soient supprimés périodiquement.

Nous continuerons à travailler sur le système local pour explorer la configuration de systemd-tmpfiles.

Vous aurez besoin des privilèges root pour configurer systemd-tmpfiles. Étant donné que l'utilisateur labex a accès sudo, nous pouvons utiliser sudo pour les commandes requises.

systemd-tmpfiles lit les fichiers de configuration à partir de /etc/tmpfiles.d/ et /usr/lib/tmpfiles.d/. Ces fichiers définissent les règles de création, de suppression et de gestion des fichiers et répertoires.

Créons un fichier de configuration personnalisé pour gérer un nouveau répertoire temporaire. Nous allons créer un répertoire /run/my_temp_dir et configurer systemd-tmpfiles pour nettoyer les fichiers de plus de 1 minute.

Créez le fichier de configuration /etc/tmpfiles.d/my_temp_dir.conf :

sudo nano /etc/tmpfiles.d/my_temp_dir.conf

Ajoutez le contenu suivant au fichier :

d /run/my_temp_dir 0755 labex labex 1m

Explication de la ligne :

• d : Spécifie que cette entrée définit un répertoire.
• /run/my_temp_dir : Le chemin d'accès au répertoire.
• 0755 : Les permissions pour le répertoire.
• labex labex : Le propriétaire et le groupe pour le répertoire.
• 1m : L'âge après lequel les fichiers de ce répertoire doivent être supprimés (1 minute).

Enregistrez et quittez l'éditeur (Ctrl+o, Entrée, Ctrl+x dans nano).

Maintenant, disons à systemd-tmpfiles d'appliquer cette configuration. L'option --create créera le répertoire s'il n'existe pas.

sudo systemd-tmpfiles --create /etc/tmpfiles.d/my_temp_dir.conf

Vérifiez que le répertoire a été créé avec les permissions et la propriété correctes :

ls -ld /run/my_temp_dir

Vous devriez voir une sortie similaire à :

drwxr-xr-x 2 labex labex 6 Jun 10 06:55 /run/my_temp_dir

Ensuite, créons un fichier de test à l'intérieur de ce nouveau répertoire temporaire :

sudo touch /run/my_temp_dir/test_file.txt

Vérifiez que le fichier existe :

ls -l /run/my_temp_dir/test_file.txt

Maintenant, nous devons attendre plus d'une minute pour que le fichier devienne "ancien" selon notre configuration. Attendez au moins 70 secondes (1 minute et 10 secondes).

Après avoir attendu plus d'une minute, nous allons exécuter manuellement systemd-tmpfiles avec l'option --clean pour déclencher le processus de nettoyage en fonction de notre configuration.

sudo systemd-tmpfiles --clean /etc/tmpfiles.d/my_temp_dir.conf

Enfin, vérifiez si test_file.txt a été supprimé :

ls -l /run/my_temp_dir/test_file.txt

Vous devriez obtenir une erreur "No such file or directory", indiquant que systemd-tmpfiles a nettoyé avec succès l'ancien fichier.

Ceci termine l'étape de configuration de systemd-tmpfiles. Le fichier de configuration et le répertoire temporaire resteront en place pour référence.

Résumé

Dans ce lab, vous avez appris à planifier et à gérer des tâches ponctuelles à l'aide de la commande at, y compris la planification de tâches de manière interactive et non interactive, l'affichage de la file d'attente at avec atq et la suppression des tâches en attente avec atrm. Vous avez également acquis une maîtrise de la planification des tâches récurrentes spécifiques à l'utilisateur à l'aide de crontab, couvrant la façon d'éditer, de lister et de supprimer les tâches cron, et de comprendre la syntaxe cron pour spécifier les heures d'exécution. De plus, le lab a démontré comment planifier des tâches récurrentes à l'échelle du système en plaçant des scripts dans les répertoires cron standard (/etc/cron.hourly, /etc/cron.daily, etc.) et comment créer des tâches cron personnalisées dans /etc/cron.d.

Enfin, vous avez exploré la planification de tâches avancée avec les minuteurs systemd, en apprenant à créer et à activer des unités de service et de minuterie pour les tâches récurrentes, et comment gérer les fichiers et répertoires temporaires à l'aide de systemd-tmpfiles pour un nettoyage automatisé. Ce lab complet a fourni une expérience pratique dans la gestion des divers besoins de planification de tâches sur les systèmes RHEL, des commandes ponctuelles simples aux processus système récurrents complexes.