Accéder au contenuNavigation Accéder à la page : page précédente [raccourci clavier p] / page suivante [raccourci clavier n]
documentation.suse.com / Utilisation des minuteurs systemd

Utilisation des minuteurs systemd

Date de publication : 29 sep 2024
CONTENU

De l'exécution d'un script de sauvegarde à intervalles réguliers au démarrage d'un processus spécifique dès le démarrage de la machine, de nombreuses tâches nécessitent une planification sur un système Linux. Les minuteurs systemd offrent un mécanisme flexible pour la planification et la gestion des travaux et des services.

MOTIF

Cet article entend fournir une présentation complète des minuteurs systemd couvrant la création, la maintenance, les tests, le dépannage et la migration à partir de cron.

EFFORT

La création d'un exemple de minuteur systemd prend 10 minutes. Comptez jusqu'à 30 minutes pour bien comprendre le fonctionnement des minuteurs systemd.

CONDITIONS REQUISES

1 Concept de minuteur systemd

Les unités de minuteur systemd fournissent un mécanisme de planification des travaux sous Linux. L'heure d'exécution de ces travaux peut être basée sur la date/l'heure ou sur des événements.

Les unités de minuteur systemd sont identifiées par l'extension de nom de fichier .timer. Chaque fichier de minuteur nécessite un fichier de service correspondant qu'il contrôle. En d'autres termes, un fichier de minuteur active et gère le fichier de service correspondant. Les minuteurs systemd prennent en charge les fonctions suivantes :

  • Les travaux planifiés à l'aide d'une unité de minuteur peuvent dépendre d'autres services systemd. Les unités de minuteur sont traitées comme des services systemd standard et peuvent donc être gérées avec systemctl.

  • Les minuteurs peuvent fonctionner en temps réel (en étant déclenchés par des événements du calendrier) ou monotones (ils sont alors déclenchés après un délai spécifié qui s'est écoulé depuis un certain point de départ).

  • Les unités de temps sont consignées dans le journal système, ce qui facilite leur surveillance et leur dépannage.

  • Les minuteurs utilisent les services de gestion systemd centralisés.

  • Si le système est éteint pendant la durée d'exécution prévue, le minuteur se réenclenche une fois que le système est de nouveau en cours d'exécution.

2 Création d'un minuteur

L'exemple suivant montre comment configurer un minuteur qui déclenche le script de shell helloworld.sh après l'heure de démarrage et recommence son exécution toutes les 24 heures par rapport à son heure d'activation. Il fonctionne également du lundi au vendredi à 10 h.

2.1 Exemple Hello World

  1. Créez le fichier /etc/systemd/system/helloworld.service avec le contenu suivant :

    [Unit]
    Description="Hello World script"
    
    [Service]
    ExecStart=/usr/local/bin/helloworld.sh

    Il s'agit d'un fichier de service systemd qui indique quelle application systemd doit être exécutée.

  2. Créez le fichier /etc/systemd/system/helloworld.timer avec le contenu suivant :

    [Unit]
    Description="Run helloworld.service 5min after boot and every 24 hours relative to activation time"
    
    [Timer]
    OnBootSec=5min
    OnUnitActiveSec=24h
    OnCalendar=Mon..Fri *-*-* 10:00:*
    Unit=helloworld.service
    
    [Install]
    WantedBy=multi-user.target

    Il s'agit du fichier de minuteur qui contrôle l'activation du fichier de service respectif.

  3. Vérifiez que les fichiers que vous avez créés ci-dessus ne contiennent aucune erreur :

    > systemd-analyze verify /etc/systemd/system/helloworld.*

    Si la commande ne renvoie aucun résultat, les fichiers ont réussi la vérification.

  4. Démarrez le minuteur :

    > sudo systemctl start helloworld.timer

    Active le minuteur pour la session en cours uniquement.

  5. Activez le minuteur pour vous assurer qu'il est activé au démarrage :

    > sudo systemctl enable helloworld.timer

2.2 L'exemple expliqué

Exemple 1 : le fichier de service
[Unit]
Description="Hello World script"1

[Service]
ExecStart=/usr/local/bin/helloworld.sh2

1

Brève description expliquant la fonction du fichier de service.

2

L'application à exécuter.

Les sections [Unit] et [Service]représentent les sections minimales requises pour qu'un fichier de service fonctionne. Les fichiers de service systemd contiennent normalement une section [Install] qui détermine une ou plusieurs cibles pour un service à charger. Cette section n'est pas requise dans les fichiers de service pour les minuteurs, étant donné que ces informations sont fournies avec le fichier de minuteur. Pour une configuration avancée, reportez-vous à la section Managing systemd targets with systemctl.

Exemple 2 : le fichier de minuteur
[Unit]
Description="Run helloworld.service 5min after boot and every 24 hours relative to activation time"1

[Timer]
OnBootSec=5min2
OnUnitActiveSec=24h3
OnCalendar=Mon..Fri *-*-* 10:00:*4
Unit=helloworld.service5

[Install]
WantedBy=multi-user.target6

1

Brève description expliquant à quoi sert le fichier de minuteur.

2

Spécifie un minuteur qui déclenche le service cinq minutes après le démarrage du système. Pour plus de détails, reportez-vous à la section Minuteurs monotones.

3

Spécifie un minuteur qui déclenche le service 24 heures après son activation (autrement dit, le minuteur déclenche le service une fois par jour). Pour plus de détails, reportez-vous à la section Minuteur en temps réel.

4

Spécifie un minuteur qui déclenche le service à des moments fixes (dans cet exemple, du lundi au vendredi à 10 heures). Pour plus de détails, reportez-vous à la section Minuteur en temps réel.

5

Fichier de service à exécuter.

6

Cible systemd dans laquelle le minuteur est activé. Pour plus d'informations sur les cibles systemd, reportez-vous au document Managing systemd targets with systemctl.

3 Gestion des minuteurs

Vous pouvez gérer les minuteurs à l'aide de la commande systemctl.

Démarrage et arrêt des minuteurs
> sudo systemctl start TIMER.timer
> sudo systemctl restart TIMER.timer
> sudo systemctl stop TIMER.timer
Activation et désactivation des minuteurs
> sudo systemctl enable TIMER.timer
> sudo systemctl disable TIMER.timer
Affichage du contenu du fichier de minuteur
> sudo systemctl cat TIMER.timer
Vérification d'un minuteur spécifique
> sudo systemctl status TIMER.timer
Exemple 3 : État du minuteur
> sudo systemctl status helloworld.timer
● helloworld.timer - "Run helloworld.service 5min after boot and every 24 hours
relative to activation time"1
Loaded: loaded (/etc/systemd/system/helloworld.timer; disabled; vendor preset: disabled)2
Active: active (waiting) since Tue 2022-10-26 18:35:41 CEST; 6s ago3
Trigger: Wed 2022-10-27 18:35:41 CEST; 23h left4
Triggers: ● helloworld.service5
6
Oct 26 18:35:41 neo systemd[1]: Started "Run helloworld.service 5min after boot and every 24 hours relative to activation time".7

1

Nom et description du fichier du minuteur.

2

Indique si un minuteur a pu être analysé et s'il est conservé en mémoire (chargé), affiche le chemin d'accès complet au fichier de minuteur et indique si le minuteur est lancé au moment du démarrage (activé) ou non (désactivé). La première valeur indique la configuration actuelle du système, la seconde, la valeur prédéfinie du fournisseur.

3

Indique si le minuteur est actif (en attente de déclenchement d'événements) ou inactif. S'il est actif, il affiche également le temps écoulé depuis la dernière activation (6 secondes dans cet exemple).

4

Date et heure du prochain déclenchement du minuteur.

5

Nom du fichier de service déclenché par le minuteur.

6

Ligne facultative pointant vers la documentation (par exemple, pages de manuel). Si celle-ci n'est pas disponible, une ligne vide s'affiche (comme dans cet exemple).

7

Dernière entrée de journal créée par le minuteur.

Pour lister tous les minuteurs disponibles sur le système, utilisez systemctl list-timers. Les options suivantes sont disponibles :

Répertorier tous les minuteurs actifs :
> sudo systemctl list-timers
Répertorier tous les minuteurs, y compris ceux qui sont inactifs :
> sudo systemctl list-timers --all
Répertorier tous les minuteurs correspondant à un modèle :
> sudo systemctl list-timers PATTERN
> sudo systemctl list-timers --allPATTERN

PATTERN doit être un nom ou une expression globbing du shell. Les opérateurs *, ? et []peuvent être utilisés. Reportez-vous à la section man 7 glob pour plus d'informations sur les modèles globbing.

Répertorier les minuteurs correspondant à un état donné :
> sudo systemctl list-timers --state=STATE

STATE prend les valeurs suivantes : active, failed, load, sub. Pour plus de détails, reportez-vous à la section man systemctl.

Exemple 4 : liste des minuteurs

L'exécution d'une commande systemctl list-timers affiche les résultats dans un tableau similaire au suivant. Dans cet exemple, tous les minuteurs actifs correspondant au modèle snapper* sont répertoriés :

> sudo systemctl list-timers snapper*
NEXT1                       LEFT2      LAST3                        PASSED4   UNIT5                  ACTIVATES6

-----------------------------------------------------------------------------------------------------------------------------
Tue 2022-10-26 19:00:00 CEST 39min left Tue 2022-10-26 18:00:29 CEST 19min ago snapper-timeline.timer snapper-timeline.service
Wed 2022-10-27 08:33:04 CEST 14h   left Tue 2022-10-26 08:33:04 CEST 9h ago    snapper-cleanup.timer  snapper-cleanup.service

1

Heure de la prochaine exécution du minuteur.

2

Temps restant avant la prochaine exécution du minuteur.

3

Heure de la dernière exécution du minuteur.

4

Temps écoulé depuis la dernière exécution du minuteur.

5

Nom de l'unité de minuteur.

6

Nom du service que le minuteur active.

4 Types de minuteur

systemd prend en charge deux types de minuteurs : en temps réel (basé sur le calendrier) et monotones (basés sur les événements). Bien que les minuteurs soient normalement permanents, systemd permet également de configurer des minuteurs transitoires qui ne sont valides que pour la session en cours.

Minuteur en temps réel

Les minuteurs en temps réel sont déclenchés par des événements du calendrier. Ils sont définis à l'aide de l'option OnCalendar.

Vous pouvez spécifier quand déclencher un événement en fonction de la date et de l'heure. Utilisez le modèle suivant :

OnCalendar=DayOfWeek1 Year-Month-Day2 Hour:Minute:Second3

1

Jour de la semaine. Les valeurs possibles sont Sun, Mon, Tue, Wed, Thu, Fri et Sat. Pour ignorer un jour de la semaine, ne l'indiquez pas.

2

Date. Indiquez le mois et le jour par deux chiffres et l'année par quatre chiffres. Chaque valeur peut être remplacée par le caractère joker * pour correspondre à chaque occurrence.

3

Heure. Spécifiez chaque valeur à l'aide de deux chiffres. Chaque valeur peut être remplacée par le caractère joker * pour correspondre à chaque occurrence.

S'applique à toutes les valeurs : utilisez deux points pour définir une plage continue (Mon..Fri). Utilisez une virgule pour délimiter une liste de valeurs distinctes (Mon,Wed,Fri).

Exemple 5 : exemples de minuteurs en temps réel
  • 18 h tous les vendredis :

    OnCalendar=Fri *-*-* 18:00:00
  • 5 h tous les jours :

    OnCalendar=Mon..Sun *-*-* 5:00:00
  • 1 h et 3 h les dimanches et mardis :

    OnCalendar=Tue,Sun *-*-* 01,03:00:00
  • Date unique :

    OnCalendar=Mo..Sun 2023-09-23 00:00:01
  • Pour spécifier des déclencheurs à des moments différents, vous pouvez créer plusieurs entrées OnCalendar dans un seul fichier de minuteur :

    OnCalendar=Mon..Fri *-*-* 10:00
    OnCalendar=Sat,Sun *-*-* 22:00

Pour obtenir la liste complète des fonctions et options disponibles, reportez-vous à la page man 7 systemd.time qui fournit des informations supplémentaires concernant les sujets suivants :

  • raccourcir la syntaxe et utiliser des abréviations ;

  • spécifier des répétitions ;

  • rechercher des jours spécifiques dans un mois (dernier jour du mois, dimanche dernier, etc.) ;

  • appliquer des fuseaux horaires.

Minuteurs monotones

Les minuteurs monotones sont déclenchés un certain temps après un événement donné, par exemple, un événement de démarrage du système ou d'activation de l'unité système. Les valeurs sont définies en tant qu'unités de temps (minutes, heures, jours, mois, années, etc.). Les unités suivantes sont prises en charge : usec, msec, seconds, minutes, hours, days, weeks, months et years. Plusieurs options permettent de définir des minuteurs monotones :

  • OnActiveSec : durée spécifiée après l'activation de l'unité

    OnActiveSec=50minutes
  • OnBootSec : durée spécifiée après le démarrage du système

    OnBootSec=10hours
  • OnStartupSec : durée spécifiée après le démarrage du gestionnaire de services. Pour les services système, cette valeur est pratiquement égale à OnActiveSec. Utilisez cette option pour les services utilisateur dans lesquels le gestionnaire de services est lancé lors de la connexion de l'utilisateur.

    OnStartupSec=5minutes 20seconds
  • OnUnitActiveSec : durée après la dernière activation du service correspondant

    OnUnitActiveSec=10seconds
  • OnUnitInactiveSec : durée après la dernière désactivation du service correspondant

    OnUnitInactiveSec=2hours 15minutes 18 seconds
Minuteurs transitoires

Les minuteurs transitoires sont des minuteurs temporaires qui sont valides uniquement durant la session en cours. Ces minuteurs vous permettent d'utiliser un fichier de service existant ou de démarrer un programme directement. Les minuteurs transitoires sont invoqués en exécutant la commande systemd-run.

L'exemple suivant exécute l'unité helloworld.service toutes les deux heures :

> sudo systemd-run --on-active="2hours" --unit="helloworld.service"

Pour exécuter une commande directement, utilisez la syntaxe suivante. Dans cet exemple, le script /usr/local/bin/helloworld.sh est appelé directement :

> sudo systemd-run --on-active="2hours" /usr/local/bin/helloworld.sh

Si la commande accepte des paramètres, ajoutez-les en les séparant par une espace :

> sudo systemd-run --on-active="2hours" /usr/local/bin/helloworld.sh --language=pt_BR

Les minuteurs transitoires peuvent être monotones ou fonctionner en temps réel. Les paramètres suivants sont pris en charge et fonctionnent comme décrit dans la rubrique Minuteurs monotones :

  • --on-active

  • --on-startup

  • --on-unit-active

  • --on-unit-inactive

  • --on-calendar

Pour plus d'informations, reportez-vous à la commande man 1 systemd-run.

5 Test des entrées du calendrier

systemd fournit un outil pour tester et créer des entrées de minuteur d'agenda pour les minuteurs en temps réel : systemd-analyze calendar. Il accepte le même argument que l'entrée OnCalendar requise pour configurer les minuteurs en temps réel.

Vous pouvez concaténer plusieurs arguments séparés par des espaces. Si le terme à tester est correct, la sortie affiche le prochain déclenchement du minuteur (en heure locale et UTC). Elle affiche également la chaîne dans un format normalisé (Normalized form) et l'utilisation de cette chaîne dans le fichier du minuteur est recommandée. Prenez en considération les exemples suivants :

> systemd-analyze calendar "Tue,Sun *-*-* 01,03:00:00"
Normalized form: Tue,Sun *-*-* 01,03:00:00
Next elapse: Sun 2021-10-31 01:00:00 CEST
(in UTC): Sat 2021-10-30 23:00:00 UTC
From now: 3 days left

> systemd-analyze calendar "Mon..Fri *-*-* 10:00" "Sat,Sun *-*-* 22:00"
Original form: Mon..Fri *-*-* 10:00
Normalized form: Mon..Fri *-*-* 10:00:00
Next elapse: Thu 2021-10-28 10:00:00 CEST
(in UTC): Thu 2021-10-28 08:00:00 UTC
From now: 19h left

Original form: Sat,Sun *-*-* 22:00
Normalized form: Sat,Sun *-*-* 22:00:00
Next elapse: Sat 2021-10-30 22:00:00 CEST
(in UTC): Sat 2021-10-30 20:00:00 UTC
From now: 3 days left

Pour les minuteurs récurrents, utilisez le paramètre –iterations N afin de répertorier les heures de déclenchement, puis vérifiez s'ils fonctionnent comme prévu. L'argument N spécifie le nombre d'itérations que vous souhaitez tester. L'exemple de chaîne suivant se déclenche toutes les 8 heures (à partir de 00:00:00) le dimanche :

> systemd-analyze calendar --iterations 5 "Sun *-*-* 0/08:00:00"
Original form: Sun *-*-* 0/08:00:00
Normalized form: Sun *-*-* 00/8:00:00
Next elapse: Sun 2021-10-31 00:00:00 CEST
(in UTC): Sat 2021-10-30 22:00:00 UTC
From now: 3 days left
Iter. #2: Sun 2021-10-31 08:00:00 CET
(in UTC): Sun 2021-10-31 07:00:00 UTC
From now: 3 days left
Iter. #3: Sun 2021-10-31 16:00:00 CET
(in UTC): Sun 2021-10-31 15:00:00 UTC
From now: 4 days left
Iter. #4: Sun 2021-11-07 00:00:00 CET
(in UTC): Sat 2021-11-06 23:00:00 UTC
From now: 1 week 3 days left
Iter. #5: Sun 2021-11-07 08:00:00 CET
(in UTC): Sun 2021-11-07 07:00:00 UTC
From now: 1 week 3 days left

6 Notifications par message électronique en cas d'échec d'un minuteur

systemd n'offre pas de fonction similaire à MAILTO de cron. La procédure ci-dessous décrit une solution de contournement pour activer les notifications par message électronique en cas d'échec d'un minuteur.

La procédure comporte les étapes suivantes :

  1. Créez un script qui envoie un message électronique.

  2. Créez un fichier de service systemd exécutant le script de messagerie.

  3. Testez le fichier de service de messagerie.

  4. À partir du service contrôlé par le minuteur, appelez le fichier de service de messagerie créé via OnFailure.

Dans l'exemple suivant, nous utilisons la commande mailx du paquet mailx. Le serveur de messagerie Postfix doit être installé et configuré correctement.

  1. Créez le script /usr/local/bin/send_systemd_email.

    1. Le script requiert deux paramètres : $1, l'adresse électronique et $2, le nom du fichier de service pour lequel la notification d'échec est reçue. Les deux paramètres sont fournis par le fichier d'unité qui exécute le script de messagerie.

      #!/bin/sh
      systemctl status --full "$2" | mailx -S sendwait\
       -s "Service failure for $2" -r root@$HOSTNAME $1
    2. Assurez-vous que le script est exécutable :

      > sudo chmod 755 /usr/local/bin/send_systemd_email
  2. Créez le fichier /etc/systemd/system/send_email_to_USER@.service.

    [Unit]
    Description=Send systemd status information by email for %i to USER
    
    [Service]
    Type=oneshot
    ExecStart=/usr/local/bin/send_systemd_email EMAIL_ADDRESS %i
    User=root
    Group=systemd-journal

    Remplacez USER et EMAIL_ADDRESS dans le fichier par l'adresse de connexion et l'adresse électronique de l'utilisateur qui doit recevoir le message électronique. %i est le nom du service qui a échoué (il est transmis au service de messagerie par le paramètre %n).

  3. Vérifiez le fichier de service et corrigez les problèmes signalés :

    > systemd-analyze verify /etc/systemd/system/send_email_to_USER@.service

    Si la commande ne renvoie aucun résultat, le fichier a réussi la vérification.

  4. Pour vérifier la procédure complète, démarrez le service à l'aide de l'instance dbus à des fins de test. (Vous pouvez utiliser tout autre service en cours d'exécution. dbus est employé dans cet exemple, car l'exécution du service est garantie sur n'importe quelle installation.)

    > sudo systemctl start send_email_to_USER@dbus.service

    En cas de réussite, EMAIL_ADDRESS reçoit un courrier électronique ayant comme objet Service failure for dbus et contenant les messages d'état dbus dans le corps. (Il s'agit simplement d'un test. Il n'y a aucun problème avec le service dbus. Vous pouvez supprimer le message en toute sécurité, aucune action n'est requise).

    Si le message électronique de test a bien été envoyé, intégrez-le à votre fichier de service.

  5. Pour ajouter une notification par message électronique au service, ajoutez une option OnFailure à la section Unit du fichier de service pour lequel vous souhaitez être averti en cas d'échec :

    [Unit]
    Description="Hello World script"
    OnFailure1=send_email_to_USER2@%n3.service
    
    [Service]
    ExecStart=/usr/local/bin/helloworld.sh

    1

    L'option OnFailure prend un service comme argument.

    2

    Remplacez la partie du nom de fichier de l'unité de service par le nom de connexion.

    3

    Spécifie le nom du service (helloworld, dans cet exemple). Ce nom est disponible dans le fichier de service de messagerie en tant que %i.

  6. Vous avez correctement configuré la notification d'échec pour les services systemd.

Astuce
Astuce : envoi de notifications par message électronique à plusieurs utilisateurs

L'adresse électronique du destinataire est codée en dur dans le fichier de service de messagerie. Pour envoyer des messages de notification à un autre utilisateur, copiez le fichier du service de messagerie et remplacez le nom de connexion de l'utilisateur dans le nom de fichier et l'adresse électronique dans la copie.

Pour envoyer une notification d'échec à plusieurs destinataires simultanément, ajoutez les fichiers de service respectifs au fichier de service (utilisez des espaces comme séparateur) :

OnFailure=send_email_to_tux@%n.service send_email_to_wilber@%n.service

7 Utilisation de minuteurs en tant qu'utilisateur standard

Les minuteurs systemd peuvent également être utilisés par des utilisateurs standard. Ils vous aident à automatiser les tâches récurrentes telles que les sauvegardes, le traitement d'images ou le déplacement de données dans le cloud.

Les mêmes procédures et tâches que pour les minuteurs système sont valides. Toutefois, les différences suivantes doivent être prises en compte :

  • Les fichiers de minuteur et de service doivent se trouver à l'emplacement ~/.config/systemd/user/.

  • Toutes les commandes systemctl et journalctl doivent être exécutées avec le paramètre --user. systemd-analyze ne nécessite pas cette option.

    En tant qu'utilisateur standard, vous devez fournir le chemin d'accès aux fichiers d'unité, comme dans les exemples ci-dessous. Sinon, s'il existe un minuteur système portant le même nom, il sera exécuté ou répertorié dans la liste à la place.

    > systemctl --user start ~/.config/systemd/user/helloworld.timer
    > systemctl --user enable ~/.config/systemd/user/helloworld.timer
    > systemctl --user list-timers
    > journalctl --user -u helloworld.*
    > systemd-analyze verify ~/.config/systemd/user/helloworld.timer
Important
Important : les minuteurs de l'utilisateur ne s'exécutent que pendant une session active

Comme pour les autres services systemd démarrés en tant qu'utilisateur standard, les minuteurs de l'utilisateur ne s'exécutent que lorsque l'utilisateur est connecté. Toutefois, pour démarrer les minuteurs utilisateur au moment du démarrage et les faire fonctionner après la déconnexion, activez la fonction de persistance lingering pour chaque utilisateur concerné :

sudo loginctl enable-linger USER

Pour plus d'informations, reportez-vous à la commande man 1 loginctl.

Important
Important : les variables d'environnement ne sont pas héritées

L'instance utilisateur systemd n'hérite pas des variables d'environnement définies par des scripts tels que ~/.profile ou ~/.bashrc. Pour vérifier l'environnement systemd, exécutez systemctl --user show-environment.

Pour importer des variables manquantes dans l'environnement systemd, spécifiez la commande suivante à la fin de ~/.bashrc :

systemctl --user import-environment VARIABLE1 VARIABLE2

8 Migration de cron vers des minuteurs systemd

Tous les travaux cron peuvent être migrés vers des minuteurs systemd. Vous trouverez des instructions et un exemple ici.

  1. Créez un fichier de service exécutant le script. Pour plus de détails, reportez-vous à l'Exemple 1, « le fichier de service ».

  2. Créez un fichier de minuteur exécutant le fichier de service. Pour des instructions générales, consultez l'Exemple 2, « le fichier de minuteur ».

    1. Convertissez les entrées du calendrier. L'heure est spécifiée différemment dans cron et dans systemd. Utilisez les modèles ci-dessous comme modèle de conversion :

      Cron:               Minute Hour Day Month DayOfWeek
      systemd: OnCalendar=DayOfWeek Year-Month-Day Hour:Minute:Second

      Pour tester l'entrée de calendrier convertie, suivez les instructions de la Section 5, « Test des entrées du calendrier ».

    2. Convertissez les pseudonymes cron (@NICK) :

      Cron     : systemd timer
      -------- : ----------------------------
      @reboot  : OnBootSec=1s
      @yearly  : OnCalendar=*-01-01 00:00:00
      @annually: OnCalendar=*-01-01 00:00:00
      @monthly : OnCalendar=*-*-01 00:00:00
      @weekly  : OnCalendar=Sun *-*-* 00:00:00
      @daily   : OnCalendar=*-*-* 00:00:00
      @hourly  : OnCalendar=*-*-* *:00:00
    3. Convertissez les assignations de variables. L'assignation de variable systemd doit aller dans la section [Service]. Vous ne pouvez pas convertir MAILTO de cette manière. Pour ce faire, reportez-vous à l'étape suivante.

      cron: VARIABLE=VALUE
      systemd: Environment="VARIABLE=VALUE"
    4. Configurez des notifications par message électronique pour remplacer la fonction MAILTO de cron en suivant les instructions de la Section 6, « Notifications par message électronique en cas d'échec d'un minuteur ».

Exemple 6 : migration de cron vers le minuteur systemd

Voici les entrées crontab qui appellent le script helloworld.sh 5 minutes après le démarrage et à 10 heures du lundi au vendredi :

@reboot sleep 300 && /usr/local/bin/helloworld.sh
0 10 * * * 1-5 /usr/local/bin/helloworld.sh

Le fichier de service systemd (helloworld.service) qui appelle le script ressemble à ceci :

[Unit]
Description="Hello World script"
[Service]
ExecStart=/usr/local/bin/helloworld.sh

Le fichier de minuteur (helloworld.timer) ressemble à ceci :

[Unit]
Description="Run helloworld.service 5min after boot and at 10am every Mon-Fri"
[Timer]
OnBootSec=5min
OnCalendar=Mon..Fri *-*-* 10:00:*
Unit=helloworld.service
[Install]
WantedBy=multi-user.target

9 Dépannage et FAQ

Apprenez à déboguer et à dépanner les minuteurs systemd qui ont échoué. Trouvez des réponses aux questions fréquemment posées sur les minuteurs systemd.

9.1 Évitement des erreurs

Pour éviter les erreurs avec les minuteurs systemd, veillez à respecter les meilleures pratiques suivantes :

  • Vérifiez que l'exécutable que vous spécifiez dans le service avec ExecStart s'exécute correctement.

  • Vérifiez la syntaxe des fichiers de service et de minuteur en exécutant systemd-analyze verify FILE.

  • Vérifiez les heures d'exécution des entrées du calendrier en exécutant systemd-analyze calendar CALENDER_ENTRY.

9.2 Absence de déclenchement de l'événement

Lorsque vous activez un minuteur qui contient des erreurs non critiques, systemd les ignore en mode silencieux. Par exemple :

Exemple 7 : extrait du fichier du minuteur systemd contenant une erreur non fatale
[Timer]
OnBootSec=5min
OnClendar=Mon..Fri 10:00
Unit=helloworld.service

La ligne 3 contient une erreur de syntaxe (OnClendar au lieu de OnCalendar). Étant donné que la section [Timer] contient une seconde entrée de minuteur (OnBoot), l'erreur n'est pas critique et est ignorée en mode silencieux. Par conséquent, le déclencheur du lundi au vendredi n'est pas exécuté. La seule façon de détecter l'erreur consiste à utiliser la commande systemd-analyze verify :

#  systemd-analyze verify /etc/systemd/system/helloworld.timer
/etc/systemd/system/helloworld.timer:7: Unknown key name 'OnClendar' in section 'Timer', ignoring.

9.3 Vérification des erreurs dans le journal système

Comme pour chaque service systemd, les événements et les opérations déclenchés par des minuteurs sont consignés dans le journal système. Si un déclencheur ne se comporte pas comme prévu, vérifiez les messages du journal en entrant la commande journalctl. Pour filtrer les informations pertinentes du journal, utilisez le paramètre -u pour spécifier les minuteurs et les fichiers de service systemd. Cette option permet d'afficher les entrées du journal du minuteur et le fichier de service correspondant :

sudo journalctl -u  helloworld.timer -u helloworld.service

ou en version plus courte (le cas échéant) :

sudo journalctl -u  helloworld.*

journalctl est un outil qui prend en charge de nombreuses options et filtres. Reportez-vous à la commande man 1 journalctl pour plus d'informations. Les options suivantes sont utiles pour le dépannage des minuteurs :

  • -b : affiche uniquement les entrées du démarrage actuel.

  • -S today : affiche uniquement les entrées du jour.

  • -x : affiche les textes d'aide avec l'entrée du journal.

  • -f : commence par les entrées les plus récentes et imprime continuellement le journal lorsque de nouvelles entrées sont ajoutées. Cette option est utile pour vérifier les déclencheurs qui se produisent à intervalles courts. Quittez avec CtrlC.

9.4 Minuteur systemd : rattrapage des exécutions manquées

Si un minuteur systemd était inactif ou si le système était hors tension pendant le temps d'exécution prévu, les événements manqués peuvent éventuellement être déclenchés immédiatement lorsque le minuteur est réactivé. Pour activer cette fonction, ajoutez l'option de configuration Persistent=true à la section [Timer] :

[Timer]
OnCalendar=Mon..Fri 10:00
Persistent=true
Unit=helloworld.service

9.5 Comment migrer cron vers des minuteurs systemd ?

Tous les travaux cron peuvent être migrés vers des minuteurs systemd. Voici des instructions générales sur la migration d'une tâche cron :

  1. Créez un fichier de service exécutant le script. Pour plus de détails, reportez-vous à l'Exemple 1, « le fichier de service ».

  2. Créez un fichier de minuteur exécutant le fichier de service. Pour des instructions générales, consultez l'Exemple 2, « le fichier de minuteur ».

    1. Convertissez les entrées du calendrier. L'heure est spécifiée différemment dans cron et dans systemd. Utilisez les modèles ci-dessous comme modèle de conversion :

      Cron:               Minute Hour Day Month DayOfWeek
      systemd: OnCalendar=DayOfWeek Year-Month-Day Hour:Minute:Second

      Pour tester l'entrée de calendrier convertie, suivez les instructions de la Section 5, « Test des entrées du calendrier ».

    2. Convertissez les pseudonymes cron (@NICK) :

      Cron     : systemd timer
      -------- : ----------------------------
      @reboot  : OnBootSec=1s
      @yearly  : OnCalendar=*-01-01 00:00:00
      @annually: OnCalendar=*-01-01 00:00:00
      @monthly : OnCalendar=*-*-01 00:00:00
      @weekly  : OnCalendar=Sun *-*-* 00:00:00
      @daily   : OnCalendar=*-*-* 00:00:00
      @hourly  : OnCalendar=*-*-* *:00:00
    3. Convertissez les assignations de variables. L'assignation de variable systemd doit aller dans la section [Service]. Vous ne pouvez pas convertir MAILTO de cette manière. Pour ce faire, reportez-vous à l'étape suivante.

      cron: VARIABLE=VALUE
      systemd: Environment="VARIABLE=VALUE"
    4. Configurez des notifications par message électronique pour remplacer la fonction MAILTO de cron en suivant les instructions de la Section 6, « Notifications par message électronique en cas d'échec d'un minuteur ».

Exemple 8 : migration de cron vers le minuteur systemd

Voici les entrées crontab qui appellent le script helloworld.sh 5 minutes après le démarrage et à 10 heures du lundi au vendredi :

@reboot sleep 300 && /usr/local/bin/helloworld.sh
0 10 * * * 1-5 /usr/local/bin/helloworld.sh

Le fichier de service systemd (helloworld.service) qui appelle le script ressemble à ceci :

[Unit]
Description="Hello World script"
[Service]
ExecStart=/usr/local/bin/helloworld.sh

Le fichier de minuteur (helloworld.timer) ressemble à ceci :

[Unit]
Description="Run helloworld.service 5min after boot and at 10am every Mon-Fri"
[Timer]
OnBootSec=5min
OnCalendar=Mon..Fri *-*-* 10:00:*
Unit=helloworld.service
[Install]
WantedBy=multi-user.target

10 Informations supplémentaires