Dateien und Verzeichnisse im Long-Format mit Ansible auflisten - Anleitung & Tipps

Einführung

Ansible ist ein weit verbreitetes IT-Automatisierungstool, das die Infrastrukturverwaltung und -bereitstellung vereinfacht. In diesem Lab werden wir untersuchen, wie man Dateien und Verzeichnisse im Langformat mit Ansible auflistet. Sie werden lernen, wie man Ansible einrichtet, Playbooks erstellt und die integrierten Module verwendet, um Dateiinformationen von Remote-Systemen aufzulisten. Am Ende dieses Labs werden Sie praktische Erfahrungen mit Ansible-Befehlen und -Techniken haben, die Ihre Automatisierungs-Workflows verbessern können.

Installation und Einrichtung von Ansible

In diesem Schritt installieren wir Ansible auf unserem System und erstellen eine grundlegende Inventory-Datei, um unsere lokale Umgebung zu verwalten.

Installation von Ansible

Zuerst installieren wir Ansible mit dem Paketmanager:

sudo apt update
sudo apt install -y ansible

Nachdem die Installation abgeschlossen ist, überprüfen Sie, ob Ansible korrekt installiert wurde, indem Sie die Version überprüfen:

ansible --version

Sie sollten eine Ausgabe ähnlich dieser sehen:

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

Erstellen eines Ansible Inventory

Eine Inventory-Datei ist eine Liste der verwalteten Knoten, mit denen Ansible arbeiten kann. Für dieses Lab erstellen wir eine einfache Inventory-Datei, die unsere lokale Maschine enthält.

Erstellen Sie ein Verzeichnis für unser Ansible-Projekt:

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

Erstellen Sie nun eine Inventory-Datei mit dem VS Code Editor:

Klicken Sie auf das Symbol "Explorer" in der linken Seitenleiste.
Navigieren Sie zum Verzeichnis ~/project/ansible-lab.
Klicken Sie mit der rechten Maustaste und wählen Sie "New File" (Neue Datei).
Benennen Sie die Datei inventory.ini.
Fügen Sie der Datei den folgenden Inhalt hinzu:

[local]
localhost ansible_connection=local

Diese Inventory-Datei definiert eine Gruppe namens local, die nur unseren Host enthält, und gibt an, dass Ansible lokal anstatt über SSH eine Verbindung herstellen soll.

Erstellen der Ansible-Konfigurationsdatei

Erstellen wir eine grundlegende Ansible-Konfigurationsdatei, um Standardeinstellungen festzulegen:

Klicken Sie im Explorer-Panel mit der rechten Maustaste auf das Verzeichnis ansible-lab und wählen Sie "New File" (Neue Datei).
Benennen Sie die Datei ansible.cfg.
Fügen Sie den folgenden Inhalt hinzu:

[defaults]
inventory = inventory.ini
host_key_checking = False

Diese Konfigurationsdatei weist Ansible an, standardmäßig unsere Datei inventory.ini zu verwenden und die SSH-Host-Key-Überprüfung zu deaktivieren, was für Lab-Umgebungen nützlich ist.

Testen der Einrichtung

Testen wir unsere Ansible-Einrichtung, indem wir einen einfachen Befehl ausführen:

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

Sie sollten eine Ausgabe ähnlich dieser sehen:

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

Dies bestätigt, dass Ansible korrekt konfiguriert ist und mit unserer lokalen Maschine kommunizieren kann.

Erstellen eines einfachen Ansible Playbooks zum Auflisten von Dateien

In diesem Schritt erstellen wir ein einfaches Ansible Playbook, um Dateien und Verzeichnisse aufzulisten. Playbooks sind YAML-Dateien, die eine Reihe von Aufgaben definieren, die auf verwalteten Knoten ausgeführt werden sollen.

Verstehen von Ansible Playbooks

Bevor wir mit der Erstellung unseres Playbooks beginnen, wollen wir verstehen, was ein Playbook ist:

Ein Playbook ist eine YAML-Datei, die eine Liste von Plays enthält.
Jeder Play definiert eine Reihe von Aufgaben, die auf einer bestimmten Gruppe von Hosts ausgeführt werden sollen.
Aufgaben sind einzelne Aktionen, die Ansible-Module aufrufen.
Module sind wiederverwendbare Codeeinheiten, die bestimmte Operationen ausführen.

Erstellen unseres ersten Playbooks

Erstellen wir ein einfaches Playbook, um den Inhalt des Verzeichnisses /etc aufzulisten:

Navigieren Sie im Explorer-Panel zum Verzeichnis ~/project/ansible-lab.
Klicken Sie mit der rechten Maustaste und wählen Sie "New File" (Neue Datei).
Benennen Sie die Datei list_files.yml.
Fügen Sie den folgenden Inhalt hinzu:

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

Lassen Sie uns verstehen, was dieses Playbook tut:

Die erste Zeile (---) kennzeichnet den Beginn eines YAML-Dokuments.
name: List files and directories ist ein beschreibender Name für den Play.
hosts: local gibt an, dass dieser Play auf Hosts in der Gruppe local ausgeführt wird (definiert in unserem Inventory).
tasks: beginnt die Liste der auszuführenden Aufgaben.
Die erste Aufgabe führt den Befehl ls -l /etc aus und speichert das Ergebnis in einer Variable namens directory_contents.
Die zweite Aufgabe zeigt den Inhalt der Variable directory_contents.stdout_lines an.

Ausführen des Playbooks

Führen wir nun unser Playbook aus:

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

Sie sollten eine Ausgabe ähnlich dieser sehen:

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

Die Ausgabe zeigt den Inhalt des Verzeichnisses /etc im Langformat, das Berechtigungen, Eigentümer, Gruppe, Größe und Änderungsdatum enthält.

Verwenden eines anderen Verzeichnisses

Ändern wir nun unser Playbook, um den Inhalt des Verzeichnisses /home/labex aufzulisten:

Öffnen Sie die Datei list_files.yml im Editor.
Ändern Sie den Pfad im Befehl von /etc in /home/labex.
Speichern Sie die Datei mit dem folgenden Inhalt:

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

Führen Sie das Playbook erneut aus:

ansible-playbook list_files.yml

Die Ausgabe zeigt nun den Inhalt des Verzeichnisses /home/labex anstelle von /etc.

Verwendung des Ansible File-Moduls für die Long-Format-Auflistung

Im vorherigen Schritt haben wir das command-Modul verwendet, um den Befehl ls -l auszuführen. Obwohl dies funktioniert, bietet Ansible ein spezialisierteres Modul für die Arbeit mit Dateien und Verzeichnissen: das Modul ansible.builtin.file. In diesem Schritt lernen wir, wie man dieses Modul zusammen mit dem Modul ansible.builtin.find verwendet, um Dateien auf eine Ansible-native Art und Weise aufzulisten.

Verwendung des find-Moduls

Das Modul ansible.builtin.find wurde entwickelt, um Dateien zu finden, die bestimmten Kriterien entsprechen. Es bietet eine leistungsfähigere und flexiblere Möglichkeit, Dateien aufzulisten, im Vergleich zum command-Modul.

Erstellen wir ein neues Playbook, das das find-Modul verwendet:

Navigieren Sie im Explorer-Panel zum Verzeichnis ~/project/ansible-lab.
Klicken Sie mit der rechten Maustaste und wählen Sie "New File" (Neue Datei).
Benennen Sie die Datei find_files.yml.
Fügen Sie den folgenden Inhalt hinzu:

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

Dieses Playbook verwendet das find-Modul, um alle Dateien und Verzeichnisse im Verzeichnis /etc zu finden und dann die ersten 10 Elemente anzuzeigen.

Führen wir das Playbook aus:

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

Sie sollten eine Ausgabe sehen, die detaillierte Informationen über jede Datei enthält, einschließlich:

Pfad
Modus (Berechtigungen)
Eigentümer und Gruppe
Größe
Änderungszeit

Erstellen eines Playbooks mit Long-Format-Details

Erstellen wir nun ein umfassenderes Playbook, das Dateien im Long-Format mit allen Details anzeigt:

Klicken Sie im Explorer-Panel mit der rechten Maustaste und wählen Sie "New File" (Neue Datei).
Benennen Sie die Datei long_format.yml.
Fügen Sie den folgenden Inhalt hinzu:

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

Dieses Playbook:

Verwendet das find-Modul, um Dateien im Verzeichnis /etc zu finden.
Erstellt eine formatierte Liste, die der Ausgabe des Befehls ls -l ähnelt.
Zeigt die ersten 10 Dateien in der Liste an.

Führen wir das Playbook aus:

ansible-playbook long_format.yml

Die Ausgabe zeigt Dateidetails in einem Format, das dem Befehl ls -l ähnelt.

Filtern von Dateien basierend auf Kriterien

Ein Vorteil der Verwendung der Ansible-Module ist die Möglichkeit, Dateien basierend auf verschiedenen Kriterien zu filtern. Erstellen wir ein Playbook, das nur die Konfigurationsdateien (Dateien, die mit .conf enden) auflistet:

Klicken Sie im Explorer-Panel mit der rechten Maustaste und wählen Sie "New File" (Neue Datei).
Benennen Sie die Datei filter_files.yml.
Fügen Sie den folgenden Inhalt hinzu:

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

Dieses Playbook:

Verwendet das find-Modul, um Dateien im Verzeichnis /etc zu finden, die mit .conf enden.
Zeigt jede Datei mit ihren Details an.

Führen wir das Playbook aus:

ansible-playbook filter_files.yml

Die Ausgabe zeigt Details nur für .conf-Dateien im Verzeichnis /etc.

Vergleichen mit dem Command-Modul

Erstellen wir noch ein Playbook, um die Ausgabe des find-Moduls mit dem traditionellen Befehl ls -l zu vergleichen:

Klicken Sie im Explorer-Panel mit der rechten Maustaste und wählen Sie "New File" (Neue Datei).
Benennen Sie die Datei compare_methods.yml.
Fügen Sie den folgenden Inhalt hinzu:

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

Dieses Playbook:

Verwendet das command-Modul, um ls -l für die Datei /etc/passwd auszuführen.
Verwendet das find-Modul, um dieselbe Datei zu finden.
Zeigt beide Ausgaben zum Vergleich an.

Führen wir das Playbook aus:

ansible-playbook compare_methods.yml

Sie können nun den Unterschied zwischen den beiden Methoden sehen:

Der Befehl ls -l liefert Ihnen eine einzelne Textzeile im traditionellen Unix-Format.
Das find-Modul liefert Ihnen ein strukturiertes Datenobjekt, das Sie in Ansible manipulieren können.

Erstellen einer wiederverwendbaren Rolle für die Dateiauflistung

In diesem Schritt lernen wir, wie man eine Ansible-Rolle für die Dateiauflistung erstellt. Rollen sind eine Möglichkeit, Playbooks zu organisieren und wiederverwendbarer zu machen. Dies ist besonders nützlich, wenn Sie dieselbe Aufgabe in mehreren Playbooks oder Projekten ausführen müssen.

Verstehen von Ansible-Rollen

Eine Ansible-Rolle ist eine Reihe von Aufgaben, Variablen, Dateien, Vorlagen und anderen Ressourcen, die in einer Standardverzeichnisstruktur zusammengefasst sind. Rollen erleichtern die Wiederverwendung von Code und dessen Weitergabe an andere.

Die Standardverzeichnisstruktur für eine Rolle sieht so aus:

roles/
  rolename/
    tasks/      ## Hauptaufgaben für die Rolle
    handlers/   ## Handler, die durch Aufgaben ausgelöst werden
    defaults/   ## Standardvariablen
    vars/       ## Rollenvariablen
    files/      ## Statische Dateien
    templates/  ## Vorlagen
    meta/       ## Metadaten für die Rolle

Erstellen einer Dateiauflistungsrolle

Erstellen wir eine Rolle für die Auflistung von Dateien im Long-Format:

Erstellen Sie zuerst die Verzeichnisstruktur für unsere Rolle:

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

Erstellen Sie die Hauptaufgabendatei für unsere Rolle:

cd ~/project/ansible-lab

Navigieren Sie im Explorer-Panel zu ~/project/ansible-lab/roles/file_lister/tasks.
Klicken Sie mit der rechten Maustaste und wählen Sie "New File" (Neue Datei).
Benennen Sie die Datei main.yml.
Fügen Sie den folgenden Inhalt hinzu:

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

Diese Rolle:

Findet Dateien in einem angegebenen Verzeichnis basierend auf Parametern.
Zeigt die Dateien entweder im Long-Format oder nur die Pfade an.
Verwendet Standardwerte für Parameter, wenn diese nicht angegeben sind.

Verwenden unserer Rolle in einem Playbook

Erstellen wir nun ein Playbook, das unsere neue Rolle verwendet:

Navigieren Sie im Explorer-Panel zum Verzeichnis ~/project/ansible-lab.
Klicken Sie mit der rechten Maustaste und wählen Sie "New File" (Neue Datei).
Benennen Sie die Datei use_role.yml.
Fügen Sie den folgenden Inhalt hinzu:

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

Dieses Playbook:

Wird auf dem lokalen Host ausgeführt.
Verwendet unsere Rolle file_lister.
Legt Variablen für die Rolle fest, um ihr Verhalten anzupassen.

Führen wir das Playbook aus:

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

Sie sollten eine Ausgabe sehen, die die Details aller .conf-Dateien im Verzeichnis /etc anzeigt.

Anpassen von Rollenvariablen

Einer der Vorteile von Rollen ist, dass wir ihr Verhalten einfach anpassen können, indem wir die Variablen ändern. Erstellen wir ein weiteres Playbook, das unsere Rolle mit anderen Parametern verwendet:

Klicken Sie im Explorer-Panel mit der rechten Maustaste und wählen Sie "New File" (Neue Datei).
Benennen Sie die Datei custom_listing.yml.
Fügen Sie den folgenden Inhalt hinzu:

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

Dieses Playbook:

Verwendet unsere Rolle file_lister.
Legt fest, dass im Verzeichnis /home/labex gesucht werden soll.
Filtert nach YAML-Dateien (*.yml).
Zeigt nur Dateipfade an (keine vollständigen Details).

Führen wir das Playbook aus:

ansible-playbook custom_listing.yml

Sie sollten eine Liste aller YAML-Dateien im Verzeichnis /home/labex sehen, ohne die detaillierten Informationen.

Erweiterte Verwendung: Erstellen eines Berichts

Erstellen wir abschließend ein fortgeschritteneres Playbook, das unsere Rolle verwendet, um einen Bericht über Dateien zu generieren:

Klicken Sie im Explorer-Panel mit der rechten Maustaste und wählen Sie "New File" (Neue Datei).
Benennen Sie die Datei generate_report.yml.
Fügen Sie den folgenden Inhalt hinzu:

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

Dieses Playbook:

Findet .conf-Dateien im Verzeichnis /etc.
Erstellt eine Textdatei mit einem Header.
Fügt Informationen über jede Datei an den Bericht an.
Zeigt den Speicherort des Berichts an.

Führen wir das Playbook aus:

ansible-playbook generate_report.yml

Nachdem Sie das Playbook ausgeführt haben, können Sie den Bericht anzeigen:

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

Sie sollten einen formatierten Bericht sehen, der alle .conf-Dateien im Verzeichnis /etc auflistet.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie man Ansible verwendet, um Dateien und Verzeichnisse im Long-Format aufzulisten. Sie haben praktische Erfahrung gesammelt mit:

Einrichten von Ansible durch Installation der Software und Erstellung einer Inventory-Datei.
Erstellen von grundlegenden Playbooks, die das Command-Modul verwenden, um den Befehl ls -l auszuführen.
Verwenden der integrierten File- und Find-Module von Ansible, um detaillierte Informationen über Dateien zu erhalten.
Erstellen einer wiederverwendbaren Ansible-Rolle für die Auflistung von Dateien mit verschiedenen Optionen.
Generieren von formatierten Berichten basierend auf Dateiinformationen.

Diese Fähigkeiten helfen Ihnen, Dateiverwaltungsaufgaben in Ihrer Infrastruktur zu automatisieren und Dateilisten in größere Automatisierungs-Workflows zu integrieren. Wenn Sie weiterhin mit Ansible arbeiten, können Sie auf diesen Konzepten aufbauen, um komplexere Automatisierungen zu erstellen, die Dateien, Verzeichnisse und deren Berechtigungen in Ihrer gesamten Umgebung verwalten.