From af0a418af6da29b70d133b732b13efcc5cf76a36 Mon Sep 17 00:00:00 2001 From: Thomas Dannenberg Date: Sat, 4 Oct 2025 20:15:14 +0000 Subject: [PATCH] =?UTF-8?q?Kapitel=206/Premium=20Rohtext.md=20hinzugef?= =?UTF-8?q?=C3=BCgt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Kapitel 6/Premium Rohtext.md | 1011 ++++++++++++++++++++++++++++++++++ 1 file changed, 1011 insertions(+) create mode 100644 Kapitel 6/Premium Rohtext.md diff --git a/Kapitel 6/Premium Rohtext.md b/Kapitel 6/Premium Rohtext.md new file mode 100644 index 0000000..622ab9a --- /dev/null +++ b/Kapitel 6/Premium Rohtext.md @@ -0,0 +1,1011 @@ +# Kapitel 6 – Nextcloud (Premium) + +## Einleitung + +Bisher ist die Nextcloud vollständig eingerichtet und für den täglichen Einsatz bereit. +Im Premium-Kapitel erweitern wir dieses stabile Grundsystem um praktische Automatisierungen, +zusätzliche Leistungsoptimierungen und Komfortfunktionen, die den Betrieb langfristig vereinfachen. + +Alle Erweiterungen bauen direkt auf deiner bestehenden Installation auf. +Du musst nichts neu einrichten, sondern ergänzt gezielt einzelne Funktionen, +damit deine Cloud im Alltag zuverlässiger arbeitet und sich viele Aufgaben selbst erledigen. + +> [!NOTE] +> Premium bedeutet im UCC-Tutorial keine höhere Schwierigkeit. +> Es bleibt bei verständlichen Schritt-für-Schritt-Anleitungen, die direkt in deiner Umgebung funktionieren. + +### Themen dieses Kapitels + +1. **Automatische Sicherung der Datenbank und Konfiguration** + – tägliche Backups inklusive Protokollierung + +2. **Automatische Löschung älterer Sicherungen** + – hält den Speicherplatz sauber, ohne manuelles Eingreifen + +3. **Wiederherstellung eines Backups** + – komplette Rücksicherung der Instanz in wenigen Schritten + +4. **Mail-Benachrichtigung bei Backup-Ergebnissen** + – automatische Info über erfolgreiche oder fehlerhafte Sicherungen + +5. **php.ini- und www.conf-Tuning** + – höhere Performance, größere Uploads und längere Skriptlaufzeiten + +6. **Redis-Optimierung** + – stabileres Locking, schnelleres Caching und geringere Latenz + +7. **Externe Speicher-Mounts in Nextcloud** + – zusätzliche Laufwerke, Netzfreigaben oder externe Cloud-Speicher einbinden + +8. **SFTP-Upload-Integration** + – automatisches Hochladen von Dateien in entfernte Server oder Container + +9. **Preview-Cache optimieren** + – Vorschaugenerierung beschleunigen und Speicherverbrauch reduzieren + +10. **Abschluss & Ergebnis** + – Übersicht aller Optimierungen, Routinen und Wartungstipps + +👉 *Screenshot geeignet: Nextcloud-Dashboard mit aktivem Cron-Job und geöffnetem Systemstatus.* + +--- + +## Automatische Sicherung der Datenbank und Konfiguration + +Ein verlässliches Backup ist die wichtigste Grundlage für einen stabilen Nextcloud-Betrieb. +Ziel ist eine automatische tägliche Sicherung der Datenbank und Konfigurationsdateien – +vollständig ohne manuelle Eingriffe. +So bleiben alle Benutzer, Freigaben und Systemeinstellungen jederzeit wiederherstellbar. + +### Ziel + +- Automatische tägliche Sicherung der Datenbank und Konfiguration +- Speicherung der Backups mit Datum im Dateinamen +- Protokollierung des Ablaufs in einer Logdatei +- Keine Unterbrechung des laufenden Betriebs + +> [!TIP] +> Die Sicherung läuft regelmäßig im Hintergrund und legt für jeden Tag ein separates Archiv an. +> Damit hast du jederzeit Zugriff auf ältere Stände, falls du versehentlich etwas gelöscht oder geändert hast. + +### Sicherungsskript anlegen + +Melde dich per SSH im Nextcloud-Container an und öffne den Editor: + +```bash +nano /usr/local/bin/nextcloud_backup.sh +``` + +Füge den folgenden Inhalt ein: + +```bash +#!/bin/bash +# +# nextcloud_backup.sh +# Erstellt ein tägliches Backup der Nextcloud-Datenbank und -Konfiguration +# + +BACKUP_DIR="/mnt/hdd/nextcloud_backups" +DATE=$(date +'%Y-%m-%d_%H-%M') +DB_NAME="nextcloud" +DB_USER="nextcloud" +DB_PASS="DEIN_SICHERES_PASSWORT" +NC_PATH="/srv/nextcloud/app/nextcloud" +LOGFILE="/var/log/nextcloud_backup.log" + +mkdir -p "$BACKUP_DIR" + +echo "[$(date +'%d.%m.%Y %H:%M:%S')] Backup gestartet" >> "$LOGFILE" + +# Datenbank sichern +pg_dump -U "$DB_USER" "$DB_NAME" > "$BACKUP_DIR/db_${DATE}.sql" + +# Konfiguration und App-Verzeichnis sichern +tar -czf "$BACKUP_DIR/config_${DATE}.tar.gz" \ + "$NC_PATH/config" \ + "$NC_PATH/themes" \ + "$NC_PATH/custom_apps" + +echo "[$(date +'%d.%m.%Y %H:%M:%S')] Backup abgeschlossen" >> "$LOGFILE" +``` + +Datei speichern mit **STRG+O**, Enter, und mit **STRG+X** schließen. +Anschließend ausführbar machen: + +```bash +chmod +x /usr/local/bin/nextcloud_backup.sh +``` + +> [!NOTE] +> Das Skript legt alle Backups unter `/mnt/hdd/nextcloud_backups` ab. +> Jedes Backup enthält eine Datenbanksicherung und die wichtigsten Konfigurationsdateien. + +### Automatische Ausführung einrichten + +Damit das Backup regelmäßig läuft, hinterlegen wir das Skript im Cron-Dienst des Containers. + +```bash +crontab -e +``` + +Ganz unten einfügen: + +```bash +0 3 * * * /usr/local/bin/nextcloud_backup.sh +``` + +> [!TIP] +> Diese Zeile führt das Backup täglich um **03:00 Uhr** aus. +> Du kannst den Zeitpunkt anpassen, z. B. `0 2 * * *` für 02:00 Uhr. + +Speichern: **STRG+O**, Enter +Beenden: **STRG+X** + +### Ergebnis prüfen + +Nach der ersten Ausführung kannst du prüfen, ob das Backup funktioniert hat: + +```bash +ls -lh /mnt/hdd/nextcloud_backups +``` + +Du solltest zwei neue Dateien sehen, z. B.: + +``` +db_2025-10-05_03-00.sql +config_2025-10-05_03-00.tar.gz +``` + +Das Protokoll kannst du mit folgendem Befehl anzeigen: + +```bash +tail -n 20 /var/log/nextcloud_backup.log +``` + +> [!TIP] +> Wenn du die Sicherung sofort testen möchtest, führe das Skript einmal manuell aus: +> ```bash +> /usr/local/bin/nextcloud_backup.sh +> ``` +> So siehst du direkt im Terminal, ob PostgreSQL und alle Pfade korrekt funktionieren. + +👉 *Screenshot geeignet: Terminal mit Ausgabe von `ls -lh /mnt/hdd/nextcloud_backups` und `tail -n 20 /var/log/nextcloud_backup.log`.* + +## Automatische Löschung älterer Sicherungen + +Damit der Speicherplatz auf deiner Festplatte nicht durch alte Backups überläuft, +ergänzen wir das Sicherungsskript um eine automatische Löschfunktion. +Diese entfernt Sicherungen, die älter als eine bestimmte Anzahl von Tagen sind. +So bleibt der Backup-Ordner sauber, ohne dass du manuell eingreifen musst. + +### Ziel + +- Ältere Sicherungen automatisch löschen +- Zeitraum frei wählbar (z. B. 30 Tage) +- Log-Eintrag für jede gelöschte Datei + +> [!TIP] +> 30 Tage sind ein bewährter Zeitraum, um genug Sicherungen vorzuhalten und trotzdem Speicherplatz zu sparen. +> Du kannst die Zahl aber jederzeit anpassen – sie ist direkt im Skript konfigurierbar. + +### Skript anpassen + +Öffne das Sicherungsskript erneut: + +```bash +nano /usr/local/bin/nextcloud_backup.sh +``` + +Ergänze am Ende des Skripts folgende Zeilen **unterhalb** des letzten `echo`-Befehls: + +```bash +# Alte Backups löschen (älter als 30 Tage) +find "$BACKUP_DIR" -type f -mtime +30 -print -delete >> "$LOGFILE" 2>&1 +echo "[$(date +'%d.%m.%Y %H:%M:%S')] Alte Backups (älter als 30 Tage) gelöscht" >> "$LOGFILE" +``` + +Speichern mit **STRG+O**, Enter, und beenden mit **STRG+X**. + +### Funktionsweise + +- `find` durchsucht den Backup-Ordner nach Dateien, die älter als 30 Tage sind (`-mtime +30`). +- Diese Dateien werden gelöscht, und die Dateinamen werden im Log vermerkt. +- Der Befehl läuft jedes Mal mit, wenn das Backup gestartet wird. + +> [!NOTE] +> Du kannst den Zeitraum flexibel anpassen – etwa `-mtime +14` für zwei Wochen +> oder `-mtime +60` für zwei Monate Aufbewahrungszeit. +> Achte darauf, dass der Befehl immer **am Ende** des Skripts steht, +> damit erst das neue Backup erstellt und danach aufgeräumt wird. + +### Überprüfung + +Um zu sehen, ob die Bereinigung funktioniert, kannst du sie manuell testen: + +```bash +bash /usr/local/bin/nextcloud_backup.sh +``` + +Danach prüfst du das Log: + +```bash +tail -n 20 /var/log/nextcloud_backup.log +``` + +Wenn dort Einträge wie +`Alte Backups (älter als 30 Tage) gelöscht` +erscheinen, funktioniert die Automatik korrekt. + +👉 *Screenshot geeignet: Logdatei mit Hinweis auf gelöschte Backups und aktuelle Sicherung.* + +## Wiederherstellung eines Backups + +Eine Sicherung ist nur so gut, wie ihre Wiederherstellung funktioniert. +In diesem Abschnitt stellen wir sicher, dass du im Notfall deine komplette Nextcloud +– inklusive Datenbank, Konfiguration und App-Einstellungen – schnell und zuverlässig wiederherstellen kannst. + +### Ziel + +- Wiederherstellung der Nextcloud-Datenbank und Konfigurationsdateien +- Schritt-für-Schritt-Ablauf ohne Risiko +- Funktioniert sowohl nach Datenverlust als auch bei Migration auf neue Hardware + +> [!IMPORTANT] +> Du kannst die Wiederherstellung jederzeit in einer Testumgebung üben. +> So weißt du im Ernstfall genau, welche Schritte nötig sind, und vermeidest Fehler unter Zeitdruck. + +### Vorbereitung + +1. **Nextcloud-Dienst stoppen**, damit keine Schreibvorgänge stattfinden: + ```bash + systemctl stop nginx + systemctl stop php8.3-fpm + systemctl stop redis-server + systemctl stop postgresql + ``` +2. **Backup-Verzeichnis prüfen:** + ```bash + ls -lh /mnt/hdd/nextcloud_backups + ``` + Wähle das gewünschte Sicherungsdatum, z. B. `db_2025-10-05_03-00.sql` und `config_2025-10-05_03-00.tar.gz`. + +### Wiederherstellung der Datenbank + +1. PostgreSQL starten: + ```bash + systemctl start postgresql + ``` +2. Bestehende Datenbank löschen und neu anlegen: + ```bash + su - postgres + psql -c "DROP DATABASE nextcloud;" + psql -c "CREATE DATABASE nextcloud;" + psql -c "GRANT ALL PRIVILEGES ON DATABASE nextcloud TO nextcloud;" + exit + ``` +3. Datenbankinhalt wiederherstellen: + ```bash + psql -U nextcloud -d nextcloud < /mnt/hdd/nextcloud_backups/db_2025-10-05_03-00.sql + ``` + +> [!NOTE] +> Wenn du mehrere Backups im Ordner hast, kannst du natürlich auch ein älteres Datum verwenden. +> Ersetze einfach den Dateinamen im Befehl durch die gewünschte Sicherung. + +### Wiederherstellung der Konfiguration + +1. Alte Konfiguration entfernen (optional, falls beschädigt): + ```bash + rm -rf /srv/nextcloud/app/nextcloud/config + rm -rf /srv/nextcloud/app/nextcloud/themes + rm -rf /srv/nextcloud/app/nextcloud/custom_apps + ``` +2. Archiv entpacken: + ```bash + tar -xzf /mnt/hdd/nextcloud_backups/config_2025-10-05_03-00.tar.gz -C / + ``` + Dadurch werden die gesicherten Ordner wieder an ihre ursprüngliche Position kopiert. + +3. Berechtigungen prüfen: + ```bash + chown -R www-data:www-data /srv/nextcloud/app/nextcloud + chmod -R 750 /srv/nextcloud/app/nextcloud + ``` + +### Neustart der Dienste + +Nach der Wiederherstellung startest du die Dienste wieder: + +```bash +systemctl start redis-server +systemctl start php8.3-fpm +systemctl start nginx +``` + +> [!TIP] +> Wenn du möchtest, kannst du vor dem Neustart mit +> ```bash +> systemctl status nginx php8.3-fpm redis-server postgresql +> ``` +> prüfen, ob alle Dienste fehlerfrei bereitstehen. + +### Überprüfung + +Öffne im Browser deine Nextcloud-URL, z. B.: + +``` +https://cloud.DEINE-DOMAIN.tld +``` + +Du solltest dich mit deinem bestehenden Benutzer anmelden können +und dieselben Dateien, Freigaben und Einstellungen wie vor dem Backup sehen. + +> [!NOTE] +> Wenn der Login nicht sofort funktioniert, leere den Browser-Cache oder führe einen Neustart des Containers durch. +> Danach ist die Instanz wieder vollständig betriebsbereit. + +👉 *Screenshot geeignet: Terminal mit erfolgreicher Datenbank-Wiederherstellung und Nextcloud-Login im Browser.* + +## Mail-Benachrichtigung bei Backup-Ergebnissen + +Nextcloud verfügt über eine eigene Mailfunktion, die Systemmeldungen und Benachrichtigungen automatisch verschicken kann. +Diese Funktion nutzen wir auch für die Information über erfolgreiche oder fehlgeschlagene Backups. +Damit entfällt die manuelle Prüfung der Logdateien – du wirst direkt per E-Mail informiert, wenn etwas schiefgeht. + +### Ziel + +- Automatische E-Mail-Benachrichtigung bei fehlerhaften oder erfolgreichen Backups +- Keine zusätzlichen Programme oder Konfigurationen außerhalb von Nextcloud +- Nutzung der integrierten SMTP-Funktion in der Weboberfläche + +### Einrichtung in Nextcloud + +1. **Anmelden als Administrator** + Melde dich in deiner Nextcloud unter + ``` + https://cloud.DEINE-DOMAIN.tld + ``` + mit deinem Admin-Konto an. + +2. **Mail-Server öffnen** + Klicke oben rechts auf dein Profilbild → **Einstellungen** → **Verwaltung** → **Grundlegende Einstellungen**. + Scrolle bis zum Abschnitt **E-Mail-Server**. + +3. **SMTP-Daten eintragen** + - Versandmethode: **SMTP** + - Verschlüsselung: **STARTTLS** + - Authentifizierung: aktivieren + - Absenderadresse: z. B. `nextcloud@DEINE-DOMAIN.tld` + - Benutzername und Passwort: Zugangsdaten deines Mailkontos + - SMTP-Server: z. B. `mail.DEINE-DOMAIN.tld` + - Port: **587** + + 👉 *Screenshot geeignet: Nextcloud-Einstellungen → E-Mail-Server mit ausgefüllten SMTP-Daten.* + +4. **Testmail senden** + Klicke auf **E-Mail-Versand testen**. + Wenn alles funktioniert, erscheint die Meldung *„E-Mail erfolgreich gesendet.“* + +> [!NOTE] +> Einige Mailanbieter – etwa Google, GMX oder Outlook – verlangen für externe Anwendungen ein **App-Passwort**, +> das du im Kundenportal generieren kannst. +> Trage in diesem Fall das App-Passwort statt deines normalen Logins ein. + +### Aktivierung der Benachrichtigungen + +Damit du über Systemereignisse informiert wirst: + +1. Öffne in der Weboberfläche oben rechts das Glocken-Symbol (Benachrichtigungen). +2. Klicke unten auf **Einstellungen**. +3. Aktiviere **Systemmeldungen per E-Mail erhalten**. + +Nextcloud verschickt dann automatisch eine Nachricht, +wenn Cronjobs oder interne Prozesse (wie das Backup-Skript) Fehler melden. +Damit bleibst du informiert, ohne externe Tools zu benötigen. + +👉 *Screenshot geeignet: Benachrichtigungsmenü mit aktivierter Option „Systemmeldungen per E-Mail erhalten“.* + +## php.ini- und www.conf-Tuning + +Nextcloud arbeitet mit PHP-FPM – das bedeutet, dass alle Webanfragen durch einen PHP-Prozess laufen. +Damit große Uploads, wie z. B. VODs oder Projektarchive, problemlos übertragen werden können, +passen wir die wichtigsten PHP-Parameter an. +Das betrifft die Dateien **php.ini** (globale Werte) und **www.conf** (Prozesssteuerung). + +> [!NOTE] +> Diese Optimierungen sind speziell für Systeme gedacht, die große Mediendateien verarbeiten. +> Sie verbessern Stabilität und Performance deutlich – ohne, dass du mehr Hardware benötigst. + +### Ziel + +- Große Datei-Uploads bis 50 GB ermöglichen +- PHP-Cache optimieren für schnellere Ladezeiten +- Parallelverarbeitung von Anfragen stabilisieren + +### php.ini anpassen + +Öffne die globale PHP-Konfiguration: + +```bash +nano /etc/php/8.3/fpm/php.ini +``` + +Suche und passe folgende Parameter an: + +```ini +upload_max_filesize = 50G +post_max_size = 50G +memory_limit = 2048M +max_execution_time = 7200 +max_input_time = 7200 +date.timezone = Europe/Berlin + +opcache.enable = 1 +opcache.memory_consumption = 256 +opcache.max_accelerated_files = 20000 +opcache.interned_strings_buffer = 16 +opcache.validate_timestamps = 1 +``` + +> [!TIP] +> Für Nextcloud ist es unkritisch, große Werte zu setzen – +> sie gelten nur, wenn tatsächlich große Dateien übertragen werden. +> `max_execution_time` und `max_input_time` sichern lange Uploads gegen Abbrüche ab. + +Speichern: **STRG+O**, Enter +Beenden: **STRG+X** + +--- + +### www.conf anpassen + +Die Datei `www.conf` bestimmt, wie viele PHP-Prozesse gleichzeitig arbeiten dürfen. +Das ist wichtig, wenn viele Uploads oder Vorschaugenerierungen parallel laufen. + +```bash +nano /etc/php/8.3/fpm/pool.d/www.conf +``` + +Passe folgende Werte an: + +```ini +pm = dynamic +pm.max_children = 25 +pm.start_servers = 5 +pm.min_spare_servers = 3 +pm.max_spare_servers = 10 +pm.max_requests = 500 + +; Pfadvariable setzen (wichtig für OCC-Befehle) +env[PATH] = /usr/local/bin:/usr/bin:/bin +``` + +> [!NOTE] +> Diese Werte sind auf Container mit 8–16 GB RAM ausgelegt. +> Wenn du mehr Ressourcen hast, kannst du `pm.max_children` entsprechend erhöhen. +> Bei kleineren Containern (z. B. 4 GB RAM) ist ein Wert zwischen 10–15 sinnvoll. + +Anschließend PHP-FPM neu laden: + +```bash +systemctl reload php8.3-fpm +``` + +--- + +### Wirkung prüfen + +1. Öffne in Nextcloud **Einstellungen → Verwaltung → Übersicht**. +2. Wenn keine Warnungen mehr zu Speicher- oder Upload-Limits erscheinen, greifen die neuen Werte. +3. Optional prüfen: + ```bash + systemctl status php8.3-fpm + ``` + +> [!TIP] +> Diese Optimierung wirkt sich nicht nur auf Uploads aus, +> sondern beschleunigt auch App-Installationen und Dateioperationen innerhalb von Nextcloud. + +👉 *Screenshot geeignet: Nextcloud-Adminbereich mit angepassten PHP-Limits ohne Warnmeldungen.* + +## Redis-Optimierung + +Redis ist in Nextcloud der zentrale Zwischenspeicher für häufig genutzte Daten, +z. B. Session-Informationen, Datei-Locks und Cache-Einträge. +Dadurch entfällt bei jedem Seitenaufruf ein Großteil der Datenbankabfragen – +Nextcloud reagiert schneller und stabiler, besonders bei mehreren gleichzeitigen Zugriffen. + +Im Free-Teil haben wir Redis bereits eingerichtet. +Hier optimieren wir seine Leistung und verhindern, dass alte Cache-Einträge unkontrolliert wachsen. + +> [!NOTE] +> Diese Anpassungen sind besonders sinnvoll, wenn du mehrere Benutzer hast oder große Datenmengen mit häufigen Dateioperationen verarbeitest. + +### Ziel + +- Stabileres File-Locking und schnellerer Seitenaufbau +- Automatische Speicherbereinigung bei hohem Redis-Füllstand +- Kürzere Zugriffszeiten durch gezieltes Feintuning + +--- + +### Redis-Konfiguration prüfen + +Öffne die Redis-Konfiguration: + +```bash +nano /etc/redis/redis.conf +``` + +Suche und ändere bzw. ergänze folgende Zeilen: + +```ini +# Redis durch systemd verwalten lassen +supervised systemd + +# Socket statt TCP-Port nutzen (schneller und sicherer) +unixsocket /var/run/redis/redis-server.sock +unixsocketperm 770 + +# Maximalen Speicherbedarf festlegen (Beispiel: 256 MB) +maxmemory 256mb + +# Alte Schlüssel entfernen, wenn Speicher voll ist +maxmemory-policy allkeys-lru + +# Hintergrund-Speicherung aktivieren +save 900 1 +save 300 10 +save 60 10000 +``` + +> [!TIP] +> `maxmemory 256mb` ist ein stabiler Wert für Container mit 4–8 GB RAM. +> Wenn du viele gleichzeitige Benutzer hast, kannst du auf 512 MB erhöhen. + +Speichern: **STRG+O**, Enter +Beenden: **STRG+X** + +Redis neu starten: + +```bash +systemctl restart redis-server +``` + +--- + +### Socket-Rechte prüfen + +Redis kommuniziert mit Nextcloud über einen UNIX-Socket. +Damit Nextcloud darauf zugreifen darf, muss der Webserver-Benutzer (`www-data`) Mitglied der Redis-Gruppe sein: + +```bash +usermod -aG redis www-data +systemctl restart php8.3-fpm +``` + +> [!NOTE] +> Diese Einstellung brauchst du nur einmal vorzunehmen. +> Sie bleibt auch nach einem Neustart erhalten. + +--- + +### Redis-Status testen + +Mit folgendem Befehl kannst du prüfen, ob Redis läuft und korrekt eingebunden ist: + +```bash +redis-cli -s /var/run/redis/redis-server.sock ping +``` + +Die Ausgabe sollte lauten: + +``` +PONG +``` + +Wenn stattdessen eine Fehlermeldung erscheint (z. B. „Permission denied“), +stimmen die Socketrechte oder Gruppenmitgliedschaften noch nicht. + +> [!TIP] +> In Nextcloud selbst kannst du unter +> **Einstellungen → Verwaltung → Übersicht** +> sehen, ob Redis erkannt wurde. +> Wenn dort keine Warnung zu „Transactional File Locking“ mehr erscheint, funktioniert alles korrekt. + +👉 *Screenshot geeignet: Terminalausgabe mit „PONG“ und Nextcloud-Adminbereich ohne Redis-Warnmeldung.* + +## Externe Speicher in Nextcloud einbinden + +Nextcloud kann auch Daten anzeigen, die gar nicht im normalen Cloud-Ordner liegen. +So kannst du zum Beispiel deine Videodateien, Projektordner oder große Backups +auf einer zweiten Festplatte ablegen und trotzdem direkt in Nextcloud darauf zugreifen. + +Das spart Speicher im Hauptordner und macht die Übersicht deutlich einfacher – +besonders, wenn du regelmäßig große Dateien (z. B. VODs) nutzt. + +> [!NOTE] +> Du musst dafür keine neue Festplatte kaufen oder alles verschieben. +> Nextcloud kann vorhandene Ordner einfach **verlinken** und wie eigene Daten behandeln. + +--- + +### Ziel + +- Zusätzliche Ordner oder Laufwerke direkt in Nextcloud einbinden +- Zugriff über die normale Weboberfläche +- Freigabe oder Zugriff nur für bestimmte Nutzer möglich + +--- + +### Schritt 1 – App „Externer Speicher“ aktivieren + +1. Melde dich als Administrator in deiner Nextcloud an. +2. Klicke oben rechts auf dein Profilbild → **Apps**. +3. Wähle links den Bereich **Integration**. +4. Suche die App **„Externer Speicher“** und klicke auf **Aktivieren**. + +👉 *Screenshot geeignet: Nextcloud-App-Übersicht mit aktivierter „Externer Speicher“-App.* + +--- + +### Schritt 2 – Speicher hinzufügen + +1. Klicke oben rechts wieder auf dein Profilbild → **Einstellungen**. +2. Scrolle links im Menü bis zum Bereich **Verwaltung → Externer Speicher**. +3. Klicke unten auf **Hinzufügen**. +4. Wähle im Feld **Ordnername** aus, wie der Speicher in Nextcloud heißen soll, z. B. `Videos`. +5. Im Feld **Speichertyp** wählst du: + - **Lokal** – wenn der Ordner im Container liegt (z. B. `/mnt/hdd/videos`) + - **SFTP** – wenn der Ordner auf einem anderen Server oder Container liegt + +👉 *Screenshot geeignet: Maske „Externer Speicher hinzufügen“ mit ausgewähltem Typ „Lokal“.* + +--- + +### Schritt 3 – Pfad oder Verbindung eintragen + +**Für lokale Speicher:** +1. Öffne im Container ein Terminal. +2. Lege einen Ordner an, falls er noch nicht existiert: + ```bash + mkdir -p /mnt/hdd/videos + chown -R www-data:www-data /mnt/hdd/videos + chmod 750 /mnt/hdd/videos + ``` +3. Trage in der Nextcloud-Weboberfläche bei **Pfad** genau diesen Ordner ein: + ``` + /mnt/hdd/videos + ``` + +**Für SFTP (andere Server oder Container):** +1. Wähle in der Nextcloud-Maske als Typ **SFTP**. +2. Gib unter **Host** die IP-Adresse des Zielservers an (z. B. `10.0.0.10`). +3. Trage deinen **Benutzernamen** und das **Passwort** ein, + das du auf dem Zielsystem für den Zugriff verwendest. +4. Im Feld **Pfad** gibst du an, wo die Dateien dort liegen (z. B. `/srv/uploads`). + +> [!TIP] +> Bei SFTP musst du nichts extra installieren – die Verbindung nutzt dieselbe Technik, +> die du auch bei WinSCP oder FileZilla verwendest. + +--- + +### Schritt 4 – Zugriff testen + +1. Öffne in Nextcloud den Bereich **Dateien**. +2. Du siehst jetzt einen neuen Ordner, z. B. `Videos`. +3. Öffne ihn – wenn der Zugriff funktioniert, kannst du Dateien sehen oder neue hinzufügen. + +> [!NOTE] +> Wenn du die Meldung *„Speicher nicht verfügbar“* siehst, +> stimmt meist der Pfad oder der Benutzerzugriff im Container nicht. +> Prüfe im Terminal, ob der Ordner wirklich existiert +> und `www-data` der Besitzer ist: +> ```bash +> ls -ld /mnt/hdd/videos +> ``` + +👉 *Screenshot geeignet: Nextcloud-Dateiansicht mit geöffnetem Ordner „Videos“.* + +--- + +### Schritt 5 – Rechte und Freigaben + +In der Speicherverwaltung kannst du einstellen, +wer den neuen Speicher überhaupt sehen darf: + +- **Alle Benutzer** – jeder sieht den Ordner in seiner Cloud +- **Nur bestimmte Gruppen oder Admins** – sinnvoll für sensible Daten +- **Schreibgeschützt** – erlaubt nur das Ansehen, keine Änderungen + +> [!TIP] +> Wenn du mehrere Personen in deiner Nextcloud hast, +> lohnt sich die Gruppenzuweisung, damit jeder nur die passenden Ordner sieht. + +## SFTP-Upload-Integration + +Mit der SFTP-Integration kannst du Dateien automatisch von deiner Nextcloud auf einen anderen Server oder Container hochladen. +Das ist besonders praktisch, wenn du regelmäßig große Dateien sichern oder VODs automatisch auf einen Upload-Server verschieben willst – +zum Beispiel in deinen Archiv-Container, einen externen Speicher oder eine Produktionsumgebung. + +> [!NOTE] +> SFTP steht für **Secure File Transfer Protocol** und überträgt Daten verschlüsselt – +> im Gegensatz zu FTP, das unverschlüsselt arbeitet. +> Du kannst also auch sensible Daten sicher verschieben. + +--- + +### Ziel + +- Automatisches Hochladen ausgewählter Dateien über SFTP +- Kein manuelles Kopieren mehr per WinSCP oder FileZilla +- Optional: Tägliche Synchronisierung mit einem anderen Server + +--- + +### Schritt 1 – SSH-Schlüssel erstellen + +Wir nutzen SSH-Schlüssel, damit der Upload ohne Passworteingabe funktioniert. +Öffne das Terminal im Nextcloud-Container: + +```bash +ssh-keygen -t ed25519 -f /root/.ssh/id_ed25519 -C "nextcloud-auto-upload" +``` + +> Drücke einfach **Enter**, wenn nach einer Passphrase gefragt wird. +> Der Schlüssel besteht aus zwei Dateien: +> - `/root/.ssh/id_ed25519` → privater Schlüssel (bleibt im Container) +> - `/root/.ssh/id_ed25519.pub` → öffentlicher Schlüssel (wird auf dem Zielserver hinterlegt) + +--- + +### Schritt 2 – Schlüssel auf Zielsystem hinterlegen + +1. Melde dich auf dem Zielsystem (z. B. Archiv-Container oder externer Server) an. +2. Öffne dort die Datei: + ```bash + nano ~/.ssh/authorized_keys + ``` +3. Füge den Inhalt der Datei `/root/.ssh/id_ed25519.pub` aus dem Nextcloud-Container ein. +4. Datei speichern (**STRG+O**, Enter, **STRG+X**) und schließen. + +> [!TIP] +> Falls die Datei `authorized_keys` noch nicht existiert, wird sie automatisch erstellt. +> Achte darauf, dass sie dem Benutzer gehört, unter dem du dich verbindest. + +--- + +### Schritt 3 – Verbindung testen + +Zurück im Nextcloud-Container: + +```bash +sftp user@10.0.0.10 +``` + +Wenn du ohne Passwortabfrage verbunden wirst, funktioniert der Schlüsselzugriff. +Beende die Sitzung mit: + +```bash +exit +``` + +👉 *Screenshot geeignet: Terminalausgabe mit erfolgreicher SFTP-Verbindung ohne Passwort.* + +--- + +### Schritt 4 – Upload-Skript erstellen + +Jetzt legen wir ein einfaches Skript an, das Dateien aus einem bestimmten Nextcloud-Ordner +(z. B. „Uploads“) automatisch auf das Zielsystem überträgt. + +```bash +nano /usr/local/bin/nextcloud_sftp_upload.sh +``` + +Füge den folgenden Inhalt ein: + +```bash +#!/bin/bash +# +# nextcloud_sftp_upload.sh +# Lädt Dateien aus dem Upload-Ordner per SFTP auf ein Zielsystem hoch +# + +SOURCE="/mnt/hdd/nextcloud_data/admin/files/Uploads" +TARGET="user@10.0.0.10:/srv/archive" +LOGFILE="/var/log/nextcloud_sftp_upload.log" + +echo "[$(date +'%d.%m.%Y %H:%M:%S')] Upload gestartet" >> "$LOGFILE" + +# Hochladen aller neuen Dateien +sftp -q -b - "$TARGET" <> "$LOGFILE" +``` + +Datei speichern und schließen (**STRG+O**, Enter, **STRG+X**) +Dann ausführbar machen: + +```bash +chmod +x /usr/local/bin/nextcloud_sftp_upload.sh +``` + +--- + +### Schritt 5 – Automatische Ausführung planen + +Damit die Dateien regelmäßig übertragen werden, +tragen wir das Skript im Cron-Dienst ein: + +```bash +crontab -e +``` + +Am Ende hinzufügen: + +```bash +30 2 * * * /usr/local/bin/nextcloud_sftp_upload.sh +``` + +> [!NOTE] +> Damit startet der Upload täglich um **02:30 Uhr**. +> Du kannst die Uhrzeit natürlich frei anpassen. + +--- + +### Schritt 6 – Funktion testen + +Starte das Skript manuell: + +```bash +/usr/local/bin/nextcloud_sftp_upload.sh +``` + +Dann prüfe das Log: + +```bash +tail -n 20 /var/log/nextcloud_sftp_upload.log +``` + +Wenn alles funktioniert, siehst du im Zielverzeichnis die hochgeladenen Dateien. + +> [!TIP] +> Du kannst auch mehrere Zielsysteme eintragen, +> indem du die `sftp`-Befehle im Skript einfach duplizierst – +> z. B. für gleichzeitige Sicherung auf Archiv- und Backup-Server. + +👉 *Screenshot geeignet: Terminal mit erfolgreichem Upload und Logauszug.* + +## Preview-Cache optimieren + +Nextcloud erzeugt für viele Dateitypen automatisch Vorschaubilder (Previews) – +zum Beispiel für Fotos, Videos oder PDFs. +Das ist praktisch, kann aber bei großen Medienbibliotheken schnell viel Rechenleistung und Speicherplatz verbrauchen. +Mit den richtigen Einstellungen lassen sich die Previews deutlich beschleunigen und besser kontrollieren. + +> [!NOTE] +> Diese Optimierung ist besonders wichtig, wenn du viele hochauflösende Dateien nutzt – +> etwa VODs, Thumbnails oder große Bildergalerien. + +--- + +### Ziel + +- Vorschaugenerierung beschleunigen +- Speicherbedarf für Thumbnails reduzieren +- CPU-Last bei großen Datenmengen senken + +--- + +### Schritt 1 – Preview-App prüfen + +1. Melde dich als Administrator in deiner Nextcloud an. +2. Klicke oben rechts auf dein Profilbild → **Apps**. +3. Suche im Bereich **Multimedia** nach der App **Preview Generator**. +4. Wenn sie noch nicht aktiviert ist, klicke auf **Aktivieren**. + +👉 *Screenshot geeignet: App-Übersicht mit aktivierter „Preview Generator“-App.* + +> [!TIP] +> Die App ist offiziell von Nextcloud und in jeder Installation enthalten. +> Sie kümmert sich um die Erstellung und Verwaltung von Vorschaubildern. + +--- + +### Schritt 2 – Standardwerte anpassen + +Nextcloud erstellt standardmäßig viele verschiedene Vorschaustufen. +Das verlangsamt den Upload großer Dateien und kann mehrere Gigabyte Speicher belegen. +Wir begrenzen die Anzahl der Größen und definieren sinnvolle Maximalwerte. + +Öffne die Konfiguration: + +```bash +nano /srv/nextcloud/app/nextcloud/config/config.php +``` + +Füge (oder ergänze) diese Zeilen: + +```php +'enabledPreviewProviders' => [ + 'OC\\Preview\\Image', + 'OC\\Preview\\JPEG', + 'OC\\Preview\\PNG', + 'OC\\Preview\\GIF', + 'OC\\Preview\\PDF', + 'OC\\Preview\\MP3', + 'OC\\Preview\\TXT', + 'OC\\Preview\\Movie', +], + +'preview_max_x' => 2048, +'preview_max_y' => 2048, +'preview_max_filesize_image' => 50, +``` + +> [!NOTE] +> Diese Werte sind ein guter Kompromiss: +> - Maximal 2048 × 2048 Pixel für Previews +> - Keine Vorschau für Bilder größer als 50 MB +> - Unterstützt nur häufig genutzte Dateitypen + +Speichern und schließen (**STRG+O**, Enter, **STRG+X**). + +--- + +### Schritt 3 – Preview-Cache automatisch erzeugen + +Die Vorschauen lassen sich im Hintergrund generieren, +damit sie später sofort verfügbar sind. +Wir aktivieren dazu den Preview Generator als Cronjob. + +```bash +crontab -u www-data -e +``` + +Ganz unten einfügen: + +```bash +@daily php -f /srv/nextcloud/app/nextcloud/occ preview:generate-all -vvv +``` + +> [!TIP] +> Dadurch werden jeden Tag alle neu hochgeladenen Dateien automatisch verarbeitet. +> Beim ersten Lauf kann der Prozess länger dauern, da vorhandene Dateien nachgerendert werden. + +--- + +### Schritt 4 – Preview-Cache aufräumen + +Mit der Zeit sammeln sich viele alte Thumbnails an, +die für gelöschte Dateien gar nicht mehr gebraucht werden. +Wir bereinigen sie regelmäßig: + +```bash +@weekly php -f /srv/nextcloud/app/nextcloud/occ preview:cleanup -n +``` + +So bleibt der Cache schlank und aktuell. + +> [!NOTE] +> Beide Cronjobs laufen leise im Hintergrund. +> Du musst nichts weiter tun, die Previews bleiben immer aufgeräumt. + +--- + +### Schritt 5 – Wirkung prüfen + +1. Öffne in Nextcloud den Ordner mit vielen Bildern oder Videos. +2. Beim ersten Öffnen werden die Vorschaubilder schnell sichtbar, ohne lange Ladezeit. +3. Die Systemauslastung bleibt auch bei mehreren Dateien stabil. + +👉 *Screenshot geeignet: Nextcloud-Dateiansicht mit geladenen Vorschaubildern ohne Verzögerung.* + +> [!TIP] +> Wenn du häufig große Medien bearbeitest, lohnt es sich, den Cronjob nachts laufen zu lassen. +> So entstehen keine Performanceeinbußen während der Nutzung. +