Planifier des tâches automatiques sur un VPS avec cron

À quoi servent les tâches planifiées cron ?

Les tâches planifiées cron permettent d’exécuter automatiquement une commande ou un script à une date et une fréquence définies. Une fois la tâche enregistrée, le service cron la lance sans intervention manuelle, même lorsque votre session SSH est fermée.

Cron est utile pour automatiser :

• une sauvegarde nocturne ;
• le nettoyage de fichiers temporaires ;
• l’exécution régulière d’un script ;
• la génération d’un rapport ;
• l’envoi d’une notification ;
• la synchronisation de fichiers ;
• une tâche à chaque redémarrage du VPS.

Prenons un script de sauvegarde situé dans :

/usr/local/bin/sauvegarde.sh

Vous pouvez demander à cron de l’exécuter chaque nuit à une heure précise. Le script doit toutefois fonctionner correctement lorsqu’il est lancé manuellement avant d’être ajouté à la crontab.

Testez toujours votre commande ou votre script dans le terminal avant de le planifier. Cron ne corrigera ni un mauvais chemin, ni une permission manquante, ni une erreur dans le programme.

Pour administrer votre serveur à distance, consultez le guide pour vous connecter à un VPS en SSH.

Comprendre la syntaxe d’une crontab

Une ligne cron classique contient cinq champs temporels suivis de la commande à exécuter :

* * * * * commande
│ │ │ │ │
│ │ │ │ └── Jour de la semaine
│ │ │ └──── Mois
│ │ └────── Jour du mois
│ └──────── Heure
└────────── Minute

Voici le détail des champs :

Position	Champ	Valeurs courantes
1	Minute	0 à 59
2	Heure	0 à 23
3	Jour du mois	1 à 31
4	Mois	1 à 12
5	Jour de la semaine	0 à 7, dimanche correspondant généralement à 0 ou 7
6	Commande	Programme ou script à exécuter

Cette tâche s’exécute tous les jours à 03 h 00 :

0 3 * * * /usr/local/bin/sauvegarde.sh

Les principaux caractères spéciaux sont :

Caractère	Fonction	Exemple
*	Toutes les valeurs	* * * * *
,	Plusieurs valeurs	0 8,12,18 * * *
-	Plage de valeurs	0 9 * * 1-5
/	Intervalle	*/15 * * * *

Exemples :

# Toutes les 15 minutes
*/15 * * * * /chemin/commande

# Du lundi au vendredi à 09 h 00
0 9 * * 1-5 /chemin/commande

# À 08 h 00, 12 h 00 et 18 h 00
0 8,12,18 * * * /chemin/commande

Cron propose également des raccourcis :

@hourly  /chemin/commande
@daily   /chemin/commande
@weekly  /chemin/commande
@monthly /chemin/commande
@reboot  /chemin/commande

@reboot lance la commande lorsque le service cron démarre, généralement après le démarrage du système. Il ne garantit pas que toutes les dépendances réseau ou applicatives soient déjà prêtes.

Un outil comme crontab.guru peut vous aider à relire une expression, mais vérifiez toujours son résultat avant de l’utiliser en production.

Éditer la crontab du bon utilisateur

Chaque utilisateur Linux peut disposer de sa propre crontab. Les commandes s’exécutent avec les permissions du propriétaire de cette crontab.

Pour modifier celle de l’utilisateur connecté :

crontab -e

Lors de la première utilisation, le système peut vous demander de choisir un éditeur. nano constitue généralement le choix le plus simple pour débuter.

Pour afficher les tâches enregistrées :

crontab -l

Pour modifier la crontab de root :

sudo crontab -e

N’utilisez la crontab root que lorsqu’une tâche exige réellement des privilèges administrateur. Pour une application appartenant à un utilisateur standard, planifiez la tâche avec ce même utilisateur.

Emplacement	Particularité
crontab -e	Crontab de l’utilisateur courant
sudo crontab -e	Crontab de root
/etc/crontab	Crontab système avec un champ utilisateur supplémentaire
/etc/cron.d/	Fichiers système utilisant également un champ utilisateur

Dans /etc/crontab, la syntaxe contient le compte d’exécution :

0 3 * * * utilisateur /usr/local/bin/sauvegarde.sh

Dans une crontab créée avec crontab -e, n’ajoutez pas ce champ :

0 3 * * * /usr/local/bin/sauvegarde.sh

Exemples de tâches planifiées cron

Sauvegarde chaque nuit à 03 h 00

Créez un dossier de logs accessible à votre utilisateur :

mkdir -p /home/utilisateur/logs

Ajoutez dans crontab -e :

0 3 * * * /usr/local/bin/sauvegarde.sh >> /home/utilisateur/logs/sauvegarde.log 2>&1

La partie suivante ajoute la sortie normale au fichier :

>> /home/utilisateur/logs/sauvegarde.log

Celle-ci redirige aussi les erreurs vers le même fichier :

2>&1

Exécuter un script toutes les 15 minutes

*/15 * * * * /usr/bin/python3 /home/utilisateur/scripts/tache.py >> /home/utilisateur/logs/tache.log 2>&1

Utilisez le chemin absolu de Python et du script.

Lancer une commande chaque jour à minuit

0 0 * * * /usr/bin/find /home/utilisateur/cache -type f -mtime +7 -delete

Testez d’abord la commande sans -delete :

/usr/bin/find /home/utilisateur/cache -type f -mtime +7

Vous pourrez ainsi vérifier la liste des fichiers concernés avant leur suppression.

Exécuter un script au démarrage

@reboot /home/utilisateur/scripts/initialisation.sh >> /home/utilisateur/logs/initialisation.log 2>&1

Pour superviser une application permanente et la redémarrer après un crash, préférez un service systemd plutôt qu’une tâche @reboot.

Éviter les pièges classiques de cron

Utiliser des chemins absolus

Cron dispose d’un environnement plus limité que votre terminal interactif. Une commande fonctionnant en SSH peut échouer lorsqu’elle est lancée automatiquement.

Évitez :

0 3 * * * python sauvegarde.py

Préférez :

0 3 * * * /usr/bin/python3 /home/utilisateur/scripts/sauvegarde.py

Trouvez le chemin d’un programme avec :

command -v python3
command -v rsync
command -v node

Définir explicitement le PATH

Vous pouvez déclarer un environnement au début de la crontab :

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

0 3 * * * /usr/local/bin/sauvegarde.sh

Utilisez malgré tout des chemins absolus pour les scripts et fichiers importants.

Rediriger la sortie

Sans redirection, les messages peuvent être envoyés au système de messagerie locale ou rester difficiles à retrouver.

Ajoutez un fichier de log :

*/15 * * * * /home/utilisateur/scripts/tache.sh >> /home/utilisateur/logs/tache.log 2>&1

Prévoyez une rotation ou un nettoyage des logs afin qu’ils ne remplissent pas le disque.

Vérifier le fuseau horaire

Cron utilise généralement l’heure du système. Vérifiez-la avec :

timedatectl status

Pour configurer le fuseau horaire de Paris :

sudo timedatectl set-timezone Europe/Paris

Une tâche prévue à 03 h 00 s’exécutera selon l’heure système du VPS, avec les effets éventuels des changements d’heure.

Ne pas dépendre du dossier courant

Cron ne lance pas nécessairement la commande depuis le dossier de votre application.

Utilisez :

0 3 * * * cd /home/utilisateur/mon-app && /usr/bin/node script.js >> /home/utilisateur/logs/app.log 2>&1

Ou configurez directement votre script pour utiliser des chemins absolus.

Vérifier qu’une tâche cron s’exécute

Commencez par lancer exactement la commande prévue :

/usr/local/bin/sauvegarde.sh

Vérifiez son code de sortie :

echo $?

La valeur 0 indique généralement une exécution réussie.

Contrôlez ensuite le service cron :

sudo systemctl status cron

Sur certaines distributions, il peut porter un autre nom :

sudo systemctl status crond

Pour consulter les journaux avec systemd :

sudo journalctl -u cron -n 100 --no-pager

Suivez-les en direct :

sudo journalctl -u cron -f

Sur une installation utilisant rsyslog, les événements peuvent également apparaître dans :

grep CRON /var/log/syslog

Ajoutez temporairement une tâche de test :

* * * * * /usr/bin/date >> /home/utilisateur/logs/cron-test.log 2>&1

Attendez son exécution, vérifiez le fichier, puis supprimez cette ligne.

Les causes fréquentes d’échec sont :

• mauvais utilisateur ;
• chemin relatif ;
• script non exécutable ;
• variable d’environnement absente ;
• fichier de log non accessible ;
• erreur de syntaxe ;
• fuseau horaire inattendu.

Alternative : les timers systemd

Les timers systemd constituent une alternative moderne à cron. Ils nécessitent généralement deux unités :

mon-traitement.service
mon-traitement.timer

Ils permettent notamment :

• de centraliser les logs dans journalctl ;
• de définir des dépendances ;
• de rattraper certaines exécutions manquées ;
• de contrôler précisément l’environnement ;
• d’associer la planification à un service supervisé.

Ils sont plus verbeux, mais particulièrement adaptés aux tâches système complexes. Pour comprendre les unités et les logs systemd, consultez le guide pour créer un service systemd.

Des sauvegardes automatiques sont incluses pour vous aider à restaurer. Conservez aussi vos propres exports réguliers : vous restez responsable de vos données.

En résumé

• Les tâches planifiées cron exécutent automatiquement des commandes à des horaires définis.
• Une expression cron contient minute, heure, jour du mois, mois et jour de la semaine.
• Modifiez votre crontab avec crontab -e.
• Vérifiez-la avec crontab -l.
• Utilisez la crontab de l’utilisateur qui doit réellement exécuter la tâche.
• Testez toujours le script manuellement avant de le planifier.
• Utilisez des chemins absolus pour les programmes, scripts, fichiers et logs.
• Redirigez la sortie avec >> fichier.log 2>&1.
• Vérifiez le fuseau horaire avec timedatectl.
• Consultez les exécutions avec journalctl -u cron ou les journaux système disponibles.
• Utilisez @reboot pour une commande ponctuelle au démarrage, pas pour superviser une application.
• Préférez un timer systemd pour une planification avancée avec dépendances et logs centralisés.
• Pour exécuter vos tâches planifiées cron sur un VPS hébergé en France avec stockage NVMe, Anti-DDoS L3/L4/L7 inclus, panel de gestion et support francophone, découvrez les offres VPS TalCloud.