Crontab : Planification de tâches automatiques sous Linux

Prérequis

• Système d'exploitation : Distribution Linux (Debian, Ubuntu, CentOS, Rocky Linux, etc.)
• Privilèges : Accès utilisateur standard pour les tâches personnelles, accès root ou sudo pour les tâches système
• Connaissances : Bases du terminal Linux et de l'édition de fichiers en ligne de commande
• Paquets : Le paquet cron est généralement installé par défaut sur la plupart des distributions

Vérifiez que le service cron est bien installé et actif :

sudo systemctl status cron

Si cron n'est pas installé :

# Debian / Ubuntu
sudo apt update && sudo apt install -y cron

# CentOS / Rocky Linux
sudo dnf install -y cronie

# Activer et démarrer le service
sudo systemctl enable cron
sudo systemctl start cron

Comprendre Cron

Le démon cron

Cron est un démon (service en arrière-plan) qui se lance au démarrage du système. Chaque minute, il vérifie s'il existe des tâches planifiées à exécuter pour l'instant courant. S'il en trouve, il les exécute avec les permissions de l'utilisateur propriétaire de la tâche.

Le démon cron consulte plusieurs sources pour déterminer les tâches à exécuter :

• Crontabs utilisateur : stockés dans /var/spool/cron/crontabs/ (un fichier par utilisateur)
• Crontab système : le fichier /etc/crontab (contient un champ utilisateur supplémentaire)
• Répertoire cron.d : les fichiers dans /etc/cron.d/ (format identique à /etc/crontab)

Crontab utilisateur vs /etc/crontab

Il existe une différence importante entre le crontab d'un utilisateur et le fichier /etc/crontab système :

# Crontab utilisateur (crontab -e) — PAS de champ utilisateur
# minute  heure  jour  mois  jour_semaine  commande
0 2 * * * /home/user/backup.sh

# /etc/crontab système — AVEC champ utilisateur
# minute  heure  jour  mois  jour_semaine  utilisateur  commande
0 2 * * * root /usr/local/bin/backup-system.sh

Syntaxe Crontab

Les 5 champs temporels

Chaque ligne d'un crontab suit le format suivant avec 5 champs de planification :

┌───────────── minute (0 - 59)
│ ┌───────────── heure (0 - 23)
│ │ ┌───────────── jour du mois (1 - 31)
│ │ │ ┌───────────── mois (1 - 12)
│ │ │ │ ┌───────────── jour de la semaine (0 - 7, 0 et 7 = dimanche)
│ │ │ │ │
* * * * * commande_a_executer

Caractères spéciaux

Les caractères spéciaux permettent de définir des planifications flexibles :

• * (astérisque) : correspond à toutes les valeurs possibles du champ
• , (virgule) : sépare une liste de valeurs — ex : 1,15 (le 1er et le 15)
• - (tiret) : définit une plage de valeurs — ex : 1-5 (lundi à vendredi)
• / (barre oblique) : définit un intervalle — ex : */10 (toutes les 10 unités)

Raccourcis prédéfinis

Cron propose des raccourcis pratiques pour les planifications courantes :

@reboot     # Exécuter une fois au démarrage du système
@yearly     # Équivalent à : 0 0 1 1 *  (1er janvier à minuit)
@monthly    # Équivalent à : 0 0 1 * *  (1er de chaque mois à minuit)
@weekly     # Équivalent à : 0 0 * * 0  (chaque dimanche à minuit)
@daily      # Équivalent à : 0 0 * * *  (chaque jour à minuit)
@hourly     # Équivalent à : 0 * * * *  (chaque heure à la minute 0)

Gestion du crontab

Commandes essentielles

# Éditer le crontab de l'utilisateur courant
crontab -e

# Afficher le crontab de l'utilisateur courant
crontab -l

# Supprimer le crontab de l'utilisateur courant
crontab -r

# Éditer le crontab d'un autre utilisateur (root requis)
sudo crontab -u www-data -e

# Afficher le crontab d'un autre utilisateur
sudo crontab -u www-data -l

Crontab utilisateur vs crontab root

Chaque utilisateur possède son propre crontab. Les tâches s'exécutent avec les permissions de cet utilisateur :

# En tant qu'utilisateur normal
crontab -e
# Les tâches s'exécutent avec les permissions de votre compte

# En tant que root
sudo crontab -e
# Les tâches s'exécutent avec les permissions root — à utiliser avec prudence

Exemples pratiques

Sauvegarde quotidienne

Planifiez une sauvegarde automatique chaque nuit à 2h du matin :

# Sauvegarde quotidienne à 2h00
0 2 * * * /usr/local/bin/backup.sh >> /var/log/backup.log 2>&1

Exemple de script de sauvegarde associé :

#!/bin/bash
# /usr/local/bin/backup.sh
DATE=$(date +\%Y\%m\%d)
BACKUP_DIR="/backup"
SOURCE="/var/www/html"

echo "=== Backup demarré le $(date) ==="
tar -czf "${BACKUP_DIR}/www-${DATE}.tar.gz" "${SOURCE}"

# Supprimer les sauvegardes de plus de 30 jours
find "${BACKUP_DIR}" -name "www-*.tar.gz" -mtime +30 -delete
echo "=== Backup termine le $(date) ==="

Nettoyage des logs

# Nettoyer les fichiers temporaires tous les dimanches à 3h00
0 3 * * 0 find /tmp -type f -atime +7 -delete

# Rotation des logs applicatifs chaque premier du mois
0 4 1 * * /usr/local/bin/rotate-logs.sh

Monitoring système

# Vérifier l'espace disque toutes les 6 heures
0 */6 * * * /usr/local/bin/check-disk.sh

# Monitoring de la charge CPU toutes les 5 minutes
*/5 * * * * /usr/local/bin/check-cpu.sh >> /var/log/cpu-monitor.log 2>&1

# Vérifier qu'un service est actif toutes les 2 minutes
*/2 * * * * systemctl is-active --quiet nginx || systemctl restart nginx

Envoi de rapports

# Rapport hebdomadaire chaque lundi à 8h00
0 8 * * 1 /usr/local/bin/weekly-report.sh | mail -s "Rapport hebdomadaire" admin@example.com

# Rapport d'utilisation disque quotidien
0 7 * * * df -h | mail -s "Rapport disque $(hostname)" admin@example.com

Variables d'environnement

Le crontab permet de définir des variables d'environnement en début de fichier. C'est essentiel car cron utilise un environnement minimal très différent de votre shell interactif :

# Définir le shell à utiliser
SHELL=/bin/bash

# Définir le PATH (critique — cron utilise un PATH très restreint par défaut)
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

# Adresse email pour recevoir la sortie des tâches
MAILTO=admin@example.com

# Répertoire personnel
HOME=/home/monuser

# Tâches planifiées ci-dessous
0 2 * * * /usr/local/bin/backup.sh
*/30 * * * * /usr/local/bin/check-services.sh

Variables les plus importantes

• PATH : Détermine où cron cherche les exécutables. Par défaut, le PATH de cron est /usr/bin:/bin, ce qui est très limité
• SHELL : Le shell utilisé pour exécuter les commandes (par défaut /bin/sh)
• MAILTO : L'adresse email qui reçoit la sortie des tâches (vide = pas d'email)
• HOME : Le répertoire de travail pour l'exécution des tâches

Répertoires cron

En plus du crontab personnel, Linux propose des répertoires prédéfinis pour organiser les tâches selon leur fréquence d'exécution :

/etc/cron.d/         # Fichiers crontab supplémentaires (format système avec champ utilisateur)
/etc/cron.daily/     # Scripts exécutés quotidiennement
/etc/cron.hourly/    # Scripts exécutés toutes les heures
/etc/cron.weekly/    # Scripts exécutés chaque semaine
/etc/cron.monthly/   # Scripts exécutés chaque mois

Utilisation des répertoires cron

Pour ajouter une tâche quotidienne, placez simplement un script exécutable dans le répertoire approprié :

# Créer un script de nettoyage quotidien
sudo tee /etc/cron.daily/clean-tmp > /dev/null << 'SCRIPT'
#!/bin/bash
# Supprimer les fichiers temporaires de plus de 7 jours
find /tmp -type f -atime +7 -delete 2>/dev/null
find /var/tmp -type f -atime +30 -delete 2>/dev/null
SCRIPT

# Rendre le script exécutable (OBLIGATOIRE)
sudo chmod +x /etc/cron.daily/clean-tmp

Planification par /etc/cron.d

Le répertoire /etc/cron.d/ permet d'ajouter des fichiers au format crontab système, avec un champ utilisateur :

# /etc/cron.d/monitoring
SHELL=/bin/bash
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

# Vérification toutes les 5 minutes
*/5 * * * * root /usr/local/bin/check-services.sh >> /var/log/monitoring.log 2>&1

Anacron

Anacron est un complément de cron conçu pour les machines qui ne fonctionnent pas 24h/24 (postes de travail, laptops). Contrairement à cron, anacron ne s'exécute pas en temps réel : il vérifie au démarrage si des tâches planifiées ont été manquées et les exécute en rattrapage.

Configuration d'anacron

Le fichier de configuration principal est /etc/anacrontab :

# /etc/anacrontab
# période(jours)  délai(minutes)  identifiant       commande

SHELL=/bin/bash
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

1   5    cron.daily     run-parts /etc/cron.daily
7   10   cron.weekly    run-parts /etc/cron.weekly
30  15   cron.monthly   run-parts /etc/cron.monthly

• Période : la fréquence en jours (1 = quotidien, 7 = hebdomadaire, 30 = mensuel)
• Délai : nombre de minutes à attendre après le démarrage avant d'exécuter la tâche
• Identifiant : nom unique pour le suivi dans /var/spool/anacron/

# Installer anacron si absent
sudo apt install -y anacron

# Forcer l'exécution d'anacron manuellement
sudo anacron -f -n

Logging et debugging

Consulter les logs cron

Les actions du démon cron sont enregistrées dans syslog :

# Debian / Ubuntu
sudo grep CRON /var/log/syslog

# CentOS / Rocky Linux
sudo grep CRON /var/log/cron

# Suivre les logs en temps réel
sudo tail -f /var/log/syslog | grep CRON

Redirection stdout et stderr

Maîtrisez les redirections pour capturer toutes les sorties de vos tâches :

# Rediriger stdout et stderr vers un fichier de log
0 2 * * * /usr/local/bin/backup.sh >> /var/log/backup.log 2>&1

# Séparer stdout et stderr dans des fichiers distincts
0 2 * * * /usr/local/bin/backup.sh >> /var/log/backup.log 2>> /var/log/backup-errors.log

# Ignorer toute sortie (silencieux)
0 2 * * * /usr/local/bin/backup.sh > /dev/null 2>&1

# Ajouter un horodatage dans les logs
0 2 * * * echo "--- $(date) ---" >> /var/log/backup.log && /usr/local/bin/backup.sh >> /var/log/backup.log 2>&1

Emails de notification

Par défaut, si une tâche cron produit une sortie (stdout ou stderr) et que la variable MAILTO est configurée, cron envoie un email. Vérifiez que votre système dispose d'un MTA (Mail Transfer Agent) fonctionnel :

# Tester l'envoi de mail depuis cron
* * * * * echo "Test cron mail $(date)" 2>&1

# Vérifier la file de mails
sudo mailq

# Lire les mails locaux
mail

Sécurisation

Contrôle d'accès avec cron.allow et cron.deny

Linux permet de contrôler quels utilisateurs peuvent utiliser crontab via deux fichiers :

# /etc/cron.allow — si ce fichier existe, SEULS les utilisateurs listés peuvent utiliser crontab
sudo tee /etc/cron.allow > /dev/null << EOF
root
admin
déployer
EOF

# /etc/cron.deny — les utilisateurs listés sont INTERDITS d'utiliser crontab
sudo tee /etc/cron.deny > /dev/null << EOF
guest
testuser
EOF

La logique de priorité est la suivante :

1. Si /etc/cron.allow existe, seuls les utilisateurs qui y figurent peuvent accéder à crontab
2. Si seul /etc/cron.deny existe, tous les utilisateurs sauf ceux listés ont accès
3. Si aucun des deux fichiers n'existe, le comportement dépend de la distribution

Permissions des scripts

# Vérifier les permissions d'un script cron
ls -la /usr/local/bin/backup.sh

# Permissions recommandées : lecture + exécution pour le propriétaire uniquement
sudo chmod 700 /usr/local/bin/backup.sh
sudo chown root:root /usr/local/bin/backup.sh

# Pour un script exécuté par un utilisateur spécifique
sudo chmod 750 /home/déployer/scripts/deploy.sh
sudo chown déployer:déployer /home/déployer/scripts/deploy.sh

Bonnes pratiques

Utiliser des scripts wrapper

Plutôt que de mettre des commandes complexes directement dans le crontab, utilisez des scripts dédiés :

#!/bin/bash
# /usr/local/bin/cron-backup-wrapper.sh
# Script wrapper pour la sauvegarde cron

set -euo pipefail

LOGFILE="/var/log/backup-cron.log"
LOCKFILE="/tmp/backup-cron.lock"

# Vérifier qu'une autre instance ne tourne pas déjà
if [ -f "$LOCKFILE" ]; then
    echo "$(date) - ERREUR: backup déjà en cours (lockfile existe)" >> "$LOGFILE"
    exit 1
fi

# Créer le lock file
trap "rm -f $LOCKFILE" EXIT
touch "$LOCKFILE"

echo "$(date) - Démarrage de la sauvegarde" >> "$LOGFILE"
/usr/local/bin/backup.sh >> "$LOGFILE" 2>&1
echo "$(date) - Sauvegarde terminée (code retour: $?)" >> "$LOGFILE"

Lock files pour éviter les exécutions simultanées

L'utilitaire flock permet de garantir qu'une seule instance de votre tâche s'exécute à la fois :

# Utilisation de flock dans le crontab
*/5 * * * * flock -n /tmp/check-services.lock /usr/local/bin/check-services.sh

# Avec timeout (attente de 60 secondes maximum)
0 * * * * flock -w 60 /tmp/sync.lock /usr/local/bin/sync-data.sh

Logging structuré

#!/bin/bash
# Fonction de logging avec horodatage
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> /var/log/cron-tasks.log
}

log "INFO: Démarrage de la tâche"
# ... commandes ...
log "INFO: Tâche terminée avec succès"

Sauvegarder son crontab

# Exporter le crontab courant
crontab -l > ~/crontab-backup-$(date +%Y%m%d).txt

# Restaurer depuis une sauvegarde
crontab ~/crontab-backup-20260212.txt

# Automatiser la sauvegarde du crontab (meta-cron)
0 0 * * 0 crontab -l > /backup/crontabs/$(whoami)-$(date +\%Y\%m\%d).txt

Troubleshooting

La tâche ne s'exécute pas

Voici une checklist de diagnostic systématique :

1. Vérifier le service cron :

sudo systemctl status cron
# Si inactif :
sudo systemctl start cron

2. Vérifier la syntaxe du crontab :

# Lister pour vérifier visuellement
crontab -l

# Valider avec un outil en ligne ou tester dans un éditeur

3. Vérifier les logs :

sudo grep CRON /var/log/syslog | tail -20

4. Tester le script manuellement avec le même environnement :

# Simuler l'environnement minimal de cron
env -i SHELL=/bin/bash HOME=/root PATH=/usr/bin:/bin /usr/local/bin/mon-script.sh

Problèmes de PATH

C'est la cause numéro 1 des tâches cron qui échouent. Par défaut, le PATH de cron est très limité :

# MAUVAIS — commande sans chemin absolu
0 2 * * * mysqldump -u root mabase > /backup/db.sql

# BON — chemin absolu vers la commande
0 2 * * * /usr/bin/mysqldump -u root mabase > /backup/db.sql

# MIEUX — définir le PATH en début de crontab
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
0 2 * * * mysqldump -u root mabase > /backup/db.sql

Problèmes de permissions

# Vérifier que le script est exécutable
ls -la /usr/local/bin/mon-script.sh

# Ajouter le droit d'exécution si manquant
chmod +x /usr/local/bin/mon-script.sh

# Vérifier que l'utilisateur peut accéder au répertoire de sortie
ls -la /var/log/
# Le répertoire de log doit être accessible en écriture

Problèmes d'encodage et de caractères spéciaux

# Le caractère % a une signification spéciale dans crontab (retour à la ligne)
# Il doit être échappé avec un antislash

# MAUVAIS
0 2 * * * /usr/bin/date +%Y%m%d > /tmp/date.txt

# BON
0 2 * * * /usr/bin/date +\%Y\%m\%d > /tmp/date.txt

Conclusion

Crontab est un outil fondamental de l'administration Linux qui permet d'automatiser efficacement les tâches récurrentes. Pour résumer les points essentiels :

• Maîtrisez la syntaxe des 5 champs et des caractères spéciaux pour planifier précisément vos tâches
• Définissez toujours le PATH en début de crontab pour éviter les problèmes d'exécution
• Utilisez des scripts wrapper avec lock files et logging pour des tâches fiables
• Redirigez les sorties vers des fichiers de log pour faciliter le debugging
• Sécurisez vos scripts avec des permissions strictes et contrôlez l'accès via cron.allow/cron.deny
• Pensez à anacron pour les machines qui ne tournent pas en continu
• Sauvegardez votre crontab régulièrement pour éviter les pertes de configuration

En combinant cron avec de bonnes pratiques de scripting et de logging, vous construisez une infrastructure d'automatisation robuste et facile à maintenir.