Vaultwarden auf einem 2C2G-Studentenserver aufsetzen: Den Passwort-Tresor nicht nackt ins Netz stellen
前往评论 ↓Vaultwarden gehört wohl zu den Diensten, die am besten auf einen kleinen 2C2G-Server passen
Es ist schlank und das Client-Ökosystem ist ausgereift – Handy, Computer und Browser-Plugins lassen sich direkt über offizielle Bitwarden-Clients verbinden
Gleichzeitig ist es einer der Dienste, bei denen ich am wenigsten zum lockeren Rumspielen rate
Wenn der Blog crasht, kann man ihn neu aufbauen; wenn beim Passwort-Tresor etwas schiefgeht, sind Accounts, 2FA, Panel-Passwörter und im Zweifel der Zugang zu all deinen weiteren Servern weg
Deshalb geht es hier nicht um irgendwelchen Schnickschnack, sondern um einen Ansatz, der für den Alltag reicht:
- Mit Docker Compose starten
- Nur über HTTPS nach außen freigeben
- Direkt nach der Registrierung die Registrierung wieder schließen
- Backup und Wiederherstellung nicht aufschieben
Offizielles Projekt:
https://github.com/dani-garcia/vaultwarden
Compose-Doku:
https://github.com/dani-garcia/vaultwarden/wiki/Using-Docker-Compose
Für wen passt das
Passt aus meiner Sicht zu diesen Leuten:
- du hast schon einen eigenen kleinen Server
- du willst deine Passwortdaten selbst in der Hand behalten
- du bist bereit, den Dreckskram wie HTTPS, Backups und Updates anzupacken
Wenn du einfach nur Ruhe haben willst, sind das offizielle Bitwarden-Hosting, 1Password oder der Apple Passwörter-Manager alle super
Der Vorteil von Vaultwarden ist nicht null Wartungsaufwand, sondern dass es leichter ist, freier – und besser zu den kleinen Kisten von chronisch pleiten Studierenden passt
Das brauchst du vorab
- einen VPS, auf dem Docker läuft
- eine Domain oder zumindest einen stabilen HTTPS-Einstieg
- Docker und Docker Compose
- grundlegende Kenntnisse zu SSH, Reverse Proxy und Firewall
Falls Docker noch nicht installiert ist, schau zuerst in Docker und Docker Compose Minimal-Einstieg: Diese yml-Dateien verstehen
Falls noch keine Domain eingerichtet ist, schau zuerst in Dem frisch aufgesetzten Blog eine kostenlose Domain geben und in der Webmaster-Community kurz Hallo sagen
Verzeichnis anlegen
Ich packe das Ganze wieder unter /srv/stacks
sudo mkdir -p /srv/stacks/vaultwardensudo chown -R $USER:$USER /srv/stacks/vaultwardencd /srv/stacks/vaultwardenmkdir -p vw-dataDie Verzeichnisstruktur sieht ungefähr so aus:
/srv/stacks/vaultwarden/ docker-compose.yml vw-data/Später landen Datenbank, Anhänge und so weiter genau in vw-data
Zuerst die Compose-Datei schreiben
services: vaultwarden: image: ghcr.io/dani-garcia/vaultwarden:latest container_name: vaultwarden restart: unless-stopped environment: DOMAIN: "https://vault.example.com" SIGNUPS_ALLOWED: "true" INVITATIONS_ALLOWED: "false" ENABLE_WEBSOCKET: "true" TZ: "Asia/Shanghai" volumes: - ./vw-data:/data ports: - "127.0.0.1:8080:80"Ersetze vault.example.com durch deine eigene Domain
Wichtig ist hier vor allem diese Zeile:
127.0.0.1:8080:80Das heißt: Vaultwarden lauscht nur lokal auf 8080
Aus dem öffentlichen Netz kommt man nicht direkt drauf, sondern nur über Nginx, Caddy oder Cloudflare Tunnel
Schreib es nicht gleich so:
0.0.0.0:8080:80Einen Passwort-Tresor direkt nackt auf einen öffentlichen HTTP-Port zu legen, ist keine gute Idee
Ein paar Variablen kurz erklärt:
DOMAIN: die finale HTTPS-Adresse, unter der später zugegriffen wirdSIGNUPS_ALLOWED: bei der ersten Registrierung kurz anmachen, danach sofort wieder ausINVITATIONS_ALLOWED: für den Eigengebrauch direkt aus; wenn du jemanden einladen willst, geht es damitENABLE_WEBSOCKET: einfach anlassen, dann fühlt sich die Client-Synchronisation halbwegs normal an
Starten
docker compose up -ddocker compose logs -f vaultwardenKurz lokal prüfen:
curl -I http://127.0.0.1:8080/Wenn ein Statuscode zurückkommt, lebt der Container
Fertig ist es damit aber noch nicht – denn das eigentliche Thema ist HTTPS
Reverse Proxy und HTTPS
So etwas wie Vaultwarden sollte nicht dauerhaft auf HTTP laufen
Sicherheitskontext im Browser, Passwort-Manager-Clients und am Ende auch dein eigenes Bauchgefühl verlangen, dass du HTTPS sauber hinbekommst
Ich entscheide mich meist für einen von zwei Wegen
Weg A: Caddy / Nginx
Passt, wenn die Domain direkt auf den Server zeigt und 80 sowie 443 offen sein dürfen
Caddy ist am bequemsten:
vault.example.com { reverse_proxy 127.0.0.1:8080}Um die Zertifikate kümmert er sich selbst
Nginx geht genauso; die Grundidee ist dieselbe, nämlich https://vault.example.com auf 127.0.0.1:8080 weiterzuleiten
server { listen 80; server_name vault.example.com; return 301 https://$host$request_uri;}
server { listen 443 ssl http2; server_name vault.example.com;
ssl_certificate /path/to/fullchain.pem; ssl_certificate_key /path/to/privkey.pem;
location / { client_max_body_size 525M; proxy_pass http://127.0.0.1:8080; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header X-Forwarded-Proto $scheme; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection "upgrade"; }}Nach dem Ändern nicht vergessen zu prüfen:
sudo nginx -tsudo systemctl reload nginxWeg B: Cloudflare Tunnel
Wenn der Ursprungsserver gar nicht erst 80 und 443 öffnen soll, ist ein Tunnel angenehmer
Der Aufbau sieht dann so aus:
vault.example.com -> Cloudflare -> Cloudflare Tunnel -> 127.0.0.1:8080 -> VaultwardenGenau das nutze ich selbst
Und grundsätzlich gilt: Leg nicht über den gesamten Vaultwarden eine Cloudflare-Access-Login-Seite
Für Browser-Plugins und Mobile-Clients ist das unpraktisch
Wenn du extra absichern willst, schütze lieber gezielt nur /admin
Direkt nach der ersten Registrierung die Registrierung schließen
Nach dem ersten Öffnen von https://vault.example.com legst du zuerst deinen eigenen Hauptaccount an
Direkt danach die Config anpassen:
SIGNUPS_ALLOWED: "false"Und dann neu starten:
docker compose up -dGlaub nicht, deine Domain sei zu unscheinbar – öffentliche Dienste werden früher oder später gescannt
Was nach dem Anlegen des Accounts als Erstes kommt
- ein wirklich starkes Master-Passwort setzen
- Zwei-Faktor-Authentifizierung aktivieren
- Passwörter erst importieren, wenn HTTPS sauber läuft
- vor dem Import aus dem alten Passwort-Manager ein Offline-Backup exportieren
Und noch ein sehr pragmatischer Punkt:
Wirf nicht unüberlegt SSH-Keys vom Server, Panel-Passwörter oder irgendwelche Root-Zugangsdaten in einen Passwort-Tresor, dessen Backup-Strategie noch nicht steht
Erst aufsetzen, dann nach und nach umziehen
Backup
Die wichtigsten Daten von Vaultwarden liegen hier:
/srv/stacks/vaultwarden/vw-dataAm einfachsten lässt du erst ein internes Backup erstellen und packst dann das ganze Verzeichnis zusammen
cd /srv/stacks/vaultwardenmkdir -p backupsdocker compose exec -T vaultwarden /vaultwarden backuptar -czf backups/vaultwarden-$(date +%Y%m%d-%H%M%S).tar.gz docker-compose.yml vw-dataFalls du .env, SMTP, Admin-Tokens oder Ähnliches nutzt, sichere das gleich mit – aber wirf es nicht in ein öffentliches Repo
Danach das Backup lokal ziehen oder auf eine andere Maschine synchronisieren
scp your-server:/srv/stacks/vaultwarden/backups/vaultwarden-20260625-030000.tar.gz .Lass es nicht nur auf demselben Server liegen
Ein Backup auf derselben Maschine ist oft so gut wie gar kein Backup
Wiederherstellungstests
Nur sichern zu können, aber nicht wiederherstellen zu können, ist ziemlich riskant
Du solltest zumindest ab und zu prüfen, ob im Backup-Archiv überhaupt etwas drin ist:
tar -tzf backups/vaultwarden-20260625-030000.tar.gz | sed -n '1,30p'Normalerweise solltest du das hier sehen:
docker-compose.ymlvw-data/vw-data/db.sqlite3Im Ernstfall beim Wiederherstellen erst den Dienst stoppen und dann die alten Daten wegschieben:
cd /srv/stacks/vaultwardendocker compose downmv vw-data vw-data.before-restore-$(date +%Y%m%d-%H%M%S)tar -xzf backups/vaultwarden-20260625-030000.tar.gzdocker compose up -dNach dem Wiederherstellen mindestens vier Dinge prüfen:
- Weboberfläche öffnet sich
- eigener Login klappt
- Einträge sind noch da
- Browser-Plugin und Handy synchronisieren
Warte nicht, bis es wirklich knallt, um zum ersten Mal eine Wiederherstellung zu üben
Updates
Vor dem Update erst sichern – da nicht faul sein
cd /srv/stacks/vaultwardendocker compose exec -T vaultwarden /vaultwarden backupdocker compose pulldocker compose up -ddocker compose logs --tail=100 vaultwardenNach dem Update nicht nur ins Log schauen, sondern Web und Clients selbst kurz antesten
Passt es zu 2C2G?
Passt super
Vaultwarden braucht kaum Ressourcen, auf 2C2G läuft es ganz entspannt
Die wahren Kosten stecken nicht in CPU und RAM, sondern in den Wartungsgewohnheiten:
- HTTPS
- Registrierung schließen
- Backup
- Wiederherstellung
- Update
Wenn du deinen Self-Hosting-Weg ernsthaft starten willst, taugt es sogar ziemlich gut als erster ernsthafter Dienst
Der Komfortgewinn durch einen eigenen Passwort-Tresor ist schwer vorstellbar, und sich einen eigenen Tresor zusammenzubasteln ist auch ein guter Einstieg ins Deployment
Weiterlesen
Domain und HTTPS für den Passwort-Tresor lassen sich mit Cloudflare Tunnel kombinieren, die Ergebnisse des Backup-Skripts über ntfy aufs Handy schicken und andere schlanke Dienste in der Liste leichter Dienste für kleine Server unterbringen