Cómo listar archivos y directorios en formato largo con Ansible

Introducción

Ansible es una herramienta de automatización de TI ampliamente utilizada que simplifica la gestión e implementación de la infraestructura. En este laboratorio, exploraremos cómo listar archivos y directorios en formato largo utilizando Ansible. Aprenderá a configurar Ansible, crear playbooks y utilizar los módulos integrados para listar información de archivos de sistemas remotos. Al final de este laboratorio, tendrá experiencia práctica con los comandos y técnicas de Ansible que pueden mejorar sus flujos de trabajo de automatización.

Instalación y Configuración de Ansible

En este paso, instalaremos Ansible en nuestro sistema y crearemos un archivo de inventario básico para gestionar nuestro entorno local.

Instalación de Ansible

Primero, instalemos Ansible usando el gestor de paquetes:

sudo apt update
sudo apt install -y ansible

Después de que la instalación se complete, verifique que Ansible esté instalado correctamente comprobando su versión:

ansible --version

Debería ver una salida similar a esta:

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

Creación de un Inventario de Ansible

Un archivo de inventario es una lista de nodos gestionados con los que Ansible puede trabajar. Para este laboratorio, crearemos un archivo de inventario simple que incluye nuestra máquina local.

Cree un directorio para nuestro proyecto Ansible:

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

Ahora, cree un archivo de inventario usando el editor VS Code:

1. Haga clic en el icono "Explorador" en la barra lateral izquierda
2. Navegue al directorio ~/project/ansible-lab
3. Haga clic con el botón derecho y seleccione "Nuevo archivo"
4. Nombre el archivo inventory.ini
5. Agregue el siguiente contenido al archivo:

[local]
localhost ansible_connection=local

Este archivo de inventario define un grupo llamado local que incluye solo nuestro localhost, y especifica que Ansible debe conectarse localmente en lugar de usar SSH.

Creación del Archivo de Configuración de Ansible

Creemos un archivo de configuración básico de Ansible para especificar la configuración predeterminada:

1. En el panel del Explorador, haga clic con el botón derecho en el directorio ansible-lab y seleccione "Nuevo archivo"
2. Nombre el archivo ansible.cfg
3. Agregue el siguiente contenido:

[defaults]
inventory = inventory.ini
host_key_checking = False

Este archivo de configuración le dice a Ansible que use nuestro archivo inventory.ini por defecto y deshabilita la comprobación de la clave del host SSH, lo cual es útil para entornos de laboratorio.

Prueba de la Configuración

Probemos nuestra configuración de Ansible ejecutando un comando simple:

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

Debería ver una salida similar a esta:

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

Esto confirma que Ansible está configurado correctamente y puede comunicarse con nuestra máquina local.

Creación de un Playbook Básico de Ansible para Listar Archivos

En este paso, crearemos un playbook básico de Ansible para listar archivos y directorios. Los playbooks son archivos YAML que definen un conjunto de tareas a ejecutar en nodos gestionados.

Entendiendo los Playbooks de Ansible

Antes de comenzar a crear nuestro playbook, entendamos qué es un playbook:

• Un playbook es un archivo YAML que contiene una lista de plays
• Cada play define un conjunto de tareas para ejecutar en un grupo específico de hosts
• Las tareas son acciones individuales que llaman a los módulos de Ansible
• Los módulos son unidades de código reutilizables que realizan operaciones específicas

Creación de Nuestro Primer Playbook

Creemos un playbook simple para listar el contenido del directorio /etc:

1. En el panel del Explorador, navegue al directorio ~/project/ansible-lab
2. Haga clic con el botón derecho y seleccione "Nuevo archivo"
3. Nombre el archivo list_files.yml
4. Agregue el siguiente contenido:

---
- 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

Entendamos qué hace este playbook:

• La primera línea (---) indica el inicio de un documento YAML
• name: List files and directories es un nombre descriptivo para el play
• hosts: local especifica que este play se ejecutará en los hosts del grupo local (definido en nuestro inventario)
• tasks: comienza la lista de tareas a ejecutar
• La primera tarea ejecuta el comando ls -l /etc y almacena el resultado en una variable llamada directory_contents
• La segunda tarea muestra el contenido de la variable directory_contents.stdout_lines

Ejecución del Playbook

Ahora ejecutemos nuestro playbook:

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

Debería ver una salida similar a esta:

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 salida muestra el contenido del directorio /etc en formato largo, que incluye permisos, propietario, grupo, tamaño y fecha de modificación.

Uso de un Directorio Diferente

Ahora modifiquemos nuestro playbook para listar el contenido del directorio /home/labex:

1. Abra el archivo list_files.yml en el editor
2. Cambie la ruta en el comando de /etc a /home/labex
3. Guarde el archivo con el siguiente contenido:

---
- 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

Ejecute el playbook de nuevo:

ansible-playbook list_files.yml

La salida ahora mostrará el contenido del directorio /home/labex en lugar de /etc.

Uso del Módulo File de Ansible para Listado en Formato Largo

En el paso anterior, usamos el módulo command para ejecutar el comando ls -l. Si bien esto funciona, Ansible proporciona un módulo más dedicado para trabajar con archivos y directorios: el módulo ansible.builtin.file. En este paso, aprenderemos a usar este módulo junto con el módulo ansible.builtin.find para listar archivos de una manera más nativa de Ansible.

Uso del Módulo find

El módulo ansible.builtin.find está diseñado para localizar archivos que coinciden con criterios específicos. Proporciona una forma más potente y flexible de listar archivos en comparación con el módulo command.

Creemos un nuevo playbook que use el módulo find:

1. En el panel del Explorador, navegue al directorio ~/project/ansible-lab
2. Haga clic con el botón derecho y seleccione "Nuevo archivo"
3. Nombre el archivo find_files.yml
4. Agregue el siguiente contenido:

---
- 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]

Este playbook usa el módulo find para localizar todos los archivos y directorios en el directorio /etc y luego muestra los primeros 10 elementos.

Ejecutemos el playbook:

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

Debería ver una salida que contiene información detallada sobre cada archivo, incluyendo:

• Ruta (Path)
• Modo (permisos)
• Propietario y grupo
• Tamaño
• Tiempo de modificación

Creación de un Playbook con Detalles en Formato Largo

Ahora, creemos un playbook más completo que muestre los archivos en formato largo con todos los detalles:

1. En el panel del Explorador, haga clic con el botón derecho y seleccione "Nuevo archivo"
2. Nombre el archivo long_format.yml
3. Agregue el siguiente contenido:

---
- 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] }}"

Este playbook:

1. Usa el módulo find para localizar archivos en el directorio /etc
2. Crea una lista formateada que se asemeja a la salida del comando ls -l
3. Muestra los primeros 10 archivos de la lista

Ejecutemos el playbook:

ansible-playbook long_format.yml

La salida mostrará los detalles del archivo en un formato similar al comando ls -l.

Filtrado de Archivos Basado en Criterios

Una ventaja de usar los módulos de Ansible es la capacidad de filtrar archivos en función de varios criterios. Creemos un playbook que liste solo los archivos de configuración (archivos que terminan con .conf):

1. En el panel del Explorador, haga clic con el botón derecho y seleccione "Nuevo archivo"
2. Nombre el archivo filter_files.yml
3. Agregue el siguiente contenido:

---
- 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 }}"

Este playbook:

1. Usa el módulo find para localizar archivos en el directorio /etc que terminan con .conf
2. Muestra cada archivo con sus detalles

Ejecutemos el playbook:

ansible-playbook filter_files.yml

La salida mostrará detalles solo para los archivos .conf en el directorio /etc.

Comparación con el Módulo Command

Creemos un playbook más para comparar la salida del módulo find con el comando tradicional ls -l:

1. En el panel del Explorador, haga clic con el botón derecho y seleccione "Nuevo archivo"
2. Nombre el archivo compare_methods.yml
3. Agregue el siguiente contenido:

---
- 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]

Este playbook:

1. Usa el módulo command para ejecutar ls -l en el archivo /etc/passwd
2. Usa el módulo find para localizar el mismo archivo
3. Muestra ambas salidas para la comparación

Ejecutemos el playbook:

ansible-playbook compare_methods.yml

Ahora puede ver la diferencia entre los dos métodos:

• El comando ls -l le da una sola línea de texto en el formato Unix tradicional
• El módulo find le da un objeto de datos estructurado que puede manipular en Ansible

Creación de un Rol Reutilizable para Listado de Archivos

En este paso, aprenderemos a crear un rol de Ansible para listar archivos. Los roles son una forma de organizar los playbooks y hacerlos más reutilizables. Esto es especialmente útil cuando necesita realizar la misma tarea en múltiples playbooks o proyectos.

Entendiendo los Roles de Ansible

Un rol de Ansible es un conjunto de tareas, variables, archivos, plantillas y otros recursos que se agrupan en una estructura de directorio estándar. Los roles facilitan la reutilización del código y su compartición con otros.

La estructura de directorio estándar para un rol se ve así:

roles/
  rolename/
    tasks/      ## Tareas principales para el rol
    handlers/   ## Handlers activados por las tareas
    defaults/   ## Variables predeterminadas
    vars/       ## Variables del rol
    files/      ## Archivos estáticos
    templates/  ## Plantillas
    meta/       ## Metadatos para el rol

Creación de un Rol de Listado de Archivos

Creemos un rol para listar archivos en formato largo:

1. Primero, cree la estructura de directorio para nuestro rol:

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

2. Cree el archivo de tarea principal para nuestro rol:

cd ~/project/ansible-lab

3. En el panel del Explorador, navegue a ~/project/ansible-lab/roles/file_lister/tasks
4. Haga clic con el botón derecho y seleccione "Nuevo archivo"
5. Nombre el archivo main.yml
6. Agregue el siguiente contenido:

---
## 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))

Este rol:

1. Encuentra archivos en un directorio especificado en función de los parámetros
2. Muestra los archivos en formato largo o solo las rutas
3. Usa valores predeterminados para los parámetros si no se especifican

Uso de Nuestro Rol en un Playbook

Ahora, creemos un playbook que use nuestro nuevo rol:

1. En el panel del Explorador, navegue al directorio ~/project/ansible-lab
2. Haga clic con el botón derecho y seleccione "Nuevo archivo"
3. Nombre el archivo use_role.yml
4. Agregue el siguiente contenido:

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

Este playbook:

1. Se ejecuta en el host local
2. Usa nuestro rol file_lister
3. Establece variables para que el rol personalice su comportamiento

Ejecutemos el playbook:

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

Debería ver la salida que muestra los detalles de todos los archivos .conf en el directorio /etc.

Personalización de las Variables del Rol

Una de las ventajas de los roles es que podemos personalizar fácilmente su comportamiento cambiando las variables. Creemos otro playbook que use nuestro rol con diferentes parámetros:

1. En el panel del Explorador, haga clic con el botón derecho y seleccione "Nuevo archivo"
2. Nombre el archivo custom_listing.yml
3. Agregue el siguiente contenido:

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

Este playbook:

1. Usa nuestro rol file_lister
2. Lo configura para buscar en el directorio /home/labex
3. Filtra los archivos YAML (*.yml)
4. Muestra solo las rutas de los archivos (no los detalles completos)

Ejecutemos el playbook:

ansible-playbook custom_listing.yml

Debería ver una lista de todos los archivos YAML en el directorio /home/labex, sin la información detallada.

Uso Avanzado: Creación de un Informe

Finalmente, creemos un playbook más avanzado que use nuestro rol para generar un informe de archivos:

1. En el panel del Explorador, haga clic con el botón derecho y seleccione "Nuevo archivo"
2. Nombre el archivo generate_report.yml
3. Agregue el siguiente contenido:

---
- 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 }}"

Este playbook:

1. Encuentra archivos .conf en el directorio /etc
2. Crea un archivo de texto con un encabezado
3. Agrega información sobre cada archivo al informe
4. Muestra la ubicación del informe

Ejecutemos el playbook:

ansible-playbook generate_report.yml

Después de ejecutar el playbook, puede ver el informe:

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

Debería ver un informe formateado que enumera todos los archivos .conf en el directorio /etc.

Resumen

En este laboratorio, ha aprendido a usar Ansible para listar archivos y directorios en formato largo. Ha adquirido experiencia práctica con:

1. Configuración de Ansible mediante la instalación del software y la creación de un archivo de inventario
2. Creación de playbooks básicos que usan el módulo command para ejecutar el comando ls -l
3. Uso de los módulos file y find integrados de Ansible para obtener información detallada sobre los archivos
4. Creación de un rol de Ansible reutilizable para listar archivos con varias opciones
5. Generación de informes formateados basados en la información de los archivos

Estas habilidades le ayudarán a automatizar las tareas de gestión de archivos en su infraestructura e integrar listados de archivos en flujos de trabajo de automatización más amplios. A medida que continúe trabajando con Ansible, puede basarse en estos conceptos para crear automatizaciones más complejas que gestionen archivos, directorios y sus permisos en todo su entorno.