Automatisierung der VPS-Einrichtung mit Ansible: Inventar und erstes Playbook

Einführung

Ansible ist ein Open-Source-Automatisierungstool, das für Konfigurationsmanagement, Anwendungsbereitstellung und Infrastrukturprovisionierung verwendet wird. Es verbindet sich über SSH mit Servern und erfordert keine Agenteninstallation auf entfernten Maschinen, was es einfach und sicher in der Anwendung macht. Häufige Anwendungsfälle sind die Automatisierung der Servereinrichtung, das Konsistenthalten von Konfigurationen und die Bereitstellung von Anwendungen auf mehreren Systemen gleichzeitig.

In diesem Tutorial richten Sie Ansible auf Ihrem lokalen Rechner ein und verwenden es, um die Konfiguration mehrerer VPS-Instanzen zu automatisieren. Anstatt jeden Server manuell zu konfigurieren, definieren Sie Aufgaben einmal und wenden sie überall an. Sie erstellen ein Inventar, schreiben Ihr erstes Playbook und stellen einen funktionierenden Webanwendungs-Stack bereit.

Verständnis der Ansible-Kernkonzepte

Sie schreiben kein Skript, das Befehle nacheinander ausführt. Sie beschreiben, wie Ihre Server nach Abschluss des Playbooks aussehen sollen.

In diesem Tutorial verwenden Sie nur einige wenige Kernkomponenten. Die Inventardatei definiert Ihre VPS-Server und wie Ansible sich mit ihnen verbindet. Im Playbook beschreiben Sie den gewünschten Zustand Ihrer Server. Innerhalb des Playbooks definieren Aufgaben einzelne Teile dieses gewünschten Zustands, wie installierte Pakete, laufende Dienste oder Konfigurationsdateien.

Das wichtigste Konzept hier ist die Deklarativität. Anstatt genaue Befehle zu schreiben, wie Sie es in einem Shell-Skript tun würden, beschreiben Sie das gewünschte Ergebnis. Zum Beispiel sagen Sie Ansible nicht, dass es einen Befehl zum Installieren von Nginx ausführen soll. Sie definieren, dass Nginx installiert sein muss. Sie sagen ihm nicht, dass es einen Dienst manuell starten soll. Sie definieren, dass der Dienst laufen und aktiviert sein muss. Ansible entscheidet dann, welche Aktionen erforderlich sind, um diesen Zustand zu erreichen.

Dies unterscheidet sich von einem traditionellen Ansatz, bei dem Sie Befehle manuell in einer bestimmten Reihenfolge ausführen würden. In solchen Skripten müssen Sie jede mögliche Situation selbst handhaben. Mit Ansible ist die Logik in die von Ihnen verwendeten Module integriert, wie Paketverwaltung, Dienststeuerung, Dateiverwaltung und HTTP-Überprüfungen.

Ein weiteres Schlüsselkonzept ist die Idempotenz. Das bedeutet, dass das mehrfache Ausführen desselben Playbooks keine unnötigen Änderungen verursacht. Wenn das System bereits dem gewünschten Zustand entspricht, lässt Ansible es unverändert. Zum Beispiel, wenn Nginx bereits installiert ist, wird es nicht erneut installiert. Wenn eine Konfigurationsdatei bereits dem entspricht, was Sie definiert haben, wird sie nicht neu geschrieben.

Aufgrund der Deklarativität und Idempotenz können Sie das Playbook sicher mehrmals ausführen. Beim ersten Durchlauf installiert und konfiguriert Ansible alles. Bei nachfolgenden Starts überprüft es nur den Systemzustand und ändert ihn bei Bedarf.

Voraussetzungen

• Zielgruppe: Anfänger-Systemadministratoren
• Geschätzte Zeit: ~40–60 Minuten
• Betriebssystem: Debian 13 auf lokalem PC und allen VPS-Knoten
• VPS-Knoten:
  • ans0: 192.168.10.10
  • ans1: 192.168.10.11
  • ans2: 192.168.10.12
• Zugang:
  • SSH-Zugang zu allen VPS-Instanzen
  • Ein Benutzer mit Sudo-Rechten auf jedem VPS
• Netzwerk:
  • Port 22 offen für SSH
  • Port 80 offen für HTTP
• Lokaler Rechner:
  • Python 3 installiert
  • Internetzugang
• Endziel: Am Ende dieses Tutorials konfigurieren Sie mehrere VPS-Server automatisch, installieren Nginx, stellen PocketBase bereit und machen es über einen Webserver zugänglich.

Schritt 1: Ansible auf lokalem Rechner installieren

Ansible läuft auf Ihrem lokalen Rechner und verbindet sich mit entfernten Servern. Sie installieren es nur einmal.

Aktualisieren Sie die Paketlisten:

sudo apt update

Ansible installieren:

sudo apt install ansible -y

Installation überprüfen:

ansible --version

Erwartetes Ergebnis: Sie sehen Versionsinformationen. Dies bestätigt, dass Ansible installiert und einsatzbereit ist.

Schritt 2: SSH-Zugang vorbereiten

Ansible verwendet SSH, um sich mit Servern zu verbinden. Um zu vermeiden, jedes Mal Passwörter einzugeben, verwenden Sie SSH-Schlüssel.

SSH-Schlüssel generieren:

ssh-keygen

Drücken Sie Enter, um die Standardwerte zu akzeptieren. Dies erstellt ein Schlüsselpaar:

• Privater Schlüssel bleibt auf Ihrem PC
• Öffentlicher Schlüssel wird auf die Server kopiert

Schlüssel auf VPS kopieren:

ssh-copy-id <YOUR_USERNAME>@192.168.10.10

ssh-copy-id <YOUR_USERNAME>@192.168.10.11

ssh-copy-id <YOUR_USERNAME>@192.168.10.12

Zugang testen:

ssh <YOUR_USERNAME>@192.168.10.10

Erwartetes Ergebnis: Sie melden sich an, ohne ein Passwort einzugeben.

Schritt 3: Ansible-Projekt und Inventar erstellen

Ansible verwendet eine Inventardatei, um zu wissen, welche Server verwaltet werden sollen.

Projektverzeichnis erstellen:

mkdir ~/ansible-vps

cd ~/ansible-vps

Inventardatei erstellen:

nano inventory.ini

Fügen Sie den folgenden Inhalt in die Inventardatei ein:

[vps]
ans0 ansible_host=192.168.10.10
ans1 ansible_host=192.168.10.11
ans2 ansible_host=192.168.10.12
[vps:vars]
ansible_user=<YOUR_USERNAME>
ansible_python_interpreter=/usr/bin/python3

Erklärung:

• [vps] ist ein Gruppenname
• ans0, ans1, ans2 sind logische Namen
• ansible_host definiert reale IP-Adressen
• ansible_user sagt Ansible, mit welchem Benutzer es sich anmelden soll

Konnektivität testen:

ansible -i inventory.ini vps -m ping

Erwartetes Ergebnis: Jeder Server gibt "pong" zurück.

Schritt 4: Ihr erstes Playbook erstellen

Ein Playbook ist eine Datei, in der Sie Aufgaben beschreiben, die Sie auf Servern ausführen möchten.

Datei erstellen:

nano playbook.yml

Fügen Sie den folgenden Inhalt in die Playbook-Datei ein:

- name: Configure VPS nodes
  hosts: vps
  become: true
  tasks:
    - name: Test connectivity
      ping:
    - name: Update apt cache
      apt:
        update_cache: yes
    - name: Upgrade packages
      apt:
        upgrade: dist
    - name: Install Nginx
      apt:
        name: nginx
        state: present
    - name: Ensure Nginx is running
      service:
        name: nginx
        state: started
        enabled: true
    - name: Test HTTP connectivity
      uri:
        url: http://127.0.0.1/
        return_content: no
    - name: Create directory for PocketBase
      file:
        path: /opt/pocketbase/pb_public
        state: directory
    - name: Install unzip
      apt:
        name: unzip
        state: present
    - name: Download PocketBase
      get_url:
        url: https://github.com/pocketbase/pocketbase/releases/download/v0.36.7/pocketbase_0.36.7_linux_amd64.zip
        dest: /opt/pocketbase/pocketbase.zip
    - name: Unpack PocketBase
      unarchive:
        src: /opt/pocketbase/pocketbase.zip
        dest: /opt/pocketbase/
        remote_src: yes
    - name: Create Pocketbase index.html
      copy:
        dest: /opt/pocketbase/pb_public/index.html
        content: |
          <h1>Pocketbase</h1>
    - name: Create systemd service
      copy:
        dest: /etc/systemd/system/pocketbase.service
        content: |
          [Unit]
          Description=PocketBase Service
          After=network.target
          [Service]
          Type=simple
          ExecStart=/opt/pocketbase/pocketbase serve --http=127.0.0.1:8090
          Restart=always
          [Install]
          WantedBy=multi-user.target
    - name: Reload systemd
      command: systemctl daemon-reexec
    - name: Enable and start PocketBase
      service:
        name: pocketbase
        enabled: true
        state: started
    - name: Configure Nginx site
      copy:
        dest: /etc/nginx/sites-available/pocketbase
        content: |
          server {
              listen 80;
              server_name _;
              location / {
                  proxy_pass http://127.0.0.1:8090;
                  proxy_set_header Host $host;
                  proxy_set_header X-Real-IP $remote_addr;
              }
          }
    - name: Enable Nginx site
      file:
        src: /etc/nginx/sites-available/pocketbase
        dest: /etc/nginx/sites-enabled/pocketbase
        state: link
    - name: Remove default site
      file:
        path: /etc/nginx/sites-enabled/default
        state: absent
    - name: Restart Nginx
      service:
        name: nginx
        state: restarted
    - name: Check PocketBase availability
      uri:
        url: http://127.0.0.1:8090/_/
        return_content: no

Erklärung:

• hosts: vps bedeutet alle Server in der Gruppe
• become: true führt Aufgaben mit erhöhten Rechten aus
• Jede Aufgabe beschreibt eine Aktion
• Module wie apt, service, file sind in Ansible integriert

Schritt 5: Playbook ausführen

ansible-playbook -i inventory.ini playbook.yml

Erwartetes Ergebnis: Aufgaben werden auf allen Knoten ohne Fehler ausgeführt.

Verifizierung

Webserver überprüfen:

curl http://192.168.10.10/

Erwartetes Ergebnis: HTTP-Antwort wird zurückgegeben.

Im Browser öffnen: http://192.168.10.10/_/

Erwartetes Ergebnis: PocketBase-Oberfläche wird geladen.

Für andere Knoten wiederholen.

Änderungen rückgängig machen

sudo systemctl stop pocketbase

sudo systemctl disable pocketbase

sudo rm /etc/systemd/system/pocketbase.service

sudo rm -rf /opt/pocketbase

sudo apt remove nginx unzip -y

Systemd neu laden:

sudo systemctl daemon-reload

Fehlerbehebung

• SSH schlägt fehl: Schlüssel und Benutzer überprüfen
• Ansible-Ping schlägt fehl: Netzwerkverbindung zwischen Hosts sicherstellen
• Nginx-Probleme: systemctl status nginx
• PocketBase-Probleme: journalctl -u pocketbase

Fazit

Sie haben das Ansible-Automatisierungstool installiert, ein Inventar erstellt und Ihr erstes Playbook geschrieben. Sie haben die Bereitstellung von Nginx und PocketBase auf mehreren Servern automatisiert.

Nächste Schritte:

• Verwenden Sie Rollen für eine bessere Struktur
• Fügen Sie Variablen und Vorlagen hinzu
• HTTPS konfigurieren