Kapitel 6/Tutorial.md aktualisiert

Kapitel 6/Tutorial.md

@@ -1,42 +1,35 @@
 🛠️ Kapitel 6 – Vaultwarden (Docker, Debian‑12‑LXC) – Tutorial
 
-🎯 Ziel
-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.
+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.
 
-🧩 Was wir aufbauen
+—
 
-* **Image:** `vaultwarden/server:latest`
-* **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)
+## Ziel und Aufbau
 
-✅ 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`)
-* `DEINE-DOMAIN.tld` = deine echte Domain
+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>`.
 
-— — —
+—
 
-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
 apt update && apt upgrade -y
 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
 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
 ```
 
-**Prüfen:**
+Prüfe kurz, ob alles da ist:
 
 ```bash
 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
 mkdir -p /opt/vaultwarden && cd /opt/vaultwarden
 mkdir -p data
-openssl rand -base64 48   # Token erzeugen und kopieren
 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
-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
-# Optional SMTP (nur falls Mailversand gewünscht)
+# Optional: SMTP, falls du Verifizierungs- und Reset-Mails brauchst
 # SMTP_HOST=smtp.example.com
 # SMTP_FROM=pass@example.com
 # SMTP_PORT=587
@@ -84,19 +78,18 @@ SIGNUPS_ALLOWED=false
 # SMTP_PASSWORD=deinPasswort
 ```
 
-**Speichern:** `Strg+O`, `Enter` → Beenden: `Strg+X`.
-👉 `DOMAIN` zwingend **https**; `ADMIN_TOKEN` schützt `/admin`; Signups sind zu.
+Speichern mit Strg+O, Enter, anschließend Strg+X.
 
-— — —
+—
 
-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
 nano docker-compose.yml
 ```
 
-**Inhalt einfügen:**
-
 ```yaml
 services:
   vaultwarden:
@@ -113,97 +106,57 @@ services:
       - "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
 docker compose up -d
-docker compose logs -f --tail=50 vaultwarden
+docker compose logs -f --tail=80 vaultwarden
 ```
 
-Erwartet: Meldungen wie `Rocket has launched…`.
-👉 Erst prüfen, dann veröffentlichen.
+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.
 
-— — —
+—
 
-6️⃣ NPM einrichten (Proxy, WebSockets, SSL)
-**Proxy Host:**
+## 6) Veröffentlichung im Nginx Proxy Manager (GUI)
 
-* **Domain Names:** `pass.DEINE-DOMAIN.tld`
-* **Scheme:** `http`
-* **Forward Host/IP:** `<VW_IP>`
-* **Forward Port:** `8000`
-* **Block Common Exploits:** ✔️  · **Websockets Support:** ✔️
+Ö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.
 
-**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`
-* **Forward Host/IP:** `<VW_IP>`
-* **Forward Port:** `3012`
-* **Websockets Support:** ✔️
+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.
 
-**SSL‑Tab:**
+—
 
-* **Request a new SSL Certificate (Let’s Encrypt)**
-* **Force SSL**, **HTTP/2**, **HSTS**: ✔️
+## 7) Admin‑Backend absichern und ersten Benutzer anlegen
 
-**Test:** `https://pass.DEINE-DOMAIN.tld` → Loginseite sichtbar; Live‑Änderung zwischen zwei Clients testen.
-👉 Die Custom‑Location leitet den WebSocket‑Kanal (Live‑Sync) korrekt weiter.
+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`.
 
-— — —
-
-7️⃣ Admin‑Backend (GUI), Admin‑Token absichern & erster Nutzer
-Öffne `https://pass.DEINE-DOMAIN.tld/admin` und melde dich **mit deinem bisherigen Admin‑Token** an (zunächst im Klartext aus `.env`).
-
-**A) Admin‑Token auf Argon2 PHC umstellen (GUI, sicher)**
-
-1. **Hash erzeugen** (nimmt dein künftiges Admin‑Passwort entgegen → zweimal eingeben):
+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.
 
 ```bash
-   # 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).
-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`).
+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:
 
 ```bash
-   cd /opt/vaultwarden
-   sed -i '/^ADMIN_TOKEN=/d' .env
-   docker compose restart vaultwarden
-   ```
-4. **Prüfen:**
-
-   ```bash
-   docker compose logs --tail=100 vaultwarden | grep -F "plain text `ADMIN_TOKEN`" || echo "✅ Admin‑Token ist als Argon2 PHC aktiv"
+sed -i '/^ADMIN_TOKEN=/d' /opt/vaultwarden/.env
+cd /opt/vaultwarden && docker compose restart vaultwarden
 ```
 
-   **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!).
+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.
 
-**B) Ersten Benutzer per GUI anlegen (ohne SMTP)**
+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.
 
-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).
+## 8) Backups verstehen und durchführen
 
-**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)
+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.
 
 ```bash
 cd /opt/vaultwarden
@@ -215,107 +168,44 @@ tar -czf /root/vaultwarden-backup-$(date +%F).tar.gz data
 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** ✔️
-* **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
+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.
 
-✅ 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
-* **Registrierungen aus**, Admin‑Backend per **Token** geschützt
-* Daten persistent unter `/opt/vaultwarden/data` und per Tar gesichert
+**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.
 
-— — —
+**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.
-* **Browser‑Erweiterung:** Suche nach *Bitwarden* im Add‑on‑Store deines Browsers, installiere das Add‑on.
+**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.
 
-  * In den Add‑on‑Einstellungen **„Self‑Hosted/Server‑URL“** auf `https://pass.DEINE-DOMAIN.tld` setzen.
-  * 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.
+**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.
 
-### 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“
-* **Benutzername / E‑Mail** und **Passwort** eintragen
-* **URL:** z. B. `https://www.twitch.tv`
-  Speichern.
-  **Erfolg:** Der Eintrag erscheint sofort; das Add‑on zeigt ihn ebenfalls (Live‑Sync).
+```bash
+cd /opt/vaultwarden
+docker compose pull
+docker compose up -d
+```
 
-### 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**:
-
-* 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).
+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.