Thomas/Homelab--Bratonein-Kontrollzentrum--Tutorial
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Kapitel 6/Tutorial.md aktualisiert

Browse Source
This commit is contained in:
Thomas Dannenberg
2025-08-21 19:00:55 +00:00
parent 2adb7a1cb7
commit 010e791be5
1 changed files with 78 additions and 188 deletions
Download Patch File Download Diff File Expand all files Collapse all files

266
Kapitel 6/Tutorial.md
View File

@@ -1,42 +1,35 @@
🛠️ Kapitel 6 – Vaultwarden (Docker, Debian‑12‑LXC) – Tutorial 🛠️ Kapitel 6 – Vaultwarden (Docker, Debian‑12‑LXC) – Tutorial
🎯 Ziel Zu Beginn ein kurzer Hinweis: Grundlegendes wie die Bedienung von Nano, das Anlegen eines LXC samt SSH‑Zugang oder das Hinterlegen der Domain im Nginx Proxy Manager (NPM) haben wir bereits in den Basis‑Kapiteln ausführlich gezeigt. Hier verweisen wir darauf und konzentrieren uns auf das, was Vaultwarden besonders macht – mit Erklärungen dort, wo Entscheidungen oder Schalter wichtig sind.
Vaultwarden in einem Debian‑12‑LXC per **Docker + Compose** bereitstellen, hinter **Nginx Proxy Manager** (NPM) mit **HTTPS** und **WebSockets** veröffentlichen; **Registrierungen deaktivieren**, **Admin‑Token** setzen und **Backups** ermöglichen.
🧩 Was wir aufbauen —
* **Image:** `vaultwarden/server:latest` ## Ziel und Aufbau
* **Ports:** `8000:80` (Web/API), `3012:3012` (WebSocket/Live‑Sync)
* **Persistenz:** `./data:/data` → Hostpfad `/opt/vaultwarden/data`
* **Konfig per `.env`:** `DOMAIN`, `ADMIN_TOKEN`, `SIGNUPS_ALLOWED=false` (+ optional `SMTP_*`)
* **Reverse‑Proxy (NPM):** Proxy Host für `pass.DEINE‑DOMAIN.tld`, Custom Location `/notifications/hub → 3012`, SSL (Let’s Encrypt)
✅ Voraussetzungen (konkret) Wir setzen Vaultwarden in einem Debian‑12‑LXC mit Docker und Docker Compose auf. Der Dienst läuft intern auf Port 80 (Web/API) und 3012 (WebSocket). NPM veröffentlicht ihn sauber unter `https://pass.DEINE‑DOMAIN.tld`, inklusive Let’s‑Encrypt‑Zertifikat sowie einer speziellen Weiterleitung des WebSocket‑Kanals. Registrierungen bleiben geschlossen; das Admin‑Backend sichern wir mit einem modernen Argon2‑Token. Am Ende weißt du nicht nur, **was** zu klicken ist, sondern auch **warum**.
* **LXC:** Debian 12 (Bookworm) – erstellt nach Grundkapitel *Erster LXC – Grundsetup & SSH* (hier nur Verweis) —
* **Specs:** 1 vCPU · **512 MB–1 GB RAM** (512 MB empfohlen) · **4–8 GB Disk** · **statische IPv4** (z. B. `10.0.0.16/24`), IPv6 optional
* **NPM** läuft (separater LXC), **Subdomain** `pass.DEINE‑DOMAIN.tld` zeigt auf NPM (DNS A/AAAA gesetzt)
* **Outbound‑Internet** im LXC erreichbar; **Hostports 8000/3012** frei
🔁 Platzhalter ## Voraussetzungen (knapp, aber konkret)
* `<VW_IP>` = IP des Vaultwarden‑LXC (z. B. `10.0.0.16`) Der Container ist ein Debian‑12‑LXC nach unserem Grundsetup. Plane eine vCPU, 512 MB bis 1 GB RAM und 4–8 GB Platte ein. Der LXC hat eine statische IPv4 (zum Beispiel `10.0.0.16/24`). NPM läuft bereits in einem eigenen LXC, und deine Subdomain `pass.DEINE‑DOMAIN.tld` zeigt via DNS auf NPM. Im Folgenden nennen wir diese IP des Vaultwarden‑LXC `<VW_IP>`.
* `DEINE-DOMAIN.tld` = deine echte Domain
— — — —
1️⃣ System vorbereiten ## 1) System vorbereiten
Bevor wir Docker installieren, bringen wir die Paketquellen auf Stand und installieren die kleinen Helfer, mit denen wir das offizielle Docker‑Repository sauber einbinden. Das ist transparenter und sicherer als ein Einzeiler‑Installskript.
```bash ```bash
apt update && apt upgrade -y apt update && apt upgrade -y
apt install -y ca-certificates curl gnupg lsb-release apt install -y ca-certificates curl gnupg lsb-release
``` ```
👉 `ca-certificates`/`curl`/`gnupg` werden für das Docker‑Repo benötigt. —
— — — ## 2) Docker und Compose installieren
2️⃣ Docker & Compose installieren Wir fügen die signierte Docker‑Quelle hinzu, installieren Engine, CLI und das Compose‑Plugin und schalten den Dienst ein. Vorteil: schnelle Sicherheitsupdates direkt vom Projekt, und Compose ist als modernes Plugin integriert (kein separater „docker‑compose“-Binary mehr).
```bash ```bash
mkdir -p /etc/apt/keyrings mkdir -p /etc/apt/keyrings
@@ -50,32 +43,33 @@ apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker
systemctl enable --now docker systemctl enable --now docker
``` ```
**Prüfen:** Prüfe kurz, ob alles da ist:
```bash ```bash
docker --version && docker compose version docker --version && docker compose version
``` ```
👉 Offizielle Pakete, Compose als Plugin integriert. Falls Docker im LXC nicht starten will, aktiviere in Proxmox beim CT „nesting“ und „keyctl“ und starte den Container neu.
— — — —
3️⃣ Projekt anlegen & `.env` erstellen ## 3) Projekt anlegen und Konfiguration schreiben
Wir legen das Arbeitsverzeichnis `/opt/vaultwarden` samt Datenordner an. Die Konfiguration parken wir in einer `.env`‑Datei – das trennt Geheimnisse sauber von der Compose‑Datei und macht spätere Anpassungen ungefährlich.
```bash ```bash
mkdir -p /opt/vaultwarden && cd /opt/vaultwarden mkdir -p /opt/vaultwarden && cd /opt/vaultwarden
mkdir -p data mkdir -p data
openssl rand -base64 48 # Token erzeugen und kopieren
nano .env nano .env
``` ```
**Inhalt (`.env`) – Platzhalter ersetzen, Token einfügen:** Füge folgenden Inhalt ein und ersetze Platzhalter (die Domain bitte **mit https** – sonst fehlen später Assets oder Links wirken „kaputt“):
``` ```
DOMAIN=https://pass.DEINE-DOMAIN.tld DOMAIN=https://pass.DEINE-DOMAIN.tld
ADMIN_TOKEN=HIER_DEIN_ERZEUGTES_TOKEN_EINFÜGEN # Wir beginnen mit geschlossenen Registrierungen und öffnen sie später kurz für deinen Erstnutzer.
SIGNUPS_ALLOWED=false SIGNUPS_ALLOWED=false
# Optional SMTP (nur falls Mailversand gewünscht) # Optional: SMTP, falls du Verifizierungs- und Reset-Mails brauchst
# SMTP_HOST=smtp.example.com # SMTP_HOST=smtp.example.com
# SMTP_FROM=pass@example.com # SMTP_FROM=pass@example.com
# SMTP_PORT=587 # SMTP_PORT=587
@@ -84,19 +78,18 @@ SIGNUPS_ALLOWED=false
# SMTP_PASSWORD=deinPasswort # SMTP_PASSWORD=deinPasswort
``` ```
**Speichern:** `Strg+O`, `Enter` → Beenden: `Strg+X`. Speichern mit Strg+O, Enter, anschließend Strg+X.
👉 `DOMAIN` zwingend **https**; `ADMIN_TOKEN` schützt `/admin`; Signups sind zu.
— — — —
4️⃣ `docker-compose.yml` schreiben ## 4) Compose‑Datei erstellen
Die Compose‑Datei beschreibt, welches Image gestartet wird, wo Daten liegen und welche Ports wir durchreichen. Wichtig sind hier das Daten‑Volume und der zusätzliche WebSocket‑Port – ohne den gibt es keinen Live‑Sync zwischen Clients.
```bash ```bash
nano docker-compose.yml nano docker-compose.yml
``` ```
**Inhalt einfügen:**
```yaml ```yaml
services: services:
vaultwarden: vaultwarden:
@@ -113,97 +106,57 @@ services:
- "3012:3012" # WebSocket (Live Sync) - "3012:3012" # WebSocket (Live Sync)
``` ```
**Speichern:** `Strg+O`, `Enter` → `Strg+X`. —
👉 `./data:/data` = Persistenz auf dem Host.
— — — ## 5) Starten und prüfen
5️⃣ Container starten & Logs prüfen Jetzt starten wir den Container im Hintergrund und schauen live in die Protokolle. So siehst du sofort, ob Vaultwarden sauber „hochkommt“, bevor du die Veröffentlichung in NPM anfasst.
```bash ```bash
docker compose up -d docker compose up -d
docker compose logs -f --tail=50 vaultwarden docker compose logs -f --tail=80 vaultwarden
``` ```
Erwartet: Meldungen wie `Rocket has launched…`. Wenn Zeilen wie „Rocket has launched…“ auftauchen und keine Fehlermeldungen zu `/data` erscheinen, läuft der Dienst intern – genau so wollen wir ihn vorfinden, bevor wir nach außen gehen.
👉 Erst prüfen, dann veröffentlichen.
— — — —
6️⃣ NPM einrichten (Proxy, WebSockets, SSL) ## 6) Veröffentlichung im Nginx Proxy Manager (GUI)
**Proxy Host:**
* **Domain Names:** `pass.DEINE-DOMAIN.tld` Öffne die NPM‑Oberfläche und lege einen neuen Proxy Host an. In das Feld „Domain Names“ trägst du `pass.DEINE‑DOMAIN.tld` ein. Als Scheme wählst du „http“, denn NPM beendet die Verschlüsselung, und als Ziel gibst du die interne Adresse deines Vaultwarden‑Containers an: `<VW_IP>` mit Port **8000**. Die beiden Schalter „Block Common Exploits“ und „Websockets Support“ aktivierst du, damit NPM typische Angriffsversuche abfängt und der spätere Live‑Kanal technisch erlaubt ist.
* **Scheme:** `http`
* **Forward Host/IP:** `<VW_IP>`
* **Forward Port:** `8000`
* **Block Common Exploits:** ✔️ · **Websockets Support:** ✔️
**Custom Location:** Bevor du speicherst, wechselst du in den Reiter „Custom Locations“ und fügst **eine** Location hinzu. Als Pfad gibst du `/notifications/hub` ein – das ist der spezielle WebSocket‑Endpunkt, über den Vaultwarden Änderungen in Echtzeit verteilt. Als Ziel trägst du wieder `<VW_IP>` ein, diesmal aber mit Port **3012**, und aktivierst auch hier den WebSocket‑Schalter. Speichere die Location und wechsle in den Reiter „SSL“.
* **Location:** `/notifications/hub` Dort forderst du ein neues Let’s‑Encrypt‑Zertifikat für deine Subdomain an, akzeptierst die Nutzungsbedingungen und setzt direkt **Force SSL**, **HTTP/2** und **HSTS**. Nach dem Speichern dauert es einen Moment. Anschließend rufst du im Browser `https://pass.DEINE‑DOMAIN.tld` auf. Die Login‑Seite sollte jetzt erreichbar sein; wenn du dich auf zwei Geräten anmeldest und einen Tresor‑Eintrag änderst, siehst du die Änderung ohne Neuladen – das bestätigt, dass die WebSocket‑Weiterleitung funktioniert.
* **Forward Host/IP:** `<VW_IP>`
* **Forward Port:** `3012`
* **Websockets Support:** ✔️
**SSL‑Tab:** —
* **Request a new SSL Certificate (Let’s Encrypt)** ## 7) Admin‑Backend absichern und ersten Benutzer anlegen
* **Force SSL**, **HTTP/2**, **HSTS**: ✔️
**Test:** `https://pass.DEINE-DOMAIN.tld` → Loginseite sichtbar; Live‑Änderung zwischen zwei Clients testen. Beim ersten Öffnen des Admin‑Bereichs unter `https://pass.DEINE‑DOMAIN.tld/admin` meldet Vaultwarden oft, dass ein Klartext‑`ADMIN_TOKEN` unsicher ist. Das stimmt – deshalb hinterlegen wir einen **Argon2‑PHC‑Hash** in der GUI und entfernen den Klartext‑Eintrag danach aus der `.env`.
👉 Die Custom‑Location leitet den WebSocket‑Kanal (Live‑Sync) korrekt weiter.
— — — Zum Erzeugen des Hashes nutzen wir das eingebaute Werkzeug des Containers. Der Befehl fragt dich zweimal nach dem **künftigen Admin‑Passwort** (also nicht nach dem Hash). Den ausgegebenen String, der mit `$argon2id$…` beginnt, kopierst du vollständig.
7️⃣ Admin‑Backend (GUI), Admin‑Token absichern & erster Nutzer ```bash
Öffne `https://pass.DEINE-DOMAIN.tld/admin` und melde dich **mit deinem bisherigen Admin‑Token** an (zunächst im Klartext aus `.env`). docker exec -it vaultwarden /vaultwarden hash --preset owasp
```
**A) Admin‑Token auf Argon2 PHC umstellen (GUI, sicher)** Zurück im Admin‑Panel gehst du auf **Settings → General** und fügst den kompletten PHC‑String in das Feld „Admin token / Argon2 PHC“ ein. Nach dem Speichern verwendest du im Admin‑Login künftig das **Passwort**, das du beim Hash erzeugt hast – nicht den Hash selbst. Damit der Klartext‑Eintrag nicht mehr herumliegt, entfernst du die Zeile `ADMIN_TOKEN=` aus der `.env` und startest den Container neu:
1. **Hash erzeugen** (nimmt dein künftiges Admin‑Passwort entgegen → zweimal eingeben): ```bash
sed -i '/^ADMIN_TOKEN=/d' /opt/vaultwarden/.env
cd /opt/vaultwarden && docker compose restart vaultwarden
```
```bash Damit ist das Backend zeitgemäß gehärtet. Jetzt legst du deinen ersten Nutzer an: In **Settings → General** schaltest du „Allow new signups“ kurz ein und speicherst. In einem neuen Tab öffnest du `https://pass.DEINE‑DOMAIN.tld/#/register`, registrierst dein Konto, meldest dich einmal an und deaktivierst die Registrierung wieder. Wenn du bereits SMTP konfiguriert hast, kannst du alternativ über **Users → Invitations** Einladungs‑Mails verschicken.
# Container-Name ist im Tutorial 'vaultwarden'
docker exec -it vaultwarden /vaultwarden hash --preset owasp
```
> Kopiere **den kompletten PHC‑String** ab `$argon2id$…` (ohne zusätzliche Anführungszeichen). Zum Schluss gehst du in deinem Benutzerkonto auf **Settings → Security** und aktivierst die Zwei‑Faktor‑Anmeldung (TOTP oder FIDO2/YubiKey). Das schützt deinen Tresor zusätzlich, selbst wenn jemand an dein Passwort käme.
2. **Im Admin‑Panel speichern:**
* Admin → **Settings** → **General** → Feld **“Admin token / Argon2 PHC”** —
* PHC‑String einfügen → **Save**.
3. **Konflikte vermeiden:** Entferne das alte `ADMIN_TOKEN` aus der `.env` (wir nutzen künftig die **GUI‑Konfig**/`config.json`).
```bash ## 8) Backups verstehen und durchführen
cd /opt/vaultwarden
sed -i '/^ADMIN_TOKEN=/d' .env
docker compose restart vaultwarden
```
4. **Prüfen:**
```bash Wichtig ist nicht der Container – den kannst du jederzeit ersetzen –, sondern der **Datenordner** auf dem Host. Darin liegen Datenbank, Anhänge, „Sends“ und Konfiguration. Ein einfaches, zuverlässiges Backup besteht darin, diesen Ordner regelmäßig als Archiv zu sichern. Für maximale Konsistenz kannst du Vaultwarden vorher kurz stoppen; für kleine Umgebungen ist ein „Online‑Tar“ oft ausreichend.
docker compose logs --tail=100 vaultwarden | grep -F "plain text `ADMIN_TOKEN`" || echo "✅ Admin‑Token ist als Argon2 PHC aktiv"
```
**Login‑Hinweis:** Ab jetzt loggst du dich im Admin‑Bereich mit **dem Klartext‑Passwort** ein, das du beim `hash` eingegeben hast (nicht mit dem langen PHC‑String!).
**B) Ersten Benutzer per GUI anlegen (ohne SMTP)**
1. Admin → **Settings → General** → **Allow new signups** **einschalten** → **Save**.
2. In neuem Tab `https://pass.DEINE-DOMAIN.tld/#/register` öffnen → Benutzer anlegen → anmelden.
3. Admin → **Allow new signups** wieder **ausschalten** → **Save**.
> **Mit SMTP** kannst du stattdessen Admin → **Users → Invitations** nutzen (Einladungs‑Mail).
**C) Sicherheit abrunden**
* Eigenes Benutzerkonto → **Settings/Security** → **2FA** (TOTP oder FIDO2/YubiKey) aktivieren.
* Optional: **SMTP** in Admin‑Panel setzen und **Testmail** senden.
— — —
8️⃣ Backup (Basis)
```bash ```bash
cd /opt/vaultwarden cd /opt/vaultwarden
@@ -215,107 +168,44 @@ tar -czf /root/vaultwarden-backup-$(date +%F).tar.gz data
ls -lh /root/vaultwarden-backup-*.tar.gz ls -lh /root/vaultwarden-backup-*.tar.gz
``` ```
👉 Ein Tar reicht als Grundlage; regelmäßig per Cron sichern. Die Wiederherstellung ist entsprechend einfach: neue Instanz bis zur Compose‑Datei bringen, Archiv nach `/opt/vaultwarden/` kopieren, entpacken, `docker compose up -d` – fertig.
— — — —
🛠️ Fehlerhilfe (kurz) ## 9) Vaultwarden im Alltag nutzen (Standard‑Anwendungen im Detail)
* **Kein Live‑Sync / 502:** NPM‑Location `/notifications/hub` → Port **3012** + **Websockets** ✔️ Nach der Installation geht es darum, den Tresor im Alltag bequem und sicher zu verwenden. Der Einstieg geschieht meist über die Web‑Oberfläche: Du meldest dich unter `https://pass.DEINE‑DOMAIN.tld` an und siehst zunächst einen leeren Tresor. Lege deinen ersten Eintrag an – Name, Benutzername oder E‑Mail, ein mit dem Generator erzeugtes langes Passwort und die Ziel‑URL. Das ist bewusst simpel: Einträge sind die kleinste Einheit, aus ihnen baust du dir später Ordnung und Automatik.
* **Icons/Links fehlen:** In `.env` `DOMAIN` = **https**; dann `docker compose restart vaultwarden`
* **Container startet nicht:** `docker compose logs --tail=200 vaultwarden`
* **Let’s‑Encrypt‑Fehler:** DNS‑Eintrag prüfen; Rate‑Limit abwarten
✅ Ergebnis **Einträge anlegen & strukturieren.** Wenn du viele Zugänge hast, zahlt sich eine klare Struktur aus. Lege in der Web‑Oberfläche Ordner an (etwa „Streaming“, „Privat“, „Server“). Beim Speichern eines Eintrags weist du ihn direkt einem Ordner zu. So findest du Logins auch nach Monaten wieder, ohne suchen zu müssen. Für wiederkehrende Notizen (z. B. Seriennummern, kleine API‑Tokens) gibt es den Eintragstyp „Sichere Notiz“.
* Vaultwarden läuft hinter NPM mit **HTTPS**; **WebSockets** funktionieren **Browser‑Erweiterung verbinden.** Installiere die Bitwarden‑Erweiterung in deinem Browser und stelle in den Einstellungen die Server‑URL auf deine Instanz (`https://pass.DEINE‑DOMAIN.tld`). Nach dem Login siehst du dieselben Einträge wie im Web‑Tresor. Aktiviere die Option, beim Aufruf einer Login‑Seite passende Einträge vorzuschlagen; wenn du möchtest, kannst du auch Auto‑Fill per Tastenkombination erlauben. Das ist besonders praktisch, wenn du häufig zwischen Diensten wechselst.
* **Registrierungen aus**, Admin‑Backend per **Token** geschützt
* Daten persistent unter `/opt/vaultwarden/data` und per Tar gesichert
— — — **Import bestehender Passwörter.** Viele starten nicht bei null. Der Import liegt in der Web‑Oberfläche unter „Werkzeuge → Importieren“. Wähle die Quelle (z. B. Chrome, Firefox, Bitwarden CSV/JSON), lade die Datei hoch und starte den Import. Sinnvoll ist es, zunächst einen temporären Ordner wie „Eingang“ anzulegen und dort alles hinein importieren zu lassen. Danach ziehst du Stück für Stück in deine endgültige Struktur um und löschst Dubletten. Falls eine Website Sonderregeln für Passwörter hat (nur bestimmte Zeichen), passe den betroffenen Eintrag nach dem Import an – wichtig ist, dass der in Vaultwarden gespeicherte Wert mit dem wirklich gesetzten Passwort übereinstimmt.
9️⃣ Arbeiten mit Vaultwarden – Kurzguide (Praxis) **TOTP/2FA in Einträgen hinterlegen.** Aktivierst du bei einem Dienst Zwei‑Faktor‑Anmeldung, bekommst du einen QR‑Code oder einen Text‑Schlüssel (Base32). In Vaultwarden öffnest du den passenden Eintrag, fügst ein neues Feld vom Typ „Authenticator‑Schlüssel (TOTP)“ hinzu und kopierst den Schlüssel hinein. Ab dann zeigt der Eintrag alle 30 Sekunden einen neuen sechsstelligen Code an, den du beim Login verwendest. Praktisch: Die Browser‑Erweiterung kann den TOTP‑Code mit ausfüllen oder mit einem Klick kopieren. Für besonders kritische Zugänge kannst du überlegen, TOTP getrennt aufzubewahren (z. B. Hardware‑Token) – Standard‑Accounts sind im Alltag mit TOTP im Tresor jedoch gut bedient.
> **Ziel:** Direkt nach der Einrichtung sicher starten. Du brauchst nur deine URL `https://pass.DEINE-DOMAIN.tld`. **Autofill sinnvoll einsetzen.** Auto‑Fill spart Zeit, sollte aber bewusst konfiguriert werden. Lasse dir beim Seitenaufruf passende Einträge vorschlagen, bestätigt wird das Füllen idealerweise manuell (Klick oder Tastenkürzel). Auf gemeinsam genutzten Rechnern empfiehlt sich außerdem, die Erweiterung nach kurzer Inaktivität automatisch zu sperren und nur per Master‑Passwort, PIN oder Biometrie zu entsperren.
### 9.1 Anmelden & Clients verbinden **„Send“: sicher teilen, was nicht im Mail‑Postfach liegen soll.** Manchmal musst du einem Kollegen schnell einen Schlüssel oder eine kleine Datei geben. Mit „Send“ erzeugst du einen geschützten Link mit Ablaufdatum und optionalem Kennwort sowie einer Begrenzung der Abrufe. Das passt gut für einmalige Übergaben, ohne dass sensible Inhalte in E‑Mails oder Chat‑Verläufen liegen bleiben.
* **Web:** Öffne `https://pass.DEINE-DOMAIN.tld`, logge dich mit deinem Benutzer ein. **Gemeinsam nutzen: Organisation & Sammlungen.** Wenn ihr zu zweit oder im kleinen Team arbeitet, legst du eine Organisation an und darin „Sammlungen“ (etwa „Stream‑Zugänge“, „Server‑Logins“). Einträge, die ihr teilen wollt, verschiebst du in die passende Sammlung. Zugriffsrechte vergibst du pro Mitglied und Sammlung. Wichtig: Einladungen versendet Vaultwarden per Mail – ohne funktionierendes SMTP legst du neue Konten zunächst wie oben beschrieben über eine kurz geöffnete Registrierung an und verschiebst Einträge anschließend in Sammlungen.
* **Browser‑Erweiterung:** Suche nach *Bitwarden* im Add‑on‑Store deines Browsers, installiere das Add‑on.
* In den Add‑on‑Einstellungen **„Self‑Hosted/Server‑URL“** auf `https://pass.DEINE-DOMAIN.tld` setzen. **Export vs. Backup – was ist der Unterschied?** Der persönliche Export in der Web‑Oberfläche ist dafür gedacht, deinen Tresor nutzerseitig mitzunehmen (je nach Client als CSV oder verschlüsselte JSON‑Variante). Das **Server‑Backup** aus Abschnitt 8 sichert die komplette Instanz mit allen Anhängen, „Sends“ und Einstellungen. Für echte Ausfallsicherheit nutzt du beides: regelmäßige Server‑Backups und gelegentliche Exporte des eigenen Tresors.
* Einloggen → das Tresorsymbol erscheint in der Toolbar.
* **Desktop/Mobile (optional):** Bitwarden‑App installieren → beim ersten Start **Server** auf `https://pass.DEINE-DOMAIN.tld` stellen → einloggen.
**Erfolg:** Du siehst deinen (noch leeren) Tresor in Web & Add‑on.
### 9.2 Ersten Eintrag anlegen (Login) ## 10) Updates ohne Drama
Web‑UI → **Neu** → **Anmeldung**: Ein Update entspricht einem Image‑Tausch. Du holst das aktuelle Image und startest neu; die Daten bleiben, wo sie sind. Vorherige Backups sind trotzdem Pflicht.
* **Name:** z. B. „Twitch – Hauptaccount“ ```bash
* **Benutzername / E‑Mail** und **Passwort** eintragen cd /opt/vaultwarden
* **URL:** z. B. `https://www.twitch.tv` docker compose pull
Speichern. docker compose up -d
**Erfolg:** Der Eintrag erscheint sofort; das Add‑on zeigt ihn ebenfalls (Live‑Sync). ```
### 9.3 Ordner/Struktur Wenn etwas nach einem Update unerwartet läuft, Rollbackst du kurzzeitig auf den vorherigen Tag bzw. die vorherige Image‑ID und planst das Update neu – mit Blick ins Changelog.
Web‑UI → **Ordner** → **Neuer Ordner**: z. B. „Streaming“. —
Im Eintrag den **Ordner** auf „Streaming“ stellen → speichern.
**Warum:** Ordnung hält die Suche schlank.
### 9.4 Sicheres Passwort generieren ## Ergebnis
Web‑UI oder Add‑on → **Generator**: Vaultwarden läuft hinter NPM unter deiner eigenen Domain mit gültigem TLS, Live‑Sync per WebSockets und gehärtetem Admin‑Backend. Registrierungen sind standardmäßig zu, dein erster Benutzer ist angelegt, und du hast ein praktisches Backup‑Verfahren. Ab hier geht es um Komfort: Add‑ons in allen Browsern, Apps auf den Geräten und ein bisschen Routine beim Generieren wirklich starker, individueller Passwörter.
* Länge **20–24**, **Zahlen**, **Sonderzeichen** an; **keine ähnlichen Zeichen**.
* „Generieren“ → „In Eintrag übernehmen“ (oder **Kopieren** und ins Zielkonto einfügen).
**Tipp:** Nach Passwortwechsel beim Dienst die Änderung **im Tresor speichern**.
### 9.5 TOTP (2‑Faktor) im Eintrag hinterlegen
Beim Ziel‑Dienst 2FA aktivieren → du bekommst einen **TOTP‑Schlüssel** (Base32) oder **QR**.
* Im Tresor‑Eintrag → **Feld hinzufügen** → **„Authenticator‑Schlüssel (TOTP)“** wählen → Schlüssel einfügen → speichern.
* Der Eintrag zeigt nun **zeitbasierte 6‑stellige Codes**.
**Test:** Logout beim Dienst → Login mit Passwort + aktuellem Code aus dem Eintrag.
### 9.6 Import vorhandener Passwörter (optional)
Web‑UI → **Werkzeuge** → **Importieren**:
* **Format** wählen (z. B. Chrome/Firefox/Bitwarden JSON/CSV).
* Datei auswählen → **Import**.
**Hinweis:** Nach dem Import kurz durchgehen, doppelte/alte Logins aufräumen.
### 9.7 Autofill testen (Browser‑Add‑on)
Zur Login‑Seite wechseln → Tresorsymbol → passenden Eintrag anklicken → Felder werden gefüllt.
**Tipp:** In den Add‑on‑Einstellungen „Beim Seitenaufruf vorschlagen/Auto‑Fill“ nach Wunsch aktivieren.
### 9.8 „Send“ (sicher teilen, optional)
Web‑UI → **Neu** → **Send**:
* Text oder Datei wählen, **Ablaufdatum**, **max. Abrufe**, optional **Kennwort** setzen → **Erstellen** → **Link kopieren**.
**Einsatz:** Einzelne Secrets/Dateien sicher an Partner schicken.
### 9.9 Organisation (Team, optional)
Web‑UI → **Organisationen** → **Neue Organisation** (Name vergeben).
* Mitglieder einladen (erfordert **funktionierendes SMTP**).
* **Sammlungen** anlegen (z. B. „Stream‑Zugänge“) und Einträge zuordnen.
**Hinweis:** Ohne SMTP später nachrüsten; bis dahin Solo‑Tresor nutzen.
### 9.10 Export (Nutzer‑Sicht) & Restore‑Probe
Web‑UI → **Werkzeuge** → **Exportieren** → Format wählen (z. B. Bitwarden JSON) → lokal verschlüsselt ablegen.
**Probe‑Restore:** In einer Testinstanz/Profil importieren und prüfen. (Server‑Backups hast du zusätzlich in Schritt 8.)
### 9.11 Gute Praxis
* **Ein Dienst = ein eindeutiges Passwort**; Passwortgenerator konsequent nutzen.
* Wo verfügbar, **2FA aktivieren** und TOTP im Eintrag hinterlegen.
* Add‑on/Apps: **Sperre/Timeout** und **Biometrie/PIN** aktivieren.
* Regelmäßig **aufräumen** (alte/duplizierte Logins löschen).