Comment lister des fichiers et répertoires au format long avec Ansible

Introduction

Ansible est un outil d'automatisation informatique largement utilisé qui simplifie la gestion et le déploiement de l'infrastructure. Dans ce lab, nous allons explorer comment lister des fichiers et des répertoires en format long en utilisant Ansible. Vous apprendrez à configurer Ansible, à créer des playbooks et à utiliser les modules intégrés pour lister les informations sur les fichiers à partir de systèmes distants. À la fin de ce lab, vous aurez une expérience pratique des commandes et des techniques Ansible qui peuvent améliorer vos flux de travail d'automatisation.

Installation et configuration d'Ansible

Dans cette étape, nous allons installer Ansible sur notre système et créer un fichier d'inventaire de base pour gérer notre environnement local.

Installation d'Ansible

Tout d'abord, installons Ansible en utilisant le gestionnaire de paquets :

sudo apt update
sudo apt install -y ansible

Une fois l'installation terminée, vérifiez qu'Ansible est correctement installé en vérifiant sa version :

ansible --version

Vous devriez voir une sortie similaire à celle-ci :

ansible [core 2.12.0]
  config file = /etc/ansible/ansible.cfg
  configured module search path = ['/home/labex/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  ansible python module location = /usr/lib/python3/dist-packages/ansible
  ansible collection location = /home/labex/.ansible/collections:/usr/share/ansible/collections
  executable location = /usr/bin/ansible
  python version = 3.10.x (default, Ubuntu 22.04)
  jinja version = 3.0.3
  libyaml = True

Création d'un inventaire Ansible

Un fichier d'inventaire est une liste de nœuds gérés avec lesquels Ansible peut travailler. Pour ce lab, nous allons créer un simple fichier d'inventaire qui inclut notre machine locale.

Créez un répertoire pour notre projet Ansible :

mkdir -p ~/project/ansible-lab
cd ~/project/ansible-lab

Maintenant, créez un fichier d'inventaire en utilisant l'éditeur VS Code :

1. Cliquez sur l'icône "Explorer" dans la barre latérale gauche
2. Naviguez vers le répertoire ~/project/ansible-lab
3. Faites un clic droit et sélectionnez "Nouveau fichier"
4. Nommez le fichier inventory.ini
5. Ajoutez le contenu suivant au fichier :

[local]
localhost ansible_connection=local

Ce fichier d'inventaire définit un groupe appelé local qui inclut uniquement notre localhost, et spécifie qu'Ansible doit se connecter localement plutôt qu'en utilisant SSH.

Création du fichier de configuration Ansible

Créons un fichier de configuration Ansible de base pour spécifier les paramètres par défaut :

1. Dans le panneau Explorer, faites un clic droit sur le répertoire ansible-lab et sélectionnez "Nouveau fichier"
2. Nommez le fichier ansible.cfg
3. Ajoutez le contenu suivant :

[defaults]
inventory = inventory.ini
host_key_checking = False

Ce fichier de configuration indique à Ansible d'utiliser notre fichier inventory.ini par défaut et désactive la vérification des clés d'hôte SSH, ce qui est utile pour les environnements de lab.

Test de la configuration

Testons notre configuration Ansible en exécutant une commande simple :

cd ~/project/ansible-lab
ansible local -m ping

Vous devriez voir une sortie similaire à celle-ci :

localhost | SUCCESS => {
    "changed": false,
    "ping": "pong"
}

Cela confirme qu'Ansible est correctement configuré et peut communiquer avec notre machine locale.

Création d'un playbook Ansible de base pour lister des fichiers

Dans cette étape, nous allons créer un playbook Ansible de base pour lister les fichiers et les répertoires. Les playbooks sont des fichiers YAML qui définissent un ensemble de tâches à exécuter sur les nœuds gérés.

Comprendre les playbooks Ansible

Avant de commencer à créer notre playbook, comprenons ce qu'est un playbook :

• Un playbook est un fichier YAML qui contient une liste de plays
• Chaque play définit un ensemble de tâches à exécuter sur un groupe spécifique d'hôtes
• Les tâches sont des actions individuelles qui appellent des modules Ansible
• Les modules sont des unités de code réutilisables qui effectuent des opérations spécifiques

Création de notre premier playbook

Créons un playbook simple pour lister le contenu du répertoire /etc :

1. Dans le panneau Explorer, naviguez vers le répertoire ~/project/ansible-lab
2. Faites un clic droit et sélectionnez "Nouveau fichier"
3. Nommez le fichier list_files.yml
4. Ajoutez le contenu suivant :

---
- name: List files and directories
  hosts: local
  tasks:
    - name: Get directory listing
      command: ls -l /etc
      register: directory_contents

    - name: Display directory contents
      debug:
        var: directory_contents.stdout_lines

Comprenons ce que fait ce playbook :

• La première ligne (---) indique le début d'un document YAML
• name: List files and directories est un nom descriptif pour le play
• hosts: local spécifie que ce play s'exécutera sur les hôtes du groupe local (défini dans notre inventaire)
• tasks: commence la liste des tâches à exécuter
• La première tâche exécute la commande ls -l /etc et stocke le résultat dans une variable appelée directory_contents
• La deuxième tâche affiche le contenu de la variable directory_contents.stdout_lines

Exécution du playbook

Exécutons maintenant notre playbook :

cd ~/project/ansible-lab
ansible-playbook list_files.yml

Vous devriez voir une sortie similaire à celle-ci :

PLAY [List files and directories] *****************************************************

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

TASK [Get directory listing] **********************************************************
changed: [localhost]

TASK [Display directory contents] *****************************************************
ok: [localhost] => {
    "directory_contents.stdout_lines": [
        "total 1088",
        "drwxr-xr-x  2 root root    4096 Apr 15 12:34 acpi",
        "drwxr-xr-x  3 root root    4096 Apr 15 12:34 alternatives",
        "-rw-r--r--  1 root root    3028 Aug  1  2017 bash.bashrc",
        "drwxr-xr-x  2 root root    4096 Apr 15 12:34 bash_completion.d",
        "... [more files and directories] ..."
    ]
}

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

La sortie affiche le contenu du répertoire /etc au format long, qui comprend les permissions, le propriétaire, le groupe, la taille et la date de modification.

Utilisation d'un répertoire différent

Modifions maintenant notre playbook pour lister le contenu du répertoire /home/labex :

1. Ouvrez le fichier list_files.yml dans l'éditeur
2. Remplacez le chemin dans la commande de /etc par /home/labex
3. Enregistrez le fichier avec le contenu suivant :

---
- name: List files and directories
  hosts: local
  tasks:
    - name: Get directory listing
      command: ls -l /home/labex
      register: directory_contents

    - name: Display directory contents
      debug:
        var: directory_contents.stdout_lines

Exécutez à nouveau le playbook :

ansible-playbook list_files.yml

La sortie affichera désormais le contenu du répertoire /home/labex au lieu de /etc.

Utilisation du module File d'Ansible pour une liste au format long

Dans l'étape précédente, nous avons utilisé le module command pour exécuter la commande ls -l. Bien que cela fonctionne, Ansible fournit un module plus dédié pour travailler avec les fichiers et les répertoires : le module ansible.builtin.file. Dans cette étape, nous allons apprendre à utiliser ce module avec le module ansible.builtin.find pour lister les fichiers d'une manière plus native à Ansible.

Utilisation du module find

Le module ansible.builtin.find est conçu pour localiser les fichiers correspondant à des critères spécifiques. Il offre un moyen plus puissant et flexible de lister les fichiers par rapport au module command.

Créons un nouveau playbook qui utilise le module find :

1. Dans le panneau Explorer, naviguez vers le répertoire ~/project/ansible-lab
2. Faites un clic droit et sélectionnez "Nouveau fichier"
3. Nommez le fichier find_files.yml
4. Ajoutez le contenu suivant :

---
- name: Find files with Ansible
  hosts: local
  tasks:
    - name: Find all files in /etc
      ansible.builtin.find:
        paths: /etc
        file_type: any
      register: found_files

    - name: Display the first 10 files
      debug:
        var: found_files.files[:10]

Ce playbook utilise le module find pour localiser tous les fichiers et répertoires dans le répertoire /etc, puis affiche les 10 premiers éléments.

Exécutons le playbook :

cd ~/project/ansible-lab
ansible-playbook find_files.yml

Vous devriez voir une sortie qui contient des informations détaillées sur chaque fichier, notamment :

• Path (Chemin)
• Mode (permissions)
• Owner and group (Propriétaire et groupe)
• Size (Taille)
• Modified time (Heure de modification)

Création d'un playbook avec des détails au format long

Maintenant, créons un playbook plus complet qui affiche les fichiers au format long avec tous les détails :

1. Dans le panneau Explorer, faites un clic droit et sélectionnez "Nouveau fichier"
2. Nommez le fichier long_format.yml
3. Ajoutez le contenu suivant :

---
- name: List files in long format
  hosts: local
  tasks:
    - name: Find files in /etc
      ansible.builtin.find:
        paths: /etc
        file_type: any
        recurse: no
      register: found_files

    - name: Create a formatted list of files
      set_fact:
        formatted_files: "{{ formatted_files | default([]) + [item] }}"
      loop: "{{ found_files.files }}"
      loop_control:
        label: "{{ item.path }}"
      vars:
        item_info: >-
          {{ item.mode }} {{ item.uid | string | ljust(5) }}
          {{ item.gid | string | ljust(5) }} {{ item.size | string | ljust(10) }}
          {{ item.mtime | string | ljust(11) }} {{ item.path }}

    - name: Display files in long format
      debug:
        msg: "{{ formatted_files[:10] }}"

Ce playbook :

1. Utilise le module find pour localiser les fichiers dans le répertoire /etc
2. Crée une liste formatée qui ressemble à la sortie de la commande ls -l
3. Affiche les 10 premiers fichiers de la liste

Exécutons le playbook :

ansible-playbook long_format.yml

La sortie affichera les détails des fichiers dans un format similaire à la commande ls -l.

Filtrage des fichiers en fonction de critères

Un avantage de l'utilisation des modules d'Ansible est la possibilité de filtrer les fichiers en fonction de divers critères. Créons un playbook qui liste uniquement les fichiers de configuration (fichiers se terminant par .conf) :

1. Dans le panneau Explorer, faites un clic droit et sélectionnez "Nouveau fichier"
2. Nommez le fichier filter_files.yml
3. Ajoutez le contenu suivant :

---
- name: List filtered files in long format
  hosts: local
  tasks:
    - name: Find configuration files in /etc
      ansible.builtin.find:
        paths: /etc
        patterns: "*.conf"
        file_type: file
      register: conf_files

    - name: Display configuration files
      debug:
        msg: "{{ item.mode }} {{ item.uid }} {{ item.gid }} {{ item.size }} {{ item.mtime }} {{ item.path }}"
      loop: "{{ conf_files.files }}"
      loop_control:
        label: "{{ item.path }}"

Ce playbook :

1. Utilise le module find pour localiser les fichiers dans le répertoire /etc qui se terminent par .conf
2. Affiche chaque fichier avec ses détails

Exécutons le playbook :

ansible-playbook filter_files.yml

La sortie affichera les détails uniquement pour les fichiers .conf dans le répertoire /etc.

Comparaison avec le module Command

Créons un autre playbook pour comparer la sortie du module find avec la commande traditionnelle ls -l :

1. Dans le panneau Explorer, faites un clic droit et sélectionnez "Nouveau fichier"
2. Nommez le fichier compare_methods.yml
3. Ajoutez le contenu suivant :

---
- name: Compare listing methods
  hosts: local
  tasks:
    - name: Get directory listing with ls command
      command: ls -l /etc/passwd
      register: ls_output

    - name: Get file info with find module
      ansible.builtin.find:
        paths: /etc
        patterns: "passwd"
        file_type: file
      register: find_output

    - name: Display ls command output
      debug:
        var: ls_output.stdout_lines

    - name: Display find module output
      debug:
        var: find_output.files[0]

Ce playbook :

1. Utilise le module command pour exécuter ls -l sur le fichier /etc/passwd
2. Utilise le module find pour localiser le même fichier
3. Affiche les deux sorties pour comparaison

Exécutons le playbook :

ansible-playbook compare_methods.yml

Vous pouvez maintenant voir la différence entre les deux méthodes :

• La commande ls -l vous donne une seule ligne de texte au format Unix traditionnel
• Le module find vous donne un objet de données structurées que vous pouvez manipuler dans Ansible

Création d'un rôle réutilisable pour la liste de fichiers

Dans cette étape, nous allons apprendre à créer un rôle Ansible pour la liste de fichiers. Les rôles sont un moyen d'organiser les playbooks et de les rendre plus réutilisables. Ceci est particulièrement utile lorsque vous devez effectuer la même tâche sur plusieurs playbooks ou projets.

Comprendre les rôles Ansible

Un rôle Ansible est un ensemble de tâches, de variables, de fichiers, de modèles et d'autres ressources qui sont regroupés dans une structure de répertoire standard. Les rôles facilitent la réutilisation du code et son partage avec d'autres.

La structure de répertoire standard pour un rôle ressemble à ceci :

roles/
  rolename/
    tasks/      ## Tâches principales du rôle
    handlers/   ## Gestionnaires déclenchés par les tâches
    defaults/   ## Variables par défaut
    vars/       ## Variables de rôle
    files/      ## Fichiers statiques
    templates/  ## Modèles
    meta/       ## Métadonnées pour le rôle

Création d'un rôle de liste de fichiers

Créons un rôle pour lister les fichiers au format long :

1. Tout d'abord, créez la structure de répertoire pour notre rôle :

cd ~/project/ansible-lab
mkdir -p roles/file_lister/tasks

2. Créez le fichier de tâche principal pour notre rôle :

cd ~/project/ansible-lab

3. Dans le panneau Explorer, naviguez vers ~/project/ansible-lab/roles/file_lister/tasks
4. Faites un clic droit et sélectionnez "Nouveau fichier"
5. Nommez le fichier main.yml
6. Ajoutez le contenu suivant :

---
## Tasks for file_lister role

- name: Find files in the specified directory
  ansible.builtin.find:
    paths: "{{ path | default('/etc') }}"
    patterns: "{{ patterns | default('*') }}"
    file_type: "{{ file_type | default('any') }}"
    recurse: "{{ recurse | default(false) }}"
  register: found_files

- name: Display files in long format
  debug:
    msg: "{{ item.mode }} {{ item.uid }} {{ item.gid }} {{ item.size }} {{ item.mtime }} {{ item.path }}"
  loop: "{{ found_files.files | sort(attribute='path') }}"
  loop_control:
    label: "{{ item.path }}"
  when: show_details | default(true)

- name: Display only file paths
  debug:
    msg: "{{ item.path }}"
  loop: "{{ found_files.files | sort(attribute='path') }}"
  loop_control:
    label: "{{ item.path }}"
  when: not (show_details | default(true))

Ce rôle :

1. Trouve les fichiers dans un répertoire spécifié en fonction des paramètres
2. Affiche les fichiers au format long ou simplement les chemins
3. Utilise des valeurs par défaut pour les paramètres s'ils ne sont pas spécifiés

Utilisation de notre rôle dans un playbook

Maintenant, créons un playbook qui utilise notre nouveau rôle :

1. Dans le panneau Explorer, naviguez vers le répertoire ~/project/ansible-lab
2. Faites un clic droit et sélectionnez "Nouveau fichier"
3. Nommez le fichier use_role.yml
4. Ajoutez le contenu suivant :

---
- name: Use file listing role
  hosts: local
  roles:
    - role: file_lister
      vars:
        path: "/etc"
        patterns: "*.conf"
        file_type: "file"
        show_details: true

Ce playbook :

1. S'exécute sur l'hôte local
2. Utilise notre rôle file_lister
3. Définit des variables pour le rôle afin de personnaliser son comportement

Exécutons le playbook :

cd ~/project/ansible-lab
ansible-playbook use_role.yml

Vous devriez voir une sortie affichant les détails de tous les fichiers .conf dans le répertoire /etc.

Personnalisation des variables de rôle

L'un des avantages des rôles est que nous pouvons facilement personnaliser leur comportement en modifiant les variables. Créons un autre playbook qui utilise notre rôle avec des paramètres différents :

1. Dans le panneau Explorer, faites un clic droit et sélectionnez "Nouveau fichier"
2. Nommez le fichier custom_listing.yml
3. Ajoutez le contenu suivant :

---
- name: Custom file listing
  hosts: local
  roles:
    - role: file_lister
      vars:
        path: "/home/labex"
        patterns: "*.yml"
        file_type: "file"
        show_details: false

Ce playbook :

1. Utilise notre rôle file_lister
2. Le configure pour rechercher dans le répertoire /home/labex
3. Filtre les fichiers YAML (*.yml)
4. Affiche uniquement les chemins des fichiers (pas les détails complets)

Exécutons le playbook :

ansible-playbook custom_listing.yml

Vous devriez voir une liste de tous les fichiers YAML dans le répertoire /home/labex, sans les informations détaillées.

Utilisation avancée : Création d'un rapport

Enfin, créons un playbook plus avancé qui utilise notre rôle pour générer un rapport de fichiers :

1. Dans le panneau Explorer, faites un clic droit et sélectionnez "Nouveau fichier"
2. Nommez le fichier generate_report.yml
3. Ajoutez le contenu suivant :

---
- name: Generate file listing report
  hosts: local
  vars:
    report_path: "~/project/ansible-lab/file_report.txt"
  tasks:
    - name: Find files in the specified directory
      ansible.builtin.find:
        paths: "/etc"
        patterns: "*.conf"
        file_type: "file"
      register: found_files

    - name: Create report header
      copy:
        dest: "{{ report_path }}"
        content: |
          File Listing Report
          Generated on: {{ ansible_date_time.date }} at {{ ansible_date_time.time }}
          -----------------------------------------------------------
          Mode       Owner  Group  Size       Modified    Path
          -----------------------------------------------------------
        force: yes

    - name: Append file information to report
      lineinfile:
        path: "{{ report_path }}"
        line: "{{ item.mode }} {{ item.uid }} {{ item.gid }} {{ item.size | string | ljust(10) }} {{ item.mtime }} {{ item.path }}"
      loop: "{{ found_files.files | sort(attribute='path') }}"
      loop_control:
        label: "{{ item.path }}"

    - name: Display report location
      debug:
        msg: "Report generated at {{ report_path }}"

Ce playbook :

1. Trouve les fichiers .conf dans le répertoire /etc
2. Crée un fichier texte avec un en-tête
3. Ajoute des informations sur chaque fichier au rapport
4. Affiche l'emplacement du rapport

Exécutons le playbook :

ansible-playbook generate_report.yml

Après avoir exécuté le playbook, vous pouvez afficher le rapport :

cat ~/project/ansible-lab/file_report.txt

Vous devriez voir un rapport formaté listant tous les fichiers .conf dans le répertoire /etc.

Résumé

Dans ce Lab, vous avez appris à utiliser Ansible pour lister les fichiers et les répertoires au format long. Vous avez acquis une expérience pratique avec :

1. La configuration d'Ansible en installant le logiciel et en créant un fichier d'inventaire
2. La création de playbooks de base qui utilisent le module command pour exécuter la commande ls -l
3. L'utilisation des modules file et find intégrés d'Ansible pour obtenir des informations détaillées sur les fichiers
4. La création d'un rôle Ansible réutilisable pour lister les fichiers avec diverses options
5. La génération de rapports formatés basés sur les informations des fichiers

Ces compétences vous aideront à automatiser les tâches de gestion des fichiers dans votre infrastructure et à intégrer les listes de fichiers dans des flux de travail d'automatisation plus importants. Au fur et à mesure que vous continuerez à travailler avec Ansible, vous pourrez vous appuyer sur ces concepts pour créer des automatisations plus complexes qui gèrent les fichiers, les répertoires et leurs permissions dans l'ensemble de votre environnement.