Project Phoenyx: Disaster Recovery (Vaultwarden Standby)

Kategorie: Advanced / Sicherheit | Dokumentation

In der IT ist Redundanz keine Option, sondern eine Notwendigkeit. Nachdem wir im vorherigen Artikel die Datenbank-Replikation etabliert haben, widmen wir uns nun der Anwendungsschicht. Ziel ist es, den Passwort-Manager Vaultwarden auf einem zweiten Server (Server 1) so vorzubereiten, dass er im Katastrophenfall innerhalb von Minuten die Arbeit von Server 2 übernehmen kann.

1. Das Konzept: Das Rettungsboot

Stell dir Server 2 als dein Kreuzfahrtschiff vor. Es läuft unter Volllast, bedient alle Anfragen und speichert neue Daten. Server 1 ist das Rettungsboot an der Seite. Es hängt an den Davits (Docker Container gestoppt), ist aber voll ausgerüstet (konfiguriert) und wird ständig gewartet (Datenbank-Replikation).

Server 2 (Master)

Status: LIVE

Traefik + Vaultwarden

MariaDB Master (Write)

➡ Sync ➡

Server 1 (Standby)

Status: SCHLAFEND

Caddy + Vaultwarden (Stopped)

MariaDB Slave (Read-Only)

[Image of High Availability Architecture]

Wir nennen dies "Cold Standby", weil die Anwendung auf Server 1 nicht aktiv läuft (Cold), aber jederzeit gestartet werden kann (Standby). Der Vorteil gegenüber einem "Hot Standby" (beide laufen gleichzeitig) ist die Vermeidung von Datenkonflikten ("Split-Brain") und Ressourcenersparnis.

Warum Caddy statt Traefik auf Server 1?
Im Notfall muss es schnell gehen. Caddy ist ein Webserver, der sich HTTPS-Zertifikate vollautomatisch besorgt, sobald er gestartet wird. Wir sparen uns komplexe Konfigurationen für den "Rettungsanker".

2. Voraussetzungen

3. Installation auf Server 1

Schritt 3.1: Verzeichnisstruktur

Wir legen einen sauberen Ordner für unseren Standby-Dienst an. Hier liegen später alle Konfigurationsdateien.

mkdir -p /opt/docker/vaultwarden_standby/vw-data

Schritt 3.2: Die Umgebungsvariablen (.env)

Erstelle die Datei /opt/docker/vaultwarden_standby/.env. Hier definieren wir die Geheimnisse. Wichtig: Da die Datenbank repliziert wird, müssen Benutzername und Passwort exakt mit denen von Server 2 übereinstimmen.

# --- ALLGEMEINE EINSTELLUNGEN ---
DOMAIN=vault.phoenyx-systems.de

# Admin Token (Identisch zu Server 2, für Notfall-Zugriff)
ADMIN_TOKEN=DeinLangesAdminTokenVonServer2

# --- DATENBANK (Slave Verbindung) ---
DB_USER=vaultwarden_user
DB_PASSWORD=DeinGeheimesDBPasswort
DB_NAME=vaultwarden

# Hostname des MariaDB-Slave Containers
DB_HOST=mariadb_replica

Schritt 3.3: Der Webserver (Caddyfile)

Caddy benötigt nur eine winzige Konfigurationsdatei. Erstelle /opt/docker/vaultwarden_standby/Caddyfile. Caddy übernimmt hier die Rolle, die Traefik auf Server 2 spielt: Er nimmt Anfragen aus dem Internet an (Port 80/443) und leitet sie an Vaultwarden weiter.

{$DOMAIN} {
    log {
        output file /var/log/caddy/access.log
    }

    # Leitet Anfragen an den internen Container weiter
    reverse_proxy vaultwarden-standby:80 {
        header_up X-Real-IP {remote_host}
    }
}

Schritt 3.4: Die Container-Definition (Docker Compose)

Das Herzstück. Erstelle /opt/docker/vaultwarden_standby/docker-compose.yml. Beachte besonders die Einstellung restart: "no" – wir wollen nicht, dass dieser Container versehentlich automatisch startet.

services:
  vaultwarden-standby:
    image: vaultwarden/server:latest
    container_name: vaultwarden_cold
    restart: "no"  # WICHTIG: Startet nicht automatisch!
    env_file: .env
    environment:
      - DOMAIN=https://${DOMAIN}
      - WEBSOCKET_ENABLED=true
      - SIGNUPS_ALLOWED=false
      - ADMIN_TOKEN=${ADMIN_TOKEN}
      # Verbindung zur replizierten Datenbank
      - DATABASE_URL=mysql://${DB_USER}:${DB_PASSWORD}@${DB_HOST}:3306/${DB_NAME}
    volumes:
      # Hier landen die synchronisierten Anhänge (Bilder etc.)
      - ./vw-data:/data
    networks:
      - database_internal
      - caddy_net

  caddy-standby:
    image: caddy:latest
    container_name: caddy_cold
    restart: "no"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - caddy_data:/data
      - caddy_config:/config
    environment:
      - DOMAIN=${DOMAIN}
    networks:
      - caddy_net
    depends_on:
      - vaultwarden-standby

networks:
  database_internal:
    external: true
  caddy_net:
    driver: bridge

volumes:
  caddy_data:
  caddy_config:

4. Synchronisation der Anhänge

Die Datenbank (Passwörter) wird automatisch repliziert. Aber was ist mit Datei-Anhängen oder Icons? Diese liegen als Dateien auf Server 2. Wir müssen sie regelmäßig rüberkopieren.

Erstelle dazu auf Server 2 einen Cronjob oder ein Skript, das via rsync die Daten schiebt:

rsync -avz --delete -e ssh \
    /opt/containers/vaultwarden/vw-data/ \
    [email protected]:/opt/docker/vaultwarden_standby/vw-data/

(Dieser Befehl sollte idealerweise alle paar Stunden laufen).

Notfallplan

5. Der Ernstfall (Disaster Recovery)

Server 2 ist ausgefallen (Hardware-Defekt, RZ-Brand, etc.). Du brauchst jetzt sofort deine Passwörter. Atme tief durch und befolge diese Schritte.

Schritt A: DNS Umschalten

Logge dich bei deinem DNS-Provider (z.B. Cloudflare) ein. Ändere den A-Record für vault.phoenyx-systems.de von der IP des Server 2 auf die IP von Server 1.

Schritt B: Datenbank öffnen

Die Datenbank auf Server 1 ist im "Read-Only"-Modus (Schreibschutz), um Konflikte zu vermeiden. Damit Vaultwarden starten kann, müssen wir diesen Schutz aufheben.

docker exec -it mariadb_replica mariadb -u root -p -e "STOP SLAVE; SET GLOBAL read_only = 0;"

Schritt C: Rettungsboot starten

Fahre die Standby-Container hoch.

cd /opt/docker/vaultwarden_standby
docker compose up -d

Schritt D: Warten

Caddy wird beim Starten bemerken, dass er nun für die Domain zuständig ist und automatisch Zertifikate bei Let's Encrypt anfordern. Dies dauert ca. 30-60 Sekunden. Danach ist dein Passwort-Manager wieder online.

6. Der Rückweg (Failback)

Achtung: Sobald du auf Server 1 arbeitest (neue Passwörter speicherst), sind die Daten auf Server 2 veraltet!

Wenn Server 2 repariert ist, kannst du nicht einfach zurückschalten. Du musst:

  1. Einen frischen Datenbank-Dump von Server 1 erstellen.
  2. Diesen Dump auf Server 2 importieren.
  3. Server 2 wieder als Master starten.
  4. Server 1 stoppen und wieder als Slave (Read-Only) einrichten.