Module Script Ansible

Introduction

Dans ce laboratoire, vous allez apprendre à utiliser le module Script Ansible pour exécuter des scripts personnalisés sur des hôtes distants. Le module Script vous permet d'exécuter des scripts écrits dans n'importe quel langage de programmation sur les hôtes cibles, offrant ainsi des options de flexibilité et de personnalisation dans vos tâches d'automatisation.

Skills Graph

Exécuter un script simple

Dans cette étape, vous allez exécuter un script simple sur un hôte distant à l'aide du module Script Ansible.

Tout d'abord, créez un nouveau fichier de playbook Ansible appelé /home/labex/project/script-module-playbook.yaml et ouvrez-le dans un éditeur de texte.
Ajoutez le contenu suivant au fichier de playbook :

- hosts: localhost
  tasks:
    - name: Exécuter un script simple
      script: /home/labex/project/simple_script.sh
      register: script_output

    - name: Afficher la sortie du script
      debug:
        var: script_output.stdout_lines

• hosts : Cela spécifie l'hôte cible sur lequel exécuter le playbook. Dans ce cas, le playbook sera exécuté sur l'hôte local car l'hôte cible est "localhost".
• tasks : Il s'agit d'une liste de tâches à exécuter.
• name : C'est le nom descriptif de la tâche qui identifie le but de la tâche.
• script : C'est la commande réelle que la tâche exécute. Elle indique à Ansible d'exécuter le script nommé "simple_script.sh" situé dans le répertoire "/home/labex/project/" sur l'hôte cible.
• register : Cela enregistre la sortie du script dans la variable script_output pour une utilisation ultérieure dans le playbook.
• debug : C'est le module Ansible utilisé pour afficher des informations de débogage.
• var : C'est un paramètre du module debug qui affiche la sortie standard du script de la tâche précédente. script_output.stdout_lines contient chaque ligne de la sortie du script.

En résumé, le principal but de ce playbook est d'exécuter un script sur l'hôte local et d'afficher la sortie standard du script après son exécution. La variable enregistrée script_output contient la sortie du script, qui est ensuite affichée à l'aide du module Debug.

Ensuite, créez un fichier de script simple appelé /home/labex/project/simple_script.sh avec le contenu suivant :

#!/bin/bash
echo "This is a simple script."

Assurez-vous que le fichier de script est exécutable (chmod +x simple_script.sh) et placez le fichier de script dans le répertoire /home/labex/project/ spécifié dans le playbook.

Enfin, exécutez le playbook avec la commande suivante :

chmod +x simple_script.sh
ansible-playbook script-module-playbook.yaml

Observez la sortie du script affichée dans la sortie d'exécution du playbook.
Exemple de sortie :

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

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

TASK [Execute a simple script] *************************************************
changed: [localhost]

TASK [Display script output] ***************************************************
ok: [localhost] => {
    "script_output.stdout_lines": [
        "This is a simple script."
    ]
}

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

Ici, "This is a simple script." est la sortie du script simple_script.sh.

Passer des variables à des scripts

Dans cette étape, vous allez apprendre à passer des variables de votre playbook Ansible à des scripts exécutés à l'aide du module Script.

Tout d'abord, modifiez le fichier de playbook existant en supprimant tout le contenu et en ajoutant le contenu suivant au fichier de playbook :

- hosts: localhost
  tasks:
    - name: Exécuter un script avec une variable
      script: /home/labex/project/var_script.sh "{{ message }}"
      register: variable_script_output

    - name: Afficher la sortie du script avec variable
      debug:
        var: variable_script_output.stdout_lines

• script : C'est la commande réelle que la tâche exécutera. Et {{ message }} est une variable qui est passée au script. Les doubles accolades indiquent qu'il s'agit d'une variable Ansible, et sa valeur sera remplacée dynamiquement pendant l'exécution.
• register : Cela enregistre la sortie du script dans la variable "variable_script_output" pour une utilisation ultérieure dans le playbook.
• debug : C'est le module Ansible utilisé pour afficher des informations de débogage.
• var : Ce paramètre du module debug affiche la sortie standard du script de la tâche précédente. variable_script_output.stdout_lines contient chaque ligne de la sortie du script.

En résumé, ce playbook exécute un script sur l'hôte local, en passant une variable appelée "message" au script. La sortie du script est enregistrée dans la variable variable_script_output, puis elle est affichée à l'aide du module debug.

Ensuite, créez un fichier de script simple appelé /home/labex/project/var_script.sh avec le contenu suivant :

#!/bin/bash
echo $1

Assurez-vous que le fichier de script est exécutable (chmod +x var_script.sh) et placez le fichier de script dans le répertoire /home/labex/project/ spécifié dans le playbook.

Enfin, en passant la variable message en tant que variable supplémentaire en utilisant l'option -e lors de l'exécution du playbook.

chmod +x var_script.sh
ansible-playbook script-module-playbook.yaml -e "message=Hello,Ansible"

Observez la sortie du script avec le message fourni.
Exemple de sortie :

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

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

TASK [Execute script with a variable] ******************************************
changed: [localhost]

TASK [Display variable script output] ******************************************
ok: [localhost] => {
    "variable_script_output.stdout_lines": [
        "Hello,Ansible"
    ]
}

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

Ici, "Hello,Ansible" est la sortie du script simple_script.sh.

Gérer l'échec d'un script

Dans cette étape, vous allez apprendre à gérer l'échec d'un script lors de son exécution à l'aide du module Script. Vous allez gérer les cas où le script renvoie un statut de sortie non nul, indiquant un échec.

Tout d'abord, modifiez le fichier de playbook existant en supprimant tout le contenu et en ajoutant le contenu suivant au fichier de playbook :

- hosts: localhost
  tasks:
    - name: Exécuter un script qui échoue
      script: /home/labex/project/failing_script.sh
      register: failing_script_output
      ignore_errors: yes

    - name: Gérer l'échec du script
      debug:
        msg: "Le script a échoué. Exécution d'une action de secours."
      when: failing_script_output.failed

• script : C'est la commande réelle que la tâche exécutera.
• register : Cela enregistre la sortie du script dans la variable "failing_script_output" pour une utilisation ultérieure dans le playbook.
• ignore_errors : Ce paramètre est défini sur yes pour permettre à Ansible de continuer à exécuter les tâches suivantes même si cette tâche de script échoue. L'échec sera enregistré dans la variable failing_script_output.
• debug : C'est le module Ansible utilisé pour afficher des informations de débogage.
• msg : Ce paramètre du module debug affiche un message indiquant que le script a échoué. Cette tâche ne sera exécutée que lorsque la tâche précédente (failing_script_output) a échoué.
• when : Cette condition assure que cette tâche n'est exécutée que lorsque le script dans la première tâche a échoué. Si le script réussit, cette tâche sera ignorée.

En résumé, ce playbook tente d'exécuter un script qui peut échouer. Si le script échoue, le playbook gère l'échec en affichant un message de débogage et en exécutant une action de secours. Le paramètre ignore_errors: yes permet au playbook de continuer même si le script échoue, et la condition when: failing_script_output.failed assure que la tâche de gestion n'est exécutée que lorsqu'elle est nécessaire.

Ensuite, créez un fichier de script qui échoue appelé /home/labex/project/failing_script.sh avec le contenu suivant :

#!/bin/bash
exit 1

Assurez-vous que le fichier de script est exécutable (chmod +x failing_script.sh) et placez le fichier de script dans le répertoire /home/labex/project/ spécifié dans le playbook.

Enfin, exécutez le playbook et observez que le script qui échoue est exécuté mais ignoré en raison de ignore_errors: yes.

chmod +x failing_script.sh
ansible-playbook script-module-playbook.yaml

Le playbook affichera un message de débogage indiquant l'échec et exécutera une action de secours.
Exemple de sortie :

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

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

TASK [Execute a failing script] ************************************************
fatal: [localhost]: FAILED! => {"changed": true, "msg": "non-zero return code", "rc": 1, "stderr": "", "stderr_lines": [], "stdout": "", "stdout_lines": []}
...ignoring

TASK [Handle script failure] ***************************************************
ok: [localhost] => {
    "msg": "Le script a échoué. Exécution d'une action de secours."
}

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

Le "msg": "Le script a échoué. Exécution d'une action de secours." indique que le script failing_script.sh a échoué lors de son exécution.

Sommaire

Félicitations ! Vous avez réussi à terminer le laboratoire sur le module Script Ansible. Vous avez appris à utiliser le module Script pour exécuter des scripts personnalisés sur des hôtes distants, passer des variables à des scripts et gérer les échecs de scripts.

Le module Script offre une grande flexibilité et des options de personnalisation dans vos tâches d'automatisation en vous permettant de tirer parti de la puissance des scripts personnalisés. Cependant, assurez-vous d'écrire des scripts sécurisés et fiables et de valider tout input pour prévenir les vulnérabilités de sécurité.

Maintenant que vous comprenez bien le module Script, vous pouvez l'intégrer à vos playbooks Ansible pour automatiser diverses tâches et réaliser des scénarios d'automatisation plus avancés. Bonne programmation avec Ansible !