Ansible Semaphore installieren: Playbooks per Weboberfläche steuern

Docker installieren

#

System aktualisieren

#

apt update && apt upgrade -y && apt install ca-certificates curl -y

Docker-Paketquelle einrichten

#

install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
chmod a+r /etc/apt/keyrings/docker.asc
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian $(. /etc/os-release && echo "$VERSION_CODENAME") stable" > /etc/apt/sources.list.d/docker.list

Docker und Docker Compose installieren

#

apt update && apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

Dockge installieren

#

Dockge einrichten

#

Dockge ist eine Weboberfläche, mit der du Docker-Compose-Stacks bequem im Browser verwaltest. Dieser Befehl legt die Verzeichnisse an und startet Dockge:

mkdir -p /opt/stacks /opt/dockge && cd /opt/dockge && curl -fsSL https://raw.githubusercontent.com/louislam/dockge/master/compose.yaml -o compose.yaml && docker compose up -d

Dockge öffnen

#

Öffne Dockge im Browser und lege direkt dein Admin-Konto an:

http://IP-deines-Servers:5001

Semaphore einrichten

#

Stack anlegen

#

Klicke in Dockge auf + Compose und gib unter „Allgemein“ den Stack-Namen semaphore ein.

compose.yaml einfügen

#

services:
  semaphore-db:
    image: postgres:17
    container_name: semaphore-db
    restart: unless-stopped
    environment:
      POSTGRES_DB: ${DB_NAME}
      POSTGRES_USER: ${DB_USER}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - ./data/postgres:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${DB_USER} -d ${DB_NAME}"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - internal

  semaphore:
    image: semaphoreui/semaphore:latest
    container_name: semaphore
    restart: unless-stopped
    depends_on:
      semaphore-db:
        condition: service_healthy
    ports:
      - 127.0.0.1:3000:3000
    environment:
      SEMAPHORE_DB_DIALECT: postgres
      SEMAPHORE_DB_HOST: semaphore-db
      SEMAPHORE_DB_PORT: 5432
      SEMAPHORE_DB: ${DB_NAME}
      SEMAPHORE_DB_USER: ${DB_USER}
      SEMAPHORE_DB_PASS: ${DB_PASSWORD}
      SEMAPHORE_ADMIN: ${ADMIN_USER}
      SEMAPHORE_ADMIN_NAME: ${ADMIN_NAME}
      SEMAPHORE_ADMIN_EMAIL: ${ADMIN_EMAIL}
      SEMAPHORE_ADMIN_PASSWORD: ${ADMIN_PASSWORD}
      SEMAPHORE_ACCESS_KEY_ENCRYPTION: ${ACCESS_KEY_ENCRYPTION}
      SEMAPHORE_PLAYBOOK_PATH: /tmp/semaphore/
      TZ: Europe/Berlin
    volumes:
      - semaphore-config:/etc/semaphore
    networks:
      - internal
      - default

volumes:
  semaphore-config:

networks:
  internal:

Semaphore ist damit nur auf dem Server selbst erreichbar. Wie du trotzdem darauf zugreifst, steht weiter unten.

Für die Konfiguration nutze ich ein benanntes Volume statt eines normalen Ordners. Semaphore läuft im Container nicht als root, und ein benanntes Volume bekommt automatisch die passenden Rechte. Bei einem normalen Ordner würde Semaphore mit einem Rechtefehler abbrechen.

Umgebungsvariablen in der .env festlegen

#

Trag unten rechts im Feld für die .env diese Werte ein, und zwar ohne Leerzeichen um das Gleichheitszeichen:

DB_NAME=semaphore
DB_USER=semaphore
DB_PASSWORD=dein-datenbank-passwort
ADMIN_USER=admin
ADMIN_NAME=Dein Name
ADMIN_EMAIL=du@deine-domain.de
ADMIN_PASSWORD=dein-sicheres-passwort
ACCESS_KEY_ENCRYPTION=hier-der-schluessel

Der Schlüssel für ACCESS_KEY_ENCRYPTION muss genau 32 Bytes lang und Base64-kodiert sein. So erzeugst du ihn:

head -c32 /dev/urandom | base64

Stack starten

#

Klicke auf Speichern und dann auf Deploy.

Semaphore öffnen

#

Weil Semaphore SSH-Schlüssel zu all deinen Servern speichert, gehört es nicht offen ins Internet. Für den Zugriff baust du von deinem Rechner aus einen SSH-Tunnel auf:

ssh -L 3000:localhost:3000 root@IP-deines-Servers

Solange die Verbindung offen ist, erreichst du Semaphore unter http://localhost:3000. Melde dich mit dem Benutzer und Passwort aus der .env an. Für dauerhaften Zugriff im Team setzt du am besten einen Reverse Proxy mit HTTPS davor, erreichbar nur über VPN.

Erstes Playbook starten

#

In Semaphore baut sich alles aus ein paar Bausteinen auf. Leg sie in dieser Reihenfolge an:

1. Key Store: Hinterlege den privaten SSH-Schlüssel, mit dem sich Semaphore auf deinen Servern anmeldet.
2. Repositories: Trag das Git-Repository ein, in dem deine Playbooks liegen.
3. Inventory: Leg fest, auf welchen Servern das Playbook laufen soll. Du kannst die Liste direkt eingeben, im gleichen Format wie die inventory.ini aus der Ansible-Anleitung.
4. Environment: Leg eine leere Umgebung an. Hier kannst du später Variablen hinterlegen.
5. Task Templates: Verbinde alles zu einer Vorlage, indem du Playbook, Inventory, Repository und Environment auswählst.

Danach startest du das Playbook mit Run und siehst die Ausgabe live im Browser. Unter Schedule kannst du es auch automatisch laufen lassen, zum Beispiel jede Nacht für Updates.

Fehlersuche

#

Startet Semaphore nicht oder ist die Anmeldung nicht möglich, schau in die Logs:

docker logs semaphore --tail 30

Semaphore aktualisieren

#

cd /opt/stacks/semaphore && docker compose pull && docker compose up -d