systeme mit ansible konfigurieren

Systeme mit Ansible konfigurieren

Mit Ansible kann man verwaltete Systeme innerhalb von orcharhino konfigurieren. Unsere aktuelle Dokumentation gibt es hier.

Ansible ist ein Tool für Automatisierung und Konfigurationsmanagement. Es benötigt weder Client noch Daemon und arbeitet ausschließlich mit Python und SSH. Ansible besteht aus einem Kontrollknoten, z.B. einem Notebook, einer Workstation oder einem Server und verwalteten Knoten, also den Systemen in seinem Inventar. Mit Ansible lassen sich Systeme ähnlich wie mit Puppet und Salt konfigurieren.

 

Tipp: Das Ansible Plug-in für Konfigurationsmanagement basiert auf Ansible-Rollen, die Systemen oder Systemgruppen zugeordnet sind.

Für alle, die Ansible Playbooks verwenden möchten, könnte das Application-Centric Deployment (ACD) Plug-in interessant sein. Mit ACD kann man Anwendungen mit mehreren Systemen mit einem Ansible Playbook und einer Anwendungsdefinition bereitstellen und konfigurieren. Weitere Informationen gibt es hier: Application-Centric Deployment

Webinar auf YouTube: „orcharhino Ansible Integration vs. AWX/Tower“

Tuesday, April 30, 11:00 – 11:45 a.m. CEST
Webinar: Driving Efficiency with Event-Driven Ansible: An Introduction

Unravel the theoretical foundations of Event-Driven Ansible alongside a practical demonstration.
Presented by our blog author Dr. Ottavia Balducci.

Ansible-Installation

Wenn man einen neuen orcharhino installiert, kann man im 5. Schritt der Main orcharhino Installation Steps Ansible als Toll fürs Konfigurationsmanagement auswählen. Diese Option installiert und konfiguriert das Ansible Plug-in auf dem orcharhino.

Um das Ansible Plug-in zu installieren, muss man den folgenden Befehl auf dem bestehenden orcharhino ausführen:

# orcharhino-installer --enable-foreman-plugin-ansible --enable-foreman-proxy-plugin-ansible

Damit installiert man das Ansible Plug-in und die orcharhino Proxy-Funktionen für das gebündelte orcharhino Proxy, das in jedem orcharhino immer enthalten ist.

Das Plug-in zur Fernausführung wird benötigt, um Ansible Playbooks als Job Templates auszuführen. Dieses Plug-in kann man mit dem folgenden Befehl im orcharhino installieren:

# orcharhino-installer --enable-foreman-plugin-remote-execution --enable-foreman-proxy-plugin-remote-execution-script

Ansible Basics

Ansible besteht aus Playbooks, Plays, Tasks, Modulen, Rollen, Fakten und Inventories:

  • Ein Playbook ist eine Sammlung von Plays. Ansible Playbooks sind idempotent, d.h. Ansible wird nur dann tätig, wenn der aktuelle Zustand vom gewünschten Zustand abweicht. Wenn sie mehrmals ausgeführt werden, führt dies nicht zu anderen Ergebnissen, als wenn sie nur einmal ausgeführt werden.

  • Ein Play enthält einen oder mehrere Tasks und verbindet sie mit einzelnen Systemen.

  • Ein Task ist eine einzelne Anweisung und ruft ein einzelnes Modul auf. Sie hat einen Namen und Modulparameter und wird der Reihe nach ausgeführt wie in den Rollen aufgelistet. Tasks können Handlers auslösen, d.h. Tasks, die einmal am Ende eines Playbooks ausgeführt werden.

  • Ein Modul ist der eigentliche Code, der an den verwalteten Knoten übertragen und dort ausgeführt wird, und weist in der Regel eine Form der integrierten Abstraktion auf. So installiert und deinstalliert das Paketmodul beispielsweise Pakete unabhängig vom Betriebssystem und dem Paketmanager. Es gibt viele öffentliche Module, z.B. Service, und man kann auch eigene benutzerdefinierte Module schreiben. Eine Liste der verfügbaren Module gibt es im Ansible Plug-in Index.

  • Eine Rolle ist eine Sammlung von Playbooks mit allen erforderlichen Variablendateien und Konfigurationstemplates.

  • Ein Fakt ist eine Variable, die von Systeminformationen abgeleitet ist. Fakten werden standardmäßig zu Beginn eines jeden Laufs erfasst und können in Playbooks aufgerufen werden.

  • Ein Inventory ist eine YAML-Datei, die die vorhandene Infrastruktur beschreibt, d.h. eine Liste von Systemen und Systemgruppen. Inventories werden häufig verwendet, um Teilmengen von Systemen zu erstellen, die die Ausführung bestimmter Aufgaben auf vordefinierten Systemen ermöglichen. Weitere Informationen gibt es in der Ansible-Inventory-Dokumentation.

Um Ansible Playbooks, Rollen und Inventories lesen und schreiben zu können, muss man mit der YAML-Syntax vertraut sein: YAML (.yaml-Dateien) ist eine Mark-up-Sprache, die auf Einrückungen mit zwei Leerzeichen und ohne Tabulatoren basiert. YAML-Dateien beginnen immer mit drei Bindestrichen und können mit drei Punkten enden. Weitere Informationen finden Sie in der Dokumentation zur Ansible YAML Syntax.

Ansible-Ad-hoc-Befehle eignen sich hervorragend, um einzelne Aufgaben zu testen. In der Regel handelt es sich um Einzeiler, bei denen es sich nicht lohnt, sie in einem Playbook zu speichern. Im folgenden Beispiel wird das Setupmodul auf dem lokalen Rechner ausgeführt:

# ansible localhost -m setup

Mit diesem Befehl wird das Setupmodul ausgeführt, das automatisch Informationen ausgibt, die zu Beginn eines jeden Playbooks gesammelt werden. Es sammelt Hardwareinformationen wie Speicher, Netzwerkschnittstellen und freie Systemressourcen sowie das Betriebssystem, Umgebungsvariablen, verfügbare Python-Versionen und die laufende Kernel-Version. Weitere Informationen finden Sie in der Dokumentation des Ansible Ad Hoc Command.

Beispiel für eine Ansible-Rolle

Die folgende Ansible-Rolle konfiguriert Systeme für den Betrieb eines nginx-Servers mit einer statischen Webseite, die verschiedene Systeminformationen über den Server anzeigt, indem sie eine Jinja-Vorlage rendert. Der folgende Codeblock stellt die Struktur der Ansible-Rolle dar:

Tipp: Man kann das Beispiel für eine Ansible-Rolle auf der ATIX github-Seite finden.

$ tree nginx_sysinfo
nginx_sysinfo
├── defaults
│   └── main.yaml
├── files
│   └── stylesheet.css
├── handlers
│   └── main.yaml
├── tasks
│   └── main.yaml
├── templates
│   └── index.html.j2
└── vars
    └── main.yaml

6 directories, 6 files

HINWEIS: Diese Ansible-Rollenstruktur muss im orcharhino oder orcharhino Proxy in /etc/ansible/roles/ verfügbar sein, wie unten in Schritt 1 beschrieben.

Der folgende Codeblock stellt den Inhalt der Datei defaults/main.yaml dar:

---
full_info: false
...

Er zeigt eine Variable namens full_info, die auf false gesetzt wurde.

Der folgende Codeblock enthält den Inhalt der Datei files/stylesheet.css. Diese CSS-Datei gestaltet die Webseite:

body {
    width: 100%;
    font-family:Arial,Verdana,Calibri,sans-serif;
    font-size:11pt;
    margin-top:0px;
    margin-left:0px;
    margin-right:250px;
    margin-left:200px;
    text-align:left;
    padding-left: 0px;
}

a:link, a:visited {
      color: inherit;
  text-decoration:none;
  }

a:active, a:hover {
  color:#000;
  text-decoration:underline;
        background-color:lightblue;
        text-decoration:none;
  }

h1 {
    font-family:Calibri,Arial,Verdana,sans-serif;
    font-size:30pt;
    text-align:left;
    font-weight:bold;
}

h2 {
    font-family:Calibri,Arial,Verdana,sans-serif;
    clear:both;
    font-size:25pt;
    font-weight:bold;
    margin-top:2em;
}

br {
    clear:both;
}

td {
  padding:5px;
  padding-right:30px;
}

table {
    padding:0px;
    empty-cells:show;
    border-spacing:0px;
    margin-top:50px;
    max-width:50%;
}

th {
    text-align:left;
    border-bottom: solid 1px black;
}

tr:nth-child(even)  {
    background-color: lightblue;
}

tr:nth-child(odd)  {
    background-color: white;
}

Der folgende Codeblock zeigt den Inhalt der Datei handlers/main.yaml:

---
- name: Restart nginx
  become: true
  service:
    name: "{{ nginx_service_name }}"
    state: restarted
...

Er enthält eine Aufgabe namens Restart nginx, die nur einmal am Ende des Playbooks ausgeführt wird, wenn der Handler ein oder mehrere Male ausgelöst wird.

Der folgende Codeblock stellt den Inhalt der Datei tasks/main.yaml dar:

---
- name: Add epel-repository for CentOS
  become: true
  yum:
    name: epel-release
    state: present
  when: ansible_distribution == 'CentOS'

- name: Install required packages
  become: true
  package:
    name: "{{ packages }}"
    state: present

- name: Start nginx service and make it persistent
  become: true
  service:
    name: "{{ nginx_service_name }}"
    state: started
    enabled: true

- name: Set www root for nginx
  set_fact:
    nginx_www_root: "{{ nginx_www_root[ansible_os_family] }}"

- name: Create default page
  become: true
  template:
    src: index.html.j2
    dest: "{{ nginx_www_root }}/index.html"
    validate: tidy %s
  notify: restart nginx

- name: Copy css
  become: true
  copy:
    src: stylesheet.css
    dest: "{{ nginx_www_root }}/stylesheet.css"
  notify: restart nginx

- name: Stop firewall
  become: true
  service:
    name: firewalld
    state: stopped
...

In diesem Playbook befinden sich sieben Tasks, die der Reihe nach ausgeführt werden. Sie werden bei Bedarf als Root User ausgeführt und automatisieren die Schritte zur Installation eines nginx-Webservers, zur Anzeige der Systeminformationen und zum Stoppen der Firewall.

Der folgende Codeblock zeigt den Inhalt der Datei templates/index.html.j2:

<style type="text/css">@import url('./stylesheet.css') all;</style>
<h1>Information about running host</h1>
{% for key, value in ansible_default_ipv4.items() %}{% endfor %}
{% for key, value in ansible_default_ipv6.items() %}{% endfor %}
<table style="float: left; margin-right: 50px;">
<tbody>
<tr>
<th colspan="2">Network information</th>
</tr>
<tr>
<td>Host name</td>
<td>{{ ansible_nodename }}</td>
</tr>
<tr>
<td>IPv4 addresses</td>
<td>{{ ", ".join(ansible_all_ipv4_addresses) }}</td>
</tr>
<tr>
<td>IPv6 addresses</td>
<td>{{ ", ".join(ansible_all_ipv6_addresses) }}</td>
</tr>
<tr>
<td>Default IPv4 interface -- {{ key }}</td>
<td>{{ value }}</td>
</tr>
<tr>
<td>Default IPv6 interface -- {{ key }}</td>
<td>{{ value }}</td>
</tr>
<tr>
<td>Host name</td>
<td>{{ ansible_hostname }}</td>
</tr>
<tr>
<td>FQDN</td>
<td>{{ ansible_fqdn }}</td>
</tr>
</tbody>
</table>
{% if full_info %}
<table>
<tbody>
<tr>
<th colspan="2">OS Facts</th>
</tr>
<tr>
<td>This system is running on</td>
<td>{{ ansible_distribution }}</td>
</tr>
<tr>
<td>Version</td>
<td>{{ ansible_distribution_version }}</td>
</tr>
<tr>
<td>OS Family</td>
<td>{{ ansible_os_family}}</td>
</tr>
<tr>
<td>Used package manager</td>
<td>{{ ansible_pkg_mgr }}</td>
</tr>
<tr>
<td>AppArmor</td>
<td>{{ ansible_apparmor['status'] }}</td>
</tr>
<tr>
<td>Selinux</td>
<td>{{ ansible_selinux['status'] }}</td>
</tr>
<tr>
<td>Python Version</td>
<td>{{ ansible_python_version }}</td>
</tr>
</tbody>
</table>
{% for key, value in ansible_env.items() %}{% endfor %}
<table>
<tbody>
<tr>
<th colspan="2">Environment variables</th>
</tr>
<tr>
<td>{{ key }}</td>
<td>{{ value }}</td>
</tr>
</tbody>
</table>
{% endif %}

Dieses Template beinhaltet Standard-HTML-Code und Anweisungen für Jinja. Jinja rendert diese Datei und füllt ihre Variablen aus.

Der folgende Codeblock stellt den Inhalt der Datei vars/main.yaml dar:

---
nginx_package_name: nginx
nginx_service_name: nginx
nginx_www_root:
Debian: "/var/www/html/"
RedHat: "/usr/share/nginx/html/"

packages:
- tidy
- "{{ nginx_service_name }}"
...

In dieser Datei befinden sich alle notwendigen Variablen, z.B. das nginx www Root Directory, das abhängig ist von der Linux Distribution, auf der nginx läuft.

Verwendung von Ansible

In diesem Abschnitt wird beschrieben, wie man eine Ansible-Rolle für Konfigurationsmanagement in orcharhino verwendet. Wir haben das oben gezeigte Beispiel genommen, um einen nginx-Webserver auf mehreren von orcharhino verwalteten Systemen zu installieren und zu konfigurieren. Alternativ kann man auch eine beliebige Ansible-Rolle aus der Ansible Galaxy herunterladen.

Man kann Ansible-Rollen ausführen und ihre Ergebnisse in fünf Schritten in orcharhino überprüfen:

1. Rolle auf orcharhino übertragen

Man kann entweder eine Rolle der Ansible Galaxy direkt in orcharhino herunterladen oder eine eigene Rolle von egal welcher Maschine mittels scp übertragen.

a) Rolle aus der Ansible Galaxy herunterladen

Um eine Rolle aus der Ansible Galaxy herunterzuladen, muss man den folgenden Befehl im orcharhino ausführen:

 

# sudo ansible-galaxy install geerlingguy.nginx -p /etc/ansible/roles/

Damit lädt man die Rolle automatisch herunter und sie wird im richtigen Directory gespeichert, damit orcharhino sie importieren kann.

b. Eigene Rolle kopieren

Um eine eigene Rolle zu kopieren, transferiert man sie mittels scpin den orcharhino:

# scp /path/to/local_role/ root@orcharhino.example.com:/etc/ansible/roles/

2. Rolle in den orcharhino importieren

Um neu heruntergeladene Ansible-Rollen in orcharhino zu importieren, geht man auf Configure > Ansible Roles.

Ansible Roles
  • Ein Klick auf den Import from My_FQDN Button (1) öffnet ein Drop-down-Menü mit einer Liste, in der orcharhino und alle dazugehörigen orcharhino Proxies. So kann man die Maschine auswählen, von der die Rolle importiert wird. Hier ist es wichtig, sicherzustellen, dass man die auswählt, auf der man vorher die Ansible-Rolle heruntergeladen hat.

  • Außerdem wird eine Tabelle (2) mit den verfügbaren Ansible-Rollen angezeigt.

  • Man kann Ansible-Rollen löschen, indem man im Actions-Menü (3) auf “Delete” klickt.

Ansible Roles Upload
  • Daraufhin wird eine Liste (1) mit Ansible-Rollen angezeigt, die entweder hinzugefügt oder entfernt wurden.

    In diesem Beispiel wird die Ansible-Rolle ansible_nginx_sysinfo wie oben beschrieben hinzugefügt.

  • Nach Auswahl der gewünschten Rolle klickt man auf Update (2), um sie in orcharhino zu importieren.

3. Ansible-Rolle zu Systemgruppen oder einzelnen Systemen hinzufügen

Man kann die Ansible-Rolle für einzelne Systeme oder Systemgruppen verfügbar machen:

a) Einzelne Systeme

Um eine Ansible-Rolle für einzelne Systeme verfügbar zu machen, geht man zu Hosts > All Hosts und klickt im Action-Menü rechts neben einem System auf Edit. Mit einem Klick auf das blaue Pluszeichen navigiert man zum Ansible Roles Tab, um die Ansible-Rolle hinzuzufügen.

b) Systemgruppen

Unter Configure > Host Groups kann man eine Systemgruppe auswählen. Auf der Ansible Roles Tab kann man die importierte Ansible-Rolle hinzufügen. Nicht vergessen, auf Submit zu klicken, um die Änderungen im orcharhino zu speichern.

4. Ansible-Rolle ausführen

Man kann eine Ansible-Rolle entweder sofort ausführen, einmalig zu einem späteren Zeitpunkt oder regelmäßig. Dazu geht man auf Hosts > All Hosts und wählt ein System oder mehrere aus, indem man die Checkbox links markiert.

Dazu wählt man Schedule Remote Job von dem Drop-down-Menü Select Action aus. So gelangt man zur Seite Job invocations:

Ansible Job
  • Ansible Playbook als Job category (1) auswählen.

  • Ansible Roles – Ansible Default als Job template (2) auswählen.

  • Man kann auch einen Bookmark für vordefinierte Systemselektionen verwenden.

  • Das Suchfeld Search query (4) enthält die Namen der ausgewählten Systeme.

  • Mit dem Button Neu laden (5) wird die Anzahl der Systeme neu berechnet, welche die Suche findet und gegen die die Ansible-Rolle ausgeführt wird.

  • Mit einem Klick auf den Vorschaubutton (6) werden alle Systeme angezeigt, gegen die die Ansible-Rolle ausgeführt wird.

    i) Um sie sofort auszuführen, wählt man bei den Schedule Radio Buttons (7) Execute now.

Ansible Job Execute Now

Mit einem Klick auf Submit (8) wird die Ansible-Rolle sofort ausgeführt.

ii) Um eine Ausführung in der Zukunft zu planen, wählt man bei den Radio Buttons Schedule future execution (7).

Ansible Job Execute Future
  • Startzeit (8) auswählen, zu der die Ansible-Rolle ausgeführt wird.

  • Man kann (muss aber nicht) ein zweites Datum im Feld Start before (9) eingeben, um die geplante Ausführung abzubrechen, falls sie nicht vor einem bestimmten Datum begonnen werden kann.

  • Mit einem Klick auf Submit (10) plant man die Ausführung der Ansible-Rolle.

iii) Um die regelmäßig auszuführen, wählt man Set up recurring execution bei den Schedule Radio Buttons (7).

Ansible Job Execute Recurring
  • Mit dem Repeats-Drop-down-Menü (8) kann man die Häufigkeit festlegen, z.B. stündlich, täglich, wöchentlich, monatlich oder cronline. Die letzte Option ermöglicht eine präzise Eingabe ähnlich wie bei Unix-Cron-Jobs.

  • Wenn man im oben genannten Drop-down-Menü das At-Feld (9) auswählt, kann man die Stunde und Minute festlegen, zu der die Ansible-Rolle ausgeführt wird.

  • Man kann sich dafür entscheiden, die Ansible-Rolle nur eine bestimmte Anzahl an Malen auszuführen, indem man einen Wert in dem Feld Repeat N times (10) eingibt.

  • Zudem kann man die Ansible-Rolle an einem bestimmten Datum anhalten, indem man den Radio Button on im Feld Ends (11) auswählt. Im Beispiel wird die geplante Ausführung nicht beendet.

  • Mit einem Klick auf Submit (12) startet die wiederholte Ausführung der Ansible-Rolle.

Alternativ kann man auch Play Ansible roles aus dem Select Action Drop-down-Menü auswählen. Dies führt alle verfügbaren Ansible-Rollen aus und man gelangt sofort zur Jobs-Seite.

Dies führt zu demselben Ergebnis wie das Auswählen von “jetzt ausführen” in Schritt 4 wie oben beschrieben.

5. Ergebnisse anzeigen

Nachdem man die Ansible-Rollen im obigen Schritt gestartet hat, wird man automatisch auf die Seite mit den entsprechenden Aufgaben weitergeleitet.

Will man andere bereits ausgeführte oder geplante Aufgaben überprüfen, geht man auf die Seite Jobs:

Monitor > Jobs

Den entsprechenden Job kann man in der Liste aller laufenden Jobs auswählen.

Ansible Job Success
  • Das Pie Chart (1) veranschaulicht das Ergebnis der Ausführung der Ansible-Rolle. Es zeigt den Gesamtstatus, z.B. 100 % Erfolg im obigen Beispiel, sowie die Anzahl der erfolgreichen, fehlgeschlagenen, noch laufenden und abgebrochenen Tasks, die durch die Symbole unter dem Diagramm angezeigt werden.

  • In der unteren Tabelle (2) werden alle Systeme angezeigt, auf denen die Aufgabe ausgeführt wurde. Wenn man auf den Namen eines Systems klickt, gelangt man zu dessen Ansible-Ergebnisseite.

  • Das Dropdown-Menü Actions (3) ermöglicht es, eine Aufgabe auf einem einzelnen System erneut auszuführen. Wenn man auf die Schaltfläche Host detail klickt, gelangt man zur Seite Hosts.

  • Wenn man auf den Button Job Task (4) klickt, gelangt man zur Seite Task (siehe unten).

Ansible Job Success Job Task
  • Die Task-Seite zeigt viele Informationen in einer Tabelle an, wie z.B. Username sowie Anfangs- und Enddatum der Task (1). Es gibt zudem eine kurze Zusammenfassung der Anzahl der Tasks, die erfolgreich ausgeführt wurden, was durch den grünen Balken dargestellt wird.

  • Mit dem Sub tasks Button (2) gelangt man zu folgender Seite:

Ansible Job Success Job Task Sub Task
  • Die Seite zeigt Details zu allen ausgeführten Ansible-Rollen an.

  • Die untere Tabelle (1) listet die ausgeführte Ansible-Rolle sowie deren Status und Ergebnis auf. Wenn man auf die Aufgabe im obigen Screenshot klickt, erhält man den folgenden Output:

PLAY [all] *********************************************************************

TASK [Gathering Facts] *********************************************************

ok: [host1.example.com]

TASK [nginx_sysinfo : Add epel-repository for CentOS] **************************

changed: [host1.example.com]

TASK [nginx_sysinfo : Install required packages] *******************************

changed: [host1.example.com]

TASK [nginx_sysinfo : Start nginx service and make it persistent] **************

changed: [host1.example.com]

TASK [nginx_sysinfo : Set www root for nginx] **********************************
ok: [host1.example.com]

TASK [nginx_sysinfo : create default page] *************************************

changed: [host1.example.com]

TASK [nginx_sysinfo : copy css] ************************************************

changed: [host1.example.com]

RUNNING HANDLER [nginx_sysinfo : restart nginx] ********************************

changed: [host1.example.com]

PLAY RECAP *********************************************************************
host1.example.com : ok=8 changed=6 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0

Exit status: 0

Weitere Ressourcen

  • Die offizielle Ansible-Dokumentation ist eine gute Ressource für alles, was sich um Ansible dreht.

  • Ansible gibt es bei EPEL und releases.ansible.com. Hinweis: Beide Links führen zu den Repositories der EL-Version 7 für x86_64-Systeme.

  • Weitere Informationen findet man in der orcharhino management UI unter Configure > Ansible Roles.

ansible

Ansible-Schulung

ATIX bietet Ansible-Schulungen für Anfänger:innen und Fortgeschrittene an, in denen Teilnehmer:innen lernen, wie man Ansible als Konfigurationsmanagement-Tool nutzt. So können sie ihre Infrastruktur mit Ansible-Rollen effizienter verwalten und finden heraus, wie sie Ansible-Rollen, Inventories und Playbooks bestmöglich erstellen, nutzen und pflegen.

The following two tabs change content below.

Maximilian Kolb

Technical Content Creator at ATIX