Beispiele für Ansible-Schleifen und Einführung

In einem früheren Artikel haben wir über Ansible gesprochen, eine sehr nützliche kostenlose und Open-Source-Software, die in Python geschrieben wurde und mit der wir Aufgaben auf mehreren Computern automatisieren können. Wir haben gesehen, wie man es auf einigen der am häufigsten verwendeten Linux-Distributionen installiert und welche grundlegenden Konzepte hinter seiner Verwendung stehen. In diesem Artikel konzentrieren wir uns auf die Verwendung von Schleifen in Ansible-Playbooks, um eine einzelne Aufgabe mehrmals mit unterschiedlichen Daten auszuführen.

In diesem Tutorial lernen Sie:

So verwenden Sie Schleifen in Ansible-Playbooks
So durchlaufen Sie eine Liste von Elementen
So durchlaufen Sie eine Liste von Hashes
So legen Sie das Zeitintervall zwischen Schleifeniterationen fest
So behalten Sie den Überblick über den Schleifenindex

Verwendete Softwareanforderungen und Konventionen

Einführung in Schleifen

Beginnen wir mit einer einfachen, einzelnen Aufgabe. Angenommen, wir möchten sicherstellen, dass auf eine Datei ein bestimmter Satz von Berechtigungen angewendet wurde. Um das Konzept in eine Ansible-Aufgabe zu übersetzen, würden wir das ansible.builtin.file-Modul verwenden und schreiben:

- name: Apply permissions
  ansible.builtin.file:
    path: /foo.conf
    mode: '600'

Mit der obigen Aufgabendefinition haben wir einen Zustand deklariert: Auf die Datei /foo.conf muss der Berechtigungsmodus 600 angewendet werden (ihr Besitzer sollte in der Lage sein, sie zu lesen und zu beschreiben; ihrer Gruppe und dem Rest der Welt sollten keine Privilegien zugewiesen werden). Angenommen, wir möchten dasselbe für mehrere Dateien tun. Wie gehen wir vor?

Natürlich wäre es eine sehr schlechte Idee, für jede Datei genau die gleiche Aufgabe zu schreiben, da wir uns wiederholen würden. Ideal wäre es, die gleiche Aufgabe zu verwenden, aber mit unterschiedlichen Daten. Dies ist ein typischer Fall, in dem es richtig ist, eine Schleife zu verwenden. Hier ist, was wir schreiben könnten:

- name: Set permissions
  ansible.builtin.file:
    path: "{{ item }}"
    mode: '600'
  loop:
    - /foo.conf
    - /bar.conf
    - /baz.conf

Wenn die Aufgabe ausgeführt wird, wird die folgende Ausgabe in der Konsole zurückgegeben:

TASK [Apply permissions] *******************************************************
changed: [localhost] => (item=/foo.conf)
changed: [localhost] => (item=/bar.conf)
changed: [localhost] => (item=/baz.conf)

Was wir oben gemacht haben, ist ein sehr einfaches Beispiel für eine Schleife in einem Ansible-Playbook. Wie Sie sehen können, haben wir das Schlüsselwort loop auf der gleichen Einrückungsebene wie der Aufgabenname verwendet. In diesem Fall haben wir mit der yaml-Syntax eine Liste von Pfaden bereitgestellt; Dann haben wir in der Aufgabe selbst die Variable item verwendet, um auf jeden einzelnen von ihnen zu verweisen. Bei jeder Iteration verweist diese Variable auf ein Element der von uns angegebenen Liste.

Ziemlich einfach! In diesem trivialen Beispiel haben wir allen Dateien in der Liste die gleichen Berechtigungen zugewiesen. Was ist, wenn wir jedem von ihnen einen anderen Berechtigungsmodus zuweisen möchten?

Angeben mehrerer Parameter durch Durchlaufen einer Liste von Hashes

Wie gesagt, im vorherigen Beispiel haben wir einfach über eine Liste iteriert. Es kann jedoch Fälle geben, in denen wir bei jeder Iteration mehrere Parameter angeben müssen. In diesen Fällen möchten wir stattdessen eine Liste von Hashes definieren und iterieren.

Angenommen, wir möchten die Berechtigungen mehrerer Dateien mit derselben Aufgabe festlegen, genau wie wir es zuvor getan haben, aber wir möchten jeder Datei einen anderen Berechtigungsmodus zuweisen. Wie könnten wir das tun? In einem solchen Fall würde es nicht ausreichen, über eine einfache Liste zu iterieren. Was wir tun wollen, ist, über eine Liste von Hashes zu iterieren. In jedem Hash geben wir die Parameter an, die verwendet werden sollen, und deren Werte. Hier ist ein Beispiel:

- name: Set permissions
  ansible.builtin.file:
    path: "{{ item.path }}"
    mode: "{{ item.mode }}"
  loop:
    - { path: '/foo.conf', mode: '600' }
    - { path: '/bar.conf', mode: '640' }
    - { path: '/baz.conf', mode: '640' }

Werfen wir einen Blick auf das, was wir oben getan haben. Genau wie im vorherigen Beispiel haben wir die loop-Anweisung verwendet, um eine Schleife zu erstellen, diesmal haben wir jedoch eine Liste von Hashes angegeben. In jedem Hash haben wir die Pfad- und Modusschlüssel verwendet und ihnen die entsprechenden Werte für jede Datei zugewiesen.

Beachten Sie, dass die Schlüsselnamen hier völlig willkürlich sind: Sie sollten nicht unbedingt den Parametern entsprechen, die in der Aufgabe verwendet werden. In der Aufgabe selbst wird, genau wie zuvor, über die Variable item auf den Wert verwiesen, der bei jeder Iteration der Schleife zugewiesen wird. In diesem Fall wäre jedes Element einer der von uns angegebenen Hashes. Um auf die Schlüssel in jedem Hash zuzugreifen, verwenden wir eine ., genau wie wir es tun würden, um auf eine Eigenschaft eines Python-Objekts zuzugreifen, sodass z. B. item.path jedes Mal auf den Wert verweist, der diesem Schlüssel im Hash zugewiesen ist.

Steuern der Zeit zwischen den Iterationen

Es kann einige Fälle geben, in denen wir die Zeitspanne festlegen möchten, die zwischen den Iterationen einer Schleife vergehen soll. Wie können wir dies in einem Playbook tun? Alles, was wir tun müssen, ist, die pause-Direktive innerhalb des Abschnitts loop_control zu verwenden. Hier ist ein triviales Beispiel für eine Ansible-Schleife, in der jede Iteration 5 Sekunden nach der vorherigen ausgeführt wird:

- name: Print message
  ansible.builtin.debug:
    msg: "{{ item }}"
  loop:
    - Hello
    - World
  loop_control:
    pause: 5

Den Überblick über den Iterationsindex behalten

Genau wie im vorherigen Beispiel können wir den Abschnitt loop_control verwenden, um die Anzahl der Schleifeniterationen zu verfolgen. Alles, was wir tun müssen, ist, die index_var Richtlinie zu verwenden. Die Variable, die wir als Wert für diese Direktive angeben, enthält den Index der aktuellen Iteration (nullbasiert). Hier ist ein Beispiel:

- name: Print message
  ansible.builtin.debug:
    msg: "The item is {{ item }} and loop index is {{ i }}"
  loop:
    - hello
    - world
  loop_control:
    index_var: i

Die Aufgabe, die wir im obigen Beispiel definiert haben, ist sehr trivial und hat keinen wirklichen Nutzen; Es kann jedoch nützlich sein, anzuzeigen, wie der Iterationsindex erhöht wird. Wenn wir es ausführen, erhalten wir die folgende Ausgabe:

TASK [Print message] ***********************************************************
ok: [localhost] => (item=Hello) => {
    "msg": "The item is Hello and loop index is 0"
}
ok: [localhost] => (item=World) => {
    "msg": "The item is World and loop index is 1"
}

Schlüsse

In diesem Artikel haben wir die grundlegende Verwendung von Schleifen in Ansible-Playbooks kennengelernt und den Lesern wurden einige einführende Beispiele für Ansible-Schleifen zur Verfügung gestellt. Wir haben gesehen, wie man über eine einfache Liste von Elementen und über eine Liste von Hashes iteriert, die jeweils einen Satz von Schlüssel-Wert-Paaren enthalten.

Wir haben auch gesehen, wie man angibt, wie viele Sekunden zwischen den einzelnen Iterationen einer Schleife vergehen sollen, und wie man den Iterationsindex in einer Variablen mit dem Abschnitt loop_control bzw. den Anweisungen pause und index_var verfolgt. Hier haben wir kaum an der Oberfläche dessen gekratzt, was mit Schleifen möglich ist. Für tiefergehende Kenntnisse konsultieren Sie bitte die offizielle Ansible-Dokumentation!