Bisher habe ich meine Serverlandschaft zu Fuß aktuell gehalten und Ansible lediglich für kompliziertere Docker Orchestrierung genutzt. Da ich Docker aber vornehmlich im lokalen Netz einsetze, lag es nahe, die regelmäßige Aktualisierung auch zu delegieren und wenn möglich, gleich zu automatisieren. Natürlich lässt sich das auch mit Ansible allein bewerkstelligen, allerdings ist es übersichtlicher mit einer grafischen Oberfläche und dort kommt Semaphore ins Spiel.

Ich verwende eine virtuelle Maschine mit einem minimalen Ubuntu LTS und aktiviertem SSH um dort die notwendigen Werkzeuge zu installieren. Der Server würde sicher mit 2GB Hauptspeicher auskommen, der Hypervisor erlaubt mir aber mit seinem dynamischen Speichermanagement auch 4GB zuzuweisen und so auch für größere Aufgaben gerüstet zu sein. Ich gehe im weiteren Verlauf davon aus, dass die zu betreuenden Server über SSH erreichbar sind und mit Public Key Authentifizierung ausgestattet sind. Wie das eingerichtet wird habe ich bereits in einem früheren Beitrag ausgeführt.

Installation

Für jede Anwendung gibt es verschiedene Wege der Installation, von denen ich einige ausprobiert habe und die sich in Komplexität, Aktualität und in der Pflege recht stark unterscheiden. Ich versuche das Übersetzen oder direkte Installieren von der Quelle (hier Github) zu vermeiden, da das Einspielen von Fixes gerne vergessen wird. Es steht Dir natürlich frei selbst in den Dokumentationen eine andere Lösung auszuwählen als ich sie hier nachzeichne:

• https://github.com/ansible/ansible
• https://github.com/ansible-semaphore/semaphore

Ansible installiere ich aus dem PPA (welches zu diesem Zweck hinzugefügt werden muss), während Git und Python aus dem Ubuntu Repository ausreichen und Semaphore als Snap Container genutzt wird.

$ sudo apt update
$ sudo apt install software-properties-common
$ sudo add-apt-repository --yes --update ppa:ansible/ansible
$ sudo apt update
$ sudo apt install git ansible python3
$ sudo snap install semaphore

Um einen administrativen Benutzer anzulegen wird letzterer direkt wieder angehalten, der Benutzer angelegt und dann wieder gestartet. Die Parameter für den Benutzer (login, name, email und password) passt Du natürlich deinen Vorlieben an. Weitere Konten lassen sich später in der GUI ergänzen.

$ sudo snap stop semaphore

$ sudo semaphore user add --admin \
--login johndoe \
--name=JohnDoe \
--email=johndoe@gmail.com \
--password=12345

$ sudo snap start semaphore

Damit ist die Installation bereits abgeschlossen und Semaphore mit einem Browser erreichbar unter http://<name oder IP deines Semaphore Servers>:3000 und du kannst dich mit dem eben erstellten Konto anmelden. Stelle die Oberfläche ggf. auf Dark Mode und erstelle das erste Projekt (meines heißt Linux Server Updates). Es muss lediglich ein Projektname vergeben werden.

Repository anlegen

Die Playbooks (mindestens eines je Projekt) werden aus einem Git Repository zur Laufzeit als Tasktemplates geladen. Ich habe zu diesem Zweck ein privates Repository auf Github mit dem Namen semaphore erstellt (lass ruhig gleich eine README.md Datei erzeugen und wähle eine für dich passende Lizenz). Anschließend sollte ein SSH Schlüsselpaar generiert und am besten gleich im Benutzerprofil, im Verzeichnis .ssh gespeichert werden.

PS>  ssh-keygen -C "username@hostname" -f C:\Users\username\.ssh\github.ed25519 -t ed25519

username@hostname ist lediglich ein Kommentar ( -C ), der aber später bei der Zuordnung helfen kann. Verwende den Anmeldenamen des Servers und dessen Hostnamen. Die zu erstellende Schlüsseldatei wird im Parameter -f übergeben, wobei username dein Windows Benutzer ist. Zwar kann der Dateiname frei gewählt werden, ich empfehle aber ihn zur besseren Erkennbarkeit sprechend zum Verwendungzweck zu erstellen, denn dort werden sich einige solcher Schlüssel sammeln. Mit dem Parameter -t wird letzlich dann die zu nutzende Verschlüsselungsart übergeben. Ist der Befehl abgearbeitet findest du zwei Schlüssel in dem Verzeichnis C:\Users\username.ssh. In github.ed25519 befindet sich der private Schlüssel und in github.ed25519.pub der öffentliche Schlüssel. Letzteren hinterlegst du dann in deinem Github Profil unter SSH and GPG Keys und berechtigst ihn für dein Repository.

Jetzt wird noch das erste Ansible Playbook im Repository erstellt. Ich habe das Playbook apt_updates.yml genannt und es bekommt folgenden Inhalt.

---
- name: Update packeges via apt
  hosts: all  
  become: true
  become_method: sudo
  become_user: root
  gather_facts: true

  tasks:
    - name: Update package cache
      apt:
        update_cache: yes

    - name: Upgrade packages
      apt:
        upgrade: dist
        autoclean: yes

Ich spare mir an dieser Stelle weitere Erläuterungen zur Ansible-Syntax, da es sich hier um ein recht einfaches Beispiel handelt und verweise auf die umfangreiche Dokumentation.

Das Semaphore Projekt „Linux Server Updates„

Key Store

Der Key Store enthält Anmeldeobjekte, also Name/Passwort Paare oder IDs mit privaten Schlüsseln. Der Name des Eintrages ist frei wählbar, ich würde aber dringend anraten den Verwendungszweck dort deutlich zu machen. Bei mir heißt der Git Semaphore Key neben dem Hoster (Github) und dem Namen des Repository (semaphore) noch die Info, dass es um einen Schlüssel geht. Wenn sich erst ein paar Projekte angesammelt haben, ist das außerordentlich hilfreich bei der Auswahl innerhalb des Templates. Als Username kannst Du Deine Github ID verwenden, das ist aber optional und kann auch leer gelassen werden. Im Feld Private Key legst Du den Inhalt der Datei C:\Users\username.ssh\github.ed25519 ab, die Du zuvor angelegt hattest.

Auf die Art kannst Du auch gleich noch die SSH Schlüssel und Username/Passwort Paare (Benutzer muss sudo Rechte haben) für Deine Server hinterlegen.

Repositories

Der Eintrag in Semaphore für das Repository ergibt sich dann fast von selbst. Den Namen wieder sprechend vergeben, dann die URL die Github zu Deinem Repository unter SSH anzeigt. Die ergibt sich aus der Schnittstelle (git), der Domain, Deiner Github UserID, dem Namen des Repositories und wird mit der Erweiterung .git abgeschlossen (s.u.). Anschließend noch den Branch auswählen (üblicherweise main) und den eben erstellten Eintrag aus dem Key Store.

Inventory

Im Inventar werden die Maschinen gespeichert, die Ansible bedienen soll. Dazu stellst Du zunächst den Type auf Static, wählst dann unter Sudo Credentials die Username/Passwort Kombination aus dem Keystore mit sudo Berechtigung für diese Servergruppe und unter User Credentials die SSH Username/Key Kombination aus. Letzteres kann auch mit Username/Passwort passieren, davon kann ich aber grundsätzlich nur abraten. Das funktioniert natürlich für eine Gruppe von Maschinen nur solange die auch die selben Nutzer/Passwort/Key Kombinationen eingerichtet haben - sonst wird jede Maschine ein eigenes Inventory benötigen!

Jetzt nur noch die Liste der Maschinen erstellen (Enter Inventory...) wie er im Beispielbild unten als Info zu sehen ist. Der Name der Gruppe kann frei vergeben werden, muss lediglich in eckigen Klammern ([]) stehen. Die Maschinen bekommen alle eine eigene Zeile und können mit IP Adresse oder vollständigem DNS Namen (mit Domain) eigetragen werden.

Variable Groups

Für dieses Projekt benötigen wir keine, ohne solch einen Eintrag lässt sich aber kein Template erstellen. Daher erstellen wir eine leere Gruppe und nennen sie default.

Task Templates

Diese Vorlage beschreibt den eigentlichen Arbeitsauftrag für Ansible. Ich habe als Beispiel meine LAN Server (Raspis und VMs) ausgewählt. Name und Beschreibung sind frei wählbar, Inventory, Repository und Variable Group auswählen, den Dateinamen des Playbook (apt_updates.yml) in Path to Playbook file eintragen und speichern.

An dem Punkt ist der Task bereits ausführbar. Klicke ihn an und in der darauf erscheinenden Seite findest Du (rechts oben) eine Schaltfläche run. Mit dem Bleistift rechts daneben kann der Task auch bearbeitet werden. Semaphore aktualisiert nicht gerade zügig die Rückmeldungen von Ansible, bleib geduldig bis das Ergebnis erscheint, dass Du später dann über die Task ID wieder aufrufen kannst, was bei der Fehlersuche unumgänglich ist. Bei mir ist es gerne mal ein Raspberry Pi der zu beschäftigt oder nicht im DNS zu finden ist, was aber dann schnell nachvollzogen werden kann

Schedule

Als letzte Aufgabe fehlt nur noch die automatische, regelmäßige Durchführung des ganzen und zu diesem Zweck bietet uns Semaphore die Zeitpläne. Es ist das Template und das Timing auszuwählen sowie der Plan zu aktivieren. Im Beispielbild wird die Vorlage jeden Tag um 3:00 Uhr morgens ausgeführt.

Im Fediverse kann mitdiskutiert und Fragen beantwortet werden.