Maîtriser les expressions Cron : L'analyseur Cron en ligne ultime

Qu'est-ce que Cron ? Retour aux sources

Cron est l'un des utilitaires les plus anciens et les plus durables de l'univers Unix. Il a été écrit par Ken Thompson dans le cadre d'Unix V7 (1979) aux laboratoires Bell. Le nom « cron » vient du mot grec chronos (χρόνος), qui signifie « temps ».

Le démon cron original se réveillait toutes les minutes, analysait une liste de tâches planifiées et exécutait celles dont l'heure était venue. Cette conception élégamment simple — une table d'expressions temporelles associées à des commandes — s'est révélée si efficace qu'elle est devenue le standard de facto pour la planification sur tous les systèmes Unix. Les distributions Linux modernes embarquent des descendants comme Vixie Cron (Paul Vixie, 1988), cronie et fcron, tandis que macOS utilise launchd en interne. L'influence de cron s'est également étendue aux frameworks applicatifs : Quartz Scheduler (Java), APScheduler (Python), node-cron (Node.js) et des plateformes cloud comme AWS EventBridge reprennent toutes sa syntaxe d'expressions.

Syntaxe Standard à 5 Champs

Une expression cron standard comporte cinq champs séparés par des espaces :

┌───────── minute         (0–59)
│ ┌─────── heure          (0–23)
│ │ ┌───── jour du mois   (1–31)
│ │ │ ┌─── mois           (1–12 ou JAN–DEC)
│ │ │ │ ┌─ jour de semaine (0–7 ou SUN–SAT ; 0 et 7 = dimanche)
│ │ │ │ │
* * * * *  commande

Description Détaillée de Chaque Champ

Champ	Valeurs autorisées	Description
Minute	0–59	La minute de l'heure à laquelle la tâche s'exécute
Heure	0–23	L'heure du jour (horloge 24 h)
Jour du mois	1–31	Le jour calendaire du mois
Mois	1–12 ou JAN–DEC	Le mois de l'année
Jour de semaine	0–7 ou SUN–SAT	Le jour de la semaine (0 et 7 = dimanche)

Important : Lorsque le jour du mois et le jour de semaine sont tous deux différents de *, cron utilise une logique OU : si l'une ou l'autre des conditions correspond, la tâche s'exécute. Cela surprend souvent les débutants.

Syntaxe Étendue à 6 Champs (avec Secondes)

Certains schedulers — notamment Quartz Scheduler (Java), Spring Framework et plusieurs plateformes cloud — ajoutent un champ secondes au début :

┌─────────── seconde      (0–59)
│ ┌───────── minute       (0–59)
│ │ ┌─────── heure        (0–23)
│ │ │ ┌───── jour du mois (1–31)
│ │ │ │ ┌─── mois         (1–12)
│ │ │ │ │ ┌─ jour semaine (1–7 dans Quartz ; 1=dimanche)
│ │ │ │ │ │
0 * * * * ?

Notez que Quartz numérote les jours de la semaine différemment (1=dimanche, 7=samedi), contrairement à Unix cron où 0 et 7 représentent tous deux le dimanche.

Caractères Spéciaux Expliqués

`*` — Toute Valeur

Correspond à toutes les valeurs possibles de ce champ. * * * * * s'exécute toutes les minutes.

`,` — Liste de Valeurs

Spécifie plusieurs valeurs discrètes. 0 9,12,18 * * * s'exécute tous les jours à 9h00, 12h00 et 18h00.

`-` — Plage

Spécifie une plage inclusive. 0 9-17 * * 1-5 s'exécute toutes les heures de 9h à 17h, du lundi au vendredi.

`/` — Valeurs de Pas

*/n signifie « toutes les n unités ». */15 * * * * s'exécute toutes les 15 minutes. Combinable avec des plages : 10-50/10 signifie 10, 20, 30, 40, 50.

`?` — Aucune Valeur Spécifique (Quartz/Spring uniquement)

Utilisé dans le champ jour du mois ou jour de semaine pour indiquer « peu importe ». Comme spécifier les deux champs est ambigu, l'un d'eux doit être ?.

`L` — Dernier (Quartz/Spring uniquement)

Dans le jour du mois : dernier jour du mois. Dans le jour de semaine : dernière occurrence de ce jour dans le mois. 0 0 L * ? s'exécute le dernier jour de chaque mois à minuit.

`W` — Jour Ouvrable le Plus Proche (Quartz/Spring uniquement)

15W dans le jour du mois désigne le jour ouvrable le plus proche du 15. Si le 15 est samedi, la tâche s'exécute le vendredi 14 ; si c'est dimanche, le lundi 16.

`#` — Nième Occurrence du Jour de Semaine (Quartz/Spring uniquement)

2#3 signifie le troisième mardi du mois. Format : <jour>#<occurrence>. 0 10 ? * 2#1 s'exécute le premier lundi de chaque mois à 10h00.

Alias de Temps Spéciaux

La plupart des implémentations cron supportent ces raccourcis pratiques :

Alias	Équivalent	Description
`@yearly`	`0 0 1 1 *`	Une fois par an, le 1er janvier à minuit
`@annually`	`0 0 1 1 *`	Identique à @yearly
`@monthly`	`0 0 1 * *`	Le premier jour de chaque mois à minuit
`@weekly`	`0 0 * * 0`	Chaque dimanche à minuit
`@daily`	`0 0 * * *`	Chaque jour à minuit
`@midnight`	`0 0 * * *`	Identique à @daily
`@hourly`	`0 * * * *`	Chaque heure à la minute 0
`@reboot`	—	Une fois au démarrage du système

Exemples Courants d'Expressions Cron

Expression	Signification
`* * * * *`	Chaque minute
`0 * * * *`	Chaque heure (à la minute 0)
`/15 * * *`	Toutes les 15 minutes
`0 0 * * *`	Chaque jour à minuit
`30 2 * * *`	Chaque jour à 2h30
`0 9-17 * * 1-5`	Chaque heure de 9h à 17h, jours ouvrables
`0 0 * * 0`	Chaque dimanche à minuit
`0 0 1 * *`	Le premier jour de chaque mois à minuit
`0 0 1 1 *`	Le 1er janvier à minuit (une fois par an)
`0 6 * * 1-5`	Les jours ouvrables à 6h00
`0 /6 * *`	Toutes les 6 heures

Utilisation de Crontab sous Linux

# Éditer votre crontab personnel
crontab -e

# Lister les entrées crontab actuelles
crontab -l

# Supprimer complètement votre crontab
crontab -r

# Éditer le crontab d'un autre utilisateur (root uniquement)
crontab -u nomutilisateur -e

Exemple de Fichier Crontab

# Variables d'environnement au début
SHELL=/bin/bash
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
[email protected]

# Sauvegarde chaque jour à 2h30
30 2 * * * /usr/local/bin/backup.sh

# Nettoyage chaque dimanche à minuit, avec journalisation
0 0 * * 0 /usr/local/bin/cleanup.sh >> /var/log/cleanup.log 2>&1

# Vérification de santé toutes les 15 minutes
*/15 * * * * /usr/local/bin/health-check.sh

# Cron sensible au fuseau horaire (extension GNU cron / cronie)
CRON_TZ=Europe/Paris
0 9 * * 1-5 /usr/local/bin/rapport-matinal.sh

Répertoires Cron au Niveau Système

/etc/crontab — crontab système avec un champ de nom d'utilisateur supplémentaire
/etc/cron.d/ — fichiers cron individuels pour les paquets et services
/etc/cron.daily/, /etc/cron.hourly/, /etc/cron.weekly/, /etc/cron.monthly/ — les scripts placés ici sont exécutés à ces intervalles via run-parts

Cron sous macOS et Windows

macOS : `launchd`

macOS a déprécié le démon cron au profit de launchd. Bien que cron fonctionne encore, Apple préfère les fichiers .plist dans ~/Library/LaunchAgents/ (tâches utilisateur) ou /Library/LaunchDaemons/ (tâches système). Beaucoup de développeurs utilisent toutefois encore cron pour sa simplicité.

Windows : Planificateur de Tâches

Windows utilise le Planificateur de tâches (schtasks) avec sa propre configuration XML. WSL (Sous-système Windows pour Linux) offre un environnement Linux complet avec cron natif.

Schedulers au Niveau Applicatif

Node.js — node-cron

const cron = require('node-cron');

// Planifier à 2h30 du matin avec fuseau horaire
cron.schedule('30 2 * * *', async () => {
  await executerSauvegardeQuotidienne();
}, {
  timezone: "Europe/Paris"
});

Python — APScheduler

from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.triggers.cron import CronTrigger

scheduler = BlockingScheduler()

@scheduler.scheduled_job(CronTrigger.from_crontab('0 9 * * 1-5'))
def tache_matinale():
    print("Bonjour ! C'est un jour ouvrable.")

scheduler.start()

Java — Quartz Scheduler

Quartz utilise des expressions à 6 champs (seconde, minute, heure, jour du mois, mois, jour de semaine) et supporte les caractères avancés (L, W, #, ?).

// Quartz : chaque jour ouvrable à 9h00
CronScheduleBuilder schedule = CronScheduleBuilder.cronSchedule("0 0 9 ? * MON-FRI");

Schedulers Cloud et Conteneurs

AWS EventBridge Scheduler

Supporte les expressions cron à 6 champs (UTC). L'un des champs jour du mois ou jour de semaine doit être ? :

cron(0 2 * * ? *)   # Chaque jour à 2h UTC

Google Cloud Scheduler

Utilise la syntaxe Unix standard à 5 champs avec support des fuseaux horaires.

Kubernetes CronJob

apiVersion: batch/v1
kind: CronJob
metadata:
  name: sauvegarde-quotidienne
spec:
  schedule: "0 2 * * *"
  concurrencyPolicy: Forbid
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: backup
            image: backup-image:latest
          restartPolicy: OnFailure

concurrencyPolicy: Forbid empêche les exécutions simultanées si une tâche dure plus longtemps que son intervalle.

Gestion des Fuseaux Horaires

Cron s'exécute dans le fuseau horaire du système, qui est souvent UTC sur les serveurs. Une tâche planifiée à 0 9 * * * sur un serveur UTC s'exécutera à 9h UTC, soit 10h (heure de Paris en hiver) ou 11h (en été).

Bonnes pratiques pour les fuseaux horaires :

Utiliser CRON_TZ=Europe/Paris dans le crontab pour spécifier explicitement le fuseau
Exploiter les champs de fuseau horaire dans les plateformes cloud (GCP Cloud Scheduler, Kubernetes spec.timeZone)
Préférer des heures UTC fixes pour éviter les problèmes liés aux changements d'heure (DST) : 0 2 * * * peut s'exécuter deux fois ou pas du tout lors des transitions DST
Toujours documenter dans les commentaires quel fuseau correspond à chaque expression cron

Considérations de Sécurité

Les tâches cron s'exécutent souvent avec des privilèges élevés et constituent une surface d'attaque courante.

Principe du moindre privilège : Exécuter sous l'utilisateur ayant les droits minimaux nécessaires, en évitant root.

Pas d'identifiants dans le code : Ne jamais inclure de mots de passe, clés API ou jetons directement dans les entrées crontab ou les scripts. Utiliser des fichiers de variables d'environnement à permissions restreintes (chmod 600) ou des gestionnaires de secrets.

Permissions des scripts : S'assurer que les scripts cron ne sont pas modifiables par d'autres utilisateurs.

chmod 750 /usr/local/bin/backup.sh
chown root:staff /usr/local/bin/backup.sh

Surveillance et alertes : Utiliser MAILTO= pour recevoir les erreurs par e-mail ; des services comme Healthchecks.io ou Cronitor alertent lorsqu'une tâche ne s'exécute pas comme prévu.

Bonnes Pratiques

Concevoir des tâches idempotentes : Une tâche qui peut être exécutée plusieurs fois avec le même résultat facilite la reprise après incident.

Verrouillage de fichier contre les exécutions simultanées : Utiliser flock pour les tâches longues :

*/5 * * * * flock -n /var/lock/myjob.lock /usr/local/bin/myjob.sh

Rediriger la sortie explicitement :

0 3 * * * /usr/local/bin/backup.sh >> /var/log/backup.log 2>&1

Vérifier les expressions avant le déploiement : Utiliser l'outil Cron Parser pour confirmer exactement quand une expression se déclenche.

Versionner les crontabs : Gérer les fichiers crontab dans Git et les déployer avec Ansible ou Puppet pour éviter la « dérive de configuration ».

Foire Aux Questions (FAQ)

Q : Pourquoi ma tâche cron ne s'exécute-t-elle pas ?
Les causes les plus courantes : (1) permissions d'exécution manquantes sur le script, (2) le script dépend de variables d'environnement absentes dans l'environnement minimal de cron, (3) problèmes de PATH — cron ne charge pas la configuration du shell, utiliser des chemins absolus, (4) le démon cron ne tourne pas (systemctl status cron).

Q : Quelle est la différence entre */5 et 0/5 ?
Dans cron Unix standard, */5 signifie toutes les 5 minutes à partir de 0 (0, 5, 10, ..., 55). 0/5 n'est pas une syntaxe Unix cron standard, mais est utilisée dans Quartz/AWS avec la même signification.

Q : Cron peut-il exécuter une tâche chaque seconde ?
La granularité minimale de cron standard est d'une minute. Pour une planification sub-minute, utiliser des schedulers applicatifs comme Quartz, APScheduler avec des déclencheurs d'intervalle, ou les timers systemd.

Q : Comment exécuter une tâche le dernier jour du mois ?
Cron standard n'a pas d'opérateur natif pour « dernier jour ». La solution courante : tester si le lendemain est le 1er. Dans Quartz cron, utiliser L dans le champ jour du mois.

Q : Quelle est la différence entre 0 0 * * 0 et @weekly ?
Ils sont équivalents : les deux s'exécutent à minuit le dimanche. @weekly est un alias mnémotechnique défini dans la plupart des implémentations cron modernes.

Q : Comment déboguer un script qui fonctionne dans le terminal mais échoue dans cron ?
Cron s'exécute avec un environnement minimal (généralement HOME, LOGNAME, PATH=/usr/bin:/bin, SHELL=/bin/sh). Ajouter #!/bin/bash et set -e au script, utiliser des chemins absolus pour toutes les commandes, rediriger stdout/stderr vers un fichier de log.

Résumé

Cron fait tourner l'automatisation Unix depuis 1979 et reste le mécanisme de planification le plus utilisé aujourd'hui. Que vous gériez un seul serveur Linux, orchestriez des charges de travail Kubernetes ou configuriez des déclencheurs d'événements cloud, une compréhension approfondie de la syntaxe cron vous épargnera des heures de débogage et préviendra de coûteuses erreurs de planification.

Points clés :

La syntaxe standard à 5 champs couvre la grande majorité des cas d'usage
Utiliser / pour les pas, , pour les listes, - pour les plages
Toujours considérer le fuseau horaire — préférer UTC sur les serveurs ou spécifier CRON_TZ explicitement
Appliquer les principes de sécurité : moindre privilège, pas d'identifiants dans le code, surveillance
Vérifier les expressions avec un outil de parsing avant de les déployer en production

Aperçu

Les tâches cron sont au cœur de l'automatisation moderne, mais leur syntaxe peut être intimidante, même pour les administrateurs système chevronnés. Notre analyseur cron en ligne est conçu pour éliminer les incertitudes de la planification. En traduisant des expressions cron cryptiques en un langage clair et lisible par l'homme, cet outil garantit que vos tâches planifiées s'exécutent exactement au moment prévu. Que vous gériez des sauvegardes, des scripts de nettoyage ou des e-mails automatisés, la précision est primordiale.

Caractéristiques principales

Traduction en temps réel : Visualisez instantanément la signification de votre expression cron en français simple.
Prochaines exécutions : Affichez une liste des 5 prochaines exécutions planifiées ou plus pour vérifier votre logique.
Prise en charge de tous les champs : Gère les formats cron standard, y compris les variations à 6 champs (secondes) et 7 champs (années).
Coloration syntaxique : Des repères visuels vous aident à identifier les minutes, les heures, les jours, les mois et les semaines.

Comment l'utiliser

Saisie : Collez ou tapez votre expression cron dans le champ principal.
Observation : La traduction lisible par l'homme se met à jour automatiquement au fur et à mesure que vous tapez.
Vérification : Consultez la liste des "Prochaines exécutions" pour vous assurer qu'elle correspond à vos besoins.
Copier : Utilisez les exemples fournis si vous partez de zéro.

Cas d'utilisation courants

Maintenance du serveur : Planification de sauvegardes nocturnes de bases de données ou de rotations de journaux.
Développement Web : Configuration de tâches d'arrière-plan récurrentes dans des frameworks comme Laravel ou Django.
DevOps : Configuration de pipelines CI/CD et de vérifications de santé automatisées.
Productivité personnelle : Gestion de rappels récurrents ou d'exécutions de scripts sur des machines locales.

Contexte technique

Les expressions cron se composent de 5 à 7 champs séparés par des espaces. Chaque champ représente une unité de temps : minute, heure, jour du mois, mois et jour de la semaine. Notre analyseur utilise un moteur logique robuste qui gère les caractères spéciaux tels que * (tout), , (liste), - (plage), / (incrément) et L (dernier). Il calcule avec précision les prochaines occurrences en tenant compte des années bissextiles et de la durée des mois.

Foire aux questions

Prend-il en charge les secondes ? Oui, il prend en charge les expressions cron à 6 champs incluant les secondes.
Peut-il gérer des alias non standard comme @daily ? Oui, les alias courants sont pris en charge.
Tient-il compte du fuseau horaire ? Par défaut, les calculs sont basés sur l'heure UTC, mais vous pouvez ajuster votre perspective en conséquence.

Limites

Variations d'implémentation : Différents systèmes (par exemple, Quartz, AWS, Jenkins) présentent de légères variations dans la syntaxe cron ; vérifiez toujours avec votre plateforme spécifique.
Cas particuliers : Le "dernier jour du mois" (L) et le "jour ouvrable le plus proche" (W) peuvent se comporter différemment selon le système d'exploitation.