Ansible-Variablentypen: Wie verwendet man Variablen in Ansible?

Ansible-Variablen sind nützlich, um Unterschiede zwischen verschiedenen Systemen zu verwalten. Diese Plattform ermöglicht die gleichzeitige Ausführung von Playbooks und Aufgaben auf mehreren Systemen mit einem einzigen Befehl. Unterschiede zwischen den Systemen lassen sich durch die Definition von Variablen in YAML-Syntax, einschließlich Listen und Wörterbüchern, ausdrücken.

Diese Variablen können an verschiedenen Stellen festgelegt werden, beispielsweise in Befehlszeilen, wiederverwendbaren Dateien oder Rollen, im Inventar oder in Playbooks. Darüber hinaus können während der Ausführung von Playbooks neue Variablen generiert werden, indem die Rückgabewerte von Aufgaben als Variablen zugewiesen werden.

In diesem Leitfaden werden wir die Konzepte der Ansible-Variablen durchgehen und deren Verwendung, Typen und Funktionalität im Detail untersuchen.

Welche Bedeutung haben Ansible-Variablen?

Ansible ist ein beliebtes Tool für das Konfigurationsmanagement, das häufig zur effizienten Verwaltung mehrerer Server eingesetzt wird. Es vereinfacht Aufgaben wie die Serverkonfiguration und die Installation von Anwendungen durch die Automatisierung von Prozessen. Mit Ansible können Sie problemlos eine große Anzahl von Remote-Servern verwalten und Aufgaben nacheinander von einem zentralen Kernknoten aus ausführen. Dies rationalisiert Verwaltungsaufgaben, steigert die Produktivität und gewährleistet Konsistenz in Ihrer gesamten Infrastruktur.

Variablen in Ansible dienen als leistungsstarke Werkzeuge zur Vereinfachung der Verwaltung dynamischer Werte im gesamten Projekt und verringern so die Wahrscheinlichkeit menschlicher Fehler. Sie bieten eine bequeme Möglichkeit, Abweichungen und Diskrepanzen zwischen verschiedenen Umgebungen und Systemen zu handhaben. Mit Variablen gewinnen wir die Flexibilität, diese an verschiedenen Stellen zu definieren, jeweils mit unterschiedlichen Prioritätsstufen, die auf unsere spezifischen Anforderungen zugeschnitten sind. Darüber hinaus ermöglicht uns Ansible, neue Variablen direkt in unseren Playbooks zu registrieren, indem wir die Ausgabe von Aufgaben erfassen, was die Anpassungsmöglichkeiten weiter verbessert. Eine bemerkenswerte Art von Variablen in Ansible sind Ansible-Facts, die wertvolle Informationen liefern, die von Remote-Hosts abgerufen werden. Diese Facts, auf die über die Variable `ansible_facts` zugegriffen werden kann, bieten Einblicke in verschiedene Aspekte der Zielsysteme.

So können wir beispielsweise Details zur Betriebssystemdistribution (ansible_distribution) und deren Version (ansible_distribution_version), Informationen zu Host-Geräten, die von Ansible verwendete Python-Version (ansible_python_version) sowie die Systemarchitektur (ansible_architecture) abrufen. Die Nutzung von Ansible-Facts bereichert unsere Projekte, indem sie fundierte Entscheidungsfindung und effiziente Automatisierungsabläufe ermöglicht.

Regeln für Ansible-Variablennamen

Variablen in Ansible werden nach bestimmten Richtlinien vergeben, die die Namenskonventionen für Variablen vorschreiben.

• In Ansible muss der Variablenname mit einem Buchstaben beginnen (Groß- oder Kleinbuchstabe). Zum Beispiel username, Saleprice usw.
• Variablen in Ansible enthalten Buchstaben (entweder Groß- oder Kleinbuchstaben oder eine Kombination daraus), Unterstriche und Ziffern – zum Beispiel username, sale_price, foo23 usw.
• Bestimmte Zeichenfolgen oder Schlüsselwörter sind für spezielle Funktionen reserviert und können nicht als gültige Variablennamen verwendet werden. Dazu gehören Playbook-Schlüsselwörter und Python-Schlüsselwörter.

Obwohl nicht zwingend erforderlich, ist es ratsam, einfache und aussagekräftige Variablennamen zu verwenden. Diese Vorgehensweise vereinfacht Ihren Arbeitsablauf in Ansible.

Arten von Ansible-Variablen

Es gibt verschiedene Arten von Ansible-Variablen, die Sie in einem Playbook auf unterschiedliche Weise definieren und verwenden können.

• Einfache Variablen;
• Spezielle Variablen (Verbindungsvariablen, Magic-Variablen, Ansible-Facts);
• Register-Variablen.

Einfache Ansible-Variablen

Die grundlegendste Verwendung einfacher Variablen besteht darin, eine Variable mit einem einzelnen Wert in der YAML-Datei des Playbooks zu definieren.

Betrachten wir ein einfaches Beispiel für ein Playbook, das eine Meldung ausgibt.

---
- name: Example Playbook with Variables
  hosts: all
  gather_facts: false
  vars:
    greeting_message: "Hello, welcome to Ansible variables understanding!"
  tasks:
    - name: Display Greeting
      debug:
        msg: "{{ greeting_message }}"

Im obigen Playbook verwenden wir einfache Ansible-Variablen:

• name: benennt das Playbook und beschreibt es.
• hosts: legt die Zielhosts fest, auf denen die Aufgaben ausgeführt werden. Hier ist es all.
• vars: definiert die Variable greeting_message mit dem Text „Hello, welcome to Ansible variables understanding!“.
• tasks: enthält die Liste der Aufgaben, die auf den Zielhosts ausgeführt werden.
• debug: Modul, das Meldungen zur Fehlersuche ausgibt. Hier zeigt es den Wert der Variable greeting_message an.
• msg: legt die auszugebende Meldung fest. Die Variable wird in doppelten geschweiften Klammern referenziert.

Führen Sie das Playbook aus, und der Wert von greeting_message wird in der Ausgabe von msg angezeigt.

Ansible-Set-Variablen in Aufgaben

Ansible-Set-Variablen sind benutzerdefinierte Variablen, die Sie innerhalb von Playbooks oder Rollen definieren und mit Werten belegen können. Diese Variablen werden in der Regel verwendet, um Informationen zu speichern, die sich je nach Ihrer Umgebung oder Ihren Anforderungen ändern können. Sie können Variablen auf verschiedenen Ebenen festlegen, beispielsweise global, innerhalb eines Playbooks oder einer bestimmten Aufgabe. Sehen wir uns ein Beispiel an:

---
- name: Set variables
  hosts: localhost
  tasks:
    - name: Set user role variables
      set_fact:
        user_name: "supervisor"
        user_permissions: "rwx"

    - name: Display user variables
      debug:
        msg: "The user '{{ user_name }}' has permissions '{{ user_permissions }}'"

Ansible-Variablen mit Arrays und Schleifen

In Ansible werden Arrays, genau wie in Programmiersprachen, verwendet, um Sammlungen miteinander in Zusammenhang stehender Elemente zu speichern. Diese Sammlungen, die als Arrays bezeichnet werden, können mehrere Werte desselben Datentyps enthalten.

Betrachten wir ein Beispiel für ein Ansible-Playbook, das Variablen mit Arrays/Listen verwendet und veranschaulicht, wie man diese in einer Schleife durchläuft:

---
- name: Example Playbook with Variable Arrays and Loops
  hosts: all
  gather_facts: false
  vars:
    fruits:
      - apple
      - banana
      - orange
  tasks:
    - name: Display Fruits
      debug:
        msg: "The fruit is {{ item }}"
      loop: "{{ fruits }}"

Im obigen Playbook ist „fruits“ eine Variable, die ein Array/eine Liste von Früchten enthält. Die loop-Anweisung wird verwendet, um das fruits-Array zu durchlaufen. Innerhalb der Schleife zeigt die debug-Aufgabe jede Frucht mithilfe der item-Variablen an.

Ansible-Spezialvariablen

In Ansible sind Spezialvariablen vordefinierte Variablen, die wichtige Informationen über das System, das Inventar oder den Kontext der Playbook-Ausführung enthalten. Ansible-Spezialvariablen werden in verschiedene Typen unterteilt, wie z. B. Magic-Variablen, Verbindungsvariablen und Ansible-Facts. Ihre Namen sind reserviert, was bedeutet, dass Sie keine Variablen mit denselben Namen wie diese Spezialvariablen definieren können.

Ansible-Facts

Ansible-Facts sind Details, die während der Ausführung des Playbooks über die Hosts gesammelt werden. Dieser als „Gathering Facts“ bezeichnete Prozess umfasst das Erfassen von Informationen wie der IP-Adresse des Systems, dem aktuellen Datum und der Uhrzeit, BIOS-Spezifikationen, Festplattenpartitionen und anderen relevanten Hardware-Details.

Das folgende Playbook zeigt einige der gesammelten Facts an:

---
- name: Display Ansible facts
  hosts: localhost
  gather_facts: true
  tasks:
    - name: Show some facts
      debug:
        msg:
          - "Hostname: {{ ansible_hostname }}"
          - "Distribution: {{ ansible_distribution }} {{ ansible_distribution_version }}"
          - "Arbeitsspeicher (MB): {{ ansible_memtotal_mb }}"

Im obigen Beispiel:

Wir setzen gather_facts auf true, wodurch Ansible angewiesen wird, Informationen über die Zielhosts zu erfassen. Anschließend verwenden wir das Debug-Modul, um einige der erfassten Fakten anzuzeigen, wie z. B. den Hostnamen (ansible_hostname), die Distribution (ansible_distribution) und deren Version (ansible_distribution_version) sowie den Gesamtspeicher (ansible_memtotal_mb). Wenn Sie dieses Playbook mit ansible-playbook ausführen, sammelt Ansible Fakten von allen in Ihrer Inventardatei angegebenen Hosts und zeigt die relevanten Informationen für jeden Host an. Hier sammeln wir Informationen nur für „localhost“.

Um die mit Ihrem lokalen System verbundenen Ansible-Facts anzuzeigen, führen Sie den folgenden Befehl aus:

$ sudo ansible -m setup localhost

Der obige Befehl verwendet das Modul „setup“, um Fakten über das „localhost“-System zu erfassen. Er gibt eine Ausgabe im JSON-Format aus, die eine Vielzahl von Informationen über das lokale System enthält, wie z. B. Hardware-Details, Netzwerkkonfiguration, Betriebssystem und mehr.

Ansible-Magic-Variablen

Ansible-Magic-Variablen sind vordefinierte Variablen, die Informationen über die Ausführungsumgebung, den aktuellen Host oder andere kontextbezogene Details liefern. Magic-Variablen in Ansible werden automatisch vom Tool generiert und sind unveränderlich, was bedeutet, dass Benutzer ihre Werte nicht ändern können. Diese Variablen repräsentieren stets den internen Zustand von Ansible und können von Benutzern nicht verändert werden. Daher sind sie nur in ihrer vordefinierten Form verwendbar und können nicht angepasst werden.

Hier ist ein Beispiel für die Verwendung von Ansible-Magievariablen in einem Playbook:

---
- hosts: all
  tasks:
    - debug:
        var: ansible_version

Ansible-Verbindungsvariablen

Verbindungsvariablen in Ansible dienen als Konfigurationseinstellungen, die festlegen, wie Ansible während der Ausführung von Aufgaben und Playbooks Verbindungen zu Remote-Hosts herstellt. Sie bieten Flexibilität bei der Verwaltung verschiedener Verbindungstypen, Authentifizierungsmechanismen und host-spezifischer Konfigurationen.

Nehmen wir ein Beispiel, bei dem wir den Befehl „date“ auf dem lokalen Host ausführen.

---
- name: Run Command on Localhost
  hosts: localhost
  connection: local
  gather_facts: no
  vars:
    command_to_run: "date"
  tasks:
    - name: Execute Command
      ansible.builtin.shell: "{{ command_to_run }}"
      register: command_output

    - name: Display Command Output
      ansible.builtin.debug:
        msg: "Command output: {{ command_output.stdout }}"

Im obigen Beispiel:

• name: Name des Playbooks, hier „Run Command on Localhost“.
• hosts: Zielhosts des Playbooks. Hier localhost, das Playbook läuft also nur auf dem lokalen Rechner.
• connection: legt fest, wie Ansible sich mit den Zielhosts verbindet. Mit local führt Ansible die Aufgaben direkt auf dem Steuerknoten aus, also auf dem lokalen Rechner.
• gather_facts: steuert, ob Ansible Facts über die Zielhosts sammelt. Mit no werden keine Facts gesammelt.
• vars: definiert Variablen für dieses Playbook. Die Variable command_to_run erhält den Wert „date“, also einen Shell-Befehl, der das aktuelle Datum ausgibt.
• tasks: enthält die Liste der Aufgaben, die Ansible ausführt.
• ansible.builtin.shell: führt Shell-Befehle auf den Zielhosts aus. Hier wird der Befehl aus der Variable command_to_run ausgeführt.
• register: speichert die Ausgabe des Shell-Befehls zur späteren Verwendung in command_output.
• ansible.builtin.debug: gibt Debug-Meldungen aus. Hier wird die in command_output.stdout gespeicherte Ausgabe angezeigt.

Nach der Ausführung dieses Ansible-Playbooks sehen Sie die Ausführung des Befehls date auf dem lokalen Host und die Anzeige der Ausgabe, d. h. des aktuellen Datums und der aktuellen Uhrzeit.

Ansible-Registervariablen

Das Ansible-Registermodul dient dazu, die Ausgabe einer Aufgabe in einer Variablen zu speichern. In der Regel wird dabei eine Aufgabe auf einem Remote-Host mithilfe von Modulen wie „shell“ oder „command“ ausgeführt. Sobald das Registermodul die Ausgabe der Aufgabe erfasst hat, kann darauf in verschiedenen Kontexten Bezug genommen werden, beispielsweise in bedingten Anweisungen oder bei der Ausgabe der Ergebnisse.

Sehen wir uns an, wie das Registermodul eingesetzt wird, um die Ausgabe einer Aufgabe zu erfassen. Im bereitgestellten Playbook wird der Befehl „free“ auf einem lokalen Host ausgeführt. Das Register-Modul erfasst die Ausgabe des Befehls, die anschließend auf der Standardausgabe (stdout) angezeigt wird.

---
- name: Ansible Register Variable Example
  hosts: localhost
  tasks:
    - name: Get Memory Usage
      shell: "free"
      register: memory_usage

    - debug:
        var: memory_usage.stdout

In diesem Beispiel:

Das „shell“-Modul wird verwendet, um den Befehl „free“ auszuführen, der Informationen zur Speicherauslastung anzeigt. Die Ausgabe des Befehls „free“ wird vom „register“-Modul erfasst und in der Variablen „memory_usage“ gespeichert. Das „debug“-Modul zeigt dann die erfasste Ausgabe des Befehls „free“ mithilfe des Attributs „stdout“ der Variablen „memory_usage“ an. Dieses Playbook führt den Befehl „free“ auf dem lokalen Host aus, Sie können ihn jedoch für alle Hosts in der Inventardatei angeben und die von jedem Host erfassten Informationen zur Speicherauslastung anzeigen.

Fazit

In diesem Leitfaden haben wir uns eingehend mit Ansible-Variablen befasst und untersucht, wie man sie in verschiedenen Szenarien definiert und referenziert. Durch den Einsatz von Variablen erhalten Sie die Möglichkeit, Ihre Playbooks anzupassen und zu parametrisieren, was die Flexibilität und Anpassungsfähigkeit erhöht.

Darüber hinaus haben wir wichtige Best Practices zur Optimierung der Variablennutzung in Playbooks vorgestellt, um reibungslosere Automatisierungsabläufe zu gewährleisten und die Komplexität zu reduzieren. Wir haben gezeigt, wie Sie verschiedene Ansible-Variablentypen in einem Playbook verwenden und auf Ihrem System ausführen können. Wenn Sie ein Remote-Hosting oder einen VPS-Linux-Server nutzen, können Sie die oben genannten Richtlinien anwenden und die Ansible-Variablen auf Ihrem Linux-Server einsetzen.

Um mehr über Ansible-Variablen zu erfahren und weitere Möglichkeiten zu erkunden, empfehlen wir Ihnen, die offizielle Ansible-Dokumentation zu konsultieren. Dort finden Sie umfassende Ressourcen und zusätzliche Einblicke in Ansible-Variablen, die es Ihnen ermöglichen, das volle Potenzial dieser leistungsstarken Funktion auszuschöpfen. Nutzen Sie die Vielseitigkeit von Ansible-Variablen, um Ihre Automatisierungsstrategien zu optimieren und die Effizienz Ihrer gesamten Infrastruktur zu steigern.