Posts by nebelwaende.de

Guten Morgen Ihr Lieben,

ich suche o.g Modell von Synology. Wer hat eins mit dieser Konfiguration abzugeben. Gebraucht und guter Zustand wäre fein...

Liebe Grüße aus Bochum

nebelwaende.de

Sollte man wegen der Syncthing Problematik einen Case bei UGREEN dazu aufmachen?

ntfy für RAID-Fehler auf UGREEN NAS

ntfy ist ein einfacher Push-Benachrichtigungsdienst, mit dem du bei RAID-Problemen auf deinem UGREEN NAS sofort eine Nachricht auf dein Smartphone erhältst.

Schnell-Setup

1. ntfy-App installieren (Android/iOS) und ein Topic abonnieren, z. B. ugreen-raid-alerts
2. Curl-Befehl testen:

curl -H "Title: RAID-Test" -H "Tags: warning" -d "Test-Nachricht" https://ntfy.sh/ugreen-raid-alerts

Im RAID-Monitoring-Script nutzen

Füge diesen Curl-Aufruf in dein bestehendes Monitoring-Script ein, wenn ein Fehler erkannt wird:

curl -H "Title: ⚠️ RAID-FEHLER" -H "Priority: urgent" -H "Tags: x" -d "RAID degraded oder ausgefallen" https://ntfy.sh/ugreen-raid-alerts

Typische Anwendungsfälle

• Laufwerk ausgefallen: Sofort-Alert mit hoher Priorität
• Rebuild fehlgeschlagen: Benachrichtigung beim Abbruch
• Pool korrupt: Kritische Warnung nach Firmware-Updates

Optional: Als Cron-Job

Prüfe alle 10 Minuten den RAID-Status und sende nur bei Änderung/Alarm:

*/10 * * * * /pfad/zum/script.sh

Quellen:

[1] ntfy https://docs.ntfy.sh/

[2] ntfy.sh | Send push notifications to your phone via PUT/POST https://ntfy.sh/ [3] ntfy - PUT/POST to your phone – Apps bei Google Play

Beispiel Script:

#!/bin/bash
#
# RAID + SMART-Monitor für UGREEN, Synology, WD NAS Systeme hier (DXP2800)
# Sendet ntfy.sh-Benachrichtigung bei RAID-Degradierung oder SMART-Fehlern
#
# Einrichtung:
# 1. Script speichern: /usr/local/bin/raid-smart-ntfy-monitor.sh
# 2. Ausführbar machen: chmod +x /usr/local/bin/raid-smart-ntfy-monitor.sh
# 3. NTFY_TOPIC und HOSTNAME anpassen (unten im Script)
# 4. Cronjob eintragen: crontab -e
#    */10 * * * * /usr/local/bin/raid-smart-ntfy-monitor.sh
#
# ntfy-App installieren (Android/iOS) und Topic abonnieren: raid-alerts
# Test: curl -H "Title: RAID-Test" -H "Tags: warning" -d "Test" https://ntfy.sh/raid-alerts
#
# Dry-Run Modus:
#   ./raid-smart-ntfy-monitor.sh --dry-run
#   Zeigt Status auf stdout ohne ntfy zu senden
#

# === KONFIGURATION ===
NTFY_TOPIC="raid-alerts"          # Dein ntfy-Topic (in App abonnieren)
NTFY_SERVER="https://ntfy.sh"            # ntfy-Server
LOGFILE="/var/log/raid-smart-monitor.log"
RAID_STATEFILE="/var/run/raid-ntfy-state"     # Merkt sich RAID-Status
SMART_STATEFILE="/var/run/smart-ntfy-state"   # Merkt sich SMART-Status

# Systemname (Hostname) - wird in jeder Nachricht mitgesendet
# Option 1: Automatisch vom System
SYSTEM_HOSTNAME="Mein Label: `uname -n`"
# Option 2: Manuell setzen (auskommentieren wenn automatisch)
# SYSTEM_HOSTNAME="DXP2800"
# =====================

# === ARGUMENTE PARSEN ===
DRY_RUN=false

for arg in "$@"; do
  case $arg in
    --dry-run|-d)
      DRY_RUN=true
      shift
      ;;
  esac
done

# === FUNKTIONEN ===

# RAID-Status prüfen
check_raid() {
  RAID_STATUS=$(cat /proc/mdstat)
  
  if echo "$RAID_STATUS" | grep -qE '^\s*md[0-9]+.*\[._\]'; then
    RAID_HEALTHY=false
    DEGRADED_ARRAYS=$(echo "$RAID_STATUS" | grep -E '^\s*md[0-9]+.*\[._\]' | awk -F: '{print $1}' | tr -d ' ')
  else
    RAID_HEALTHY=true
    DEGRADED_ARRAYS=""
  fi
}

# SMART-Status aller Platten prüfen
check_smart() {
  SMART_ISSUES=""
  SMART_DETAILS=""
  
  # Alle SATA/SCSI Platten prüfen (/dev/sd[a-z])
  for disk in /dev/sd[a-z]; do
    if [ -b "$disk" ]; then
      RESULT=$(smartctl -H "$disk" 2>/dev/null | grep -i "SMART overall-health" | awk -F': ' '{print $2}')
      if [ -n "$RESULT" ] && [ "$RESULT" != "PASSED" ]; then
        SMART_ISSUES="$SMART_ISSUES $disk:$RESULT"
        SMART_DETAILS="$SMART_DETAILS\n$disk: $RESULT"
      fi
    fi
  done
  
  # Alle NVMe Platten prüfen (/dev/nvme[0-9]n[0-9])
  for disk in /dev/nvme[0-9]n[0-9]; do
    if [ -b "$disk" ]; then
      RESULT=$(smartctl -H "$disk" 2>/dev/null | grep -i "SMART overall-health" | awk -F': ' '{print $2}')
      if [ -n "$RESULT" ] && [ "$RESULT" != "PASSED" ]; then
        SMART_ISSUES="$SMART_ISSUES $disk:$RESULT"
        SMART_DETAILS="$SMART_DETAILS\n$disk: $RESULT"
      fi
    fi
  done
  
  if [ -n "$SMART_ISSUES" ]; then
    SMART_HEALTHY=false
  else
    SMART_HEALTHY=true
  fi
}

# ntfy Nachricht senden
send_ntfy() {
  local title="$1"
  local priority="$2"
  local tags="$3"
  local message="$4"
  
  # Systemname in die Nachricht einbauen
  local full_message="System: $SYSTEM_HOSTNAME\n\n$message"
  
  curl -s -S -H "Title: $title" \
       -H "Priority: $priority" \
       -H "Tags: $tags" \
       -d "$full_message" \
       "$NTFY_SERVER/$NTFY_TOPIC" 2>/dev/null
}

# === HAUPTLOGIK ===

TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')

# RAID prüfen
check_raid

# SMART prüfen
check_smart

# Letzte States lesen
if [ -f "$RAID_STATEFILE" ]; then
  RAID_LAST_STATE=$(cat "$RAID_STATEFILE")
else
  RAID_LAST_STATE="unknown"
fi

if [ -f "$SMART_STATEFILE" ]; then
  SMART_LAST_STATE=$(cat "$SMART_STATEFILE")
else
  SMART_LAST_STATE="unknown"
fi

if [ "$DRY_RUN" = true ]; then
  # === DRY-RUN MODUS ===
  echo "=== RAID + SMART Monitor Dry-Run ==="
  echo "System: $SYSTEM_HOSTNAME"
  echo "Zeit: $TIMESTAMP"
  echo ""
  echo "=== RAID-Status ==="
  cat /proc/mdstat
  echo ""
  echo "RAID Gesundheitsstatus: $RAID_HEALTHY"
  if [ "$RAID_HEALTHY" = false ]; then
    echo "Betroffene Arrays: $DEGRADED_ARRAYS"
  fi
  echo ""
  echo "=== SMART-Status ==="
  
  # SMART Details anzeigen
  echo "SATA/SCSI Platten:"
  for disk in /dev/sd[a-z]; do
    if [ -b "$disk" ]; then
      echo -n "  $disk: "
      smartctl -H "$disk" 2>/dev/null | grep -i "SMART overall-health" || echo "N/A"
    fi
  done
  
  echo "NVMe Platten:"
  for disk in /dev/nvme[0-9]n[0-9]; do
    if [ -b "$disk" ]; then
      echo -n "  $disk: "
      smartctl -H "$disk" 2>/dev/null | grep -i "SMART overall-health" || echo "N/A"
    fi
  done
  
  echo ""
  echo "SMART Gesundheitsstatus: $SMART_HEALTHY"
  if [ "$SMART_HEALTHY" = false ]; then
    echo "Probleme: $SMART_ISSUES"
  fi
  echo ""
  echo "=== ntfy würde senden ==="
  
  # RAID Alert?
  if [ "$RAID_HEALTHY" = false ]; then
    echo "RAID Alert:"
    echo "  Title: ⚠️ RAID-FEHLER"
    echo "  Priority: urgent"
    echo "  Tags: x"
    echo "  Message: System: $SYSTEM_HOSTNAME"
    echo "           RAID degraded oder ausgefallen"
    if [ "$RAID_HEALTHY" != "$RAID_LAST_STATE" ]; then
      echo "  → WÜ´RDE gesendet (Statuswechsel)"
    else
      echo "  → Kein Send (kein Statuswechsel)"
    fi
    echo ""
  fi
  
  # SMART Alert?
  if [ "$SMART_HEALTHY" = false ]; then
    echo "SMART Alert:"
    echo "  Title: ⚠️ SMART-FEHLER"
    echo "  Priority: urgent"
    echo "  Tags: x"
    echo "  Message: System: $SYSTEM_HOSTNAME"
    echo "           Festplatte(n) melden Fehler:$SMART_ISSUES"
    if [ "$SMART_HEALTHY" != "$SMART_LAST_STATE" ]; then
      echo "  → WÜ´RDE gesendet (Statuswechsel)"
    else
      echo "  → Kein Send (kein Statuswechsel)"
    fi
    echo ""
  fi
  
  # OK Nachricht?
  if [ "$RAID_HEALTHY" = true ] && [ "$SMART_HEALTHY" = true ]; then
    echo "OK Status:"
    echo "  Title: ✅ RAID + SMART OK"
    echo "  Priority: default"
    echo "  Tags: white_check_mark"
    echo "  Message: System: $SYSTEM_HOSTNAME"
    echo "           Alle Arrays und Platten sind healthy"
    if [ "true" != "$RAID_LAST_STATE" ] || [ "true" != "$SMART_LAST_STATE" ]; then
      echo "  → WÜ´RDE gesendet (Statuswechsel von Alert zu OK)"
    else
      echo "  → Kein Send (kein Statuswechsel)"
    fi
  fi
  
  exit 0
fi

# === NORMALER MODUS (mit ntfy) ===

ALERT_SENT=false

# RAID Alert senden (nur bei Statuswechsel)
if [ "$RAID_HEALTHY" != "$RAID_LAST_STATE" ]; then
  echo "$RAID_HEALTHY" > "$RAID_STATEFILE"
  
  if [ "$RAID_HEALTHY" = false ]; then
    MESSAGE="RAID degraded oder ausgefallen\n\nBetroffene Arrays: $DEGRADED_ARRAYS\n\nZeit: $TIMESTAMP\n\nBitte prüfen: cat /proc/mdstat"
    
    send_ntfy "⚠️ RAID-FEHLER" "urgent" "x" "$MESSAGE"
    
    echo "[$TIMESTAMP] ALERT: RAID degraded - $DEGRADED_ARRAYS" >> "$LOGFILE"
    ALERT_SENT=true
  else
    # RAID wieder healthy
    MESSAGE="RAID wieder healthy\n\nAlle Arrays sind synchronisiert.\n\nZeit: $TIMESTAMP"
    
    send_ntfy "✅ RAID OK" "default" "white_check_mark" "$MESSAGE"
    
    echo "[$TIMESTAMP] OK: RAID wieder healthy" >> "$LOGFILE"
    ALERT_SENT=true
  fi
fi

# SMART Alert senden (nur bei Statuswechsel)
if [ "$SMART_HEALTHY" != "$SMART_LAST_STATE" ]; then
  echo "$SMART_HEALTHY" > "$SMART_STATEFILE"
  
  if [ "$SMART_HEALTHY" = false ]; then
    MESSAGE="Festplatte(n) melden Fehler:$SMART_DETAILS\n\nZeit: $TIMESTAMP\n\nBitte prüfen: smartctl -H /dev/sdX"
    
    send_ntfy "⚠️ SMART-FEHLER" "urgent" "x" "$MESSAGE"
    
    echo "[$TIMESTAMP] ALERT: SMART Fehler - $SMART_ISSUES" >> "$LOGFILE"
    ALERT_SENT=true
  else
    # SMART wieder healthy (nach Plattentausch o.äı·)
    MESSAGE="SMART Status wieder OK\n\nAlle Platten sind healthy.\n\nZeit: $TIMESTAMP"
    
    send_ntfy "✅ SMART OK" "default" "white_check_mark" "$MESSAGE"
    
    echo "[$TIMESTAMP] OK: SMART wieder healthy" >> "$LOGFILE"
    ALERT_SENT=true
  fi
fi

# OK Nachricht wenn beide healthy und vorher ein Alert aktiv war
if [ "$RAID_HEALTHY" = true ] && [ "$SMART_HEALTHY" = true ]; then
  if [ "$RAID_LAST_STATE" = "false" ] || [ "$SMART_LAST_STATE" = "false" ]; then
    MESSAGE="Alle Arrays und Platten sind healthy\n\nZeit: $TIMESTAMP"
    
    send_ntfy "✅ RAID + SMART OK" "default" "white_check_mark" "$MESSAGE"
    
    echo "[$TIMESTAMP] OK: Alles healthy" >> "$LOGFILE"
    ALERT_SENT=true
  fi
fi

# Loggen wenn kein Alert gesendet wurde
if [ "$ALERT_SENT" = false ]; then
  if [ "$RAID_HEALTHY" = true ] && [ "$SMART_HEALTHY" = true ]; then
    echo "[$TIMESTAMP] OK: RAID + SMART healthy" >> "$LOGFILE"
  else
    echo "[$TIMESTAMP] WARN: RAID=$RAID_HEALTHY SMART=$SMART_HEALTHY (kein Statuswechsel)" >> "$LOGFILE"
  fi
fi

# Optional: Alte Statefiles bereinigen (nach 7 Tagen)
find /var/run -name "*-ntfy-state" -mtime +7 -delete 2>/dev/null

exit 0

Hi HauptStrasseEins,

man kann nicht pauschal sagen, dass Tailscale besser als WireGuard ist, weil Tailscale im Kern nur WireGuard mit einer komfortablen Verwaltungsschicht drumherum ist. Bei Geschwindigkeit, Stabilität und Stromverbrauch sind beide praktisch gleich, da Tailscale dieselbe WireGuard-Technik für die Datenübertragung nutzt. Der echte Vorteil von Tailscale liegt in der extrem einfachen Einrichtung und automatischen Verwaltung, was besonders bei vielen Geräten oder wechselnden Netzwerken sehr angenehm ist. Für deinen Router macht WireGuard weiterhin Sinn als klassisches, unabhängiges VPN, während Tailscale besonders für die Server-zu-Server-Verbindung wie bei unRAID sehr praktisch ist. Du kannst beides problemlos parallel nutzen und musst dich nicht für eine Lösung entscheiden. Liebe Grüße aus Bochum

Hi,
die Synchronisation bestimmter Datenbereiche – insbesondere deiner Nutzdaten – lässt sich sehr gut mit Syncthing realisieren. Die Synchronisation erfolgt dabei direkt peer-to-peer ausschließlich zwischen deinen beiden NAS-Systemen und ist durchgehend TLS-verschlüsselt.
Für zusätzliche Sicherheit kannst du beide NAS-Systeme zusätzlich in ein gemeinsames VPN-Netzwerk einbinden, beispielsweise über Tailscale (Tailnet) oder Netbird. Dadurch wird die Verbindung zusätzlich abgesichert und ist nur innerhalb dieses privaten Netzwerks erreichbar.

Ja — das ist nicht ein Docker- oder chmod-Problem, sondern fast sicher ein Zeilenenden-Problem: bash\r zeigt an, dass die Datei noch CRLF enthält statt sauberem LF. Das passiert oft, wenn ein Skript in einem Windows-Editor wie Notepad++ bearbeitet wurde, auch wenn es “Unix script file” heißt.

Willkommen

Guten Morgen zusammen,

bei Syncthing lässt sich der Scan- und Synchronisierungsintervall pro Ordner über die Weboberfläche individuell einstellen; bei mir läuft das zum Beispiel alle 60 Sekunden, der Standardwert beträgt 3600 Sekunden. Welche Intervalle sinnvoll sind, hängt natürlich von der Dateigröße und dem Änderungsaufkommen ab.
Über weitere Ordner‑Parameter kannst du außerdem festlegen, ob Dateien zufällig synchronisiert werden sollen oder ob zuerst die neuesten Dateien übertragen werden sollen.
Die App läuft sehr stabil, existiert seit 2013 und wird regelmäßig gepflegt und aktualisiert.

Viele Grüße

Meine verteilte Sync- und Backup-Infrastruktur:

Ich betreibe eine hybride Sync- und Backup-Lösung für meine verstreut platzierten Clients (macOS, Windows 11 und Ubuntu) mit dem UGREEN NAS als zentralem Hub:

Sync-Ebene mit Syncthing
Auf allen Clients sowie auf dem UGREEN NAS (als Docker-Container betrieben) läuft Syncthing. Das NAS fungiert dabei als Relay-Station und kontinuierlicher Sync-Knoten, der alle Geräte miteinander verbindet und Daten in Echtzeit synchronisiert.

Backup-Ebene mit rsnapshot
Zusätzlich implementiere ich eine hierarchische Backup-Strategie: Mindestens stündlich übernimmt rsnapshot alle neuen oder geänderten Dateien vom Syncthing-Volume und sichert sie in ein separates Volume des NAS. Dadurch entsteht ein zeitlich versionierter Snapshotspeicher, der sowohl vor versehentlichem Löschen als auch vor Ransomware schützt.

Diese Zwei-Ebenen-Architektur kombiniert die Vorteile von Echtzeit-Sync (Syncthing) mit regelmäßigen, versionierten Backups (rsnapshot) – für maximale Datenverfügbarkeit und -sicherheit.

┌─────────────────────────────────────────────────────────────────────────┐
│                    VERTEILTE SYNC- & BACKUP-ARCHITEKTUR                 │
└─────────────────────────────────────────────────────────────────────────┘

    ┌──────────┐      ┌──────────┐      ┌──────────┐
    │   Mac    │      │  Win11   │      │  Ubuntu  │
    │  Client  │      │  Client  │      │  Client  │
    │          │      │          │      │          │
    │Syncthing │      │Syncthing │      │Syncthing │
    └────┬─────┘      └────┬─────┘      └────┬─────┘
         │                 │                 │
         └─────────────────┼─────────────────┘
                           │
                    ┌──────▼──────┐
                    │   Tailscale │  (VPN-Tunnel)
                    │    / Wireguard│
                    └──────┬──────┘
                           │
         ┌─────────────────▼─────────────────┐
         │                                   │
         │      UGREEN NAS (DXP2800)         │
         │                                   │
         │  ┌─────────────────────────────┐  │
         │  │    Docker Container         │  │
         │  │  ┌───────────────────────┐  │  │
         │  │  │    Syncthing          │  │  │
         │  │  │  (Relay-Station)      │  │  │
         │  │  └──────────┬────────────┘  │  │
         │  └─────────────┼───────────────┘  │
         │                │                  │
         │                ▼                  │
         │  ┌─────────────────────────────┐  │
         │  │     Volume 1 (Sync)         │  │
         │  │  ★ Aktuelle Sync-Daten      │  │
         │  └──────────┬──────────────────┘  │
         │             │                     │
         │             │ rsnapshot           │
         │             │ (stündlich)         │
         │             ▼                     │
         │  ┌─────────────────────────────┐  │
         │  │     Volume 2 (Backup)       │  │
         │  │  ★ Versionierte Snapshots   │  │
         │  │  ★ hourly/ daily/ weekly    │  │
         │  └─────────────────────────────┘  │
         │                                   │
         └───────────────────────────────────┘

Überblick

Podcast

Ausschreibung: Python/FastAPI-Entwickler für universelle Dropshipping-Integrationsplattform

Aufgabenm

Anforderungen

Gewünscht ist

Projektziel

Rahmenbedingungen

Bewerbungswunsch

Ausschreibung: Python/FastAPI-Entwickler für universelle Dropshipping-Integrationsplattform

Wir suchen einen erfahrenen Python-Entwickler zur Umsetzung einer flexiblen Integrationsschicht zwischen unserem Odoo-Webshop und verschiedenen Dropshipping-Lieferanten. Die Lösung soll zunächst die InnoCigs-API anbinden und später leicht um weitere Lieferanten-APIs erweiterbar sein.

Ziel ist der Aufbau einer sauberen, wartbaren und modularen Middleware, die Lieferanteninformationen zentral verarbeitet und dem Webshop über eine FastAPI-Schnittstelle bereitstellt. Zusätzlich sollen Bestellungen aus dem Shop automatisiert an den jeweiligen Lieferanten übermittelt werden können.

Aufgaben

• Entwicklung einer Python-basierten Integrationsschicht mit FastAPI.
• Anbindung der InnoCigs-API als erster Lieferant.
• Konzeption einer universellen Connector-Struktur für weitere Lieferanten.
• Umsetzung von CronJobs bzw. geplanten Synchronisationsskripten.
• Abruf und Verarbeitung von Produktdaten, Beständen, Preisen, Bestellungen und Trackinginformationen.
• Bereitstellung der Daten für einen Odoo-Webshop über eine stabile API.
• Optional: Implementierung eines Bestell-Services zur Weiterleitung von Shop-Bestellungen an Lieferanten.
• Dokumentation der Schnittstellen und der technischen Architektur.

Anforderungen

• Sehr gute Kenntnisse in Python.
• Erfahrung mit FastAPI.
• Erfahrung mit REST-APIs und API-Integrationen.
• Kenntnisse in CronJobs, Background Jobs oder Scheduler-Mechanismen.
• Erfahrung mit modularer Softwarearchitektur und sauberer Trennung von Integrationslogik.
• Idealerweise Erfahrung mit Odoo oder E-Commerce-Integrationen.
• Verständnis für Authentifizierung, Logging, Fehlerbehandlung und Rate Limiting.

Gewünscht ist

• Eine saubere und erweiterbare Architektur.
• Ein Connector-Konzept, mit dem weitere Dropshipping-Lieferanten leicht ergänzt werden können.
• Eine klare Trennung zwischen Lieferanten-Logik, API-Schicht und Shop-Integration.
• Wartbarer Code mit guter Dokumentation.
• Pragmatismus und Erfahrung im Aufbau produktionsnaher Integrationen.

Projektziel

Am Ende soll eine zentrale, universell erweiterbare Lieferantenplattform entstehen, die mehrere Dropshipping-Partner anbinden kann und den Odoo-Webshop zuverlässig mit aktuellen Produkt-, Preis- und Bestandsdaten versorgt.

Rahmenbedingungen

• Bevorzugt wird eine strukturierte, eigenverantwortliche Arbeitsweise.
• Erfahrung mit API-Design und Integrationsprojekten ist wichtig.
• Remote-Zusammenarbeit ist möglich.
• Eine langfristige Zusammenarbeit für weitere Lieferantenanbindungen ist ausdrücklich gewünscht.

Bewerbungswunsch

Bitte sende uns:

• kurze Vorstellung und relevante Projekterfahrung,
• Beispiele für API- oder FastAPI-Projekte,
• Informationen zu deiner Verfügbarkeit,
• dein Stundensatz oder ein Angebot für das Gesamtprojekt.

Quote from steffenglock

Ich habe Ollama mit Qwen2.5 7B auf nem Raspi am laufen gehabt und das war quälend langsam. Am besten lief noch Llama 3.2 (3B) Da denk ich das nas wird auch seine Probleme haben. Es sei denn die Programmierer haben irgendetwas optimiert.

Wenn UGROS PRO mitspielt könnte man eine NVIDIA GPU per USBc/Thunderbolt anschließen.

Guten Abend,

ich habe ein Experiment geplant: OpenClaw nativ auf UGOS Pro meines UGREEN NASync DXP2800 – komplett internetlos auf einem isolierten LAN-Switch. Die Idee ist klar: Kann ein autonomer KI-Agent wie OpenClaw lokale Daten (PDF-Rechnungen analysieren, Summen extrahieren, Berichte erstellen) ohne jeglichen Internetzugang verarbeiten? Wie eine "kontrollierte Kernschmelze": maximal isoliert, aber kalkulierbar.

Die Vision: Pur offline

Das DXP2800 soll an einem einfachen Switch hängen – nur LAN-Verbindung zum Client-PC, kein Router, keine Cloud. OpenClaw + Ollama (lokale Modelle wie qwen2.5:14b oder llama3.2:3b) bearbeiten den gesamten Datenbestand. Keine Web-Skills, keine APIs – reine CPU-Inference auf Intel N100. Typische Tasks in 20-60 Sekunden, perfekt für Batch-Verarbeitung. Absolut sicher: Keine Prompt-Injection von außen, nur lokale Ressourcen.

Native statt Docker, weil UGOS Pro das direkt unterstützt – kein Overhead, volle Nutzung der 8-16 GB DDR5-RAM. OpenClaw als System-Daemon, Ollama auf localhost:11434, Dashboard auf LAN-IP:18789. Alles bleibt im LAN eingesperrt.

So soll es laufen (geplant)

Vorbereitung (einmal Internet): Node.js 22+, Ollama-Modelle auf SSD, OpenClaw per Install-Script. Dann Switch umstecken – air-gapped!

Konfiguration: LLM_API=ollama, OLLAMA_BASE_URL=127.0.0.1:11434, Context-Window 65536. Test-Befehle wie „Analysiere PDFs in /data/invoices, erstelle CSV" sollen direkt ins Dateisystem schreiben. Monitoring über UGOS-Dashboard (CPU 70-90%, RAM ~12 GB).

Hat jemand schon mit Ugreen AI was gemacht. Wie nutzt man die App auf einem DXP 2800?

Danke eineb der Artikel enthält viel Text. Mir fehlt die Passage da wo das UGROS ein vorheriges RAID wiedererkennt und anbietet es zu aktivieren / restaurieren. Ich gehe derzeit weiter davon aus das das UGROS noch nicht kann. Es hat natürlich was, sollte jemand die Platten klauen, da er sie im gleichen Modell nicht verwenden wird können.

Datenschutz Top.

Das Bild sieht gut aus...

Guten Abend, ich habe heute das Ersatzgerät, dass am Dienstag von Cyberport geliefert wurde, in Betrieb genommen. Meiner Erfahrung nach sind die RAID 1 Platten komplett wieder neu einzurichten. Da wird von UGROS nix erkannt. So war ich froh ein logisches Backup meiner Daten gehabt zu haben.

Halll Urh, nicht direkt: WhatsApp speichert jedoch tägliche Backups automatisch unter /Android/media/com.whatsapp/WhatsApp/Backups/...

Mit Syncthing for Android könntest Du die dortigen Daten auf das NAS bekommen.

Liebe Grüße aus Bochum

Quote from MGS

Moin,

Ich würde mir mal mit dem sct Befehl die temperaturhistorie der Platten anzeigen lassen.
smartctl -l scttemp -l scttempsts /dev/sda

ZB

Meine 7200er hatten zum Zeitpunkt

des Absturzes 49 grad C.
Der chipsatz dürfte viel heißer gewesen sein.
So konnte ich den Zusammenhang zwischen Absturz und Lüfter bestimmen. Und das passte ziemlich genau.

Mal als Tipp.

Mach ich wenn ich wieder per ssh auf die Maschine komme.

Quote from nebelwaende.de

Ich vermute das LAN Kabel hat nen hau. Die Maschine ist leider nicht hier ich schaue mir das wenn ich wieder vor Ort bin genauer an. Danke für die Nachricht.

Hat sich nicht bestätigt.

Anbei noch das Video mit dem Fehlerbild.

Maschine ist unterwegs zurück zu Cyberport. Mal sehen was der Service sagt.

Ich habe das LAN-Kabel getauscht, die Festplatten und den Arbeitsspeicher ausgebaut und bei UGREEN eine Störungsmeldung eröffnet. Aktuell vermute ich, dass der Speicher die Ursache ist. Leider habe ich kein HDMI-Kabel zur Hand, um weitere Tests durchzuführen. Mal sehen, wie sich die Situation entwickelt