- Générateur d'expression CRON

Qu'est-ce qu'une expression CRON ?

CRON est un planificateur de tâches Unix qui existe depuis 1975. Son nom vient du grec chronos (temps). Il permet d'exécuter des commandes ou scripts automatiquement selon un calendrier précis, sans intervention humaine.

Une expression CRON est une chaîne de caractères composée de 5 champs séparés par des espaces, chaque champ représentant une unité de temps. Combinés, ils définissent précisément quand une tâche doit s'exécuter.

Pourquoi utiliser CRON ?

• Sauvegardes automatiques — exporter une base de données toutes les nuits à 2h
• Rapports périodiques — envoyer un email de synthèse chaque lundi matin
• Nettoyage de fichiers — supprimer les logs de plus de 30 jours chaque semaine
• Synchronisation de données — appeler une API externe toutes les 5 minutes
• Déploiements planifiés — lancer un build en dehors des heures de pointe
• Surveillance — vérifier la disponibilité d'un service toutes les minutes
• Archivage — compresser et archiver des données mensuellement

Visualisation de la structure

┌─────────────── minute (0-59)
│ ┌───────────── heure (0-23)
│ │ ┌─────────── jour du mois (1-31)
│ │ │ ┌───────── mois (1-12)
│ │ │ │ ┌─────── jour de la semaine (0-6, dimanche=0)
│ │ │ │ │
* * * * *  commande-à-exécuter

La démon cron lit le fichier crontab (cron table) et exécute les commandes au moment spécifié. Chaque utilisateur Linux peut avoir son propre crontab éditable via crontab -e.

Syntaxe des 5 champs CRON

Champ 1 — La minute (0-59)

Le champ minute définit à quelle(s) minute(s) la tâche doit s'exécuter dans l'heure. Valeurs : 0 (début d'heure) à 59.

# Exécution à la 15e minute de chaque heure
15 * * * * /usr/bin/mon-script.sh

# Exécution à la 0e et 30e minute (deux fois par heure)
0,30 * * * * /usr/bin/mon-script.sh

Champ 2 — L'heure (0-23)

Définit à quelle(s) heure(s) la tâche s'exécute. Utilise le format 24h : 0 = minuit, 12 = midi, 23 = 23h.

# Tous les jours à 14h30
30 14 * * * /usr/bin/mon-rapport.sh

# Deux fois par jour : 6h et 18h
0 6,18 * * * /usr/bin/sync-data.sh

Champ 3 — Jour du mois (1-31)

Spécifie le jour du mois. Attention : certains mois n'ont pas 31 jours, pensez à valider votre calendrier.

# Le 1er de chaque mois à minuit (facturation mensuelle)
0 0 1 * * /usr/bin/facturation.sh

# Le 15 et le dernier jour du mois
0 0 1,15 * * /usr/bin/paie.sh

Champ 4 — Le mois (1-12)

Filtre par mois. 1 = janvier, 12 = décembre. Certains systèmes acceptent aussi les abréviations anglaises (jan, feb…).

# Tâche annuelle en janvier uniquement
0 0 1 1 * /usr/bin/bilan-annuel.sh

# Tous les trimestres (mars, juin, septembre, décembre)
0 0 1 3,6,9,12 * /usr/bin/rapport-trimestriel.sh

Champ 5 — Jour de semaine (0-6)

0 = dimanche, 1 = lundi, …, 6 = samedi. Sur certains systèmes, 7 est aussi accepté pour le dimanche. Certains systèmes acceptent aussi mon, tue, wed, thu, fri, sat, sun.

# Chaque lundi à 8h
0 8 * * 1 /usr/bin/rapport-semaine.sh

# Du lundi au vendredi à 9h (jours ouvrables)
0 9 * * 1-5 /usr/bin/backup.sh

# Le week-end à midi
0 12 * * 6,0 /usr/bin/maintenance.sh

Caractères spéciaux et syntaxe avancée

🔀 Le pas avec */N

Le caractère / permet de définir un intervalle. */5 signifie "toutes les 5 unités", à partir de 0.

# Toutes les 5 minutes
*/5 * * * * /usr/bin/check-status.sh

# Toutes les 2 heures, à la minute 0
0 */2 * * * /usr/bin/sync.sh

# Toutes les 6 heures (0h, 6h, 12h, 18h)
0 */6 * * * /usr/bin/rapport.sh

# Tous les 2 jours du mois
0 0 */2 * * /usr/bin/archivage.sh

🎯 Les alias @ (varnish CRON)

La plupart des démons CRON modernes acceptent des alias pratiques :

⚠️ Combinaison jour-mois ET jour-semaine

# S'exécute le 15 du mois OU chaque lundi (pas uniquement le lundi 15 !)
0 0 15 * 1 /usr/bin/tache.sh

# Pour cibler uniquement le lundi 15, il faut scripter la logique dans le script lui-même
0 0 15 * 1 [ $(date +\%u) -eq 1 ] && /usr/bin/tache.sh

Exemples d'expressions CRON courantes

⚡ Surveillance et monitoring

# Vérifier la disponibilité d'un service toutes les minutes
* * * * * /usr/bin/check-uptime.sh >> /var/log/uptime.log 2>&1

# Vérifier l'espace disque toutes les 15 minutes
*/15 * * * * df -h | mail -s "Espace disque" admin@exemple.com

# Ping de santé toutes les 5 minutes
*/5 * * * * curl -s https://mon-api.com/health || mail -s "API DOWN" ops@exemple.com

💾 Sauvegardes et archivage

# Sauvegarde MySQL toutes les nuits à 2h30
30 2 * * * mysqldump -u root -pMOTPASSE ma_bdd > /backup/db_$(date +\%Y\%m\%d).sql

# Compression des logs chaque dimanche à 3h
0 3 * * 0 tar -czf /archive/logs_$(date +\%Y\%W).tar.gz /var/log/

# Rotation des sauvegardes : garder seulement les 7 derniers jours
0 4 * * * find /backup/ -name "*.sql" -mtime +7 -delete

# Snapshot journalier d'un volume Docker
0 1 * * * docker run --rm -v myvolume:/data alpine tar czf /backup/vol_$(date +\%Y\%m\%d).tar.gz /data

📊 Rapports et notifications

# Rapport quotidien chaque matin à 8h
0 8 * * * /usr/bin/python3 /scripts/daily-report.py

# Rapport hebdomadaire chaque lundi à 7h
0 7 * * 1 /usr/bin/node /scripts/weekly-stats.js

# Newsletter mensuelle le 1er de chaque mois à 10h
0 10 1 * * /usr/bin/php /web/send-newsletter.php

# Récap trimestriel (mars, juin, sept, déc)
0 9 1 3,6,9,12 * /usr/bin/rapport-trimestriel.sh

🔄 Synchronisation et import de données

# Synchronisation avec une API externe toutes les heures
0 * * * * /usr/bin/php /scripts/sync-api.php

# Import de fichier CSV chaque jour ouvrable à 6h
0 6 * * 1-5 /usr/bin/python3 /scripts/import-csv.py /data/export.csv

# Mise à jour de cache Redis à 23h30
30 23 * * * redis-cli FLUSHDB && /usr/bin/php /scripts/warm-cache.php

🛠️ Maintenance serveur

# Nettoyage des fichiers temporaires chaque nuit
0 0 * * * find /tmp -type f -atime +1 -delete

# Redémarrage d'un service chaque dimanche à 4h (maintenance)
0 4 * * 0 systemctl restart nginx

# Mise à jour des paquets chaque mois (Ubuntu/Debian)
0 3 1 * * apt-get update && apt-get -y upgrade >> /var/log/apt-update.log 2>&1

# Vider le cache OPcache PHP en production chaque soir
0 23 * * * php -r "opcache_reset();" 2>/dev/null

CRON dans différents environnements

🐧 Linux crontab

Le crontab est le système natif. Chaque utilisateur possède son propre fichier, éditable avec crontab -e.

# Afficher le crontab actuel
crontab -l

# Éditer le crontab
crontab -e

# Supprimer tout le crontab
crontab -r

# Crontab pour un autre utilisateur (root seulement)
crontab -u www-data -e

# Système crontab (/etc/crontab) — inclut un champ utilisateur
# min  heure  jour-mois  mois  jour-sem  UTILISATEUR  commande
*/5    *      *          *     *         www-data     /usr/bin/php /web/cron.php

🚀 GitHub Actions

GitHub Actions supporte les déclencheurs CRON via schedule. Attention : GitHub utilise l'heure UTC et les exécutions peuvent être retardées en période de forte charge.

name: Rapport hebdomadaire

on:
  schedule:
    # Chaque lundi à 9h UTC
    - cron: '0 9 * * 1'
  workflow_dispatch: # Déclenchement manuel aussi possible

jobs:
  generate-report:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Générer le rapport
        run: node scripts/weekly-report.js

---
# Plusieurs horaires dans un même workflow
on:
  schedule:
    - cron: '0 8 * * 1-5'  # Jours ouvrables à 8h UTC
    - cron: '0 0 * * 0'    # Dimanche à minuit UTC

☸️ Kubernetes CronJob

Kubernetes dispose d'une ressource CronJob native pour planifier des pods de façon périodique.

apiVersion: batch/v1
kind: CronJob
metadata:
  name: backup-database
spec:
  # Sauvegarde chaque nuit à 2h30
  schedule: "30 2 * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 1
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: backup
            image: postgres:15
            command: ["/bin/sh", "-c"]
            args:
            - pg_dump -h $DB_HOST -U $DB_USER ma_bdd > /backup/dump_$(date +%Y%m%d).sql
          restartPolicy: OnFailure

☁️ AWS EventBridge (CloudWatch Events)

AWS EventBridge supporte deux formats : le format CRON standard (légèrement modifié) et le format rate.

# Format AWS CRON (6 champs, avec année, sans jour de semaine standard)
# cron(minute heure jour-mois mois jour-semaine année)

# Tous les jours à 12h UTC
cron(0 12 * * ? *)

# Chaque lundi à 8h UTC
cron(0 8 ? * MON *)

# 1er de chaque mois à 3h
cron(0 3 1 * ? *)

# Format rate (plus simple pour les intervalles réguliers)
rate(5 minutes)
rate(1 hour)
rate(7 days)

📦 Node.js avec node-cron

// Installation
npm install node-cron

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

// Exécution toutes les 5 minutes
cron.schedule('*/5 * * * *', () => {
    console.log('Synchronisation des données...');
    syncData();
});

// Tous les jours à 9h (timezone Paris)
cron.schedule('0 9 * * *', () => {
    sendDailyReport();
}, {
    scheduled: true,
    timezone: "Europe/Paris"
});

// Arrêter une tâche
const task = cron.schedule('* * * * *', doSomething);
task.stop();

Bonnes pratiques et pièges à éviter

✅ Bonnes pratiques

❌ Pièges fréquents

Problème 1 — Le script ne s'exécute pas

# ❌ Mauvais (php peut être introuvable)
* * * * * php /var/www/cron.php

# ✅ Correct (chemin absolu)
* * * * * /usr/bin/php /var/www/cron.php

# Vérifier le chemin de php
which php  # → /usr/bin/php

Problème 2 — Exécutions simultanées

# ❌ Sans verrou : deux instances peuvent tourner simultanément
*/5 * * * * /usr/bin/php /var/www/import.php

# ✅ Avec flock : attend la fin de l'exécution précédente
*/5 * * * * flock -n /tmp/import.lock /usr/bin/php /var/www/import.php

Problème 3 — Emails indésirables

# ❌ Sans redirection : cron envoie un email à chaque exécution
* * * * * /usr/bin/mon-script.sh

# ✅ Redirection vers log
* * * * * /usr/bin/mon-script.sh >> /var/log/mon-script.log 2>&1

# ✅ Désactiver complètement les emails
* * * * * /usr/bin/mon-script.sh > /dev/null 2>&1

# ✅ Définir MAILTO vide pour désactiver les emails globalement
MAILTO=""
* * * * * /usr/bin/mon-script.sh

Problème 4 — Le % dans les commandes

# ❌ Le % a une signification spéciale dans crontab (retour ligne)
0 2 * * * mysqldump db > /backup/db_$(date +%Y%m%d).sql

# ✅ Échapper les % avec des backslashes
0 2 * * * mysqldump db > /backup/db_$(date +\%Y\%m\%d).sql

🔍 Débogage des CRON jobs

# Vérifier les logs du démon cron (Ubuntu/Debian)
grep CRON /var/log/syslog | tail -20

# Ou avec journalctl (systemd)
journalctl -u cron --since "1 hour ago"

# Vérifier que le démon cron tourne
systemctl status cron

# Tester un script dans un environnement cron-like
env -i HOME=/root LOGNAME=root PATH=/usr/bin:/bin /bin/sh -c "votre-commande"

# Voir le crontab actuel formaté
crontab -l | grep -v "^#" | grep -v "^$"

📐 Étalement des tâches

Si vous avez plusieurs serveurs ou plusieurs tâches CRON similaires, évitez de toutes les planifier à la même heure (minuit, heure pile) pour ne pas créer des pics de charge.

# ❌ Tous les serveurs exécutent à minuit → pic de charge
0 0 * * * /usr/bin/backup.sh

# ✅ Étalement : serveur A à 0h, serveur B à 0h15, serveur C à 0h30
# Serveur A :
0 0 * * * /usr/bin/backup.sh
# Serveur B :
15 0 * * * /usr/bin/backup.sh
# Serveur C :
30 0 * * * /usr/bin/backup.sh

# ✅ Ou aléatoire via sleep (Linux)
0 0 * * * sleep $((RANDOM \% 600)) && /usr/bin/backup.sh