Comment exécuter un Cron Job uniquement s'il n'est pas déjà en cours ?

Utilisation des mécanismes de verrouillage de fichiers

Le verrouillage de fichiers est une méthode permettant de s'assurer qu'une seule instance d'une tâche cron s'exécute à la fois. Elle fonctionne en créant un fichier de verrouillage au démarrage de la tâche et en le supprimant à la fin de celle-ci. Si une autre instance de la tâche tente de démarrer alors que le fichier de verrouillage existe, elle ne s'exécutera pas.

Le verrouillage de fichiers pour la gestion des tâches cron offre les avantages suivants :

• Simple à mettre en œuvre
• Fonctionne avec différents langages de programmation
• Évite les conflits de ressources
• Aide à maintenir la cohérence des données

<?php
$lockFile = '/chemin/vers/fichier/verrou';

if (file_exists($lockFile)) {
    echo "La tâche est déjà en cours d'exécution. Arrêt.\n";
    exit(1);
}

// Création du fichier de verrouillage
file_put_contents($lockFile, getmypid());

// Votre code de tâche ici

// Suppression du fichier de verrouillage une fois terminé
unlink($lockFile);
?>

La commande flock : Une approche moderne du verrouillage de fichiers

La commande flock est une méthode plus récente pour gérer le verrouillage de fichiers pour les tâches cron. C'est un utilitaire intégré dans de nombreux systèmes Linux qui gère directement les verrous de fichiers.

Fonctionnement de flock :

1. Il tente d'acquérir un verrou sur un fichier spécifié
2. En cas de succès, il exécute la commande donnée
3. Sinon, il attend ou quitte, selon les options utilisées

Avantages de l'utilisation de flock :

• Facile à utiliser avec une syntaxe simple
• Gère automatiquement la libération du verrou à la fin du processus
• Fonctionne bien avec les scripts shell et les opérations en ligne de commande
• Plus fiable que la création et la suppression manuelles de fichiers de verrouillage

L'utilisation de flock peut vous aider à éviter les complexités de la gestion manuelle des fichiers de verrouillage, rendant vos configurations de tâches cron plus fiables et moins sujettes aux erreurs.

0 * * * * /usr/bin/flock -n /tmp/monverrou.lock /chemin/vers/votre/script.sh

Configuration de la tâche cron avec flock

Pour utiliser flock dans vos entrées de tâches cron, suivez cette syntaxe :

* * * * * /usr/bin/flock [options] /chemin/vers/fichier_verrou /chemin/vers/commande

Voici un exemple d'entrée de tâche cron utilisant flock :

0 2 * * * /usr/bin/flock -n /tmp/sauvegarde.lock /home/utilisateur/script_sauvegarde.sh

Cette tâche cron exécute un script de sauvegarde tous les jours à 2h00 du matin. L'option -n indique à flock de quitter s'il ne peut pas obtenir le verrou, empêchant la tâche d'attendre.

0 2 * * * /usr/bin/flock -w 60 /tmp/sauvegarde.lock /home/utilisateur/script_sauvegarde.sh

Configuration des emplacements et des permissions des fichiers de verrouillage

Lors du choix des emplacements des fichiers de verrouillage :

1. Utilisez le répertoire /tmp pour les verrous à court terme
2. Pour les verrous à long terme, utilisez /var/lock ou créez un répertoire dans /var
3. N'utilisez pas les répertoires personnels pour les fichiers de verrouillage dans les tâches cron système

Pour définir les permissions des fichiers de verrouillage :

1. Créez le fichier de verrouillage avec des permissions limitées :

   touch /var/lock/matache.lock
   chmod 600 /var/lock/matache.lock

2. Assurez-vous que l'utilisateur exécutant la tâche cron peut écrire dans le fichier de verrouillage

3. Pour les tâches cron système, utilisez un utilisateur et un groupe spécifiques pour une meilleure sécurité

En suivant ces étapes, vous pouvez configurer flock avec vos tâches cron pour empêcher l'exécution simultanée des tâches et gérer les fichiers de verrouillage en toute sécurité.

Utilisation des fichiers PID (Process ID)

Les fichiers PID sont des fichiers texte qui contiennent l'identifiant de processus d'un programme en cours d'exécution. Ils peuvent être utilisés pour vérifier si un processus est en cours d'exécution. Pour les tâches cron, les fichiers PID peuvent aider à empêcher l'exécution simultanée de plusieurs instances de la même tâche.

Fonctionnement des fichiers PID pour les tâches cron :

1. La tâche crée un fichier PID avec son identifiant de processus au démarrage.
2. Avant de démarrer, la tâche vérifie si le fichier PID existe et si l'identifiant de processus qu'il contient est toujours en cours d'exécution.
3. Si le processus est en cours d'exécution, la nouvelle instance se termine. Sinon, elle crée un nouveau fichier PID et s'exécute.

Étapes pour mettre en œuvre une solution basée sur les fichiers PID :

1. Créez un fichier PID lorsque la tâche démarre :

   echo $$ > /chemin/vers/tache.pid

2. Vérifiez l'existence d'un fichier PID au début de votre script :

   if [ -f /chemin/vers/tache.pid ]; then
    pid=$(cat /chemin/vers/tache.pid)
    if ps -p $pid > /dev/null 2>&1; then
      echo "La tâche est déjà en cours d'exécution."
      exit 1
    fi
   fi

3. Supprimez le fichier PID à la fin de la tâche :

   rm /chemin/vers/tache.pid

echo $$ > /chemin/vers/tache_sauvegarde_$(date +%Y%m%d).pid

Solutions de script pour l'exclusivité des tâches

Les scripts personnalisés offrent un moyen de gérer l'exclusivité des tâches cron. Ces scripts peuvent vérifier les instances en cours d'exécution et gérer divers scénarios en fonction de vos besoins.

Un script bash simple pour vérifier les instances en cours d'exécution :

#!/bin/bash

FICHIER_VERROU="/tmp/matache.lock"

if [ -e ${FICHIER_VERROU} ] && kill -0 `cat ${FICHIER_VERROU}`; then
    echo "La tâche est déjà en cours d'exécution"
    exit 1
fi

# Assurez-vous que le fichier de verrouillage est supprimé lorsque nous quittons, puis revendiquez-le
trap "rm -f ${FICHIER_VERROU}; exit" INT TERM EXIT
echo $$ > ${FICHIER_VERROU}

# Votre code de tâche ici

# Nettoyage
rm -f ${FICHIER_VERROU}

Ce script :

1. Vérifie l'existence d'un fichier de verrouillage
2. Si le fichier de verrouillage existe, il vérifie si l'identifiant de processus qu'il contient est toujours en cours d'exécution
3. Si la tâche n'est pas en cours d'exécution, il crée un fichier de verrouillage avec son propre identifiant de processus
4. Il met en place un piège pour supprimer le fichier de verrouillage lorsque le script se termine
5. Une fois la tâche terminée, il supprime le fichier de verrouillage

En utilisant ces méthodes, vous pouvez empêcher les exécutions simultanées de vos tâches cron sans dépendre d'outils externes comme flock.

#!/bin/bash

FICHIER_VERROU="/tmp/matache.lock"
DELAI=3600 # délai d'attente de 1 heure

if [ -e ${FICHIER_VERROU} ]; then
    pid=$(cat ${FICHIER_VERROU})
    if ps -p $pid > /dev/null 2>&1; then
        duree_execution=$(($(date +%s) - $(stat -c %Y ${FICHIER_VERROU})))
        if [ $duree_execution -gt $DELAI ]; then
            echo "La tâche s'exécute depuis plus de $DELAI secondes. Arrêt en cours."
            kill $pid
            rm -f ${FICHIER_VERROU}
        else
            echo "La tâche est déjà en cours d'exécution"
            exit 1
        fi
    fi
fi

trap "rm -f ${FICHIER_VERROU}; exit" INT TERM EXIT
echo $$ > ${FICHIER_VERROU}

# Votre code de tâche ici

rm -f ${FICHIER_VERROU}