Ansible

Aus Laub-Home.de Wiki
Zur Navigation springen Zur Suche springen
Baustelle-100px.png Work in Progress:
Diese Seite wird erst noch aufgebaut. Bitte noch keine Änderungen vornehmen, ohne mit dem ursprünglichen Author zu sprechen!
Vielen Dank.
Das Logo des Ansible-Projektes

Ansible ist ein Orchestrierungs-Tool mit dessen Hilfe technische Prozessen im Infrastrukturbereich automatisiert werden können, dazu zählen u.a. Deployments, Systemprovisionierungen und Konfigurationsmanagement. Ursprünglich 2012 von Michael DeHaan veröffentlicht wurde die Technologie 2015 von Red Hat gekauft und seit dem von diesem und der Community weiterentwickelt. Der Kern von Ansible ist Open-Source, Red Hat bietet allerdings kommerzielle Zusatzpakete wie z.B. Ansible Tower und Enterprise Support an.

Dieser Artikel gibt eine Einführung in die Technologie.

Installation

TODO

Technische Konzepte

Der folgende Abschnitt gibt eine Einführung in die von Ansible festgelegten Konzepte inklusive kleiner Beispiele.

Ansible ist in Python geschrieben, ein Vorwissen der Programmiersprache ist für den normalen Gebrauch nicht notwendig. Für die Definitionen wird nahezu durchgehen die YAML-Syntax benutzt, hier ist es hilfreich, das Konzept von YAML vorab verstanden zu haben, ist aber nicht zwingend notwendig. YAML ist nicht kompliziert und wird bei der Einarbeitung in Ansible meist als "Beifang" mitgelernt.

Die Architektur sieht vor, dass eine beliebige Anzahl von Clients (Managed-Nodes) von einem einzigen Rechner aus (Control-Node) verwaltet werden können. Dabei muss der Control-Node nicht zwangsweise ein fester Server sein, sondern es kann sich hierbei auch um den lokalen Rechner handeln. Die Anweisungen und Inventories können auch einfach auf einen anderen Rechner übertragen und von diesem ausgeführt werden, d.h. es muss nicht nur einen Control-Server geben. Siehe dazu die Empfehlungen weiter unten bezüglich dem verteiltem Arbeiten mit Ansible.

Automatisierung im klassichen Ansatz hat meist bedeutet, dass der/die Administrator(en) über die Zeit eine Ansammlung von Skripten (z.B. Bash) erstellt und in eigen-Regie verwaltet haben. Diese Skripte waren oft eine Ansammlung von Befehlen, die auf dem jeweiligem System ausgeführt wurden. Ansible verfolgt einen etwas anderen Ansatz. In Ansible werden meist nicht Befehle, sondern Zustände definiert. Soll z.B. auf dem Ziel-System ein User erstell werden wurde im klassischen Ansatz ein "useradd"-Befehl in ein Skript gepackt. In Ansible wird definiert, dass der User mit den Attributen Name, Gruppe, Home-Verzeichniss, etc. auf dem Ziel-System existieren soll. Wird Ansible ausgeführt prüft dieses, ob der definierte Zusand existiert und wenn nein wird das System insofern angepasst, dass der gewünschte Zusand erreicht wird. Existiert der definierte User nicht, wird dieser z.B. erstellt. Exisitiert dieser, aber die ihm zugewiesenen Gruppen sind nicht korrekt, dann werden seine Gruppen entsprechend der Definition angepasst. Wie genau diese Anpassung erfolgt wird dabei komplett Ansible überlassen. Dies hat den Vorteil, dass der Admin sich meistens nicht mit Sonderfällen und Fehler-Verarbeitung kümmern muss und ist außerdem Ziel-Unabhängig aufgebaut, d.h. die Definitionen sind, OS-unabhängig. Aber Vorsicht! Dies ist leider nicht all-Umfassend in Ansible implementiert. Weitere Beispiele dazu werden weiter unten aufgeführt.

Im Hintergrund generiert Ansible Python Skripte, pusht diese über SSH auf die Clients und führt diese dann aus, daher sind die einzigen Anforderungen an die Clients, dass Python installiert und der Login per SSH aktiv sein muss, einen dedizierten Ansible-Client gibt es nicht (agent-less). Das hat den Vorteil, dass die Wartung von Ansible selbst nahezu kein Aufwand nötigt ist. Da die meisten Linux-Systeme bereits mit Python ausgeliefert und über SSH verwaltet werden sind fast alle Linux-Systeme unterstützt und können auch nachträglich von Ansible verwaltet werden.

Inventar

Welche Systeme ein Control-Node verwaltet wird über das sogenannte Inventar (Inventory) definiert. Dabei handelt es sich um eine einfache Text-Datei, in welcher alle Systeme eingetragen werden. Für diese Datei können 2 Formate genutzt werden: Das INI- und YAML-Format. Welches eingesetzt wird ist eine persönliche Entscheidung, das INI-Format ist etwas einfacher zu lesen, YAML ist aber struktierierter und auch mit dem Rest von Ansible konsistent.

Die folgenden Beispiele für Inventare werden in beiden Formaten aufgezeigt, beide stellen dabei die gleiche Struktur dar. Als erstes ein einfaches Inventar, welches 5 Systeme enhält:

1 # INI-Format
2 web.example.com
3 mail.example.com
4 chat.example.com
5 video.example.com
6 10.0.10.4
1 # YAML-Format
2 all:
3   hosts:
4     web.example.com:
5     mail.example.com:
6     chat.example.com:
7     video.example.com:
8     10.0.10.4:

Standardmäßig versucht Ansible, den im Inventory angegebenen Namen für eine SSH-Verbindung zu nutzten, d.h. es können sowohl DNS-Namen als auch IP-Adressen genutzt werden. Dies ist allerdings nicht zwingend, da die angegeben Hosts im Inventar eigentlich Alias sind. Die tatsächliche IP/der tatsächlichen Hostname kann optional über Variablen zum jeweiligen Host-Eintrag unabhängig gesetzt werden. Das hat den Vorteil, dass kurze, eindeutige Namen innerhalb Ansibles für den Verweis auf Systeme genutzt werden kann, wenn z.B. kein DNS zur Verfügung steht oder die Namen der Systeme sehr lang und/oder unleserlich sind. Als User für die SSH-Verbindung wird der aktuelle (Linux-)User genutzt. Zusätzlich kann ein Host-Eintrag auch um weitere Variablen erweitert werden, um spezifische Gegebenheiten der Umgebung zu berücksichtigen, z.B. ein alternativer SSH-Port. Es folgt ein Beispiel mit dem Inventar von oben, allerdings mit optionalen Variablen erweitert:

 1 # INI-Format
 2 webserver ansible_host=web.example.com     # Der Host 'webserver' ist eigentlich
 3                                            # 'web.example.com'
 4 mail.example.com
 5 chat.example.com ansible_port=20202        # Die SSH-Verbindung erfolgt über
 6                                            # Port 20202 anstatt 22
 7 video.example.com ansible_user=ansible     # Benutze den SSH-User "ansible" für
 8                                            # Die Verbindung anstatt den
 9                                            # aktuellen User.
10 test.example.com ansible_host=10.0.10.4 ansible_port=2022 ansible_user=testuser
 1 # YAML-Format
 2 all:
 3   hosts:
 4     webserver:
 5       ansible_host: 'web.example.com'
 6     mail.example.com:
 7     chat.example.com:
 8       ansible_port: 20202
 9     video.example.com:
10       ansible_user: 'ansible'
11     test.example.com:
12       ansible_host: '10.0.10.4'
13       ansible_port: 2022
14       ansible_user: 'testuser'

Wie zu sehen ist werden im INI-Format Variablen hinter den Host als "<key>=<value>" Paare geschrieben und durch Leerzeichen getrennt. Es können beliebig viele Variablen gentutzt werden. Bei YAML wird eine Variable als zusätzliches Element unterhalb des Hosts definiert. Eine Liste der vom Inventar supporteten Variablen kann hier eingesehen werden. Das Inventar kann einzelne System auch in Gruppen einteilen. Diese Gruppen können dann als ganzes in Ansible angesprochen werden. Dies hat den Vorteil, dass ein neuer Host einfach einer bestehenden Gruppe zugeordnet und dann natlos in bestehende Strukturen eingebunden werden kann. Hier ein Beispiel:

 1 # INI-Format
 2 chat.example.com
 3 video.example.com
 4 
 5 [webserver]
 6 web01.example.com
 7 web02.example.com
 8 web03.example.com
 9 web04.example.com
10 
11 [mailserver]
12 mail01.example.com
13 mail02.example.com
14 
15 [dbserver]
16 dba.example.com
17 dbb.example.com
18 dbc.example.com


 1 # YAML-Format
 2 all:
 3   hosts:
 4     chat.example.com:
 5     video.example.com:
 6   children:
 7     webserver:
 8       hosts:
 9         web01.example.com:
10         web02.example.com:
11         web03.example.com:
12         web04.example.com:
13     mailserver:
14       hosts:
15         mail01.example.com:
16         mail02.example.com:
17     dbserver:
18       hosts:
19         dba.example.com:
20         dbb.example.com:
21         dbc.example.com:

Gruppen können dabei auch verschachtelt werden. Das gleiche Beispiel hier nochmal mit einer zusätzlichen Gruppe "frontend", welche die extern verfügbaren Systeme enthält:

 1 # INI-Format
 2 chat.example.com
 3 video.example.com
 4 
 5 [webserver]
 6 web01.example.com
 7 web02.example.com
 8 web03.example.com
 9 web04.example.com
10 
11 [mailserver]
12 mail01.example.com
13 mail02.example.com
14 
15 [dbserver]
16 dba.example.com
17 dbb.example.com
18 dbc.example.com
19 
20 [frontend:children]
21 webserver
22 mailserver
 1 # YAML-Format
 2 all:
 3   hosts:
 4     chat.example.com:
 5     video.example.com:
 6   children:
 7     frontend:
 8       children:
 9         webserver:
10           hosts:
11             web01.example.com:
12             web02.example.com:
13             web03.example.com:
14             web04.example.com:
15         mailserver:
16           hosts:
17             mail01.example.com:
18             mail02.example.com:
19     dbserver:
20       hosts:
21         dba.example.com:
22         dbb.example.com:
23         dbc.example.com:

An dieser Stelle zeigt sich auch ein Vorteil der YAML-Syntax gegenüber INI: In der YAML-Syntax kann eine Gruppe definiert werden, die sowohl Gruppen als auch normale Hosts enthält. In INI führt eine solche Definition leider zu einem Syntax-Fehler:

 1 # INI-Format
 2 # Nicht funktionsfähig, die Definition in der Gruppe "frontend" wird einen
 3 # Syntax-Fehler werfen!
 4 
 5 [webserver]
 6 web01.example.com
 7 web02.example.com
 8 web03.example.com
 9 web04.example.com
10 
11 [mailserver]
12 mail01.example.com
13 mail02.example.com
14 
15 [dbserver]
16 dba.example.com
17 dbb.example.com
18 dbc.example.com
19 
20 [frontend:children]
21 chat.example.com      # Das hier wird einen Syntax-Fehler werfen!
22 video.example.com     # Das hier wird einen Syntax-Fehler werfen!
23 webserver
24 mailserver
 1 # YAML-Format
 2 # Im Gegensatz zum INI-Format wird hier kein Syntax-Fehler geworfen!
 3 
 4 all:
 5   children:
 6     frontend:
 7       hosts:                    # Diese Definition funktioniert!
 8         chat.example.com:       # Diese Definition funktioniert!
 9         video.example.com:      # Diese Definition funktioniert!
10       children:
11         webserver:
12           hosts:
13             web01.example.com:
14             web02.example.com:
15             web03.example.com:
16             web04.example.com:
17         mailserver:
18           hosts:
19             mail01.example.com:
20             mail02.example.com:
21     dbserver:
22       hosts:
23         dba.example.com:
24         dbb.example.com:
25         dbc.example.com:

Als letzten Punkt soll genannt werden, dass in einem Inventar Hosts auch auch in Ranges definiert werden können. Das ist besonders von Vorteil, wenn eine großzahl von Systemen mit relativ gleichem Namen existieren und das Inventar nicht zu "aufgebläht" werden soll. In unserem Beispiel von oben haben wir in unseren Gruppen Systeme mit durchlaufenden Nummern bzw Buchstaben deklariert, also z.B. web01, web02 etc.. Die Syntax dafür ist "[<von>:<bis>]" und kann für Zahlen und Buchstaben benutzt werden. Hier nochmal das obere Beispiel, welches mit Ranges definiert wurde:

 1 # INI-Format
 2 chat.example.com
 3 video.example.com
 4 
 5 [webserver]
 6 web[01:04].example.com
 7 
 8 [mailserver]
 9 mail[01:02].example.com
10 
11 [dbserver]
12 db[a:c].example.com
13 
14 [frontend:children]
15 webserver
16 mailserver
 1 # YAML-Format
 2 all:
 3   children:
 4     frontend:
 5       hosts:
 6         chat.example.com:
 7         video.example.com:
 8       children:
 9         webserver:
10           hosts:
11             web[01:04].example.com:
12         mailserver:
13           hosts:
14             mail[01:02].example.com:
15     dbserver:
16       hosts:
17         db[a:c].example.com:

Module

Module sind so etwas wie Ansible-native Befehl, sie werden mit bestimmten Variablen aufgerufen und das Modul führt dann den jeweiligen Befehl aus, meistens auf dem Ziel-System. Die meisten Module verfolgen dabei das bereits oben erwähnte Konzept der definierten Zustände. Jetzt könnte man vielleicht denken, dass es sich hierbei um das gleiche wie klassische Shell-Befehle handelt und es kommt der Sache schon nahe. Allerding dienen Module auch als eine Art Abstraktionsschicht, d.h. das Modul zum erstellen eines Users wird immer gleich definiert, Ansible kümmert sich darum, dass der User auf den verschiedenen Systemen gemäß der Definition existiert unabhängig von darunter liegenden OS.

Im Rahmen von Playbooks (näheres dazu siehe unten Playbooks) werden Module mit YAML deklariert, hier ein Beispiel:

1 - name: "Create a new user"
2   user:
3     name: "test"                     # Name des neuen Users
4     group: "testgroup"               # Primäre Gruppe des neuen Users
5     shell: "/bin/bash"               # Die Login-Shell des Users
6     password: "<PASSWORD HASH>"      # Der Password-Hash des Users
7     state: present                   # Status des Users, hier "vorhanden"
8     system: no                       # Der neue User ist kein System-Account

Gehen wir das Ganze mal durch:

Ganz am Anfang steht "name", dass ist eine optionale Bezeichnung, die der Aktion gegeben werden kann, hier sollte immer etwas kurzes und sprechendes stehen. Wer das weg lässt macht sich schnell unbeliebt :-)

Der nächste Punkt sagt, dass die Aktion das Modul "user" aufrufen soll, die eingerückten weiteren Punkte sind, YAML typisch, eine Ansammlung von Key-Value-Paaren, die "user" unterstellt sind und den zu erstellenden User beschreiben. Ein Modul kann eine beliebige Zahl dieser Variablen haben, meistens werden aber nur die wenigsten zwingend benötigt. Das "user"-Modul hat z.B. über 30 verfügbare Variablen, die meisten haben aber gut gewählte Standard-Werte. Ein Überblick der vom Ansible-Projekt mitgelieferten Module (Core Modules) sowie der verfügbaren Variablen und Beispielen kann in der Dokumentation des Projektes eingesehen werden.

Es können auch eigene Module geschrieben und in Ansible ingetriert werden, die bereits mitgelieferten reichten jedoch in über 99% der Fälle locker aus. Module werden primär in Python geschrieben um eine durchgehende Kompatibilität zwischen den unterschiedlichen Systemen zu gewährleisten, allerdings kann theoretisch fast jede Programmiersprache verwendet werden. Der dazu gehörende Interpreter (z.B. Perl) muss dann aber auf dem Ziel-System verfügbar sein.

Wird ein Modul ausgeführt gibt es danach eine von 3 möglichen Status-Meldungen zurück:

Mögliche Status-Meldungen eines Ansible Moduls
Status Beschreibung
OK Das Modul wurde erfolgreich ausgeführt, es mussten keine Veränderungen am Ziel durchgeführt werden um den definierten Status zu erreichen
Changed Das Modul wurde erfolgreich ausgeführt, das Ziel-System wurde angepasst um den definierten Status zu erreichen
Failed Das Modul ist in einen kritischen Fehler gelaufen.

Gibt ein Modul den Status Failed zurück endet sofort die komplette Ausführung von Ansible für das jeweilige Ziel, auch wenn es noch nachfolgende Aktionen gibt, die theoretisch erfolgreich durchgeführt werden könnten. Zudem kann ein Modul noch zusätzlich informationen zurück geben wie z.B. der Status-Code eines dazugehörenden Kommandos oder eine Fehlermeldung.

Ad-Hoc Befehle

TODO

Playbooks

TODO

Rollen

TODO

Verteiltes Arbeiten

TODO

Quellen