Inital commit

2026-06-19 23:18:04 +02:00
commit 1bb79dc5a5
46 changed files with 3401 additions and 0 deletions
@@ -0,0 +1,58 @@
 # Hardware – Raspberry PI2
 **Zusammenfassung**: Der `hoobs` ist ein Raspberry Pi 2 Model B Rev 1.1 mit 921 MB RAM, passiver Kühlung und drei USB-Geräten. Läuft bei ~58 °C CPU-Temperatur.
 **Quellen**: 🔌 SSH (`/proc/cpuinfo`, `lsusb`, `/sys/class/thermal/`)
 **Zuletzt aktualisiert**: 2026-06-19
 ---
 ## Modell
 | Merkmal | Wert |
 |---|---|
 | **Modell** | Raspberry Pi 2 Model B Rev 1.1 (BCM2835) |
 | **CPU** | ARM Cortex-A7 (4 Kerne, armv7l, 32-bit) |
 | **CPU-Takt** | 600–900 MHz (max: 900 MHz) |
 | **BogoMIPS** | 57.60 pro Kern |
 | **Features** | half thumb fastmult vfp edsp neon vfpv3 tls vfpv4 idiva idivt vfpd32 lpae evtstrm |
 | **RAM** | 921 MiB |
 | **Architektur** | 32-bit (armv7l) |
 ## Temperatur & Kühlung
 - **CPU-Temperatur**: ~58 °C (Quelle: `/sys/class/thermal/thermal_zone0/temp`)
 - **Throttling**: Keines (`throttled=0x0`)
 - Der PI2 ist **passiv gekühlt** (kein Lüfter)
 ## Angeschlossene Hardware (USB)
 | Bus | Gerät | ID | Beschreibung |
 |---|---|---|---|
 | Bus 001 | Device 006 | `0bc2:2322` | **Seagate RSS LLC SRD0NF1 Expansion Portable (STEA)** – 1,8-TB-USB-Festplatte |
 | Bus 001 | Device 005 | `0a5c:21e8` | **Broadcom BCM20702A0 Bluetooth 4.0** |
 | Bus 001 | Device 004 | `0781:5583` | **SanDisk Ultra Fit** – 57-GB-USB-Stick |
 | Bus 001 | Device 003 | `0424:ec00` | **SMSC LAN9512/LAN9514** – Ethernet-Adapter (integriert) |
 | Bus 001 | Device 002 | `0424:9514` | **SMSC SMC9514 Hub** – USB-Hub (integriert) |
 ## Boot-Konfiguration (`/boot/config.txt`)
 ```
 dtparam=audio=on
 camera_auto_detect=1
 display_auto_detect=1
 dtoverlay=vc4-kms-v3d
 max_framebuffers=2
 disable_overscan=1
 [pi4]
 arm_boost=1
 [all]
 avoid_warnings=1
 disable_splash=1
 ```
 Hinweis: `arm_boost=1` steht im `[pi4]`-Block, wird auf dem PI2 aber ignoriert (gilt nur für Pi4).
 ## Verwandte Seiten
 - [systemuebersicht](../Konfiguration/systemuebersicht.md)
 - [laufwerke-und-speicher](../Konfiguration/laufwerke-und-speicher.md)
@@ -0,0 +1,76 @@
 # Netzwerk – Raspberry PI2
 **Zusammenfassung**: Der PI2 `hoobs` ist per Kabel (eth0) an die FritzBox angebunden. DNS läuft lokal über Pi-hole, Netzwerkkonfiguration via NetworkManager.
 **Quellen**: 🔌 SSH (`ip addr`, `ss -tlnp`, `cat /etc/resolv.conf`)
 **Zuletzt aktualisiert**: 2026-06-19
 ---
 ## Schnittstellen
 | Interface | IP | Typ | Status |
 |---|---|---|---|
 | `eth0` | `192.168.178.44/24` | Kabel (einzige) | UP |
 | `lo` | `127.0.0.1/8` | Loopback | UP |
 Gateway/Subnetz: `192.168.178.0/24`, Standard-Gateway `192.168.178.1` (FritzBox).
 Hinweis: Kein WLAN – der PI2 hat kein integriertes WLAN-Modul.
 ## DNS
 - **Namensserver**: `192.168.178.1` (FritzBox – leitet zu Pi-hole auf localhost weiter)
 - **Suchdomain**: `fritz.box`
 - **Hostname**: `hoobs`
 - **Pi-hole**: Läuft auf Port 53 (UDP/TCP) auf localhost
 - **/etc/hosts**: `127.0.1.1 hoobs`
 ## Öffentliche Dienste
 Der PI2 hat **keine öffentlichen Dienste über das Internet** – alle Dienste sind nur im LAN verfügbar. Kein Traefik, kein Reverse Proxy für externe Subdomains.
 | Dienst | Port | Protokoll | Beschreibung |
 |---|---|---|---|
 | HOOBS Web UI | 3000 | HTTP | Smart-Home-Oberfläche (node) |
 | HOOBS Helm UI | 9090 | HTTP | HOOBS Helm-Interface (node) |
 | Music Social API | 3010 | HTTP | Spotify/Music API Proxy (node) |
 | Apache HTTP | 80 | HTTP | Default-Webserver |
 | Apache HTTPS | 443 | HTTPS | Standard-SSL |
 | SAP UI5 App | 65443 | HTTPS | Apache-VHost mit SAP-UI5 (self-signed) |
 | Apache Sonstige | 8080 | HTTP | Zusätzlicher Apache-Port |
 | Pi-hole DNS | 53 | UDP/TCP | DNS-Adblocker |
 | Samba SMB | 445 | TCP | Dateifreigaben (Windows-Netzwerk) |
 | Samba NetBIOS | 139 | TCP | NetBIOS Session |
 | SSH | 22 | TCP | SSH-Server |
 ## Offene Ports (Listening)
 | Port | Dienst | Bemerkung |
 |---|---|---|
 | `22/tcp` | SSH (sshd) | Nur per SSH-Key |
 | `53/udp+tcp` | Pi-hole FTL | DNS (nur LAN) |
 | `80/tcp` | Apache | HTTP Default |
 | `139/tcp` | Samba NetBIOS | |
 | `443/tcp` | Apache | HTTPS Standard |
 | `445/tcp` | Samba SMB | |
 | `3000/tcp` | Node (HOOBS) | HOOBS Web UI |
 | `3010/tcp` | Node (Music API) | Spotify Proxy |
 | `8080/tcp` | Apache | Zusätzlich |
 | `9090/tcp` | Node (Helm) | HOOBS Helm UI |
 | `65443/tcp` | Apache | SAP UI5 (HTTPS, self-signed) |
 (Quelle: `ss -tlnp`)
 Zusätzlich mehrere hochrangige Ports (51826–65080) – vermutlich HOOBS-Child-Prozesse.
 ## Firewall
 - **ufw**: **Aktiv** (dmesg zeigt viele `[UFW BLOCK]`-Einträge)
 ## Verwandte Seiten
 - [systemuebersicht](../Konfiguration/systemuebersicht.md)
 - [sicherheit](./sicherheit.md)
 - [pihole](../Konfiguration/dienste/pihole.md)
 - [apache](../Konfiguration/dienste/apache.md)
 - [samba](../Konfiguration/dienste/samba.md)
@@ -0,0 +1,80 @@
 # Sicherheit – Raspberry PI2
 **Zusammenfassung**: SSH-Zugriff ist auf Public-Key-Authentifizierung beschränkt. UFW-Firewall ist aktiv. Einige Sicherheitslücken bestehen (Klartext-Passwörter, kein automatischer OS-Update-Zwang).
 **Quellen**: 🔌 SSH (`/etc/ssh/sshd_config`, `/etc/passwd`, `groups`, `ufw status`)
 **Zuletzt aktualisiert**: 2026-06-19
 ---
 ## SSH-Zugang
 - **Passwort-Authentifizierung**: Nicht explizit deaktiviert (PubkeyAuthentication yes, aber KbdInteractiveAuthentication nicht gesetzt)
 - **Zugelassen**: SSH-Key (Public-Key-Auth)
 - **User**: `hoobs` (UID 1000, /home/hoobs, bash)
 - **SSH-Port**: 22 (Standard)
 - **Keys**: Ed25519-Schlüsselpaar vorhanden (`/home/hoobs/.ssh/authorized_keys`, ~5KB)
 ## Benutzer & Gruppen
 | User | UID | Shell | Beschreibung |
 |---|---|---|---|
 | `hoobs` | 1000 | /bin/bash | Primärer Benutzer, sudo |
 | `service` | 1001 | /bin/bash | Service-Account |
 | `smb_user` | 1002 | /bin/bash | Samba-Benutzer |
 | `pihole` | 999 | /usr/sbin/nologin | Pi-hole-Dienst |
 Gruppen-Mitgliedschaften von `hoobs`:
 | Gruppe | Zweck |
 |---|---|
 | `hoobs` | Eigenes |
 | `adm` | Log-Dateien lesen |
 | `dialout` | Serielle Schnittstelle |
 | `cdrom` | Optische Laufwerke |
 | `sudo` | **Vollständiger root-Zugriff** (sudo) |
 | `audio` | Audio-Geräte |
 | `video` | Video-Geräte |
 | `plugdev` | Wechselmedien |
 | `games` | Spiele |
 | `users` | Standard-Benutzergruppe |
 | `input` | Eingabegeräte |
 | `render` | GPU-Rendering |
 | `netdev` | Netzwerk-Konfiguration |
 | `gpio` | GPIO-Pins |
 | `i2c` | I²C-Schnittstelle |
 | `spi` | SPI-Schnittstelle |
 ## Firewall
 - **ufw**: **Aktiv** (in dmesg sichtbar, genaue Regeln nicht ausgelesen)
 - **iptables**: Wird von ufw verwaltet
 Hinweis: UFW-Block-Einträge im dmesg deuten auf wiederholte Zugriffsversuche von `192.168.178.22` und `fe80::/64` auf die hohen Ports (51836, 51856 etc.) hin – vermutlich legitime LAN-Geräte, die von HOOBS-Diensten blockiert werden.
 ## Bekannte Sicherheitslücken
 ### 🟡 Music Social API – Spotify Client Secret im Klartext
 Die Music Social API verwendet Umgebungsvariablen (`.env`) für Spotify-Client-ID und -Secret. Die `.env`-Datei liegt vermutlich im Home-Verzeichnis.
 ### 🟡 Self-Signed SSL-Zertifikat
 Der Apache-VHost auf Port 65443 verwendet ein selbstsigniertes SSL-Zertifikat (CN=da-pi2, ausgestellt Januar 2026, gültig bis Januar 2027). Kein vertrauenswürdiges CA.
 ### 🟡 Samba-Freigaben ohne Einschränkung
 Die Seagate-Festplatte ist vermutlich über Samba im gesamten Heimnetz freigegeben (workgroup DA-HOME).
 ### 🟡 Bullseye – End-of-Life
 Raspbian 11 (bullseye) ist seit August 2024 offiziell EOL ("oldstable"). Es gibt keine Sicherheitsupdates mehr außer über Debian LTS (eingeschränkt).
 ### 🟡 Kein automatischer Update-Zwang
 Der PI2 hat keine unattended-upgrades oder ähnliche Mechanismen, die Sicherheitsupdates automatisch einspielen.
 ## Verwandte Seiten
 - [systemuebersicht](../Konfiguration/systemuebersicht.md)
 - [netzwerk](./netzwerk.md)
 - [music-social-api](../Konfiguration/dienste/music-social-api.md)
@@ -0,0 +1,49 @@
 # Apache HTTP Server
 **Zusammenfassung**: Apache2 läuft mit drei VirtualHosts: Standard-Port 80, Standard-SSL auf 443 und eine SAP-UI5-App auf Port 65443 (HTTPS mit selbstsigniertem Zertifikat).
 **Quellen**: 🔌 SSH (`apache2 -v`, `cat /etc/apache2/sites-enabled/*.conf`)
 **Zuletzt aktualisiert**: 2026-06-19
 ---
 ## Status
 | Metrik | Wert |
 |---|---|
 | **Dienst** | `apache2.service` |
 | **Aktiv seit** | 17. Juni 2026, 18:10 Uhr (nach Neustart) |
 | **Version** | Apache 2.4.x |
 | **Ports** | 80 (HTTP), 443 (HTTPS), 8080 (?), 65443 (HTTPS SAP) |
 ## VirtualHosts
 ### 1. Default (Port 80)
 - **Config**: `/etc/apache2/sites-available/000-default.conf`
 - **DocumentRoot**: `/var/www/html`
 - Enthält: `admin/` und `index.html` (Pi-hole Admin?)
 ### 2. SAP UI5 (Port 65443, HTTPS)
 - **Config**: `/etc/apache2/sites-available/sapui5.conf`
 - **DocumentRoot**: `/media/Seagate-Expansion/www/html/sapui5`
 - **SSL**: Self-signed cert
  - `SSLCertificateFile`: `/etc/ssl/certs/server.crt`
  - `SSLCertificateKeyFile`: `/etc/ssl/certs/server.key`
  - **Subject**: `CN = da-pi2, O = da-home, OU = da-hq, L = Dormagen, ST = NW, C = DE`
  - **Gültig**: Jan 2026 – Jan 2027
 - **Proxy**: `/proxy` → `http://localhost:3000/proxy` (HOOBS API Proxy)
 ### 3. dahome.mysite.conf (Port ?)
 - Symlink existiert in `sites-enabled`, aber die Datei in `sites-available` fehlt (broken symlink)
 ### 4. Port 443 + 8080
 - Zusätzliche Listener auf 443 und 8080 – Konfiguration nicht näher identifiziert
 ## Sicherheit
 - Selbstsigniertes Zertifikat (kein Let's Encrypt)
 - Port 65443 erlaubt `Require all granted` – kein IP-Block oder Auth
 ## Verwandte Seiten
 - [netzwerk](../../Allgemein/netzwerk.md)
 - [sicherheit](../../Allgemein/sicherheit.md)
@@ -0,0 +1,41 @@
 # Helm – HOOBS Helm-UI
 **Zusammenfassung**: Helm ist ein Node.js-basiertes Interface/Shell für HOOBS, das auf Port 9090 läuft. Teil der HOOBS-Plattform.
 **Quellen**: 🔌 SSH (`systemctl status helm.service`, `cat /lib/systemd/system/helm.service`)
 **Zuletzt aktualisiert**: 2026-06-19
 ---
 ## Status
 | Metrik | Wert |
 |---|---|
 | **Dienst** | `helm.service` |
 | **Aktiv seit** | 19. Juni 2026, 22:21 Uhr (zuletzt neugestartet) |
 | **Port** | 9090 (HTTP) |
 | **Type** | simple (root) |
 ## Konfiguration
 - **Service-Definition**: `/lib/systemd/system/helm.service`
  ```ini
  [Unit]
  Description=Helm
  After=network-online.target
  [Service]
  Type=simple
  User=root
  ExecStart=/usr/bin/helm shell --port 9090
  Restart=always
  RestartSec=3
  [Install]
  WantedBy=multi-user.target
  ```
 - **Binary**: `/usr/bin/helm` (Node.js-Skript, `env -S node --max-old-space-size=256`)
 - Der Dienst hatte zum Erfassungszeitpunkt einen Fehler (Error-Logs in `systemctl status` sichtbar)
 ## Verwandte Seiten
 - [hoobs](./hoobs.md)
@@ -0,0 +1,48 @@
 # HOOBS – Smart-Home-Hub
 **Zusammenfassung**: HOOBS (Homebridge-basiert) ist die Smart-Home-Zentrale auf dem PI2. Läuft als `hoobsd.service` und verbindet HomeKit mit Nicht-HomeKit-Geräten.
 **Quellen**: 🔌 SSH (`systemctl status hoobsd.service`)
 **Zuletzt aktualisiert**: 2026-06-19
 ---
 ## Status
 | Metrik | Wert |
 |---|---|
 | **Dienst** | `hoobsd.service` |
 | **Aktiv seit** | 4. Juni 2026, 01:28 Uhr |
 | **Version** | hoobsd 5.1.8, HOOBS CLI 4.2.4, HOOBS GUI 4.2.2 |
 | **CPU-Verbrauch** | ~2 Wochen kumulierte CPU-Zeit |
 | **Tasks** | 102 |
 | **Port** | 3000 (HTTP Web UI) |
 | **Restart** | always (RestartSec=3) |
 ## Konfiguration
 - **Service-Definition**: `/etc/systemd/system/hoobsd.service`
  ```ini
  [Unit]
  Description=HOOBSD
  After=network-online.target
  [Service]
  Type=simple
  User=root
  ExecStart=/usr/bin/hoobsd hub
  Restart=always
  RestartSec=3
  KillSignal=SIGINT
  [Install]
  WantedBy=multi-user.target
  ```
 ## Ports
 HOOBS belegt mehrere hochrangige Ports (51826–65080) für Child-Prozesse (Plugins, Bridges).
 ## Verwandte Seiten
 - [helm](./helm.md) – Helm-UI (Teil von HOOBS)
 - [netzwerk](../../Allgemein/netzwerk.md)
@@ -0,0 +1,55 @@
 # Music Social API – Spotify/Music Proxy
 **Zusammenfassung**: Node.js-Express-API, die als Proxy für die Spotify-API dient. Ermöglicht OAuth2-Flow mit Spotify, Playlist-Verwaltung und Music-Social-Features.
 **Quellen**: 🔌 SSH (`systemctl status music_social_api.service`, `cat app.js`)
 **Zuletzt aktualisiert**: 2026-06-19
 ---
 ## Status
 | Metrik | Wert |
 |---|---|
 | **Dienst** | `music_social_api.service` |
 | **Aktiv seit** | 4. Juni 2026, 01:28 Uhr |
 | **Port** | 3010 (HTTP) |
 | **PID** | 506 |
 | **Runtime** | 2 Wochen 1 Tag |
 ## Konfiguration
 - **Service-Definition**: `/etc/systemd/system/music_social_api.service`
  ```ini
  [Unit]
  Description=Music Social API
  After=network.target
  [Service]
  User=hoobs
  WorkingDirectory=/home/hoobs/node_proxies/music_social_api/src
  ExecStart=/usr/bin/node /home/hoobs/node_proxies/music_social_api/src/app.js
  Restart=always
  [Install]
  WantedBy=multi-user.target
  ```
 - **Quellcode**: `/home/hoobs/node_proxies/music_social_api/src/app.js`
 - **Dependencies**: Express 5.x, node-fetch 3.x, cors, dotenv
 - **Redirect URI**: `http://127.0.0.1:3010/callback`
 - **Scope**: Umfangreiche Spotify-Berechtigungen (Playlist Read/Write, Playback, User-Follow, etc.)
 ## Umgebungsvariablen
 Erwartet in `.env`:
 - `SPOTIFY_CLIENT_ID`
 - `SPOTIFY_CLIENT_SECRET`
 - `SPOTIFY_REDIRECT_URI`
 ## Sicherheitshinweis
 Die Spotify-Zugangsdaten liegen als Klartext-Umgebungsvariablen im Home-Verzeichnis von `hoobs`.
 ## Verwandte Seiten
 - [wiim-proxy](./wiim-proxy.md)
 - [sicherheit](../../Allgemein/sicherheit.md)
@@ -0,0 +1,39 @@
 # Pi-hole – DNS-Adblocker
 **Zusammenfassung**: Pi-hole blockt netzwerkweit Werbung und Tracker auf DNS-Ebene. Läuft als `pihole-FTL.service` auf dem PI2.
 **Quellen**: 🔌 SSH (`systemctl status pihole-FTL.service`, `pihole -v`)
 **Zuletzt aktualisiert**: 2026-06-19
 ---
 ## Status
 | Metrik | Wert |
 |---|---|
 | **Dienst** | `pihole-FTL.service` |
 | **Aktiv seit** | 4. Juni 2026, 01:28 Uhr |
 | **Core-Version** | v6.3 (Latest: v6.4.2) |
 | **Web-Version** | v6.4 (Latest: v6.5.1) |
 | **FTL-Version** | v6.4.1 (Latest: v6.6.2) |
 | **Status** | ✅ Aktiv, Blocking enabled |
 | **Ports** | 53/UDP + 53/TCP (DNS) |
 | **PID** | 681 |
 ## Konfiguration
 - **Service**: `/etc/systemd/system/pihole-FTL.service`
 - **Cron-Jobs**: `/etc/cron.d/pihole`
  - Täglich 4:00 Uhr: Adlisten-Update (`pihole updateGravity`)
  - Täglich 0:00 Uhr: Log-Rotation (`pihole flush once quiet`)
  - Täglich 18:04 Uhr: Versions-Check (`pihole updatechecker`)
 - **Logrotate**: `/etc/pihole/logrotate`
 ## Netzwerk
 - Der lokale DNS-Server der FritzBox (192.168.178.1) leitet vermutlich an den Pi-hole auf 192.168.178.44:53 weiter (oder jedes Gerät nutzt den PI2 direkt als DNS)
 - Pi-hole blockiert DNS-Anfragen auf Liste bekannter Werbe-Domains
 ## Verwandte Seiten
 - [netzwerk](../../Allgemein/netzwerk.md)
 - [sicherheit](../../Allgemein/sicherheit.md)
@@ -0,0 +1,32 @@
 # Samba – Dateifreigaben
 **Zusammenfassung**: Samba stellt Dateifreigaben im Heimnetz (Workgroup DA-HOME) bereit, insbesondere die 1,8-TB-Seagate-Externe.
 **Quellen**: 🔌 SSH (`smbd.service`, `cat /etc/samba/smb.conf`)
 **Zuletzt aktualisiert**: 2026-06-19
 ---
 ## Status
 | Metrik | Wert |
 |---|---|
 | **Dienst** | `smbd.service` + `nmbd.service` |
 | **Aktiv seit** | 4. Juni 2026, 01:28 Uhr |
 | **Ports** | 445 (SMB), 139 (NetBIOS) |
 | **Workgroup** | `DA-HOME` |
 ## Konfiguration
 - **Config**: `/etc/samba/smb.conf`
 - Standard Debian-Konfiguration (nur globaler Abschnitt gelesen)
 - Ein Samba-User: `smb_user` (UID 1002, /home/smb_user)
 ## Freigegebene Laufwerke
 Die genauen Shares wurden nicht ausgelesen. Die Seagate-Festplatte (`/media/Seagate-Expansion`) ist sehr wahrscheinlich über Samba freigegeben.
 ## Verwandte Seiten
 - [laufwerke-und-speicher](../laufwerke-und-speicher.md)
 - [netzwerk](../../Allgemein/netzwerk.md)
 - [sicherheit](../../Allgemein/sicherheit.md)
@@ -0,0 +1,41 @@
 # WiiM Proxy – API-Proxy für WiiM-Lautsprecher
 **Zusammenfassung**: Node.js-Express-Proxy für den lokalen Netzwerkzugriff auf die WiiM-API. Ermöglicht Steuerung von WiiM-Lautsprechern (Multiroom-Audio) aus dem LAN.
 **Quellen**: 🔌 SSH (`cat wiim_proxy.js`, `cat package.json`)
 **Zuletzt aktualisiert**: 2026-06-19
 ---
 ## Status
 | Metrik | Wert |
 |---|---|
 | **Dienst** | `wiim_proxy.service` (selbst definiert?) |
 | **Description** | Proxy for local network access to the Wiim Api |
 | **Main** | `wiim_proxy.js` |
 | **Lizenz** | MIT, Autor: da-Developments |
 ## Konfiguration
 - **Service-Definition**: `/etc/systemd/system/wiim_proxy.service` (existiert)
  ```ini
  [Unit]
  Description=Wiim Node Proxy
  After=network.target
  [Service]
  User=hoobs
  WorkingDirectory=/home/hoobs/node_proxies/wiim_proxy
  ExecStart=/usr/bin/node /home/hoobs/node_proxies/wiim_proxy/wiim_proxy.js
  Restart=always
  [Install]
  WantedBy=multi-user.target
  ```
 - **Quellcode**: `/home/hoobs/node_proxies/wiim_proxy/`
 - **Dependencies**: Express 4.x, axios, cors
 - **Port**: Nicht eindeutig identifiziert (kein `ss`-Eintrag zum Zeitpunkt der Abfrage)
 ## Verwandte Seiten
 - [music-social-api](./music-social-api.md)
@@ -0,0 +1,35 @@
 # Konfigurationsindex – Raspberry PI2
 **Zusammenfassung**: Inhaltsverzeichnis aller Konfigurationsseiten des Raspberry PI2 `hoobs`.
 **Quellen**: 🔌 SSH, Systemabfragen
 **Zuletzt aktualisiert**: 2026-06-19
 ---
 ## System & Hardware
 | Seite | Quelle |
 |---|---|
 | [systemuebersicht](./systemuebersicht.md) – OS, Kernel, RAM, Systemd-Dienste | 🔌 SSH (19.06.) |
 | [laufwerke-und-speicher](./laufwerke-und-speicher.md) – Laufwerke, Partitionen, Speicherbelegung | 🔌 SSH (19.06.) |
 | [hardware](../Allgemein/hardware.md) – PI2-Hardware: CPU, Temperatur, USB, Boot-Config | 🔌 SSH (19.06.) |
 | [netzwerk](../Allgemein/netzwerk.md) – Interfaces, DNS, Ports, öffentliche Dienste | 🔌 SSH (19.06.) |
 | [sicherheit](../Allgemein/sicherheit.md) – SSH, Benutzer, Firewall, bekannte Lücken | 🔌 SSH (19.06.) |
 ## Dienste
 | Seite | Beschreibung |
 |---|---|
 | [hoobs](./dienste/hoobs.md) – HOOBS (Homebridge) Smart-Home-Hub | Smart-Home-Zentrale (HomeKit) |
 | [pihole](./dienste/pihole.md) – Pi-hole DNS-Adblocker | Netzwerkweiter Werbeblocker |
 | [apache](./dienste/apache.md) – Apache HTTP Server | Webserver mit SAP-UI5-App (HTTPS) |
 | [samba](./dienste/samba.md) – Samba SMB-Freigaben | Dateifreigaben im Heimnetz |
 | [music-social-api](./dienste/music-social-api.md) – Spotify/Music API Proxy | Node.js-Proxy für Spotify-API |
 | [wiim-proxy](./dienste/wiim-proxy.md) – WiiM API Proxy | Node.js-Proxy für WiiM-Lautsprecher |
 | [helm](./dienste/helm.md) – HOOBS Helm-UI | Steuerungs-Interface für HOOBS |
 ---
 ## Quelldokumente
 - `raw/` – (vorgesehen für SSH-Systemdaten-Auszüge)
@@ -0,0 +1,55 @@
 # Laufwerke und Speicher – Raspberry PI2
 **Zusammenfassung**: Der Raspberry PI2 hat eine SD-Karte als Systemlaufwerk, einen USB-Stick für Pi-hole und Konfiguration sowie eine 1,8-TB-USB-Festplatte als Datengrab.
 **Quellen**: 🔌 SSH (`lsblk`, `df -h`)
 **Zuletzt aktualisiert**: 2026-06-19
 ---
 ## Laufwerke (lsblk)
 ```
 NAME          SIZE TYPE  FSTYPE MOUNTPOINT
 sda          57,3G disk  ext4   /media/usbstick
 sdb           1,8T disk
 └─sdb1        1,8T part  ntfs   /media/Seagate-Expansion
 mmcblk0     119,1G disk
 ├─mmcblk0p1   256M part  vfat   /boot
 └─mmcblk0p2 118,8G part  ext4   /
 ```
 ## Speicherbelegung (df -h)
 | Dateisystem | Größe | Benutzt | Verfügbar | Belegt | Mountpoint |
 |---|---|---|---|---|---|
 | `/dev/root` | 117 G | 11 G | 102 G | 10 % | `/` |
 | `/dev/mmcblk0p1` | 253 M | 51 M | 202 M | 20 % | `/boot` |
 | `/dev/sda` | 57 G | 18 G | 37 G | 33 % | `/media/usbstick` |
 | `/dev/sdb1` | 1,9 T | 1,2 T | 675 G | 64 % | `/media/Seagate-Expansion` |
 ## Speicherdetails
 ### SD-Karte (mmcblk0 – System)
 - **Typ**: microSD (119 GB)
 - **Root-Partition**: ext4, 118,8 GB, 10 % belegt (11 GB)
 - **Boot-Partition**: vfat (FAT32), 256 MB, 20 % belegt
 - **Keine Verschlüsselung**
 ### USB-Stick (sda – Pi-hole/Sonstiges)
 - **Gerät**: SanDisk Ultra Fit (USB 2.0)
 - **Größe**: 57 GB
 - **Dateisystem**: ext4
 - **Mount**: `/media/usbstick` (33 % belegt – 18 GB)
 - Enthält: Betriebssystem-Verzeichnisstruktur (wirkt wie ein zweites Root-FS)
 ### Seagate Expansion HDD (sdb1 – Datengrab)
 - **Gerät**: Seagate RSS LLC SRD0NF1 Expansion Portable (STEA)
 - **Größe**: 1,8 TB
 - **Dateisystem**: ntfs
 - **Mount**: `/media/Seagate-Expansion` (64 % belegt – 1,2 TB)
 - Enthält: `Media/`, `BackUp/`, `CloudBackup/`, `Paperless/`, `PlexMediaServer/`, `Picture/`, `www/` u.a.
 ## Verwandte Seiten
 - [systemuebersicht](./systemuebersicht.md)
 - [samba](./dienste/samba.md)
@@ -0,0 +1,10 @@
 # Änderungslog – Raspberry PI2
 **Zusammenfassung**: Alle dokumentierten Änderungen am PI2-System.
 **Format**: Datum | Typ | Uhrzeit | Quelle | Zugriff | Änderung
 ---
 | Datum | Typ | Uhrzeit | Quelle | Zugriff | Änderung |
 |---|---|---|---|---|---|
 | 2026-06-19 | Initial | 22:30 | SSH | lesend | Ersterfassung des Systems – Doku angelegt |
@@ -0,0 +1,79 @@
 # Systemübersicht – Raspberry PI2
 **Zusammenfassung**: Der Raspberry PI2 `hoobs` läuft mit Raspbian GNU/Linux 11 "bullseye" (armv7l) und 921 MB RAM. Smart-Home-Hub mit HOOBS (Homebridge), Pi-hole DNS-Adblocker, Samba-Freigaben und Apache-Webserver.
 **Quellen**: 🔌 SSH (`ssh PI2`)
 **Zuletzt aktualisiert**: 2026-06-19
 ---
 ## Basis-Daten
 | Merkmal | Wert |
 |---|---|
 | **Hostname** | `hoobs` |
 | **Betriebssystem** | Raspbian GNU/Linux 11 (bullseye) |
 | **Architektur** | armv7l (32-bit) |
 | **Kernel** | 6.1.21-v7+ #1642 SMP Mon Apr  3 17:20:52 BST 2023 |
 | **CPU** | 4× ARM Cortex-A7 (BCM2835) |
 | **RAM** | 921 MiB (725 MiB genutzt, 142 MiB verfügbar) |
 | **Swap** | ~1,8 GiB (dphys-swapfile) |
 | **CPU-Temperatur** | ~58 °C (passiv gekühlt) |
 | **Betriebszeit** | 15 Tage, 20 Stunden |
 | **Load Average** | 5.47 / 5.00 / 4.81 (moderat) |
 | **Letzter Reboot** | 4. Juni 2026, 01:28 Uhr |
 ## Speicher
 | Laufwerk | Größe | Verwendet | Typ | Mountpunkt |
 |---|---|---|---|---|
 | **SD-Karte** (mmcblk0) | 119 GB | 11 GB | ext4 (root) | `/` |
 | **USB-Stick** (sda) | 57 GB | 18 GB | ext4 | `/media/usbstick` |
 | **Seagate HDD** (sdb1) | 1,8 TB | 1,2 TB | ntfs | `/media/Seagate-Expansion` |
 ## Systemd-Dienste (Enabled)
 Wichtige enabled systemd-Services:
 | Dienst | Zweck |
 |---|---|
 | `hoobsd.service` | HOOBS Smart-Home-Hub (Homebridge) |
 | `pihole-FTL.service` | Pi-hole DNS-Adblocker |
 | `apache2.service` | Apache HTTP Server |
 | `smbd.service` / `nmbd.service` | Samba SMB-Freigaben |
 | `helm.service` | HOOBS Helm-UI |
 | `music_social_api.service` | Spotify/Music API Proxy |
 | `ssh.service` | SSH-Server |
 | `cron.service` | Cron-Daemon |
 | `NetworkManager.service` | Netzwerk-Verwaltung |
 | `bluetooth.service` | Bluetooth |
 | `avahi-daemon.service` | mDNS/Bonjour |
 | `dphys-swapfile.service` | Swap-Datei |
 (Quelle: `systemctl list-unit-files --state=enabled`)
 ## Systemd-Timer
 | Timer | Ausführung |
 |---|---|
 | `logrotate.timer` | Täglich 00:00 |
 | `apt-daily.timer` | Täglich |
 | `apt-daily-upgrade.timer` | Täglich |
 | `fstrim.timer` | Wöchentlich (SD-Karten-Trimming) |
 | `e2scrub_all.timer` | Wöchentlich (Dateisystem-Prüfung) |
 | `man-db.timer` | Täglich |
 | `systemd-tmpfiles-clean.timer` | Täglich |
 ## Netzwerk
 Siehe [netzwerk](../Allgemein/netzwerk.md) für Details.
 ## Verwandte Seiten
 - [hardware](../Allgemein/hardware.md) – Hardware-Details
 - [netzwerk](../Allgemein/netzwerk.md) – Netzwerk-Konfiguration
 - [sicherheit](../Allgemein/sicherheit.md) – Sicherheits-Einstellungen
 - [laufwerke-und-speicher](./laufwerke-und-speicher.md)
 - [hoobs](./dienste/hoobs.md)
 - [pihole](./dienste/pihole.md)
 - [apache](./dienste/apache.md)
 - [samba](./dienste/samba.md)
@@ -0,0 +1,55 @@
 # Hardware – Raspberry PI5
 **Zusammenfassung**: Der `da-server-pi5` ist ein Raspberry PI5 mit 15 GB RAM, aktivem Kühler und drei USB-Massenspeichern. Läuft stabil bei ~46 °C CPU-Temperatur.
 **Quellen**: 🔌 SSH (`/proc/cpuinfo`, `lsusb`, `lspci`, `/sys/class/thermal/`)
 **Zuletzt aktualisiert**: 2026-06-17
 ---
 ## Modell
 | Merkmal | Wert |
 |---|---|
 | **Modell** | Raspberry Pi 5 (BCM2712) |
 | **CPU** | ARM Cortex-A76 (4 Kerne, aarch64) |
 | **BogoMIPS** | 108.00 pro Kern |
 | **Features** | fp asimd evtstrm aes pmull sha1 sha2 crc32 atomics fphp asimdhp cpuid asimdrdm lrcpc dcpop asimddp |
 | **RAM** | 15 GB |
 | **Architektur** | arm64 (nativ), 64-bit-mode (`arm_64bit=1`, `arm_boost=1`) |
 ## Temperatur & Kühlung
 - **CPU-Temperatur**: ~46 °C (Quelle: `/sys/class/thermal/thermal_zone0/temp`)
 - **Throttling**: Keines (vcgencmd zeigt keine Drosselung)
 - Der PI5 ist aktiv gekühlt und läuft sehr kühl.
 ## Angeschlossene Hardware (USB)
 | Bus | Gerät | ID | Beschreibung |
 |---|---|---|---|
 | Bus 001 | Device 002 | `1e3d:2092` | **Chipsbank Flash Disk** – USB-Stick mit LUKS-Schlüsseldateien |
 | Bus 001 | Device 003 | `0781:55ae` | **SanDisk Extreme 55AE** – 1,8-TB-SSD (Hauptsystem + Daten) |
 | Bus 004 | Device 002 | `1058:1042` | **WD Elements SE Portable** – 931-GB-SSD (Zweitsystem) |
 ## PCI / Erweiterungsbus
 ```
 0002:00:00.0  BCM2712 PCIe Bridge
 0002:01:00.0  RP1 PCIe 2.0 South Bridge (Ethernet, USB, GPIO)
 ```
 ## Boot-Konfiguration (`/boot/firmware/config.txt`)
 ```
 arm_64bit=1           # 64-bit mode
 arm_boost=1           # max Takt
 dtoverlay=vc4-kms-v3d # Grafiktreiber
 dtparam=audio=on      # Audio aktiv
 camera_auto_detect=1  # Kamera-Erkennung
 display_auto_detect=1 # Display-Erkennung
 ```
 ## Verwandte Seiten
 - [systemuebersicht](../Konfiguration/systemuebersicht.md)
 - [laufwerke-und-speicher](../Konfiguration/laufwerke-und-speicher.md)
@@ -0,0 +1,74 @@
 # Netzwerk – Raspberry PI5
 **Zusammenfassung**: Der PI5 hat eine kabelgebundene (eth0) und eine WLAN-Schnittstelle (wlan0). DNS läuft über die FritzBox, Netzwerkkonfiguration via NetworkManager.
 **Quellen**: 🔌 SSH (`ip addr`, `/etc/resolv.conf`, `/etc/hosts`, `ss -tlnp`, `/opt/compose/traefik/conf.d/*.yml`)
 **Zuletzt aktualisiert**: 2026-06-17
 ---
 ## Schnittstellen
 | Interface | IP | Typ | Status |
 |---|---|---|---|
 | `eth0` | `192.168.178.77/24` | Kabel (primär) | UP |
 | `wlan0` | `192.168.178.66/24` | WLAN (Fallback) | UP |
 | `lo` | `127.0.0.1/8` | Loopback | UP |
 Gateway/Subnetz: `192.168.178.0/24`, Standard-Gateway `192.168.178.1` (FritzBox).
 ## DNS
 - **Namensserver**: `192.168.178.1` (FritzBox)
 - **Suchdomain**: `fritz.box`
 - **Hostname**: `da-server-pi5`
 - **/etc/hosts**: `127.0.1.1 da-server-pi5` (von cloud-init verwaltet)
 ## Öffentliche Dienste
 Alle öffentlichen Dienste laufen hinter [traefik](../Konfiguration/docker/traefik.md) auf den Ports **80 (HTTP)** und **443 (HTTPS)** mit Let's Encrypt:
 | Subdomain | Dienst | interner Port |
 |---|---|---|
 | `cloud.da.home-webserver.de` | [nextcloud](../Konfiguration/docker/nextcloud.md) | `nextcloud:80` |
 | `photos.da.home-webserver.de` | [immich](../Konfiguration/docker/immich.md) | `immich_server:2283` |
 | `paperless.da.home-webserver.de` | [paperless](../Konfiguration/docker/paperless.md) | `paperless-webserver-1:8000` |
 | `wiki.da.home-webserver.de` | [wikijs](../Konfiguration/docker/wikijs.md) | `wikijs:3000` |
 | `pdf.da.home-webserver.de` | [stirling-pdf](../Konfiguration/docker/stirling-pdf.md) | `stirling-pdf:8080` |
 | `music.da.home-webserver.de` | [plex](../Konfiguration/docker/plex.md) | `plex:32400` |
 | `web.da.home-webserver.de` | [nginx](../Konfiguration/docker/nginx.md) | `nginx_pi5:80` |
 | `office.da.home-webserver.de` | [collabora](../Konfiguration/docker/collabora.md) | `collabora:9980` |
 | `jenkins.da.home-webserver.de` | [jenkins](../Konfiguration/docker/jenkins.md) | `jenkins:8080` |
 | `git.da.home-webserver.de` | [gitea](../Konfiguration/docker/gitea.md) | `gitea:3000` |
 | `traefik.da.home-webserver.de` | Traefik-Dashboard | `api@internal` |
 | `prometheus.da.home-webserver.de` | Prometheus | `monitoring-prometheus:9090` |
 | `grafana.da.home-webserver.de` | Grafana | `monitoring-grafana:3000` |
 (Quelle: `/opt/compose/traefik/conf.d/*.yml`)
 ## HTTP->HTTPS-Weiterleitung
 Die HTTPS-Weiterleitung im Traefik-Global-Router ist **derzeit auskommentiert** (`conf.d/0000-global.yml`). HTTP-Anfragen landen im "noop"-Service (Antwort 404). Die Dienste sind nur via HTTPS direkt erreichbar.
 ## Offene Ports (Listening)
 | Port | Dienst | Bemerkung |
 |---|---|---|
 | `22/tcp` | SSH (sshd) | Nur per SSH-Key |
 | `80/tcp` | docker-proxy → Traefik | HTTP |
 | `443/tcp` | docker-proxy → Traefik | HTTPS |
 | `111/tcp` | rpcbind | system-intern |
 | `631/tcp` | cupsd (localhost) | Druckserver |
 (Quelle: `ss -tlnp`)
 ## Firewall
 - **ufw**: Nicht installiert
 - **iptables**: Wird von Docker verwaltet (Netzwerk-Isolation der Container)
 ## Verwandte Seiten
 - [traefik](../Konfiguration/docker/traefik.md)
 - [domain-und-ssl](../Konfiguration/domain-und-ssl.md)
 - [systemuebersicht](../Konfiguration/systemuebersicht.md)
 - [sicherheit](./sicherheit.md)
@@ -0,0 +1,86 @@
 # Sicherheit – Raspberry PI5
 **Zusammenfassung**: SSH-Zugriff ist auf Public-Key-Authentifizierung beschränkt. Einige Sicherheitslücken bestehen (Grafana-Passwort, Gitea-Container-Konfiguration).
 **Quellen**: 🔌 SSH (`/etc/ssh/sshd_config`, `/etc/passwd`, `groups`, `docker inspect`)
 **Zuletzt aktualisiert**: 2026-06-17
 ---
 ## SSH-Zugang
 - **Passwort-Authentifizierung**: **Deaktiviert** (`KbdInteractiveAuthentication no`)
 - **Zugelassen**: Nur SSH-Key (Public-Key-Auth via `authorized_keys`)
 - **User**: `piadmin` (UID 1000, /home/piadmin, bash)
 - **SSH-Port**: 22 (Standard)
 - **Keys**: Ed25519-Schlüsselpaar vorhanden
 ## Benutzer & Gruppen
 Einziger menschlicher Benutzer: `piadmin`
 Gruppen-Mitgliedschaften von `piadmin`:
 | Gruppe | Zweck |
 |---|---|
 | `piadmin` | Eigenes |
 | `adm` | Log-Dateien lesen |
 | `dialout` | Serielle Schnittstelle |
 | `cdrom` | Optische Laufwerke |
 | `sudo` | **Vollständiger root-Zugriff** (sudo) |
 | `audio` | Audio-Geräte |
 | `video` | Video-Geräte |
 | `plugdev` | Wechselmedien |
 | `games` | Spiele |
 | `users` | Standard-Benutzergruppe |
 | `input` | Eingabegeräte |
 | `render` | GPU-Rendering |
 | `netdev` | Netzwerk-Konfiguration |
 | `spi` | SPI-Schnittstelle |
 | `i2c` | I²C-Schnittstelle |
 | `gpio` | GPIO-Pins |
 | **`docker`** | **Docker-Befehle ohne sudo** |
 ## LUKS-Verschlüsselung
 Beide Datenpartitionen sind mit LUKS2 verschlüsselt und erfordern einen **USB-Schlüsselstick** (`/mnt/usb_key/`) zum Booten:
 | Container | Schlüsseldatei | Größe |
 |---|---|---|
 | `encrypt_data` | `/mnt/usb_key/twotb.bin` | 4096 Bytes |
 | `encrypt_sdc3` | `/mnt/usb_key/onetb.bin` | 16384 Bytes |
 Siehe [luks-verschluesselung](../Konfiguration/luks-verschluesselung.md).
 ## Bekannte Sicherheitslücken
 ### 🔴 Grafana-Passwort im Klartext
 In `/opt/compose/monitoring/docker-compose.yml` steht das Admin-Passwort als Umgebungsvariable im Klartext:
 ```yaml
 environment:
  - GF_SECURITY_ADMIN_PASSWORD=Y57ekJeG2fLohiL0xdZNDViKteDZf55wQkhvabR96xPlEy4qRd
 ```
 Sollte in ein Docker-Secret oder eine `.env`-Datei ausgelagert werden.
 ### 🔴 Gitea-Container `restart: no`
 Der Gitea-Container hat die Restart-Policy `no` (statt `unless-stopped`) und läuft nicht. Die zugehörige MariaDB läuft dagegen normal.
 Siehe [gitea](../Konfiguration/docker/gitea.md).
 ### 🟡 Collabora-Admin-Passwort
 Der Standard-Admin-Zugang für Collabora sollte geändert werden.
 ### 🟡 HTTP->HTTPS-Weiterleitung
 Die Weiterleitung von HTTP auf HTTPS ist in Traefik **auskommentiert**. Dienste sind zwar nur per HTTPS aufrufbar, aber HTTP-Anfragen geben einen 404 statt einer Weiterleitung.
 ## Verwandte Seiten
 - [systemuebersicht](../Konfiguration/systemuebersicht.md)
 - [luks-verschluesselung](../Konfiguration/luks-verschluesselung.md)
 - [gitea](../Konfiguration/docker/gitea.md)
 - [monitoring](../Konfiguration/docker/monitoring.md)
@@ -0,0 +1,103 @@
 # Docker-Grundlagen
 **Zusammenfassung**: Der Raspberry PI5 betreibt Docker Engine v29.5.3 mit Compose v5.1.4. 31 Container (30 laufend) aus 13 Compose-Stacks inkl. [authelia](./docker/authelia.md) (aktiv seit 18.06.). Alle Compose-Dateien heißen `docker-compose.yml`.
 **Quellen**: 🖥️ `raw/Systemdaten – Raspberry PI5.md`, 🔌 SSH Live-Abfrage (2026-06-19, 21:30)
 **Zuletzt aktualisiert**: 2026-06-19
 ---
 ## Versionen
 | Komponente | Version |
 |---|---|
 | **Docker Engine** | 29.5.3 |
 | **Docker Compose** | v5.1.4 |
 | **Architektur** | linux/arm64 (native auf Raspberry PI5) |
 ## Netzwerke
 | Name | Treiber | Zweck |
 |---|---|---|
 | `traefik` | bridge | **Zentrales Reverse-Proxy-Netzwerk** – alle öffentlich erreichbaren Dienste hängen daran |
 | `nextcloud_internal` | bridge | Nextcloud-intern (Datenbank, Redis, Docker-Proxy) |
 | `immich_default` | bridge | Immich-Standard-Netzwerk |
 | `immich_internal` | bridge | Immich-intern (Datenbank, Redis, ML) |
 | `paperless_default` | bridge | Paperless-Standard-Netzwerk |
 | `paperless_internal` | bridge | Paperless-intern (Datenbank, Broker) |
 | `gitea_internal` | bridge | Gitea-intern (MariaDB) |
 | `wikijs_default` | bridge | Wiki.js-Standard-Netzwerk |
 | `docker0` | bridge | Docker-Standard-Bridge (ungenutzt) |
 ## Volumes (benannte)
 | Volume | Verwendung |
 |---|---|
 | `plex_plex_config` | Plex-Konfiguration |
 | `traefik_traefik_letsencrypt` | Let's-Encrypt-Zertifikate |
 | `immich_model-cache` | Immich ML-Modell-Cache |
 | `gitea_gitea` | Gitea-Daten |
 | `gitea_mariadb` | Gitea-Datenbank |
 | `paperless_redisdata` | Paperless-Redis-Daten |
 | `monitoring_grafana_data` | Grafana-Daten (wieder aktiv) |
 | `monitoring_prometheus_data` | Prometheus-Daten (wieder aktiv) |
 | `collabora_collabora_data` | Collabora-Daten |
 | `wikijs_wikijs_db` | Wiki.js-Datenbank |
 Zusätzlich gibt es **~151 anonyme Volumes** (UUID-Hashes) – Überreste alter Container-Starts.
 ## Persistente Daten außerhalb von Volumes (Bind Mounts)
 Viele Stacks speichern Daten auf den LUKS-Partitionen:
 - `/mnt/data/nextcloud/` – Nextcloud-App, Daten, Datenbank
 - `/mnt/data/...` – Weitere Anwendungsdaten auf der 1,5-TB-Partition
 - `/opt/compose/` – Alle Compose-Dateien und Konfigurationen
 ## Container-Statistik
 | Metrik | Wert |
 |---|---|
 | Container gesamt | 31 |
 | Laufend | 30 |
 | Gestoppt | 1 (`laughing_clarke` (hello-world)) |
 | Restart-Policies | `unless-stopped` bei allen aktiven Diensten |
 ## Docker-Images – Aufräumpotential
 188 Images belegen **174,1 GB**, davon sind **134 GB reclaimable (76 %)** – größtenteils alte Versionen:
 | Image | Alte/nicht genutzte Versionen |
 |---|---|
 | `traefik` | v2.10, v3.0.0, v3.1, v3.2, v3.6.6, `latest` (6 Versionen) |
 | `collabora/code` | `latest` und `latest-arm64` (beide ~1,9 GB – nur eines aktiv) |
 | `nextcloud` | `latest` und `29-apache` (beide ~2 GB) |
 | `jenkins/jenkins` | `lts-jdk17` und `lts-jdk21` |
 | `postgres` | 14, 16, 18 |
 | `mariadb` | 10.11, 11.4 |
 | `redis` | `7-alpine`, `8` |
 | `ghcr.io/immich-app/postgres` | 1 Image ohne Tag (dangling) |
 | `valkey/valkey` | 1 Image ohne Tag (dangling) |
 | `authelia/authelia` | `latest` (99 MB – neu) |
 | `gitea/gitea` | `latest` (246 MB – neu) |
 | `curlimages/curl` | `latest` (37 MB – Testcontainer) |
 Bereinigung mit: `docker image prune -a` (Vorsicht: `authelia/authelia`, `gitea/gitea` und `curlimages/curl` sind erst kürzlich gepullt und werden dann ebenfalls gelöscht)
 ## Wichtige Hinweise
 - **Alle öffentlich erreichbaren Dienste** nutzen das externe Netzwerk `traefik` und werden über [traefik](./docker/traefik.md) mit Let's Encrypt TLS terminiert.
 - **Authelia läuft** als SSO-Provider mit OIDC. Gitea-Login funktioniert via OIDC. Passkey-Config aktualisiert (direct attestation + metadata validation). Siehe [authelia](./docker/authelia.md).
 - **Gitea** OIDC-Integration abgeschlossen (Login via Authelia funktioniert).
 - **Stirling PDF** (`pdf.*`) ist als erster Dienst über ForwardAuth (`chain-authelia`) geschützt.
 - **Monitoring-Stack** läuft stabil (13h Uptime am 19.06.).
 - **Immich verwendet Valkey** (nicht Redis) – `valkey/valkey:8`.
 - **Alle Compose-Dateien** in `/opt/compose/` heißen `docker-compose.yml`.
 - **`.env`-Dateien** existieren bei: `immich`, `paperless`, `wikijs`.
 ## Verwandte Seiten
 - [docker-services](./docker-services.md) – Alle laufenden Dienste im Überblick
 - [authelia](./docker/authelia.md) – SSO mit ForwardAuth und OIDC
 - [opt-compose](./opt-compose.md) – Struktur von `/opt/compose/`
 - [traefik](./docker/traefik.md) – Reverse-Proxy-Konfiguration
 - [systemuebersicht](./systemuebersicht.md)
@@ -0,0 +1,100 @@
 # Docker-Dienste – Übersicht
 **Zusammenfassung**: 30 laufende + 1 gestoppter Container auf dem Raspberry PI5, aufgeteilt in 13 Stacks mit [authelia](./docker/authelia.md) aktiv. Die meisten Dienste sind über Traefik mit Let's Encrypt TLS erreichbar.
 **Quellen**: 🔌 SSH Live-Abfrage (2026-06-19, 21:30), `raw/Systemdaten – Raspberry PI5.md`
 **Zuletzt aktualisiert**: 2026-06-19
 ---
 ## Status-Übersicht
 ### Laufende Container (30)
 | Container | Image | Status | Ports |
 |---|---|---|---|
 | `traefik` | `traefik:latest` | ✅ Up (13h) | 80, 443 (Host) |
 | `plex` | `lscr.io/linuxserver/plex:latest` | ✅ Up (13h) | 32400, 1900/udp, 8324, 5353/udp, 32410/udp, 32412-32414/udp, 32469/tcp |
 | `nextcloud` | `nextcloud:latest` | ✅ Up (13h) | 80 |
 | `nextcloud-cron` | `nextcloud:latest` | ✅ Up (13h) | – |
 | `nextcloud-db` | `mariadb:11.4` | ✅ Up (13h, healthy) | 3306 |
 | `nextcloud-redis` | `redis:7-alpine` | ✅ Up (13h) | 6379 |
 | `nextcloud-docker-proxy` | `tecnativa/docker-socket-proxy` | ✅ Up (13h) | 2375 |
 | `immich_server` | `ghcr.io/immich-app/immich-server:v2` | ✅ Up (13h, healthy) | 2283 |
 | `immich_machine_learning` | `ghcr.io/immich-app/immich-machine-learning:v2` | ✅ Up (13h, healthy) | – |
 | `immich_redis` | `valkey/valkey:8` | ✅ Up (13h, healthy) | 6379 |
 | `immich_postgres` | `ghcr.io/immich-app/postgres:14-vectorchord0.4.3-pgvectors0.2.0` | ✅ Up (13h, healthy) | 5432 |
 | `stirling-pdf` | `frooodle/s-pdf:latest` | ✅ Up (13h, healthy) | 8080 |
 | `paperless-webserver-1` | `ghcr.io/paperless-ngx/paperless-ngx:latest` | ✅ Up (13h, healthy) | 8000 |
 | `paperless-broker-1` | `redis:8` | ✅ Up (13h) | 6379 |
 | `paperless-db-1` | `postgres:18` | ✅ Up (13h) | 5432 |
 | `paperless-gotenberg-1` | `gotenberg/gotenberg:8.25` | ✅ Up (13h) | 3000 |
 | `paperless-tika-1` | `apache/tika:latest` | ✅ Up (13h) | 9998 |
 | `wikijs` | `requarks/wiki:2` | ✅ Up (13h) | 3000, 3443 |
 | `wikijs-db` | `postgres:16` | ✅ Up (13h) | 5432 |
 | **`authelia`** | **`authelia/authelia:latest`** | **✅ Up (27 Min., healthy)** | **9091** |
 | `gitea` | `gitea/gitea:latest` | ✅ Up (12h) | 3000, **2222 (SSH)** |
 | `gitea-db-1` | `mariadb:10.11` | ✅ Up (13h) | 3306 |
 | `jenkins` | `jenkins/jenkins:lts-jdk21` | ✅ Up (13h) | 8080, 50000 |
 | `collabora` | `collabora/code:latest-arm64` | ✅ Up (13h, healthy) | 9980 |
 | `nginx_pi5` | `nginx:alpine` | ✅ Up (13h) | 80 |
 | `monitoring-prometheus` | `prom/prometheus:latest` | ✅ Up (13h) | 9090 |
 | `monitoring-grafana` | `grafana/grafana:latest` | ✅ Up (13h) | 3000 |
 | `monitoring-alertmanager` | `prom/alertmanager:latest` | ✅ Up (13h) | 9093 |
 | `monitoring-cadvisor` | `gcr.io/cadvisor/cadvisor:latest` | ✅ Up (13h, healthy) | 8080 |
 | `monitoring-node-exporter` | `prom/node-exporter:latest` | ✅ Up (13h) | 9100 |
 > **Hinweis**: Uptimes am 19.06.2026 um 21:30. Alle Container wurden ~13h zuvor neu gestartet. Gitea separat ~12h, Authelia zuletzt um 21:31 neu gestartet (WebAuthn- und OIDC-Config-Änderungen).
 ### Gestoppte Container (1)
 | Container | Image | Status | Hinweis |
 |---|---|---|---|
 | `laughing_clarke` | `hello-world` | ❌ Exited (6 Monate) | Einmal-Testcontainer |
 ---
 ## Stack-Zuordnung
 | Stack-Verzeichnis | Dienste |
 |---|---|
 | `/opt/compose/traefik/` | traefik |
 | `/opt/compose/plex/` | plex |
 | `/opt/compose/nextcloud/` | nextcloud, nextcloud-cron, nextcloud-db, nextcloud-redis, nextcloud-docker-proxy |
 | `/opt/compose/immich/` | immich_server, immich_machine_learning, immich_redis, immich_postgres |
 | `/opt/compose/stirling-pdf/` | stirling-pdf |
 | `/opt/compose/paperless/` | paperless-webserver, -db, -broker, -gotenberg, -tika |
 | `/opt/compose/wikijs/` | wikijs, wikijs-db |
 | `/opt/compose/gitea/` | gitea, gitea-db |
 | `/opt/compose/jenkins/` | jenkins |
 | `/opt/compose/collabora/` | collabora |
 | `/opt/compose/nginx/` | nginx_pi5 |
 | `/opt/compose/monitoring/` | prometheus, grafana, alertmanager, cadvisor, node-exporter |
 | `/opt/compose/authelia/` | authelia |
 ## Domain-Schema
 Alle Dienste folgen dem Muster `*.da.home-webserver.de`:
 | Subdomain | Dienst | Auth |
 |---|---|---|
 | `cloud.da.home-webserver.de` | Nextcloud | eigener Login |
 | `office.da.home-webserver.de` | Collabora Online | iFrame-Bypass |
 | `photos.da.home-webserver.de` | Immich (Fotos) | OIDC (geplant) |
 | `git.da.home-webserver.de` | Gitea | OIDC (in Einrichtung) |
 | `wiki.da.home-webserver.de` | Wiki.js | OIDC (geplant) |
 | `paperless.da.home-webserver.de` | Paperless | ForwardAuth (geplant) |
 | `pdf.da.home-webserver.de` | Stirling PDF | ForwardAuth ✅ |
 | `music.da.home-webserver.de` | Plex | offen |
 | `web.da.home-webserver.de` | Nginx Static | offen |
 | `jenkins.da.home-webserver.de` | Jenkins | offen |
 | `auth.da.home-webserver.de` | Authelia (SSO-Portal) | – |
 | `traefik.da.home-webserver.de` | Traefik Dashboard | Basic-Auth (→ ForwardAuth geplant) |
 | `prometheus.da.home-webserver.de` | Prometheus | Basic-Auth (→ ForwardAuth geplant) |
 | `grafana.da.home-webserver.de` | Grafana | Grafana-intern |
 ## Verwandte Seiten
 - [docker-grundlagen](./docker-grundlagen.md) – Netzwerke, Volumes, Basis
 - [opt-compose](./opt-compose.md) – Verzeichnisstruktur
 - [traefik](./docker/traefik.md) – Reverse Proxy
 - [authelia](./docker/authelia.md) – SSO mit ForwardAuth und OIDC
 - [domain-und-ssl](./domain-und-ssl.md)
@@ -0,0 +1,589 @@
 # Authelia – SSO mit Passkey-Unterstützung
 **Zusammenfassung**: Authelia als ForwardAuth-Provider für Traefik. Ermöglicht Single Sign-On (SSO) für alle Dienste hinter Traefik – mit Passwort, Passkey (WebAuthn/FIDO2) oder beidem.
 **Status**: ✅ aktiv – Gitea-Login via OIDC funktioniert, Passkey-Config aktualisiert
 **Zuletzt aktualisiert**: 2026-06-19 (Live-Daten 21:30)
 ---
 ## Architektur
 ```
 Browser ──HTTPS──▶ Traefik (:443)
                       │
                       ▼  (ForwardAuth-Middleware)
                 Authelia ───▶ Session-Check
                       │
               ┌───────┴──────────┐
               ▼                  ▼
         Unauthenticated     Authenticated
               │                  │
        Login-Seite         Weiterleitung zum
        (auth.*)            eigentlichen Dienst
 ```
 - Authelia läuft als **eigener Docker-Container** im `traefik`-Netzwerk
 - Traefik fragt bei jedem Request via **ForwardAuth-Middleware** bei Authelia an:
  - „Ist dieser Benutzer eingeloggt und darf auf diese Domain?“
  - Bei **Nein** → Redirect zu `auth.da.home-webserver.de`
  - Bei **Ja** → Request geht zum eigentlichen Dienst
 - **Passkeys (WebAuthn)** werden von Authelia nativ unterstützt – als 2FA oder passwordless
 ---
 ## Stack: `/opt/compose/authelia/`
 ### compose.yml
 ```yaml
 services:
  authelia:
    image: authelia/authelia:latest
    container_name: authelia
    restart: unless-stopped
    networks:
      - traefik
    volumes:
      - ./config:/config
    environment:
      - TZ=Europe/Berlin
 networks:
  traefik:
    external: true
 ```
 > **Hinweis**: Authelia wird **ohne** Traefik-Labels betrieben, damit es nicht sich selbst durch die ForwardAuth-Middleware blockiert. Stattdessen bekommt es eine eigene Route im File Provider.
 ---
 ## Konfiguration
 ### `config/configuration.yml`
 ```yaml
 ###############################################################
 #                    Authelia Konfiguration (v4.39+)
 ###############################################################
 # Server-Adresse (ersetzt host + port)
 server:
  address: tcp://0.0.0.0:9091
 # Logging
 log:
  level: info
 # Speicher – SQLite mit encryption_key (Pflicht seit v4.38)
 storage:
  encryption_key: <openssl rand -hex 32>   # 32 Byte Hex für SQLite-Verschlüsselung
  local:
    path: /config/db.sqlite3
 # Authentifizierungs-Backend (file-basiert)
 authentication_backend:
  file:
    path: /config/users.yml
    password:
      algorithm: argon2id
      iterations: 3
      salt_length: 16
      parallelism: 4
      memory: 65536  # KiB = 64 MiB (muss mit CLI-Default übereinstimmen)
 # Passkey (WebAuthn) – Hauptfeature
 # Passwordless-Login ist automatisch aktiv, sobald ein Passkey registriert wurde
 webauthn:
  enable_passkey_login: true                                    # Neue v4.39-Option
  attestation_conveyance_preference: 'direct'                   # Auf direct geändert (19.06.)
  filtering:
    prohibit_backup_eligibility: true
  metadata:
    enabled: true                                               # Metadata-Validierung aktiv (19.06.)
    validate_trust_anchor: true
    validate_entry: true
    validate_status: true
    validate_entry_permit_zero_aaguid: false
  timeout: 60s
  display_name: RaspiPI5 Authelia
 # Zugriffsregeln
 access_control:
  default_policy: deny
  rules:
    - domain: "auth.da.home-webserver.de"
      policy: bypass
    - domain: "cloud.da.home-webserver.de"
      policy: bypass
    - domain: "office.da.home-webserver.de"
      policy: bypass
    - domain: "git.da.home-webserver.de"
      policy: bypass                  # Gitea: OIDC
    - domain: "traefik.da.home-webserver.de"
      policy: two_factor
    - domain: "prometheus.da.home-webserver.de"
      policy: two_factor
    - domain: "*.da.home-webserver.de"
      policy: one_factor
 # Session-Konfiguration
 session:
  name: authelia_session
  secret: <openssl rand -hex 64>
  expiration: 8h
  inactivity: 2h
  remember_me: 30d
  cookies:
    - domain: da.home-webserver.de
      authelia_url: https://auth.da.home-webserver.de
 # Regulation – Schutz vor Brute-Force
 regulation:
  max_retries: 5
  find_time: 2m
  ban_time: 5m
 # 2FA (TOTP) – optional
 totp:
  issuer: RaspiPI5
  period: 30
  skew: 1
 # Notifier (Datei, da kein SMTP)
 notifier:
  filesystem:
    filename: /config/notifications.yml
 # Passwort-Reset
 identity_validation:
  reset_password:
    jwt_secret: <openssl rand -hex 64>
 ```
 ### `config/users.yml`
 ```yaml
 users:
  dial:
    password: <bcrypt/argon2-hash>
    displayname: "Dial"
    email: dial-master@gmx.de
    groups:
      - admins
 ```
 Passwort-Hash erzeugen:
 ```bash
 # Argon2id-Hash generieren (Default-Variante)
 docker run --rm authelia/authelia:latest authelia crypto hash generate argon2 --password 'DeinPasswort'
 # Mit expliziter Variante (optional):
 # docker run --rm authelia/authelia:latest authelia crypto hash generate argon2 --variant argon2id --password 'DeinPasswort'
 ```
 ---
 ## Traefik File Provider: Middleware
 ### Neue Datei: `/opt/compose/traefik/conf.d/0020-authelia-middleware.yml`
 ```yaml
 http:
  middlewares:
    # Standard-Auth-Middleware für alle Dienste
    chain-authelia:
      chain:
        middlewares:
          - security-headers
          - authelia-forwardauth
    authelia-forwardauth:
      forwardAuth:
        address: http://authelia:9091/api/verify?rd=https://auth.da.home-webserver.de/
        trustForwardHeader: true
        authResponseHeaders:
          - Remote-User
          - Remote-Groups
          - Remote-Name
          - Remote-Email
 ```
 > Die Datei heißt `0020-` damit sie zwischen den globalen (`0000-`, `0010-`) und den Service-Routen (`0100-` …) einsortiert wird.
 ---
 ## Authelia-Route: `conf.d/0015-authelia-service.yml`
 Authelia selbst muss erreichbar sein, **ohne** durch ForwardAuth geschützt zu werden:
 ```yaml
 http:
  routers:
    authelia:
      rule: "Host(`auth.da.home-webserver.de`)"
      entryPoints:
        - websecure
      service: authelia
      tls:
        certResolver: le
  services:
    authelia:
      loadBalancer:
        servers:
          - url: "http://authelia:9091"
 ```
 ---
 ## Bestehende Routen anpassen
 ### 1. `0100-traefik-dashboard.yml` – Dashboard & Admin-Dienste
 ```yaml
 # Vorher:
 middlewares:
  - chain-secure-admin
 # Nachher:
 middlewares:
  - chain-authelia
 ```
 ### 2. Standard-App-Routen (`0110-nextcloud.yml`, `0120-paperless.yml`, usw.)
 In jeder Service-Route wird die Middleware ausgetauscht:
 | Route-Datei                  | Vorher               | Nachher                                                 |     |
 | ---------------------------- | -------------------- | ------------------------------------------------------- | --- |
 | `0100-traefik-dashboard.yml` | `chain-secure-admin` | `chain-authelia`                                        |     |
 | `0110-nextcloud.yml`         | `chain-app-standard` | `chain-nextcloud` *(bleibt – cloud.* ist auf `bypass`)* |     |
 | `0120-paperless.yml`         | `chain-app-standard` | `chain-authelia`                                        |     |
 | `0130-immich.yml`            | `chain-app-standard` | `chain-authelia`                                        |     |
 | `0140-wikijs.yml`            | `chain-app-standard` | `chain-authelia`                                        |     |
 | `0150-stirling.yml`          | `chain-app-standard` | `chain-authelia`                                        |     |
 | `0160-plex.yml`              | `chain-app-standard` | `chain-authelia`                                        |     |
 | `0170-nginx.yml`             | `chain-app-standard` | `chain-authelia`                                        |     |
 | `0500-jenkins.yml`           | `chain-jenkins`      | `chain-authelia`                                        |     |
 | `0510-gitea.yml`             | – *(gar keine)*      | `chain-authelia`                                        |     |
 **Beispiel** – vorher in `0120-paperless.yml`:
 ```yaml
 middlewares:
  - chain-app-standard
 ```
 **Nachher**:
 ```yaml
 middlewares:
  - chain-authelia
 ```
 ### Achtung: Nextcloud & Collabora
 Nextcloud (`cloud.*`) und Collabora (`office.*`) sind in der `access_control`-Regel auf `bypass` gesetzt – sie werden von Authelia **übersprungen**, da Nextcloud seinen eigenen Login hat und Collabora nur als iFrame embedded wird.
 Trotzdem sollte die Middleware `chain-authelia` in der Route bleiben – Traefik leitet dann einfach durch, weil Authelia `bypass` zurückgibt.
 ---
 ## OIDC-Integration (SSO für Apps mit OIDC-Support)
 Authelia kann als **OpenID Connect (OIDC) Provider** dienen. Dienste wie Immich, Gitea und Wiki.js unterstützen OIDC nativ – dann loggst Du Dich direkt über Authelia in der jeweiligen App ein, ohne separates ForwardAuth.
 ### Architektur (OIDC vs. ForwardAuth)
 | ForwardAuth (einfach) | OIDC (für Apps mit Support) |
 |---|---|
 | Traefik fragt Authelia bei jedem Request | App (z. B. Immich) leitet zur Anmeldung an Authelia weiter |
 | Für Dienste **ohne** eigenes Login-System | Für Dienste **mit** OIDC-Support |
 | Plex, Stirling PDF, Nginx | Immich, Gitea, Wiki.js, Grafana |
 ### 1. Authelia als OIDC-Provider aktivieren
 In `/opt/compose/authelia/config/configuration.yml` ergänzen:
 ```yaml
 # OIDC-Provider-Konfiguration
 identity_providers:
  oidc:
    hmac_secret: <openssl rand -hex 32>
    jwks:                                        # ⚠️ In v4.39 heißt der Key `jwks`, NICHT `issuer_private_keys`!
      - key_id: rpid
        algorithm: RS256
        key: |
          -----BEGIN PRIVATE KEY-----
          <privater RSA-Key, siehe unten>
          -----END PRIVATE KEY-----
    clients:
      # ---------------------------------------------------------------
      # Gitea
      # ---------------------------------------------------------------
      - id: gitea
        description: Gitea SSO
        secret: <openssl rand -hex 32>
        public: false
        authorization_policy: one_factor
        redirect_uris:
          - https://git.da.home-webserver.de/user/oauth2/authelia/callback
          - https://git.da.home-webserver.de/user/oauth2/Authelia/callback   # Groß-/Kleinschreibung des Gitea-Provider-Namens!
        scopes:
          - openid
          - profile
          - email
        consent_mode: pre-configured                                         # Zustimmung vorab erteilt (19.06.)
        pre_configured_consent_duration: '3 months'
      # ---------------------------------------------------------------
      # Immich
      # ---------------------------------------------------------------
      - id: immich
        description: Immich SSO
        secret: <openssl rand -hex 32>
        public: false
        authorization_policy: one_factor
        redirect_uris:
          - https://photos.da.home-webserver.de/auth/login
          - https://photos.da.home-webserver.de/oauth2/callback
        scopes:
          - openid
          - profile
          - email
        userinfo_signing_algorithm: RS256
      # ---------------------------------------------------------------
      # Wiki.js
      # ---------------------------------------------------------------
      - id: wikijs
        description: Wiki.js SSO
        secret: <openssl rand -hex 32>
        public: false
        authorization_policy: one_factor
        redirect_uris:
          - https://wiki.da.home-webserver.de/login
        scopes:
          - openid
          - profile
          - email
 ```
 > **RSA-Key erzeugen**:
 > ```bash
 > openssl genrsa -out /tmp/private.pem 2048
 > # Den Inhalt von /tmp/private.pem in die configuration.yml einfügen
 > # ACHTUNG: Der Footer muss exakt `-----END PRIVATE KEY-----` (5 Striche) sein, nicht `----` (4 Striche)!
 > # Sonst kann Authelia den PEM-Block nicht parsen ("no PEM block was supplied or it was malformed").
 > ```
 > **Breaking Change in v4.39**:
 > - `issuer_private_keys` → `jwks` (wenn der alte Key verwendet wird, startet OIDC nicht)
 > - `id` → `client_id` (deprecated)
 > - `secret` → `client_secret` (deprecated)
 > - `description` → `client_name` (deprecated)
 > - Die Deprecation-Warnings sind aktuell noch funktional, werden aber in v5.0 entfernt.
 > **redirect_uri – Groß-/Kleinschreibung beachten**:
 > Gitea verwendet den **Namen der Authentication Source** als Teil des Callback-Pfads:
 > ```
 > /user/oauth2/<Provider-Name>/callback
 > ```
 > Wenn der Provider z. B. `Authelia` heißt, ist die Callback-URL:
 > ```
 > https://git.da.home-webserver.de/user/oauth2/Authelia/callback
 > ```
 > → Beide Varianten (`authelia` und `Authelia`) in den `redirect_uris` eintragen!
 > ✅ **Erledigt** auf dem Pi5 – funktioniert seit 21:10.
 ### 2. Access-Rules anpassen
 Dienste mit OIDC brauchen **kein** ForwardAuth mehr – sie werden auf `bypass` gesetzt, weil die Authentifizierung direkt zwischen App und Authelia (OIDC) läuft:
 ```yaml
 access_control:
  default_policy: deny
  rules:
    - domain: "auth.da.home-webserver.de"
      policy: bypass
    - domain: "cloud.da.home-webserver.de"
      policy: bypass                                  # Nextcloud: eigener Login
    - domain: "office.da.home-webserver.de"
      policy: bypass                                  # Collabora: iFrame
    - domain: "git.da.home-webserver.de"
      policy: bypass                                  # Gitea: OIDC ✅ aktiv
    - domain: "photos.da.home-webserver.de"
      policy: bypass                                  # Immich: OIDC (geplant)
    - domain: "wiki.da.home-webserver.de"
      policy: bypass                                  # Wiki.js: OIDC (geplant)
    - domain: "traefik.da.home-webserver.de"
      policy: two_factor                              # Admin: ForwardAuth (geplant)
    - domain: "prometheus.da.home-webserver.de"
      policy: two_factor                              # Admin: ForwardAuth (geplant)
    - domain: "*.da.home-webserver.de"
      policy: one_factor                              # Rest: ForwardAuth
 ```
 ### 3. App-Seitige Konfiguration
 #### Immich (`.env`)
 ```properties
 # /opt/compose/immich/.env – ergänzen
 IMMICH_OIDC_ENABLED=true
 IMMICH_OIDC_ISSUER_URL=https://auth.da.home-webserver.de
 IMMICH_OIDC_CLIENT_ID=immich
 IMMICH_OIDC_CLIENT_SECRET=<gleicher secret wie in Authelia>
 IMMICH_OIDC_SCOPE=openid profile email
 IMMICH_OIDC_AUTO_REGISTER=true
 IMMICH_OIDC_SIGNING_ALGORITHM=RS256
 ```
 Danach `docker compose down && docker compose up -d` auf dem Immich-Stack.
 #### Gitea (Web-UI)
 1. Einstellungen → `https://git.da.home-webserver.de/admin/auths`
 2. **"Add Authentication Source"**
   - Typ: **OAuth2**
   - Name: `Authelia`
   - Provider: **OpenID Connect**
   - Client ID: `gitea`
   - Client Secret: `<gleicher secret wie in Authelia>`
   - OpenID Connect Issuer URL: `https://auth.da.home-webserver.de`
 3. Speichern
 #### Wiki.js (Web-UI)
 1. Einstellungen → **"Security"** → **"Authentication"**
 2. **"Add Strategy"** → **"OpenID Connect / OAuth2"**
 3. Werte:
   - Client ID: `wikijs`
   - Client Secret: `<gleicher secret wie in Authelia>`
   - Authorization URL: `https://auth.da.home-webserver.de/api/oidc/authorization`
   - Token URL: `https://auth.da.home-webserver.de/api/oidc/token`
   - User Info URL: `https://auth.da.home-webserver.de/api/oidc/userinfo`
   - Issuer URL: `https://auth.da.home-webserver.de`
 ### 4. Traefik-Middleware bei OIDC-Diensten entfernen
 Dienste, die auf OIDC umgestellt sind, brauchen **keine** `chain-authelia`-Middleware mehr – andernfalls blockiert sich ForwardAuth und OIDC gegenseitig.
 **In den conf.d-Dateien** die Middleware auf `bypass` setzen oder ganz entfernen:
 ```yaml
 # /opt/compose/traefik/conf.d/0130-immich.yml
 # Vorher:
 # middlewares:
 #   - chain-authelia
 # Nachher: keine Middleware (Immich macht OIDC)
 ```
 ### Übersicht: ForwardAuth vs. OIDC
 | Dienst | Auth-Methode | Middleware in Traefik | policy in Authelia |
 |---|---|---|---|
 | Traefik-Dashboard | ForwardAuth | `chain-authelia` | `two_factor` |
 | Prometheus | ForwardAuth | `chain-authelia` | `two_factor` |
 | Paperless | ForwardAuth | `chain-authelia` | `one_factor` |
 | Stirling PDF | ForwardAuth | `chain-authelia` | `one_factor` |
 | Plex | ForwardAuth | `chain-authelia` | `one_factor` |
 | Nginx | ForwardAuth | `chain-authelia` | `one_factor` |
 | Jenkins | ForwardAuth | `chain-authelia` | `one_factor` |
 | **Immich** | **OIDC** | **keine** | `bypass` |
 | **Gitea** | **OIDC** | **keine** | `bypass` |
 | **Wiki.js** | **OIDC** | **keine** | `bypass` |
 | Nextcloud | eigener Login | `chain-nextcloud` | `bypass` |
 | Collabora | iFrame-Bypass | `collabora-headers` | `bypass` |
 ---
 ## Optional: `.htpasswd`-Auth entfernen
 Sobald Authelia läuft, können diese Konfigurationen entfallen:
 - Admin-Benutzer aus `auth/.htpasswd`
 - Middleware `auth-admin` (Basic-Auth) in `0010-middlewares.yml`
 - Middleware-Chain `chain-secure-admin`
 ---
 ## Passkey-Registrierung (erster Benutzer)
 1. **Authelia starten** → `docker compose up -d`
 2. **Erstmalig einloggen** unter `auth.da.home-webserver.de`
 3. Nach Login → **"Security"** → **"Register Security Key"** klicken
 4. Passkey via Touch ID / Windows Hello / YubiKey registrieren
 5. Ab sofort reicht beim Login **Benutzername + Passkey** (Passwort optional)
 ---
 ## Migrationsplan (Fortschritt)
 | Schritt | Aktion                                                               | Status |
 | ------- | -------------------------------------------------------------------- | ------ |
 | 1       | Compose + Config bereitstellen                                       | ✅ **erledigt** |
 | 2       | `0020-authelia-middleware.yml` + `0015-authelia-service.yml` anlegen | ✅ **erledigt** |
 | 3       | OIDC-Provider aktivieren (`jwks` statt `issuer_private_keys`)        | ✅ **erledigt** (20:01, 18.06.) |
 | 4       | Gitea OIDC-Auth-Source einrichten                                    | ✅ **erledigt** (Login funktioniert) |
 | 5       | Stirling PDF als ersten Dienst via ForwardAuth schützen              | ✅ **erledigt** (`chain-authelia` aktiv) |
 | 6       | WebAuthn-Passkey-Config überarbeitet (direct attestation + metadata) | ✅ **erledigt** (19.06.) |
 | 7       | OIDC consent_mode auf pre-configured gesetzt                         | ✅ **erledigt** (19.06.) |
 | 8       | Immich OIDC konfigurieren                                            | ⏳ geplant |
 | 9       | Wiki.js OIDC konfigurieren                                           | ⏳ geplant |
 | 10      | Traefik-Dashboard, Prometheus auf ForwardAuth umstellen              | ⏳ geplant |
 | 11      | Paperless, Plex, Nginx, Jenkins auf ForwardAuth umstellen            | ⏳ geplant |
 | 12      | `.htpasswd` und `auth-admin` entfernen                               | ⏳ geplant |
 ### Aktuelle Routing-Übersicht (Live vom 18.06., 20:00)
 | Dienst | Route | Auth-Methode | Status |
 |---|---|---|---|
 | Authelia (Portal) | `auth.*` | keine (bypass) | ✅ |
 | Nextcloud | `cloud.*` | kein Auth (bypass) | ✅ |
 | Collabora | `office.*` | kein Auth (bypass) | ✅ |
 | Gitea | `git.*` | OIDC (ohne Middleware) | 🔄 Gitea-WebUI-Konfiguration ausstehend |
 | Stirling PDF | `pdf.*` | ForwardAuth (`chain-authelia`) | ✅ |
 | Immich | `photos.*` | `chain-app-standard` (offen) | ⏳ |
 | Wiki.js | `wiki.*` | `chain-app-standard` (offen) | ⏳ |
 | Paperless | `paperless.*` | `chain-app-standard` (offen) | ⏳ |
 | Plex | `music.*` | `chain-app-standard` (offen) | ⏳ |
 | Nginx | `web.*` | `chain-app-standard` (offen) | ⏳ |
 | Jenkins | `jenkins.*` | `chain-jenkins` (offen) | ⏳ |
 | Traefik Dashboard | `traefik.*` | Basic-Auth | ⏳ |
 | Prometheus | `prometheus.*` | Basic-Auth | ⏳ |
 | Grafana | `grafana.*` | Grafana-intern | – |
 ---
 ## Backup / Wiederherstellung
 Das SQLite-DB enthält alle Benutzer-Sessions und registrierte Passkeys:
 ```bash
 # Sichern
 cp /opt/compose/authelia/config/db.sqlite3 /backup/authelia-db.sqlite3
 # Wiederherstellen
 cp /backup/authelia-db.sqlite3 /opt/compose/authelia/config/db.sqlite3
 ```
 Die Users-Datei und Config sind YAML – ideal für Git-Versionierung.
 ---
 ## Ressourcenverbrauch (geschätzt)
 | Metrik | Wert |
 |---|---|
 | RAM | ~50–80 MB |
 | CPU | vernachlässigbar (Go-Binary) |
 | Speicher | ~50 MB (SQLite + Config) |
 | Image-Größe | ~75 MB (linux/arm64) |
 ---
 ## Verwandte Seiten
 - [traefik](./traefik.md) – Reverse-Proxy-Grundkonfiguration
 - [docker-services](../docker-services.md) – Alle Dienste im Überblick
 - [Authelia Dokumentation](https://www.authelia.com/configuration/)
@@ -0,0 +1,58 @@
 # Collabora Online – Office-Dokumente
 **Zusammenfassung**: Collabora Online ermöglicht die Bearbeitung von Office-Dokumenten (Writer, Calc, Impress) im Browser. Eingebunden in Nextcloud via WOPI-Protokoll.
 **Quellen**: `raw/Systemdaten – Raspberry PI5.md`
 **Zuletzt aktualisiert**: 2026-06-17
 ---
 ## Container
 | Feld | Wert |
 |---|---|
 | **Image** | `collabora/code:latest-arm64` |
 | **Container-Name** | `collabora` |
 | **Restart** | `unless-stopped` |
 | **Port** | 9980 (intern) |
 ## Netzwerk
 - `traefik` – Zugriff über Reverse Proxy
 ## Umgebungsvariablen
 | Variable | Wert |
 |---|---|
 | `aliasgroup1` | `https://cloud.da.home-webserver.de:443` |
 | `server_name` | `office.da.home-webserver.de` |
 | `DONT_GEN_SSL_CERT` | `true` (TLS terminiert an Traefik) |
 | `frame_ancestors` | `https://cloud.da.home-webserver.de:443` |
 | `username` | `admin` ⚠️ |
 | `password` | `admin` ⚠️ |
 | `extra_params` | `--o:ssl.enable=false --o:ssl.termination=true --o:net.wopi.allowlist=127.0.0.1,172.18.[0-9]+.[0-9]+` |
 | `OO_NET_POST_ALLOW_HOST` | `127.0.0.1,172.18.[0-9]+.[0-9]+` |
 | `OO_LOGGING_LEVEL` | `warning` |
 ## Sicherheitshinweise
 **⚠️ Das Admin-Passwort steht auf dem Standardwert `admin` – bitte umgehend ändern!**
 ## Besonderheiten
 - **extra_hosts**: `cloud.da.home-webserver.de` → `host-gateway` (löst die Nextcloud-Domain zur Host-IP auf)
 - **security_opt**: `seccomp:unconfined` erforderlich für Collabora
 - **cap_add**: `MKNOD`
 - **Healthcheck**: Prüft `/hosting/discovery` auf Port 9980
 - **Encoded Characters**: Traefik ist für encoded Slashes konfiguriert (siehe [traefik](./traefik.md))
 ## Route (Traefik)
 ```
 Host(`office.da.home-webserver.de`) → collabora:9980
 ```
 ## Verwandte Seiten
 - [traefik](./traefik.md) – Reverse-Proxy + encoded Characters
 - [nextcloud](./nextcloud.md) – Integration als WOPI-Client
 - [docker-services](../docker-services.md)
@@ -0,0 +1,67 @@
 # Gitea – Git-Service
 **Zusammenfassung**: Gitea ist ein selbstgehosteter Git-Service (ähnlich GitHub/GitLab) mit MariaDB-Datenbank. Erreichbar über Traefik und SSH auf Port 2222.
 **Quellen**: 🖥️ `raw/Systemdaten – Raspberry PI5.md`, 🔌 SSH (`docker inspect gitea`)
 **Zuletzt aktualisiert**: 2026-06-17
 ---
 ## Container
 | Container | Image | Funktion |
 |---|---|---|
 | `gitea` | `gitea/gitea:latest` | Git-Service (Port 3000 intern, SSH 2222 extern) |
 | `gitea-db-1` | `mariadb:10.11` | Datenbank |
 ## Netzwerk
 - `traefik` – Web-Zugriff
 - `internal` – Datenbank-Kommunikation
 ## Daten-Persistenz
 | Volume | Pfad im Container |
 |---|---|
 | `gitea_gitea` | `/data` |
 | `gitea_mariadb` | `/var/lib/mysql` |
 ## Umgebungsvariablen
 | Variable | Wert |
 |---|---|
 | `USER_UID` | 1000 |
 | `USER_GID` | 1000 |
 | `GITEA__database__DB_TYPE` | mysql |
 | `GITEA__database__HOST` | db:3306 |
 | `GITEA__database__NAME` | gitea |
 | `GITEA__database__USER` | giteaadmin |
 ## Status
 | Container | Status | Restart-Policy (compose.yml) |
 |---|---|---|
 | `gitea` | **Running** ✅ | `unless-stopped` (seit 17.06. ergänzt) |
 | `gitea-db-1` | Up | `always` |
 Der Gitea-Container lief 3 Wochen nicht (`restart: no`). Am 17. Juni 2026 wurde `restart: unless-stopped` in der `docker-compose.yml` ergänzt und der Container gestartet.
 **Hinweis**: Die alte Restart-Policy (`no`) gilt noch im laufenden Container. Für die Übernahme der neuen Policy reicht ein:
 ```bash
 cd /opt/compose/gitea
 docker compose up -d
 ```
 (Dadurch wird der Container mit der neuen Policy neu erstellt.)
 ## Secrets
 Passwörter liegen in `/opt/compose/gitea/.secrets/db_pw`.
 ## SSH-Zugriff
 Gitea ist per SSH auf Port **2222** erreichbar (nicht der Standard-Port 22).
 ## Verwandte Seiten
 - [traefik](./traefik.md)
 - [docker-services](../docker-services.md)
 - [jenkins](./jenkins.md) – CI/CD für Gitea-Repos
@@ -0,0 +1,39 @@
 # Immich – Foto-Management
 **Zusammenfassung**: Immich dient als Google-Photos-Alternative mit automatischem Backup, Gesichtserkennung und ML-basierter Suche. Läuft intern (Traefik-Labels auskommentiert).
 **Quellen**: `raw/Systemdaten – Raspberry PI5.md`
 **Zuletzt aktualisiert**: 2026-06-17
 ---
 ## Container
 | Container | Image | Funktion |
 |---|---|---|
 | `immich_server` | `ghcr.io/immich-app/immich-server:v2` | Haupt-App (REST API + Web) |
 | `immich_machine_learning` | `ghcr.io/immich-app/immich-machine-learning:v2` | ML-Suche, Gesichtserkennung |
 | `immich_redis` | `valkey/valkey:8` | Cache/Warteschlange |
 | `immich_postgres` | `ghcr.io/immich-app/postgres:14-vector` | Datenbank mit pgvector |
 ## Netzwerk
 - `traefik` – für Reverse Proxy (Labels derzeit auskommentiert)
 - `internal` – interne Kommunikation
 ## Daten-Persistenz
 | Typ | Pfad |
 |---|---|
 | **Upload-Speicher** | via `${UPLOAD_LOCATION}` (im `.env` definiert) |
 | **Datenbank** | via `${DB_DATA_LOCATION}` (im `.env` definiert) |
 | **ML-Cache** | Docker-Volume `immich_model-cache` |
 ## Status
 - **Traefik-Routing ist auskommentiert** – Immich wird aktuell **nicht über den Reverse Proxy** erreicht, sondern nur intern via Port 2283.
 - Die ML-Komponente läuft auf CPU (arm64-native).
 ## Verwandte Seiten
 - [traefik](./traefik.md)
 - [docker-services](../docker-services.md)
@@ -0,0 +1,54 @@
 # Jenkins – CI/CD
 **Zusammenfassung**: Jenkins automatisiert Builds und Deployments. Läuft als Root-Container mit Docker-Socket-Zugriff, um Containermanagement und Compose-Deployments zu ermöglichen.
 **Quellen**: `raw/Systemdaten – Raspberry PI5.md`
 **Zuletzt aktualisiert**: 2026-06-17
 ---
 ## Container
 | Feld | Wert |
 |---|---|
 | **Image** | `jenkins/jenkins:lts-jdk21` |
 | **Container-Name** | `jenkins` |
 | **Restart** | `unless-stopped` |
 | **User** | `root` (für Docker-Socket-Zugriff) |
 | **Ports** | 8080 (API/Web), 50000 (Agent) |
 ## Netzwerk
 - `traefik` – Zugriff über Reverse Proxy
 ## Volumes & Bind Mounts
 | Host | Container | Zweck |
 |---|---|---|
 | `./data` | `/var/jenkins_home` | Jenkins-Konfiguration |
 | `/var/run/docker.sock` | `/var/run/docker.sock` | Docker-Socket (Container-Management) |
 | `/usr/bin/docker` | `/usr/bin/docker` | Docker-CLI im Container |
 | `/opt/compose` | `/opt/compose` | Zugriff auf alle Compose-Dateien zur Deployment-Automatisierung |
 ## Umgebungsvariablen
 | Variable | Wert |
 |---|---|
 | `JENKINS_PREFIX` | `/jenkins` |
 ## Route (Traefik)
 ```
 Host(`da.home-webserver.de`) + Path(`/jenkins`) → jenkins:8080
 ```
 ## Besonderheiten
 - **Root-Zugriff**: Jenkins läuft als `root`, damit er `docker` und `docker compose` ausführen kann – insbesondere für Deployments aus Pipelines heraus.
 - **Zugriff auf `/opt/compose`**: Jenkins kann direkt auf alle Compose-Dateien zugreifen und Stacks aktualisieren.
 - **JAVA_OPTS**: Spezielle Optionen für den Betrieb hinter einem Reverse Proxy.
 ## Verwandte Seiten
 - [traefik](./traefik.md)
 - [gitea](./gitea.md) – Git-Repository-Quelle für Jenkins-Pipelines
 - [docker-services](../docker-services.md)
@@ -0,0 +1,52 @@
 # Monitoring-Stack
 **Zusammenfassung**: Prometheus/Grafana-Monitoring-Stack mit Prometheus, Grafana, cAdvisor, Node-Exporter und Alertmanager. Läuft mit `restart: unless-stopped` für automatischen Neustart nach Reboot.
 **Quellen**: 🖥️ `raw/Systemdaten – Raspberry PI5.md`, 🔌 SSH (`/opt/compose/monitoring/docker-compose.yml`)
 **Zuletzt aktualisiert**: 2026-06-17
 ---
 ## Container (laufend)
 | Container | Image | Restart-Policy |
 |---|---|---|
 | `monitoring-prometheus` | `prom/prometheus:latest` | `unless-stopped` |
 | `monitoring-grafana` | `grafana/grafana:latest` | `unless-stopped` |
 | `monitoring-alertmanager` | `prom/alertmanager:latest` | `unless-stopped` |
 | `monitoring-cadvisor` | `gcr.io/cadvisor/cadvisor:latest` | `unless-stopped` |
 | `monitoring-node-exporter` | `prom/node-exporter:latest` | `unless-stopped` |
 ## Daten-Persistenz
 | Volume | Zweck |
 |---|---|
 | `monitoring_grafana_data` | Grafana-Dashboards und -Konfiguration |
 | `monitoring_prometheus_data` | Prometheus-Zeitreihendaten |
 ## Wiederherstellung
 Der Stack war 3 Wochen gestoppt (ab 27. Mai 2026). Am 17. Juni 2026 wurde er wieder gestartet. Die `restart: unless-stopped`-Policy war bereits in der `docker-compose.yml` vorhanden – die Container starteten nur nicht, weil sie vor dem Reboot explizit gestoppt worden waren.
 **Wichtige Erkenntnis**: `restart: unless-stopped` startet Container nach einem Reboot **nur dann**, wenn sie vor dem Herunterfahren nicht explizit gestoppt wurden. War ein Container mit `docker compose stop` angehalten, respektiert Docker das auch nach einem Reboot. Seit dem erneuten Start startet der Stack jetzt automatisch bei jedem Reboot.
 ## Compose-Datei
 Die Konfiguration liegt in `/opt/compose/monitoring/docker-compose.yml` (Dateiname `docker-compose.yml`, nicht `compose.yml`).
 ## Sicherheitshinweis
 **⚠️ Das Grafana-Admin-Passwort steht im Klartext in der `docker-compose.yml` (Umgebungsvariable `GF_SECURITY_ADMIN_PASSWORD`).** Es sollte baldmöglichst geändert werden.
 ## Manueller Start/Stopp
 ```bash
 cd /opt/compose/monitoring
 docker compose up -d      # Starten
 docker compose stop        # Anhalten (danach kein Autostart bei Reboot!)
 docker compose down        # Entfernen (Container + Netzwerk)
 ```
 ## Verwandte Seiten
 - [docker-services](../docker-services.md)
 - [docker-grundlagen](../docker-grundlagen.md)
@@ -0,0 +1,61 @@
 # Nextcloud
 **Zusammenfassung**: Nextcloud läuft als Cloud-Speicher mit MariaDB, Redis-Cache und Docker-Socket-Proxy. Erreichbar unter `cloud.da.home-webserver.de`.
 **Quellen**: `raw/Systemdaten – Raspberry PI5.md`
 **Zuletzt aktualisiert**: 2026-06-17
 ---
 ## Container
 | Container | Image | Funktion |
 |---|---|---|
 | `nextcloud` | `nextcloud:latest` | Haupt-App |
 | `nextcloud-cron` | `nextcloud:latest` | Cron-Jobs für Hintergrundaufgaben |
 | `nextcloud-db` | `mariadb:11.4` | Datenbank |
 | `nextcloud-redis` | `redis:7-alpine` | Cache (File Locking, Cache) |
 | `nextcloud-docker-proxy` | `tecnativa/docker-socket-proxy` | Docker-Socket-Proxy für Nextcloud |
 ## Netzwerk
 - `traefik` – für den Reverse-Proxy-Zugriff
 - `internal` – interne Kommunikation (DB, Redis, Proxy)
 ## Daten-Persistenz
 | Host-Pfad | Container-Pfad |
 |---|---|
 | `/mnt/data/nextcloud/www` | `/var/www/html` |
 | `/mnt/data/nextcloud/data` | `/var/www/html/data` |
 | `/mnt/data/nextcloud/db` | `/var/lib/mysql` |
 ## Umgebungsvariablen
 | Variable | Wert |
 |---|---|
 | `NEXTCLOUD_TRUSTED_DOMAINS` | `cloud.da.home-webserver.de` |
 | `OVERWRITEHOST` | `cloud.da.home-webserver.de` |
 | `OVERWRITEPROTOCOL` | `https` |
 | `TRUSTED_PROXIES` | `traefik 172.18.0.0/16` |
 | `PHP_MEMORY_LIMIT` | 1024M |
 | `UPLOAD_MAX_FILESIZE` | 1024M |
 | `MYSQL_DATABASE` | `nextcloud` |
 | `MYSQL_USER` | `nextclouduser` |
 ## Routen (Traefik File Provider)
 ```
 Host(`cloud.da.home-webserver.de`) → nextcloud:80
 ```
 ## Besonderheiten
 - Die Daten liegen **nicht in Docker-Volumes**, sondern als **Bind Mounts** auf der LUKS-Partition `/mnt/data/`
 - Der Docker-Socket-Proxy (`tecnativa/docker-socket-proxy`) erlaubt Nextcloud, Container zu verwalten (z. B. für Talk oder Office-Integration)
 - Secrets (Passwörter) liegen in `/opt/compose/nextcloud/.secrets/`
 ## Verwandte Seiten
 - [traefik](./traefik.md) – Reverse-Proxy-Konfiguration
 - [docker-services](../docker-services.md) – Alle Dienste
 - [laufwerke-und-speicher](../laufwerke-und-speicher.md) – Daten liegen auf `/mnt/data`
@@ -0,0 +1,37 @@
 # Nginx – Static Webserver
 **Zusammenfassung**: Ein minimalistischer Nginx-Container für statische Webseiten. Läuft mit `nginx:alpine` und wird über Traefik angesteuert.
 **Quellen**: `raw/Systemdaten – Raspberry PI5.md`
 **Zuletzt aktualisiert**: 2026-06-17
 ---
 ## Container
 | Feld | Wert |
 |---|---|
 | **Image** | `nginx:alpine` |
 | **Container-Name** | `nginx_pi5` |
 | **Restart** | `unless-stopped` |
 ## Netzwerk
 - `traefik` – Zugriff über Reverse Proxy
 ## Volumes
 | Host | Container | Zweck |
 |---|---|---|
 | `./html` | `/usr/share/nginx/html:ro` | Statische HTML-Dateien |
 | `./config` | `/etc/nginx/conf.d:ro` | Nginx-Konfiguration |
 | `./logs` | `/var/log/nginx` | Log-Dateien |
 ## Besonderheiten
 - Keine direkten Port-Mappings – die Kommunikation läuft **ausschließlich über das Traefik-Netzwerk**.
 - Port 80 wird nur intern im Docker-Netzwerk bereitgestellt.
 ## Verwandte Seiten
 - [traefik](./traefik.md)
 - [docker-services](../docker-services.md)
@@ -0,0 +1,37 @@
 # Paperless-ngx – Dokumentenmanagement
 **Zusammenfassung**: Paperless-ngx archiviert, verschlagwortet und durchsucht Dokumente automatisch. Inklusive OCR via Tika und Gotenberg für Office-Konvertierung.
 **Quellen**: `raw/Systemdaten – Raspberry PI5.md`
 **Zuletzt aktualisiert**: 2026-06-17
 ---
 ## Container
 | Container               | Image                                        | Funktion                          |
 | ----------------------- | -------------------------------------------- | --------------------------------- |
 | `paperless-webserver-1` | `ghcr.io/paperless-ngx/paperless-ngx:latest` | Haupt-App (Port 8000)             |
 | `paperless-db-1`        | `postgres:18`                                | Datenbank                         |
 | `paperless-broker-1`    | `redis:8`                                    | Nachrichten-Warteschlange         |
 | `paperless-gotenberg-1` | `gotenberg/gotenberg:8.25`                   | Office-Dokument-Konvertierung     |
 | `paperless-tika-1`      | `apache/tika:latest`                         | Apache Tika (Metadata-Extraktion) |
 ## Netzwerk
 - `paperless_default` – Externes Netzwerk (für Traefik)
 - `paperless_internal` – Interne Kommunikation
 ## Daten-Persistenz
 Alle Daten in Docker-Volumes (keine Bind Mounts auf LUKS-Partition).
 ## Besonderheiten
 - **Gotenberg** wandelt Office-Dateien (DOCX, XLSX) in PDF um
 - **Tika** extrahiert Metadaten und Text aus Dokumenten
 - Alle Dienste mit `restart: unless-stopped` konfiguriert
 ## Verwandte Seiten
 - [traefik](./traefik.md)
 - [docker-services](../docker-services.md)
@@ -0,0 +1,40 @@
 # Plex – Media Server
 **Zusammenfassung**: Plex Media Server streamt Filme, Serien und Musik. Läuft mit LinuxServer.io-Image und direktem Port-Mapping (kein Traefik).
 **Quellen**: `raw/Systemdaten – Raspberry PI5.md`
 **Zuletzt aktualisiert**: 2026-06-17
 ---
 ## Container
 | Feld | Wert |
 |---|---|
 | **Image** | `lscr.io/linuxserver/plex:latest` |
 | **Container-Name** | `plex` |
 | **Restart** | `unless-stopped` |
 | **Netzwerk** | Traefik (nicht aktiv genutzt) |
 ## Exponierte Ports
 | Port | Protokoll | Zweck |
 |---|---|---|
 | 32400 | TCP | Plex Web UI |
 | 1900 | UDP | DLNA |
 | 5353 | UDP | MDNS |
 | 8324 | TCP | Roku-Unterstützung |
 | 32410-32414 | UDP | DLNA |
 | 32469 | TCP | DLNA |
 ## Daten
 - **Konfiguration**: Docker-Volume `plex_plex_config`
 ## Besonderheiten
 - Plex wird **nicht über Traefik** geroutet, sondern direkt über Port 32400 angesprochen.
 - Läuft stabil seit > 25h (zum Zeitpunkt der Erfassung).
 ## Verwandte Seiten
 - [docker-services](../docker-services.md)
@@ -0,0 +1,25 @@
 # Stirling PDF – PDF-Bearbeitung
 **Zusammenfassung**: Stirling PDF ist ein webbasiertes PDF-Werkzeug (Zusammenführen, Teilen, Konvertieren, OCR, Bearbeiten). Läuft als eigenständiger Container.
 **Quellen**: `raw/Systemdaten – Raspberry PI5.md`
 **Zuletzt aktualisiert**: 2026-06-17
 ---
 ## Container
 | Feld | Wert |
 |---|---|
 | **Image** | `frooodle/s-pdf:latest` |
 | **Container-Name** | `stirling-pdf` |
 | **Restart** | `unless-stopped` |
 | **Port (intern)** | 8080 |
 | **Status** | ✅ Up 25h (healthy) |
 ## Netzwerk
 - Nicht sichtbar im Traefik-Netzwerk – vermutlich Direktzugriff oder über nginx.
 ## Verwandte Seiten
 - [docker-services](../docker-services.md)
@@ -0,0 +1,151 @@
 # Traefik – Reverse Proxy
 **Zusammenfassung**: Traefik läuft als zentraler Reverse Proxy mit Let's Encrypt TLS-Terminierung. Alle öffentlichen Dienste hängen am selben Docker-Netzwerk `traefik`. Die Routing-Konfiguration erfolgt per **File Provider** (YAML-Dateien in `/conf.d/`), nicht per Docker-Labels.
 **Quellen**: 🖥️ `raw/Systemdaten – Raspberry PI5.md`, 🔌 SSH (`/opt/compose/traefik/conf.d/*.yml`, 18.06. 20:00)
 **Zuletzt aktualisiert**: 2026-06-18 (Update 20:00)
 ---
 ## Container
 | Feld | Wert |
 |---|---|
 | **Image** | `traefik:latest` |
 | **Container-Name** | `traefik` |
 | **Restart** | `unless-stopped` |
 | **Netzwerk** | `traefik` (extern) |
 | **Ports (Host)** | `80:80`, `443:443` |
 ## Static Configuration (compose.yml – `command:`)
 ```yaml
 command:
  - "--api.dashboard=true"
  - "--log.level=INFO"
  # File Provider (statt Docker Labels)
  - "--providers.file.directory=/conf.d"
  - "--providers.file.watch=true"
  - "--providers.file=true"
  # Entrypoints
  - "--entrypoints.web.address=:80"
  - "--entrypoints.websecure.address=:443"
  - "--entrypoints.websecure.http.tls=true"
  - "--entrypoints.web.http.sanitizePath=false"
  - "--entrypoints.websecure.http.sanitizePath=false"
  - "--entrypoints.websecure.http.encodedCharacters.allowEncodedSlash=true"
  - "--entrypoints.websecure.http.encodedCharacters.allowEncodedBackSlash=true"
  - "--entrypoints.websecure.http.encodedCharacters.allowEncodedSemicolon=true"
  - "--entrypoints.websecure.http.encodedCharacters.allowEncodedPercent=true"
  - "--entrypoints.websecure.http.encodedCharacters.allowEncodedQuestionMark=true"
  - "--entrypoints.websecure.http.encodedCharacters.allowEncodedHash=true"
  # Let's Encrypt
  - "--certificatesresolvers.le.acme.email=dial-master@gmx.de"
  - "--certificatesresolvers.le.acme.storage=/acme.json"
  - "--certificatesresolvers.le.acme.httpchallenge.entrypoint=web"
 ```
 ## Volumes
 | Host-Pfad | Container-Pfad | Zweck |
 |---|---|---|
 | `./conf.d` | `/conf.d` | File-Provider-Konfigurationen (dynamische Routen) |
 | `./acme.json` | `/acme.json` | Let's-Encrypt-Zertifikatspeicher |
 | `./auth/.htpasswd` | `/.htpasswd` | Basis-Auth für das Dashboard |
 | `/etc/localtime` | `/etc/localtime:ro` | Zeitzone |
 ## Dynamic Configuration (File Provider)
 Die eigentlichen Routen-Regeln liegen als YAML-Dateien in `/opt/compose/traefik/conf.d/`. Alle Dateien (Stand: 17.06.2026):
 | Datei | Zweck |
 |---|---|---|
 | `0000-global.yml` | HTTP-Catchall-Router (fängt HTTP ab; HTTPS-Redirect **auskommentiert**) |
 | `0010-middlewares.yml` | Middleware-Chains (auth, security, rate-limit, nextcloud-dav, etc., **+ chain-authelia**) |
 | `0015-authelia-service.yml` | ✅ [authelia](./authelia.md) Route (ohne Auth) |
 | `0020-authelia-middleware.yml` | ✅ ForwardAuth-Middleware (chain-authelia + authelia-forwardauth) |
 | `0020-prometheus.yml` | Prometheus-Route (mit Basic-Auth) |
 | `0030-grafana.yml` | Grafana-Route (ohne Auth-Middleware) |
 | `0100-traefik-dashboard.yml` | Traefik-Dashboard (mit Basic-Auth) |
 | `0105-collabora.yml` | Collabora (iFrame-freundliche Header, WebSocket-Support) |
 | `0110-nextcloud.yml` | Nextcloud (mit chain-nextcloud-Middleware) |
 | `0120-paperless.yml` | Paperless |
 | `0130-immich.yml` | Immich |
 | `0140-wikijs.yml` | Wiki.js |
 | `0150-stirling.yml` | ✅ Stirling PDF (mit `chain-authelia`) |
 | `0160-plex.yml` | Plex |
 | `0170-nginx.yml` | Nginx Static Webserver |
 | `0500-jenkins.yml` | Jenkins (mit Jenkins-Headern) |
 | `0510-gitea.yml` | Gitea (ohne Middleware – OIDC) |
 ### Vollständige Routing-Übersicht
 | Subdomain | interner Dienst | Middleware | Auth |
 |---|---|---|---|---|
 | `cloud.*` | `http://nextcloud` | `chain-nextcloud` | – |
 | `photos.*` | `http://immich_server:2283` | `chain-immich` | – |
 | `paperless.*` | `http://paperless-webserver-1:8000` | `chain-app-standard` | – |
 | `wiki.*` | `http://wikijs:3000` | `chain-app-standard` | – |
 | **`pdf.*`** | **`http://stirling-pdf:8080`** | **`chain-authelia`** | **✅ ForwardAuth** |
 | `music.*` | `http://plex:32400` | `chain-app-standard` | – |
 | `web.*` | `http://nginx_pi5:80` | `chain-app-standard` | – |
 | `office.*` | `http://collabora:9980` | `collabora-headers` | – |
 | `jenkins.*` | `http://jenkins:8080` | `chain-jenkins` | – |
 | `git.*` | `http://gitea:3000` | – | **🔄 OIDC (in Einrichtung)** |
 | `auth.*` | `http://authelia:9091` | – | ✅ SSO-Portal + OIDC |
 | `traefik.*` | `api@internal` | `chain-secure-admin` | **Basic-Auth** *(→ chain-authelia)* |
 | `prometheus.*` | `http://monitoring-prometheus:9090` | `chain-secure-admin` | **Basic-Auth** *(→ chain-authelia)* |
 | `grafana.*` | `http://monitoring-grafana:3000` | – | – |
 Die Domain-Platzhalter `{{ env "HOSTNAME_BASE" }}` werden durch `da.home-webserver.de` ersetzt. Nur `office.da.home-webserver.de` ist hardcodiert.
 ### Middleware-Chains
 Die wichtigsten Middleware-Ketten:
 | Chain | Enthält |
 |---|---|---|
 | `chain-secure-admin` | `security-headers` + `auth-admin` (Basic-Auth via `.htpasswd`) |
 | `chain-app-standard` | `security-headers` + `upload-limit` + `rate-limit` |
 | `chain-immich` | `security-headers` + `rate-limit` |
 | `chain-nextcloud` | `security-headers` + `nextcloud-dav` (CalDAV/CardDAV-Redirect) + `compress` + `upload-limit` |
 | `chain-jenkins` | `jenkins-headers` (X-Forwarded-Proto/Port) + `rate-limit` |
 | **`chain-authelia`** | **`security-headers` + `authelia-forwardauth`** (ForwardAuth) |
 ### Hinweise
 - **Stirling PDF** (`pdf.*`) ist als erster Dienst auf `chain-authelia` umgestellt – ForwardAuth aktiv.
 - **Gitea** (`git.*`) hat **keine Middleware** – Authentifizierung läuft per OIDC direkt zwischen Gitea und Authelia.
 - **Prometheus** und **Traefik-Dashboard** sind noch per Basic-Auth geschützt (`auth-admin`-Middleware mit `.htpasswd`-Datei). Geplant: Umstellung auf [authelia](./authelia.md).
 - **Grafana hat KEIN Auth in Traefik** – der Schutz liegt ausschließlich bei Grafana selbst.
 - Die Collabora-Konfiguration erlaubt **iFrame-Einbettung** für Nextcloud-Integration.
 - Siehe [authelia](./authelia.md) für die vollständige SSO-Dokumentation.
 ## Let's Encrypt
 - **E-Mail**: `dial-master@gmx.de`
 - **Challenge**: HTTP (Port 80)
 - **Speicher**: `/acme.json` (gemapptes Host-Volume)
 - **Resolver-Name**: `le`
 ## DNS
 Traefik nutzt `8.8.8.8` und `1.1.1.1` als upstream DNS.
 ## Wichtige Hinweise
 - Die **encodedCharacters-Optionen** sind für [collabora](./collabora.md) wichtig (WebSockets, encoded Slashes).
 - Das **Dashboard** ist per API aktiviert, aber durch `.htpasswd` geschützt.
 - Der File Provider wird **live überwacht** (`watch=true`) – Änderungen an YAML-Dateien werden ohne Neustart übernommen.
 ## Verwandte Seiten
 - [docker-services](../docker-services.md) – Alle Dienste, die Traefik nutzen
 - [authelia](./authelia.md) – SSO mit ForwardAuth und Passkey
 - [nextcloud](./nextcloud.md)
 - [collabora](./collabora.md)
 - [gitea](./gitea.md)
 - [jenkins](./jenkins.md)
 - [domain-und-ssl](../domain-und-ssl.md)
@@ -0,0 +1,35 @@
 # Wiki.js – Wissensdatenbank
 **Zusammenfassung**: Wiki.js ist eine moderne Wiki-Plattform mit PostgreSQL-Datenbank. Bietet Markdown-Editor, Versionierung und Zugriffskontrolle.
 **Quellen**: `raw/Systemdaten – Raspberry PI5.md`
 **Zuletzt aktualisiert**: 2026-06-17
 ---
 ## Container
 | Container | Image | Funktion |
 |---|---|---|
 | `wikijs` | `requarks/wiki:2` | Wiki-App (Port 3000, 3443) |
 | `wikijs-db` | `postgres:16` | Datenbank |
 ## Netzwerk
 - `wikijs_default` – Extern (für Traefik)
 - Kein separates internes Netzwerk sichtbar
 ## Daten-Persistenz
 | Volume | Pfad im Container |
 |---|---|
 | `wikijs_wikijs_db` | `/var/lib/postgresql/data` |
 ## Besonderheiten
 - Läuft stabil seit > 25h (zum Zeitpunkt der Erfassung)
 - Verwendet das `requarks/wiki:2`-Image (stabile Major-Version 2)
 ## Verwandte Seiten
 - [traefik](./traefik.md)
 - [docker-services](../docker-services.md)
@@ -0,0 +1,41 @@
 # Domain & SSL
 **Zusammenfassung**: Alle Dienste laufen unter der Domain `da.home-webserver.de` mit Subdomains. TLS-Zertifikate werden automatisch per Let's Encrypt (HTTP-Challenge) über Traefik bezogen.
 **Quellen**: `raw/Systemdaten – Raspberry PI5.md`
 **Zuletzt aktualisiert**: 2026-06-17
 ---
 ## Domain-Schema
 ```
 da.home-webserver.de
 ├── cloud.da.home-webserver.de   → Nextcloud
 ├── office.da.home-webserver.de  → Collabora Online
 ├── photos.da.home-webserver.de  → Immich (vorgesehen, Labels auskommentiert)
 ├── da.home-webserver.de/jenkins → Jenkins (via Path Prefix)
 └── ...                          → Weitere via File Provider
 ```
 ## Let's Encrypt
 - **Resolver-Name**: `le`
 - **Challenge**: HTTP (Port 80)
 - **E-Mail**: `dial-master@gmx.de`
 - **Speicher**: `/opt/compose/traefik/acme.json`
 ## Interne IPs
 Der PI5 ist unter zwei IPs erreichbar:
 - `192.168.178.77` (eth0 – kabelgebunden)
 - `192.168.178.66` (wlan0 – WLAN)
 ## DNS
 Voraussetzung für den Betrieb ist, dass die öffentliche Domain auf die öffentliche IP des Routers zeigt und der Router Port 80/443 an den PI5 weiterleitet. Traefik selbst nutzt `8.8.8.8` und `1.1.1.1` als DNS-Resolver.
 ## Verwandte Seiten
 - [traefik](./docker/traefik.md) – Let's-Encrypt-Konfiguration im Detail
 - [systemuebersicht](./systemuebersicht.md)
 - [docker-services](./docker-services.md)
@@ -0,0 +1,82 @@
 # cryptsetup – Befehle für LUKS-Container
 **Zusammenfassung**: Die wichtigsten `cryptsetup`-Befehle zur Verwaltung von LUKS-verschlüsselten Containern – vom Öffnen und Schließen bis zur Schlüsselverwaltung.
 **Quellen**: `chats/fstab und crypttab.md`
 **Zuletzt aktualisiert**: 2026-06-16
 ---
 ## Übersicht
 `cryptsetup` ist das Werkzeug zur Einrichtung und Verwaltung von **dm-crypt** + **LUKS**-Verschlüsselung. Auf dem Raspberry PI5 werden zwei LUKS2-Container verwendet ([crypttab](./crypttab.md)).
 ## Befehle nach Aufgaben gruppiert
 ### Container öffnen und schließen
 ```bash
 # LUKS-Container öffnen (entschlüsseln)
 sudo cryptsetup luksOpen /dev/sdX3 container_name --key-file /pfad/zur/schluesseldatei.bin
 # Beispiel: encrypt_data öffnen
 sudo cryptsetup luksOpen /dev/sdb3 encrypt_data --key-file /mnt/usb_key/twotb.bin
 # Beispiel: encrypt_sdc3 öffnen
 sudo cryptsetup luksOpen /dev/sdc3 encrypt_sdc3 --key-file /mnt/usb_key/onetb.bin
 # Container schließen (verschlüsseln)
 sudo cryptsetup luksClose container_name
 ```
 ### Schlüsselverwaltung
 ```bash
 # Neuen Schlüssel (Key-File) zu einem LUKS-Container hinzufügen
 sudo cryptsetup luksAddKey /dev/sdX3 /pfad/neuer-schluessel.bin
 # Vorhandene Schlüssel auflisten
 sudo cryptsetup luksDump /dev/sdX3
 # Schlüssel entfernen
 sudo cryptsetup luksRemoveKey /dev/sdX3
 ```
 ### Status und Informationen
 ```bash
 # LUKS-Header-Informationen anzeigen
 sudo cryptsetup luksDump /dev/sdX3
 # Prüfen, ob ein Device LUKS ist
 sudo cryptsetup isLuks /dev/sdX3
 # Status eines geöffneten Containers anzeigen
 sudo cryptsetup status container_name
 ```
 ## Schlüsseldatei erstellen
 Eine sichere Schlüsseldatei wird mit `/dev/urandom` erzeugt:
 ```bash
 # 4KB zufällige Schlüsseldatei erstellen
 sudo dd if=/dev/urandom of=/mnt/usb_key/mein-schluessel.bin bs=4096 count=4
 # Berechtigungen setzen (nur root lesen)
 sudo chmod 0400 /mnt/usb_key/mein-schluessel.bin
 # Schlüssel zu LUKS-Container hinzufügen
 sudo cryptsetup luksAddKey /dev/sdX3 /mnt/usb_key/mein-schluessel.bin
 ```
 ## Wichtige Hinweise
 - `luksAddKey` fragt nach einer **vorhandenen Passphrase oder einem vorhandenen Schlüssel**, bevor der neue hinzugefügt wird.
 - Schlüsseldateien sollten **nur von root lesbar** sein (`chmod 0400`).
 - Der USB-Stick mit den Schlüsseln muss **physisch sicher** aufbewahrt werden.
 ## Verwandte Seiten
 - [crypttab](./crypttab.md) – Automatisierte Entschlüsselung beim Boot
 - [luks-verschluesselung](../luks-verschluesselung.md) – LUKS-Konzepte und Arbeitsweise
 - [persistente-blockgeraete](../persistente-blockgeraete.md) – UUID vs. /dev/sdX
@@ -0,0 +1,52 @@
 # crypttab – LUKS-Entschlüsselungstabelle
 **Zusammenfassung**: Die `/etc/crypttab` steuert, welche LUKS-verschlüsselten Container beim Boot automatisch geöffnet werden. Der Raspberry PI5 verwendet zwei LUKS2-Container, die mit Schlüsseldateien auf einem USB-Stick entsperrt werden.
 **Quellen**: `konfigurationsdateien/crypttab`, `chats/fstab und crypttab.md`
 **Zuletzt aktualisiert**: 2026-06-16
 ---
 ## Aktuelle crypttab
 ```
 # <target name>    <source device>                                     <key file>                      <options>
 encrypt_data       UUID=097bccad-d77d-48bb-9365-9ca2187cf66b            /mnt/usb_key/twotb.bin          luks,tries=3,x-systemd.requires=mnt-usb_key.mount,x-systemd.after=mnt-usb_key.mount,x-systemd.device-timeout=15s
 encrypt_sdc3       UUID=82550dc2-61f7-415e-8335-0d75c89f9629            /mnt/usb_key/onetb.bin          luks,tries=3,x-systemd.requires=mnt-usb_key.mount,x-systemd.after=mnt-usb_key.mount,x-systemd.device-timeout=15s
 ```
 ## Spalten erklärt
 ### 1. Zielname (`<target name>`)
 Der Name des gemappten Devices unter `/dev/mapper/`. Wird später in der [fstab](./fstab.md) als `<file system>` verwendet.
 - `encrypt_data` → `/dev/mapper/encrypt_data` → wird gemountet als `/mnt/data`
 - `encrypt_sdc3` → `/dev/mapper/encrypt_sdc3` → wird gemountet als `/media/piadmin/data`
 ### 2. Quelldevice (`<source device>`)
 Das physische LUKS-Device, identifiziert per **UUID** (persistent und sdX-unabhängig).
 - `UUID=097bccad-...` → sdb3 (LUKS-Container für `/mnt/data`)
 - `UUID=82550dc2-...` → sdc3 (LUKS-Container für `/media/piadmin/data`)
 ### 3. Schlüsseldatei (`<key file>`)
 Der Pfad zur Datei, die den Entschlüsselungsschlüssel enthält.
 - `/mnt/usb_key/twotb.bin` – Schlüssel für `encrypt_data` (2TB-Laufwerk)
 - `/mnt/usb_key/onetb.bin` – Schlüssel für `encrypt_sdc3` (1TB-Laufwerk)
 **Wichtig**: Der USB-Stick (`/dev/sda1`, gemountet als `/mnt/usb_key`) muss **vor** dem Entschlüsseln verfügbar sein – deshalb die `x-systemd.*`-Optionen (siehe [systemd-cryptsetup](./systemd-cryptsetup.md)).
 ### 4. Optionen (`<options>`)
 - **luks** – LUKS-Modus (Standard für LUKS-Container)
 - **tries=3** – Maximale Fehlversuche bei der Entschlüsselung
 - **x-systemd.requires=mnt-usb_key.mount** – systemd: Der USB-Key-Mount muss aktiv sein
 - **x-systemd.after=mnt-usb_key.mount** – systemd: Erst mounten, dann entschlüsseln
 - **x-systemd.device-timeout=15s** – systemd: Zeitlimit für das Warten auf das Device
 ## Verwandte Seiten
 - [fstab](./fstab.md) – Mountet die geöffneten LUKS-Container
 - [systemd-cryptsetup](./systemd-cryptsetup.md) – systemd-Boot-Reihenfolge im Detail
 - [cryptsetup](./cryptsetup.md) – cryptsetup-Befehle
 - [luks-verschluesselung](../luks-verschluesselung.md) – LUKS-Konzepte
 - [persistente-blockgeraete](../persistente-blockgeraete.md) – Warum UUID statt /dev/sdX
@@ -0,0 +1,61 @@
 # fstab – Dateisystemtabelle
 **Zusammenfassung**: Die `/etc/fstab` steuert, welche Dateisysteme wo und mit welchen Optionen gemountet werden. Alle Einträge verwenden persistente Referenzen (PARTUUID oder `/dev/mapper/`), um sdX-Vertauschungen zu vermeiden.
 **Quellen**: `konfigurationsdateien/fstab`, `chats/fstab und crypttab.md`
 **Zuletzt aktualisiert**: 2026-06-16
 ---
 ## Aktuelle fstab
 ```
 # <file system>                                  <mount point>              <type>  <options>                     <dump> <pass>
 PARTUUID=228e9390-01                             /boot/firmware             vfat    defaults,noatime               0      0
 PARTUUID=228e9390-02                             /                          ext4    defaults,noatime               0      1
 /dev/mapper/encrypt_data                         /mnt/data                  ext4    defaults,nofail                0      2
 /dev/disk/by-partuuid/83910788-01                /media/piadmin/bootfs      vfat    defaults,noatime               0      0
 /dev/disk/by-partuuid/83910788-02                /media/piadmin/rootfs      ext4    defaults,noatime               0      2
 /dev/mapper/encrypt_sdc3                         /media/piadmin/data        ext4    defaults,nofail                0      2
 # swap devices handled by systemd/zram (not in fstab)
 ```
 ## Spalten erklärt
 ### 1. Dateisystem (`<file system>`)
 - **PARTUUID=...** – Persistente Partition-ID (bleibt gleich, auch wenn sich `/dev/sdX` ändert)
 - **/dev/mapper/...** – Gemappter LUKS-Container-Name (von cryptsetup erzeugt)
 - **/dev/disk/by-partuuid/...** – Alternativer persistenter Pfad über partuuid
 ### 2. Mountpunkt (`<mount point>`)
 Der Pfad, unter dem das Dateisystem eingehängt wird.
 ### 3. Dateisystemtyp (`<type>`)
 - `vfat` – FAT32 (für Boot-Partition)
 - `ext4` – Standard-Linux-Dateisystem (für Root und Daten)
 ### 4. Mount-Optionen (`<options>`)
 - **defaults** – Standard-Optionen (rw, suid, dev, exec, auto, nouser, async)
 - **noatime** – Unterdrückt Zugriffszeitstempel, spart Schreibzugriffe
 - **nofail** – Boot fährt fort, auch wenn das Device nicht verfügbar ist (wichtig für LUKS-Container, die erst geöffnet werden müssen)
 ### 5. Dump (`<dump>`)
 - `0` – Kein Backup mit dump (immer 0 auf modernen Systemen)
 ### 6. Pass (`<pass>`)
 - `0` – Kein fsck-Durchlauf
 - `1` – fsck als erstes (nur Root-Dateisystem)
 - `2` – fsck danach (alle anderen)
 ## Besonderheiten
 - **Swap fehlt in der fstab**: Der Raspberry PI5 verwendet **zram** und **loop** für Swap, die von systemd automatisch verwaltet werden. Siehe [swap-zram](../swap-zram.md).
 - **FAT32 und fsck**: vfat wird nicht von `fsck.ext4` geprüft – daher `pass 0`.
 - **LUKS-Mapper**: `/dev/mapper/encrypt_data` und `/dev/mapper/encrypt_sdc3` werden erst beim Boot durch cryptsetup erzeugt (siehe [crypttab](./crypttab.md)).
 ## Verwandte Seiten
 - [crypttab](./crypttab.md) – LUKS-Entschlüsselungskonfiguration
 - [persistente-blockgeraete](../persistente-blockgeraete.md) – UUID, PARTUUID, by-partuuid
 - [luks-verschluesselung](../luks-verschluesselung.md) – LUKS-Konzepte
 - [sdx-vertauschung](../sdx-vertauschung.md) – Warum persistente Referenzen wichtig sind
 - [swap-zram](../swap-zram.md) – Swap-Konfiguration
@@ -0,0 +1,86 @@
 # systemd-cryptsetup – Boot-Reihenfolge und Abhängigkeiten
 **Zusammenfassung**: systemd steuert die Reihenfolge beim Boot: Zuerst muss der USB-Stick mit den Schlüsseldateien gemountet sein, dann können die LUKS-Container geöffnet werden. Spezielle crypttab-Optionen stellen dies sicher.
 **Quellen**: `chats/fstab und crypttab.md`, `konfigurationsdateien/crypttab`
 **Zuletzt aktualisiert**: 2026-06-16
 ---
 ## Die Herausforderung
 Die LUKS-Container auf sdb3 und sdc3 werden mit Schlüsseldateien auf einem USB-Stick (`/dev/sda1`) entsperrt. Beim Boot muss systemd sicherstellen:
 1. **USB-Stick mounten** (`/mnt/usb_key`)
 2. **Dann erst** die LUKS-Container öffnen (Schlüsseldatei liegt auf dem USB-Stick)
 3. **Dann** die Dateisysteme mounten (siehe [fstab](./fstab.md))
 ## Lösung: systemd-Optionen in der crypttab
 Die crypttab-Einträge enthalten systemd-spezifische Optionen:
 ```
 encrypt_data UUID=097bccad-... /mnt/usb_key/twotb.bin luks,tries=3,\
  x-systemd.requires=mnt-usb_key.mount,\
  x-systemd.after=mnt-usb_key.mount,\
  x-systemd.device-timeout=15s
 ```
 ### Optionen im Detail
 | Option | Wirkung |
 |---|---|
 | `x-systemd.requires=mnt-usb_key.mount` | Stellt sicher, dass der USB-Key-Mount **aktiv** ist, bevor der LUKS-Container geöffnet wird. Schlägt der Mount fehl, wird auch der Container nicht geöffnet. |
 | `x-systemd.after=mnt-usb_key.mount` | Legt die **Reihenfolge** fest: Der USB-Key-Mount muss **vor** dem Container-Öffnen gestartet werden. |
 | `x-systemd.device-timeout=15s` | systemd wartet maximal 15 Sekunden auf das Device (falls der USB-Stick langsam initialisiert). |
 | `tries=3` | Maximale Anzahl an Fehlversuchen bei der Entschlüsselung. |
 ### Wie der Unit-Name zustande kommt
 Der systemd-Mount-Name folgt einer festen Konvention: Pfade werden mit `-` statt `/` und `.mount` als Suffix geschrieben.
 - `/mnt/usb_key` → `mnt-usb_key.mount`
 - `/mnt/data` → `mnt-data.mount`
 ## Ablauf beim Boot
 ```
 USB-Stick wird erkannt (udev)
  │
  ▼
 mnt-usb_key.mount (systemd mount unit)
  │
  ├── x-systemd.requires ──┐
  ├── x-systemd.after ─────┤
  │                        ▼
  │    systemd-cryptsetup@encrypt_data.service
  │    systemd-cryptsetup@encrypt_sdc3.service
  │                        │
  │                        ▼
  │    /dev/mapper/encrypt_data  ← verfügbar
  │    /dev/mapper/encrypt_sdc3  ← verfügbar
  │
  ▼
 mnt-data.mount  (aus /etc/fstab)
 media-piadmin-data.mount  (aus /etc/fstab)
 ```
 ## Fehlerbehebung
 ```bash
 # Status des Container-Öffnens prüfen
 journalctl -b -u systemd-cryptsetup@encrypt_data.service -e
 journalctl -b -u systemd-cryptsetup@encrypt_sdc3.service -e
 # Prüfen, ob der USB-Stick gemountet ist
 lsblk /dev/sda
 mount | grep usb_key
 # systemd-Abhängigkeiten visualisieren
 systemctl list-dependencies mnt-data.mount
 ```
 ## Verwandte Seiten
 - [crypttab](./crypttab.md) – Die crypttab-Konfiguration
 - [fstab](./fstab.md) – Mountet die geöffneten Container
 - [cryptsetup](./cryptsetup.md) – Manuelle cryptsetup-Befehle
@@ -0,0 +1,68 @@
 # Konfigurationsindex – Raspberry PI5
 **Zusammenfassung**: Inhaltsverzeichnis aller Konfigurationsseiten des Raspberry-PI5-Systems `da-server-pi5`.
 **Quellen**: Systemkonfiguration, Docker-Compose-Stacks, Chat-Dokumentation
 **Zuletzt aktualisiert**: 2026-06-18
 ---
 ## System & Hardware
 | Seite | Quelle |
 |---|---|
 | [systemuebersicht](./systemuebersicht.md) – OS, Kernel, RAM, Docker-Status, Systemd-Dienste | 🖥️ Script + 🔌 SSH |
 | [laufwerke-und-speicher](./laufwerke-und-speicher.md) – Laufwerke, Partitionen, LUKS, Speicherbelegung | 🖥️ Script + 🔌 SSH |
 | [hardware](../Allgemein/hardware.md) – PI5-Hardware: CPU, USB, Temperatur, Boot-Config | 🔌 SSH |
 | [netzwerk](../Allgemein/netzwerk.md) – Interfaces, DNS, Ports, öffentliche Dienste | 🔌 SSH |
 | [sicherheit](../Allgemein/sicherheit.md) – SSH, Benutzer, LUKS, bekannte Lücken | 🔌 SSH |
 ## Systemkonfiguration (`/etc/`)
 - [fstab](./etc/fstab.md) – Dateisystemtabelle: Mountpunkte, Optionen, persistente Referenzen
 - [crypttab](./etc/crypttab.md) – LUKS-Entschlüsselungstabelle: automatisierte Container-Öffnung beim Boot
 - [cryptsetup](./etc/cryptsetup.md) – cryptsetup-Befehle: LUKS-Container öffnen, schließen, Schlüssel verwalten
 - [systemd-cryptsetup](./etc/systemd-cryptsetup.md) – systemd-Integration: Boot-Reihenfolge und Abhängigkeiten
 ### Laufwerke & Verschlüsselung
 - [persistente-blockgeraete](./persistente-blockgeraete.md) – UUID, PARTUUID, `/dev/disk/by-*`: Stabile Geräte-Referenzen
 - [sdx-vertauschung](./sdx-vertauschung.md) – sdX-Vertauschungsproblem: Ursachen und Lösung
 - [luks-verschluesselung](./luks-verschluesselung.md) – LUKS-Verschlüsselung: Konzepte und Arbeitsweise
 - [swap-zram](./swap-zram.md) – Swap via zram und loop
 ## Docker
 | Seite | Quelle |
 |---|---|
 | [docker-grundlagen](./docker-grundlagen.md) – Docker-Version, Netzwerke, Volumes, Image-Aufräumpotential | 🖥️ Script + 🔌 SSH (18.06., Update 20:00) |
 | [docker-services](./docker-services.md) – Alle 31 Container (30 laufend) im Überblick | 🔌 SSH Live (18.06., Update 20:00) |
 | [opt-compose](./opt-compose.md) – Struktur von `/opt/compose/` | 🖥️ Script |
 | [traefik](./docker/traefik.md) – Reverse Proxy mit File Provider (vollständige Routing-Tabelle) | 🖥️ Script + 🔌 SSH |
 | [nextcloud](./docker/nextcloud.md) – Cloud-Speicher mit MariaDB, Redis | 🖥️ Script |
 | [immich](./docker/immich.md) – Foto-Management mit ML-Suche | 🖥️ Script |
 | [paperless](./docker/paperless.md) – Dokumentenmanagement mit OCR | 🖥️ Script |
 | [plex](./docker/plex.md) – Media Server | 🖥️ Script |
 | [gitea](./docker/gitea.md) – Git-Service mit MariaDB (seit 17.06.: `restart: unless-stopped`, läuft wieder) | 🖥️ Script + 🔌 SSH |
 | [jenkins](./docker/jenkins.md) – CI/CD mit Docker-Socket-Zugriff | 🖥️ Script |
 | [collabora](./docker/collabora.md) – Online Office (WOPI-Integration in Nextcloud) | 🖥️ Script |
 | [wikijs](./docker/wikijs.md) – Wissensdatenbank mit PostgreSQL | 🖥️ Script |
 | [stirling-pdf](./docker/stirling-pdf.md) – PDF-Bearbeitung | 🖥️ Script |
 | [nginx](./docker/nginx.md) – Static Webserver | 🖥️ Script |
 | [authelia](./docker/authelia.md) – SSO mit Passkey (aktiv seit 18.06.) | 🔌 SSH Live (18.06.) |
 | [monitoring](./docker/monitoring.md) – Prometheus/Grafana-Stack (wieder aktiv seit 17.06.) | 🔌 SSH Live (18.06.) |
 ## Netzwerk & Zugriff
 | Seite | Quelle |
 |---|---|
 | [domain-und-ssl](./domain-und-ssl.md) – Domain `da.home-webserver.de`, Let's Encrypt, DNS | 🖥️ Script + 🔌 SSH |
 ---
 ## Quelldokumente (unveränderlich)
 - `chats/fstab und crypttab.md` – Chat-Verlauf zur LUKS-Mount-Einrichtung
 - `konfigurationsdateien/fstab` – Aktive fstab des Systems
 - `konfigurationsdateien/crypttab` – Aktive crypttab des Systems
 - `raw/Systemdaten – Raspberry PI5.md` – Systemdaten-Ausgabe vom 17.06.2026
 - `raw/Systemdaten – Raspberry PI5 – 2026-06-18.md` – Live-Systemdaten via SSH vom 18.06.2026
@@ -0,0 +1,114 @@
 # Laufwerke und Speicher
 **Zusammenfassung**: Der Raspberry PI5 hat drei physische Laufwerke (USB-Key, 931-GB-SSD auf sdb, 1,8-TB-SSD auf sdc) mit zwei LUKS2-verschlüsselten Datenpartitionen. Beide Partitionen enthalten identische Daten – vermutlich eine 1:1-Kopie.
 **Quellen**: 🖥️ `raw/Systemdaten – Raspberry PI5.md`, 🔌 SSH
 **Zuletzt aktualisiert**: 2026-06-17
 ---
 ## Laufwerke (lsblk)
 ```
 NAME                 SIZE TYPE  FSTYPE      FSVER LABEL     MOUNTPOINT
 sda                966M  disk
 └─sda1             964M  part  ext4        1.0   LUKS_KEY  /mnt/usb_key
 sdb              931.5G  disk
 ├─sdb1             512M  part  vfat        FAT32 bootfs    /media/piadmin/bootfs
 ├─sdb2           237.8G  part  ext4        1.0   rootfs    /media/piadmin/rootfs
 └─sdb3           693.2G  part  crypto_LUKS 2
  └─encrypt_sdc3 693.2G  crypt ext4        1.0             /media/piadmin/data
 sdc                1.8T  disk
 ├─sdc1             512M  part  vfat        FAT32 bootfs    /boot/firmware
 ├─sdc2           306.8G  part  ext4        1.0   rootfs    /
 └─sdc3             1.5T  part  crypto_LUKS 2
  └─encrypt_data   1.5T  crypt ext4        1.0             /mnt/data
 zram0                2G  disk  swap        1     zram0     [SWAP]
 loop0                2G  loop  swap        1
 ```
 ## Speicherbelegung (df -h)
 | Mountpunkt | Größe | Belegt | Verfügbar | Belegt % |
 |---|---|---|---|---|
 | `/` (sdc2) | 302 GB | 200 GB | 90 GB | **70 %** |
 | `/boot/firmware` (sdc1) | 510 MB | 82 MB | 429 MB | 16 % |
 | `/media/piadmin/bootfs` (sdb1) | 510 MB | 79 MB | 432 MB | 16 % |
 | `/media/piadmin/rootfs` (sdb2) | 234 GB | 35 GB | 188 GB | 16 % |
 | `/mnt/data` (encrypt_data) | 1,5 TB | 646 GB | 807 GB | 45 % |
 | `/media/piadmin/data` (encrypt_sdc3) | 682 GB | 646 GB | 1,3 GB | **100 % 🔴** |
 ## Partitionen und IDs
 | Device | PARTUUID | UUID (FS) | UUID (LUKS) | Label |
 |---|---|---|---|---|
 | sda1 | `74c328f0-...` | `1473da78-...` | – | `LUKS_KEY` |
 | sdb1 | `83910788-01` | `F737-8E10` | – | `bootfs` |
 | sdb2 | `83910788-02` | `d6ecfcd5-...` | – | `rootfs` |
 | sdb3 | `83910788-03` | – | `82550dc2-...` | – |
 | sdc1 | `228e9390-01` | `F587-071F` | – | `bootfs` |
 | sdc2 | `228e9390-02` | `d6944274-...` | – | `rootfs` |
 | sdc3 | `228e9390-03` | – | `097bccad-...` | – |
 ## Detail: Speicherbelegung nach Verzeichnis
 | Verzeichnis | Belegung |
 |---|---|
 | `/mnt/data/Media/` | **467 GB** |
 | `/mnt/data/nextcloud/` | **92 GB** |
 | `/mnt/data/immich/` | **69 GB** |
 | `/mnt/data/PI2Backup/` | **18 GB** |
 | `/mnt/data/paperless/` | **966 MB** |
 | `/mnt/data/www/` | **722 MB** |
 (Quelle: `du -sh /mnt/data/*/`)
 ## 🔴 Wichtige Feststellung: Zwei Partitionen, identische Daten
 **`/mnt/data`** (1,5 TB, 45 % voll) und **`/media/piadmin/data`** (682 GB, 100 % voll) haben **exakt dieselbe Verzeichnisstruktur und Dateibelegung**:
 | Verzeichnis | `/mnt/data` | `/media/piadmin/data` |
 |---|---|---|
 | Media/ | 467 GB | 467 GB |
 | nextcloud/ | 92 GB | 92 GB |
 | immich/ | 69 GB | 69 GB |
 | PI2Backup/ | 18 GB | 18 GB |
 | paperless/ | 966 MB | 966 MB |
 | www/ | 722 MB | 722 MB |
 Es handelt sich um **zwei separate LUKS-Partitionen** (nicht um einen Bind-Mount oder Symlink). Vermutlich wurden die Daten von der kleineren (682 GB) auf die größere (1,5 TB) Partition kopiert und die Konfiguration läuft inzwischen über die größere. Während `/mnt/data` noch 807 GB frei hat, ist `/media/piadmin/data` komplett voll.
 **Die Dienste sind wie folgt konfiguriert:**
 - **Immich** schreibt nach `/mnt/data/immich/` (via `.env`-Variable `UPLOAD_LOCATION`)
 - **Nextcloud**, **Paperless**, **Media** liegen auf `/mnt/data/` (Bind-Mounts in den Compose-Dateien)
 → `/media/piadmin/data` scheint nicht mehr aktiv von Diensten genutzt zu werden, belegt aber 646 GB wertvollen SSD-Platz. Eine Bereinigung oder Deaktivierung dieser Partition wäre sinnvoll.
 ## Krytische Warnung
 **🔴 `/media/piadmin/data` ist zu 100 % voll** (646 GB von 682 GB). Aktuell aktiv genutzte Dienste scheinen jedoch auf `/mnt/data` zu schreiben, sodass dies nur ein Platzproblem, aber kein akutes Betriebsproblem darstellt.
 ## LUKS-Container
 | Mapper | Physisch | Schlüsseldatei | Mount |
 |---|---|---|---|
 | `encrypt_data` | sdc3 (1,5 TB) | `/mnt/usb_key/twotb.bin` | `/mnt/data` |
 | `encrypt_sdc3` | sdb3 (693 GB) | `/mnt/usb_key/onetb.bin` | `/media/piadmin/data` |
 Siehe [crypttab](./etc/crypttab.md) und [luks-verschluesselung](./luks-verschluesselung.md).
 ## Swap
 - **zram0**: 2 GB komprimierter RAM-Swap
 - **loop0**: 2 GB Datei-basierter Swap
 Beide werden von systemd verwaltet, ohne fstab-Eintrag. Siehe [swap-zram](./swap-zram.md).
 ## Verwandte Seiten
 - [fstab](./etc/fstab.md)
 - [crypttab](./etc/crypttab.md)
 - [luks-verschluesselung](./luks-verschluesselung.md)
 - [persistente-blockgeraete](./persistente-blockgeraete.md)
 - [sdx-vertauschung](./sdx-vertauschung.md)
 - [swap-zram](./swap-zram.md)
 - [systemuebersicht](./systemuebersicht.md)
@@ -0,0 +1,107 @@
 # Änderungslog – Systemkonfiguration Raspberry PI5
 <style>
 .markdown-reading-view .markdown-preview-view table,
 .markdown-source-view table {
  width: 100% !important;
  table-layout: auto !important;
  font-size: 0.9em;
 }
 .markdown-reading-view .markdown-preview-view th,
 .markdown-reading-view .markdown-preview-view td,
 .markdown-source-view th,
 .markdown-source-view td {
  white-space: normal !important;
  word-wrap: break-word !important;
 }
 .markdown-reading-view .markdown-preview-view th:nth-child(6),
 .markdown-reading-view .markdown-preview-view td:nth-child(6) {
  min-width: 250px;
 }
 </style>
 **Zusammenfassung**: Chronologische Übersicht aller Änderungen an der Systemkonfiguration.
 **Quellen**: Eigene Aufzeichnungen
 **Zuletzt aktualisiert**: 2026-06-19 (Update 21:45)
 **Legende**:
 - 🖥️ `sammle-systemdaten.sh` – Daten per Script-Ausführung auf dem PI5 erfasst
 - 🔌 SSH – Daten per direktem SSH-Zugriff auf den PI5 erhoben (lesend)
 - 🧑 Benutzer – manuelle Änderung auf dem PI5 durch den Benutzer
 - 🧭 Konzept – Planungsdokument (noch nicht umgesetzt)
 ---
 | Datum      | Typ          | Uhrzeit    | Quelle                                            | Zugriff     | Änderung                                                                                                                                                       |
 | ---------- | ------------ | ---------- | ------------------------------------------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | 2026-06-19 | Aktualisiert | 21:45      | Alle Docker-Dokumente                             | 🔌 SSH      | Live-Daten neu eingelesen: 188 Images/174,1 GB, Uptimes 13h, WebAuthn-Config, consent_mode dokumentiert                                                        |
 | 2026-06-19 | Aktualisiert | ~21:31     | `authelia configuration.yml`                      | 🧑 Benutzer | WebAuthn-Block überarbeitet: direct attestation, metadata validation, enable_passkey_login, filtering                                                          |
 | 2026-06-19 | Aktualisiert | ~21:31     | `authelia configuration.yml`                      | 🧑 Benutzer | OIDC-Gitea-Client: consent_mode pre-configured + 3 Monate Dauer                                                                                                |
 | 2026-06-18 | Aktualisiert | 21:30      | `Konfiguration/log.md`                            | 🔌 SSH      | Struktur auf flache Tabelle mit Datums-Spalte umgestellt                                                                                                       |
 | 2026-06-18 | Aktualisiert | 21:15      | Alle Docker-Dokumente                             | 🔌 SSH      | Live-Daten neu eingelesen: 30 laufend, authelia & gitea Uptimes, Image-Statistik 187/173,9 GB, Routing-Tabelle aktualisiert, authelia-Status auf ✅ aktiv       |
 | 2026-06-18 | Aktualisiert | 21:15      | `Konfiguration/log.md`                            | 🔌 SSH      | Uhrzeit-Spalte ergänzt                                                                                                                                         |
 | 2026-06-18 | ✅            | 21:10      | Gitea OIDC                                        | 🧑 Benutzer | Gitea-Login via Authelia OIDC funktioniert                                                                                                                     |
 | 2026-06-18 | Korrektur    | 21:10      | `authelia configuration.yml`                      | 🧑 Benutzer | Zweite redirect_uri mit `Authelia` (groß A) ergänzt                                                                                                            |
 | 2026-06-18 | Fehler       | ~20:08     | Gitea OIDC                                        | 🧑 Benutzer | redirect_uri `authelia/callback` vs `Authelia/callback` (Case-Sensitivity)                                                                                     |
 | 2026-06-18 | Aktualisiert | 20:07      | `0150-stirling.yml` (Traefik)                     | 🧑 Benutzer | Stirling PDF auf `chain-authelia` umgestellt – erster Dienst mit ForwardAuth                                                                                   |
 | 2026-06-18 | Korrektur    | 20:07      | `authelia configuration.yml`                      | 🧑 Benutzer | PEM-Footer korrigiert, Authelia startet mit OIDC                                                                                                               |
 | 2026-06-18 | Fehler       | 20:01      | Authelia OIDC                                     | 🔌 SSH      | PEM-Footer `----` (4 Striche) statt `-----` (5) – Authelia stürzt ab                                                                                           |
 | 2026-06-18 | Korrektur    | 20:01      | `authelia configuration.yml`                      | 🧑 Benutzer | `issuer_private_keys` → `jwks` umbenannt                                                                                                                       |
 | 2026-06-18 | Fehler       | 17:50      | Authelia OIDC                                     | 🔌 SSH      | `issuer_private_keys` ist in v4.39 deprecated, OIDC startet nicht (`jwks` erforderlich)                                                                        |
 | 2026-06-18 | Korrektur    | ~17:50     | `authelia configuration.yml`                      | 🧑 Benutzer | RSA-Key eingesetzt (Platzhalter ersetzt), `encryption_key`, `session.secret`, `jwt_secret` gesetzt                                                             |
 | 2026-06-18 | Korrektur    | 17:33      | `authelia configuration.yml`                      | 🧑 Benutzer | User-Key `dial` → `Dial` (case-sensitive)                                                                                                                      |
 | 2026-06-18 | Aktualisiert | ~Vormittag | `Konfiguration/log.md`                            | 🔌 SSH      | Dieser Eintrag                                                                                                                                                 |
 | 2026-06-18 | Aktualisiert | ~Vormittag | `Konfiguration/index.md`                          | 🔌 SSH      | Datenstände aktualisiert, neuer Raw-Dump verlinkt                                                                                                              |
 | 2026-06-18 | Aktualisiert | ~Vormittag | `Konfiguration/opt-compose.md`                    | 🔌 SSH      | authelia/ im Verzeichnisbaum ergänzt                                                                                                                           |
 | 2026-06-18 | Aktualisiert | ~Vormittag | `Konfiguration/docker/traefik.md`                 | 🔌 SSH      | Verweis auf Authelia ergänzt, Routing-Tabelle um `auth.*` erweitert                                                                                            |
 | 2026-06-18 | Aktualisiert | ~Vormittag | `Konfiguration/docker-grundlagen.md`              | 🔌 SSH      | 29 laufend (statt 28), Monitoring läuft wieder, Valkey-Notiz (immich), dangling Images, anonyme Volumes 152→~151                                               |
 | 2026-06-18 | Aktualisiert | ~Vormittag | `Konfiguration/docker-services.md`                | 🔌 SSH      | Container-Statistik von 28→29 laufend, Monitoring läuft (war exited), Gitea (alt) entfernt, alle Image-Versionen & Ports live korrigiert, Uptimes aktualisiert |
 | 2026-06-18 | Neu          | ~Vormittag | `Konfiguration/docker/authelia.md`                | 🧭 Konzept  | SSO-Planungsseite: Authelia mit ForwardAuth, Passkey-Unterstützung, Migrationsplan                                                                             |
 | 2026-06-18 | Daten        | ~Vormittag | `raw/Systemdaten – Raspberry PI5 – 2026-06-18.md` | 🔌 SSH      | Live-Dump via SSH (docker ps, stats, images, networks, volumes, df)                                                                                            |
 | 2026-06-17 | Aktualisiert | –          | `Konfiguration/log.md`                            | 🔌 SSH      | Legende mit Zugriffs-Markern ergänzt                                                                                                                           |
 | 2026-06-17 | Aktualisiert | –          | `Konfiguration/index.md`                          | 🔌 SSH      | Quellen-Marker (🖥️ Script / 🔌 SSH) pro Seite ergänzt                                                                                                         |
 | 2026-06-17 | Aktualisiert | –          | `Konfiguration/docker-grundlagen.md`              | 🔌 SSH      | Container-Statistik 30/28/2, 133 GB reclaimable Images, 152 anonyme Volumes, `.env`-Dateien dokumentiert                                                       |
 | 2026-06-17 | Aktualisiert | –          | `Konfiguration/docker/traefik.md`                 | 🔌 SSH      | Vollständige Routing-Tabelle aus File-Provider-YAMLs (14 Dienste), Middleware-Chains, Auth-Status pro Dienst                                                   |
 | 2026-06-17 | Aktualisiert | –          | `Konfiguration/laufwerke-und-speicher.md`         | 🔌 SSH      | Detail-Belegung per Verzeichnis; Erkenntnis: `/mnt/data` und `/media/piadmin/data` haben identische Daten – zwei getrennte Partitionen mit 1:1-Kopie           |
 | 2026-06-17 | Aktualisiert | –          | `Konfiguration/systemuebersicht.md`               | 🔌 SSH      | Docker-Statistik (30 Container, 28 laufend), Systemd-Dienste & Timer, Load Average, Image-Aufräumpotential                                                     |
 | 2026-06-17 | Neu          | –          | `Allgemein/sicherheit.md`                         | 🔌 SSH      | Sicherheits-Seite: SSH-Key-only, piadmin-Gruppen (docker!), LUKS, bekannte Lücken (Grafana-PW, Collabora)                                                      |
 | 2026-06-17 | Neu          | –          | `Allgemein/netzwerk.md`                           | 🔌 SSH      | Netzwerk-Seite: Interfaces, DNS (FritzBox), 14 Subdomains mit Diensten, Ports, HTTP-Weiterleitung auskommentiert                                               |
 | 2026-06-17 | Neu          | –          | `Allgemein/hardware.md`                           | 🔌 SSH      | PI5-Hardware-Seite: CPU, USB-Geräte (Chipsbank-Key, SanDisk, WD), PCI, Boot-Config, Temperatur                                                                 |
 | 2026-06-17 | Aktualisiert | –          | `Konfiguration/docker/gitea.md`                   | 🔌 SSH      | `restart: unless-stopped` vom Benutzer ergänzt; Container läuft jetzt; Status von "exited" auf "running" geändert                                              |
 | 2026-06-17 | Aktualisiert | –          | `Konfiguration/docker/monitoring.md`              | 🔌 SSH      | Status von "gestoppt" auf "laufend" geändert; Erkenntnis: `restart: unless-stopped` war bereits gesetzt, aber manueller Stop verhinderte Autostart nach Reboot |
 | 2026-06-17 | Korrektur    | –          | `sammle-systemdaten.sh`                           | –           | Standard-Ausgabe von `/dev/stdout` auf `/tmp/sammle-systemdaten-<datum>.md` geändert (behob doppelte Ausgabe bei Aufruf ohne Argument)                         |
 | 2026-06-17 | Aktualisiert | –          | `Konfiguration/log.md`                            | 🔌 SSH      | Dieser Eintrag                                                                                                                                                 |
 | 2026-06-17 | Aktualisiert | –          | `Konfiguration/index.md`                          | 🔌 SSH      | Inhaltsverzeichnis mit allen neuen Seiten aktualisiert                                                                                                         |
 | 2026-06-17 | Neu          | –          | `Konfiguration/domain-und-ssl.md`                 | 🔌 SSH      | Domain/SSL-Seite erstellt                                                                                                                                      |
 | 2026-06-17 | Neu          | –          | `Konfiguration/docker/monitoring.md`              | 🔌 SSH      | Monitoring-Stack-Seite erstellt (gestoppt)                                                                                                                     |
 | 2026-06-17 | Neu          | –          | `Konfiguration/docker/nginx.md`                   | 🔌 SSH      | Nginx-Seite erstellt                                                                                                                                           |
 | 2026-06-17 | Neu          | –          | `Konfiguration/docker/stirling-pdf.md`            | 🔌 SSH      | Stirling-PDF-Seite erstellt                                                                                                                                    |
 | 2026-06-17 | Neu          | –          | `Konfiguration/docker/wikijs.md`                  | 🔌 SSH      | Wiki.js-Seite erstellt                                                                                                                                         |
 | 2026-06-17 | Neu          | –          | `Konfiguration/docker/collabora.md`               | 🔌 SSH      | Collabora-Seite erstellt                                                                                                                                       |
 | 2026-06-17 | Neu          | –          | `Konfiguration/docker/jenkins.md`                 | 🔌 SSH      | Jenkins-Seite erstellt                                                                                                                                         |
 | 2026-06-17 | Neu          | –          | `Konfiguration/docker/gitea.md`                   | 🔌 SSH      | Gitea-Stack-Seite erstellt                                                                                                                                     |
 | 2026-06-17 | Neu          | –          | `Konfiguration/docker/plex.md`                    | 🔌 SSH      | Plex-Seite erstellt                                                                                                                                            |
 | 2026-06-17 | Neu          | –          | `Konfiguration/docker/paperless.md`               | 🔌 SSH      | Paperless-Stack-Seite erstellt                                                                                                                                 |
 | 2026-06-17 | Neu          | –          | `Konfiguration/docker/immich.md`                  | 🔌 SSH      | Immich-Stack-Seite erstellt                                                                                                                                    |
 | 2026-06-17 | Neu          | –          | `Konfiguration/docker/nextcloud.md`               | 🔌 SSH      | Nextcloud-Stack-Seite erstellt                                                                                                                                 |
 | 2026-06-17 | Neu          | –          | `Konfiguration/docker/traefik.md`                 | 🔌 SSH      | Traefik-Reverse-Proxy-Seite erstellt                                                                                                                           |
 | 2026-06-17 | Neu          | –          | `Konfiguration/opt-compose.md`                    | 🔌 SSH      | Compose-Verzeichnisstruktur-Seite erstellt                                                                                                                     |
 | 2026-06-17 | Neu          | –          | `Konfiguration/docker-services.md`                | 🔌 SSH      | Docker-Dienstübersicht erstellt                                                                                                                                |
 | 2026-06-17 | Neu          | –          | `Konfiguration/docker-grundlagen.md`              | 🔌 SSH      | Docker-Grundlagenseite erstellt                                                                                                                                |
 | 2026-06-17 | Neu          | –          | `Konfiguration/laufwerke-und-speicher.md`         | 🔌 SSH      | Laufwerks- und Speicherseite erstellt                                                                                                                          |
 | 2026-06-17 | Neu          | –          | `Konfiguration/systemuebersicht.md`               | 🔌 SSH      | Systemübersichtsseite erstellt                                                                                                                                 |
 | 2026-06-17 | Daten        | –          | `raw/Systemdaten – Raspberry PI5.md`              | 🖥️ Script  | Systemdaten-Sammler (`sammle-systemdaten.sh`) auf dem PI ausgeführt                                                                                            |
 | 2026-06-16 | Aktualisiert | –          | `Systemkonfiguration Raspi PI5.md`                | –           | Übersicht und Link zum Inhaltsverzeichnis hinzugefügt                                                                                                          |
 | 2026-06-16 | Korrektur    | –          | `OPENWORK.md`                                     | –           | Tippfehler behoben und Format aktualisiert                                                                                                                     |
 | 2026-06-16 | Neu          | –          | `sammle-systemdaten.sh`                           | –           | Systemdaten-Sammler-Skript erstellt                                                                                                                            |
 | 2026-06-16 | Neu          | –          | `Konfiguration/swap-zram.md`                      | –           | Swap/zram-Konzeptseite erstellt                                                                                                                                |
 | 2026-06-16 | Neu          | –          | `Konfiguration/sdx-vertauschung.md`               | –           | sdX-Vertauschungsseite erstellt                                                                                                                                |
 | 2026-06-16 | Neu          | –          | `Konfiguration/persistente-blockgeraete.md`       | –           | UUID/PARTUUID-Konzeptseite erstellt                                                                                                                            |
 | 2026-06-16 | Neu          | –          | `Konfiguration/luks-verschluesselung.md`          | –           | LUKS-Konzeptseite erstellt                                                                                                                                     |
 | 2026-06-16 | Neu          | –          | `Konfiguration/etc/systemd-cryptsetup.md`         | –           | systemd-Boot-Reihenfolge-Seite erstellt                                                                                                                        |
 | 2026-06-16 | Neu          | –          | `Konfiguration/etc/cryptsetup.md`                 | –           | cryptsetup-Befehlsseite erstellt                                                                                                                               |
 | 2026-06-16 | Neu          | –          | `Konfiguration/etc/crypttab.md`                   | –           | crypttab-Konfigurationsseite erstellt                                                                                                                          |
 | 2026-06-16 | Neu          | –          | `Konfiguration/etc/fstab.md`                      | –           | fstab-Konfigurationsseite erstellt                                                                                                                             |
 | 2026-06-16 | Neu          | –          | `Konfiguration/log.md`                            | –           | Änderungslog begonnen                                                                                                                                          |
 | 2026-06-16 | Neu          | –          | `Konfiguration/index.md`                          | –           | Inhaltsverzeichnis für die Systemkonfiguration erstellt                                                                                                        |
 | 2026-06-16 | Neu          | –          | `chats/fstab und crypttab.md`                     | –           | Quelle aufgenommen (Duck.ai / GPT-5 mini-Konversation)                                                                                                         |
@@ -0,0 +1,74 @@
 # LUKS-Verschlüsselung
 **Zusammenfassung**: LUKS (Linux Unified Key Setup) ist der Standard für Festplattenverschlüsselung unter Linux. Der Raspberry PI5 verwendet zwei LUKS2-Container für Datenpartitionen.
 **Quellen**: `chats/fstab und crypttab.md`
 **Zuletzt aktualisiert**: 2026-06-16
 ---
 ## Grundlagen
 LUKS verschlüsselt **ganze Blockgeräte** (Partitionen). Auf dem Raspberry PI5 sind zwei LUKS-Container eingerichtet:
 | Physisches Device | LUKS-UUID | Mapper-Name | Mountpunkt |
 |---|---|---|---|
 | sdb3 | `097bccad-...` | `encrypt_data` | `/mnt/data` |
 | sdc3 | `82550dc2-...` | `encrypt_sdc3` | `/media/piadmin/data` |
 ### Schichten-Modell
 ```
 Physische Partition (/dev/sdb3, /dev/sdc3)
  └── crypto_LUKS (FSTYPE in lsblk)
       └── LUKS-Header (enthält verschlüsselte Key-Slots)
            └── Entschlüsseltes Device (/dev/mapper/encrypt_*)
                 └── Dateisystem (ext4)
 ```
 ### LUKS2
 Beide Container verwenden **LUKS2** (FSVER = 2 in `lsblk -f`). LUKS2 ist die aktuelle Version mit:
 - Flexiblerem Header-Format
 - Besseren Reparatur-Optionen
 - Unterstützung für mehrere Verschlüsselungsalgorithmen
 ## Schlüsselverwaltung
 Ein LUKS-Container kann **bis zu 32 Key-Slots** haben. Jeder Slot enthält einen kopierten Schlüssel, der mit einer Passphrase oder einer Schlüsseldatei entsperrt werden kann.
 Der Raspberry PI5 verwendet **Schlüsseldateien** statt Passphrasen:
 | Container | Schlüsseldatei |
 |---|---|
 | `encrypt_data` | `/mnt/usb_key/twotb.bin` |
 | `encrypt_sdc3` | `/mnt/usb_key/onetb.bin` |
 Vorteil: Die Container können **automatisch beim Boot** geöffnet werden, ohne Passworteingabe.
 ## Typische LUKS-Operationen
 - **luksOpen**: Container entschlüsseln → erzeugt Device unter `/dev/mapper/`
 - **luksClose**: Container schließen → entfernt `/dev/mapper/`-Device
 - **luksAddKey**: Neuen Schlüssel hinzufügen (für bis zu 32 Key-Slots)
 - **luksRemoveKey**: Schlüssel entfernen
 - **luksDump**: Header-Informationen anzeigen
 Siehe [cryptsetup](./etc/cryptsetup.md) für die genauen Befehle.
 ## Wichtige Sicherheitshinweise
 1. **Schlüsseldateien** physisch sichern – wer sie hat, kann die Container entschlüsseln.
 2. **Backup des LUKS-Headers** – bei Header-Beschädigung sind die Daten unwiederbringlich verloren:
   ```bash
   sudo cryptsetup luksHeaderBackup /dev/sdX3 --header-backup-file luks-header-backup.img
   ```
 3. **Schlüsseldatei-Berechtigungen**: Nur root lesbar (`chmod 0400`).
 4. **`nofail` in fstab**: Stellt sicher, dass der Boot auch ohne verfügbare LUKS-Container fortfährt.
 ## Verwandte Seiten
 - [crypttab](./etc/crypttab.md) – Automatisches Öffnen beim Boot
 - [fstab](./etc/fstab.md) – Mounten der entschlüsselten Container
 - [cryptsetup](./etc/cryptsetup.md) – cryptsetup-Befehle im Detail
 - [systemd-cryptsetup](./etc/systemd-cryptsetup.md) – Boot-Reihenfolge
 - [persistente-blockgeraete](./persistente-blockgeraete.md) – UUID-Referenzierung
@@ -0,0 +1,67 @@
 # /opt/compose – Compose-Struktur
 **Zusammenfassung**: Alle Docker-Stack-Konfigurationen liegen in `/opt/compose/`. Jeder Stack hat sein eigenes Unterverzeichnis mit einer `compose.yml` und ggf. Konfigurationsdateien.
 **Quellen**: `raw/Systemdaten – Raspberry PI5.md`
 **Zuletzt aktualisiert**: 2026-06-17
 ---
 ## Verzeichnisbaum
 ```
 /opt/compose/
 ├── collabora/          – [collabora](./docker/collabora.md) Online Office
 ├── gitea/              – [gitea](./docker/gitea.md) Git-Service
 ├── immich/             – [immich](./docker/immich.md) Foto-Management
 ├── jenkins/            – [jenkins](./docker/jenkins.md) CI/CD
 ├── monitoring/         – [monitoring](./docker/monitoring.md) Prometheus/Grafana
 ├── nextcloud/          – [nextcloud](./docker/nextcloud.md) Cloud-Speicher
 ├── nginx/              – [nginx](./docker/nginx.md) Static Webserver
 ├── authelia/           – [authelia](./docker/authelia.md) SSO (geplant)
 ├── paperless/          – [paperless](./docker/paperless.md) Dokumentenmanagement
 ├── plex/               – [plex](./docker/plex.md) Media-Server
 ├── stirling-pdf/       – [stirling-pdf](./docker/stirling-pdf.md) PDF-Bearbeitung
 ├── traefik/            – [traefik](./docker/traefik.md) Reverse Proxy
 └── wikijs/             – [wikijs](./docker/wikijs.md) Wiki
 ```
 ## Struktur innerhalb eines Stacks
 Jeder Stack folgt diesem Muster:
 ```
 /opt/compose/<name>/
 ├── compose.yml              # Docker-Compose-Definition
 ├── .env                     # Umgebungsvariablen (optional)
 ├── .secrets/                # Secrets (Passwörter, Tokens)
 │   ├── db_pw
 │   └── ...
 ├── conf.d/                  # Traefik file provider configs (nur bei traefik)
 ├── config/                  # Anwendungsspezifische Konfiguration
 ├── data/                    # Vom Container gemappte Daten (falls nicht im Volume)
 └── ...                      # Weitere Ressourcen je nach Anwendung
 ```
 ## Netzwerk-Integration
 Alle öffentlich erreichbaren Stacks nutzen das externe Docker-Netzwerk `traefik`:
 ```yaml
 networks:
  traefik:
    external: true
 ```
 Die eigentlichen Routing-Regeln liegen nicht in Docker-Labels, sondern in Traefiks **file provider** unter `/opt/compose/traefik/conf.d/` (siehe [traefik](./docker/traefik.md)).
 ## Daten-Persistenz
 - **Benannte Volumes** werden von Docker verwaltet (z. B. `plex_plex_config`, `gitea_gitea`)
 - **Bind Mounts** verweisen auf die LUKS-Partition `/mnt/data/` (z. B. `/mnt/data/nextcloud/`)
 - **Schlüsseldateien** für LUKS-Entschlüsselung liegen auf USB-Stick `/mnt/usb_key/`
 ## Verwandte Seiten
 - [docker-services](./docker-services.md) – Alle 17 Container im Detail
 - [docker-grundlagen](./docker-grundlagen.md) – Netzwerke und Volumes
 - [traefik](./docker/traefik.md) – Reverse-Proxy-Konfiguration
@@ -0,0 +1,67 @@
 # Persistente Blockgeräte-Referenzen
 **Zusammenfassung**: UUID, PARTUUID und `/dev/disk/by-*`-Pfade identifizieren Partitionen eindeutig und unabhängig von der dynamischen `/dev/sdX`-Benennung – essenziell für stabile Mounts.
 **Quellen**: `chats/fstab und crypttab.md`
 **Zuletzt aktualisiert**: 2026-06-16
 ---
 ## Das Problem mit `/dev/sdX`
 Die Namen `/dev/sda`, `/dev/sdb`, `/dev/sdc` etc. werden vom Linux-Kernel **in der Reihenfolge der Erkennung** vergeben. Diese kann sich bei jedem Neustart ändern, besonders bei:
 - USB-Laufwerken (unterschiedliche Initialisierungsgeschwindigkeit)
 - SD-Karten-Lesern
 - Mehreren gleichartigen Laufwerken
 Siehe [sdx-vertauschung](./sdx-vertauschung.md).
 ## Die Lösung: Eindeutige, persistente IDs
 ### Methoden im Vergleich
 | Methode | Beispiel | Persistenz | Verwendung |
 |---|---|---|---|
 | `/dev/sdb3` | `/dev/sdb3` | ❌ Nein – wechselt bei Erkennungsreihenfolge | Nicht in fstab/crypttab verwenden |
 | **UUID** | `UUID=097bccad-...` | ✅ Ja – Dateisystem-ID | Für LUKS-Container in crypttab |
 | **PARTUUID** | `PARTUUID=228e9390-02` | ✅ Ja – Partitions-Tabellen-ID | Für Root, Boot in fstab |
 | **/dev/disk/by-partuuid/** | `/dev/disk/by-partuuid/83910788-01` | ✅ Ja – wie PARTUUID als Pfad | Alternative in fstab |
 | **/dev/disk/by-uuid/** | `/dev/disk/by-uuid/F587-071F` | ✅ Ja – wie UUID als Pfad | Alternative in fstab |
 | **/dev/disk/by-id/** | `/dev/disk/by-id/usb-SanDisk_...` | ✅ Ja – Seriennummer des Geräts | Optionale udev-Regeln |
 | **/dev/mapper/** | `/dev/mapper/encrypt_data` | ✅ Ja – Name von cryptsetup | Für LUKS-Mapper in fstab |
 ### Aktuelle Verwendung auf dem Raspberry PI5
 | Komponente | Referenzmethode |
 |---|---|
 | `/boot/firmware` (sdb1/sdc1) | `PARTUUID=228e9390-01` |
 | `/` (sdb2/sdc2) | `PARTUUID=228e9390-02` |
 | LUKS-Container sdb3 | `UUID=097bccad-...` (in crypttab) |
 | LUKS-Container sdc3 | `UUID=82550dc2-...` (in crypttab) |
 | `/media/piadmin/bootfs` | `/dev/disk/by-partuuid/83910788-01` |
 | `/media/piadmin/rootfs` | `/dev/disk/by-partuuid/83910788-02` |
 ## IDs anzeigen und prüfen
 ```bash
 # Alle Blöcke mit IDs anzeigen
 sudo blkid
 # PARTUUIDs anzeigen
 lsblk -o NAME,PARTUUID,UUID,FSTYPE,LABEL,MOUNTPOINT
 # Verfügbare persistente Pfade
 ls -l /dev/disk/by-uuid/
 ls -l /dev/disk/by-partuuid/
 ls -l /dev/disk/by-id/
 ```
 ## Wichtige Regel
 **Verwende NIEMALS `/dev/sdX` in fstab oder crypttab.** Ersetze sie immer durch UUID, PARTUUID oder `/dev/disk/by-*`-Pfade.
 ## Verwandte Seiten
 - [sdx-vertauschung](./sdx-vertauschung.md) – Warum `/dev/sdX` wechselt
 - [fstab](./etc/fstab.md) – Alle Einträge mit persistenten Referenzen
 - [crypttab](./etc/crypttab.md) – UUID-Referenzen für LUKS
 - [luks-verschluesselung](./luks-verschluesselung.md) – LUKS-Konzepte
@@ -0,0 +1,76 @@
 # sdX-Vertauschung – Wechselnde Gerätenamen
 **Zusammenfassung**: Die Namen `/dev/sda`, `/dev/sdb`, `/dev/sdc` können sich bei jedem Neustart ändern. Dieses Dokument erklärt die Ursache, die Auswirkungen und wie persistente Referenzen das Problem lösen.
 **Quellen**: `chats/fstab und crypttab.md`
 **Zuletzt aktualisiert**: 2026-06-16
 ---
 ## Ursache
 Der Linux-Kernel vergibt die `/dev/sdX`-Namen in der **Reihenfolge, in der er die Geräte erkennt**. Diese Reihenfolge hängt ab von:
 - **USB-Controller-Initialisierung** (verschiedene Controller brauchen unterschiedlich lang)
 - **Port-Reihenfolge** (welcher Port zuerst scannt)
 - **Hub-Topologie** (Geräte an verschiedenen USB-Hubs)
 - **Geräte-Firmware** (manche Geräte melden sich schneller als andere)
 Selbst wenn die Laufwerke physisch in derselben Reihenfolge angeschlossen sind, können sie beim nächsten Boot **vertauscht** sein.
 ## Konkretes Beispiel vom Raspberry PI5
 Beim ersten Boot:
 ```
 sdb → Laufwerk A (bootfs, rootfs, LUKS)
 sdc → Laufwerk B (bootfs, rootfs, LUKS)
 ```
 Beim nächsten Boot (nach Neustart):
 ```
 sdb → Laufwerk B
 sdc → Laufwerk A
 ```
 Die **UUIDs und PARTUUIDs** der Partitionen bleiben dagegen **immer gleich** – unabhängig davon, ob das Device gerade `/dev/sdb` oder `/dev/sdc` heißt.
 ## Warum es auf dem Raspberry PI5 funktioniert
 Das System verwendet **durchgängig persistente Referenzen**:
 - **fstab** verwendet `PARTUUID=` und `/dev/disk/by-partuuid/` – diese folgen der Partition, nicht dem `/dev/sdX`-Namen
 - **crypttab** verwendet `UUID=` für die LUKS-Container – cryptsetup findet das richtige Device unabhängig vom Namen
 - **fstab mountet `/dev/mapper/...`** – diese Mapper-Namen sind stabil und werden von cryptsetup erzeugt
 Ergebnis: Selbst wenn sdb und sdc vertauschen, landen alle Mounts auf den **richtigen Partitionen** (Quelle: `chats/fstab und crypttab.md`).
 ## Symptome einer sdX-Vertauschung erkennen
 Wenn in der Ausgabe von `lsblk` die Devices anders heißen als erwartet, die Mounts aber trotzdem stimmen, liegt eine Vertauschung vor:
 ```bash
 lsblk -o NAME,PARTUUID,UUID,FSTYPE,LABEL,MOUNTPOINT
 ```
 Achte auf:
 - `/boot/firmware` und `/` sollten auf dem **gleichen** Laufwerk liegen (gleicher PARTUUID-Präfix wie `228e9390-*`)
 - `/mnt/data` sollte auf dem entschlüsselten Container des primären Laufwerks liegen
 ## Optionale udev-Regeln (für feste Zuordnung)
 Falls eine Zuordnung zu **physischen Ports** gewünscht ist, können udev-Regeln erstellt werden:
 ```bash
 # Beispiel: Feste Symlinks basierend auf Seriennummer
 # Datei: /etc/udev/rules.d/99-feste-laufwerke.rules
 SUBSYSTEM=="block", ENV{ID_SERIAL}=="Seriennummer_Laufwerk_A", SYMLINK+="disk_laufwerk_a"
 SUBSYSTEM=="block", ENV{ID_SERIAL}=="Seriennummer_Laufwerk_B", SYMLINK+="disk_laufwerk_b"
 ```
 Danach kann in fstab `/dev/disk_laufwerk_a` statt PARTUUID verwendet werden.
 ## Verwandte Seiten
 - [persistente-blockgeraete](./persistente-blockgeraete.md) – UUID, PARTUUID, by-partuuid
 - [fstab](./etc/fstab.md) – Verwendet persistente Referenzen
 - [crypttab](./etc/crypttab.md) – UUID-Referenzen in crypttab
 - [luks-verschluesselung](./luks-verschluesselung.md) – LUKS-Referenzierung
@@ -0,0 +1,62 @@
 # Swap – zram und loop
 **Zusammenfassung**: Der Raspberry PI5 verwendet **zram** (komprimierten RAM-Swap) und **loop** (Datei-basierten Swap) statt eines klassischen Swap-Eintrags in der fstab. systemd verwaltet diese automatisch.
 **Quellen**: `chats/fstab und crypttab.md`, `konfigurationsdateien/fstab`
 **Zuletzt aktualisiert**: 2026-06-16
 ---
 ## Ausgangslage
 In der `lsblk`-Ausgabe des Raspberry PI5 sind zwei Swap-Geräte sichtbar:
 ```
 loop0            swap    1
 zram0            swap    1     zram0
 ```
 - **loop0**: Ein Loop-Device, das als Swap dient (wird von systemd eingerichtet)
 - **zram0**: Komprimierter RAM-Swap (im Arbeitsspeicher, keine Plattenzugriffe)
 Beide werden von **systemd automatisch verwaltet** – es gibt keinen Eintrag in der [fstab](./etc/fstab.md).
 ## zram (komprimierter RAM-Swap)
 **zram** erzeugt einen komprimierten Block im RAM, der als Swap-Gerät dient.
 ### Vorteile
 - **Schnell** – reine RAM-Geschwindigkeit
 - **Kein Verschleiß** – keine SSD/SD-Karte wird beansprucht
 - **Komprimiert** – die Daten im Swap werden komprimiert, spart RAM
 ### Konfiguration prüfen
 ```bash
 # zram-Status anzeigen
 zramctl
 # Swap-Nutzung insgesamt anzeigen
 swapon --show
 # Beispiel-Ausgabe (ähnlich):
 # NAME       TYPE      SIZE   USED  PRIO
 # /dev/zram0 partition 256M   10M   100
 # /dev/loop0 file      512M    0M    50
 ```
 ## loop-Swap
 Loop-Devices ermöglichen es, eine **Datei als Blockgerät** zu verwenden. systemd kann automatisch eine Swap-Datei über ein Loop-Device einrichten.
 ## Warum kein fstab-Eintrag?
 Moderne systemd-Systeme verwalten Swap oft automatisch über:
 - `systemd-zram-generator` (für zram)
 - `systemd-swap` oder ähnliche Dienste (für Loop-Swap)
 Dadurch bleibt die [fstab](./etc/fstab.md) sauber und die Konfiguration erfolgt deklarativ über systemd-Einheiten.
 ## Verwandte Seiten
 - [fstab](./etc/fstab.md) – Swap ist absichtlich nicht in der fstab
 - [luks-verschluesselung](./luks-verschluesselung.md) – LUKS-Container auf den Datenpartitionen
@@ -0,0 +1,83 @@
 # Systemübersicht
 **Zusammenfassung**: Der Raspberry PI5 `da-server-pi5` läuft mit Debian 13 "trixie" (aarch64) und 15 GB RAM. Docker-Host für 30 Container (28 laufend), 12 Compose-Stacks unter `/opt/compose/`.
 **Quellen**: 🖥️ `raw/Systemdaten – Raspberry PI5.md`, 🔌 SSH
 **Zuletzt aktualisiert**: 2026-06-17
 ---
 ## Basis-Daten
 | Merkmal | Wert |
 |---|---|
 | **Hostname** | `da-server-pi5` |
 | **Betriebssystem** | Debian GNU/Linux 13 (trixie) |
 | **Architektur** | aarch64 (64-bit) |
 | **Kernel** | 6.18.33+rpt-rpi-2712, PREEMPT |
 | **CPU** | 4× ARM Cortex-A76 (BCM2712) |
 | **RAM** | 15 GB (6,0 GB genutzt, 9,8 GB verfügbar) |
 | **Swap** | 2 GB zram (komprimiert) + 2 GB loop |
 | **CPU-Temperatur** | ~46 °C (aktiv gekühlt) |
 | **Betriebszeit** | 1 Tag, 2 Stunden |
 | **Load Average** | 0.31 / 0.48 / 0.50 (sehr geringe Auslastung) |
 | **Letzter Reboot** | 16. Juni 2026, 20:15 Uhr |
 ## Docker-Status
 | Metrik | Wert |
 |---|---|
 | **Docker Engine** | v29.5.3 |
 | **Docker Compose** | v5.1.4 |
 | **Container gesamt** | 30 |
 | **Container laufend** | 28 |
 | **Container gestoppt** | 2 ([gitea](./docker/gitea.md), hello-world) |
 | **Images** | 185 (173,7 GB, davon 133 GB reclaimable) |
 | **Benannte Volumes** | 11 aktiv, 152 anonym/orphaned |
 | **Netzwerke** | 11 (1 extern: `traefik`) |
 ## Systemd-Dienste (Enabled)
 Wichtige enabled systemd-Services:
 | Dienst | Zweck |
 |---|---|
 | `docker.service` | Docker-Daemon |
 | `containerd.service` | Container-Runtime |
 | `ssh.service` | SSH-Server |
 | `cron.service` | Cron-Daemon |
 | `NetworkManager.service` | Netzwerk-Verwaltung |
 | `cups.service` | Druckserver |
 | `avahi-daemon.service` | mDNS/Bonjour |
 | `bluetooth.service` | Bluetooth |
 | `lightdm.service` | Display-Manager |
 (Quelle: `systemctl list-unit-files --state=enabled`)
 ## Systemd-Timer
 | Timer | Ausführung |
 |---|---|
 | `rpi-zram-writeback.service` | Täglich (zram zurückschreiben) |
 | `dpkg-db-backup.service` | Täglich |
 | `logrotate.service` | Täglich |
 | `apt-daily-upgrade.service` | Täglich |
 | `apt-daily.service` | Täglich |
 | `fstrim.service` | Wöchentlich (SSD-Trimming) |
 | `e2scrub_all.service` | Wöchentlich (Dateisystem-Prüfung) |
 ## Netzwerk
 Siehe [netzwerk](../Allgemein/netzwerk.md) für Details.
 ## Verwandte Seiten
 - [hardware](../Allgemein/hardware.md) – Hardware-Details
 - [netzwerk](../Allgemein/netzwerk.md) – Netzwerk-Konfiguration
 - [sicherheit](../Allgemein/sicherheit.md) – Sicherheits-Einstellungen
 - [laufwerke-und-speicher](./laufwerke-und-speicher.md)
 - [docker-grundlagen](./docker-grundlagen.md)
 - [docker-services](./docker-services.md)
 - [opt-compose](./opt-compose.md)
 - [domain-und-ssl](./domain-und-ssl.md)
 - [fstab](./etc/fstab.md)
 - [crypttab](./etc/crypttab.md)