Module Ansible Command

Introduction

Dans ce laboratoire, vous allez explorer le module Ansible Command, un outil puissant pour exécuter des commandes sur des hôtes distants. Le module Command vous permet d'interagir avec la ligne de commande directement depuis vos playbooks et tâches Ansible, offrant ainsi une méthode polyvalente pour gérer des systèmes distants. Tout au long de ce laboratoire, vous apprendrez à utiliser le module Ansible Command pour exécuter diverses commandes, travailler avec des variables et des arguments, et capturer la sortie des commandes.

Skills Graph

Créer un simple playbook Ansible

Dans cette étape, vous allez créer votre premier playbook Ansible en utilisant le module Command pour exécuter une commande simple.

Tout d'abord, accédez au répertoire du projet :

cd ~/project

Maintenant, créez un nouveau fichier appelé simple_command.yml en utilisant l'éditeur de texte de votre choix. Par exemple, vous pouvez utiliser l'éditeur nano :

nano simple_command.yml

Ajoutez le contenu suivant au fichier :

---
- name: Execute a simple command
  hosts: localhost
  tasks:
    - name: Run 'ls' command
      command: ls -l

Analysons ce playbook :

• La ligne hosts: localhost spécifie que le playbook sera exécuté sur la machine locale.
• La section tasks contient une liste de tâches à exécuter.
• La ligne command: ls -l utilise le module Command pour exécuter la commande ls -l, qui liste les fichiers et les répertoires au format détaillé.

Enregistrez le fichier et quittez l'éditeur (dans nano, appuyez sur Ctrl+X, puis Y, puis Entrée).

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

ansible-playbook simple_command.yml

Vous devriez voir une sortie similaire à celle-ci :

PLAY [Execute a simple command] ************************************************

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

TASK [Run 'ls' command] ********************************************************
changed: [localhost]

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

Cette sortie indique que le playbook s'est exécuté avec succès, en exécutant la commande ls -l sur votre machine locale.

Utiliser des variables avec le module Command

Dans cette étape, vous allez apprendre à utiliser des variables avec le module Ansible Command. Les variables vous permettent de rendre vos playbooks plus flexibles et réutilisables.

Créez un nouveau fichier appelé variable_command.yml :

nano variable_command.yml

Ajoutez le contenu suivant au fichier :

---
- name: Use variables with the Command module
  hosts: localhost
  vars:
    file_path: /etc/passwd
    line_count: 5
  tasks:
    - name: Display the last few lines of a file
      command: "tail -n {{ line_count }} {{ file_path }}"
      register: command_output

    - name: Show the command output
      debug:
        var: command_output.stdout_lines

Ce playbook introduit plusieurs nouveaux concepts :

• La section vars définit des variables qui peuvent être utilisées tout au long du playbook.
• Nous utilisons la syntaxe {{ variable_name }} pour faire référence à des variables dans la commande.
• Le mot-clé register enregistre la sortie de la commande dans une variable nommée command_output.
• Le module debug est utilisé pour afficher le contenu de la variable command_output.

Enregistrez le fichier et quittez l'éditeur.

Maintenant, exécutez le playbook :

ansible-playbook variable_command.yml

Vous devriez voir une sortie similaire à celle-ci :

PLAY [Use variables with the Command module] ***********************************

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

TASK [Display the last few lines of a file] ************************************
changed: [localhost]

TASK [Show the command output] *************************************************
ok: [localhost] => {
    "command_output.stdout_lines": [
        "games:x:5:60:games:/usr/games:/usr/sbin/nologin",
        "man:x:6:12:man:/var/cache/man:/usr/sbin/nologin",
        "lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin",
        "mail:x:8:8:mail:/var/mail:/usr/sbin/nologin",
        "news:x:9:9:news:/var/spool/news:/usr/sbin/nologin"
    ]
}

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

Cette sortie montre les 5 dernières lignes du fichier /etc/passwd, démontrant comment les variables peuvent être utilisées avec le module Command.

Capturer et traiter la sortie d'une commande

Dans cette étape, vous allez apprendre à capturer la sortie d'une commande et à la traiter davantage à l'aide d'Ansible.

Créez un nouveau fichier appelé process_output.yml :

nano process_output.yml

Ajoutez le contenu suivant au fichier :

---
- name: Capture and process command output
  hosts: localhost
  tasks:
    - name: Get disk usage information
      command: df -h
      register: df_output

    - name: Display all partitions
      debug:
        msg: "{{ df_output.stdout_lines }}"

    - name: Find root partition
      set_fact:
        root_partition: "{{ df_output.stdout_lines | select('match', '\\s+/$') | first | default('') }}"

    - name: Display root partition information
      debug:
        msg: "Root partition: {{ root_partition }}"
      when: root_partition!= ''

    - name: Extract usage percentage
      set_fact:
        root_usage: "{{ root_partition.split()[-2].rstrip('%') | int }}"
      when: root_partition!= ''

    - name: Display root partition usage
      debug:
        msg: "Root partition is {{ root_usage }}% full"
      when: root_partition!= ''

    - name: Check if root partition is over 80% full
      fail:
        msg: "Warning: Root partition is over 80% full!"
      when: root_partition!= '' and root_usage > 80

    - name: Display message if root partition not found
      debug:
        msg: "Root partition (/) not found in df output"
      when: root_partition == ''

Ce playbook est plus robuste et gère les cas où la partition racine peut ne pas être facilement détectable :

• Nous affichons toutes les partitions pour voir ce qui est disponible.
• Nous utilisons un modèle plus flexible pour trouver la partition racine.
• Nous ajoutons des vérifications pour gérer les cas où la partition racine n'est pas trouvée.
• Nous utilisons le filtre default('') pour éviter les erreurs lorsque la partition racine n'est pas trouvée.

Enregistrez le fichier et quittez l'éditeur.

Maintenant, exécutez le playbook :

ansible-playbook process_output.yml

Vous devriez voir une sortie similaire à celle-ci :

PLAY [Capture and process command output] ************************************************

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

TASK [Get disk usage information] ********************************************************
changed: [localhost]

TASK [Display all partitions] ************************************************************
ok: [localhost] => {
    "msg": [
        "Filesystem      Size  Used Avail Use% Mounted on",
        "overlay          20G  618M   20G   4% /",
        "tmpfs            64M     0   64M   0% /dev",
        "tmpfs           3.9G     0  3.9G   0% /sys/fs/cgroup",
        "shm              64M  128K   64M   1% /dev/shm",
        "/dev/vdb        100G   17G   84G  17% /etc/hosts"
    ]
}

TASK [Find root partition] ***************************************************************
ok: [localhost]

TASK [Display root partition information] ************************************************
skipping: [localhost]

TASK [Extract usage percentage] **********************************************************
skipping: [localhost]

TASK [Display root partition usage] ******************************************************
skipping: [localhost]

TASK [Check if root partition is over 80% full] ******************************************
skipping: [localhost]

TASK [Display message if root partition not found] ***************************************
ok: [localhost] => {
    "msg": "Root partition (/) not found in df output"
}

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

Cette sortie affiche toutes les partitions, identifie la partition racine et vérifie son utilisation. Les valeurs exactes peuvent différer sur votre système.

Utilisation des options du module Command

Dans cette étape, vous allez explorer certaines des options disponibles avec le module Ansible Command pour contrôler son comportement.

Créez un nouveau fichier appelé command_options.yml :

nano command_options.yml

Ajoutez le contenu suivant au fichier :

---
- name: Explore Command module options
  hosts: localhost
  tasks:
    - name: Run a command with a specific working directory
      command: pwd
      args:
        chdir: /tmp

    - name: Run a command with environment variables
      command: echo $MY_VAR
      environment:
        MY_VAR: "Hello from Ansible"

    - name: Run a command and ignore errors
      command: ls /nonexistent_directory
      ignore_errors: yes

    - name: Run a command with a timeout
      command: sleep 2
      async: 5
      poll: 0
      register: sleep_result

    - name: Check sleep command status
      async_status:
        jid: "{{ sleep_result.ansible_job_id }}"
      register: job_result
      until: job_result.finished
      retries: 5
      delay: 1

Ce playbook démontre diverses options du module Command :

• chdir : Modifie le répertoire de travail avant d'exécuter la commande.
• environment : Définit des variables d'environnement pour la commande.
• ignore_errors : Continue l'exécution du playbook même si la commande échoue.
• async et poll : Exécute la commande de manière asynchrone avec un délai d'attente.

Enregistrez le fichier et quittez l'éditeur.

Maintenant, exécutez le playbook :

ansible-playbook command_options.yml

Vous devriez voir une sortie similaire à celle-ci :

PPLAY [Explore Command module options]

TASK [Gathering Facts]
ok: [localhost]

TASK [Run a command with a specific working directory]
changed: [localhost]

TASK [Run a command with environment variables]
changed: [localhost]

TASK [Run a command and ignore errors]
fatal: [localhost]: FAILED! => {"changed": true, "cmd": ["ls", "/nonexistent_directory"], "delta": "0:00:00.006113", "end": "2024-09-06 09:40:43.373350", "msg": "non-zero return code", "rc": 2, "start": "2024-09-06 09:40:43.367237", "stderr": "ls: cannot access '/nonexistent_directory': No such file or directory", "stderr_lines": ["ls: cannot access '/nonexistent_directory': No such file or directory"], "stdout": "", "stdout_lines": []}
...ignoring

TASK [Run a command with a timeout]
changed: [localhost]

TASK [Check sleep command status]
FAILED - RETRYING: Check sleep command status (10 retries left).
FAILED - RETRYING: Check sleep command status (9 retries left).
FAILED - RETRYING: Check sleep command status (8 retries left).
FAILED - RETRYING: Check sleep command status (7 retries left).
FAILED - RETRYING: Check sleep command status (6 retries left).
FAILED - RETRYING: Check sleep command status (5 retries left).
FAILED - RETRYING: Check sleep command status (4 retries left).
FAILED - RETRYING: Check sleep command status (3 retries left).
FAILED - RETRYING: Check sleep command status (2 retries left).
FAILED - RETRYING: Check sleep command status (1 retries left).
fatal: [localhost]: FAILED! => {"ansible_job_id": "5877920468.2517", "attempts": 10, "changed": false, "finished": 0, "started": 1}

PLAY RECAP

Cette sortie démontre les différents comportements des options du module Command que nous avons explorées.

Utilisation du module Command dans un scénario compatible Docker

Dans cette étape finale, vous utiliserez le module Ansible Command dans un scénario plus réaliste et compatible Docker : vérifier l'état du service SSH et le gérer si nécessaire.

Créez un nouveau fichier appelé check_service_docker.yml :

nano check_service_docker.yml

Ajoutez le contenu suivant au fichier :

---
- name: Check and manage SSH service in Docker
  hosts: localhost
  become: yes ## Cela permet à Ansible d'utiliser sudo
  tasks:
    - name: Check SSH service status
      command: service ssh status
      register: ssh_status
      ignore_errors: yes

    - name: Display SSH service status
      debug:
        msg: "SSH service status: {{ ssh_status.stdout }}"

    - name: Start SSH service if not running
      command: service ssh start
      when: ssh_status.rc!= 0

    - name: Verify SSH service is running
      command: service ssh status
      register: ssh_status_after

    - name: Display final SSH service status
      debug:
        msg: "SSH service status is now: {{ ssh_status_after.stdout }}"

    - name: Check if SSH port is listening
      command: netstat -tuln | grep :22
      register: ssh_port_check
      ignore_errors: yes

    - name: Display SSH port status
      debug:
        msg: "SSH port 22 is {{ 'open' if ssh_port_check.rc == 0 else 'closed' }}"

Ce playbook effectue les actions suivantes :

1. Vérifie l'état du service SSH à l'aide de la commande service.
2. Affiche l'état actuel du service.
3. Démarre le service s'il n'est pas en cours d'exécution.
4. Vérifie l'état du service après le démarrage éventuel.
5. Affiche l'état final du service.
6. Vérifie si le port SSH (22) est en écoute.
7. Affiche l'état du port SSH.

Enregistrez le fichier et quittez l'éditeur.

Maintenant, exécutez le playbook avec des privilèges sudo :

sudo ansible-playbook check_service_docker.yml

Vous devriez voir une sortie similaire à celle-ci :

PLAY [Check and manage SSH service in Docker] *****************************************

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

TASK [Check SSH service status] *******************************************************
changed: [localhost]

TASK [Display SSH service status] *****************************************************
ok: [localhost] => {
    "msg": "SSH service status: * sshd is running"
}

TASK [Start SSH service if not running] ***********************************************
skipping: [localhost]

TASK [Verify SSH service is running] **************************************************
changed: [localhost]

TASK [Display final SSH service status] ***********************************************
ok: [localhost] => {
    "msg": "SSH service status is now: * sshd is running"
}

TASK [Check if SSH port is listening] *************************************************
changed: [localhost]

TASK [Display SSH port status] ********************************************************
ok: [localhost] => {
    "msg": "SSH port 22 is open"
}

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

Cette sortie montre que le service SSH était déjà en cours d'exécution, il n'a donc pas besoin d'être démarré. Le playbook a vérifié et confirmé avec succès l'état du service, et a également confirmé que le port SSH est ouvert.

Résumé

Dans ce laboratoire, vous avez exploré la polyvalence et la puissance du module Ansible Command. Vous avez appris à :

1. Créer des playbooks Ansible simples en utilisant le module Command pour exécuter des commandes de base.
2. Utiliser des variables avec le module Command pour rendre vos playbooks plus flexibles et réutilisables.
3. Capturer et traiter la sortie des commandes, vous permettant de prendre des décisions en fonction des résultats des commandes.
4. Utiliser diverses options du module Command pour contrôler son comportement, comme changer de répertoire, définir des variables d'environnement et gérer les erreurs.
5. Appliquer le module Command dans un scénario du monde réel en vérifiant et en gérant un service système.

Ces compétences constituent une base solide pour utiliser Ansible afin d'automatiser les tâches d'administration système et de gérer efficacement des hôtes distants. Au fur et à mesure que vous continuerez à travailler avec Ansible, vous trouverez que le module Command est un outil polyvalent dans votre boîte à outils d'automatisation.

N'oubliez pas que bien que le module Command soit puissant, il est souvent préférable d'utiliser des modules Ansible spécialisés (comme le module service pour gérer les services) lorsqu'ils sont disponibles. Ces modules spécialisés offrent une meilleure idempotence et peuvent gérer des scénarios plus complexes dès le départ.

Continuez à pratiquer et à explorer les capacités d'Ansible pour améliorer encore vos compétences en automatisation et rationaliser vos opérations IT.