⚙️ Crontab (Linux) – Planification de Tâches

cron est un gestionnaire de tâches (Job Scheduler) standard sur les systèmes Unix/Linux. C'est l'un des outils d'automatisation les plus anciens et les plus fiables.

Le nom "cron" vient du grec "chronos" (χρόνος), qui signifie "temps".

Le Daemon crond

Le "vrai" cron est un daemon (un service/processus d'arrière-plan) appelé crond.

Son travail est très simple :

1. Démarrer au boot du système (géré par systemd ou init).
2. Se "réveiller" (Tick) toutes les 60 secondes (à :00).
3. Lire ses fichiers de configuration (les "Crontabs", voir 1.2).
4. Vérifier si l'heure/date actuelle correspond à une règle.
5. Si oui, exécuter la commande associée.
6. Se "rendormir" (Sleep) pendant 59 secondes.

crontab (abréviation de "cron table") est le fichier texte qui contient la liste des tâches (jobs) à exécuter.

Il ne faut pas éditer ce fichier directement. On utilise toujours la commande crontab -e (voir 4.1) pour l'éditer.

Niveaux de Crontab

Il existe deux "types" de crontabs (qui co-existent) :

• 1. Crontab Utilisateur (User Crontab) :
  • Chaque utilisateur (root, www-data, bob) peut avoir son propre crontab.
  • Géré via crontab -e.
  • Fichiers stockés dans /var/spool/cron/crontabs/.
  • S'exécute avec les permissions de cet utilisateur.
• 2. Crontab Système (System Crontab) :
  • Un fichier "global" (/etc/crontab).
  • Des fichiers "drop-in" (/etc/cron.d/).
  • (Voir 6.2 et 6.3).

Une ligne crontab (utilisateur) est composée de 6 champs (5 pour le temps, 1 pour la commande).

.---------------- Minute (m)
|  .------------- Heure (h)
|  |  .---------- Jour du Mois (dom - Day of Month)
|  |  |  .------- Mois (mon - Month)
|  |  |  |  .---- Jour de la Semaine (dow - Day of Week)
|  |  |  |  |
* * * * * /chemin/vers/la/commande

L'astérisque * est un "wildcard" (joker) qui signifie "chaque" ou "tous".

Exemples (*)

# (m h dom mon dow)

# 1. Toutes les minutes de chaque jour
# (Le "Tick" de cron)
* * * * * /path/to/script.sh

# 2. À 2h00 du matin, tous les jours
# (Minute=0, Heure=2, Reste=*)
0 2 * * * /path/to/backup.sh

# 3. Tous les Dimanches, à 4h05 du matin
# (Minute=5, Heure=4, JourS=0)
5 4 * * 0 /path/to/weekly_report.sh
# (Note: 0 ou 7 = Dimanche)

L'opérateur */n (step value) permet de définir une récurrence (ex: "toutes les N minutes").

Exemples (*/n)

# (m h dom mon dow)
 
# 1. Toutes les 15 minutes
# (équivaut à 0,15,30,45)
*/15 * * * * /path/to/script.sh

# 2. Toutes les 2 heures
# (à 0h, 2h, 4h, 6h...)
0 */2 * * * /path/to/script.sh

# 3. Tous les 10 jours (1er, 11e, 21e)
0 0 */10 * * /path/to/script.sh

Combiner (Intervalle + Pas)

# Toutes les 5 minutes,
# uniquement pendant les heures de bureau (9h-17h)
*/5 9-17 * * 1-5 /path/to/script.sh

Le 6ème champ (et tout ce qui suit) est la commande shell (sh) à exécuter.

Chemins Absolus (Bonne Pratique)

Le cron s'exécute avec un $PATH minimal (voir 5.1). Ne jamais supposer que php ou python est dans le path.

# MAUVAIS (Risqué)
* * * * * php mon_script.php

# BON (Robuste)
* * * * * /usr/bin/php /home/user/web/mon_script.php

# BON (Script Shell)
* * * * * /home/user/scripts/mon_script.sh

Caractère % (Le Piège)

Attention : Le caractère % a une signification spéciale dans cron (c'est un "saut de ligne", tout ce qui suit est passé au stdin).

Si vous utilisez des commandes (comme date) qui utilisent %, vous devez l'échapper (\).

# MAUVAIS (Cassé)
* * * * * echo "Date: $(date +%Y-%m-%d)"

# BON (Échappé)
* * * * * echo "Date: $(date +\%Y-\%m-\%d)"

crontab -e (Edit) est la seule commande que vous devriez utiliser pour modifier votre crontab (utilisateur).

Fonctionnement

1. crontab -e ouvre un éditeur de texte temporaire (défini par la variable $EDITOR, ex: nano, vim) avec le contenu actuel de votre crontab.
2. Vous modifiez le fichier temporaire.
3. Vous sauvegardez et quittez l'éditeur.
4. crontab valide la syntaxe du fichier temporaire.
5. Si la syntaxe est valide, il installe le fichier dans /var/spool/cron/ (le "vrai" emplacement).
6. Si la syntaxe est invalide (ex: "*/100 * * * *"), il refuse l'installation et vous propose de re-modifier.

# Éditer le crontab de l'utilisateur actuel
$ crontab -e

# Éditer le crontab d'un *autre* utilisateur (en tant que root)
$ sudo crontab -e -u www-data

crontab -r (Remove) supprime (efface) l'intégralité du fichier crontab de l'utilisateur.

DANGER : crontab -r ne demande AUCUNE CONFIRMATION.

Les touches e et r sont voisines sur un clavier QWERTY. Il est très (très) fréquent pour les administrateurs (fatigués) de taper crontab -r en pensant taper crontab -e, et d'effacer instantanément 100 lignes de tâches planifiées.

Bonne Pratique (Alias de Sécurité)

Pour éviter cela, beaucoup d'admins ajoutent un "alias" de sécurité dans leur .bashrc / .zshrc :

# (Ajouter ceci à ~/.bashrc)
# (Demande une confirmation (interactive) avant de 'remove')
alias crontab='crontab -i'

(L'option -i (interactive) demande une confirmation "yes/no" avant -r).

C'est le piège n°1 du dépannage cron. ("Le script marche quand je le lance à la main, mais échoue dans cron !").

Le Problème

Votre shell (Bash/Zsh) (via .bashrc) a un $PATH riche :
/usr/local/bin:/usr/bin:/bin:/home/user/bin

Le daemon crond s'exécute avec un $PATH minimaliste (défini par pam_env) :
/usr/bin:/bin

Exemple (Échec)

# (Le script '/usr/local/bin/mon_script_node'
#  a été installé via 'npm install -g')
* * * * * mon_script_node

# (Résultat : Échec. Cron ne trouve pas 'mon_script_node'
#  dans /usr/bin ou /bin)

Solutions (Par ordre de préférence)

1. (Meilleur) Chemins Absolus (dans le cron) :
   * * * * * /usr/local/bin/mon_script_node
2. (OK) Chemins Absolus (dans le script) :
   (Si mon_script.sh appelle node -> utiliser /usr/local/bin/node).
3. (OK) Définir le PATH (en haut du crontab) :
   

   PATH=/usr/bin:/bin:/usr/local/bin
   * * * * * mon_script_node

Par défaut, cron capture tout ce qui est écrit sur stdout (sortie standard) et stderr (sortie d'erreur), et essaie de l'envoyer par email (voir 5.3) à l'utilisateur.

C'est souvent indésirable (spam, ou le service mail n'est pas configuré).

Contrôler la Sortie (Redirection Shell)

Scénario 1 : Silence Total (Le "Trou Noir")

Utilisé en production (si on est sûr que ça marche) pour éviter tout log/email.

# (Redirige stdout (1) vers /dev/null)
# (Redirige stderr (2) vers la même destination (1))
* * * * * /path/to/script.sh > /dev/null 2>&1

Scénario 2 : Logger dans un Fichier (Recommandé)

Rediriger stdout et stderr dans un fichier de log (avec rotation, ex: logrotate).

# 1. Envoyer stdout et stderr au même fichier (Append)
* * * * * /path/to/script.sh >> /var/log/mon_script.log 2>&1

# 2. Séparer stdout et stderr
* * * * * /path/to/script.sh >> /var/log/mon_script.log 2>> /var/log/mon_script.err

MAILTO est une variable d'environnement spéciale, définie en haut du fichier crontab.

Scénario 1 : Désactiver tous les Emails (Recommandé)

Si MAILTO est vide (""), aucun email ne sera envoyé, même si les commandes (stdout/stderr) produisent une sortie.

MAILTO=""
# (Toutes les sorties de tous les jobs
#  ci-dessous sont envoyées à /dev/null)
* * * * * /path/to/script.sh

Scénario 2 : Centraliser les Emails

Envoyer toutes les sorties (erreurs, logs) à une adresse spécifique (ex: un admin) plutôt qu'à l'utilisateur local (ex: www-data).

MAILTO="admin@ideolab.com"
# (Toute sortie (stdout/stderr) de ce job
#  sera envoyée à admin@ideolab.com)
*/15 * * * * /path/to/check.sh

C'est la méthode "standard" pour un utilisateur (ou un service, ex: www-data) pour gérer ses propres tâches.

• Commande : crontab -e (ou sudo crontab -e -u www-data)
• Emplacement (Debian/Ubuntu) : /var/spool/cron/crontabs/[nom_utilisateur]
• Format : Standard (5 champs + commande).
• Permissions : S'exécute avec les permissions de l'utilisateur (ex: www-data).

C'est le fichier de configuration "maître" du système. Il ne doit pas être édité avec crontab -e, mais avec nano /etc/crontab.

Différence : Le 6ème Champ (Utilisateur)

Les crontabs système (/etc/crontab et /etc/cron.d/) ont un champ supplémentaire (obligatoire) entre le "Temps" et la "Commande" : l'Utilisateur (User) qui doit exécuter la tâche.

# (m h dom mon dow) [USER]  [COMMAND]

# Syntaxe /etc/crontab (Notez 'root')
17 * * * * root    cd / && run-parts --report /etc/cron.hourly
25 6  * * * root    test -x /usr/sbin/anacron || ...

C'est la meilleure pratique (moderne) pour les applications (paquets) qui doivent ajouter des tâches système.

Au lieu de modifier le /etc/crontab (risqué), un paquet (ex: certbot) "droppe" (dépose) son propre fichier de configuration dans /etc/cron.d/.

crond lit /etc/crontab ET tous les fichiers dans /etc/cron.d/.

Exemple (/etc/cron.d/certbot)

# (Fichier installé par 'apt install certbot')
# (Syntaxe identique à /etc/crontab (avec "user"))
SHELL=/bin/sh
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

0 */12 * * * root test -x /usr/bin/certbot -a \! -d /run/systemd/system && perl ...

Ce sont de simples dossiers (/etc/cron.daily, /etc/cron.weekly...). Ils ne sont pas un mécanisme cron magique.

Fonctionnement (run-parts)

Ils sont gérés (déclenchés) par /etc/crontab (ou anacron) via la commande run-parts.

Regardez /etc/crontab :

# (Extrait de /etc/crontab)
# (À 6h25, tous les jours, 'root' exécute 'run-parts'
#  sur le dossier 'cron.daily')
25 6  * * * root    test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.daily )

Usage : Pour ajouter un script "daily" (ex: logrotate, backup), il suffit de le copier (en chmod +x) dans /etc/cron.daily/. (Simple, mais pas de contrôle sur l'heure exacte (ce sera 6h25)).

Problème : cron (le daemon) est "stupide". Si le PC est éteint à 6h25 (l'heure de cron.daily), les tâches (backups, updates) sont manquées (skipped) et ne s'exécuteront que le lendemain à 6h25.

Solution (anacron)

anacron (Anachronistic Cron) est un "complément" à cron, conçu pour les machines non-24/7 (Desktops, Laptops).

Fonctionnement (/etc/anacrontab) :

1. anacron est lancé au démarrage (boot) (ou via cron.hourly).
2. Il vérifie un "timestamp" (tampon) : "Quand ai-je exécuté cron.daily la dernière fois ?".
3. (Ex: "Il y a 30 heures").
4. Si le temps est > 1 jour, il exécute immédiatement les tâches cron.daily (rattrapage).

(Sur les systèmes Desktop (Ubuntu), anacron gère cron.daily/weekly/monthly, et /etc/crontab est (presque) vide).

# Syntaxe : m h dom mon dow commande
# (m=Minute, h=Heure, dom=JourMois, mon=Mois, dow=JourSemaine)

# --- Exemples de Temps ---

# Toutes les minutes
* * * * * ...

# Toutes les 5 minutes
*/5 * * * * ...

# Toutes les 15 minutes (alternative)
0,15,30,45 * * * * ...

# Toutes les heures, à la 30e minute (ex: 10:30, 11:30)
30 * * * * ...

# Tous les jours à 2h00 du matin
0 2 * * * ...

# Tous les jours à 5h30
30 5 * * * ...

# Tous les Lundis à 4h00 du matin
0 4 * * 1 ... (1 = Lundi, 0/7 = Dimanche)

# Tous les 1er du mois à 00h00
0 0 1 * * ...

# Pendant les heures de bureau (8h-17h),
# les jours de semaine (Lun-Ven)
* 8-17 * * 1-5 ...

# --- Chaînes Spéciales ---
@reboot     /path/to/script.sh
@hourly     /path/to/script.sh
@daily      /path/to/script.sh
@weekly     /path/to/script.sh
@monthly    /path/to/script.sh

# --- Logs & Commandes ---
MAILTO="" # (Désactive les emails)
PATH=/usr/bin:/bin:/usr/local/bin # (Définit un PATH)

# Exécuter un script (silencieux)
* * * * * /usr/bin/php /var/www/cron.php > /dev/null 2>&1

# Exécuter un script (avec logs)
* * * * * /path/to/backup.sh >> /var/log/backup.log 2>&1

# /etc/crontab (Syntaxe Système - avec "user")
* * * * * root /path/to/script_root.sh
* * * * * www-data /path/to/script_www.sh