Kapitel 6/Tutorial.md aktualisiert

2025-08-20 10:53:45 +00:00
parent 0e0bcaeb26
commit fbe90750ec
1 changed files with 155 additions and 275 deletions
--- a/6/Tutorial.md
+++ b/6/Tutorial.md
@@ -1,160 +1,79 @@
-📝 Kapitel 6 – Vaultwarden (ohne Docker, systemd)
+🛠️ 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, **Backup** einrichten.

-## 🎯 Was wir bauen (in Klartext)
+Voraussetzungen (siehe Readme dieses Kapitels)

-Wir richten **Vaultwarden** als Passwort‑Tresor ein. Das ist die kompatible Server‑Variante zu Bitwarden. Du bekommst:
+* LXC existiert (Specs lt. Readme). SSH/Grundsetup siehe Grundkapitel „Erster LXC – Grundsetup & SSH“.
+* NPM läuft, Subdomain z. B. `pass.DEINE‑DOMAIN.tld` zeigt auf NPM.

-* eine **Web‑Oberfläche** zum Verwalten deiner Passwörter und TOTP‑Codes,
-* **sichere Anmeldung** (Admin‑Token, Registrierungen aus),
-* **HTTPS** über den Nginx Proxy Manager (NPM) und
-* **Live‑Sync** dank WebSockets.
+Platzhalter

-Wir betreiben Vaultwarden **ohne Docker** (direkt als Programm), damit es **möglichst wenig RAM** verbraucht.
+* `<VW_IP>` = IP des Vaultwarden‑LXC, z. B. `10.0.0.16`
+* `DEINE-DOMAIN.tld` = deine echte Domain

---
+— — —

-## ✅ Voraussetzungen (kurz & klar)
-
-* LXC‑Container: **Debian 12 (Bookworm)** – erstellt nach dem Grundkapitel *Erster LXC – Grundsetup & SSH*. (Hier nicht wiederholt.)
-* **LXC‑Spezifikation für dieses Kapitel:** 1 vCPU · 256 MB RAM · 4 GB Disk · statische IPv4 (z. B. `10.0.0.16/24`). IPv6 optional (SLAAC oder None). DNS wie im Netz üblich.
-* Nginx Proxy Manager läuft (eigenes Kapitel), Domain vorhanden (z. B. `pass.DEINE-DOMAIN.tld`).
-
-**Platzhalter, die du gleich ersetzt:**
-
-* `<VW_IP>` → IP deines Vaultwarden‑LXC, z. B. `10.0.0.16`
-* `DEINE-DOMAIN.tld` → deine echte Domain
-
---
-
-## 1) System vorbereiten
-
-Wir aktualisieren das System, installieren Werkzeuge und richten einen **eigenen Dienst‑Benutzer** ein.
-
-> **Warum ein eigener Dienst‑Benutzer?**
-> Dieser Benutzer ist **nur** für den Vaultwarden‑Dienst da (kein normales Login). Dadurch sind die Tresor‑Dateien vor anderen Diensten geschützt. In früheren Docker‑Kapiteln war diese Trennung im Container bereits vorhanden – **jetzt** übernehmen wir sie auf Systemebene.
+1️⃣ System vorbereiten
+Wir aktualisieren das System und installieren Basis‑Tools.

 ```bash
 apt update && apt upgrade -y
-apt install -y ca-certificates curl unzip openssl
-
-# Dienstnutzer ohne Login anlegen (nur für den Dienst, zur Absicherung)
-useradd --system --home /var/lib/vaultwarden --shell /usr/sbin/nologin vaultwarden || true
-
-# Arbeits- und Datenordner anlegen
-mkdir -p /opt/vaultwarden
-mkdir -p /var/lib/vaultwarden/data
-
-# Eigentum der Daten an den Dienstbenutzer übergeben (Schutz der Tresor-Daten)
-chown -R vaultwarden:vaultwarden /var/lib/vaultwarden
+apt install -y ca-certificates curl gnupg lsb-release
 ```

-**So prüfst du das Ergebnis:**
+**Warum?**
+
+* `ca-certificates`/`curl`/`gnupg` brauchen wir für das Docker‑Repository.
+
+— — —
+
+2️⃣ Docker & Compose installieren
+Wir richten die offizielle Docker‑Quelle ein und installieren Engine + Compose‑Plugin.

 ```bash
-id vaultwarden
-ls -ld /opt/vaultwarden /var/lib/vaultwarden /var/lib/vaultwarden/data
+mkdir -p /etc/apt/keyrings
+curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
+
+echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
+$(. /etc/os-release && echo $VERSION_CODENAME) stable" > /etc/apt/sources.list.d/docker.list
+
+apt update
+apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
+systemctl enable --now docker
 ```

-Du siehst den Benutzer `vaultwarden` und die Ordner existieren.
-
---
-
-## 2) Vaultwarden herunterladen (einfach & stabil)
-
-### Architektur ermitteln (falls unklar)
-
-So findest du heraus, welche der drei Download‑Zeilen du brauchst.
-
-**Im Container:**
+**Prüfen:**

 ```bash
-uname -m                  # liefert z. B. x86_64, aarch64, armv7l
-dpkg --print-architecture # liefert z. B. amd64, arm64, armhf
+docker --version
+docker compose version
 ```

-**Vom Proxmox‑Host (ohne in den CT zu gehen):**
-
-```bash
-# CTID aus der GUI (z. B. 106)
-pct exec <CTID> -- uname -m
-pct exec <CTID> -- dpkg --print-architecture
-```
-
-**Zuordnung:**
-
-* `x86_64` / `amd64` → AMD64‑Zeile verwenden
-* `aarch64` / `arm64` → ARM64‑Zeile verwenden
-* `armv7l` / `armhf`  → ARMv7‑Zeile verwenden
-
-Wir nutzen die offizielle **`releases/latest/download`**‑Adresse von GitHub. Wähle **genau eine** der folgenden Zeilen passend zu deiner CPU und führe sie aus. Keine Variablen, kein jq.
-
-**AMD64 / x86\_64 (typisch Proxmox/Debian auf Intel/AMD):**
-
-```bash
-curl -fL https://github.com/dani-garcia/vaultwarden/releases/latest/download/vaultwarden-x86_64-unknown-linux-gnu.tar.gz -o /tmp/vaultwarden.tar.gz
-```
-
-**ARM64 (z. B. Raspberry Pi 4/5):**
-
-```bash
-curl -fL https://github.com/dani-garcia/vaultwarden/releases/latest/download/vaultwarden-aarch64-unknown-linux-gnu.tar.gz -o /tmp/vaultwarden.tar.gz
-```
-
-**ARMv7:**
-
-```bash
-curl -fL https://github.com/dani-garcia/vaultwarden/releases/latest/download/vaultwarden-armv7-unknown-linux-gnueabihf.tar.gz -o /tmp/vaultwarden.tar.gz
-```
-
-**Entpacken & installieren:**
-
-```bash
-mkdir -p /tmp/vw
-# Wenn der Download fehlschlug, zeigt die nächste Zeile eine Fehlermeldung – dann die passende curl-Zeile oben erneut ausführen
-.tar -xzf /tmp/vaultwarden.tar.gz -C /tmp/vw 2>/dev/null || echo "Download prüfen: /tmp/vaultwarden.tar.gz fehlt oder ist beschädigt"
-install -m 0755 /tmp/vw/vaultwarden /opt/vaultwarden/vaultwarden
-/opt/vaultwarden/vaultwarden --version
-```
-
-> Hinweis: Falls GitHub kurzzeitig begrenzt, warte 1–2 Minuten und wiederhole **nur** die `curl`‑Zeile.
-
---
-
-## 3) Konfigurationsdatei mit **Nano** erstellen
-
-Wir hinterlegen **Domain**, **Admin‑Token**, **Ports** und **WebSockets** in einer `.env`‑Datei. Diese Datei liest der Dienst später automatisch ein.
-
-1. **Sicheres Admin‑Token erzeugen** (kopieren, wir fügen es gleich ein):
+**Warum?**
+
+* So bekommst du reproduzierbar die offiziellen Pakete; Compose ist als Plugin integriert.
+
+— — —
+
+3️⃣ Projekt anlegen & **.env** erstellen
+Wir legen das Arbeitsverzeichnis an, erzeugen ein **sicheres Admin‑Token** und tragen die Einstellungen in **.env** ein.

 ```bash
+mkdir -p /opt/vaultwarden && cd /opt/vaultwarden
+mkdir -p data
 openssl rand -base64 48
+# Ausgabe kopieren (TOKEN) und im nächsten Schritt einfügen
+nano .env
 ```

-2. **Datei mit Nano öffnen:**
-
-```bash
-nano /etc/vaultwarden.env
-```
-
-3. **Folgenden Inhalt einfügen** und **Platzhalter ersetzen**:
+**Inhalt für `.env` einfügen (Platzhalter ersetzen):**

 ```
 DOMAIN=https://pass.DEINE-DOMAIN.tld
 ADMIN_TOKEN=HIER_DEIN_ERZEUGTES_TOKEN_EINFÜGEN
 SIGNUPS_ALLOWED=false
-WEBSOCKET_ENABLED=true
-
-# Der Dienst lauscht auf der IP deines LXC (so erreicht NPM ihn)
-ROCKET_ADDRESS=<VW_IP>
-ROCKET_PORT=8000
-
-# WebSocket-Endpunkt für Live-Sync
-WEBSOCKET_ADDRESS=<VW_IP>
-WEBSOCKET_PORT=3012
-
-# Optional: nur wenn du E-Mails (z. B. Verifizierung/Reset) willst
+# optional: SMTP, falls Mails gewünscht sind (Verifizierung/Reset)
 # SMTP_HOST=smtp.example.com
 # SMTP_FROM=pass@example.com
 # SMTP_PORT=587
@@ -163,168 +82,129 @@ WEBSOCKET_PORT=3012
 # SMTP_PASSWORD=deinPasswort
 ```

-4. **Speichern in Nano:** `Strg+O` → `Enter` → **Beenden:** `Strg+X`.
-5. **Datei schützen** (damit nur root und der Dienst lesen dürfen):
-
-```bash
-chown root:vaultwarden /etc/vaultwarden.env
-chmod 0640 /etc/vaultwarden.env
-```
-
-**Kurz erklärt:**
-
-* `DOMAIN` braucht **https**, damit Links/Icons korrekt sind.
-* `ADMIN_TOKEN` schützt das **Admin‑Backend** (ohne Token kommt man nicht rein).
-* `SIGNUPS_ALLOWED=false` verhindert **offene Registrierungen**.
-* `ROCKET_*` und `WEBSOCKET_*` sorgen dafür, dass der Dienst auf deiner **LXC‑IP** erreichbar ist und Live‑Sync funktioniert.
-
---
-
-## 4) Dienstdatei (systemd) anlegen
-
-Die Dienstdatei sagt Linux: *„So startest du Vaultwarden – und bitte automatisch beim Booten.“*
-
-1. **Datei öffnen:**
-
-```bash
-nano /etc/systemd/system/vaultwarden.service
-```
-
-2. **Inhalt einfügen:**
-
-```
-[Unit]
-Description=Vaultwarden (Bitwarden-compatible) – native
-After=network.target
-
-[Service]
-User=vaultwarden
-Group=vaultwarden
-EnvironmentFile=/etc/vaultwarden.env
-ExecStart=/opt/vaultwarden/vaultwarden
-WorkingDirectory=/var/lib/vaultwarden
-
-# Sicherheit (Dienst hat nur, was er braucht)
-LimitNOFILE=1048576
-PrivateTmp=true
-ProtectSystem=full
-ProtectHome=true
-NoNewPrivileges=true
-
-[Install]
-WantedBy=multi-user.target
-```
-
-3. **Speichern & schließen:** `Strg+O` → `Enter` → `Strg+X`.
-4. **Dienst laden, aktivieren und starten:**
-
-```bash
-systemctl daemon-reload
-systemctl enable --now vaultwarden
-systemctl status vaultwarden --no-pager
-```
-
-**Woran erkenne ich Erfolg?**
-
-* Status zeigt **active (running)**.
-* Optional: Ports prüfen
-
-```bash
-ss -tulpn | grep -E ':8000|:3012'
-```
-
-**Was haben wir gerade gemacht?**
-
-* Den Dienst **systemweit registriert** und **dauerhaft** aktiviert.
-* Vaultwarden läuft jetzt im Hintergrund – automatisch auch nach Neustarts.
-
---
-
-## 5) NPM einrichten (Proxy, WebSockets, Zertifikat)
-
-So wird deine Instanz über **HTTPS** erreichbar und **Live‑Sync** funktioniert.
-
-1. **Proxy Host anlegen**
-
-   * **Domain Names:** `pass.DEINE-DOMAIN.tld`
-   * **Scheme:** `http`
-   * **Forward Hostname / IP:** `<VW_IP>`
-   * **Forward Port:** `8000`
-   * **Block Common Exploits:** ✔️
-   * **Websockets Support:** ✔️
-
-2. **Custom Location hinzufügen**
-
-   * **Location:** `/notifications/hub`
-   * **Forward Hostname / IP:** `<VW_IP>`
-   * **Forward Port:** `3012`
-   * **Websockets Support:** ✔️
-
-3. **SSL aktivieren (Let’s Encrypt)**
-
-   * **Request a new SSL Certificate**
-   * **Force SSL**, **HTTP/2**, **HSTS**: ✔️
-
-**Test:** Rufe `https://pass.DEINE-DOMAIN.tld` im Browser auf → Loginseite sichtbar.
-
-**Was passiert hier?**
-
-* NPM nimmt Anfragen aus dem Internet an (443) und leitet sie an deinen Dienst weiter.
-* Die **Custom Location** sorgt dafür, dass der **WebSocket‑Kanal** (Live‑Sync) funktioniert.
-
---
-
-## 6) Erstkonfiguration im Browser
-
-1. **Admin‑Backend öffnen**: `https://pass.DEINE-DOMAIN.tld/admin` → **Admin‑Token** eingeben.
-2. **Registrierung prüfen**: „Signups allowed“ ist **aus** (kommt aus deiner `.env`).
-3. **Optional SMTP** eintragen und **Testmail** senden.
-4. **Erstes Benutzerkonto** anlegen und **2FA (TOTP oder FIDO2)** aktivieren.
-
+**Speichern in Nano:** `Strg+O`, `Enter` → **Beenden:** `Strg+X`.
 **Warum?**

-* So bleibt der Server **privat** (nur du legst Accounts an).
-* 2FA schützt deinen Tresor zusätzlich.
+* `DOMAIN` muss **https** sein (sonst fehlerhafte Assets/Links).
+* `ADMIN_TOKEN` schützt das Admin‑Backend.
+* `SIGNUPS_ALLOWED=false` verhindert offene Registrierungen.

---
+— — —

-## 7) Backup (Basis, schnell & sicher)
-
-Wir sichern den **Datenordner**. Damit kannst du den Tresor später wiederherstellen.
+4️⃣ `docker-compose.yml` schreiben
+Wir definieren den Container, die Ports und das Daten‑Volume.

 ```bash
-# Für maximale Konsistenz könntest du kurz stoppen (optional)
-# systemctl stop vaultwarden
+nano docker-compose.yml
+```

-tar -czf /root/vaultwarden-backup-$(date +%F).tar.gz -C /var/lib vaultwarden
-# systemctl start vaultwarden
+**Inhalt einfügen:**
+
+```yaml
+services:
+  vaultwarden:
+    image: vaultwarden/server:latest
+    container_name: vaultwarden
+    restart: unless-stopped
+    env_file: .env
+    environment:
+      - DOMAIN=${DOMAIN}
+    volumes:
+      - ./data:/data
+    ports:
+      - "8000:80"     # Web / API
+      - "3012:3012"   # WebSocket (Live Sync)
+```
+
+**Speichern:** `Strg+O`, `Enter` → `Strg+X`.
+**Warum?**
+
+* `./data:/data` sorgt für **Persistenz** auf dem Host (`/opt/vaultwarden/data`).
+* Port **8000** für Web/API und **3012** für WebSockets.
+
+— — —
+
+5️⃣ Container starten & prüfen
+
+```bash
+docker compose up -d
+docker compose logs -f --tail=50 vaultwarden
+```
+
+**Erwartet:** Meldungen wie `Rocket has launched from http://0.0.0.0:80`.
+**Warum?**
+
+* So siehst du direkt, ob der Start sauber war, bevor wir NPM konfigurieren.
+
+— — —
+
+6️⃣ NPM einrichten (Proxy, WebSockets, SSL)
+**Proxy Host anlegen:**
+
+* **Domain Names:** `pass.DEINE-DOMAIN.tld`
+* **Scheme:** `http`
+* **Forward Hostname / IP:** `<VW_IP>`
+* **Forward Port:** `8000`
+* **Block Common Exploits:** ✔️  · **Websockets Support:** ✔️
+
+**Custom Location hinzufügen:**
+
+* **Location:** `/notifications/hub`
+* **Forward Hostname / IP:** `<VW_IP>`
+* **Forward Port:** `3012`
+* **Websockets Support:** ✔️
+
+**SSL aktivieren:**
+
+* **Request a new SSL Certificate (Let’s Encrypt)**
+* **Force SSL**, **HTTP/2**, **HSTS**: ✔️
+
+**Test:** `https://pass.DEINE-DOMAIN.tld` → Loginseite sichtbar; nach Login Live‑Änderung zwischen zwei Clients testen.
+**Warum?**
+
+* Die Custom‑Location leitet den WebSocket‑Kanal korrekt weiter (Live‑Sync/Push).
+
+— — —
+
+7️⃣ Admin‑Backend & Sicherheit
+
+* Admin‑Seite: `https://pass.DEINE-DOMAIN.tld/admin` → **ADMIN\_TOKEN** eingeben.
+* **Registrierung** prüfen: ist **aus** (kommt aus `.env`).
+* Optional **SMTP** setzen und **Testmail** senden.
+* **Erstes Benutzerkonto** anlegen; **2FA** (TOTP oder FIDO2/YubiKey) aktivieren.
+  **Warum?**
+* So bleibt die Instanz privat und zusätzlich abgesichert.
+
+— — —
+
+8️⃣ Backup (Basis)
+Daten liegen auf dem Host in `/opt/vaultwarden/data`.
+
+```bash
+cd /opt/vaultwarden
+# optional für maximale Konsistenz kurz stoppen
+# docker compose stop vaultwarden
+
+tar -czf /root/vaultwarden-backup-$(date +%F).tar.gz data
+# docker compose start vaultwarden
 ls -lh /root/vaultwarden-backup-*.tar.gz
 ```

-**Wichtig:** Plane das als **Cron‑Job** ein und teste gelegentlich das **Restore** auf einer Test‑VM.
+**Warum?**

---
+* Ein Tar‑Archiv lässt sich leicht versionieren/auslagern; regelmäßige Cron‑Jobs sind schnell eingerichtet.

-## 🛠️ Wenn etwas nicht klappt
+— — —

-* **Seite lädt, aber kein Live‑Sync:** In NPM die **Custom Location** `/notifications/hub` prüfen (Port **3012**, WebSockets ✔️).
-* **Icons/Links seltsam:** In `/etc/vaultwarden.env` muss `DOMAIN` mit **https** beginnen.
-* **Ich komme nicht ins Admin‑Backend:** Stimmt das **ADMIN\_TOKEN** noch? (Zur Not neues Token in der `.env` setzen und `systemctl restart vaultwarden`.)
-* **Dienst startet nicht:**
+🛠️ Fehlerhilfe (kurz)

-  ```bash
-  journalctl -u vaultwarden -b --no-pager | tail -n 50
-  ```
+* **502 / kein Live‑Sync:** In NPM die **Custom Location** `/notifications/hub` → Port **3012** + **Websockets** prüfen.
+* **Seite ohne Styles/Icons:** In `.env` muss `DOMAIN` **https** enthalten; danach `docker compose restart vaultwarden`.
+* **Container nicht da:** `docker ps` prüfen; Logs: `docker compose logs --tail=200 vaultwarden`.
+* **Let’s‑Encrypt‑Fehler:** Domain‑DNS prüfen; Rate‑Limit beachten; später erneut anfordern.

-  Die letzten Zeilen zeigen meistens den Fehler (z. B. Tippfehler in der `.env`).
+✅ Ergebnis

---
-
-## ✅ Ergebnis
-
-* Deine Instanz ist über `https://pass.DEINE-DOMAIN.tld` erreichbar.
+* Vaultwarden läuft hinter NPM mit gültigem **HTTPS**, **Live‑Sync** funktioniert.
 * **Registrierungen sind aus**, Admin‑Backend ist durch **Token** geschützt.
-* **WebSockets** funktionieren (Live‑Sync zwischen Geräten).
-* **Backups** sind eingerichtet.
-
-> **Du hast jetzt einen schlanken, eigenen Passwort‑Server – ohne Docker‑Overhead, mit klaren Sicherungen und Updates.**
+* Deine Daten liegen persistent unter `/opt/vaultwarden/data` und werden gesichert.