So installierst du Vaultwarden mit Docker unter Ubuntu 22.04

Vaultwarden ist eine inoffizielle Portierung des Bitwarden-Servers, die in der Sprache Rust geschrieben wurde. Er ist kompatibel mit den offiziellen Bitwarden-Clients und weniger ressourcenintensiv als Bitwarden. Er implementiert fast alle Funktionen von Bitwarden, bis auf ein paar wenige. Es nutzt die Bitwarden-API, um Funktionen wie Organisationsunterstützung, Anhänge, Authentifikator, U2F, Yubikey, Duo-Unterstützung und Unterstützung für E-Mail-Aliasdienste bereitzustellen.

In diesem Tutorial erfährst du, wie du deine Kopie von Vaultwarden auf einem Ubuntu 22.04 Server einrichtest.

Voraussetzungen

  • Ein Server, auf dem Ubuntu 22.04 läuft.
  • Ein Nicht-Root-Benutzer mit sudo-Rechten.
  • Die Unkomplizierte Firewall (UFW) ist aktiviert und läuft.
  • Ein Fully Qualified Domain Name (FQDN), der auf den Server zeigt, z.B. vaultwarden.example.com.
  • Alles ist auf dem neuesten Stand.
    $ sudo apt update && sudo apt upgrade
    

Schritt 1 – Firewall konfigurieren

Bevor du die Pakete installierst, musst du zunächst die Firewall so konfigurieren, dass HTTP- und HTTPS-Verbindungen zugelassen werden.

Überprüfe den Status der Firewall.

$ sudo ufw status

Du solltest etwas wie das Folgende sehen.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)

Erlaube HTTP- und HTTPs-Ports.

$ sudo ufw allow http
$ sudo ufw allow https

Überprüfe den Status zur Bestätigung noch einmal.

$ sudo ufw status
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

Schritt 2 – Installiere Docker und Docker Compose

Füge den offiziellen GPG-Schlüssel von Docker hinzu.

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg

Führe den folgenden Befehl aus, um das Docker-Repository hinzuzufügen.

$ echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Aktualisiere das System, um das Docker-Repository aufzunehmen.

$ sudo apt update

Installiere Docker.

$ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin

In diesem Lehrgang wird das Docker Compose v2 Plugin anstelle des älteren Legacy Binary verwendet. Daher hat sich der Befehl zum Ausführen von docker-compose zu docker compose geändert, was sich hier widerspiegelt.

Docker läuft mit erhöhten Rechten, daher musst du sudo häufig verwenden, um Befehle auszuführen. Die bessere Option ist, dein Linux-Benutzerkonto zur Benutzergruppe docker hinzuzufügen.

$ sudo usermod -aG docker ${USER}

Die Variable ${USER} nimmt das aktuell eingeloggte Systemkonto auf. Wenn du nicht mit dem Benutzer eingeloggt bist, dem du Privilegien geben willst, ersetze ${USER} durch den Benutzernamen.

Um die neue Gruppenmitgliedschaft zu beantragen, melde dich vom Server ab und wieder an oder verwende den folgenden Befehl. Du wirst aufgefordert, das Passwort des Benutzers einzugeben.

$ su - ${USER}

Schritt 3 – Docker Compose-Datei für Vaultwarden erstellen

Erstelle ein neues Verzeichnis für Vaultwarden.

$ mkdir vaultwarden

Wechsle in dieses Verzeichnis.

$ cd vaultwarden

Erstelle die Docker Compose-Datei und öffne sie zur Bearbeitung.

$ nano docker-compose.yml

Füge den folgenden Code in die Datei ein. Ersetze die Variablen DOMAIN und EMAIL durch die entsprechenden Werte.

version: '3'

services:
  vaultwarden:
    image: vaultwarden/server:latest
    container_name: vaultwarden
    restart: always
    environment:
      WEBSOCKET_ENABLED: "true"  # Enable WebSocket notifications.
      DOMAIN: "https://vaultwarden.example.com"
      SMTP_HOST: "<smtp.domain.tld>"
      SMTP_FROM: "<[email protected]>"
      SMTP_PORT: "587"
      SMTP_SECURITY: "starttls"
      SMTP_USERNAME: "<username>"
      SMTP_PASSWORD: "<password>"
    volumes:
      - ./vw-data:/data

  caddy:
    image: caddy:2
    container_name: caddy
    restart: always
    ports:
      - 80:80  # Needed for the ACME HTTP-01 challenge.
      - 443:443
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile:ro
      - ./caddy-config:/config
      - ./caddy-data:/data
    environment:
      DOMAIN: "https://vaultwarden.example.com"  # Your domain.
      EMAIL: "[email protected]"                 # The email address to use for ACME registration.
      LOG_FILE: "/data/access.log"

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Wir richten Vaultwarden und den Caddy-Webserver in einer einzigen Docker-Compose-Datei ein. Werfen wir einen Blick auf alle Optionen, die in der Datei definiert sind.

  • image verweist auf den Speicherort der Docker-Images von Vaultwarden und Caddy auf Dockerhub.
  • container_name ermöglicht es dir, deinem Docker-Container ein Label zuzuweisen, das du verwenden kannst, wenn du den Container in einem Docker-Netzwerk referenzierst.
  • restart legt eine Neustart-Richtlinie für den Container fest. Die Einstellung “ always“ bedeutet, dass ein Container automatisch neu gestartet wird, wenn er verlassen wird.
  • Der Abschnittenvironment setzt die Variablen, die Vaultwarden und Caddy benötigen. Wenn der SMTP-Port deines Dienstes 587 ist, setze den Wert der Variable SMTP_SECURITY auf starttls und wenn der SMTP-Port deines Dienstes 465 ist, setze den Wert der Variable SMTP_SECURITY auf force_tls. Die Domain-Variable ist notwendig, damit die E-Mail-Verifizierung funktioniert. Wir haben Web Sockets aktiviert, damit die Benachrichtigungen funktionieren.
  • volume definiert die Verzeichnisse, die auf dem Server vorhanden sind, um persistente Daten zu speichern. Das Verzeichnis /vw-data auf dem Server wird dem Verzeichnis /data im Container zugeordnet, in dem alle Daten gespeichert werden, die Vaultwarden benötigt. Auf die gleiche Weise werden der Speicherort der Caddy-Datei, die Caddy-Konfiguration und die Caddy-Daten den entsprechenden Verzeichnissen im Container zugeordnet. Docker erstellt automatisch die entsprechenden Verzeichnisse auf dem Server, der im Abschnitt Volume konfiguriert wurde.
  • Ports weisen den Container an, Ports oder eine Reihe von Ports auf dem Host zu veröffentlichen.

Schritt 4 – Zusätzliche Vaultwarden-Konfiguration

Deaktivieren der Registrierung

Wenn du nicht möchtest, dass deine Vaultwarden-Installation für Benutzerregistrierungen offen ist, kannst du sie deaktivieren, indem du die folgende Variable unter dem Abschnitt environment der Docker-Kompositionsdatei hinzufügst.

environment:
     WEBSOCKET_ENABLED: "true"  # Enable WebSocket notifications.
	 SIGNUPS_ALLOWED: "false"
	 ....

Einladungen deaktivieren

Auch nach der Deaktivierung der Benutzerregistrierung kann ein bestehender Benutzer, der Teil einer Organisation ist, immer noch neue Benutzer einladen. Um dies zu verhindern, füge die folgende Variable hinzu.

INVITATIONS_ALLOWED: "false"

Passwort-Hinweise deaktivieren

Vaultwarden sendet Passwort-Hinweise per E-Mail und zeigt sie auch auf der Passwort-Hinweis-Seite an. Um diese Funktion zu deaktivieren, setze den Wert der Variable SHOW_PASSWORD_HINT.

SHOW_PASSWORD_HINT: "false"

Admin-Panel deaktivieren

Vaultwarden hostet statische Dateien für sein Webinterface. Du kannst dies deaktivieren, indem du die folgende Variable auf false setzt.

WEB_VAULT_ENABLED: "false"

Du kannst die Vault-Dateien außer Kraft setzen, indem du deine statischen Dateien in der Konfiguration unter volumes in der Compose-Datei bereitstellst.

volumes:
      - ./vw-data:/data
	  - /path/to/static/files_directory:/web-vault

Vaultwarden Log

Vaultwarden protokolliert nur auf der Standardausgabe. Du kannst ihn so konfigurieren, dass er in eine Datei protokolliert.

LOG_FILE: "/data/vaultwarden.log"

Um die Anzahl der Logmeldungen zu reduzieren, kannst du den Log-Level auf warn setzen und gleichzeitig die Variable EXTENDED_LOGGING auf true setzen.

LOG_LEVEL: "warn"
EXTENDED_LOGGING: "true"

Schritt 5 – Caddy-Datei für Vaultwarden erstellen

Nachdem wir nun Vaultwarden konfiguriert haben, erstellen wir eine Caddy-Datei für Vaultwarden und öffnen sie zur Bearbeitung.

$ nano Caddyfile

Füge den folgenden Code in die Datei ein.

{$DOMAIN}:443 {
  log {
    level INFO
    output file {$LOG_FILE} {
      roll_size 10MB
      roll_keep 10
    }
  }

  # Use the ACME HTTP-01 challenge to get a cert for the configured domain.
  tls {$EMAIL}

  # This setting may have compatibility issues with some browsers
  # (e.g., attachment downloading on Firefox). Try disabling this
  # if you encounter issues.
  encode gzip

  # The file size is set to 500MB to support the Vaultwarden (Bitwarden) Send feature.
  request_body {
       max_size 500MB
  }
  
  header {
       # Enable cross-site filter (XSS) and tell browser to block detected attacks
       X-XSS-Protection "1; mode=block"
       # Disallow the site to be rendered within a frame (clickjacking protection)
       X-Frame-Options "DENY"
       # Prevent search engines from indexing (optional)
       X-Robots-Tag "none"
       # Server name removing
       -Server
  }

  # Notifications redirected to the WebSocket server
  reverse_proxy /notifications/hub vaultwarden:3012

  # Proxy everything else to Rocket
  reverse_proxy vaultwarden:80 {
       # Send the true remote IP to Rocket, so that vaultwarden can put this in the
       # log, so that fail2ban can ban the correct IP.
       header_up X-Real-IP {remote_host}
  }
}

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Schritt 6 – Vaultwarden starten

Starte den Vaultwarden-Docker-Container.

$ docker compose up -d

Du kannst den Status des Containers mit dem folgenden Befehl überprüfen.

$ docker ps

Du wirst eine ähnliche Ausgabe erhalten.

CONTAINER ID   IMAGE                       COMMAND                  CREATED              STATUS                        PORTS                                                                                NAMES
4ad23954f1d5   caddy:2                     "caddy run --config …"   About a minute ago   Up About a minute             0.0.0.0:80->80/tcp, :::80->80/tcp, 0.0.0.0:443->443/tcp, :::443->443/tcp, 2019/tcp   caddy
d55a037850bc   vaultwarden/server:latest   "/usr/bin/dumb-init …"   About a minute ago   Up About a minute (healthy)   80/tcp, 3012/tcp                                                                     vaultwarden

Schritt 7 – Vaultwarden mit Bitwarden Clients verwenden

Öffne die URL https://vaultwarden.example.com in deinem Browser.

Vaultwarden Login Seite

Der erste Schritt besteht darin, ein Konto zu erstellen. Klicke auf die Schaltfläche Konto erstellen, um fortzufahren.

Vaultwarden Konto erstellen Seite

Gib deine Kontodaten ein und klicke auf die Schaltfläche Absenden, um fortzufahren. Du wirst auf die Anmeldeseite weitergeleitet. Gib deine Kontodaten ein, um dich anzumelden.

Vaultwarden Dashboard

Du musst alle Funktionen deines Kontos freischalten, indem du deine E-Mail verifizierst. Klicke auf die Schaltfläche E-Mail senden, um die Verifizierungsmail zu senden.

Du erhältst die folgende E-Mail. Klicke auf den Link, um deine E-Mail-Adresse zu verifizieren.

Vaultwarden Verification Email

Jetzt, wo wir unser Vaultwarden-Konto eingerichtet haben, ist es an der Zeit, es mit einem Bitwarden-Client zu nutzen. Für unser Tutorial verwenden wir die Chrome-Erweiterung. Installiere sie, indem du sie von der Website von Bitwarden herunterlädst.

Klicke auf das Symbol der Erweiterung, um den Anmeldebildschirm von Vaultwarden aufzurufen.

Bitwarden Chrome Extension Login Page

Klicke auf das Zahnrad-Symbol oben links im Popup, um die Seite mit den erweiterten Einstellungen aufzurufen. Gib https://vaultwarden.example.com als Server-URL ein.

Bitwarden Login Einstellungen Bildschirm

Klicke auf die Schaltfläche Speichern, um die Einstellung zu übernehmen. Melde dich mit deinen Vaultwarden-Zugangsdaten an, um dich in der App anzumelden.

Bitwarden Login Seite

Sobald du eingeloggt bist, gelangst du zur App-Seite und kannst Bitwarden nutzen.

Bildschirm der Bitwarden App

Schritt 8 – Vaultwarden sichern

Vaultwarden speichert seine Daten in einer SQLite-Datenbank. Eine Möglichkeit ist, einfach die Datei .sqlite3 aus dem Ordner /vw-data zu kopieren. Das ist aber nicht die empfohlene Lösung, da die Datenbank durch den Betrieb von Vaultwarden nicht in einem konsistenten Zustand ist. Um ein zuverlässiges Backup zu erstellen, werden wir den SQLite-Backup-Befehl verwenden.

Installiere das Paket sqlite3.

$ sudo apt install sqlite3

Erstelle ein Verzeichnis für die Backups.

$ mkdir ~/vw-backups

Entferne die Lese-, Schreib- und Ausführungsrechte von der Gruppe und anderen Benutzern.

$ chmod go-rwx ~/vw-backups

Erstelle die Dienstdatei Vaultwarden backups und öffne sie zur Bearbeitung.

$ sudo nano /etc/systemd/system/vaultwarden-backup.service

Füge den folgenden Code in die Datei ein.

[Unit]
Description=backup the vaultwarden sqlite database

[Service]
Type=oneshot
WorkingDirectory=/home/<username>/vw-backups
ExecStart=/usr/bin/env bash -c 'sqlite3 /home/<username>/vaultwarden/vw-data/db.sqlite3 ".backup backup-$(date -Is | tr : _).sqlite3"'
ExecStart=/usr/bin/find . -type f -mtime +30 -name 'backup*' -delete

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Starte den Dienst, um den Dienst zu testen und ein Backup zu erstellen.

$  sudo systemctl start vaultwarden-backup.service

Prüfe, ob die Sicherungsdatei vorhanden ist.

$ ls -l ~/vw-backups

Du solltest den Eintrag für die Sicherungsdatei sehen.

total 192
-rw-r--r-- 1 root root 196608 Jul 31 17:25 backup-2022-07-31T17_25_04+00_00.sqlite3

Um einen regelmäßigen Zeitplan für die Backups zu erstellen, erstelle und öffne die systemd timer unit Datei. Du musst darauf achten, dass der Dateiname mit dem Dateinamen des Dienstes übereinstimmt.

$ sudo nano /etc/systemd/system/vaultwarden-backup.timer

Füge den folgenden Code in die Datei ein.

[Unit]
Description=schedule vaultwarden backups

[Timer]
OnCalendar=04:00
Persistent=true

[Install]
WantedBy=multi-user.target

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. So wird die Sicherung täglich um 4 Uhr morgens durchgeführt.

Starte und aktiviere den Dienst der Zeitschaltuhr.

$ sudo systemctl enable vaultwarden-backup.timer
$ sudo systemctl start vaultwarden-backup.timer

Überprüfe den Status des Timerdienstes.

$  systemctl status vaultwarden-backup.timer
? vaultwarden-backup.timer - schedule vaultwarden backups
     Loaded: loaded (/etc/systemd/system/vaultwarden-backup.timer; enabled; vendor preset: enabled)
     Active: active (waiting) since Sun 2022-07-31 17:27:03 UTC; 7s ago
    Trigger: Mon 2022-08-01 04:00:00 UTC; 10h left
   Triggers: ? vaultwarden-backup.service

Jul 31 17:27:03 vaultwarden systemd[1]: Started schedule vaultwarden backups.

Damit werden nur die Daten gesichert. Du solltest sicherstellen, dass die Datenbankdatei regelmäßig außerhalb des Unternehmens oder auf deinem lokalen System gesichert wird. Um die restlichen Daten zu sichern, kannst du alles in den Ordner ~/vaultwarden/vw-data kopieren. Von den restlichen Dateien müssen das Verzeichnis attachments, die Datei config.json und die Dateien rsa_key* gesichert werden. Die Verzeichnisse sends und icon_cache sind optional und sollten gesichert werden, wenn sie groß genug sind und du sie brauchst. Sie sind grundsätzlich optional.

Schritt 9 – Vaultwarden wiederherstellen

Um die Vaultwarden-Daten wiederherzustellen, stelle sicher, dass der Container gestoppt ist. Du kannst alles unter dem Datenverzeichnis durch die gesicherte Version ersetzen. Wenn du das SQLite-Backup wiederherstellst, stelle sicher, dass du die bestehende db.sqlite3-wal Datei löschst, um eine Beschädigung zu vermeiden.

Schritt 10 – Vaultwarden aktualisieren

Die Aktualisierung von Vaultwarden ist ein einfacher Schritt. Wechsle in das Docker-Kompositionsverzeichnis von Vaultwarden.

$ cd ~/vaultwarden

Als Nächstes stoppst du den bestehenden Container und entfernst ihn. Deine Daten bleiben jedoch erhalten.

$ docker compose down --remove-orphans

Ziehe die neueste Version des Gitlab-Docker-Images.

$ docker compose pull

Starte die Container erneut.

$ docker compose up -d

Deine Vaultwarden-Installation wird aktualisiert und neu gestartet.

Fazit

Damit ist unsere Anleitung zur Installation und Konfiguration von Vaultwarden auf einem Ubuntu 22.04 Server abgeschlossen. Wenn du Fragen hast, schreibe sie unten in die Kommentare.

Das könnte dich auch interessieren …