1012 lines
30 KiB
Markdown
1012 lines
30 KiB
Markdown
# 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" <<EOF
|
||
put -r "$SOURCE"/*
|
||
EOF
|
||
|
||
echo "[$(date +'%d.%m.%Y %H:%M:%S')] Upload abgeschlossen" >> "$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.
|
||
|