Ansible-Tutorial für Einsteiger unter Linux

Ein Systemadministrator muss sich in den allermeisten Fällen um mehr als einen Server kümmern, so dass er oft sich wiederholende Aufgaben auf allen ausführen muss. In diesen Fällen ist Automatisierung ein Muss. Ansible ist eine Open-Source-Software im Besitz von Red Hat. Es ist in der Programmiersprache Python geschrieben und es handelt sich um eine Bereitstellungs- und Konfigurationsmanagement-Software, die uns in den oben genannten Fällen hilft. In diesem Tutorial werden wir sehen, wie man es installiert und welche grundlegenden Konzepte hinter seiner Verwendung stehen.

In diesem Tutorial lernen Sie:

So installieren Sie Ansible auf den am häufigsten verwendeten Linux-Distributionen
So konfigurieren Sie Ansible
Was ist das Ansible-Inventar?
Was sind die Ansible-Module?
So führen Sie ein Modul über die Befehlszeile aus
Erstellen und Ausführen eines Playbooks

Verwendete Softwareanforderungen und Konventionen

Installieren von Ansible

Das Ansible-Paket ist in den offiziellen Repositories der am häufigsten verwendeten Linux-Distributionen enthalten, so dass es einfach mit ihren nativen Paketmanagern installiert werden kann. Um es unter Debian zu installieren, können wir Folgendes ausführen:

sudo apt-get update && apt-get install ansible

So installieren Sie stattdessen Ansible auf Fedora:

sudo dnf install ansible

Ansible befindet sich im Archlinux "Community"-Repository; Wir können es mit Pacman installieren:

sudo pacman -Sy ansible

Wenn wir Ansible unter CentOS8 installieren möchten, müssen wir die Softwarequelle epel-release zu unserem System hinzufügen, da das Paket nicht in den Standard-Repositories verfügbar ist. Dazu führen wir den folgenden Befehl aus:

sudo dnf install https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm

Danach können wir einfach ausführen:

sudo dnf install ansible

Für andere distributionsspezifische Installationsanweisungen können wir die entsprechende Seite
der offiziellen Ansible-Dokumentation konsultieren.

Einführung in Ansible

Die grundlegende Besonderheit von Ansible besteht darin, dass es sich um ein agentenloses Bereitstellungssystem handelt. Das bedeutet, dass wir keinen Agenten oder Software-Daemon auf den Servern installieren müssen, die wir kontrollieren möchten. Alles, was wir brauchen, ist Ansible auf der sogenannten Control Machine zu installieren und zu konfigurieren. Die Aufgaben, die wir konfigurieren, werden in den allermeisten Fällen über eine einfache SSH-Verbindung ausgeführt.

Die Ansible-Konfigurationsdatei

Ansible kann konfiguriert werden, indem Parameter und deren Werte in einer oder mehreren Konfigurationsdateien angegeben werden. Die Anwendung sucht in der Reihenfolge ihrer Priorität nach den folgenden Dateien:

Die Datei, die über die Variable ANSIBLE_CONFIG angegeben wird
Die Datei ansible.cfg im aktuellen Arbeitsverzeichnis
Die Datei .ansible.cfg im Home-Verzeichnis des Benutzers
Die Datei /etc/ansible/ansible.cfg

Die Datei /etc/ansible/ansible.cfg ist die letzte, daher wird sie als Fallback und Standard verwendet. Aus offensichtlichen Gründen ist dies nicht der geeignete Ort, um alle möglichen Parameter zu beschreiben, die in einer Konfigurationsdatei angegeben werden können, aber hier ist ein Auszug des Dateiinhalts:

[defaults]

some basic default values...

#inventory      = /etc/ansible/hosts
#library        = /usr/share/my_modules/
#module_utils   = /usr/share/my_module_utils/
#remote_tmp     = ~/.ansible/tmp
#local_tmp      = ~/.ansible/tmp
#plugin_filters_cfg = /etc/ansible/plugin_filters.yml
#forks          = 5
#poll_interval  = 15
#sudo_user      = root
#ask_sudo_pass = True
#ask_pass      = True
#transport      = smart
#remote_port    = 22
#module_lang    = C
#module_set_locale = False

Bei den Parametern im Beispiel handelt es sich um kommentierte Parameter, die mit ihren Standardwerten definiert sind. Darunter sehen Sie die Inventarparameter, die den Wert /etc/ansible/hosts haben. Was das ist, werden wir im nächsten Abschnitt sehen.

Die Datei "hosts" oder "inventory"

In der ansible-Datei "hosts" legen wir im Grunde die IP-Adresse oder die Hostnamen der Maschinen fest, die wir mit Ansible steuern möchten (dies ist das "Inventar" im Ansible-Jargon). Bei einer Standardinstallation befindet sich die Datei im Verzeichnis /etc/ansible. In der Bestandslistendatei können Hosts gruppiert oder nicht gruppiert werden. Wir können einen Host selbst angeben, zum Beispiel:

server1

Wenn wir jedoch Operationen auf mehr als einem Host durchführen möchten, ist es sehr nützlich, Hosts in Gruppen zu setzen, die beispielsweise mit ihrer "Rolle" als Kriterium erstellt werden. Angenommen, die Hosts, mit denen wir es zu tun haben, werden alle als Webserver verwendet, könnten wir schreiben:

[webservers]
server1
server2

Ansible-Module

Ansible-Module sind im Grunde kleine Programme, die verwendet werden, um die Aufgaben auszuführen, die wir benötigen. Jeder von ihnen ist so konzipiert, dass er eine einzige grundlegende Operation ausführt, um die Granularität zu gewährleisten. Sie können über die Befehlszeile oder in Playbooks ausgeführt werden. Die vollständige Liste aller Module finden Sie auf der entsprechenden Seite der offiziellen Dokumentation. Auch hier können wir nicht alle Module untersuchen, aber hier sind einige Beispiele.

Die Module apt, dnf und yum werden verwendet, um Pakete mit den Dateimanagern zu verwalten, von denen sie ihren Namen
beziehen. Das seboolesche Modul wird verwendet, um den Status von SELinux-Booleschen Werten zu verwalten, das Benutzermodul wird verwendet, um Benutzerkonten zu verwalten, usw.

Verwenden von Modulen über die Befehlszeile

Wie wir im vorherigen Abschnitt erwähnt haben, können Module über die Befehlszeile oder über Playbooks verwendet werden. Auf Letzteres werden wir uns im nächsten Abschnitt konzentrieren; Hier zeigen wir, wie Sie ein Modul von der Befehlszeile aus mit dem Befehl Ansible verwenden. In diesem Beispiel verwenden wir das Ping-Modul. Dieses Modul hat nichts mit dem Ping-Befehl zu tun, sondern wird verwendet, um zu überprüfen, ob wir uns auf den Remote-Servern anmelden können und ob ein Python-Interpreter auf ihnen installiert ist. Das Modul gibt bei Erfolg den "pong"-Wert zurück:

ansible webservers -m ping --ask-pass

Wir haben den Befehl ansible aufgerufen, der angibt, dass wir die Aufgabe auf den Hosts-Mitgliedern der Gruppe "webservers" ausführen möchten, und mit der Option -m haben wir den Namen des Moduls übergeben, das wir verwenden möchten. Wir haben auch die Option --ask-pass verwendet, warum? Obwohl ich zuvor den Fingerabdruck des Remote-Servers zur SSH-Datei "bekannte Hosts" der Steuerungsmaschine hinzugefügt habe, habe ich den SSH-Zugriff über den öffentlichen Schlüssel nicht konfiguriert, daher sollte ein SSH-Passwort angegeben werden, wenn wir eine Aufgabe ausführen. Die Option --ask-pass sorgt dafür, dass das Passwort interaktiv abgefragt wird. Hier ist die Ausgabe des obigen Befehls
:

SSH password:
server2 | SUCCESS => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/bin/python"
    },
    "changed": false,
    "ping": "pong"
}
server1 | SUCCESS => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/bin/python"
    },
    "changed": false,
    "ping": "pong"
}

Ansible-Playbooks

Was ist ein Playbook? Ansible-Playbooks sind nichts anderes als YAML-Dateien, in denen wir die Aufgaben angeben, die wir mit Ansible ausführen möchten, und die Hosts, auf denen sie ausgeführt werden sollen. Sehen wir uns ein Playbook-Beispiel an. In der folgenden Datei richten wir eine Aufgabe ein, um sicherzustellen, dass der Vim-Texteditor installiert ist und die neueste verfügbare Version vorliegt:

---

- name: Update webservers
  hosts: webservers
  remote_user: egdoc
  become: yes

  tasks:
    - name: Ensure Vim is installed and at the latest version
      dnf:
        name: vim
        state: latest

...

Lassen Sie uns das oben Gesagte analysieren. Die --- und ..., die wir am Anfang bzw. am Ende der Datei sehen können, sind Teil der Standard-YAML-Syntax: Sie sind optional und markieren den Anfang und das Ende der Datei. Die Anweisungen und ihre Werte werden in einem Wörterbuchformat als Schlüssel-Wert-Paare dargestellt.

Ein Playbook kann mehrere sogenannte Plays enthalten; In diesem Fall haben wir nur eine definiert. In der Tat war das erste, was wir taten, den Namen anzugeben, der in diesem Beispiel "Webserver aktualisieren" lautet. Der zweite Schlüssel, den wir verwendet haben, ist hosts: Mit ihm können wir die Hostgruppe definieren, auf der die Aufgaben ausgeführt werden sollen. In diesem Fall haben wir als Wert webservers angegeben, der die Maschinen umfasst, die wir in den vorherigen Beispielen definiert haben (server1 und server2).

Der nächste Schlüssel, den wir benutzten, war remote_user. Damit können wir festlegen, mit welchem Benutzer wir uns über SSH auf den Remote-Servern anmelden sollen. Danach haben wir den Werde-Schlüssel verwendet. Dieser Schlüssel akzeptiert einen booleschen Wert und mit ihm legen wir fest, ob
Privilegienausweitung zur Ausführung der Aufgaben verwendet werden soll oder nicht. In diesem Fall, da wir uns auf den entfernten Rechnern mit dem Benutzer "egdoc" anmelden und wir Root-Rechte benötigen, um ein Paket zu installieren, setzen wir es auf yes. Es ist wichtig zu beachten
, dass die Berechtigungsausweitung in der Konfigurationsdatei /etc/ansible/ansible.cfg im entsprechenden Abschnitt konfiguriert wird. In diesem Fall sind die Standardwerte wie folgt:

[privilege_escalation]
#become=True
#become_method=sudo
#become_user=root
#become_ask_pass=False

Nachdem wir die Spielinformationen definiert hatten, begannen wir, unsere Aufgabenliste zu spezifizieren. Dazu haben wir das Schlüsselwort tasks verwendet. Jede Aufgabe hat einen Namen, der in der Dokumentation und in Aufgabenhandlern verwendet wird.

Mit dnf: haben wir angegeben, dass wir das Modul "dnf" verwenden möchten, das, wie wir bereits gesehen haben, zur Verwaltung von Paketen mit dem Standard-Paketmanager in der Red Hat-Distributionsfamilie verwendet wird. In diesem Abschnitt haben wir mit dem Namen keyword
den Paketnamen angegeben. In diesem Beispiel interessieren wir uns nur für ein einzelnes Paket, aber es können mehrere Pakete über eine Liste angegeben werden. Zum Beispiel:

dnf:
    name: [vim, nano]

Mit dem Schlüsselwort state des dnf-Moduls legen wir grundsätzlich fest, was wir mit dem/den angegebenen Paket(en) machen wollen. In diesem Fall haben wir latest als Wert verwendet: Damit stellen wir sicher, dass das Paket installiert ist und die neueste verfügbare Version auf der Distribution auf dem entfernten Rechner verwendet wird. Andere mögliche Werte, die wir verwenden können, sind remove oder abent, was dazu führt, dass das/die Paket(e) deinstalliert werden, oder present, die nur sicherstellen, dass das Paket installiert wird. Ich empfehle Ihnen, in der offiziellen Moduldokumentation nach der vollständigen Liste der Schlüssel und Werte zu suchen, die mit dem Modul verwendet werden können.

Los geht's, wir haben gerade unser erstes Playbook definiert. Wie können wir es betreiben?

Ausführen eines Playbooks

Um ein Playbook auszuführen, verwenden wir den dedizierten Befehl ansible-playbook. Der Befehl akzeptiert eine Reihe von Optionen und verwendet eine oder mehrere Playbook-Dateien als Argumente. Um das Playbook auszuführen, das wir im vorherigen Abschnitt definiert haben, würden wir beispielsweise den folgenden Befehl ausführen:

ansible-playbook --ask-pass ---ask-become-pass  /path/to/playbook.yml

Sie können feststellen, dass wir in diesem Fall den Befehl mit den Optionen --ask-become-pass aufgerufen haben. Diese Option wird benötigt, da wir in der Playbook-Datei dem Schlüssel become den Wert yes zugewiesen haben, da wir eine Privilegienausweitung benötigen, um Pakete auf den entfernten Rechnern zu installieren. Die Option --ask-become-pass sorgt dafür, dass das sudo-Passwort abgefragt wird, wenn wir das Playbook ausführen. Da wir in diesem Fall auch --ask-pass verwendet haben, wird das SSH-Passwort als Standardpasswort für die Rechteausweitung verwendet. Hier ist die Ausgabe, die wir erhalten, wenn wir das Playbook ausführen:

SSH password:
BECOME password[defaults to SSH password]:

PLAY [Update webservers] *******************************************************************************************************************************************

TASK [Gathering Facts] *********************************************************************************************************************************************
ok: [server1]
ok: [server2]

TASK [Ensure Vim is installed at the latest version] ***************************************************************************************************************
changed: [server1]
changed: [server2]

PLAY RECAP *********************************************************************************************************************************************************
server1                    : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
server2                    : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Zuerst werden wir aufgefordert, das Passwort "SSH" anzugeben, dann das Passwort "WERDEN". Wie bereits erwähnt, wird in diesem Fall das SSH-Passwort als Standardwert verwendet. Wie Sie vor der Aufgabe, die wir im Playbook angegeben haben, sehen können, wird eine weitere Aufgabe ausgeführt: "Sammeln von Fakten". Diese Aufgabe wird standardmäßig ausgeführt, um nützliche Variablen über Remote-Hosts zu sammeln, die in Playbooks verwendet werden können.

Nachdem die Aufgaben ausgeführt wurden, erhalten wir eine Zusammenfassung der von uns angegebenen Spielzüge. In diesem Fall können wir sehen, dass zwei Aufgaben korrekt ausgeführt wurden (ok=2) und eine Aufgabe eine Änderung bewirkt hat (geändert=1). Das macht Sinn: Die Änderung ist seit der Installation des vim-Pakets erfolgt.

Wenn wir nun versuchen, das Playbook erneut auszuführen, können wir sehen, dass keine Änderungen auftreten, da vim bereits installiert und in der letzten verfügbaren Version ist:

PLAY RECAP *********************************************************************************************************************************************************
server1                    : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
server2                    : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Schlüsse

In diesem Tutorial haben wir gelernt, was Ansible ist und was seine Besonderheiten sind. Wir haben gesehen, wie man es auf einigen der am häufigsten verwendeten Linux-Distributionen installiert, wie man es konfiguriert und einige grundlegende Konzepte: Was ist ein Inventar und was sind die
Ansible-Module. Wir haben auch gesehen, wie man ein Modul über die Befehlszeile ausführt und wie man ein Playbook schreibt und ausführt. Dies war nur als Einführung in die Ansible-Welt gedacht; Machen Sie sich die Hände schmutzig, experimentieren Sie und lesen Sie die offizielle Dokumentation für ein tieferes Wissen!