Thomas/Homelab--Bratonein-Kontrollzentrum--Tutorial
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Kapitel 7/Tutorial.md aktualisiert

Browse Source
This commit is contained in:
Thomas committed 2025-09-04 07:12:09 +00:00
1 parent a7255671f4
commit 4aa0243c86
1 file changed
+99 -317
Download Patch File Download Diff File Expand all files Collapse all files
Kapitel 7/Tutorial.md
+99 -317
View File
@@ -4,161 +4,65 @@
## Einleitung ## 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 ## Voraussetzungen
* **Proxmox Host** mit zwei Platten (System + Datenplatte) * **Proxmox Host** mit 2 Platten (System + Datenplatte)
* **LXC (Ubuntu 24.04 LTS)** mit aktivem Nesting * **LXC mit Ubuntu 24.04**, Nesting aktiviert
* **Nginx Proxy Manager** für HTTPS * **Nginx Proxy Manager** für HTTPS-Zugriff
* Eine **Domain**, die auf deinen Proxy zeigt * Eine **Domain**, die auf deinen Proxy zeigt
* Offene Ports **80/443** auf NPM * Container-Ressourcen: mind. 2 vCPU, 4 GB RAM
* 2 vCPU, 4–8 GB RAM für den Container * Grundwissen: Proxmox-GUI, SSH, Terminal
* Grundwissen: SSH, Proxmox-GUI, Nano-Editor
--- ---
## Vorbereitung ## 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 #### Zweite Festplatte direkt einhängen
* 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
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 ```bash
ssh root@<IP-des-Containers> ssh root@<IP-des-Containers>
```
Im Container prüfen:
```bash
ls -ld /mnt/hdd 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 ## Umsetzung
### System vorbereiten ### System aktualisieren & Pakete installieren
Zuerst bringen wir das System auf den aktuellen Stand und installieren alle benötigten Pakete:
```bash ```bash
apt update && apt upgrade -y 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` ### Projektstruktur anlegen
* 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:
```bash ```bash
mkdir -p /srv/nextcloud/app mkdir -p /srv/nextcloud/app
@@ -166,104 +70,103 @@ mkdir -p /mnt/hdd/nextcloud_data
chown -R www-data:www-data /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 ### Nextcloud herunterladen
Jetzt laden wir die aktuelle Version von Nextcloud:
```bash ```bash
cd /srv/nextcloud/app cd /srv/nextcloud/app
curl -LO https://download.nextcloud.com/server/releases/latest.zip curl -LO https://download.nextcloud.com/server/releases/latest.zip
unzip latest.zip && rm 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 ```bash
sudo -u postgres psql -c "CREATE DATABASE nextcloud;" su - postgres
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;"
``` ```
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
```
### Nginx konfigurieren Test (optional):
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
psql -U nextcloud -h 127.0.0.1 -d nextcloud -W
```
1. **Prüfe zuerst, wie dein PHP‑FPM‑Socket heißt** Wenn du Zugriff bekommst → alles korrekt.
Das ist wichtig, weil die Datei je nach PHP‑Version leicht anders heißt (z. B. `php8.3-fpm.sock`).
---
### PHP-FPM: Version prüfen
```bash ```bash
ls /run/php/ ls /run/php/
``` ```
**Erwartung:** Du siehst eine Datei wie `php8.3-fpm.sock`. Merke dir den **exakten Namen**. → z. B. `php8.3-fpm.sock` → merken
2. **vHost-Datei mit Nano anlegen/öffnen** ---
### Nginx konfigurieren
```bash ```bash
nano /etc/nginx/sites-available/nextcloud.conf nano /etc/nginx/sites-available/nextcloud.conf
``` ```
> **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 ```nginx
server { server {
listen 80; listen 80;
server_name _; server_name _;
root /srv/nextcloud/app/nextcloud;
client_max_body_size 10G; # große Uploads erlauben
root /srv/nextcloud/app/nextcloud;
index index.php index.html; index index.php index.html;
# verbotene Pfade client_max_body_size 10G;
location = /robots.txt { allow all; log_not_found off; access_log off; } location = /robots.txt { allow all; log_not_found off; access_log off; }
location ~ ^/(?:\.|autotest|occ|issue|indie|db_|console) { deny all; } location ~ ^/(?:\.|autotest|occ|issue|indie|db_|console) { deny all; }
# PHP an FPM weiterreichen
location ~ \.php(?:$|/) { location ~ \.php(?:$|/) {
fastcgi_split_path_info ^(.+\.php)(/.+)$; fastcgi_split_path_info ^(.+\.php)(/.+)$;
include fastcgi_params; include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name; fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param PATH_INFO $fastcgi_path_info; fastcgi_param PATH_INFO $fastcgi_path_info;
fastcgi_pass unix:/run/php/php8.3-fpm.sock; # <–– ggf. anpassen (siehe Schritt 1) fastcgi_pass unix:/run/php/php8.3-fpm.sock; # ggf. anpassen
fastcgi_intercept_errors on; fastcgi_intercept_errors on;
fastcgi_request_buffering off; # stabile Uploads fastcgi_request_buffering off;
} }
} }
``` ```
3. **Konfiguration aktivieren und prüfen**
```bash ```bash
ln -s /etc/nginx/sites-available/nextcloud.conf /etc/nginx/sites-enabled/ ln -s /etc/nginx/sites-available/nextcloud.conf /etc/nginx/sites-enabled/
nginx -t && systemctl reload nginx 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.
--- ---
### 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` * **Domain**: `cloud.deine-domain.tld`
2. **Forward Hostname / IP**: die **IP deines Nextcloud‑LXC** (z. B. `10.0.0.42`) * **IP**: LXC-Adresse (z. B. `10.0.0.42`)
3. **Forward Port**: `80` * **Port**: 80
4. **SSL**: „**Request a new SSL Certificate**“ aktivieren → E‑Mail eintragen → **Force SSL** und **HTTP/2** aktivieren (HSTS optional) * **SSL aktivieren** (Let’s Encrypt)
5. **Advanced (optional, aber empfohlen bei großen Dateien)**: * **Force SSL** + **HTTP/2** aktivieren
* **Advanced Tab** (optional, empfohlen):
``` ```
client_max_body_size 10G; client_max_body_size 10G;
@@ -271,30 +174,31 @@ Jetzt verbinden wir die öffentliche Domain mit deinem Container. Öffne die **N
proxy_send_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`). ---
### Browser-Setup
Im Browser: `https://cloud.deine-domain.tld`
* Admin-Benutzer erstellen
* Datenverzeichnis: `/mnt/hdd/nextcloud_data`
* Datenbank: PostgreSQL → `127.0.0.1`, DB: `nextcloud`, User: `nextcloud`, Passwort: `DEIN_SICHERES_PASSWORT`
--- ---
In der Nginx Proxy Manager Oberfläche legst du nun einen Proxy Host an: ### config.php anpassen (Reverse Proxy + Redis)
* Domain: `cloud.deine-domain.tld` ```bash
* Ziel: IP des Containers, Port 80 nano /srv/nextcloud/app/nextcloud/config/config.php
* 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:
* Datenverzeichnis: `/mnt/hdd/nextcloud_data`
* Datenbank: PostgreSQL → Host `127.0.0.1`, DB `nextcloud`, User `nextcloud`, Passwort aus dem Schritt oben
### Redis konfigurieren
Damit Nextcloud Dateien effizient sperrt und cachen kann, ergänze in `config/config.php`:
```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, 'filelocking.enabled' => true,
'memcache.local' => '\\OC\\Memcache\\Redis', 'memcache.local' => '\\OC\\Memcache\\Redis',
'memcache.locking' => '\\OC\\Memcache\\Redis', 'memcache.locking' => '\\OC\\Memcache\\Redis',
@@ -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 Tipp: `www-data` sollte zur Gruppe `redis` gehören, sonst funktioniert File Locking nicht:
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 ```bash
nano /srv/nextcloud/app/nextcloud/config/config.php usermod -aG redis www-data
``` ```
> **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 ### PHP anpassen (für große Uploads & Performance)
Damit große Uploads und viele gleichzeitige Anfragen stabil funktionieren, passen wir PHP an.
1. **php.ini (FPM) bearbeiten**
```bash ```bash
nano /etc/php/*/fpm/php.ini nano /etc/php/*/fpm/php.ini
``` ```
**Wichtige Einstellungen** (suche die Zeilen und passe sie an):
```ini ```ini
; Zeitzone – wichtig für Logs/Jobs
date.timezone = Europe/Berlin
; Uploads/Performance
upload_max_filesize = 10G upload_max_filesize = 10G
post_max_size = 10G post_max_size = 10G
memory_limit = 1024M memory_limit = 1024M
max_execution_time = 3600 max_execution_time = 3600
max_input_time = 3600
output_buffering = 0 output_buffering = 0
date.timezone = Europe/Berlin
; 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 ```bash
systemctl reload php*-fpm 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: ### Cronjob aktivieren (Nextcloud Hintergrundjobs)
```
upload_max_filesize = 10G
post_max_size = 10G
memory_limit = 1024M
```
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:
```bash ```bash
crontab -u www-data -e crontab -u www-data -e
``` ```
Dort hinzufügen: ```cron
```
*/5 * * * * php -f /srv/nextcloud/app/nextcloud/cron.php */5 * * * * php -f /srv/nextcloud/app/nextcloud/cron.php
``` ```
Jetzt führt Nextcloud alle 5 Minuten Hintergrundjobs aus.
--- ---
## Ergebnis ## Ergebnis
* Nextcloud läuft stabil im LXC und ist über HTTPS erreichbar. * Nextcloud läuft im LXC, erreichbar via HTTPS
* Die Benutzerdaten liegen getrennt auf der zweiten Festplatte unter `/mnt/hdd/nextcloud_data`. * PostgreSQL-DB ist passwortgesichert & erreichbar
* PostgreSQL + Redis sorgen für Performance. * Daten liegen getrennt unter `/mnt/hdd/nextcloud_data`
* Große Uploads sind möglich, Cronjobs laufen automatisch. * Redis aktiv → keine File-Locking-Warnung
* PHP tuned → große Uploads problemlos
### Häufige Fehlerbilder & schnelle Fixes * Hintergrundjobs laufen automatisch
* **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.
--- ---
## Nächste Schritte ## Nächste Schritte
* Vorheriges Kapitel: **Vaultwarden (Kapitel 6)** * Vorheriges Kapitel: Vaultwarden
* Nächstes Kapitel: **Affine (Kapitel 8)** * Weiter geht’s mit: Affine