Module Ansible Shell

Introduction

Dans ce laboratoire (lab), vous apprendrez à utiliser le module Ansible Shell pour exécuter des commandes shell sur des hôtes distants. Le module Shell est utile lorsque vous avez besoin d'exécuter des commandes shell qui ne sont pas couvertes par les modules Ansible existants ou lorsque vous avez besoin d'une plus grande flexibilité et de contrôle sur l'exécution.

Exécuter une commande shell simple

Dans cette étape, vous exécuterez une commande shell simple sur un hôte distant en utilisant le module Ansible Shell.

Tout d'abord, complétez le fichier /home/labex/project/simple_shell_command.yml. Ajoutez le contenu suivant au fichier de playbook :

- name: Execute a Simple Shell Command
  hosts: localhost
  gather_facts: false

  tasks:
    - name: Execute ls -l command
      shell: ls -l
      register: command_output

    - name: Display command output
      debug:
        var: command_output.stdout_lines

• hosts: localhost : L'hôte cible pour l'exécution de ce playbook Ansible est localhost.
• gather_facts: false : Désactive la collecte d'informations sur l'hôte.
• shell: ls -l : Spécifie la commande à exécuter.

En résumé, le but de ce playbook est d'exécuter la commande ls -l sur l'hôte local et d'afficher la sortie de la commande.

Ensuite, affichez la sortie de la commande dans le playbook Ansible.

ansible-playbook /home/labex/project/simple_shell_command.yml

Exemple de sortie :

[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 [Execute a Simple Shell Command] ******************************************

TASK [Execute ls -l command] ***************************************************
changed: [localhost]

TASK [Display command output] **************************************************
ok: [localhost] => {
    "command_output.stdout_lines": [
        "total 16",
        "-rwxrwxrwx 1 labex root 285 Mar  8 13:33 complex_shell_commands.yml",
        "-rwxrwxrwx 1 labex root 221 Mar  8 13:33 handle_command_failure.yml",
        "-rwxrwxrwx 1 labex root 222 Mar  8 13:33 pass_variables.yml",
        "-rwxrwxrwx 1 labex root 266 Mar  8 13:36 simple_shell_command.yml"
    ]
}

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

Ici, "command_output.stdout_lines": [...] est la sortie de la commande ls -l sur l'hôte cible.

Passer des variables aux commandes shell

Dans cette étape, vous apprendrez à passer des variables de votre playbook Ansible aux commandes shell exécutées à l'aide du module Shell.

Tout d'abord, complétez le fichier /home/labex/project/pass_variables.yml. Ajoutez le contenu suivant au fichier de playbook :

- name: Pass Variables to Shell Commands
  hosts: localhost
  gather_facts: false
  vars:
    directory_path: /home/labex

  tasks:
    - name: Execute ls command with a variable
      shell: ls "{{ directory_path }}"
      register: variable_command_output

    - name: Display variable command output
      debug:
        var: variable_command_output.stdout_lines

• hosts: localhost : L'hôte cible pour l'exécution de ce playbook Ansible est localhost.
• vars : Définit une variable nommée directory_path avec la valeur /home/labex.
• shell: ls "{{ directory_path }}" : Exécute la commande ls pour afficher le contenu du répertoire représenté par la variable directory_path.

En résumé, ce playbook exécute la commande ls avec une variable représentant un chemin de répertoire (/home/labex) sur l'hôte local et affiche la sortie de la commande.

Ensuite, affichez la sortie de la commande dans le playbook Ansible.

ansible-playbook /home/labex/project/pass_variables.yml

Exemple de sortie :

[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 [Pass Variables to Shell Commands] ****************************************

TASK [Execute ls command with a variable] **************************************
changed: [localhost]

TASK [Display variable command output] *****************************************
ok: [localhost] => {
    "variable_command_output.stdout_lines": [
        "Code",
        "Desktop",
        "golang",
        "project"
    ]
}

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

Ici, "variable_command_output.stdout_lines": [...] est la sortie de la commande ls /home/labex sur l'hôte cible.

Gérer les échecs de commande

Dans cette étape, vous apprendrez à gérer les échecs de commande lors de l'exécution de commandes shell à l'aide du module Shell. Vous allez gérer les cas où la commande shell retourne un code de sortie non nul, indiquant un échec.

Tout d'abord, complétez le fichier /home/labex/project/handle_command_failure.yml. Ajoutez le contenu suivant au fichier de playbook :

- name: Handle Command Failure
  hosts: localhost
  gather_facts: false

  tasks:
    - name: Execute a failing command
      shell: failing-command
      register: failing_command_output
      ignore_errors: yes

    - name: Handle command failure
      debug:
        msg: "The command failed. Performing fallback action."
      when: failing_command_output.failed

• hosts: localhost : L'hôte cible pour l'exécution de ce playbook Ansible est localhost.
• shell: failing-command : Cette ligne utilise le module shell pour exécuter la commande failing-command. La sortie de cette commande sera capturée et stockée dans la variable failing_command_output. Étant donné que le script failing-command n'existe pas, cette commande doit échouer.
• ignore_errors: yes : Cette ligne indique à Ansible d'ignorer toutes les erreurs qui se produisent lors de l'exécution de la commande failing-command. Cela permet au playbook de continuer à s'exécuter même si la commande échoue.
• debug : Ce module utilise le module debug pour afficher un message indiquant "The command failed. Performing fallback action." Ce message n'est affiché que lorsque la condition failing_command_output.failed est remplie, indiquant que l'exécution de la commande précédente a échoué.

En résumé, le playbook tente d'exécuter une commande qui devrait échouer, ignore toutes les erreurs qui se produisent lors de son exécution, puis affiche un message indiquant que la commande a échoué et qu'une action de secours sera entreprise en fonction de l'état d'échec de la commande.

Ensuite, affichez la sortie de la commande dans le playbook Ansible.

ansible-playbook /home/labex/project/handle_command_failure.yml

Exemple de sortie :

[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 [Handle Command Failure] **************************************************

TASK [Execute a failing command] ***********************************************
fatal: [localhost]: FAILED! => {"changed": true, "cmd": "failing-command", "delta": "0:00:00.009169", "end": "2024-03-08 13:46:22.701946", "msg": "non-zero return code", "rc": 127, "start": "2024-03-08 13:46:22.692777", "stderr": "/bin/sh: line 1: failing-command: command not found", "stderr_lines": ["/bin/sh: line 1: failing-command: command not found"], "stdout": "", "stdout_lines": []}
...ignoring

TASK [Handle command failure] **************************************************
ok: [localhost] => {
    "msg": "The command failed. Performing fallback action."
}

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

La présence de "msg": "The command failed. Performing fallback action." indique que l'exécution de la commande failing-command a échoué.

Exécuter des commandes shell complexes

Dans cette étape, vous exécuterez des commandes shell plus complexes en utilisant le module Shell. Vous explorerez l'utilisation de la redirection de commandes, des pipelines et de structures de commandes complexes.

Tout d'abord, complétez le fichier /home/labex/project/complex_shell_commands.yml. Ajoutez le contenu suivant au fichier de playbook :

- name: Execute Complex Shell Commands
  hosts: localhost
  gather_facts: false

  tasks:
    - name: Execute complex command
      shell: ls -l /home/labex | grep 'project' > /home/labex/output.txt
      register: complex_command_output

    - name: Display complex command output
      debug:
        var: complex_command_output.stdout_lines

• hosts: localhost : L'hôte cible pour l'exécution de ce playbook Ansible est localhost.
• shell : Redirige la sortie de la commande ls -l /home/labex vers le fichier /home/labex/output.txt et utilise grep pour filtrer le contenu concernant project.

En résumé, ce playbook exécute une commande shell complexe sur l'hôte local, filtre et redirige la sortie dans un fichier, puis affiche la sortie de l'exécution de la commande.

Ensuite, exécutez la commande du playbook Ansible.

ansible-playbook /home/labex/project/complex_shell_commands.yml

Exemple de sortie :

[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 [Execute Complex Shell Commands] ******************************************

TASK [Execute complex command] *************************************************
changed: [localhost]

TASK [Display complex command output] ******************************************
ok: [localhost] => {
    "complex_command_output.stdout_lines": []
}

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

Enfin, affichez le contenu du fichier /home/labex/output.txt :

cat /home/labex/output.txt

Exemple de sortie :

drwxr-xr-x 1 labex labex 4096 Mar 8 13:49 project

Résumé

Félicitations! Vous avez réussi le laboratoire sur le module Ansible Shell. Vous avez appris à utiliser le module Shell pour exécuter des commandes shell sur des hôtes distants, à passer des variables aux commandes, à gérer les échecs de commandes et à exécuter des commandes shell complexes.

Le module Shell offre une grande flexibilité et un contrôle précis pour exécuter des commandes shell dans vos playbooks Ansible. Cependant, soyez prudent lors de son utilisation, car l'exécution de commandes shell arbitraires peut avoir des implications en matière de sécurité. Assurez-vous toujours de faire confiance aux commandes et de nettoyer toutes les entrées fournies par l'utilisateur.

Maintenant que vous avez une bonne compréhension du module Shell, vous pouvez l'utiliser pour effectuer diverses tâches d'automatisation et gérer efficacement vos hôtes distants. Bonne programmation avec Ansible!