Programmer des tâches sous UNIX : cron, at, sleep
Une sauvegarde chaque nuit, un rapport tous les lundis, un nettoyage de fichiers temporaires toutes les heures : dès qu’une tâche doit se répéter, il faut cesser de la lancer à la main. Sous Unix et Linux, cron s’en charge depuis quarante ans, at traite les exécutions uniques, et sleep règle les temporisations à l’intérieur d’un script.
Ce guide couvre la syntaxe des cinq champs de cron, les erreurs qui font qu’une tâche ne part jamais — et elles sont toujours les mêmes —, la gestion des sorties et des erreurs, les alternatives modernes avec systemd, et les précautions qui évitent qu’un script se lance deux fois en parallèle.
La table cron
Chaque utilisateur dispose de sa propre table, éditée par une commande dédiée :
crontab -e
crontab -l
crontab -r
Un avertissement sur la dernière : crontab -r supprime la table sans demander confirmation. La proximité de -e et -r sur un clavier a fait perdre plus d’une configuration. Prenez l’habitude de sauvegarder avant toute modification :
crontab -l > ~/crontab-$(date +%Y%m%d).sauvegarde
Pour intervenir sur la table d’un autre utilisateur, en root :
crontab -u www-data -l
Les cinq champs
Une ligne de cron commence par cinq champs temporels, suivis de la commande.
┌─ minute (0-59)
│ ┌─ heure (0-23)
│ │ ┌─ jour (1-31)
│ │ │ ┌─ mois (1-12)
│ │ │ │ ┌─ jour de semaine (0-7, 0 et 7 = dimanche)
│ │ │ │ │
* * * * * commande à exécuter
Quatre symboles suffisent à tout exprimer :
*: toutes les valeurs ;,: une liste —1,15,30;-: un intervalle —9-17;/: un pas —*/15pour toutes les quinze minutes.
Quelques exemples lus à voix haute :
0 3 * * * # tous les jours à 3 h 00
*/15 * * * * # toutes les 15 minutes
0 */2 * * * # toutes les 2 heures, à l'heure pile
30 2 * * 1 # tous les lundis à 2 h 30
0 9-17 * * 1-5 # toutes les heures de 9 h à 17 h, du lundi au vendredi
0 0 1 * * # le 1er de chaque mois à minuit
15 4 1,15 * * # les 1er et 15 du mois à 4 h 15
Un piège rare mais déroutant : quand les champs jour du mois et jour de semaine sont tous deux renseignés, cron applique un OU et non un ET. La ligne 0 0 13 * 5 s’exécute le 13 de chaque mois et tous les vendredis, pas seulement les vendredis 13.
Des raccourcis existent pour les cas courants :
@daily /chemin/script.sh
@weekly /chemin/script.sh
@monthly /chemin/script.sh
@reboot /chemin/script.sh
Pourquoi ma tâche ne part pas
C’est la question la plus fréquente, et la réponse est presque toujours l’une de ces quatre.
Le PATH. Cron s’exécute avec un environnement minimal — en général /usr/bin:/bin seulement. Une commande qui marche dans votre terminal peut être introuvable dans cron. La parade est d’écrire des chemins absolus partout :
0 3 * * * /usr/bin/php /home/user/script.php
Un which php donne le chemin à écrire. On peut aussi définir le PATH en tête de table :
PATH=/usr/local/bin:/usr/bin:/bin
Le répertoire courant. Cron démarre dans le répertoire personnel de l’utilisateur, pas là où se trouve le script. Tout chemin relatif dans le script échouera. Ajoutez un cd explicite :
0 3 * * * cd /var/www/site && /usr/bin/php artisan traitement
Les droits. Le script doit être exécutable, et l’utilisateur de la tâche doit pouvoir lire et écrire ce qu’il manipule :
chmod +x /home/user/script.sh
Notre article sur les droits et permissions détaille ce point, qui est la deuxième cause d’échec silencieux.
Le pourcentage. Dans une table cron, le caractère % est interprété comme un retour à la ligne. Une commande contenant date +%Y%m%d est tronquée sans avertissement. Il faut l’échapper :
0 3 * * * /usr/bin/tar -czf /sauvegardes/site-$(date +\%Y\%m\%d).tar.gz /var/www/
Cette seule subtilité explique une part notable des tâches qui « ne marchent pas ».
Récupérer les sorties
Par défaut, cron envoie par courriel tout ce que la tâche écrit sur la sortie standard ou d’erreur. Sur un serveur sans messagerie configurée, ce courriel se perd — et avec lui, le message d’erreur.
La bonne pratique consiste à rediriger explicitement les deux flux vers un fichier :
0 3 * * * /home/user/script.sh >> /var/log/script.log 2>&1
Le 2>&1 est la partie qui compte : sans lui, seule la sortie normale est capturée et les erreurs disparaissent. C’est l’oubli le plus coûteux, car il transforme un échec visible en échec silencieux.
Pour une tâche bavarde dont seules les erreurs intéressent :
0 3 * * * /home/user/script.sh > /dev/null
La sortie normale part à la poubelle, les erreurs restent et déclenchent le courriel. À l’inverse, > /dev/null 2>&1 supprime tout — à n’employer que sur une tâche dont on a déjà vérifié le bon fonctionnement, sous peine de ne jamais savoir qu’elle a cessé de marcher.
Un journal qui grossit indéfiniment finit par poser problème. Deux solutions : la rotation par logrotate, ou une redirection simple avec > qui écrase à chaque exécution.
Éviter les exécutions qui se chevauchent
Une tâche planifiée toutes les cinq minutes et qui en met sept produit rapidement plusieurs instances en parallèle — puis une machine saturée. flock règle le problème en une option :
*/5 * * * * /usr/bin/flock -n /tmp/tache.lock /home/user/script.sh
L’option -n fait abandonner immédiatement si le verrou est déjà pris. Sans elle, les exécutions s’empilent en attendant leur tour, ce qui ne vaut guère mieux.
C’est une précaution à prendre systématiquement sur toute tâche fréquente dont la durée n’est pas garantie.
Où vivent les tâches
Outre les tables personnelles, plusieurs emplacements système existent :
/etc/crontab: table système, avec un champ supplémentaire pour l’utilisateur ;/etc/cron.d/: fichiers de tâches, un par application — l’emplacement recommandé pour ajouter une tâche système ;/etc/cron.daily/,cron.hourly/,cron.weekly/: scripts exécutés à la fréquence indiquée, sans horaire précis.
La syntaxe de /etc/crontab et de /etc/cron.d/ comporte six champs, l’utilisateur s’intercalant avant la commande :
0 3 * * * root /usr/local/bin/sauvegarde.sh
Oublier ce champ est une erreur fréquente lors du passage d’une table personnelle à un fichier système.
Pour vérifier qu’une tâche s’est bien lancée :
grep CRON /var/log/syslog | tail -20
journalctl -u cron --since "1 hour ago"
at : une seule fois
Quand l’exécution ne doit avoir lieu qu’une fois, at est plus adapté que cron.
at 23:00
at now + 2 hours
at 09:00 tomorrow
at 14:30 15.10.2026
La commande ouvre une saisie ; on tape les commandes puis Ctrl+D pour valider. En une ligne :
echo "/home/user/migration.sh" | at 02:00
La gestion de la file :
atq
atrm 3
at -c 3
at n’est pas installé par défaut sur toutes les distributions, et son service doit tourner. Un systemctl status atd le confirme avant de s’étonner qu’une tâche ne parte pas.
L’usage typique est l’opération de maintenance différée : redémarrer un service à deux heures du matin, appliquer une bascule DNS en pleine nuit, lancer une migration hors des heures ouvrées.
sleep : temporiser dans un script
sleep ne planifie rien : il suspend l’exécution pendant une durée donnée.
sleep 30
sleep 5m
sleep 2h
Son usage le plus courant est l’attente entre deux tentatives :
for i in 1 2 3 4 5; do
if curl -sf https://exemple.fr/sante > /dev/null; then
echo "service disponible"
break
fi
echo "tentative $i échouée, nouvel essai dans 10 s"
sleep 10
done
Il sert aussi à étaler des tâches identiques planifiées à la même minute sur plusieurs machines, pour ne pas solliciter un service central simultanément :
0 3 * * * sleep $((RANDOM \% 300)) && /home/user/script.sh
Notez l’échappement du %, indispensable dans une table cron.
Une chose que sleep ne doit pas faire : remplacer cron. Une boucle infinie avec sleep 3600 pour simuler une tâche horaire ne survit ni au redémarrage, ni à une erreur, ni à la fermeture de la session.
L’alternative systemd
Sur les systèmes récents, les timers systemd offrent une alternative à cron, avec des avantages réels : journalisation intégrée, rattrapage des exécutions manquées quand la machine était éteinte, dépendances entre unités, et une syntaxe de dates plus lisible.
systemctl list-timers
systemctl status sauvegarde.timer
Ils demandent en revanche deux fichiers — un service et un timer — là où cron se contente d’une ligne. Pour une tâche simple, cron reste plus rapide à mettre en place et se retrouve sur n’importe quel système. Pour une tâche critique dont il faut suivre les exécutions, le timer systemd est mieux outillé.
Une tâche bien écrite
Un exemple qui réunit les précautions vues plus haut :
PATH=/usr/local/bin:/usr/bin:/bin
MAILTO=""
# Sauvegarde du site, chaque nuit à 3 h 15
15 3 * * * /usr/bin/flock -n /tmp/sauvegarde.lock /home/user/sauvegarde.sh >> /var/log/sauvegarde.log 2>&1
# Nettoyage des fichiers temporaires de plus de 7 jours, chaque dimanche
0 4 * * 0 /usr/bin/find /tmp/travail -type f -mtime +7 -delete >> /var/log/nettoyage.log 2>&1
Chemins absolus, verrou contre le chevauchement, deux flux redirigés, commentaire expliquant l’intention. La seconde ligne s’appuie sur la commande find pour la sélection par ancienneté.
En résumé
- cinq champs : minute, heure, jour, mois, jour de semaine — et un OU, non un ET, quand jour et jour de semaine sont tous deux précisés ;
- chemins absolus partout : cron n’a pas votre PATH ;
- ajouter un
cdexplicite, cron démarre dans le répertoire personnel ; - échapper les
%, sans quoi la commande est tronquée sans avertissement ; >> journal 2>&1: sans le2>&1, les erreurs disparaissent ;flock -nsur toute tâche fréquente, pour éviter les exécutions parallèles ;crontab -rsupprime tout sans confirmation — sauvegarder avant d’éditer ;atpour une exécution unique,sleeppour temporiser dans un script, jamais pour planifier ;- les timers systemd quand il faut du suivi et du rattrapage.