Provisionierung der Daten

In diesem Tutorial werden wir uns mit der Provisionierung von Daten mit Ansible beschäftigen. Dabei geht es darum, wie wir mithilfe von Ansible Dateien, Datenbanken oder andere Datenquellen automatisiert bereitstellen können, um eine Infrastruktur effizient aufzusetzen.

Was bedeutet Provisionierung von Daten?

Provisionierung bezeichnet den Prozess, bei dem Ressourcen (z.B. Dateien, Datenbanken, Konfigurationsdateien) auf einem Zielsystem bereitgestellt werden. Mit Ansible lässt sich dieser Prozess automatisieren, um die Daten zuverlässig und wiederholbar auf mehreren Servern zu verteilen.

Anwendungsfälle für Daten-Provisionierung:

• Bereitstellung von Konfigurationsdateien (z.B. für Web- oder Datenbankserver).
• Dateien wie Webanwendungen, Binärdateien oder Skripte auf Zielserver kopieren.
• Datenbanken aufsetzen, initialisieren und mit Testdaten befüllen.
• Automatisierte Backups erstellen und auf sichere Ziele verschieben.

Voraussetzungen

Bevor wir beginnen, solltest du sicherstellen, dass du Folgendes auf deinem System installiert hast:

• Ansible: Installiere Ansible auf deinem System, wenn es noch nicht installiert ist:

sudo apt update
sudo apt install ansible -y

• Grundkenntnisse über Ansible und die YAML-Syntax sind hilfreich.
• Zugriff auf die Zielsysteme, auf denen du Daten provisionieren möchtest.

Schritt 1: Ein einfaches Playbook zur Bereitstellung von Dateien

Eine der häufigsten Daten-Provisionierungen ist das Kopieren von Dateien auf Zielserver. Ansible bietet hierfür das Modul copy, das es ermöglicht, Dateien von deinem lokalen System auf entfernte Maschinen zu übertragen.

Erstelle eine Datei namens provision_files.yml mit folgendem Inhalt:

---
- name: Dateien auf Zielserver kopieren
  hosts: webserver
  become: yes

  tasks:
    - name: Konfigurationsdatei kopieren
      copy:
        src: /path/to/local/configfile.conf
        dest: /etc/myapp/configfile.conf
        owner: root
        group: root
        mode: '0644'

    - name: Startskript kopieren
      copy:
        src: /path/to/local/start.sh
        dest: /usr/local/bin/start.sh
        owner: root
        group: root
        mode: '0755'

Erklärung:

• Das copy-Modul kopiert lokale Dateien (src) auf das Zielsystem (dest).
• Die Berechtigungen können mit owner, group und mode festgelegt werden.
• In diesem Fall wird eine Konfigurationsdatei nach /etc/myapp/ kopiert und ein Startskript nach /usr/local/bin/.

Playbook ausführen:

Um das Playbook auszuführen, nutze den folgenden Befehl:

ansible-playbook -i inventory provision_files.yml

Das Playbook wird die Dateien auf alle Hosts kopieren, die im webserver-Hostblock deiner Inventardatei definiert sind.

Schritt 2: Provisionierung einer Datenbank

Ein weiterer wichtiger Aspekt der Daten-Provisionierung ist das Erstellen und Konfigurieren von Datenbanken. Ansible unterstützt verschiedene Datenbanktypen wie MySQL, PostgreSQL und andere.

Beispiel: MySQL-Datenbank erstellen

Im folgenden Playbook verwenden wir das Ansible-MySQL-Modul, um eine Datenbank, einen Benutzer und Tabellen zu erstellen:

Erstelle ein Playbook namens provision_mysql.yml:

---
- name: MySQL-Datenbank bereitstellen
  hosts: dbserver
  become: yes
  tasks:
    - name: MySQL installieren
      apt:
        name: mysql-server
        state: present
        update_cache: yes

    - name: MySQL-Dienst starten
      service:
        name: mysql
        state: started
        enabled: yes

    - name: Neue MySQL-Datenbank erstellen
      mysql_db:
        name: myapp_db
        state: present

    - name: MySQL-Benutzer erstellen
      mysql_user:
        name: myapp_user
        password: "{{ mysql_user_password }}"
        priv: 'myapp_db.*:ALL'
        state: present

    - name: Tabelle in der Datenbank erstellen
      mysql_query:
        login_user: root
        login_password: "{{ mysql_root_password }}"
        query: "CREATE TABLE IF NOT EXISTS myapp_db.users (id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(100));"

Erklärung:

• Wir installieren den MySQL-Server und starten den Dienst.
• Dann erstellen wir eine neue Datenbank (myapp_db) und einen Benutzer (myapp_user).
• Mit dem mysql_query-Modul führen wir eine SQL-Abfrage aus, um eine Tabelle zu erstellen.

Playbook ausführen:

Führe das Playbook mit den benötigten Variablen für das Passwort aus:

ansible-playbook -i inventory provision_mysql.yml --extra-vars "mysql_root_password=meinrootpasswort mysql_user_password=meinuserpasswort"

Anwendungsfall: Datenbank mit Testdaten füllen

Wenn du eine Datenbank initialisieren möchtest, kannst du Ansible nutzen, um Daten automatisch in die Datenbank einzufügen:

Dies fügt Testdaten in die Tabelle ein, die zuvor erstellt wurde.

- name: Testdaten in die Tabelle einfügen
  mysql_query:
    login_user: root
    login_password: "{{ mysql_root_password }}"
    query: "INSERT INTO myapp_db.users (name) VALUES ('Max Mustermann');"

Schritt 3: Datenbackup und -wiederherstellung

Datenprovisionierung umfasst oft auch das Erstellen von Backups und deren Wiederherstellung. Hier ist ein Beispiel für das Erstellen eines MySQL-Backups und das Kopieren des Backups an einen sicheren Ort:

Backup einer MySQL-Datenbank erstellen:

- name: MySQL-Datenbank-Backup erstellen
  hosts: dbserver
  become: yes
  tasks:
    - name: MySQL-Datenbank sichern
      command: "mysqldump -u root -p{{ mysql_root_password }} myapp_db > /tmp/myapp_db_backup.sql"

    - name: Backup-Datei auf Backup-Server kopieren
      copy:
        src: /tmp/myapp_db_backup.sql
        dest: /backup/myapp_db_backup.sql

Dieses Playbook erstellt ein Backup der MySQL-Datenbank und kopiert es auf einen Backup-Server. Natürlich kannst du das Backup auch mit Tools wie rsync oder scp auf einen anderen Server übertragen.

Schritt 4: Automatisierte Wiederherstellung von Backups

Ein weiteres Beispiel ist die automatisierte Wiederherstellung von Datenbanken mithilfe von Ansible. Hier ein einfaches Playbook zur Wiederherstellung eines MySQL-Backups:

- name: MySQL-Datenbank aus Backup wiederherstellen
  hosts: dbserver
  become: yes
  tasks:
    - name: MySQL-Datenbank aus Backup wiederherstellen
      command: "mysql -u root -p{{ mysql_root_password }} myapp_db < /backup/myapp_db_backup.sql"

Dieses Playbook stellt die Datenbank mithilfe der Backup-Datei wieder her.

Fazit

Mit Ansible kannst du den Prozess der Provisionierung von Daten wie das Kopieren von Dateien, das Erstellen und Verwalten von Datenbanken oder das Erstellen von Backups automatisieren. Ansible ermöglicht es dir, die Bereitstellung von Daten zuverlässig und reproduzierbar durchzuführen.

Durch die Verwendung von Modulen wie copy, mysql_db, mysql_user und mysql_query kannst du eine Vielzahl von Aufgaben rund um die Datenprovisionierung einfach in deinen Playbooks abbilden. Mit der Automatisierung dieser Prozesse sparst du nicht nur Zeit, sondern reduzierst auch Fehler und schaffst eine konsistente Umgebung für deine Anwendungen.

Viel Erfolg beim Automatisieren deiner Datenprovisionierung mit Ansible!