Featured image of post Ansible in der Hybrid-Cloud: Der Weg zur effizienten Automatisierung

Ansible in der Hybrid-Cloud: Der Weg zur effizienten Automatisierung

Dieser Blogbeitrag zeigt dir, wie du mit Ansible die Automatisierung deines Homelabs auf ein neues Level bringst. Wir erklären die Grundlagen von Ansible, erstellen eine maßgeschneiderte Rolle und nutzen sie, um Docker effizient auf deinen Hosts zu installieren. Schritt für Schritt lernst du, wie du wiederkehrende Aufgaben vereinfachst und deine Infrastruktur konsistent verwaltest. Perfekt für alle, die ihre Hybrid-Cloud smarter und effizienter gestalten möchten!

Die Hybrid-Cloud-Serie für dein Homelab bietet eine umfassende Anleitung zur Einrichtung einer sicheren, flexiblen und skalierbaren Homelab-Umgebung. Jeder Beitrag behandelt einen spezifischen Schritt, von der Hardware-Auswahl über Automatisierung und Containerisierung bis hin zu Bereitstellung von Applikationen wie Nextcloud oder Home-Assistant.

  1. Hybrid Cloud: Die ideale Kombination aus Flexibilität, Sicherheit und Skalierbarkeit für dein Homelab
  2. Ansible in der Hybrid-Cloud: Der Weg zur effizienten Automatisierung
  3. Containerisierung mit Docker: Die ideale Grundlage für dein Homelab
  4. Caddy als Reverse Proxy: Sichere deine Hybrid-Cloud
  5. Authentik in der Hybrid-Cloud: Zentrale Authentifizierung leicht gemacht
  6. Sicherer Zugriff auf deine Hybrid-Cloud: Alles über SSH-Tunneling

Ansible in der Hybrid-Cloud: Der Weg zur effizienten Automatisierung

Im ersten Teil dieser Serie haben wir die Hardware-Grundlagen für dein Homelab geschaffen und den Grundstein für eine Hybrid-Cloud-Infrastruktur gelegt. Nun geht es darum, diese Basis effizient zu nutzen und Routineaufgaben zu automatisieren. Denn je komplexer die Umgebung, desto wichtiger wird eine zuverlässige und konsistente Verwaltung.

In diesem zweiten Teil widmen wir uns dem mächtigen Automatisierungswerkzeug Ansible, das in einer Hybrid-Cloud-Umgebung unerlässlich ist. Als agentenloses Tool ermöglicht es dir, sowohl lokale als auch Cloud-gestützte Ressourcen nahtlos zu verwalten. Ob Konfigurationsmanagement, Software-Deployments oder die Pflege von Systemen – mit Ansible machst du den nächsten Schritt hin zu einer optimierten und zukunftssicheren Infrastruktur.

Wir knüpfen an die im letzten Beitrag besprochenen Grundlagen an und zeigen dir, wie du diese durch Automatisierung auf das nächste Level hebst. Gemeinsam setzen wir die Theorie in die Praxis um und schaffen eine effizientere und dynamischere Umgebung für deine Projekte. Bereit, deine Hybrid-Cloud mit Ansible zu revolutionieren? Dann lass uns loslegen!

Voraussetzungen: Das brauchst du für Ansible in der Hybrid-Cloud

Bevor du mit der Ansible Automatisierung startest, stelle sicher, dass folgende Voraussetzungen erfüllt sind. Diese ermöglichen es dir, die Anleitung problemlos zu befolgen und Ansible vollständig zu nutzen:

  • Vorhandene Hardware: Stelle sicher, dass sowohl der Homelab-Host als auch der Cloud-Provider betriebsbereit sind. Detaillierte Informationen hierzu findest du im ersten Beitrag.

Für mein Setup nutze ich einen MINIS FORUM MS-01 und einen dedizierten Server bei Hetzner. Beide bieten eine kosteneffiziente Lösung für eine Hybrid Cloud.

  • Betriebssysteme: Die verwalteten Nodes, sowohl der Homelab- als auch der Cloud-Host, sollten idealerweise mit einer Debian-basierten Linux-Distribution ausgestattet sein. Ansible kann zwar auch andere Distributionen sowie Windows-Nodes verwalten, doch unsere Beispiele sind auf Debian-Distributionen ausgerichtet.
  • SSH-Zugriff: Die Control Node (der Host, von dem aus Ansible betrieben wird) sollte sich bereits per SSH-Schlüssel auf allen verwalteten Hosts einloggen können. Dies ist keine zwingende Voraussetzung, ist aber der Standard-Authentifizierungsmechanismus von Ansible.
  • Benutzerrechte: Der Benutzer, mit dem sich die Control Node auf den verwalteten Hosts anmeldet, muss über Sudo-Rechte verfügen.
  • Ansible-Installation: Ansible muss auf der Control Node installiert sein. Sollte dies nicht der Fall sein, konsultiere bitte die offizielle Ansible-Installationsanleitung. Stelle zudem sicher, dass die Control Node sich mit allen verwalteten Nodes verbinden kann. Dies kann z. B. mithilfe des Befehls ansible all -m ping getestet werden.

Die Voraussetzungen sind essenziell, um Ansible effektiv in einer Hybrid-Cloud-Umgebung zu nutzen. Nachdem diese Grundlagen gelegt wurden, kannst du beginnen, Ansible-Playbooks gezielt einzusetzen, um die Automatisierung und Verwaltung deiner Infrastruktur zu optimieren. Besonders im Kontext dieses Beitrags sind sie unerlässlich, da sie die Basis für die folgenden Kapitel bilden. Dort erfährst du, wie Inventories, Playbooks und Roles in Ansible angewendet werden, um eine reibungslose Container-Bereitstellung mit Docker Compose zu ermöglichen.

Was ist Ansible? Einführung in das Automatisierungstool

Ansible ist ein Open-Source-Automatisierungstool, das entwickelt wurde, um Aufgaben wie das Installieren, Konfigurieren und Verwalten von Diensten einfacher und effizienter zu machen. Es funktioniert ohne die Installation zusätzlicher Software auf den Zielsystemen, da es auf Standardprotokolle wie SSH setzt. Seine einfache Handhabung und die YAML-basierte Syntax machen es auch für Homelab-Enthusiasten leicht zugänglich.

Im Vergleich zu anderen Tools wie Terraform oder Puppet nimmt Ansible eine etwas andere Rolle ein:

  • Terraform: Während Terraform hauptsächlich auf das Provisionieren von Infrastruktur (z. B. VMs in der Cloud) spezialisiert ist, liegt der Fokus von Ansible auf der Konfiguration und Verwaltung bereits existierender Systeme. Terraform wird oft verwendet, um Ressourcen in der Cloud zu erstellen, wie z. B. virtuelle Maschinen, während Ansible darauf abzielt, diese Maschinen zu konfigurieren und Dienste bereitzustellen.
  • Puppet: Puppet ist ebenfalls ein Konfigurationsmanagement-Tool, unterscheidet sich jedoch durch die agentenbasierte Architektur. Im Gegensatz zu Ansible erfordert Puppet die Installation eines Agents auf den Zielsystemen, was den Verwaltungsaufwand erhöhen kann. Ansible ist dank seiner agentenlosen Struktur besonders für kleinere Umgebungen wie Homelabs attraktiv.

Zusammengefasst eignet sich Ansible ideal für Homelabs, da es die Komplexität minimiert, keine zusätzliche Software auf den Zielsystemen benötigt und eine niedrige Einstiegshürde bietet.

Vorteile von Ansible für dein Homelab

  1. Agentenlos: Ansible kommuniziert über Standardprotokolle wie SSH, ohne dass zusätzliche Software auf den Zielsystemen benötigt wird.
  2. Flexibel: Es unterstützt Szenarien wie die Verwaltung eines Mediaservers (z. B. Jellyfin) oder die Automatisierung von Smart-Home-Lösungen (z. B. Home Assistant).
  3. Zeitsparend: Regelmäßige Aufgaben wie Updates oder Backups können automatisiert und gleichzeitig auf mehreren Hosts ausgeführt werden.
  4. Fehlervermeidend: Automatisierte Prozesse reduzieren manuelle Fehler und sorgen für konsistente Ergebnisse.

Ein weiterer großer Vorteil von Ansible ist die aktive Community, die eine Vielzahl von Rollen und Modulen für spezifische Anwendungsfälle bereitstellt. Diese Rollen ermöglichen es dir, ohne viel Vorwissen komplexe Dienste wie Nextcloud oder Jellyfin in deinem Homelab bereitzustellen.

Durch diese Vorteile ermöglicht Ansible eine effiziente und strukturierte Verwaltung deines Homelabs, ohne dich mit unnötigem Overhead zu belasten.

Warum ist Ansible im Homelab unverzichtbar?

Im Homelab sind viele verschiedene Dienste im Einsatz, die regelmäßig aktualisiert, gesichert und konfiguriert werden müssen. Dienste wie Jellyfin, Nextcloud oder Home Assistant erfordern häufig Anpassungen, die ohne Automatisierung viel Zeit und Aufwand bedeuten können.

Ansible hilft dir dabei, diese Herausforderungen zu bewältigen:

  • Standardisierte Abläufe: Mit Ansible wird sichergestellt, dass alle Systeme und Dienste einheitlich eingerichtet und verwaltet werden.
  • Skalierbarkeit: Egal, ob du ein neues System hinzufügst oder ein bestehendes aktualisierst – Ansible macht dies effizient und einfach.
  • Flexibilität: Ansible passt sich deinem Homelab an und ermöglicht es, schnell neue Dienste zu integrieren.

Dank dieser Eigenschaften kannst du auch ein wachsendes Homelab problemlos managen und dabei sicherstellen, dass alles optimal funktioniert.

Ansible Grundlagen: Der komplette Einsteiger-Guide

Bevor du mit Ansible loslegst, solltest du die grundlegenden Konzepte verstehen. Diese umfassen die Struktur von Playbooks, die Verwendung von Inventardateien, Modulen und Variablen sowie die Organisation von Automatisierungen in Rollen. Durch das Verständnis dieser Konzepte kannst du Ansible effektiv einsetzen und die Verwaltung deines Homelabs effizienter und konsistenter gestalten.

Ansible-Playbooks: Schritt-für-Schritt-Anweisungen erstellen

Playbooks sind das Herzstück von Ansible. Sie enthalten Anweisungen, welche Aufgaben auf deinen Systemen ausgeführt werden sollen. Sie sind in YAML geschrieben, was sie leicht lesbar und verständlich macht. Hier ein Beispiel für ein Playbook, das Jellyfin auf deinem Mediaserver installiert:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
- name: Installiere Jellyfin
  hosts: mediacenter
  tasks:
    - name: Paketquellen hinzufügen
      apt_repository:
        repo: "deb [arch=amd64] https://repo.jellyfin.org/debian buster main"
        state: present
    - name: Jellyfin installieren
      apt:
        name: jellyfin
        state: present

In diesem Beispiel definiert das Playbook zwei Aufgaben: Die erste Aufgabe fügt die Paketquelle von Jellyfin hinzu, damit das Paket später installiert werden kann. Die zweite Aufgabe installiert das Jellyfin-Paket mit dem Modul apt. Das Playbook wird auf allen Hosts in der Gruppe mediacenter ausgeführt. Playbooks eignen sich hervorragend für einfache Automatisierungen, während komplexere Szenarien besser durch Rollen organisiert werden.

Inventar in Ansible: Systeme und Hosts effizient verwalten

Das Inventar ist eine Datei, in der alle Systeme definiert sind, die du mit Ansible verwalten möchtest. Hier ein Beispiel für ein Inventar:

1
2
3
4
5
6
7
8
all:
  children:
    mediacenter:
      hosts:
        192.168.1.10:
    smart_home:
      hosts:
        192.168.1.20:

Das Inventar ist in Gruppen unterteilt: mediacenter und smart_home. Jede Gruppe enthält Hosts mit ihren spezifischen IP-Adressen oder Namen. Dieses hierarchische Format ermöglicht es dir, Variablen und Rollen auf Gruppen- oder Hostebene anzuwenden, was die Verwaltung vereinfacht.

Ansible-Module: Die wichtigsten Tools für Automatisierungen

Module sind die Bausteine von Ansible. Sie führen spezifische Aufgaben aus, wie Software installieren, Dateien kopieren oder Benutzer anlegen. Hier ein Beispiel für das copy-Modul:

1
2
3
4
5
6
7
- name: Aktualisiere Home Assistant Konfigurationsdatei
  hosts: smart_home
  tasks:
    - name: Kopiere Konfiguration
      copy:
        src: /home/user/configuration.yaml
        dest: /config/configuration.yaml

Dieses Playbook verwendet das copy-Modul, um eine Konfigurationsdatei von einem Quellpfad (src) zu einem Zielpfad (dest) auf den Hosts der Gruppe smart_home zu kopieren. Das copy-Modul ist nützlich für das Bereitstellen von statischen Dateien auf Zielsystemen.

Ansible-Variablen: Flexibel konfigurieren und wiederverwenden

Variablen machen Playbooks flexibel und wiederverwendbar. Hier ein Beispiel:

1
2
3
4
5
6
7
8
vars:
  media_path: "/mnt/media"

tasks:
  - name: Medienverzeichnis erstellen
    file:
      path: "{{ media_path }}"
      state: directory

In diesem Beispiel definiert vars die Variable media_path. Innerhalb der Aufgabe wird diese Variable durch {{ media_path }} referenziert, um das Verzeichnis zu erstellen. Variablen können auf Playbook-, Gruppen- oder Hostebene definiert werden, um Konfigurationen dynamisch zu gestalten.

Rollen in Ansible: So strukturierst du deine Automatisierungen

Rollen sind der wichtigste Baustein für eine skalierbare und modulare Nutzung von Ansible. Sie helfen dir, Playbooks in wiederverwendbare Einheiten zu organisieren und komplexe Automatisierungen übersichtlich zu gestalten.

Warum sind Rollen in Ansible unverzichtbar?

Rollen erlauben es dir, deine Konfiguration in klar strukturierte, wiederverwendbare und gut wartbare Einheiten zu zerlegen. Sie fördern Best Practices, indem sie bestimmte Aufgaben und Dateien an festen Orten organisieren. Rollen sind besonders hilfreich in Szenarien, in denen du ähnliche Konfigurationen auf verschiedene Hosts anwenden möchtest oder wenn du Aufgaben wiederholt in mehreren Projekten benötigst.

Ansible-Rollen erstellen: So geht’s mit ansible-galaxy

Rollen können manuell erstellt oder mit Hilfe von ansible-galaxy generiert werden. Das Tool ansible-galaxy ist Teil der Ansible-Installation und hilft dabei, die empfohlene Verzeichnisstruktur für Rollen automatisch zu erstellen. Dies sorgt für Konsistenz und spart Zeit, besonders in größeren Projekten. So gehst du vor:

1
ansible-galaxy init meine_rolle

Dieses Kommando erstellt eine neue Rolle mit der folgenden Struktur:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
meine_rolle/
├── tasks/
│   └── main.yml
├── handlers/
│   └── main.yml
├── templates/
├── files/
├── vars/
│   └── main.yml
├── defaults/
│   └── main.yml
├── meta/
│   └── main.yml
└── README.md
  • tasks/main.yml: Definiert die Aufgaben der Rolle.
  • handlers/main.yml: Enthält Handlers, die auf Benachrichtigungen reagieren.
  • templates/: Jinja2-Templates für dynamische Konfigurationsdateien.
  • files/: Statische Dateien, die auf das Zielsystem kopiert werden.
  • vars/ und defaults/: Hier können Variablen definiert werden. Variablen in defaults haben die niedrigste Priorität.
  • meta/main.yml: Beschreibt die Metainformationen der Rolle, z. B. Abhängigkeiten.
  • README.md: Eine Beschreibung der Rolle, ihrer Funktionen und der verfügbaren Variablen.

Sobald die Rolle generiert ist, kannst du die relevanten Dateien wie tasks/main.yml und vars/main.yml entsprechend deinem Anwendungsfall anpassen.

Ansible-Rollen nutzen: Integration in Playbooks

Um eine Rolle in einem Playbook zu verwenden, fügst du sie einfach hinzu:

1
2
3
4
- name: Installiere und konfiguriere Jellyfin
  hosts: mediacenter
  roles:
    - jellyfin

Dieses Playbook wendet die Rolle jellyfin auf alle Hosts in der Gruppe mediacenter an. Rollen ermöglichen es dir, komplexe Automatisierungen übersichtlich und modular zu gestalten.

Ansible-Rollen: Best Practices für Erfolg

  • Modularität fördern: Jede Rolle sollte nur für einen spezifischen Dienst oder eine bestimmte Aufgabe zuständig sein.

  • Wiederverwendbarkeit sicherstellen: Definiere Variablen und Templates so, dass sie einfach an verschiedene Umgebungen angepasst werden können.

  • Dokumentation hinzufügen: Erkläre in der README.md der Rolle, was sie macht, welche Variablen verfügbar sind und wie sie verwendet wird.

  • Einfaches Testen einführen: Um Rollen manuell zu testen, kannst du ein Playbook schreiben, das nur die zu testende Rolle auf einem lokalen oder Testsystem ausführt:

    Beispiel:

    1
    2
    3
    4
    
    - name: Teste Jellyfin-Rolle
      hosts: localhost
      roles:
        - jellyfin
    

    Dieses Playbook kann mit folgendem Befehl ausgeführt werden:

    1
    
    ansible-playbook -i localhost, test_playbook.yml
    

    Dies stellt sicher, dass die Rolle in einer kontrollierten Umgebung getestet wird, ohne umfangreiche Setups oder zusätzliche Tools wie Molecule zu erfordern.

Ansible in Aktion: Vorbereitung und praktischer Einsatz

Ein erfolgreicher Einsatz von Ansible beginnt mit einer systematischen Vorbereitung und einer klaren schrittweisen Implementierung. Die kommenden Abschnitte legen den Grundbaustein für eine Hybrid-Cloud-Umgebung, indem wir die wichtigsten Aspekte wie Installation, Konfiguration und das Erstellen von Rollen detailliert erklären. Jeder Schritt ist essenziell, um eine stabile und effiziente Automatisierungsumgebung zu schaffen und die Grundlage für komplexere Automatisierungen in den nächsten Beiträgen zu legen.

Ansible-Projektstruktur: Aufbau und Best Practices

Eine gut organisierte Verzeichnisstruktur erleichtert die Verwaltung deines Ansible-Projekts. In dieser Blogreihe verwenden wir die folgende Struktur, um unsere Hybrid-Cloud zu implementieren und automatisiert zu verwalten. Die dargestellten Rollen werden im Laufe der Blogreihe implementiert und sind hier nur exemplarisch aufgeführt:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
ansible-project/
├── inventory/
│   ├── hosts.yml
├── site.yml
├── roles/
│   ├── docker/
│   ├── caddy/
│   ├── authentik/
│   ├── ssh-tunnel-server/
│   ├── ssh-tunnel-client/
│   ├── services/
│   │   ├── vaultwarden/
│   │   ├── nextcloud/
│   │   ├── homeassistant/
│   │   ├── jellyfin/
│   │   ├── influxdb/
│   │   └── grafana/
└── ansible.cfg
  • inventory/: Enthält die hosts.yml, die alle Zielsysteme und Variablen definiert.
  • site.yml: Die Datei site.yml dient als Haupt-Playbook in Ansible. Sie definiert die Abfolge von Rollen, die auf die jeweiligen Zielsysteme angewendet werden.
  • roles/: Enthält Rollen wie docker, caddy, authentik und diverse Services (z. B. vaultwarden, nextcloud, homeassistant).
  • ansible.cfg: Konfigurationsdatei für projektweite Einstellungen.

Ansible-Inventar: Hosts und Variablen organisieren

Definiere deine Systeme und alle Variablen direkt in einer YAML-basierten Inventardatei. In diesem Beispiel verwenden wir einen Server bei Hetzner, der unter vm1.deinedomain.de erreichbar ist, und Hosts im Homelab, die unter bm1.homelab.local und ähnlichen Namen erreichbar sind.

inventory/hosts.yml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
all:
  vars:
    ansible_user: "myuser"
    ansible_group: "mygroup"
    services_directory: "/opt/services"
    uid: "1000"
    gid: "1000"
    AUTHENTIK_SECRET_KEY: keykeykey

  children:
    cloud:
      hosts:
        vm1.deinedomain.de:
          ansible_python_interpreter: /usr/bin/python3.12
        vm2.deinedomain.de:
          ansible_python_interpreter: /usr/bin/python3.12
    homelab:
      hosts:
        bm1.homelab.local:
          example_variable: "another_example_value"
        bm2.homelab.local:
          example_variable: "another_example_value"

Im Inventar können Variablen flexibel auf verschiedenen Ebenen definiert werden: auf Host-, Gruppen- oder globaler Ebene. Dies erlaubt es, spezifische Konfigurationen für individuelle Hosts, Hostgruppen oder alle Hosts zentral zu verwalten.

  • ansible_user: Gibt den Benutzer für SSH-Verbindungen an, der für die Ausführung der Aufgaben auf den Zielsystemen verwendet wird.
  • ansible_group: (Optional) Definiert die Standardgruppe für Berechtigungen.
  • services_directory: Gibt das Basisverzeichnis an, in dem Dienste und Anwendungen installiert werden.
  • uid und gid: Bestimmen die Benutzer- und Gruppen-IDs, die bei der Konfiguration und Ausführung von Diensten verwendet werden.
  • AUTHENTIK_SECRET_KEY: Platzhalter für einen geheimen Schlüssel, der beispielsweise für die Authentifizierung eines Dienstes wie Authentik benötigt wird.

Diese Variablen ermöglichen eine dynamische und wiederverwendbare Konfiguration in Playbooks und Rollen.

Das Haupt-Playbook: Rollen effizient zuweisen

Die Datei site.yml ist das zentrale Playbook im Ansible-Projekt und steuert die gesamte Automatisierung. Sie definiert, welche Rollen auf welche Gruppen oder Hosts angewendet werden, und organisiert die Aufgaben in einer logischen Reihenfolge. Dadurch wird sichergestellt, dass alle Konfigurationen konsistent ausgeführt werden. Zum Beispiel können Cloud-Hosts zuerst grundlegende Dienste wie Docker installieren, bevor spezifische Anwendungen wie Grafana oder InfluxDB hinzugefügt werden. Das Playbook ermöglicht zudem die einfache Anpassung für unterschiedliche Umgebungen wie Cloud und Homelab, indem es die Rollen für jede Gruppe separat definiert. 

site.yml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
- name: Setup All Systems
  hosts: all
  roles:
    - role: docker

- name: Setup Cloud Systems
  hosts: cloud
  roles:
    - role: caddy
    - role: authentik
    - role: ssh-tunnel-server
    - role: services/influxdb
    - role: services/grafana

- name: Setup Homelab Systems
  hosts: homelab
  roles:
    - role: ssh-tunnel-client
    - role: services/vaultwarden
    - role: services/nextcloud
    - role: services/homeassistant
    - role: services/jellyfin

In diesem Beispiel werden Dienste wie Caddy und Authentik auf dem Cloud-Server bereitgestellt, um einen zentralen und sicheren Zugang zu allen weiteren Services zu ermöglichen. Nextcloud und Home Assistant verbleiben im Homelab, wodurch deren Daten und Funktionalitäten physisch in der privaten Infrastruktur bleiben. Diese Konfiguration kann jedoch flexibel angepasst werden, indem Rollen zwischen den Gruppen verschoben werden, um beispielsweise Nextcloud in der Cloud zu hosten, falls dies für bestimmte Szenarien vorteilhaft ist. 

Ansible-Konfiguration: Einstellungen für das Projekt

Die Datei ansible.cfg ist wichtig, um projektweite Einstellungen zu definieren. Hier ein Beispiel für eine typische Konfigurationsdatei:

ansible.cfg:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
[defaults]
inventory = inventory/hosts.yml
private_key_file = ~/.ssh/id_rsa
host_key_checking = False
retry_files_enabled = False
forks = 10

[privilege_escalation]
become = True
become_method = sudo
become_user = root
  • inventory: Der Pfad zu deiner Inventardatei.
  • private_key_file: Der Pfad zu deinem privaten SSH-Schlüssel.
  • host_key_checking: Deaktiviert die Überprüfung des Host-Schlüssels (optional für Entwicklungsumgebungen).
  • retry_files_enabled: Deaktiviert das Erstellen von Retry-Dateien.
  • forks: Die Anzahl paralleler Verbindungen.
  • Privilege Escalation: Einstellungen für sudo oder ähnliche Methoden, um Aufgaben mit erhöhten Rechten auszuführen.

Rolle erstellen: Docker-Installation mit Ansible

Die Erstellung einer Ansible-Rolle beginnt mit ihrer Initialisierung. Nutze dazu das Kommando ansible-galaxy init, um eine neue Rolle mit allen notwendigen Verzeichnissen und Dateien zu erstellen. Für die Docker-Installation gehen wir wie folgt vor:

1
ansible-galaxy init roles/docker

Dies erstellt die Basisstruktur für die Rolle docker im Verzeichnis roles/.

Aufgaben für die Docker-Installation

Die Datei roles/docker/tasks/main.yml enthält die Hauptaufgaben der Rolle. Diese Aufgaben automatisieren die Installation und Konfiguration von Docker:

roles/docker/tasks/main.yml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
- name: Install and configure Docker
  become: true
  block:
    - name: Update apt and install prerequisites
      apt:
        update_cache: no
        name: ['apt-transport-https', 'ca-certificates', 'curl', 'software-properties-common']
        state: present
    - name: Add Docker GPG key
      apt_key:
        url: https://download.docker.com/linux/ubuntu/gpg
        state: present
    - name: Add Docker repository
      apt_repository:
        repo: deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable
        state: present
    - name: Install Docker and Docker Compose
      apt:
        name: ['docker-ce', 'docker-compose-plugin']
        state: present
    - name: Ensure Docker service is started
      service:
        name: docker
        state: started
        enabled: yes
    - name: Create Docker group
      group:
        name: docker
        state: present
    - name: Add user to Docker group
      user:
        name: "{{ ansible_user }}"
        groups: docker
        append: yes
    - name: Create services directory
      become: true
      file:
        path: "{{ services_directory }}"
        state: directory
        owner: "{{ ansible_user }}"
        group: "{{ ansible_group }}"
        mode: '0755'
  rescue:
    - name: Handle Docker installation failure
      debug:
        msg: "Docker installation failed. Please check your system configuration."

Handler zum Neustarten von Docker

Ein Handler in der Datei roles/docker/handlers/main.yml sorgt dafür, dass der Docker-Dienst bei Änderungen automatisch neu gestartet wird:

roles/docker/handlers/main.yml:

1
2
3
4
- name: Restart Docker
  service:
    name: docker
    state: restarted

Rolle anwenden: Docker auf Hosts installieren

Um die Rolle anzuwenden, füge sie in dein Haupt-Playbook site.yml ein:

site.yml:

1
2
3
4
- name: Setup All Systems
  hosts: all
  roles:
    - role: docker

Ausführung der Rolle

Führe das Playbook aus, um Docker auf den Zielhosts zu installieren:

1
ansible-playbook site.yml

Ausgabe bei erfolgreicher Anwendung

Nach der erfolgreichen Ausführung des Playbooks sollte die folgende Ausgabe im Terminal erscheinen:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
TASK [docker : Install and configure Docker] **********************************
changed: [vm1.deinedomain.de]
changed: [bm1.homelab.local]

TASK [docker : Ensure Docker service is started] *****************************
ok: [vm1.deinedomain.de]
ok: [bm1.homelab.local]

TASK [docker : Create services directory] ************************************
changed: [vm1.deinedomain.de]
changed: [bm1.homelab.local]

PLAY RECAP ********************************************************************
vm1.deinedomain.de         : ok=8   changed=5    unreachable=0    failed=0   
bm1.homelab.local          : ok=8   changed=5    unreachable=0    failed=0   

Diese Ausgabe bestätigt, dass Docker erfolgreich auf den Zielhosts installiert wurde.

Fazit: Vorbereitung abgeschlossen, auf zu Docker

In diesem Beitrag haben wir erfolgreich die Grundlagen von Ansible vermittelt und eine konkrete Rolle entwickelt, um Docker auf unseren Hosts zu installieren. Dabei haben wir die Vorteile von Ansible demonstriert und gezeigt, wie es dir helfen kann, wiederkehrende Aufgaben zu automatisieren und deine Infrastruktur konsistent zu verwalten.

Die Einrichtung von Docker ist ein entscheidender Schritt, da es die Basis für viele moderne Dienste bildet. Mit Docker können wir Dienste effizient containerisieren und sowohl in der Cloud als auch im Homelab flexibel einsetzen.

Im nächsten Beitrag werden wir tiefer in die Möglichkeiten von Docker eintauchen. Wir zeigen, wie du mit Ansible und Docker deine Infrastruktur weiter ausbauen kannst, indem wir containerisierte Anwendungen bereitstellen und verwalten. Freu dich auf spannende Praxisbeispiele und nützliche Tipps, die dein Homelab auf das nächste Level bringen werden!

Erstellt mit Hugo
Theme Stack gestaltet von Jimmy