diff --git a/Kapitel 7/Tutorial.md b/Kapitel 7/Tutorial.md
index 790bcf0..15ba298 100644
--- a/Kapitel 7/Tutorial.md	
+++ b/Kapitel 7/Tutorial.md	
@@ -4,161 +4,65 @@
 
 ## Einleitung
 
-Nextcloud ist das Herzstück deiner eigenen Cloud. Hier landen Dateien, Fotos, Kalender und Kontakte – und zwar ohne Abhängigkeit von Google oder Microsoft. In diesem Kapitel bauen wir Nextcloud so auf, dass sie stabil und performant läuft. Wir setzen auf **Nginx + PHP-FPM** als Webserver, **PostgreSQL** als Datenbank und **Redis** als Cache. Die Benutzerdaten liegen auf einer separaten Festplatte unter `/mnt/hdd`. Damit ist die Cloud nicht nur schnell, sondern auch zukunftssicher.
+Nextcloud ist das Herzstück deiner privaten Cloud. Hier landen Dateien, Fotos, Kalender und Kontakte – ohne Google, ohne Microsoft. In diesem Kapitel installieren wir Nextcloud **in einem LXC-Container unter Proxmox**, setzen auf **PostgreSQL** als Datenbank, **Nginx + PHP-FPM** als Webserver und **Redis** als Cache. Die Benutzerdaten liegen auf einer separaten Festplatte – für Performance, Übersicht und Datensicherheit.
 
 ---
 
 ## Voraussetzungen
 
-* **Proxmox Host** mit zwei Platten (System + Datenplatte)
-* **LXC (Ubuntu 24.04 LTS)** mit aktivem Nesting
-* **Nginx Proxy Manager** für HTTPS
+* **Proxmox Host** mit 2 Platten (System + Datenplatte)
+* **LXC mit Ubuntu 24.04**, Nesting aktiviert
+* **Nginx Proxy Manager** für HTTPS-Zugriff
 * Eine **Domain**, die auf deinen Proxy zeigt
-* Offene Ports **80/443** auf NPM
-* 2 vCPU, 4–8 GB RAM für den Container
-* Grundwissen: SSH, Proxmox-GUI, Nano-Editor
+* Container-Ressourcen: mind. 2 vCPU, 4 GB RAM
+* Grundwissen: Proxmox-GUI, SSH, Terminal
 
 ---
 
 ## Vorbereitung
 
-### Container anlegen
+### LXC-Container erstellen
 
-In der Proxmox-GUI legst du einen neuen Container an, nennst ihn `nextcloud` und wählst Ubuntu 24.04 als Template. Gib ihm mindestens 2 CPUs und 4 GB RAM. Aktiviere „Nesting“. Als Root-Disk genügt die Systemplatte – die Daten legen wir gleich auf die zweite Platte.
+In der **Proxmox-GUI**:
 
-Beim Anlegen des Containers kann unter dem Punkt **Disks** direkt eine zweite Festplatte hinzugefügt werden:
+* CT-Name: `nextcloud`
+* Template: Ubuntu 24.04 LTS
+* CPU: 2+, RAM: 4–8 GB
+* **Nesting aktivieren** (unter „Optionen“)
 
-* Mount Point ID: automatisch
-* Storage: gewünschte Festplatte auswählen
-* Disk Größe: z. B. `500` (für 500 GB)
-* Pfad: `/mnt/hdd`
-* Backup-Haken entfernen, da wir später eine eigene Backup-Lösung verwenden
+#### Zweite Festplatte direkt einhängen
 
-Nach dem Start verbindest du dich per SSH:
+Beim Anlegen im Abschnitt „Disks“:
+
+* Mount Point: `/mnt/hdd`
+* Größe: z. B. `500` GB
+* Backup: deaktivieren
+
+Nach dem Start:
 
 ```bash
 ssh root@<IP-des-Containers>
-```
-
-Im Container prüfen:
-
-```bash
 ls -ld /mnt/hdd
 ```
 
-Wenn du hier ein Verzeichnis siehst, ist die Platte korrekt eingebunden.
+→ Gibt es das Verzeichnis? Dann ist alles korrekt eingebunden.
 
 ---
 
 ## Umsetzung
 
-### System vorbereiten
-
-Zuerst bringen wir das System auf den aktuellen Stand und installieren alle benötigten Pakete:
+### System aktualisieren & Pakete installieren
 
 ```bash
 apt update && apt upgrade -y
-apt install -y nginx php-fpm php-gd php-imagick php-intl php-mbstring php-xml php-zip php-curl php-bz2 php-gmp php-pgsql php-redis redis-server unzip curl postgresql postgresql-contrib
+apt install -y nginx php-fpm php-gd php-imagick php-intl php-mbstring php-xml \
+php-zip php-curl php-bz2 php-gmp php-pgsql php-redis redis-server \
+postgresql unzip curl
 ```
 
-Damit haben wir:
+---
 
-* Webserver: `nginx`
-* PHP mit allen benötigten Erweiterungen
-* Redis für Caching & Locking
-* PostgreSQL als Datenbank
-
-### PostgreSQL einrichten
-
-Damit Nextcloud später auf die Datenbank zugreifen kann, richten wir PostgreSQL korrekt ein. Wir arbeiten im Container als root – du brauchst weder sudo noch Umwege. Wichtig ist: PostgreSQL muss so konfiguriert werden, dass du dich mit Benutzername und Passwort lokal verbinden kannst.
-
-1. PostgreSQL-Version prüfen
-```bash
-ls /etc/postgresql/
-``` 
-
-Du bekommst z. B. 15 zurück. Diese Zahl brauchst du für den Pfad zur Konfigurationsdatei.
-
-2. Konfiguration anpassen
-```bash
-nano /etc/postgresql/15/main/pg_hba.conf
-```
-
-Ersetze 15 ggf. durch deine Version.
-
-Folgende Zeile:
-```bash
-local   all             postgres                                peer
-```
-
-ändern in:
-
-```bash
-local   all             postgres                                md5
-```
-
-Zusätzlich am Ende ergänzen:
-```bash
-host    all             all             127.0.0.1/32            md5
-```
-
-Speichern (STRG+O, Enter), schließen (STRG+X)
-
-3. PostgreSQL neu starten
-```bash
-systemctl restart postgresql
-```
-
-4. Passwort für postgres-Benutzer setzen
-
-Du brauchst jetzt ein Passwort, sonst kannst du dich nicht einloggen.
-```bash
-su - postgres
-```
-
-Dann:
-```bash
-psql -c "ALTER USER postgres WITH PASSWORD 'DEIN PASSWORT';"
-```
-
-Anschließend:
-```bash
-exit
-```
-5. Benutzer und Datenbank für Nextcloud anlegen
-```bash
-psql -U postgres -h 127.0.0.1
-```
-
-In der psql-Konsole:
-```bash
-CREATE DATABASE nextcloud;
-CREATE USER nextcloud WITH ENCRYPTED PASSWORD '149774Thomas!!';
-GRANT ALL PRIVILEGES ON DATABASE nextcloud TO nextcloud;
-\q
-```
-
-6. Verbindung testen
-```bash
-psql -U nextcloud -h 127.0.0.1 -d nextcloud -W
-```
-
-Wenn die Verbindung aufgebaut wird, ist alles korrekt.
-
-### System vorbereiten
-
-Zuerst bringen wir das System auf den aktuellen Stand und installieren alle benötigten Pakete:
-
-```bash
-apt update && apt upgrade -y
-apt install -y nginx php-fpm php-gd php-imagick php-intl php-mbstring php-xml php-zip php-curl php-bz2 php-gmp php-pgsql php-redis redis-server postgresql unzip curl
-```
-
-Damit haben wir den Webserver, PHP mit allen nötigen Erweiterungen, PostgreSQL als Datenbank, Redis als Cache sowie Werkzeuge zum Download und Entpacken.
-
-### Verzeichnisse anlegen
-
-Wir trennen Programmcode und Daten. Nextcloud selbst liegt unter `/srv/nextcloud/app`, während die Benutzerdaten auf der zweiten Platte gespeichert werden:
+### Projektstruktur anlegen
 
 ```bash
 mkdir -p /srv/nextcloud/app
@@ -166,138 +70,138 @@ mkdir -p /mnt/hdd/nextcloud_data
 chown -R www-data:www-data /mnt/hdd/nextcloud_data
 ```
 
-So ist sichergestellt, dass der Webserver-User `www-data` Zugriff hat.
+---
 
 ### Nextcloud herunterladen
 
-Jetzt laden wir die aktuelle Version von Nextcloud:
-
 ```bash
 cd /srv/nextcloud/app
 curl -LO https://download.nextcloud.com/server/releases/latest.zip
 unzip latest.zip && rm latest.zip
-chown -R www-data:www-data /srv/nextcloud/app/nextcloud
+chown -R www-data:www-data nextcloud
 ```
 
-Nach diesem Schritt findest du die entpackte Anwendung im Verzeichnis `nextcloud`.
+---
 
-### Datenbank einrichten
+### PostgreSQL: Benutzer & Datenbank
 
-Für die Datenbank verwenden wir PostgreSQL. Wir legen eine neue Datenbank und einen Benutzer an:
+🔸 WICHTIG: Wir nutzen **nur** `su - postgres`, daher ist **keine Änderung** an `pg_hba.conf` nötig!
 
 ```bash
-sudo -u postgres psql -c "CREATE DATABASE nextcloud;"
-sudo -u postgres psql -c "CREATE USER nextcloud WITH PASSWORD 'CHANGE_ME';"
-sudo -u postgres psql -c "GRANT ALL PRIVILEGES ON DATABASE nextcloud TO nextcloud;"
+su - postgres
 ```
 
-Damit ist eine leere Datenbank mit passenden Rechten vorbereitet.
+```sql
+CREATE DATABASE nextcloud;
+CREATE USER nextcloud WITH PASSWORD 'DEIN_SICHERES_PASSWORT';
+GRANT ALL PRIVILEGES ON DATABASE nextcloud TO nextcloud;
+\q
+exit
+```
+
+Test (optional):
+
+```bash
+psql -U nextcloud -h 127.0.0.1 -d nextcloud -W
+```
+
+Wenn du Zugriff bekommst → alles korrekt.
+
+---
+
+### PHP-FPM: Version prüfen
+
+```bash
+ls /run/php/
+```
+
+→ z. B. `php8.3-fpm.sock` → merken
+
+---
 
 ### Nginx konfigurieren
 
-Damit Nextcloud über den Webserver erreichbar ist, richten wir jetzt Nginx ein. Dazu brauchen wir eine sogenannte vHost‑Konfiguration – eine kleine Textdatei, die Nginx sagt, unter welchem Pfad Nextcloud liegt und wie PHP‑Dateien behandelt werden sollen.
+```bash
+nano /etc/nginx/sites-available/nextcloud.conf
+```
 
-1. **Prüfe zuerst, wie dein PHP‑FPM‑Socket heißt**
-   Das ist wichtig, weil die Datei je nach PHP‑Version leicht anders heißt (z. B. `php8.3-fpm.sock`).
+```nginx
+server {
+  listen 80;
+  server_name _;
 
-   ```bash
-   ls /run/php/
-   ```
+  root /srv/nextcloud/app/nextcloud;
+  index index.php index.html;
 
-   **Erwartung:** Du siehst eine Datei wie `php8.3-fpm.sock`. Merke dir den **exakten Namen**.
+  client_max_body_size 10G;
 
-2. **vHost-Datei mit Nano anlegen/öffnen**
+  location = /robots.txt { allow all; log_not_found off; access_log off; }
+  location ~ ^/(?:\.|autotest|occ|issue|indie|db_|console) { deny all; }
 
-   ```bash
-   nano /etc/nginx/sites-available/nextcloud.conf
-   ```
+  location ~ \.php(?:$|/) {
+    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    include fastcgi_params;
+    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+    fastcgi_param PATH_INFO $fastcgi_path_info;
+    fastcgi_pass unix:/run/php/php8.3-fpm.sock;  # ggf. anpassen
+    fastcgi_intercept_errors on;
+    fastcgi_request_buffering off;
+  }
+}
+```
 
-   > **Nano kurz erklärt:** Der Bildschirm wird blau, unten siehst du eine Befehlsleiste. Füge den folgenden Text **am Stück** ein. Speichern: **STRG+O**, Enter. Beenden: **STRG+X**.
-
-   **Inhalt der Datei (passt auf deinen PHP‑FPM‑Sockel an!):**
-
-   ```nginx
-   server {
-     listen 80;
-     server_name _;
-     root /srv/nextcloud/app/nextcloud;
-     client_max_body_size 10G;  # große Uploads erlauben
-
-     index index.php index.html;
-
-     # verbotene Pfade
-     location = /robots.txt { allow all; log_not_found off; access_log off; }
-     location ~ ^/(?:\.|autotest|occ|issue|indie|db_|console) { deny all; }
-
-     # PHP an FPM weiterreichen
-     location ~ \.php(?:$|/) {
-       fastcgi_split_path_info ^(.+\.php)(/.+)$;
-       include fastcgi_params;
-       fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
-       fastcgi_param PATH_INFO $fastcgi_path_info;
-       fastcgi_pass unix:/run/php/php8.3-fpm.sock;  # <–– ggf. anpassen (siehe Schritt 1)
-       fastcgi_intercept_errors on;
-       fastcgi_request_buffering off;  # stabile Uploads
-     }
-   }
-   ```
-
-3. **Konfiguration aktivieren und prüfen**
-
-   ```bash
-   ln -s /etc/nginx/sites-available/nextcloud.conf /etc/nginx/sites-enabled/
-   nginx -t && systemctl reload nginx
-   ```
-
-   **Was passiert hier?**
-   `ln -s …` schaltet die Site scharf. `nginx -t` prüft auf Tippfehler. Wenn „syntax is ok“ erscheint, lädt `systemctl reload nginx` die neue Konfiguration.
-   **Fehlerbild:** Falls `nginx -t` rot meckert, öffne die Datei erneut mit `nano /etc/nginx/sites-available/nextcloud.conf` und korrigiere die genannte Zeile. Danach `nginx -t` wiederholen.
+```bash
+ln -s /etc/nginx/sites-available/nextcloud.conf /etc/nginx/sites-enabled/
+nginx -t && systemctl reload nginx
+```
 
 ---
 
-### Proxy-Host im NPM einrichten
+### NPM: Proxy Host einrichten
 
-Jetzt verbinden wir die öffentliche Domain mit deinem Container. Öffne die **Nginx Proxy Manager**‑Oberfläche und lege einen **Proxy Host** an:
+Im Nginx Proxy Manager:
 
-1. **Domain**: `cloud.deine-domain.tld`
-2. **Forward Hostname / IP**: die **IP deines Nextcloud‑LXC** (z. B. `10.0.0.42`)
-3. **Forward Port**: `80`
-4. **SSL**: „**Request a new SSL Certificate**“ aktivieren → E‑Mail eintragen → **Force SSL** und **HTTP/2** aktivieren (HSTS optional)
-5. **Advanced (optional, aber empfohlen bei großen Dateien)**:
+* **Domain**: `cloud.deine-domain.tld`
+* **IP**: LXC-Adresse (z. B. `10.0.0.42`)
+* **Port**: 80
+* **SSL aktivieren** (Let’s Encrypt)
+* **Force SSL** + **HTTP/2** aktivieren
+* **Advanced Tab** (optional, empfohlen):
 
-   ```
-   client_max_body_size 10G;
-   proxy_read_timeout 3600;
-   proxy_send_timeout 3600;
-   ```
-
-**Test:** Rufe `https://cloud.deine-domain.tld` im Browser auf. Du solltest jetzt den **Nextcloud‑Setup‑Assistenten** sehen. Wenn nicht: prüfe Domain, Proxy‑Host‑Einträge und ob Nginx im LXC läuft (`systemctl status nginx`).
+```
+client_max_body_size 10G;
+proxy_read_timeout 3600;
+proxy_send_timeout 3600;
+```
 
 ---
 
-In der Nginx Proxy Manager Oberfläche legst du nun einen Proxy Host an:
+### Browser-Setup
 
-* Domain: `cloud.deine-domain.tld`
-* Ziel: IP des Containers, Port 80
-* SSL: Let’s Encrypt aktivieren
-
-Ab jetzt ist deine Nextcloud über die Domain erreichbar.
-
-### Erstinstallation im Browser
-
-Beim ersten Aufruf erscheint der Nextcloud-Setup-Assistent. Dort legst du den Admin-Account an und gibst an:
+Im Browser: `https://cloud.deine-domain.tld`
 
+* Admin-Benutzer erstellen
 * Datenverzeichnis: `/mnt/hdd/nextcloud_data`
-* Datenbank: PostgreSQL → Host `127.0.0.1`, DB `nextcloud`, User `nextcloud`, Passwort aus dem Schritt oben
+* Datenbank: PostgreSQL → `127.0.0.1`, DB: `nextcloud`, User: `nextcloud`, Passwort: `DEIN_SICHERES_PASSWORT`
 
-### Redis konfigurieren
+---
 
-Damit Nextcloud Dateien effizient sperrt und cachen kann, ergänze in `config/config.php`:
+### config.php anpassen (Reverse Proxy + Redis)
+
+```bash
+nano /srv/nextcloud/app/nextcloud/config/config.php
+```
 
 ```php
+'trusted_domains'   => ['cloud.DEINE-DOMAIN.tld'],
+'overwrite.cli.url' => 'https://cloud.DEINE-DOMAIN.tld',
+'overwritehost'     => 'cloud.DEINE-DOMAIN.tld',
+'overwriteprotocol' => 'https',
+'trusted_proxies'   => ['IP.DEINES.NPM'],
+
 'filelocking.enabled' => true,
-'memcache.local' => '\\OC\\Memcache\\Redis',
-'memcache.locking' => '\\OC\\Memcache\\Redis',
+'memcache.local'      => '\\OC\\Memcache\\Redis',
+'memcache.locking'    => '\\OC\\Memcache\\Redis',
 'redis' => [
   'host' => '/var/run/redis/redis-server.sock',
   'port' => 0,
@@ -305,181 +209,59 @@ Damit Nextcloud Dateien effizient sperrt und cachen kann, ergänze in `config/co
 ],
 ```
 
-### Nextcloud `config.php` für den Reverse Proxy – Schritt für Schritt
-
-Sobald du den Setup‑Assistenten abgeschlossen hast, legt Nextcloud die Datei `config.php` an. Darin sagen wir Nextcloud, **unter welcher Domain** sie erreichbar ist, dass **TLS am Proxy** terminiert und dass **Redis** für Cache & File‑Locking genutzt wird.
-
-1. **Datei öffnen**
-
-   ```bash
-   nano /srv/nextcloud/app/nextcloud/config/config.php
-   ```
-
-   > **Nano‑Hinweis:** Speichern mit **STRG+O**, Enter. Beenden mit **STRG+X**.
-
-2. **Diese Einträge ergänzen bzw. anpassen** (Platzhalter ersetzen):
-
-   ```php
-   'trusted_domains'   => [ 'cloud.DEINE-DOMAIN.tld' ],
-   'overwrite.cli.url' => 'https://cloud.DEINE-DOMAIN.tld',
-   'overwritehost'     => 'cloud.DEINE-DOMAIN.tld',
-   'overwriteprotocol' => 'https',
-   'trusted_proxies'   => [ 'IP-ODER-SUBNETZ-DEINES-NPM' ],
-
-   'filelocking.enabled' => true,
-   'memcache.local'      => '\OC\Memcache\Redis',
-   'memcache.locking'    => '\OC\Memcache\Redis',
-   'redis' => [
-     'host'    => '/var/run/redis/redis-server.sock',
-     'port'    => 0,
-     'timeout' => 1.5,
-   ],
-   ```
-
-**Was bewirken diese Zeilen?**
-
-* **trusted\_domains**: Schutz vor Host‑Header‑Tricks – Nextcloud antwortet nur auf **deine** Domain.
-* **overwrite\***: Nextcloud erzeugt Links konsequent als **[https://cloud.DEINE-DOMAIN.tld](https://cloud.DEINE-DOMAIN.tld)** (wichtig hinter dem Proxy, sonst drohen Mixed‑Content/Weiterleitungsschleifen).
-* **trusted\_proxies**: Erlaubt, dass Nextcloud die `X-Forwarded-*`‑Header vom NPM vertraut (sonst zeigt Nextcloud falsche Client‑IPs/Warnungen).
-* **Redis‑Block**: Aktiviert Cache + File‑Locking über den lokalen Redis‑Socket – stabiler als APCu, besonders bei CLI‑Jobs.
-
-3. **Speichern und testen**
-
-   * In Nextcloud: **Einstellungen → Verwaltung → Übersicht**.
-   * **Erwartung:** Keine Warnungen zu Proxy/Trusted Domains/File‑Locking.
-   * Falls doch: Prüfe Schreibfehler in Domain/IP, leere Browser‑Cache und lade die Seite neu.
-
----
-
-### PHP konfigurieren (php.ini & PHP‑FPM‑Pool) – Schritt für Schritt
-
-Damit große Uploads und viele gleichzeitige Anfragen stabil funktionieren, passen wir PHP an.
-
-1. **php.ini (FPM) bearbeiten**
-
-   ```bash
-   nano /etc/php/*/fpm/php.ini
-   ```
-
-   **Wichtige Einstellungen** (suche die Zeilen und passe sie an):
-
-   ```ini
-   ; Zeitzone – wichtig für Logs/Jobs
-   date.timezone = Europe/Berlin
-
-   ; Uploads/Performance
-   upload_max_filesize = 10G
-   post_max_size = 10G
-   memory_limit = 1024M
-   max_execution_time = 3600
-   max_input_time = 3600
-   output_buffering = 0
-
-   ; OPcache – macht PHP spürbar schneller
-   opcache.enable=1
-   opcache.memory_consumption=128
-   opcache.interned_strings_buffer=16
-   opcache.max_accelerated_files=10000
-   opcache.save_comments=1
-   opcache.validate_timestamps=1
-   opcache.revalidate_freq=60
-   ```
-
-   **Speichern** (STRG+O, Enter) und **beenden** (STRG+X).
-
-2. **PHP‑FPM‑Pool tunen**
-
-   ```bash
-   nano /etc/php/*/fpm/pool.d/www.conf
-   ```
-
-   **Sinnvolle Startwerte** (für 4–8 GB RAM im LXC):
-
-   ```ini
-   pm = dynamic
-   pm.max_children = 12
-   pm.start_servers = 3
-   pm.min_spare_servers = 2
-   pm.max_spare_servers = 6
-   ```
-
-   > **Faustregel:** `pm.max_children` ≈ (RAM für PHP in MB / 80). Wenn es eng wird (502/504 Fehler), leicht erhöhen; bei RAM‑Druck reduzieren.
-
-3. **FPM neu laden**
-
-   ```bash
-   systemctl reload php*-fpm
-   ```
-
-4. **Schnelltest (temporär)**
-   Erzeuge kurz eine Info‑Seite, um zu prüfen, ob die Werte wirklich beim Webserver ankommen:
-
-   ```bash
-   echo "<?php phpinfo();" > /srv/nextcloud/app/nextcloud/info.php
-   ```
-
-   Rufe `https://cloud.DEINE-DOMAIN.tld/info.php` im Browser auf und kontrolliere:
-
-   * `Loaded Configuration File` → zeigt deine FPM‑`php.ini`
-   * Werte für `upload_max_filesize`, `post_max_size`, `memory_limit`, `date.timezone`
-
-   **Wichtig:** Danach die Datei **wieder löschen** (Sicherheits‑Hygiene):
-
-   ```bash
-   rm /srv/nextcloud/app/nextcloud/info.php
-   ```
-
----
-
-In der Datei `/etc/php/*/fpm/php.ini` setzt du:
+Tipp: `www-data` sollte zur Gruppe `redis` gehören, sonst funktioniert File Locking nicht:
 
+```bash
+usermod -aG redis www-data
 ```
+
+---
+
+### PHP anpassen (für große Uploads & Performance)
+
+```bash
+nano /etc/php/*/fpm/php.ini
+```
+
+```ini
 upload_max_filesize = 10G
 post_max_size = 10G
 memory_limit = 1024M
+max_execution_time = 3600
+output_buffering = 0
+date.timezone = Europe/Berlin
 ```
 
-Danach PHP-FPM neu laden:
-
 ```bash
 systemctl reload php*-fpm
 ```
 
-### Cronjobs aktivieren
+---
 
-Damit Hintergrundaufgaben laufen, tragen wir einen Cronjob für den Webserver-User ein:
+### Cronjob aktivieren (Nextcloud Hintergrundjobs)
 
 ```bash
 crontab -u www-data -e
 ```
 
-Dort hinzufügen:
-
-```
+```cron
 */5 * * * * php -f /srv/nextcloud/app/nextcloud/cron.php
 ```
 
-Jetzt führt Nextcloud alle 5 Minuten Hintergrundjobs aus.
-
 ---
 
 ## Ergebnis
 
-* Nextcloud läuft stabil im LXC und ist über HTTPS erreichbar.
-* Die Benutzerdaten liegen getrennt auf der zweiten Festplatte unter `/mnt/hdd/nextcloud_data`.
-* PostgreSQL + Redis sorgen für Performance.
-* Große Uploads sind möglich, Cronjobs laufen automatisch.
-
-### Häufige Fehlerbilder & schnelle Fixes
-
-* **Endlosschleife oder Mixed Content** → `overwritehost`/`overwriteprotocol` prüfen, NPM zeigt wirklich auf Port 80.
-* **Proxy-Header-Warnung in Nextcloud** → `trusted_proxies` enthält nicht die NPM-IP.
-* **Uploads > 1 GB brechen ab** → PHP-Limits und `client_max_body_size` in NPM ergänzen.
-* **File-Locking-Warnung** → prüfen, ob `www-data` in der Gruppe `redis` ist.
+* Nextcloud läuft im LXC, erreichbar via HTTPS
+* PostgreSQL-DB ist passwortgesichert & erreichbar
+* Daten liegen getrennt unter `/mnt/hdd/nextcloud_data`
+* Redis aktiv → keine File-Locking-Warnung
+* PHP tuned → große Uploads problemlos
+* Hintergrundjobs laufen automatisch
 
 ---
 
 ## Nächste Schritte
 
-* Vorheriges Kapitel: **Vaultwarden (Kapitel 6)**
-* Nächstes Kapitel: **Affine (Kapitel 8)**
+* Vorheriges Kapitel: Vaultwarden
+* Weiter geht’s mit: Affine