Como listar arquivos e diretórios em formato longo com Ansible

Introdução

Ansible é uma ferramenta de automação de TI amplamente utilizada que simplifica o gerenciamento e a implantação de infraestrutura. Neste laboratório, exploraremos como listar arquivos e diretórios em formato longo usando Ansible. Você aprenderá como configurar o Ansible, criar playbooks e usar os módulos embutidos para listar informações de arquivos de sistemas remotos. Ao final deste laboratório, você terá experiência prática com comandos e técnicas do Ansible que podem aprimorar seus fluxos de trabalho de automação.

Instalando e Configurando o Ansible

Nesta etapa, instalaremos o Ansible em nosso sistema e criaremos um arquivo de inventário básico para gerenciar nosso ambiente local.

Instalando o Ansible

Primeiramente, vamos instalar o Ansible usando o gerenciador de pacotes:

sudo apt update
sudo apt install -y ansible

Após a conclusão da instalação, verifique se o Ansible foi instalado corretamente, verificando sua versão:

ansible --version

Você deve ver uma saída semelhante 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

Criando um Inventário Ansible

Um arquivo de inventário é uma lista de nós gerenciados com os quais o Ansible pode trabalhar. Para este laboratório, criaremos um arquivo de inventário simples que inclui nossa máquina local.

Crie um diretório para nosso projeto Ansible:

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

Agora, crie um arquivo de inventário usando o editor VS Code:

1. Clique no ícone "Explorer" na barra lateral esquerda
2. Navegue até o diretório ~/project/ansible-lab
3. Clique com o botão direito e selecione "New File" (Novo Arquivo)
4. Nomeie o arquivo inventory.ini
5. Adicione o seguinte conteúdo ao arquivo:

[local]
localhost ansible_connection=local

Este arquivo de inventário define um grupo chamado local que inclui apenas nosso localhost e especifica que o Ansible deve se conectar localmente, em vez de usar SSH.

Criando o Arquivo de Configuração do Ansible

Vamos criar um arquivo de configuração básico do Ansible para especificar as configurações padrão:

1. No painel Explorer, clique com o botão direito no diretório ansible-lab e selecione "New File" (Novo Arquivo)
2. Nomeie o arquivo ansible.cfg
3. Adicione o seguinte conteúdo:

[defaults]
inventory = inventory.ini
host_key_checking = False

Este arquivo de configuração informa ao Ansible para usar nosso arquivo inventory.ini por padrão e desabilita a verificação da chave do host SSH, o que é útil para ambientes de laboratório.

Testando a Configuração

Vamos testar nossa configuração do Ansible executando um comando simples:

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

Você deve ver uma saída semelhante a esta:

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

Isso confirma que o Ansible está configurado corretamente e pode se comunicar com nossa máquina local.

Criando um Playbook Ansible Básico para Listar Arquivos

Nesta etapa, criaremos um playbook Ansible básico para listar arquivos e diretórios. Playbooks são arquivos YAML que definem um conjunto de tarefas a serem executadas em nós gerenciados.

Entendendo Playbooks Ansible

Antes de começarmos a criar nosso playbook, vamos entender o que é um playbook:

• Um playbook é um arquivo YAML que contém uma lista de plays
• Cada play define um conjunto de tarefas a serem executadas em um grupo específico de hosts
• Tarefas são ações individuais que chamam módulos Ansible
• Módulos são unidades de código reutilizáveis que executam operações específicas

Criando Nosso Primeiro Playbook

Vamos criar um playbook simples para listar o conteúdo do diretório /etc:

1. No painel Explorer, navegue até o diretório ~/project/ansible-lab
2. Clique com o botão direito e selecione "New File" (Novo Arquivo)
3. Nomeie o arquivo list_files.yml
4. Adicione o seguinte conteúdo:

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

Vamos entender o que este playbook faz:

• A primeira linha (---) indica o início de um documento YAML
• name: List files and directories é um nome descritivo para o play
• hosts: local especifica que este play será executado em hosts no grupo local (definido em nosso inventário)
• tasks: inicia a lista de tarefas a serem executadas
• A primeira tarefa executa o comando ls -l /etc e armazena o resultado em uma variável chamada directory_contents
• A segunda tarefa exibe o conteúdo da variável directory_contents.stdout_lines

Executando o Playbook

Agora vamos executar nosso playbook:

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

Você deve ver uma saída semelhante 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

A saída mostra o conteúdo do diretório /etc no formato longo, que inclui permissões, proprietário, grupo, tamanho e data de modificação.

Usando um Diretório Diferente

Agora vamos modificar nosso playbook para listar o conteúdo do diretório /home/labex:

1. Abra o arquivo list_files.yml no editor
2. Altere o caminho no comando de /etc para /home/labex
3. Salve o arquivo com o seguinte conteúdo:

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

Execute o playbook novamente:

ansible-playbook list_files.yml

A saída agora mostrará o conteúdo do diretório /home/labex em vez de /etc.

Usando o Módulo File do Ansible para Listagem em Formato Longo

Na etapa anterior, usamos o módulo command para executar o comando ls -l. Embora isso funcione, o Ansible fornece um módulo mais dedicado para trabalhar com arquivos e diretórios: o módulo ansible.builtin.file. Nesta etapa, aprenderemos como usar este módulo junto com o módulo ansible.builtin.find para listar arquivos de uma maneira mais nativa do Ansible.

Usando o Módulo find

O módulo ansible.builtin.find foi projetado para localizar arquivos que correspondem a critérios específicos. Ele fornece uma maneira mais poderosa e flexível de listar arquivos em comparação com o módulo command.

Vamos criar um novo playbook que usa o módulo find:

1. No painel Explorer, navegue até o diretório ~/project/ansible-lab
2. Clique com o botão direito e selecione "New File" (Novo Arquivo)
3. Nomeie o arquivo find_files.yml
4. Adicione o seguinte conteúdo:

---
- 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 o módulo find para localizar todos os arquivos e diretórios no diretório /etc e, em seguida, exibe os primeiros 10 itens.

Vamos executar o playbook:

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

Você deve ver uma saída que contém informações detalhadas sobre cada arquivo, incluindo:

• Path (Caminho)
• Mode (Modo - permissões)
• Owner and group (Proprietário e grupo)
• Size (Tamanho)
• Modified time (Tempo de modificação)

Criando um Playbook com Detalhes em Formato Longo

Agora, vamos criar um playbook mais abrangente que exibe arquivos em um formato longo com todos os detalhes:

1. No painel Explorer, clique com o botão direito e selecione "New File" (Novo Arquivo)
2. Nomeie o arquivo long_format.yml
3. Adicione o seguinte conteúdo:

---
- 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 o módulo find para localizar arquivos no diretório /etc
2. Cria uma lista formatada que se assemelha à saída do comando ls -l
3. Exibe os primeiros 10 arquivos na lista

Vamos executar o playbook:

ansible-playbook long_format.yml

A saída mostrará os detalhes do arquivo em um formato semelhante ao comando ls -l.

Filtrando Arquivos com Base em Critérios

Uma vantagem de usar os módulos do Ansible é a capacidade de filtrar arquivos com base em vários critérios. Vamos criar um playbook que lista apenas os arquivos de configuração (arquivos terminados em .conf):

1. No painel Explorer, clique com o botão direito e selecione "New File" (Novo Arquivo)
2. Nomeie o arquivo filter_files.yml
3. Adicione o seguinte conteúdo:

---
- 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 o módulo find para localizar arquivos no diretório /etc que terminam com .conf
2. Exibe cada arquivo com seus detalhes

Vamos executar o playbook:

ansible-playbook filter_files.yml

A saída mostrará detalhes apenas para arquivos .conf no diretório /etc.

Comparando com o Módulo Command

Vamos criar mais um playbook para comparar a saída do módulo find com o comando tradicional ls -l:

1. No painel Explorer, clique com o botão direito e selecione "New File" (Novo Arquivo)
2. Nomeie o arquivo compare_methods.yml
3. Adicione o seguinte conteúdo:

---
- 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 o módulo command para executar ls -l no arquivo /etc/passwd
2. Usa o módulo find para localizar o mesmo arquivo
3. Exibe ambas as saídas para comparação

Vamos executar o playbook:

ansible-playbook compare_methods.yml

Agora você pode ver a diferença entre os dois métodos:

• O comando ls -l fornece uma única linha de texto no formato Unix tradicional
• O módulo find fornece um objeto de dados estruturado que você pode manipular no Ansible

Criando um Role Reutilizável para Listagem de Arquivos

Nesta etapa, aprenderemos como criar um role Ansible para listagem de arquivos. Roles são uma maneira de organizar playbooks e torná-los mais reutilizáveis. Isso é especialmente útil quando você precisa executar a mesma tarefa em vários playbooks ou projetos.

Entendendo Roles Ansible

Um role Ansible é um conjunto de tarefas, variáveis, arquivos, templates e outros recursos que são agrupados em uma estrutura de diretórios padrão. Roles facilitam a reutilização de código e o compartilhamento com outras pessoas.

A estrutura de diretórios padrão para um role se parece com isto:

roles/
  rolename/
    tasks/      ## Tarefas principais para o role
    handlers/   ## Handlers acionados por tarefas
    defaults/   ## Variáveis padrão
    vars/       ## Variáveis do role
    files/      ## Arquivos estáticos
    templates/  ## Templates
    meta/       ## Metadados para o role

Criando um Role de Listagem de Arquivos

Vamos criar um role para listar arquivos em formato longo:

1. Primeiro, crie a estrutura de diretórios para nosso role:

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

2. Crie o arquivo de tarefa principal para nosso role:

cd ~/project/ansible-lab

3. No painel Explorer, navegue até ~/project/ansible-lab/roles/file_lister/tasks
4. Clique com o botão direito e selecione "New File" (Novo Arquivo)
5. Nomeie o arquivo main.yml
6. Adicione o seguinte conteúdo:

---
## 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 role:

1. Encontra arquivos em um diretório especificado com base em parâmetros
2. Exibe os arquivos em formato longo ou apenas os caminhos
3. Usa valores padrão para parâmetros se eles não forem especificados

Usando Nosso Role em um Playbook

Agora, vamos criar um playbook que usa nosso novo role:

1. No painel Explorer, navegue até o diretório ~/project/ansible-lab
2. Clique com o botão direito e selecione "New File" (Novo Arquivo)
3. Nomeie o arquivo use_role.yml
4. Adicione o seguinte conteúdo:

---
- 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. É executado no host local
2. Usa nosso role file_lister
3. Define variáveis para o role para personalizar seu comportamento

Vamos executar o playbook:

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

Você deve ver a saída mostrando os detalhes de todos os arquivos .conf no diretório /etc.

Personalizando Variáveis do Role

Uma das vantagens dos roles é que podemos personalizar facilmente seu comportamento alterando as variáveis. Vamos criar outro playbook que usa nosso role com parâmetros diferentes:

1. No painel Explorer, clique com o botão direito e selecione "New File" (Novo Arquivo)
2. Nomeie o arquivo custom_listing.yml
3. Adicione o seguinte conteúdo:

---
- 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 nosso role file_lister
2. Define-o para procurar no diretório /home/labex
3. Filtra por arquivos YAML (*.yml)
4. Mostra apenas os caminhos dos arquivos (não os detalhes completos)

Vamos executar o playbook:

ansible-playbook custom_listing.yml

Você deve ver uma lista de todos os arquivos YAML no diretório /home/labex, sem as informações detalhadas.

Uso Avançado: Criando um Relatório

Finalmente, vamos criar um playbook mais avançado que usa nosso role para gerar um relatório de arquivos:

1. No painel Explorer, clique com o botão direito e selecione "New File" (Novo Arquivo)
2. Nomeie o arquivo generate_report.yml
3. Adicione o seguinte conteúdo:

---
- 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. Encontra arquivos .conf no diretório /etc
2. Cria um arquivo de texto com um cabeçalho
3. Anexa informações sobre cada arquivo ao relatório
4. Exibe a localização do relatório

Vamos executar o playbook:

ansible-playbook generate_report.yml

Após executar o playbook, você pode visualizar o relatório:

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

Você deve ver um relatório formatado listando todos os arquivos .conf no diretório /etc.

Resumo

Neste laboratório, você aprendeu como usar o Ansible para listar arquivos e diretórios em formato longo. Você adquiriu experiência prática com:

1. Configuração do Ansible, instalando o software e criando um arquivo de inventário
2. Criação de playbooks básicos que usam o módulo command para executar o comando ls -l
3. Uso dos módulos file e find integrados do Ansible para obter informações detalhadas sobre arquivos
4. Criação de um role Ansible reutilizável para listar arquivos com várias opções
5. Geração de relatórios formatados com base em informações de arquivos

Essas habilidades ajudarão você a automatizar tarefas de gerenciamento de arquivos em sua infraestrutura e integrar listagens de arquivos em fluxos de trabalho de automação maiores. À medida que você continua trabalhando com o Ansible, pode construir sobre esses conceitos para criar automações mais complexas que gerenciam arquivos, diretórios e suas permissões em todo o seu ambiente.