Aufbau eines Playbooks zur Ausführung von Backups

Ansible ist ein großartiges Werkzeug, um wiederkehrende Aufgaben in der IT-Infrastruktur zu automatisieren. Eine dieser kritischen Aufgaben ist das regelmäßige Erstellen von Backups, um Datenverlust vorzubeugen. Mit Ansible lassen sich Backups einfach automatisieren und über mehrere Server hinweg konsistent ausführen.

In diesem Tutorial zeige ich dir, wie du ein Ansible-Playbook erstellst, das auf deinen Servern regelmäßige Backups ausführt. Dabei sichern wir Verzeichnisse und Dateien in ein Backup-Verzeichnis, das entweder lokal oder auf einem Remote-Server gespeichert wird.

Voraussetzungen

• Grundlegende Kenntnisse in Ansible.
• Ein installiertes Ansible auf deinem lokalen Rechner.
• SSH-Zugang zu den Zielservern.
• Sudo-Rechte auf den Zielservern (falls notwendig).

Ansible Playbook: Struktur und Aufbau

Ein Ansible-Playbook besteht aus einer YAML-Datei, die eine Liste von Tasks (Aufgaben) enthält. Jede Aufgabe beschreibt einen spezifischen Schritt des Backupprozesses, den Ansible auf den Zielsystemen ausführen wird.

Schritt 1: Erstellen des Arbeitsverzeichnisses

Erstelle ein neues Verzeichnis für dein Backup-Playbook:

mkdir -p ~/ansible-playbooks/backup
cd ~/ansible-playbooks/backup

Schritt 2: Anlegen des Playbooks

Erstelle eine neue YAML-Datei für dein Backup-Playbook:

touch backup.yml

Öffne die Datei in deinem bevorzugten Texteditor:

nano backup.yml

Schritt 3: Playbook-Struktur

Hier ist die Grundstruktur eines Playbooks, das ein Backup eines Verzeichnisses auf jedem Server durchführt und in einem spezifischen Verzeichnis speichert.

---
- name: Backup-Playbook für wichtige Verzeichnisse
  hosts: all
  become: yes
  vars:
    backup_src: "/var/www"
    backup_dest: "/backup"
    timestamp: "{{ ansible_date_time.date }}_{{ ansible_date_time.hour }}-{{ ansible_date_time.minute }}"

  tasks:
    - name: Erstelle Backup-Verzeichnis, falls es nicht existiert
      ansible.builtin.file:
        path: "{{ backup_dest }}"
        state: directory
        mode: '0755'

    - name: Komprimiere das Quellverzeichnis
      ansible.builtin.command:
        cmd: "tar -czf {{ backup_dest }}/backup_{{ inventory_hostname }}_{{ timestamp }}.tar.gz {{ backup_src }}"
      args:
        creates: "{{ backup_dest }}/backup_{{ inventory_hostname }}_{{ timestamp }}.tar.gz"

    - name: Prüfe, ob Backup erfolgreich erstellt wurde
      ansible.builtin.stat:
        path: "{{ backup_dest }}/backup_{{ inventory_hostname }}_{{ timestamp }}.tar.gz"
      register: backup_result

    - name: Fehlermeldung anzeigen, wenn Backup fehlgeschlagen ist
      ansible.builtin.fail:
        msg: "Backup fehlgeschlagen auf {{ inventory_hostname }}"
      when: not backup_result.stat.exists

Erklärung der einzelnen Komponenten:

1. hosts: all: Das Playbook wird auf allen in der Inventardatei definierten Hosts ausgeführt. Du kannst diese Angabe anpassen, um das Playbook nur auf bestimmten Servergruppen auszuführen (z. B. webserver).
2. become: yes: Dies ermöglicht Ansible, Befehle mit Root-Rechten (sudo) auszuführen, was für das Erstellen von Backups in geschützten Verzeichnissen erforderlich sein kann.
3. Variablen:
   • backup_src: Das Verzeichnis, das du sichern möchtest. In diesem Beispiel ist es /var/www.
   • backup_dest: Das Verzeichnis, in das das Backup abgelegt wird (z. B. /backup).
   • timestamp: Wir erstellen einen Zeitstempel basierend auf dem aktuellen Datum und der Uhrzeit, um die Backups eindeutig zu benennen.
4. Tasks:
   • file: Dieser Task sorgt dafür, dass das Backup-Zielverzeichnis existiert. Wenn das Verzeichnis noch nicht vorhanden ist, wird es erstellt.
   • command: Hier wird das Quellverzeichnis mit dem tar-Kommando komprimiert und als .tar.gz-Datei im Backup-Verzeichnis gespeichert. Der Dateiname enthält den Hostnamen sowie einen Zeitstempel.
   • stat: Dieser Task prüft, ob die Backup-Datei erfolgreich erstellt wurde.
   • fail: Falls das Backup nicht erfolgreich war, gibt dieser Task eine Fehlermeldung aus und markiert das Playbook als fehlgeschlagen.

Schritt 4: Inventardatei anlegen

Um das Playbook auf deinen Servern auszuführen, musst du eine Inventardatei anlegen. Diese Datei enthält die IP-Adressen oder Hostnamen der Server, die gesichert werden sollen.

Erstelle die Inventardatei hosts:

nano hosts

Trage dort deine Server ein, zum Beispiel:

[webserver]
192.168.1.10
192.168.1.11

[dbserver]
192.168.1.20

Schritt 5: Playbook ausführen

Um das Backup-Playbook auszuführen, verwende den folgenden Befehl:

ansible-playbook -i hosts backup.yml

Dabei:

• -i hosts: Gibt die Inventardatei mit den Servern an, auf denen das Playbook ausgeführt werden soll.
• backup.yml: Der Name des Playbooks.

Ansible verbindet sich nun über SSH mit den Servern, erstellt das Backup des definierten Quellverzeichnisses und speichert es im Zielverzeichnis.

Optional: Remote-Backup mit SCP

Möchtest du das Backup auf einem entfernten Backup-Server speichern, kannst du ansible.builtin.copy verwenden oder mit ansible.builtin.command das scp-Kommando ausführen. Hier ein Beispiel für das Kopieren der Backups auf einen Remote-Server:

- name: Kopiere Backup auf Remote-Server
  ansible.builtin.command:
    cmd: "scp {{ backup_dest }}/backup_{{ inventory_hostname }}_{{ timestamp }}.tar.gz backupuser@remote-server:/remote/backup/path/"

Stelle sicher, dass du SSH-Schlüssel für die Authentifizierung eingerichtet hast, damit der Kopiervorgang ohne Passwortabfrage durchgeführt werden kann.

Fazit

Dieses Ansible-Playbook automatisiert den Prozess der Sicherung wichtiger Verzeichnisse über mehrere Server hinweg. Durch die Verwendung von Variablen und Zeitstempeln kannst du flexibel Backups benennen und verwalten. Zudem lässt sich das Playbook leicht erweitern, etwa um Remote-Backups oder zusätzliche Benachrichtigungen.

Backups sind ein zentraler Bestandteil der IT-Sicherheit, und mit Ansible kannst du sicherstellen, dass diese Aufgabe effizient und zuverlässig ausgeführt wird.

Viel Erfolg beim Einrichten deines automatisierten Backup-Systems!