LabEx
LoginBeitreten

So konfigurieren Sie die gather_facts Option in einem Ansible Playbook

AnsibleBeginner
Jetzt üben

Einführung

Ansible ist ein leistungsstarkes IT-Automatisierungstool, das Systemadministratoren und Entwicklern hilft, die Infrastruktur effizient zu verwalten. Eine seiner wichtigsten Funktionen ist die Fähigkeit, Informationen über Zielsysteme zu sammeln, die als "Facts" (Fakten) bezeichnet werden. Die Option gather_facts in Ansible bestimmt, ob und wie diese Informationen während der Playbook-Ausführung gesammelt werden.

In diesem praktischen Lab lernen Sie, wie Sie die Option gather_facts in Ansible Playbooks konfigurieren. Sie werden verschiedene Einstellungen erkunden, verstehen, wann die Fakten-Sammlung aktiviert oder deaktiviert werden soll, und entdecken, wie Sie gesammelte Fakten verwenden können, um Ihre Playbooks dynamischer und effizienter zu gestalten. Am Ende dieses Labs werden Sie in der Lage sein, Ihre Ansible-Workflows zu optimieren, indem Sie den Fakten-Sammelprozess entsprechend Ihren spezifischen Bedürfnissen steuern.

Installation von Ansible und Erkundung der Option gather_facts

Beginnen wir mit der Installation von Ansible und der Erkundung der Funktion der Option gather_facts. In diesem Schritt installieren wir Ansible, erstellen ein einfaches Inventory und führen einen Befehl aus, um zu sehen, welche Fakten gesammelt werden.

Installation von Ansible

Zuerst installieren wir Ansible auf unserem System:

sudo apt update
sudo apt install -y ansible

Nach Abschluss der Installation überprüfen Sie, ob Ansible korrekt installiert wurde:

ansible --version

Sie sollten eine Ausgabe ähnlich dieser sehen:

ansible [core 2.12.x]
  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, Aug 14 2022, 00:00:00) [GCC 11.2.0]
  jinja version = 3.0.3
  libyaml = True

Erstellen eines einfachen Inventory

Nun erstellen wir eine einfache Inventory-Datei, mit der wir arbeiten können. Die Inventory-Datei definiert die Hosts, die Ansible verwalten wird. Für dieses Lab erstellen wir ein lokales Inventory:

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

Erstellen Sie eine Inventory-Datei namens hosts mit dem Editor:

  1. Klicken Sie im WebIDE auf das Explorer-Symbol.
  2. Navigieren Sie zum Verzeichnis /home/labex/project/ansible.
  3. Klicken Sie mit der rechten Maustaste und wählen Sie "Neue Datei".
  4. Benennen Sie die Datei hosts.
  5. Fügen Sie den folgenden Inhalt hinzu:
[local]
localhost ansible_connection=local

Dieses Inventory richtet eine Gruppe namens local mit nur einem Host ein - localhost. Der Parameter ansible_connection=local weist Ansible an, Befehle direkt auf der lokalen Maschine auszuführen, ohne SSH zu verwenden.

Erkundung von gather_facts

Führen wir einen einfachen Ansible-Befehl aus, um zu sehen, welche Fakten standardmäßig gesammelt werden:

cd ~/project/ansible
ansible local -i hosts -m setup

Der obige Befehl verwendet:

  • local: die Gruppe aus unserem Inventory
  • -i hosts: gibt unsere Inventory-Datei an
  • -m setup: führt das Setup-Modul aus, das Fakten sammelt

Sie sehen eine große JSON-Ausgabe mit detaillierten Informationen über Ihr System, einschließlich:

  • Hardware-Informationen (CPU, Speicher)
  • Netzwerkkonfiguration
  • Betriebssystemdetails
  • Umgebungsvariablen
  • Und vieles mehr

Diese Informationen werden von Ansible gesammelt, wenn gather_facts aktiviert ist (was das Standardverhalten ist). Diese Fakten können in Playbooks verwendet werden, um Entscheidungen zu treffen oder Aufgaben basierend auf den Eigenschaften des Zielsystems anzupassen.

Erstellen eines grundlegenden Playbooks mit standardmäßiger Fakten-Sammlung

In diesem Schritt erstellen wir ein grundlegendes Ansible Playbook, das das Standardverhalten der Fakten-Sammlung verwendet und einige der gesammelten Informationen anzeigt.

Verstehen von Ansible Playbooks

Ein Ansible Playbook ist eine YAML-Datei, die eine Liste von Aufgaben enthält, die auf verwalteten Hosts ausgeführt werden sollen. Playbooks bieten eine Möglichkeit, Konfigurations-, Bereitstellungs- und Orchestrierungsschritte in einem einfachen, für Menschen lesbaren Format zu definieren.

Erstellen Ihres ersten Playbooks

Erstellen wir ein einfaches Playbook, das einige der Fakten anzeigt, die Ansible standardmäßig sammelt:

  1. Navigieren Sie im WebIDE zum Verzeichnis /home/labex/project/ansible.
  2. Erstellen Sie eine neue Datei namens facts_playbook.yml.
  3. Fügen Sie den folgenden Inhalt hinzu:
---
- name: Show System Facts
  hosts: local
  ## By default, gather_facts is set to 'true'

  tasks:
    - name: Display operating system
      debug:
        msg: "Operating System: {{ ansible_distribution }} {{ ansible_distribution_version }}"

    - name: Display CPU information
      debug:
        msg: "CPU: {{ ansible_processor[1] }} with {{ ansible_processor_cores }} cores"

    - name: Display memory information
      debug:
        msg: "Total Memory: {{ ansible_memtotal_mb }} MB"

    - name: Display Python version
      debug:
        msg: "Python version: {{ ansible_python_version }}"

Dieses Playbook:

  • Zielt auf die in unserem Inventory definierte local-Gruppe ab.
  • Aktiviert implizit die Fakten-Sammlung (Standardverhalten).
  • Enthält vier Aufgaben, die verschiedene von Ansible gesammelte Informationen anzeigen.

Ausführen des Playbooks

Führen wir nun das Playbook aus, um die gesammelten Fakten in Aktion zu sehen:

cd ~/project/ansible
ansible-playbook -i hosts facts_playbook.yml

Sie sollten eine Ausgabe ähnlich dieser sehen:

PLAY [Show System Facts] *****************************************************

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

TASK [Display operating system] **********************************************
ok: [localhost] => {
    "msg": "Operating System: Ubuntu 22.04"
}

TASK [Display CPU information] ***********************************************
ok: [localhost] => {
    "msg": "CPU: Intel(R) Xeon(R) CPU with 2 cores"
}

TASK [Display memory information] ********************************************
ok: [localhost] => {
    "msg": "Total Memory: 3907 MB"
}

TASK [Display Python version] ************************************************
ok: [localhost] => {
    "msg": "Python version: 3.10.6"
}

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

Beachten Sie die erste Aufgabe in der Ausgabe: TASK [Gathering Facts]. Dies ist Ansible, das automatisch Fakten sammelt, bevor eine unserer definierten Aufgaben ausgeführt werden, da der Standardwert von gather_facts true ist.

Das Playbook zeigt dann erfolgreich Informationen über Ihr System mithilfe der gesammelten Fakten an. Auf jedes Fakt wird mithilfe einer Variable mit dem Präfix ansible_ verwiesen.

Deaktivieren der Fakten-Sammlung für verbesserte Leistung

In diesem Schritt erfahren wir, wie man die Fakten-Sammlung deaktiviert, um die Playbook-Leistung in Situationen zu verbessern, in denen die Fakten nicht benötigt werden.

Verstehen, wann die Fakten-Sammlung deaktiviert werden sollte

Obwohl die Fakten-Sammlung nützlich ist, kann sie in bestimmten Szenarien unnötigen Overhead verursachen:

  • Wenn Sie einfache Aufgaben ausführen, die keine Systeminformationen erfordern.
  • Wenn Sie Playbooks häufig ausführen und sich die Fakten nicht ändern.
  • Wenn Sie die Ausführungszeit des Playbooks optimieren möchten.

Das Deaktivieren der Fakten-Sammlung kann die Ausführungsgeschwindigkeit des Playbooks erheblich verbessern, insbesondere bei der Verwaltung vieler Hosts.

Erstellen eines Playbooks mit deaktivierter Fakten-Sammlung

Erstellen wir ein neues Playbook, bei dem die Fakten-Sammlung deaktiviert ist:

  1. Navigieren Sie im WebIDE zum Verzeichnis /home/labex/project/ansible.
  2. Erstellen Sie eine neue Datei namens no_facts_playbook.yml.
  3. Fügen Sie den folgenden Inhalt hinzu:
---
- name: Playbook with Disabled Fact Gathering
  hosts: local
  gather_facts: false

  tasks:
    - name: Display current time
      command: date
      register: current_time

    - name: Show the current time
      debug:
        msg: "Current time is: {{ current_time.stdout }}"

    - name: List files in the project directory
      command: ls -la ~/project
      register: file_list

    - name: Show file list
      debug:
        msg: "Project directory contents:\n{{ file_list.stdout }}"

Dieses Playbook:

  • Deaktiviert explizit die Fakten-Sammlung mit gather_facts: false.
  • Führt Befehle aus, die nicht von Systemfakten abhängen.
  • Verwendet das Schlüsselwort register, um die Befehlsausgaben zu erfassen.
  • Zeigt die erfassten Informationen mithilfe des debug-Moduls an.

Ausführen des Playbooks mit deaktivierter Fakten-Sammlung

Führen wir das Playbook aus und beobachten die Unterschiede:

cd ~/project/ansible
ansible-playbook -i hosts no_facts_playbook.yml

Sie sollten eine Ausgabe ähnlich dieser sehen:

PLAY [Playbook with Disabled Fact Gathering] *********************************

TASK [Display current time] **************************************************
changed: [localhost]

TASK [Show the current time] *************************************************
ok: [localhost] => {
    "msg": "Current time is: Wed May 17 15:30:45 UTC 2023"
}

TASK [List files in the project directory] ***********************************
changed: [localhost]

TASK [Show file list] ********************************************************
ok: [localhost] => {
    "msg": "Project directory contents:\ntotal 20\ndrwxr-xr-x 3 labex labex 4096 May 17 15:25 .\ndrwxr-xr-x 4 labex labex 4096 May 17 15:20 ..\ndrwxr-xr-x 2 labex labex 4096 May 17 15:25 ansible\n"
}

PLAY RECAP *******************************************************************
localhost                  : ok=4    changed=2    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Beachten Sie, dass diesmal keine Aufgabe Gathering Facts in der Ausgabe enthalten ist. Das Playbook beginnt direkt mit unserer ersten definierten Aufgabe.

Vergleichen der Ausführungszeiten

Um den Leistungsunterschied zu sehen, erstellen wir ein einfaches Timing-Skript:

  1. Navigieren Sie im WebIDE zum Verzeichnis /home/labex/project/ansible.
  2. Erstellen Sie eine neue Datei namens compare_timing.sh.
  3. Fügen Sie den folgenden Inhalt hinzu:
#!/bin/bash

echo "Running playbook with fact gathering enabled..."
time ansible-playbook -i hosts facts_playbook.yml > /dev/null

echo -e "\nRunning playbook with fact gathering disabled..."
time ansible-playbook -i hosts no_facts_playbook.yml > /dev/null
  1. Machen Sie das Skript ausführbar:
chmod +x compare_timing.sh
  1. Führen Sie das Vergleichsskript aus:
./compare_timing.sh

Sie sollten eine Ausgabe sehen, die zeigt, dass das Playbook mit deaktivierter Fakten-Sammlung schneller ausgeführt wird als das mit aktivierter Fakten-Sammlung. Der Unterschied mag in unserem einfachen Beispiel gering sein, kann aber erheblich sein, wenn komplexe Playbooks auf mehreren Remote-Hosts ausgeführt werden.

Verwendung selektiver Fakten-Sammlung

In einigen Fällen benötigen Sie möglicherweise nur bestimmte Fakten anstelle aller Systeminformationen. Ansible ermöglicht eine selektive Fakten-Sammlung, um die Leistung zu optimieren und gleichzeitig die benötigten Informationen zu sammeln.

Verstehen von Fakten-Teilmengen

Ansible organisiert Fakten in Teilmengen, wie z.B.:

  • all: Alle Fakten (Standard)
  • min / minimal: Eine minimale Menge an Fakten
  • hardware: CPU-, Speicher- und Geräteinformationen
  • network: Netzwerkschnittstellen- und Routing-Informationen
  • virtual: Virtualisierungsdetails
  • ohai: Fakten von Ohai (falls verfügbar)
  • facter: Fakten von Facter (falls verfügbar)

Durch die Auswahl nur der benötigten Fakten können Sie die Playbook-Leistung verbessern und gleichzeitig Zugriff auf die erforderlichen Informationen haben.

Erstellen eines Playbooks mit selektiver Fakten-Sammlung

Erstellen wir ein Playbook, das nur Hardware-bezogene Fakten sammelt:

  1. Navigieren Sie im WebIDE zum Verzeichnis /home/labex/project/ansible.
  2. Erstellen Sie eine neue Datei namens selective_facts_playbook.yml.
  3. Fügen Sie den folgenden Inhalt hinzu:
---
- name: Selective Fact Gathering
  hosts: local
  gather_facts: true
  gather_subset:
    - "!all" ## Exclude all facts by default
    - "hardware" ## Then include only hardware facts

  tasks:
    - name: Display CPU information
      debug:
        msg: "CPU: {{ ansible_processor[1] }} with {{ ansible_processor_cores }} cores"

    - name: Display memory information
      debug:
        msg: "Total Memory: {{ ansible_memtotal_mb }} MB"

    - name: Try to access network facts (should fail)
      debug:
        msg: "Default IPv4 Address: {{ ansible_default_ipv4.address }}"
      ignore_errors: true

Dieses Playbook:

  • Aktiviert die Fakten-Sammlung mit gather_facts: true.
  • Verwendet gather_subset, um einzuschränken, welche Fakten gesammelt werden.
  • Schließt zuerst alle Fakten mit !all aus.
  • Schließt dann nur Hardware-Fakten mit hardware ein.
  • Versucht, auf Netzwerkfakten zuzugreifen (die nicht gesammelt wurden), um die Einschränkung zu demonstrieren.

Ausführen des Playbooks mit selektiver Fakten-Sammlung

Führen wir das Playbook aus, um die selektive Fakten-Sammlung in Aktion zu sehen:

cd ~/project/ansible
ansible-playbook -i hosts selective_facts_playbook.yml

Sie sollten eine Ausgabe ähnlich dieser sehen:

PLAY [Selective Fact Gathering] **********************************************

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

TASK [Display CPU information] ***********************************************
ok: [localhost] => {
    "msg": "CPU: Intel(R) Xeon(R) CPU with 2 cores"
}

TASK [Display memory information] ********************************************
ok: [localhost] => {
    "msg": "Total Memory: 3907 MB"
}

TASK [Try to access network facts (should fail)] *****************************
fatal: [localhost]: FAILED! => {"msg": "The task includes an option with an undefined variable. The error was: 'dict object' has no attribute 'address'..."}
...ignoring

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

Beachten Sie, dass die ersten beiden Aufgaben erfolgreich sind, da sie auf Hardware-Fakten zugreifen, die gesammelt wurden, aber die dritte Aufgabe fehlschlägt, da keine Netzwerkfakten gesammelt wurden. Wir haben ignore_errors: true verwendet, um die Playbook-Ausführung trotz dieses Fehlers fortzusetzen.

Erstellen eines Playbooks mit mehreren Fakten-Teilmengen

Erstellen wir nun ein Playbook, das sowohl Hardware- als auch Netzwerkfakten sammelt:

  1. Erstellen Sie im WebIDE eine neue Datei namens multiple_subsets_playbook.yml.
  2. Fügen Sie den folgenden Inhalt hinzu:
---
- name: Multiple Fact Subsets
  hosts: local
  gather_facts: true
  gather_subset:
    - "!all" ## Exclude all facts by default
    - "hardware" ## Include hardware facts
    - "network" ## Include network facts

  tasks:
    - name: Display CPU information
      debug:
        msg: "CPU: {{ ansible_processor[1] }} with {{ ansible_processor_cores }} cores"

    - name: Display memory information
      debug:
        msg: "Total Memory: {{ ansible_memtotal_mb }} MB"

    - name: Display network information
      debug:
        msg: "Default IPv4 Address: {{ ansible_default_ipv4.address }}"

Führen Sie dieses Playbook aus:

ansible-playbook -i hosts multiple_subsets_playbook.yml

Dieses Mal sollten alle Aufgaben erfolgreich sein, da wir sowohl Hardware- als auch Netzwerkfakten gesammelt haben.

Verwenden gesammelter Fakten in bedingten Aufgaben

Eine der leistungsstärksten Anwendungen gesammelter Fakten ist die Implementierung bedingter Logik in Ihren Playbooks. In diesem Schritt erstellen wir ein Playbook, das Fakten verwendet, um Entscheidungen darüber zu treffen, welche Aufgaben ausgeführt werden sollen.

Verstehen bedingter Aufgaben in Ansible

Ansible ermöglicht es Ihnen, das Schlüsselwort when zu verwenden, um Aufgaben bedingt auf der Grundlage von Variablen, Fakten oder Aufgabenergebnissen auszuführen. Dies ermöglicht es Ihnen, dynamischere und anpassungsfähigere Playbooks zu erstellen.

Erstellen eines Playbooks mit bedingten Aufgaben

Erstellen wir ein Playbook, das je nach Betriebssystem unterschiedliche Aktionen ausführt:

  1. Navigieren Sie im WebIDE zum Verzeichnis /home/labex/project/ansible.
  2. Erstellen Sie eine neue Datei namens conditional_facts_playbook.yml.
  3. Fügen Sie den folgenden Inhalt hinzu:
---
- name: Conditional Tasks Based on Facts
  hosts: local
  gather_facts: true

  tasks:
    - name: Display OS information
      debug:
        msg: "Running on {{ ansible_distribution }} {{ ansible_distribution_version }}"

    - name: Task for Ubuntu systems
      debug:
        msg: "This is an Ubuntu system. Would run apt commands here."
      when: ansible_distribution == "Ubuntu"

    - name: Task for CentOS systems
      debug:
        msg: "This is a CentOS system. Would run yum commands here."
      when: ansible_distribution == "CentOS"

    - name: Task for systems with at least 2GB RAM
      debug:
        msg: "This system has {{ ansible_memtotal_mb }} MB RAM, which is sufficient for our application."
      when: ansible_memtotal_mb >= 2048

    - name: Task for systems with less than 2GB RAM
      debug:
        msg: "This system has only {{ ansible_memtotal_mb }} MB RAM, which may not be sufficient."
      when: ansible_memtotal_mb < 2048

Dieses Playbook:

  • Sammelt alle Fakten über das System.
  • Zeigt die Betriebssysteminformationen an.
  • Führt Aufgaben bedingt auf der Grundlage des Betriebssystemtyps aus.
  • Führt Aufgaben bedingt auf der Grundlage der RAM-Menge aus.

Ausführen des bedingten Playbooks

Führen wir das Playbook aus, um bedingte Aufgaben in Aktion zu sehen:

cd ~/project/ansible
ansible-playbook -i hosts conditional_facts_playbook.yml

Da wir auf Ubuntu ausführen, sollten Sie eine Ausgabe ähnlich dieser sehen:

PLAY [Conditional Tasks Based on Facts] **************************************

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

TASK [Display OS information] ************************************************
ok: [localhost] => {
    "msg": "Running on Ubuntu 22.04"
}

TASK [Task for Ubuntu systems] ***********************************************
ok: [localhost] => {
    "msg": "This is an Ubuntu system. Would run apt commands here."
}

TASK [Task for CentOS systems] ***********************************************
skipping: [localhost]

TASK [Task for systems with at least 2GB RAM] ********************************
ok: [localhost] => {
    "msg": "This system has 3907 MB RAM, which is sufficient for our application."
}

TASK [Task for systems with less than 2GB RAM] *******************************
skipping: [localhost]

PLAY RECAP *******************************************************************
localhost                  : ok=4    changed=0    unreachable=0    failed=0    skipped=2    rescued=0    ignored=0

Beachten Sie, wie einige Aufgaben ausgeführt werden, während andere basierend auf den Bedingungen übersprungen werden. Die CentOS-Aufgabe wird übersprungen, da wir auf Ubuntu ausführen, und die Aufgabe "weniger als 2 GB RAM" wird übersprungen, da unser System mehr als 2 GB RAM hat.

Erstellen eines praktischeren Beispiels

Erstellen wir nun ein praktischeres Beispiel, das in einer realen Umgebung verwendet werden könnte:

  1. Erstellen Sie im WebIDE eine neue Datei namens practical_conditional_playbook.yml.
  2. Fügen Sie den folgenden Inhalt hinzu:
---
- name: Practical Conditional Playbook
  hosts: local
  gather_facts: true

  vars:
    app_dir: "/home/labex/project/app"

  tasks:
    - name: Create application directory
      file:
        path: "{{ app_dir }}"
        state: directory
        mode: "0755"

    - name: Configure for production environment
      copy:
        dest: "{{ app_dir }}/config.yml"
        content: |
          environment: production
          memory_limit: high
          debug: false
      when: ansible_memtotal_mb >= 4096

    - name: Configure for development environment
      copy:
        dest: "{{ app_dir }}/config.yml"
        content: |
          environment: development
          memory_limit: low
          debug: true
      when: ansible_memtotal_mb < 4096

    - name: Display configuration
      command: cat {{ app_dir }}/config.yml
      register: config_content

    - name: Show configuration
      debug:
        msg: "{{ config_content.stdout_lines }}"

Dieses Playbook:

  • Erstellt ein Verzeichnis für eine Anwendung.
  • Schreibt eine andere Konfigurationsdatei basierend auf dem verfügbaren Systemspeicher.
  • Zeigt die resultierende Konfiguration an.

Führen Sie das praktische Playbook aus:

ansible-playbook -i hosts practical_conditional_playbook.yml

Dieses Beispiel zeigt, wie Sie gesammelte Fakten verwenden können, um Konfigurationen automatisch an Systemmerkmale anzupassen.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie die Option gather_facts in Ansible Playbooks effektiv konfigurieren und verwenden. Hier ist eine Zusammenfassung dessen, was Sie erreicht haben:

  1. Grundlegende Fakten-Sammlung (Basic fact gathering): Sie haben Ansible installiert und das Standardverhalten der Fakten-Sammlung erkundet und die große Bandbreite an Systeminformationen gesehen, die Ansible sammelt.

  2. Deaktivieren der Fakten-Sammlung (Disabling fact gathering): Sie haben gelernt, wie Sie die Fakten-Sammlung deaktivieren, um die Playbook-Leistung zu verbessern, wenn die Fakten nicht benötigt werden.

  3. Selektive Fakten-Sammlung (Selective fact gathering): Sie haben entdeckt, wie Sie nur bestimmte Teilmengen von Fakten sammeln können, um ein Gleichgewicht zwischen Leistung und dem Vorhandensein der notwendigen Informationen zu schaffen.

  4. Bedingte Aufgaben (Conditional tasks): Sie haben bedingte Logik in Ihren Playbooks auf der Grundlage gesammelter Fakten implementiert, was ein dynamisches Verhalten in Abhängigkeit von den Systemmerkmalen ermöglicht.

  5. Praktische Anwendungen (Practical applications): Sie haben praktische Beispiele erstellt, die zeigen, wie Sie gesammelte Fakten in realen Szenarien verwenden können.

Durch die Beherrschung der Option gather_facts können Sie Ihre Ansible Playbooks für eine bessere Leistung optimieren und gleichzeitig Zugriff auf die benötigten Systeminformationen haben. Dieses Wissen hilft Ihnen, effizientere, flexiblere und leistungsfähigere Automatisierungs-Workflows zu erstellen.

Einige Best Practices, die Sie sich merken sollten:

  • Aktivieren Sie die Fakten-Sammlung nur, wenn dies erforderlich ist.
  • Verwenden Sie die selektive Fakten-Sammlung, wenn Sie nur bestimmte Informationen benötigen.
  • Nutzen Sie gesammelte Fakten für bedingte Aufgaben, um Ihre Playbooks anpassungsfähiger zu machen.
  • Ziehen Sie das Caching von Fakten in Betracht, wenn Sie Playbooks häufig auf denselben Hosts ausführen.

Mit diesen Fähigkeiten sind Sie bestens gerüstet, um anspruchsvollere und effizientere Ansible-Automatisierung für Ihre Infrastrukturverwaltungsanforderungen zu erstellen.

Verwandt Ansible Kurse
Red Hat Enterprise Linux Automatisierung mit Ansible (RH294) Zertifizierungslabore

Red Hat Enterprise Linux Automatisierung mit Ansible (RH294) Zertifizierungslabore

rhelansiblelinux
Ansible für Anfänger

Ansible für Anfänger

ansibledevopslinux