Ansible Command-Modul: Von den Grundlagen bis hin zu realen Anwendungen

Einführung

In diesem Lab werden Sie das Ansible Command-Modul erkunden, ein leistungsstarkes Werkzeug zum Ausführen von Befehlen auf Remote-Hosts. Das Command-Modul ermöglicht es Ihnen, direkt aus Ihren Ansible-Playbooks und -Tasks mit der Kommandozeile zu interagieren und bietet so eine vielseitige Möglichkeit zur Verwaltung von Remote-Systemen. Im Laufe dieses Labs werden Sie lernen, wie Sie das Ansible Command-Modul verwenden, um verschiedene Befehle auszuführen, mit Variablen und Argumenten zu arbeiten und die Befehlsausgabe zu erfassen.

Erstellen Sie ein einfaches Ansible-Playbook

In diesem Schritt werden Sie Ihr erstes Ansible-Playbook erstellen, indem Sie das Command-Modul verwenden, um einen einfachen Befehl auszuführen.

Zunächst navigieren Sie in das Projektverzeichnis:

cd ~/project

Nun erstellen Sie eine neue Datei namens simple_command.yml mit einem Texteditor Ihrer Wahl. Beispielsweise können Sie den nano-Editor verwenden:

nano simple_command.yml

Fügen Sie der Datei den folgenden Inhalt hinzu:

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

Lassen Sie uns dieses Playbook analysieren:

Die Zeile hosts: localhost gibt an, dass das Playbook auf dem lokalen Rechner ausgeführt wird.
Der Abschnitt tasks enthält eine Liste der auszuführenden Aufgaben.
Die Zeile command: ls -l verwendet das Command-Modul, um den Befehl ls -l auszuführen, der Dateien und Verzeichnisse im ausführlichen Format auflistet.

Speichern Sie die Datei und verlassen Sie den Editor (in nano drücken Sie Ctrl+X, dann Y und anschließend Enter).

Nun führen Sie das Playbook mit dem folgenden Befehl aus:

ansible-playbook simple_command.yml

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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

Diese Ausgabe zeigt an, dass das Playbook erfolgreich ausgeführt wurde und den Befehl ls -l auf Ihrem lokalen Rechner ausgeführt hat.

Verwenden von Variablen mit dem Command-Modul

In diesem Schritt werden Sie lernen, wie Sie Variablen mit dem Ansible Command-Modul verwenden. Variablen ermöglichen es Ihnen, Ihre Playbooks flexibler und wiederverwendbarer zu gestalten.

Erstellen Sie eine neue Datei namens variable_command.yml:

nano variable_command.yml

Fügen Sie der Datei den folgenden Inhalt hinzu:

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

Dieses Playbook führt mehrere neue Konzepte ein:

Der Abschnitt vars definiert Variablen, die im gesamten Playbook verwendet werden können.
Wir verwenden die Syntax {{ variable_name }}, um auf Variablen innerhalb des Befehls zu verweisen.
Das Schlüsselwort register speichert die Ausgabe des Befehls in einer Variablen namens command_output.
Das debug-Modul wird verwendet, um den Inhalt der Variablen command_output anzuzeigen.

Speichern Sie die Datei und verlassen Sie den Editor.

Nun führen Sie das Playbook aus:

ansible-playbook variable_command.yml

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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

Diese Ausgabe zeigt die letzten 5 Zeilen der Datei /etc/passwd und demonstriert, wie Variablen mit dem Command-Modul verwendet werden können.

Erfassen und Verarbeiten von Befehlsausgaben

In diesem Schritt werden Sie lernen, wie Sie die Ausgabe eines Befehls erfassen und mit Ansible weiter verarbeiten.

Erstellen Sie eine neue Datei namens process_output.yml:

nano process_output.yml

Fügen Sie der Datei den folgenden Inhalt hinzu:

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

Dieses Playbook ist robuster und behandelt Fälle, in denen die Root-Partition möglicherweise nicht leicht zu erkennen ist:

Wir zeigen alle Partitionen an, um zu sehen, was verfügbar ist.
Wir verwenden ein flexibleres Muster, um die Root-Partition zu finden.
Wir fügen Prüfungen hinzu, um Fälle zu behandeln, in denen die Root-Partition nicht gefunden wird.
Wir verwenden den Filter default(''), um Fehler zu vermeiden, wenn die Root-Partition nicht gefunden wird.

Speichern Sie die Datei und verlassen Sie den Editor.

Nun führen Sie das Playbook aus:

ansible-playbook process_output.yml

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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

Diese Ausgabe zeigt alle Partitionen, identifiziert die Root-Partition und prüft deren Auslastung. Die genauen Werte können auf Ihrem System abweichen.

Arbeiten mit Command-Modul-Optionen

In diesem Schritt werden Sie einige der Optionen des Ansible Command-Moduls erkunden, um sein Verhalten zu steuern.

Erstellen Sie eine neue Datei namens command_options.yml:

nano command_options.yml

Fügen Sie der Datei den folgenden Inhalt hinzu:

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

Dieses Playbook demonstriert verschiedene Optionen des Command-Moduls:

chdir: Ändert das Arbeitsverzeichnis, bevor der Befehl ausgeführt wird.
environment: Setzt Umgebungsvariablen für den Befehl.
ignore_errors: Setzt die Ausführung des Playbooks fort, auch wenn der Befehl fehlschlägt.
async und poll: Führt den Befehl asynchron mit einem Timeout aus.

Speichern Sie die Datei und verlassen Sie den Editor.

Nun führen Sie das Playbook aus:

ansible-playbook command_options.yml

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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

Diese Ausgabe demonstriert die verschiedenen Verhaltensweisen der von uns erkundeten Optionen des Command-Moduls.

Verwendung des Command-Moduls in einem Docker-freundlichen Szenario

In diesem letzten Schritt werden Sie das Ansible Command-Modul in einem realistischeren, Docker-kompatiblen Szenario verwenden: Überprüfen des Status des SSH-Dienstes und Verwalten desselben, wenn erforderlich.

Erstellen Sie eine neue Datei namens check_service_docker.yml:

nano check_service_docker.yml

Fügen Sie der Datei den folgenden Inhalt hinzu:

---
- name: Check and manage SSH service in Docker
  hosts: localhost
  become: yes ## Dies ermöglicht es Ansible, sudo zu verwenden
  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' }}"

Dieses Playbook führt die folgenden Aktionen aus:

Überprüft den Status des SSH-Dienstes mithilfe des service-Befehls.
Zeigt den aktuellen Status des Dienstes an.
Startet den Dienst, wenn er nicht läuft.
Überprüft den Dienststatus nach einem eventuellen Start.
Zeigt den endgültigen Status des Dienstes an.
Überprüft, ob der SSH-Port (22) auf Verbindungen lauscht.
Zeigt den Status des SSH-Ports an.

Speichern Sie die Datei und verlassen Sie den Editor.

Nun führen Sie das Playbook mit sudo-Rechten aus:

sudo ansible-playbook check_service_docker.yml

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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

Diese Ausgabe zeigt, dass der SSH-Dienst bereits lief und daher nicht gestartet werden musste. Das Playbook hat erfolgreich den Dienststatus überprüft und verifiziert und auch bestätigt, dass der SSH-Port geöffnet ist.

Zusammenfassung

In diesem Lab haben Sie die Vielseitigkeit und Stärke des Ansible Command-Moduls erkundet. Sie haben gelernt, wie Sie:

Einfache Ansible-Playbooks mit dem Command-Modul erstellen, um grundlegende Befehle auszuführen.
Variablen mit dem Command-Modul verwenden, um Ihre Playbooks flexibler und wiederverwendbarer zu gestalten.
Befehlsausgaben erfassen und verarbeiten, um Entscheidungen auf der Grundlage von Befehlsergebnissen zu treffen.
Mit verschiedenen Optionen des Command-Moduls arbeiten, um sein Verhalten zu steuern, wie z. B. das Ändern des Verzeichnisses, das Setzen von Umgebungsvariablen und das Behandeln von Fehlern.
Das Command-Modul in einem realen Szenario anwenden, indem Sie einen Systemdienst überprüfen und verwalten.

Diese Fähigkeiten bilden eine solide Grundlage für die Verwendung von Ansible zur Automatisierung von Systemadministrationstasks und zur effizienten Verwaltung von Remote-Hosts. Wenn Sie weiterhin mit Ansible arbeiten, werden Sie feststellen, dass das Command-Modul ein vielseitiges Werkzeug in Ihrem Automatisierungswerkzeugkasten ist.

Denken Sie daran, dass, obwohl das Command-Modul leistungsstark ist, es oft besser ist, spezialisierte Ansible-Module zu verwenden (wie das service-Modul zur Verwaltung von Diensten), wenn diese verfügbar sind. Diese spezialisierten Module bieten eine bessere Idempotenz und können komplexere Szenarien direkt ausführen.

Üben Sie weiterhin und erkunden Sie die Möglichkeiten von Ansible, um Ihre Automatisierungsfähigkeiten weiter zu verbessern und Ihre IT-Operationen zu optimieren.