# 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.

## Abschluss & Ergebnis

Mit den Erweiterungen aus diesem Kapitel ist deine Nextcloud nun vollständig automatisiert, optimiert und für den langfristigen Einsatz ausgelegt.  
Sicherungen laufen automatisch, alte Backups werden bereinigt, und bei Bedarf kannst du jederzeit alles wiederherstellen.  
Zudem sorgen die angepassten PHP- und Redis-Einstellungen für eine stabile Performance,  
auch bei größeren Uploads, VOD-Dateien oder mehreren gleichzeitigen Zugriffen.  

> [!NOTE]  
> Alle Optimierungen greifen direkt in der bestehenden Installation.  
> Du musst nichts neu installieren oder manuell starten – die Abläufe wiederholen sich automatisch über Cron.

### Zusammenfassung der Erweiterungen

| Bereich | Erweiterung | Ergebnis |
|----------|--------------|-----------|
| **Backup-Automatik** | Tägliche Sicherung von Datenbank & Konfiguration | Schutz vor Datenverlust |
| **Backup-Aufräumung** | Löscht Backups älter als 30 Tage | Spart Speicherplatz |
| **Wiederherstellung** | Vollständige Rücksicherung in wenigen Schritten | Einfache Fehlerbehebung |
| **Mail-Benachrichtigung** | Systeminterne SMTP-Einrichtung | E-Mail bei Problemen oder Erfolgen |
| **PHP-Tuning** | Erhöhte Limits und optimierter Cache | Stabile Performance, große Uploads |
| **Redis-Optimierung** | Schnellere Dateisperren und geringere DB-Last | Reaktionsschnellere Cloud |
| **Externe Speicher** | Zusätzliche Laufwerke oder Server einbinden | Mehr Flexibilität bei großen Daten |
| **SFTP-Upload** | Automatischer Export in andere Container | Sicherer Datentransfer |
| **Preview-Cache** | Schnellere Vorschau, geringerer Speicherverbrauch | Flüssigere Nutzung von Medienordnern |

### Routine-Checks (empfohlen)

1. **Logs prüfen**  
   - Backup-Log: `/var/log/nextcloud_backup.log`  
   - Upload-Log (falls aktiv): `/var/log/nextcloud_sftp_upload.log`  

2. **Cronjobs testen**  
   - Manuell ausführen, um sicherzustellen, dass alles korrekt läuft:  
     ```bash
     crontab -l
     ```

3. **Speicherbelegung beobachten**  
   - Prüfen, ob der Backup-Ordner regelmäßig aufgeräumt wird:  
     ```bash
     ls -lh /mnt/hdd/nextcloud_backups
     ```

👉 *Screenshot geeignet: Nextcloud-Dashboard mit Systemstatus „Alles auf dem neuesten Stand“ und grünem Haken.*