De cron aux temporisateurs systemd

Migrer une tâche de cron vers un temporisateur systemd, c’est réécrire une ligne cron à cinq champs en unité .timer dont l’expression OnCalendar indique quand l’unité .service correspondante doit s’exécuter — puis prouver que les deux plannings concordent avant de supprimer la ligne cron. La conversion semble mécanique : minutes et heures correspondent directement, les mois aussi, et la plupart des plannings simples se traduisent proprement. Le piège, c’est que les deux planificateurs ne comprennent pas la même chose par un planning d’apparence identique, et les points où ils divergent sont justement ceux qu’un coup d’œil ne détecte pas : un jour du mois combiné à un jour de la semaine, un déclenchement dans le trou du passage à l’heure d’été, une tâche mensuelle le 31. Vous pouvez convertir et prouver les deux côtés dans le convertisseur cron ⇄ temporisateur systemd, qui calcule les 100 prochaines exécutions de chacun et signale où elles divergent — entièrement dans votre navigateur.

Pourquoi les équipes quittent cron — et pourquoi cron reste suffisant pour les tâches simples

Cron est le plus ancien planificateur d’Unix, et ses limites sont les raisons pour lesquelles les équipes l’abandonnent. Une tâche cron ne peut pas attendre qu’un autre service soit prêt : si la tâche a besoin de la base de données, elle s’exécute quand même et échoue, car cron ne connaît pas l’ordre des dépendances. Sa sortie part vers le courrier local ou nulle part, donc une tâche qui échoue silencieusement continue d’échouer silencieusement — il n’y a pas de journal à interroger ni d’état à vérifier. Son calendrier ne compte que cinq champs, il n’y a donc aucun moyen de dire « le premier lundi du mois » ou « le dernier jour de février », et une machine éteinte ou endormie à la minute prévue manque simplement cette exécution. Un temporisateur systemd corrige chacun de ces points : des dépendances avec After= et Requires=, chaque déclenchement consigné dans le journal comme pour toute autre unité, un rattrapage Persistent= pour les exécutions manquées, et une expression OnCalendar avec noms de jours de semaine, plages de dates et syntaxe de dernier jour du mois.

Rien de tout cela ne signifie que cron est obsolète, et migrer une tâche qui fonctionne uniquement parce que les temporisateurs sont plus récents est une erreur. Cron reste l’outil adapté pour une tâche simple par utilisateur, pour un planning inchangé depuis dix ans, et pour tout système sans systemd — conteneurs, images minimales, hôtes BSD et macOS. Le test n’est pas de savoir quel planificateur est le plus récent, mais ce dont la tâche a besoin : si elle a besoin d’ordre, de journalisation, de rattrapage après un arrêt ou d’un calendrier que cron ne peut pas exprimer, migrez-la. Si c’est un planning d’une ligne qui n’a jamais échoué et que personne n’a jamais eu à déboguer, laissez-le tranquille. Une migration qui n’apporte rien est un risque sans retour, et cet article traite des migrations qui apportent quelque chose — réalisées de façon à ne pas pouvoir changer silencieusement le moment où la tâche s’exécute.

Le piège DOM+DOW : la seule erreur de migration qui double les exécutions en silence

La ligne la plus dangereuse d’une migration cron est celle qui restreint à la fois le jour du mois et le jour de la semaine, et l’exemple classique est 0 0 15 * 5. La plupart des gens le lisent comme « minuit, le vendredi 15 ». Ce n’est pas ce que cela signifie. La page de manuel crontab(5) énonce la règle sans détour : si les deux champs de jour sont restreints — aucun ne contient « * » — la commande s’exécute quand l’un ou l’autre des champs correspond. Donc 0 0 15 * 5 se déclenche à minuit le 15 de chaque mois et tous les vendredis, environ cinq fois par mois au lieu d’une, et cela dure depuis que la ligne existe. Quiconque la convertit en une seule ligne OnCalendar vient de changer le planning sans le savoir.

OnCalendar signifie l’inverse. La page de manuel systemd.time(7) donne l’exemple Thu,Fri 2012-*-1,5 et dit qu’il désigne le premier ou le cinquième jour du mois, « mais seulement si ce jour est un jeudi ou un vendredi » — la date et le jour de la semaine doivent correspondre tous les deux. La conversion naïve Fri *-*-15 00:00 ne se déclenche donc que lorsque le 15 tombe réellement un vendredi, quelques fois par an, et les exécutions du vendredi et la plupart de celles du 15 disparaissent silencieusement. La conversion correcte, ce sont deux lignes OnCalendar dans une seule unité .timer — *-*-15 00:00 et Fri *-*-* 00:00 — car la page de manuel systemd.timer(5) autorise OnCalendar à être spécifié plusieurs fois, et l’unité se déclenche dès que l’une de ses expressions arrive à échéance. Cette union est tout l’intérêt du convertisseur : il émet les deux lignes et signale l’entrée comme une union, au lieu d’émettre une seule ligne qui change le planning en silence.

Heure d’été et fin de mois : là où les deux planificateurs divergent vraiment

L’heure d’été est le point où les deux planificateurs cessent de s’accorder, même en principe, et les pages de manuel sont honnêtes sur cette asymétrie. Pour cron, crontab(5) énonce la règle explicitement : les heures inexistantes, comme les « heures perdues » du passage de printemps, ne correspondent jamais, donc une tâche prévue à 02:30 ce jour-là ne s’exécute tout simplement pas — et les heures qui se produisent deux fois, au passage d’automne, font s’exécuter deux fois les tâches correspondantes. Pour les temporisateurs, les pages de manuel de systemd n’énoncent aucune règle équivalente : systemd.time(7) et systemd.timer(5) décrivent la syntaxe du calendrier en détail, mais aucune des deux ne dit ce que fait un déclenchement OnCalendar dans l’heure perdue. Ce silence est un fait, pas une omission à combler en devinant, et cet article n’inventera pas une règle que les pages de manuel n’énoncent pas.

La fin de mois est la même histoire en miniature. Une ligne cron pour le 31 saute simplement chaque mois qui n’a pas 31 jours, et OnCalendar fait pareil par défaut — mais OnCalendar offre aussi une syntaxe que cron ne peut pas exprimer du tout, comme la forme de dernier jour avec « ~ » : *-02~01 signifie le dernier jour de février, et Mon *-05~07/1 signifie le dernier lundi de mai. La conséquence pratique est simple : gardez les tâches sensibles à l’heure en dehors de 02:00–03:00 si vous le pouvez, et sinon, générez le tableau des 100 prochaines exécutions en traversant un changement d’heure et une fin de mois, et lisez-le au lieu de deviner. Là où les pages de manuel se taisent, le tableau est la seule réponse honnête — exécutez-le, ne présumez rien. Il en va de même pour AccuracySec : les temporisateurs ne se déclenchent pas nécessairement à la seconde exacte configurée, donc un planning qui dépend de secondes exactes exige une autre conception, pas une expression plus serrée.

Le flux de preuve : comparez les 100 prochaines exécutions avant de basculer

Le flux de preuve est court, et le sauter, c’est la façon dont un bug de migration arrive en production. Convertissez la ligne cron, puis calculez les 100 prochaines exécutions des deux côtés à partir de la même heure de départ et dans le même fuseau horaire, côte à côte, et lisez le verdict sur les 100 complètes — pas sur les premières. Une divergence mensuelle peut ne pas apparaître dans les dix premières lignes, et une divergence d’heure d’été n’apparaîtra pas du tout à moins que la fenêtre ne traverse un changement d’heure, et c’est pourquoi le tableau va jusqu’à 100 exécutions et non 10. Le convertisseur calcule les deux tableaux dans votre navigateur et surligne les premières lignes où ils diffèrent ; systemd-analyze calendar valide une expression OnCalendar à la fois, ce qui sert à vérifier la moitié temporisateur, mais il ne peut pas comparer les deux moitiés à votre place.

La seconde moitié du flux est un indice pour la personne suivante. Gardez la ligne cron d’origine en commentaire dans le fichier .timer ou .service, à côté des lignes OnCalendar qui l’ont remplacée, pour que quiconque lit l’unité puisse voir ce qu’elle a remplacé et pourquoi il y a deux lignes au lieu d’une. Une conversion sans sa ligne d’origine est un planning que personne ne peut auditer : six mois plus tard, personne ne se souviendra si la deuxième ligne OnCalendar était délibérée ou un reste, et la tentation sera de la « nettoyer » — et c’est ainsi que les exécutions du vendredi disparaissent une seconde fois. La ligne cron commentée coûte une ligne et répond à la question avant qu’elle ne soit posée.

Le chemin de migration sûr : drop-ins, Persistent et le trou de @reboot

Ne modifiez jamais à la main un fichier d’unité empaqueté dans /usr/lib/systemd/system : la prochaine mise à jour du paquet l’écrasera, et la migration disparaîtra silencieusement avec le durcissement. La voie prise en charge est un drop-in — exécutez systemctl edit myjob.timer et vos modifications atterrissent dans /etc/systemd/system/myjob.timer.d/override.conf, où elles priment sur le fichier livré, survivent aux mises à jour et peuvent être supprimées en effaçant un fichier. Rechargez ensuite, activez le temporisateur et confirmez qu’il est bien armé avec systemctl list-timers, qui affiche la prochaine heure de déclenchement — le seul nombre qui vous dit si la conversion a produit le planning que vous vouliez.

Deux réglages méritent une décision délibérée plutôt qu’une valeur par défaut. Persistent=true est le bon choix pour les ordinateurs portables et de bureau qui dorment : si la machine était éteinte quand un déclenchement était dû, le service s’exécute une fois à la prochaine occasion au lieu que cette exécution n’ait jamais lieu en silence — notez qu’il s’agit d’un rattrapage unique, pas d’une répétition de chaque exécution manquée, et qu’il ne s’applique qu’aux temporisateurs OnCalendar. Et @reboot n’a pas de véritable équivalent en temporisateur : OnBootSec=, qui se déclenche un temps fixe après le démarrage, est l’analogue le plus proche, et ce n’est pas identique — il est relatif au démarrage et non « exécuter une fois au démarrage », et dans les conteneurs il est mappé sur OnStartupSec=. Si la tâche doit s’exécuter exactement une fois par démarrage, OnBootSec= est la réponse, mais documentez la différence dans l’unité ; ne prétendez pas que la conversion est exacte quand la page de manuel dit le contraire.

L’habitude d’auditer d’abord : convertissez, prouvez, exécutez en parallèle, puis basculez

La bascule la plus sûre est ennuyeuse à dessein. Convertissez, prouvez avec le tableau des 100 prochaines exécutions, puis — lorsque la tâche est idempotente — exécutez la ligne cron et le temporisateur en parallèle pendant une semaine et comparez les résultats : les journaux, les sorties, les effets secondaires. Une semaine couvre un cycle hebdomadaire complet et généralement un changement d’heure ou une fin de mois s’il y en a un à proximité, et chaque déclenchement prédit par le tableau de preuve apparaîtra dans le journal à côté de l’exécution cron qu’il duplique. Ce n’est que lorsque les deux concordent pendant une semaine complète que vous supprimez la ligne cron, et vous conservez la copie commentée dans l’unité comme indice de la section précédente.

Lorsque la tâche n’est pas idempotente — elle envoie du courrier, facture un client, modifie une base de données — n’exécutez pas les deux, car la duplication est le bug que vous essayez d’éviter. Prouvez plus rigoureusement à la place : exécutez le tableau de 100 exécutions en traversant un changement d’heure et une fin de mois, vérifiez à la main les premières lignes qui diffèrent et basculez en une seule étape, avec l’ancienne ligne commentée dans l’unité. Auditez ensuite l’unité terminée comme vous auditeriez n’importe quelle autre : notez-la avec l’auditeur d’unités systemd et lisez l’article compagnon Comment durcir les services systemd, car un temporisateur migré hérite des mêmes questions de sandbox que toute autre unité. Gardez le temporisateur, le service et la preuve sous contrôle de version — un planning qui ne vit que sur une seule machine est à une reconstruction d’être oublié.

Sources

Questions fréquentes

OnCalendar est-il simplement cron avec une autre syntaxe ?

Non — la syntaxe se recoupe, mais la sémantique diffère aux endroits qui comptent. Cron applique un OU entre le jour du mois et le jour de la semaine quand les deux sont restreints ; OnCalendar applique un ET. OnCalendar prend en charge les secondes, les plages de dates comme 01..07, les plages de jours de semaine, les fuseaux horaires et la syntaxe de dernier jour du mois avec « ~ » — rien de tout cela qu’une ligne cron à cinq champs ne peut exprimer. Il prend aussi en charge plusieurs lignes OnCalendar dans une unité et des temporisateurs monotones comme OnBootSec=. La plupart des plannings simples se traduisent proprement ; les cas pièges sont les combinaisons DOM+DOW, les secondes, @reboot et les plages de dates, et ce sont justement les cas que le convertisseur signale au lieu de deviner.

Que se passe-t-il pour un déclenchement de temporisateur dans le trou du passage à l’heure d’été ?

Les pages de manuel ne le disent pas. crontab(5) est explicite pour cron : une tâche prévue dans l’heure perdue ne s’exécute jamais, et une tâche prévue dans l’heure répétée s’exécute deux fois. systemd.time(7) et systemd.timer(5) n’énoncent aucune règle équivalente pour OnCalendar, donc ne présumez pas qu’un temporisateur se comporte comme cron à 02:30 le jour du passage de printemps. La vérification honnête, c’est le tableau de preuve : générez les 100 prochaines exécutions en traversant le changement d’heure dans le convertisseur et lisez ce qui se passe réellement. Si la tâche est sensible à l’heure, le choix le plus sûr est de la programmer entièrement en dehors de 02:00–03:00.

Puis-je exécuter cron et le temporisateur côte à côte pendant la migration ?

Oui, si la tâche est idempotente — sûre à exécuter deux fois avec le même résultat. Exécutez les deux pendant une semaine, comparez les journaux et les sorties, et ne supprimez la ligne cron que lorsque les deux concordent. Si la tâche n’est pas idempotente — elle envoie du courrier, prend un paiement ou modifie un état — n’exécutez pas les deux, car l’exécution dupliquée est elle-même l’échec. Dans ce cas, prouvez le planning avec le tableau de 100 exécutions, basculez en une seule étape et gardez l’ancienne ligne cron commentée dans l’unité pour que la conversion reste auditable.