Migrationsskript für MongoDB-Upgrade auf 7.0 mit CPU-Prüfung

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

.env.example

@@ -0,0 +1,5 @@
+MONGO_USER=unifi
+MONGO_PASS=hier-ein-langes-zufaelliges-passwort
+MONGO_DBNAME=unifi
+# MONGO_VERSION wird von start.sh automatisch passend zur CPU gesetzt.
+# Nur von Hand setzen, wenn man genau weiß, was man tut.

README.md

@@ -4,13 +4,18 @@ UniFi Network Application (Controller) mit MongoDB, alle persistenten Daten
 liegen im Projektordner unter `./data/`.
 
 - Image: [linuxserver/unifi-network-application](https://docs.linuxserver.io/images/docker-unifi-network-application/)
-- Datenbank: MongoDB **4.4** (bewusst — die CPU dieses Rechners hat kein AVX,
-  MongoDB 5+ würde nicht starten. Nicht auf ein neueres Mongo-Image wechseln!)
+- Datenbank: MongoDB — die Version wird von `start.sh` beim ersten Start
+  automatisch passend zur CPU gewählt und in `.env` gepinnt:
+  x86_64/ARM mit AVX bzw. ARMv8.2 → **7.0**, ältere CPUs ohne AVX → **4.4**
+  (Mongo 5+ startet dort nicht). Danach den Pin **nicht** von Hand erhöhen —
+  eine bestehende Datenbank läuft nicht ohne Migration unter einer neueren
+  Major-Version.
 
 ## Erster Start
 
 ```bash
-docker-compose up -d
+cp .env.example .env   # und MONGO_PASS auf ein eigenes Passwort setzen
+./start.sh             # wählt die MongoDB-Version und startet den Stack
 docker-compose logs -f unifi-network-application   # warten bis der Start durch ist
 ```
 
@@ -69,6 +74,20 @@ Autobackups einmalig in der Weboberfläche aktivieren:
 (*Einstellungen → System → Backups → Wiederherstellen*) oder bei einer
 Neuinstallation direkt im Einrichtungs-Assistenten.
 
+## MongoDB auf 7.0 migrieren
+
+```bash
+./migrate-mongo.sh
+```
+
+Für den Fall, dass der Stack auf neue Hardware umzieht (oder ursprünglich mit
+Mongo 4.4 eingerichtet wurde, die CPU aber mehr kann): Das Skript prüft zuerst
+die CPU (AVX bzw. ARMv8.2) und bricht ohne Änderungen ab, wenn MongoDB 5+
+dort nicht laufen kann. Andernfalls erstellt es ein Komplett-Backup und
+migriert die Datenbank schrittweise in-place (4.4 → 5.0 → 6.0 → 7.0, inkl.
+`featureCompatibilityVersion`), pinnt `MONGO_VERSION=7.0` in der `.env` und
+startet den Stack wieder.
+
 ## Verzeichnisstruktur
 
 ```

docker-compose.yml

@@ -2,7 +2,7 @@ version: "3.8"
 
 services:
   unifi-db:
-    image: mongo:4.4
+    image: mongo:${MONGO_VERSION:-4.4}
     container_name: unifi-db
     restart: unless-stopped
     environment:

migrate-mongo.sh

@@ -0,0 +1,117 @@
+#!/bin/bash
+# Migriert die MongoDB-Datenbank in-place auf Version 7.0.
+#
+# MongoDB erlaubt keine Sprünge über mehrere Major-Versionen, daher wird
+# schrittweise migriert (4.4 -> 5.0 -> 6.0 -> 7.0) und nach jedem Schritt die
+# featureCompatibilityVersion angehoben.
+#
+# Vorher wird geprüft, ob die CPU das überhaupt kann (MongoDB 5+ braucht auf
+# x86_64 AVX, auf ARM64 ARMv8.2) — ohne das bricht das Skript ab, ohne etwas
+# zu verändern. Außerdem wird ein Komplett-Backup erstellt.
+set -euo pipefail
+cd "$(dirname "$0")"
+
+TARGET="7.0"
+MIGRATION_PATH=("5.0" "6.0" "7.0")
+DB_DATA="$PWD/data/mongodb"
+TMP_NAME="unifi-db-migrate"
+
+# ---------- 1. CPU-Prüfung ----------
+arch="$(uname -m)"
+flags="$(grep -m1 -iE '^(flags|Features)' /proc/cpuinfo 2>/dev/null || true)"
+cpu_ok=false
+case "$arch" in
+    x86_64)        grep -qw avx     <<< "$flags" && cpu_ok=true ;;
+    aarch64|arm64) grep -qw asimddp <<< "$flags" && cpu_ok=true ;;
+esac
+if [[ "$cpu_ok" != true ]]; then
+    echo "ABBRUCH: Diese CPU ($arch) unterstützt kein AVX bzw. ARMv8.2."
+    echo "MongoDB 5+ würde auf diesem Rechner nicht starten — Migration nicht möglich."
+    echo "Es wurde nichts verändert."
+    exit 1
+fi
+echo "==> CPU-Prüfung bestanden ($arch): Migration auf mongo:$TARGET möglich."
+
+# ---------- 2. Ausgangslage prüfen ----------
+[[ -f .env ]] || { echo "FEHLER: .env fehlt."; exit 1; }
+CURRENT="$(grep '^MONGO_VERSION=' .env | cut -d= -f2 || true)"
+CURRENT="${CURRENT:-4.4}"
+if [[ "$CURRENT" == "$TARGET" ]]; then
+    echo "MongoDB ist bereits auf $TARGET gepinnt — nichts zu tun."
+    exit 0
+fi
+if [[ ! -d "$DB_DATA" ]] || [[ -z "$(ls -A "$DB_DATA" 2>/dev/null)" ]]; then
+    echo "Keine bestehende Datenbank gefunden — einfach ./start.sh ausführen,"
+    echo "das richtet direkt mongo:$TARGET ein."
+    exit 1
+fi
+echo "==> Migriere von mongo:$CURRENT auf mongo:$TARGET"
+
+# ---------- 3. Sicherheits-Backup ----------
+echo "==> Komplett-Backup vor der Migration..."
+./backup.sh --full
+
+# ---------- 4. Stack stoppen ----------
+echo "==> Container stoppen..."
+docker-compose down
+docker rm -f "$TMP_NAME" >/dev/null 2>&1 || true
+
+# Hilfsfunktionen: temporären mongod starten/abfragen/stoppen
+mongo_eval() {
+    docker exec "$TMP_NAME" sh -c \
+      'if command -v mongosh >/dev/null; then mongosh --quiet --eval "$0"; else mongo --quiet --eval "$0"; fi' \
+      "$1"
+}
+wait_for_mongo() {
+    local i
+    for i in $(seq 1 60); do
+        if mongo_eval 'db.adminCommand({ping:1}).ok' >/dev/null 2>&1; then return 0; fi
+        sleep 2
+    done
+    echo "FEHLER: mongod wurde nicht rechtzeitig bereit."; return 1
+}
+run_step() {
+    local version="$1"
+    echo "==> Schritt: mongo:$version starten..."
+    docker run -d --name "$TMP_NAME" -v "$DB_DATA":/data/db "mongo:$version" >/dev/null
+    wait_for_mongo
+    local fcv_cmd
+    if [[ "$version" == "7.0" ]]; then
+        fcv_cmd="db.adminCommand({setFeatureCompatibilityVersion: \"$version\", confirm: true})"
+    else
+        fcv_cmd="db.adminCommand({setFeatureCompatibilityVersion: \"$version\"})"
+    fi
+    echo "    featureCompatibilityVersion -> $version"
+    mongo_eval "$fcv_cmd" >/dev/null
+    docker stop "$TMP_NAME" >/dev/null
+    docker rm "$TMP_NAME" >/dev/null
+    echo "    Schritt $version abgeschlossen."
+}
+
+# ---------- 5. Schrittweise migrieren ----------
+started=false
+for step in "${MIGRATION_PATH[@]}"; do
+    # Schritte unterhalb der aktuellen Version überspringen (z.B. Start bei 5.0)
+    if [[ "$started" == false ]]; then
+        if [[ "$(printf '%s\n' "$CURRENT" "$step" | sort -V | head -1)" == "$CURRENT" && "$CURRENT" != "$step" ]]; then
+            started=true
+        else
+            continue
+        fi
+    fi
+    run_step "$step"
+done
+
+# ---------- 6. Pin aktualisieren und Stack starten ----------
+sed -i "s/^MONGO_VERSION=.*/MONGO_VERSION=$TARGET/" .env
+echo "==> MONGO_VERSION=$TARGET in .env gesetzt."
+echo "==> Stack wieder starten..."
+docker-compose pull unifi-db
+docker-compose up -d
+
+echo ""
+echo "Migration abgeschlossen. Prüfen mit:"
+echo "  docker exec unifi-db mongosh --quiet --eval 'db.version()'"
+echo "  curl -sk https://localhost:8443/status"
+echo "Das Sicherheits-Backup liegt in ./backups/ und kann bei Problemen"
+echo "mit ./restore.sh wiederhergestellt werden."

start.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+# Startet den Stack und wählt beim allerersten Start automatisch die passende
+# MongoDB-Version für diese CPU:
+#
+#   x86_64 mit AVX            -> mongo:7.0
+#   x86_64 ohne AVX           -> mongo:4.4  (Mongo 5+ startet ohne AVX nicht)
+#   aarch64 mit ARMv8.2       -> mongo:7.0  (z.B. Raspberry Pi 5, Apple Silicon)
+#   aarch64 ohne ARMv8.2      -> mongo:4.4  (z.B. Raspberry Pi 4)
+#
+# Die gewählte Version wird in .env als MONGO_VERSION festgeschrieben und
+# danach NIE automatisch geändert: eine bestehende Datenbank kann nicht
+# einfach unter einer neueren Major-Version starten (Migration nötig).
+set -euo pipefail
+cd "$(dirname "$0")"
+
+detect_mongo_version() {
+    local arch flags
+    arch="$(uname -m)"
+    flags="$(grep -m1 -iE '^(flags|Features)' /proc/cpuinfo 2>/dev/null || true)"
+    case "$arch" in
+        x86_64)
+            if grep -qw avx <<< "$flags"; then echo "7.0"; else echo "4.4"; fi ;;
+        aarch64|arm64)
+            # asimddp ist ein ARMv8.2-Merkmal; Mongo 5+ braucht ARMv8.2-A
+            if grep -qw asimddp <<< "$flags"; then echo "7.0"; else echo "4.4"; fi ;;
+        *)
+            echo "4.4" ;;
+    esac
+}
+
+if [[ ! -f .env ]]; then
+    echo "FEHLER: .env fehlt (MONGO_USER/MONGO_PASS/MONGO_DBNAME)." >&2
+    exit 1
+fi
+
+if grep -q '^MONGO_VERSION=' .env; then
+    echo "==> MongoDB-Version ist bereits gepinnt: $(grep '^MONGO_VERSION=' .env)"
+else
+    if [[ -d data/mongodb ]] && [[ -n "$(ls -A data/mongodb 2>/dev/null)" ]]; then
+        # Bestehende Datenbank ohne Pin: Stand vor dieser Automatik -> 4.4 festschreiben
+        VERSION="4.4"
+        echo "==> Bestehende Datenbank gefunden, pinne bisherige Version: mongo:$VERSION"
+    else
+        VERSION="$(detect_mongo_version)"
+        echo "==> CPU-Erkennung ($(uname -m)): verwende mongo:$VERSION"
+    fi
+    echo "MONGO_VERSION=$VERSION" >> .env
+fi
+
+docker-compose up -d
+echo ""
+echo "Stack gestartet. Logs:  docker-compose logs -f unifi-network-application"