Module d'action locale Ansible

Introduction

Bienvenue dans le Lab du module d'action locale Ansible! Dans ce lab, vous allez plonger dans l'utilisation du module d'action locale Ansible. Le module d'action locale vous permet d'exécuter des tâches sur la machine de contrôle où Ansible est exécuté. Cela est utile lorsque vous avez besoin d'effectuer des opérations localement, telles que l'exécution de commandes shell ou l'exécution de scripts.

Commençons!

Skills Graph

Exécution d'une commande simple localement

Dans cette étape, vous allez apprendre à utiliser le module d'action locale Ansible pour exécuter une commande simple sur la machine de contrôle. Cela vous aidera à comprendre l'utilisation de base et la syntaxe du module.

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

- name: Exécution d'une commande simple localement
  gather_facts: false
  hosts: localhost

  tasks:
    - name: Afficher un message localement
      local_action:
        module: command
        cmd: echo "Hello, World!"
      register: result

    - name: Déboguer la sortie
      debug:
        var: result.stdout

• gather_facts : Cela spécifie si Ansible doit collecter des informations sur les hôtes cibles. Dans ce cas, il est défini sur false, ce qui signifie que les informations ne seront pas collectées.
• 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.
• local_action : Cela indique que l'action doit être effectuée localement sur la machine de contrôle où Ansible est exécuté.
• module : Cela spécifie le module Ansible à utiliser pour l'action. Dans ce cas, il s'agit du module command.
• cmd : Il s'agit de la commande réelle à exécuter. Dans ce cas, il s'agit de la commande shell echo "Hello, World!", qui affichera le message "Hello, World!" dans la console.
• register : Cela enregistre la sortie de la commande dans la variable result pour une utilisation ultérieure dans le playbook.
• debug : Il s'agit du module Ansible utilisé pour afficher des informations de débogage.
• var : Il s'agit d'un paramètre du module debug qui spécifie la variable à déboguer. Dans ce cas, il s'agit de result.stdout, qui contient la sortie standard de la commande exécutée dans la tâche précédente.

En résumé, ce playbook exécute une commande simple echo "Hello, World!" localement sur la machine de contrôle, enregistre la sortie, puis affiche la sortie en utilisant le module debug.

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

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

Sortie exemple :

[WARNING]: Aucun inventaire n'a été analysé, seul localhost implicite est disponible
[WARNING]: La liste d'hôtes fournie est vide, seul localhost est disponible. Notez que
localhost implicite ne correspond pas à 'all'

PLAY [Local Action Module Challenge] *******************************************

TASK [Afficher un message localement] *************************************************
changed: [localhost]

TASK [Déboguer la sortie] ********************************************************
ok: [localhost] => {
    "result.stdout": "Hello, World!"
}

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

Ici, "result.stdout": "Hello, World!" est la sortie de la commande echo "Hello, World!".

Exécution d'une commande avec substitution de variables

Dans cette étape, vous approfondirez votre compréhension du module d'action locale en incorporant la substitution de variables. Cela vous permettra de modifier dynamiquement la commande exécutée en fonction des variables définies dans votre playbook.

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

- name: Exécution d'une commande avec substitution de variables
  gather_facts: false
  hosts: localhost
  vars:
    message: "Hello, Ansible!"

  tasks:
    - name: Afficher un message avec substitution de variables
      local_action:
        module: command
        cmd: echo "{{ message }}"
      register: result

    - name: Déboguer la sortie
      debug:
        var: result.stdout

• vars : Cette section est utilisée pour définir des variables. Dans ce playbook, elle définit une variable nommée message avec la valeur "Hello, Ansible!".
• local_action : Cela indique que l'action doit être effectuée localement sur la machine de contrôle où Ansible est exécuté.
• module : Cela spécifie le module Ansible à utiliser pour l'action. Dans ce cas, il s'agit du module command.
• cmd : Il s'agit de la commande réelle à exécuter. Dans ce cas, il s'agit de la commande shell echo "{{ message }}", où {{ message }} est remplacé par la valeur de la variable message définie précédemment.
• register : Cela enregistre la sortie de la commande dans la variable result pour une utilisation ultérieure dans le playbook.
• debug : Il s'agit du module Ansible utilisé pour afficher des informations de débogage.
• var : Il s'agit d'un paramètre du module debug qui spécifie la variable à déboguer. Dans ce cas, il s'agit de result.stdout, qui contient la sortie standard de la commande exécutée dans la tâche précédente.

En résumé, ce playbook exécute la commande echo "{{ message }}" localement sur la machine de contrôle, où {{ message }} est remplacé par la valeur de la variable message définie dans la section vars. Il enregistre la sortie de la commande puis l'affiche en utilisant le module debug.

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

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

Sortie exemple :

[WARNING]: Aucun inventaire n'a été analysé, seul localhost implicite est disponible
[WARNING]: La liste d'hôtes fournie est vide, seul localhost est disponible. Notez que
localhost implicite ne correspond pas à 'all'

PLAY [Local Action Module Challenge] *******************************************

TASK [Afficher un message avec substitution de variables] ******************************
changed: [localhost]

TASK [Déboguer la sortie] ********************************************************
ok: [localhost] => {
    "result.stdout": "Hello, Ansible!"
}

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

Ici, "result.stdout": "Hello, Ansible!" est la sortie de la commande echo "{{ message }}".

Exécution d'une action locale complexe

Dans cette étape, vous allez explorer une utilisation plus complexe du module d'action locale Ansible. Vous allez exécuter un script shell localement et passer des arguments au script.

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

- name: Exécution d'une action locale complexe
  gather_facts: false
  hosts: localhost

  tasks:
    - name: Exécuter un script shell avec des arguments
      local_action:
        module: shell
        cmd:./script.sh 5 7
      register: result

    - name: Déboguer la sortie
      debug:
        var: result.stdout

• local_action : Cela indique que l'action doit être effectuée localement sur la machine de contrôle où Ansible est exécuté.
• module : Cela spécifie le module Ansible à utiliser pour l'action. Dans ce cas, il s'agit du module shell.
• cmd : Il s'agit de la commande shell réelle à exécuter. Dans ce cas, il s'agit de ./script.sh 5 7, qui exécute un script shell nommé script.sh avec les arguments 5 et 7.
• register : Cela enregistre la sortie de la commande dans la variable result pour une utilisation ultérieure dans le playbook.
• debug : Il s'agit du module Ansible utilisé pour afficher des informations de débogage.
• var : Il s'agit d'un paramètre du module debug qui spécifie la variable à déboguer. Dans ce cas, il s'agit de result.stdout, qui contient la sortie standard de la commande exécutée dans la tâche précédente.

En résumé, ce playbook exécute un script shell script.sh avec les arguments 5 et 7 localement sur la machine de contrôle. Il enregistre la sortie du script puis l'affiche en utilisant le module debug.

Astuces : Nous avons préparé ce script shell pour vous, il se trouve dans le répertoire /home/labex/project/ et s'appelle script.sh. La fonction de ce script est de calculer la somme de deux paramètres.

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

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

Sortie exemple :

[WARNING]: Aucun inventaire n'a été analysé, seul localhost implicite est disponible
[WARNING]: La liste d'hôtes fournie est vide, seul localhost est disponible. Notez que
localhost implicite ne correspond pas à 'all'

PLAY [Local Action Module Challenge] *******************************************

TASK [Exécuter un script shell avec des arguments] ***********************************
changed: [localhost]

TASK [Déboguer la sortie] ********************************************************
ok: [localhost] => {
    "result.stdout": "La somme de 5 et 7 est 12."
}

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

Ici, "result.stdout": "La somme de 5 et 7 est 12." est la sortie du script ./script.sh 5 7.

Sommaire

Félicitations pour avoir terminé le Lab du module d'action locale Ansible! Dans ce lab, vous avez appris à utiliser le module d'action locale Ansible pour exécuter des commandes et des scripts localement. En commençant par l'exécution simple de commandes, vous êtes passé à l'incorporation de la substitution de variables et à l'exécution de scripts shell complexes avec des arguments.

En terminant ce lab, vous avez acquis une expérience précieuse en utilisant le module d'action locale pour les tâches qui doivent être effectuées sur la machine de contrôle. Continuez à explorer Ansible et ses modules pour améliorer encore vos capacités d'automatisation.

Joyeuses automatisations!