Einführung in Ansible-Rollen

Ansible ist ein kostenloses Open-Source-Bereitstellungssystem, das in Python geschrieben und von Red Hat gesponsert wird. In früheren Tutorials haben wir die Grundlagen von Ansible kennengelernt und gesehen, wie man Aufgaben in Playbooks organisiert und wie man sensible Daten mit ansible-vault sichert. Es gibt noch ein weiteres, sehr wichtiges Konzept, auf das wir uns konzentrieren müssen, wenn wir mit Ansible umgehen: Rollen.

Ansible-Rollen stellen eine Möglichkeit dar, Code und Aufgaben zu organisieren und wiederzuverwenden, die auf das Ausführen bestimmter Aktionen abzielen. In diesem Tutorial lernen wir, wie man Ansible-Rollen unter Linux erstellt und verwendet.

In diesem Tutorial lernen Sie:

Was ist eine Ansible-Rolle?
So erstellen Sie eine Rolle von Grund auf neu
So installieren Sie eine Rolle aus Ansible Galaxy
So verwenden Sie eine Rolle in einem Playbook

Einleitung

Beginnen wir mit einer Zusammenfassung, was eine Ansible-Rolle ist. Wir könnten eine Rolle im Grunde als eine wiederverwendbare Gruppe von Aufgaben definieren, die sich auf das Erzielen eines bestimmten Ergebnisses konzentrieren und zusammen mit den zugehörigen Variablen, Handlern und Dateien verteilt sind.

Ansible-Rollen werden in der Regel auf der ansible-Galaxy-Plattform gehostet, von wo aus sie über das Dienstprogramm ansible-galaxy installiert werden können.

Bewährte Praktiken schreiben vor, dass sich jede Rolle auf ein bestimmtes Ziel konzentriert: Wir können zum Beispiel eine Rolle erstellen, die zum Bereitstellen von Dotfiles aus einem Git-Repository verwendet wird, eine Rolle zur Installation von Samba usw. Ansible-Rollen nehmen eine bestimmte Verzeichnisstruktur an, die manuell erstellt oder, was bequemer ist, mit dedizierten Befehlen generiert werden kann. Mal sehen, wie.

Bootstrapping einer Rolle

Für dieses Tutorial erstellen wir eine Rolle, die wir zum Bereitstellen von Dotfiles verwenden, die in einem Git-Repository verwaltet werden. Anstatt die Rollenverzeichnisstruktur manuell zu erstellen, können wir das Dienstprogramm ansible-galaxy verwenden:

ansible-galaxy role init dotfiles

Der obige Befehl erstellt ein Verzeichnis, das nach der Rolle benannt ist und die grundlegende Verzeichnisstruktur enthält:

dotfiles
├── defaults
│   └── main.yml
├── handlers
│   └── main.yml
├── meta
│   └── main.yml
├── README.md
├── tasks
│   └── main.yml
├── tests
│   ├── inventory
│   └── test.yml
└── vars
    └── main.yml

Jedes Verzeichnis in der Struktur hat einen Zweck und enthält eine main.yml Datei: Hier sucht Ansible nach Inhalten. In der folgenden Tabelle haben wir versucht, zusammenzufassen, wofür sie verwendet werden (wir haben das Verzeichnis "tests" weggelassen, da wir in einem speziellen Tutorial über Rollentests sprechen werden):

Dateien	Zweck
Versäumnisse/main.yml	Definieren von Rollenvariablen
Abfertiger/main.yml	Definieren von Handlern. Handler sind Aufgaben, die wir als Reaktion auf bestimmte Ereignisse ausführen, z. B. wenn eine Aufgabe eine Statusänderung meldet.
meta/haupt.yml	Rollenmetadaten (Beschreibung, Abhängigkeiten, unterstützte Ansible-Versionen, etc...)
Aufgaben/main.yml	Definieren von Rollenaufgaben
vars/main.yml	Definieren von Rollenvariablen

Dateien in den Verzeichnissen vars und defaults werden beide verwendet, um Rollenvariablen zu definieren. Es gibt jedoch einen Unterschied: Variablen, die in Dateien definiert sind, die unter der ersteren definiert sind, haben eine höhere Priorität als die in der letzteren definierten und sind daher "schwieriger" zu überschreiben. Normalerweise definieren wir Variablen, die der Benutzer bei Standardeinstellungen eher ändert, und solche, die eher "statisch" sind, bei vars (hier erfahren Sie mehr über die Rangfolge von Ansible-Variablen)

Andere Verzeichnisse können Teil der Struktur einer Rolle sein, werden aber nicht automatisch generiert. Zwei häufig verwendete sind Vorlagen und Dateien: Wie der Name schon sagt, werden sie zum Speichern von jinja2-Vorlagen bzw. -Dateien verwendet.

Entwicklung unserer Rolle

Beginnen wir mit der Entwicklung unserer Rolle. Wir beginnen mit der Definition von Rollenvariablen, dann mit den Aufgaben, die tatsächlich das erfüllen, was wir erreichen wollen.

Definieren der Rollenvariablen

Beginnen wir mit der Definition der Variablen. In die Standard-/main.yml Datei schreiben wir folgendes:

---
dotfiles_repository: ""
dotfiles_destination: ~/.dotfiles
dotfiles_files: []

Die erste Variable, die wir definiert haben, ist dotfiles_repository. Der Wert dieser Variablen muss die URL des Remote-Git-Repositorys sein, das unsere Dotfiles hostet.

Wir müssen auch wissen, wo das Repository im Dateisystem geklont werden soll. Wir können diesen Pfad als Wert der Variablen dotfiles_destination festlegen. In diesem Fall ist das Verzeichnis ~/.dotfiles das, was wir als Standard festgelegt haben und was verwendet wird, wenn der Benutzer den Variablenwert nicht explizit überschreibt.

Die letzte Variable, die wir definiert haben, ist dotfiles_files: Der Wert dieser Variablen ist die Liste der Dateien im Repository, die der Benutzer unter seinem Home-Verzeichnis verknüpfen möchte.

Erstellen der Aufgaben

Lassen Sie uns nun die Aufgaben erstellen. Wie wir bereits gesehen haben, ist die Datei, die als Einstiegspunkt für Aufgaben verwendet wird, tasks/main.yml. Zuerst wollen wir sicherstellen, dass git auf dem Zielcomputer installiert ist. Da wir möchten, dass unsere Rolle auf verschiedenen Distributionen nutzbar ist, können wir zur Installation des Pakets das ansible.builtin.package-Modul verwenden, das als Abstraktion über die gängigsten Paketmanager wie apt, dnf und pacman funktioniert:

--- 
- name: Ensure git is installed 
  become: true
  ansible.builtin.package: 
    name: git 
    state: present

Die nächste Aufgabe besteht darin, das Git-Repository zu klonen. Das Modul ansible.builtin.git ist das, was wir hier brauchen. Das Modul verfügt über zwei erforderliche Parameter: "repo" und "dest", die die Adresse des Git-Repositorys bzw. den Pfad darstellen, in dem das Repository geklont werden soll. Wir müssen nur die entsprechenden Variablen verwenden, die wir zuvor definiert haben:

- name: Clone dotfiles repository
  ansible.builtin.git:
    repo: '{{ dotfiles_repository }}'
    dest: '{{ dotfiles_destination }}'

Schließlich fügen wir die Aufgabe hinzu, die die symbolischen Verknüpfungen erstellt. Um Links zu erstellen, können wir die ansible.builtin.file verwenden. Der Parameter "src" dieses Moduls ist der Pfad der Datei, auf die verlinkt werden soll: Wir erhalten ihn, indem wir den Pfad des geklonten Repositorys und den Namen der Datei verbinden.

Der Parameter "dest" ist stattdessen der Pfad, in dem der symbolische Link erstellt werden soll. Hier haben wir ein wenig Logik hinzugefügt, um dem Namen der Datei automatisch einen Punkt voranzustellen, falls sie ohne diesen im Repository gespeichert wird. Wir haben auch den Parameter "force" verwendet und seinen Wert auf "true" gesetzt, um die Erstellung des Links zu erzwingen, falls bereits eine Datei mit demselben Namen existiert (dies funktioniert nicht für Verzeichnisse).

Die Aufgabe wird in einer Schleife für jede Datei in der dotfiles_files Liste ausgeführt:

- name: Create the symbolic links
  ansible.builtin.file:
    src: '{{ dotfiles_destination }}/{{ item }}'
    dest: '~/{{ item is regex("^\.") | ternary(item, "." + item) }}'
    state: link
    force: true
  loop: '{{ dotfiles_files }}'

Metadaten der Rolle

Die Definition von Rollenmetadaten ist obligatorisch, wenn wir planen, unsere Rolle auf der Ansible-Galaxy-Plattform zu teilen. Wie wir bereits kurz erwähnt haben, ist Metadaten die Meta-/main.yml-Datei. Hier ist ein Beispiel für die Informationen, die bereitgestellt werden können:

galaxy_info:
  author: your name
  role_name: your role name
  description: your role description
  company: your company (optional)
  license: license (GPL-2.0-or-later, MIT, etc)
  min_ansible_version: 2.1
  galaxy_tags: []
dependencies: []

Verwenden der Rolle

Grundsätzlich gibt es zwei Möglichkeiten, wie wir eine Rolle in einem Playbook verwenden können. Eine besteht darin, die Rolle in den Playbook-Abschnitt "Rollen" aufzunehmen, die andere besteht darin, sie zu importieren oder in den Abschnitt "Aufgaben" mit den Modulen ansible.builtin.import_role oder ansible.builtin.include_role aufzunehmen.

Der Unterschied zwischen dem Importieren und Einbinden von Modulen (oder Aufgaben) liegt im Wesentlichen in der Zeit, in der die Anweisungen geparst werden: Importanweisungen werden sehr früh verarbeitet, wenn das Playbook geparst wird, während "Includes" verarbeitet werden, sobald sie gefunden werden (werfen Sie einen Blick auf diesen Vergleich für weitere Informationen zu diesem Thema).

Rollen können pro Projekt in einem Verzeichnis mit dem Namen "roles" installiert werden, relativ zum Playbook, das sie verwendet, oder "global" im roles_path, das standardmäßig lautet: ~/.ansible/roles:/usr/share/ansible/roles:/etc/ansible/roles. Sie können auch über ihren absoluten Pfad im Dateisystem referenziert werden.

Hier ist ein Beispiel dafür, wie wir unsere Rolle in einem Playbook verwenden und Werte für die verwendeten Variablen bereitstellen können:

--- 
- name: Example playbook
  hosts: localhost
  roles:
    - role: linuxconfig.dotfiles
      dotfiles_repository: https://github.com/linuxconfig/dotfiles
      dotfiles_files:
        - vim
        - vimrc

Wir können die Rolle auch importieren oder als Aufgabe einschließen:

- name: Example playbook
  hosts: localhost
  tasks:
    - name: Clone dotfiles
      ansible.builtin.import_role:
        name: linuxconfig.dotfiles
      vars:
        dotfiles_repository: https://github.com/linuxconfig/dotfiles
        dotfiles_files:
         - vim
         - vimrc

Installieren von Rollen

Sobald eine Rolle in Ansible Galaxy freigegeben wurde, kann sie installiert werden, indem Sie Folgendes ausführen:

ansible-galaxy install <role-name>

Der obige Befehl installiert standardmäßig die Rolle, die als Argument im Verzeichnis ~/.ansible/roles übergeben wird. Um die Rolle an einem anderen Ort zu installieren, können wir die Option -p (kurz für --roles-path) verwenden und den Pfad angeben, in dem wir die Rolle als Argument installieren möchten. Angenommen, wir befinden uns in unserem Projektverzeichnis und möchten eine Rolle "lokal" installieren, würden wir Folgendes ausführen:

ansible-galaxy install <role-name> -p roles

Rollen, die als Teil eines Projekts installiert werden sollen, können auch in einer Anforderungsdatei mit der folgenden Syntax aufgelistet werden:

roles:
  - linuxconfig.dotfiles

Um Rollen zu installieren, die in einer Anforderungsdatei aufgeführt sind, können wir die Option -r (--role-file) verwenden und den Pfad der Datei als Argument übergeben. Unter der Annahme, dass die Anforderungsdatei requirements.yml heißt, würden wir Folgendes ausführen:

ansible-galaxy install -r requirements.yml

Schlüsse

In diesem Tutorial haben wir gesehen, wie Sie Ansible-Rollen erstellen, verwenden und installieren, die eine Möglichkeit darstellen, Code und Aufgaben zu organisieren und wiederzuverwenden, die auf das Ausführen bestimmter Aktionen abzielen.