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-20 09:34:22 +00:00
parent 5f0cf021ad
commit 07a30e0204
1 changed files with 194 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

269
Kapitel 6/Tutorial.md
View File

@@ -1,104 +1,179 @@
🛠️ Kapitel 6 – Vaultwarden (ohne Docker, systemd) – Tutorial 📝 Kapitel 6 – Vaultwarden (ohne Docker, systemd)
Ein Weg, ohne Alternativen. Niveau: wie Readme dieses Kapitels.
—————————— > **Blog‑Stil, Laienfreundlich, ein Weg ohne Alternativen.**
Ziel > Du führst die Befehle **genau so** aus und ersetzt nur die Platzhalter. Nach jedem Block steht, **warum** du das machst und **woran** du erkennst, dass es geklappt hat.
Vaultwarden als native Binary im Debian‑12‑LXC per systemd betreiben und hinter dem Nginx Proxy Manager veröffentlichen (HTTPS + WebSockets). Öffentliche Registrierung aus, Admin‑Token gesetzt, optional SMTP, Basis‑Backup.
Voraussetzungen ---
* LXC: Debian 12 (Bookworm), root ## 🎯 Was wir bauen (in Klartext)
* NPM in separatem LXC vorhanden (Domain + Let’s Encrypt)
* LXC‑IP von Vaultwarden: \<VW\_IP> (z. B. 10.0.0.16)
Kerneinstellungen (fix) Wir richten **Vaultwarden** als Passwort‑Tresor ein. Das ist die kompatible Server‑Variante zu Bitwarden. Du bekommst:
* **ROCKET\_ADDRESS = \<VW\_IP>** (weil NPM in separatem LXC läuft) * eine **Web‑Oberfläche** zum Verwalten deiner Passwörter und TOTP‑Codes,
* **ROCKET\_PORT = 8000** * **sichere Anmeldung** (Admin‑Token, Registrierungen aus),
* **WEBSOCKET\_ADDRESS = \<VW\_IP>**, **WEBSOCKET\_PORT = 3012** * **HTTPS** über den Nginx Proxy Manager (NPM) und
* **DOMAIN = [https://pass.DEINE‑DOMAIN.tld](https://pass.DEINE‑DOMAIN.tld)** * **Live‑Sync** dank WebSockets.
* **ADMIN\_TOKEN =** sicher, ≥ 64 Zeichen
* **SIGNUPS\_ALLOWED = false**
—————————— Wir betreiben Vaultwarden **ohne Docker** (direkt als Programm), damit es **möglichst wenig RAM** verbraucht.
1. System vorbereiten ---
## ✅ Voraussetzungen (kurz & klar)
* LXC‑Container: **Debian 12 (Bookworm)**, du bist als **root** angemeldet.
* NPM läuft (eigenes Kapitel), Domain existiert (z. B. `pass.DEINE-DOMAIN.tld`).
* Die **IP** deines Vaultwarden‑LXC (Beispiel: `10.0.0.16`).
**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.
```bash ```bash
apt update && apt upgrade -y apt update && apt upgrade -y
apt install -y ca-certificates curl unzip openssl apt install -y ca-certificates curl unzip openssl nano
# Systemnutzer ohne Login
# Dienstnutzer ohne Login anlegen (nur für den Dienst, zur Absicherung)
useradd --system --home /var/lib/vaultwarden --shell /usr/sbin/nologin vaultwarden || true useradd --system --home /var/lib/vaultwarden --shell /usr/sbin/nologin vaultwarden || true
# Verzeichnisse # Arbeits- und Datenordner anlegen
mkdir -p /opt/vaultwarden mkdir -p /opt/vaultwarden
mkdir -p /var/lib/vaultwarden/data mkdir -p /var/lib/vaultwarden/data
# Eigentum der Daten an den Dienstbenutzer übergeben (Schutz der Tresor-Daten)
chown -R vaultwarden:vaultwarden /var/lib/vaultwarden chown -R vaultwarden:vaultwarden /var/lib/vaultwarden
``` ```
Prüfen: **So prüfst du das Ergebnis:**
```bash ```bash
id vaultwarden id vaultwarden
ls -ld /opt/vaultwarden /var/lib/vaultwarden /var/lib/vaultwarden/data ls -ld /opt/vaultwarden /var/lib/vaultwarden /var/lib/vaultwarden/data
``` ```
2. Binary laden und installieren Du siehst den Benutzer `vaultwarden` und die Ordner existieren.
> Wir laden immer die **neueste** „x86\_64‑unknown‑linux‑gnu“‑Release von GitHub. ---
## 2) Vaultwarden herunterladen (immer aktuelle stabile Version)
Wir installieren **immer die neuste stabile Release** direkt von der offiziellen Quelle. So sind **Sicherheitsfixes** sofort enthalten.
```bash ```bash
# 1) Download-URL der neuesten stabilen Release automatisch ermitteln
VW_URL=$(curl -s https://api.github.com/repos/dani-garcia/vaultwarden/releases/latest \ VW_URL=$(curl -s https://api.github.com/repos/dani-garcia/vaultwarden/releases/latest \
| grep browser_download_url \ | grep browser_download_url \
| grep x86_64-unknown-linux-gnu.tar.gz \ | grep x86_64-unknown-linux-gnu.tar.gz \
| cut -d '"' -f 4) | cut -d '"' -f 4)
# 2) Archiv herunterladen und entpacken
curl -L "$VW_URL" -o /tmp/vaultwarden.tar.gz curl -L "$VW_URL" -o /tmp/vaultwarden.tar.gz
mkdir -p /tmp/vw && tar -xzf /tmp/vaultwarden.tar.gz -C /tmp/vw mkdir -p /tmp/vw && tar -xzf /tmp/vaultwarden.tar.gz -C /tmp/vw
# 3) Programmdatei nach /opt verschieben (wird unser fester Pfad)
install -m 0755 /tmp/vw/vaultwarden /opt/vaultwarden/vaultwarden install -m 0755 /tmp/vw/vaultwarden /opt/vaultwarden/vaultwarden
``` ```
Prüfen: **Woran erkenne ich Erfolg?**
```bash ```bash
/opt/vaultwarden/vaultwarden --version || true /opt/vaultwarden/vaultwarden --version || true
``` ```
3. Konfiguration anlegen Du siehst die **Version** der frisch installierten Release.
**Warum so? (Laienfreundlich)**
* „Neuste stabile Release“ = **aktuelle Sicherheitsfixes** ohne Wartezeit.
* Wir holen die Datei **direkt** von der offiziellen Projektseite.
* Der Pfad `/opt/vaultwarden/` bleibt gleich – **Updates** sind später nur „Datei tauschen + Dienst neu starten“.
> 🔐 **Sicherheits‑Hinweis:** Wenn die Release‑Seite einen **SHA256‑Wert** angibt, kannst du ihn optional prüfen: `sha256sum /tmp/vaultwarden.tar.gz` ausführen und den Wert mit dem auf der Release‑Seite **visuell vergleichen**.
> 🆙 **Aktualisieren später:** Wiederhole **genau diesen Schritt** (die drei Befehle oben) und starte den Dienst neu: `systemctl restart vaultwarden`. Wenn sich seitdem Oberflächen/Optionen geändert haben, ergänzen wir im Video einen Hinweis und **aktualisieren diesen Blog‑Post**.
---
## 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):
```bash ```bash
cat >/etc/vaultwarden.env <<'EOF' openssl rand -base64 48
```
2. **Datei mit Nano öffnen:**
```bash
nano /etc/vaultwarden.env
```
3. **Folgenden Inhalt einfügen** und **Platzhalter ersetzen**:
```
DOMAIN=https://pass.DEINE-DOMAIN.tld DOMAIN=https://pass.DEINE-DOMAIN.tld
ADMIN_TOKEN=$(openssl rand -base64 48) ADMIN_TOKEN=HIER_DEIN_ERZEUGTES_TOKEN_EINFÜGEN
SIGNUPS_ALLOWED=false SIGNUPS_ALLOWED=false
WEBSOCKET_ENABLED=true WEBSOCKET_ENABLED=true
# Der Dienst lauscht auf der IP deines LXC (so erreicht NPM ihn)
ROCKET_ADDRESS=<VW_IP> ROCKET_ADDRESS=<VW_IP>
ROCKET_PORT=8000 ROCKET_PORT=8000
# WebSocket-Endpunkt für Live-Sync
WEBSOCKET_ADDRESS=<VW_IP> WEBSOCKET_ADDRESS=<VW_IP>
WEBSOCKET_PORT=3012 WEBSOCKET_PORT=3012
# Optional SMTP
# Optional: nur wenn du E-Mails (z. B. Verifizierung/Reset) willst
# 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
# SMTP_SECURITY=starttls # SMTP_SECURITY=starttls
# SMTP_USERNAME=user # SMTP_USERNAME=user
# SMTP_PASSWORD=deinPasswort # SMTP_PASSWORD=deinPasswort
EOF ```
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 chown root:vaultwarden /etc/vaultwarden.env
chmod 0640 /etc/vaultwarden.env chmod 0640 /etc/vaultwarden.env
``` ```
Prüfen: **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 ```bash
grep -E '^(DOMAIN|ROCKET_ADDRESS|WEBSOCKET_ADDRESS)=' /etc/vaultwarden.env nano /etc/systemd/system/vaultwarden.service
``` ```
4. systemd‑Service erstellen 2. **Inhalt einfügen:**
```bash ```
cat >/etc/systemd/system/vaultwarden.service <<'EOF'
[Unit] [Unit]
Description=Vaultwarden (Bitwarden-compatible) – native Description=Vaultwarden (Bitwarden-compatible) – native
After=network.target After=network.target
@@ -109,7 +184,8 @@ Group=vaultwarden
EnvironmentFile=/etc/vaultwarden.env EnvironmentFile=/etc/vaultwarden.env
ExecStart=/opt/vaultwarden/vaultwarden ExecStart=/opt/vaultwarden/vaultwarden
WorkingDirectory=/var/lib/vaultwarden WorkingDirectory=/var/lib/vaultwarden
# Hardening (schlank & sicher)
# Sicherheit (Dienst hat nur, was er braucht)
LimitNOFILE=1048576 LimitNOFILE=1048576
PrivateTmp=true PrivateTmp=true
ProtectSystem=full ProtectSystem=full
@@ -118,75 +194,118 @@ NoNewPrivileges=true
[Install] [Install]
WantedBy=multi-user.target WantedBy=multi-user.target
EOF ```
3. **Speichern & schließen:** `Strg+O` → `Enter` → `Strg+X`.
4. **Dienst laden, aktivieren und starten:**
```bash
systemctl daemon-reload systemctl daemon-reload
systemctl enable --now vaultwarden systemctl enable --now vaultwarden
systemctl status vaultwarden --no-pager systemctl status vaultwarden --no-pager
``` ```
Prüfen (sollte „active (running)“ sein): **Woran erkenne ich Erfolg?**
* Status zeigt **active (running)**.
* Optional: Ports prüfen
```bash ```bash
ss -tulpn | grep -E ':8000|:3012' ss -tulpn | grep -E ':8000|:3012'
``` ```
5. NPM: Proxy‑Host + WebSockets + SSL **Was haben wir gerade gemacht?**
* **Hosts → Proxy Hosts → Add Proxy Host** * Den Dienst **systemweit registriert** und **dauerhaft** aktiviert.
* Vaultwarden läuft jetzt im Hintergrund – automatisch auch nach Neustarts.
* Domain Names: `pass.DEINE-DOMAIN.tld` ---
* Scheme: http
* Forward Hostname / IP: **\<VW\_IP>**
* Forward Port: **8000**
* Block Common Exploits: an
* Websockets Support: an
* **Custom Locations → Add Location**
* Location: **/notifications/hub** ## 5) NPM einrichten (Proxy, WebSockets, Zertifikat)
* Forward Hostname / IP: **\<VW\_IP>**
* Forward Port: **3012**
* Websockets Support: an
* **SSL**
* Request a new SSL Certificate (Let’s Encrypt) So wird deine Instanz über **HTTPS** erreichbar und **Live‑Sync** funktioniert.
* Force SSL, HTTP/2, HSTS: an
Prüfen: 1. **Proxy Host anlegen**
* `https://pass.DEINE-DOMAIN.tld` öffnet die Login‑Seite. * **Domain Names:** `pass.DEINE-DOMAIN.tld`
* WebSocket: Eintrag von einem zweiten Client ändern → Live‑Sync sichtbar. * **Scheme:** `http`
* **Forward Hostname / IP:** `<VW_IP>`
* **Forward Port:** `8000`
* **Block Common Exploits:** ✔️
* **Websockets Support:** ✔️
6. Erstkonfiguration (Web‑UI) 2. **Custom Location hinzufügen**
* Admin‑Backend: `https://pass.DEINE-DOMAIN.tld/admin` → **ADMIN\_TOKEN** eingeben. * **Location:** `/notifications/hub`
* **Signups**: „Signups allowed“ **aus**. * **Forward Hostname / IP:** `<VW_IP>`
* Optional **SMTP** eintragen (Testmail senden). * **Forward Port:** `3012`
* Erstes Benutzerkonto anlegen und **2FA (TOTP/FIDO2)** aktivieren. * **Websockets Support:** ✔️
7. Backup (Basis) 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.
**Warum?**
* So bleibt der Server **privat** (nur du legst Accounts an).
* 2FA schützt deinen Tresor zusätzlich.
---
## 7) Backup (Basis, schnell & sicher)
Wir sichern den **Datenordner**. Damit kannst du den Tresor später wiederherstellen.
```bash ```bash
# Kurzvariante (läuft online); für 100% Konsistenz ggf. Dienst kurz stoppen # Für maximale Konsistenz könntest du kurz stoppen (optional)
# systemctl stop vaultwarden # systemctl stop vaultwarden
tar -czf /root/vaultwarden-backup-$(date +%F).tar.gz -C /var/lib vaultwarden tar -czf /root/vaultwarden-backup-$(date +%F).tar.gz -C /var/lib vaultwarden
# systemctl start vaultwarden # systemctl start vaultwarden
ls -lh /root/vaultwarden-backup-*.tar.gz ls -lh /root/vaultwarden-backup-*.tar.gz
``` ```
Cron‑Hinweis: Regelmäßig sichern; Restore testweise separat prüfen. **Wichtig:** Plane das als **Cron‑Job** ein und teste gelegentlich das **Restore** auf einer Test‑VM.
—————————— ---
Stolperfallen
* **ROCKET\_/WEBSOCKET\_ADDRESS falsch** → NPM erreicht den Dienst nicht. ## 🛠️ Wenn etwas nicht klappt
* **WebSockets nicht weitergeleitet** → Live‑Sync/Push funktioniert nicht.
* **DOMAIN nicht https** → fehlerhafte Links/Icons.
* **ADMIN\_TOKEN zu kurz/unsicher** → Risiko fürs Admin‑Backend.
* **Signups offen** → ungewollte Accounts.
Ergebnis * **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:**
* Vaultwarden läuft nativ im LXC, ist über `https://pass.DEINE-DOMAIN.tld` erreichbar, WebSockets funktionieren, Registrierungen sind aus, Admin‑Backend ist geschützt; Backups vorhanden. ```bash
journalctl -u vaultwarden -b --no-pager | tail -n 50
```
Die letzten Zeilen zeigen meistens den Fehler (z. B. Tippfehler in der `.env`).
---
## ✅ Ergebnis
* Deine Instanz ist über `https://pass.DEINE-DOMAIN.tld` erreichbar.
* **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.**