Module Ansible Cron

AnsibleAnsibleBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Bienvenue dans le laboratoire (lab) sur le module Ansible Cron ! Dans ce lab, vous apprendrez à automatiser la planification de tâches en utilisant le module Ansible Cron. Le système cron est un planificateur de tâches basé sur le temps dans les systèmes d'exploitation de type Unix qui permet aux utilisateurs de planifier des commandes ou des scripts pour qu'ils s'exécutent automatiquement à des moments ou des intervalles spécifiés.

Au cours de ce lab, vous apprendrez à utiliser Ansible pour créer, gérer et supprimer des tâches cron. Les exercices progressent d'une configuration simple à des configurations plus complexes, vous permettant de développer progressivement vos compétences avec le module Ansible Cron. À la fin de ce lab, vous aurez acquis une expérience pratique de la planification de tâches de manière cohérente et automatisée en utilisant Ansible.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL ansible(("Ansible")) -.-> ansible/ModuleOperationsGroup(["Module Operations"]) ansible(("Ansible")) -.-> ansible/PlaybookEssentialsGroup(["Playbook Essentials"]) ansible/ModuleOperationsGroup -.-> ansible/cron("Schedule Tasks") ansible/ModuleOperationsGroup -.-> ansible/shell("Execute Shell Commands") ansible/PlaybookEssentialsGroup -.-> ansible/playbook("Execute Playbook") subgraph Lab Skills ansible/cron -.-> lab-290157{{"Module Ansible Cron"}} ansible/shell -.-> lab-290157{{"Module Ansible Cron"}} ansible/playbook -.-> lab-290157{{"Module Ansible Cron"}} end

Créer une tâche cron simple

Dans cette étape, vous allez créer votre première tâche cron en utilisant le module Ansible Cron. La tâche cron exécutera un simple script shell à intervalles réguliers.

Comprendre le fonctionnement de cron

Avant de commencer, comprenons ce qu'est cron. Cron est un planificateur de tâches basé sur le temps dans les systèmes d'exploitation de type Unix qui permet aux utilisateurs de planifier des commandes ou des scripts pour qu'ils s'exécutent automatiquement à des moments ou des intervalles spécifiés. Les tâches cron sont utiles pour automatiser les tâches de maintenance système, les sauvegardes ou toute tâche récurrente.

Création du playbook Ansible

Tout d'abord, vous devez créer un playbook Ansible qui configurera la tâche cron. Dans le WebIDE, créez un nouveau fichier au chemin /home/labex/project/cron_module_playbook.yaml en cliquant sur le bouton "New File" dans le panneau de l'explorateur de fichiers.

New File

Entrez le contenu suivant dans le fichier :

- hosts: localhost
  tasks:
    - name: Create a simple cron job
      cron:
        name: my_cron_job
        minute: "*/5"
        job: /home/labex/project/script.sh

Examinons chaque partie de ce playbook :

  • hosts: localhost - Cela spécifie que le playbook sera exécuté sur la machine locale.
  • tasks - Cette section contient la liste des tâches à exécuter.
  • cron - C'est le module Ansible utilisé pour gérer les tâches cron.
  • name: my_cron_job - Cela attribue un nom descriptif à la tâche cron, facilitant son identification dans le fichier crontab.
  • minute: "*/5" - Cela planifie l'exécution de la tâche toutes les 5 minutes. La syntaxe */5 signifie "toute minute divisible par 5" (0, 5, 10, 15, etc.).
  • job: /home/labex/project/script.sh - Cela spécifie la commande ou le script à exécuter par la tâche cron.

Création du script shell

Maintenant, vous devez créer le script shell que la tâche cron exécutera. Créez un nouveau fichier au chemin /home/labex/project/script.sh dans le WebIDE.

Entrez le contenu suivant dans le fichier de script :

#!/bin/bash
echo "This is a simple script." >> /home/labex/project/cron_output.log
date >> /home/labex/project/cron_output.log

Ce simple script ajoutera un message et la date actuelle à un fichier journal à chaque exécution.

Rendre le script exécutable

Avant d'exécuter le playbook, vous devez rendre le script exécutable. Ouvrez un terminal dans le WebIDE et exécutez la commande suivante :

chmod +x /home/labex/project/script.sh

Exécution du playbook Ansible

Maintenant, exécutez le playbook Ansible pour créer la tâche cron. Dans le terminal, exécutez la commande suivante :

cd /home/labex/project
ansible-playbook cron_module_playbook.yaml

Vous devriez voir une sortie similaire à ceci :

[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that
the implicit localhost does not match 'all'

PLAY [localhost] ***************************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Create a simple cron job] ************************************************
changed: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

La ligne changed: [localhost] indique que la tâche cron a été créée avec succès.

Vérification de la tâche cron

Pour vérifier que la tâche cron a été créée, vérifiez le fichier crontab sur le système avec la commande suivante :

crontab -l

Vous devriez voir une sortie similaire à ceci :

#Ansible: my_cron_job
*/5 * * * * /home/labex/project/script.sh

La ligne #Ansible: my_cron_job est un commentaire ajouté par Ansible pour identifier la tâche cron. La partie */5 * * * * représente la planification (toutes les 5 minutes), et /home/labex/project/script.sh est la commande à exécuter.

Félicitations ! Vous avez créé avec succès une tâche cron en utilisant le module Ansible Cron. La tâche exécutera le script toutes les 5 minutes.

Planifier une tâche à une heure personnalisée

Dans cette étape, vous apprendrez à planifier une tâche cron pour qu'elle s'exécute à un moment précis plutôt qu'à intervalles réguliers. Cela est utile pour les tâches qui doivent être exécutées à des moments particuliers de la journée, telles que les sauvegardes, le traitement de données ou la génération de rapports.

Comprendre le format de temps de cron

Le format de temps de cron se compose de cinq champs, représentant :

  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, où 0 et 7 représentent le dimanche)

Lorsque vous spécifiez une valeur pour chaque champ, la tâche cron s'exécutera lorsque toutes les conditions seront remplies. Par exemple, 0 9 * * * signifie "s'exécuter à 9h00 tous les jours" (minute 0 de l'heure 9, n'importe quel jour du mois, n'importe quel mois, n'importe quel jour de la semaine).

Modification du playbook Ansible

Maintenant, modifions le playbook existant pour créer une nouvelle tâche cron qui s'exécute à un moment précis. Ouvrez le fichier /home/labex/project/cron_module_playbook.yaml dans le WebIDE et remplacez son contenu par le suivant :

- hosts: localhost
  tasks:
    - name: Schedule a task with custom time
      cron:
        name: custom_cron_job
        minute: "0"
        hour: "9"
        job: /home/labex/project/script.sh

Les modifications apportées à ce playbook incluent :

  • name: custom_cron_job - Nous créons une nouvelle tâche cron avec un nom différent.
  • minute: "0" - Cela configure la tâche pour qu'elle s'exécute à la minute 0 (au début de l'heure).
  • hour: "9" - Cela configure la tâche pour qu'elle s'exécute à 9 heures.

Les autres champs (jour du mois, mois, jour de la semaine) ne sont pas spécifiés, ce qui signifie qu'ils prennent la valeur par défaut * (n'importe quelle valeur). Ainsi, cette tâche s'exécutera à 9h00 tous les jours.

Exécution du playbook modifié

Maintenant, exécutez le playbook Ansible modifié pour créer la nouvelle tâche cron. Dans le terminal, exécutez la commande suivante :

cd /home/labex/project
ansible-playbook cron_module_playbook.yaml

Vous devriez voir une sortie similaire à ceci :

[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that
the implicit localhost does not match 'all'

PLAY [localhost] ***************************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Schedule a task with custom time] ****************************************
changed: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Vérification de la nouvelle tâche cron

Pour vérifier que la nouvelle tâche cron a été créée, vérifiez le fichier crontab sur le système :

crontab -l

Vous devriez maintenant voir deux tâches cron dans la sortie :

#Ansible: my_cron_job
*/5 * * * * /home/labex/project/script.sh
#Ansible: custom_cron_job
0 9 * * * /home/labex/project/script.sh

La première tâche est celle que vous avez créée à l'Étape 1, qui s'exécute toutes les 5 minutes. La deuxième tâche est la nouvelle que vous venez de créer, qui s'exécute à 9h00 tous les jours.

Exemples supplémentaires de planification cron

Voici quelques exemples supplémentaires de planification cron pour vous aider à mieux comprendre le format de temps :

  • 0 * * * * - S'exécuter au début de chaque heure
  • 0 0 * * * - S'exécuter à minuit tous les jours
  • 0 0 1 * * - S'exécuter à minuit le premier jour de chaque mois
  • 0 0 * * 0 - S'exécuter à minuit tous les dimanches
  • 0 12 * * 1-5 - S'exécuter à midi les jours de semaine (du lundi au vendredi)

Comprendre ces modèles vous aidera à planifier vos tâches plus efficacement en utilisant le module Ansible Cron.

Félicitations ! Vous avez réussi à planifier une tâche cron pour qu'elle s'exécute à un moment précis en utilisant le module Ansible Cron.

S'assurer qu'une tâche cron s'exécute en tant qu'un utilisateur spécifique

Dans cette étape, vous apprendrez à spécifier l'utilisateur sous lequel une tâche cron doit s'exécuter. C'est un aspect important de l'administration système et de la sécurité, car cela vous permet de contrôler les autorisations et l'environnement dans lequel les tâches planifiées s'exécutent.

Comprendre le contexte utilisateur pour les tâches cron

Dans les systèmes de type Unix, les tâches cron héritent des autorisations et de l'environnement de l'utilisateur qui les possède. Cela signifie :

  1. La tâche ne peut accéder qu'aux fichiers et aux ressources auxquels l'utilisateur a l'autorisation d'accéder.
  2. La tâche s'exécute avec les variables d'environnement et les paramètres de l'utilisateur.
  3. Tous les fichiers créés par la tâche seront appartenant à l'utilisateur.

Par défaut, lorsque vous utilisez le module Ansible Cron sans spécifier d'utilisateur, la tâche cron est créée pour l'utilisateur exécutant le playbook Ansible. Cependant, vous pouvez explicitement définir un utilisateur différent avec le paramètre user.

Modification du playbook Ansible

Modifions notre playbook pour spécifier que la tâche cron doit s'exécuter en tant que l'utilisateur labex. Ouvrez le fichier /home/labex/project/cron_module_playbook.yaml dans le WebIDE et remplacez son contenu par le suivant :

- hosts: localhost
  tasks:
    - name: Schedule a task with custom time for specific user
      cron:
        name: custom_cron_job
        minute: "0"
        hour: "9"
        job: /home/labex/project/script.sh
        user: labex

L'ajout clé ici est :

  • user: labex - Ce paramètre spécifie que la tâche cron doit être créée pour l'utilisateur labex.

Même si nous sommes déjà en train d'exécuter le playbook en tant que l'utilisateur labex dans cet environnement, le fait de le spécifier explicitement est une bonne pratique pour la clarté et la portabilité de vos playbooks dans d'autres environnements.

Exécution du playbook modifié

Maintenant, exécutez le playbook Ansible modifié pour mettre à jour la tâche cron. Dans le terminal, exécutez la commande suivante :

cd /home/labex/project
ansible-playbook cron_module_playbook.yaml

Vous devriez voir une sortie similaire à ceci :

[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that
the implicit localhost does not match 'all'

PLAY [localhost] ***************************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Schedule a task with custom time for specific user] **********************
ok: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Notez que la sortie affiche ok au lieu de changed. C'est parce que la tâche cron existe déjà, et la seule modification est le paramètre utilisateur qui, dans ce cas, est déjà correct (puisque nous exécutons le playbook en tant que l'utilisateur labex depuis le début).

Vérification de la tâche cron

Pour vérifier que la tâche cron est toujours correctement configurée, vérifiez le fichier crontab :

crontab -l

Vous devriez voir une sortie similaire à :

#Ansible: my_cron_job
*/5 * * * * /home/labex/project/script.sh
#Ansible: custom_cron_job
0 9 * * * /home/labex/project/script.sh

Affichage des tâches cron pour un utilisateur spécifique

Si vous souhaitez voir les tâches cron pour un utilisateur spécifique, vous pouvez utiliser l'option -u avec la commande crontab :

sudo crontab -u labex -l

Cette commande affiche toutes les tâches cron planifiées pour l'utilisateur labex. Dans un environnement de production, vous pourriez avoir différentes tâches cron s'exécutant en tant que différents utilisateurs en fonction des niveaux d'accès et des autorisations nécessaires pour chaque tâche.

Considérations de sécurité

Lors de la planification de tâches cron pour différents utilisateurs, tenez compte des pratiques de sécurité suivantes :

  1. Utilisez le principe du moindre privilège - attribuez les tâches cron à des utilisateurs ayant seulement les autorisations nécessaires pour effectuer leurs tâches.
  2. Évitez de planifier des tâches en tant que l'utilisateur root sauf si cela est absolument nécessaire.
  3. Assurez-vous que les scripts exécutés par les tâches cron ont les autorisations appropriées et la gestion des erreurs adéquate.
  4. Pensez à utiliser des outils de gestion de configuration comme Ansible pour maintenir des paramètres de tâches cron cohérents dans votre infrastructure.

Félicitations ! Vous avez réussi à configurer une tâche cron pour qu'elle s'exécute en tant qu'un utilisateur spécifique en utilisant le module Ansible Cron. Cette compétence vous aidera à gérer les tâches système de manière plus sécurisée et plus efficace.

Supprimer une tâche cron

Dans cette étape, vous apprendrez à supprimer les tâches cron indésirables en utilisant le module Ansible Cron. Gérer le cycle de vie complet des tâches cron est une compétence importante pour les administrateurs systèmes et les ingénieurs DevOps.

Pourquoi supprimer des tâches cron

Il existe plusieurs raisons pour lesquelles vous pourriez avoir besoin de supprimer des tâches cron :

  1. La tâche planifiée n'est plus nécessaire.
  2. Vous souhaitez remplacer une tâche existante par une nouvelle configuration.
  3. Vous devez nettoyer le système pour améliorer sa maintenabilité.
  4. La tâche doit être temporairement désactivée.

Ansible facilite la suppression des tâches cron de manière systématique et reproductible dans toute votre infrastructure.

Comprendre le paramètre state

Le module Ansible Cron utilise le paramètre state pour contrôler si une tâche cron doit être présente ou absente :

  • state: present - C'est la valeur par défaut. Elle garantit que la tâche cron existe avec la configuration spécifiée.
  • state: absent - Elle garantit que la tâche cron n'existe pas, la supprimant si elle a été créée précédemment.

Modification du playbook Ansible

Modifions notre playbook pour supprimer la première tâche cron que nous avons créée (nommée my_cron_job). Ouvrez le fichier /home/labex/project/cron_module_playbook.yaml dans le WebIDE et remplacez son contenu par le suivant :

- hosts: localhost
  tasks:
    - name: Remove the cron job
      cron:
        name: my_cron_job
        state: absent

Les éléments clés de ce playbook sont :

  • name: my_cron_job - Cela identifie la tâche cron à supprimer par son nom.
  • state: absent - Cela indique à Ansible de s'assurer que la tâche cron n'existe pas.

Notez que nous n'avons besoin que de spécifier le nom de la tâche cron pour l'identifier pour la suppression. Les autres paramètres (comme minute, heure, tâche, etc.) ne sont pas nécessaires.

Exécution du playbook modifié

Maintenant, exécutez le playbook Ansible modifié pour supprimer la tâche cron. Dans le terminal, exécutez la commande suivante :

cd /home/labex/project
ansible-playbook cron_module_playbook.yaml

Vous devriez voir une sortie similaire à ceci :

[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that
the implicit localhost does not match 'all'

PLAY [localhost] ***************************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Remove the cron job] *****************************************************
changed: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

La ligne changed: [localhost] indique que la tâche cron a été supprimée avec succès.

Vérification de la suppression de la tâche cron

Pour vérifier que la tâche cron a été supprimée, vérifiez le fichier crontab sur le système :

crontab -l

Vous devriez maintenant voir seulement la deuxième tâche cron dans la sortie :

#Ansible: custom_cron_job
0 9 * * * /home/labex/project/script.sh

L'entrée my_cron_job a été supprimée, comme demandé dans notre playbook.

Idempotence dans Ansible

L'une des fonctionnalités clés d'Ansible est l'idempotence - la propriété selon laquelle l'application de la même opération plusieurs fois donne le même résultat que l'application une seule fois. Cela est particulièrement utile pour des tâches telles que la suppression de tâches cron.

Exécutons le playbook à nouveau pour démontrer cela :

ansible-playbook cron_module_playbook.yaml

Vous devriez voir une sortie similaire à :

[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that
the implicit localhost does not match 'all'

PLAY [localhost] ***************************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Remove the cron job] *****************************************************
ok: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Notez que la deuxième fois, la sortie affiche ok au lieu de changed pour la tâche de suppression. C'est parce que la tâche cron avait déjà été supprimée, donc aucune modification n'était nécessaire.

Gestion de plusieurs tâches cron

Dans des scénarios réels, vous pourriez avoir besoin de gérer plusieurs tâches cron dans un seul playbook. Vous pouvez inclure plusieurs tâches cron, chacune avec sa propre configuration :

- hosts: localhost
  tasks:
    - name: Remove first cron job
      cron:
        name: job1
        state: absent

    - name: Create second cron job
      cron:
        name: job2
        minute: "0"
        hour: "12"
        job: /path/to/script.sh

    - name: Update third cron job
      cron:
        name: job3
        minute: "*/10"
        job: /path/to/another/script.sh

Cette approche vous permet de gérer le cycle de vie complet de toutes vos tâches cron dans un seul playbook contrôlé par version.

Félicitations ! Vous avez appris avec succès à supprimer des tâches cron en utilisant le module Ansible Cron. Cela achève la gestion de base du cycle de vie des tâches cron : création, modification et suppression.

Résumé

Félicitations pour avoir terminé le laboratoire (Lab) sur le module Ansible Cron ! Tout au long de ce laboratoire, vous avez acquis une expérience pratique sur plusieurs aspects clés de la gestion des tâches planifiées à l'aide d'Ansible :

  1. Création de tâches cron simples qui s'exécutent à intervalles réguliers.
  2. Planification de tâches pour qu'elles s'exécutent à des moments spécifiques en utilisant des expressions de temps cron personnalisées.
  3. Vérification que les tâches cron s'exécutent en tant qu'utilisateurs spécifiques pour une gestion appropriée de la sécurité et des autorisations.
  4. Suppression des tâches cron qui ne sont plus nécessaires.

Ces compétences sont essentielles pour automatiser les tâches d'administration système, les opérations de maintenance et les processus récurrents dans tout environnement Linux. En utilisant Ansible pour gérer vos tâches cron, vous bénéficiez de :

  • Une configuration cohérente sur plusieurs systèmes.
  • Le contrôle de version de vos emplois du temps de tâches.
  • Des opérations idempotentes qui peuvent être appliquées plusieurs fois.
  • Le déploiement et la gestion automatisés des tâches planifiées.

Au fur et à mesure que vous continuerez à travailler avec Ansible, envisagez d'explorer des fonctionnalités plus avancées du module Cron, telles que :

  • La définition de variables d'environnement pour les tâches cron.
  • L'utilisation de spécifications de temps spéciales comme @daily ou @reboot.
  • La combinaison de la gestion des tâches cron avec d'autres modules Ansible pour des solutions d'automatisation complètes.

La capacité à gérer efficacement les tâches planifiées est une compétence précieuse qui vous sera très utile dans l'administration système, le DevOps et d'autres rôles informatiques.