396 lines
13 KiB
Markdown
396 lines
13 KiB
Markdown
# 🛠️ Kapitel 7 – Nextcloud (Tutorial, Nginx)
|
||
|
||
---
|
||
|
||
## 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.
|
||
|
||
---
|
||
|
||
## Voraussetzungen
|
||
|
||
* **Proxmox Host** mit zwei Platten (System + Datenplatte)
|
||
* **LXC (Ubuntu 24.04 LTS)** mit aktivem Nesting
|
||
* **Nginx Proxy Manager** für HTTPS
|
||
* 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
|
||
|
||
---
|
||
|
||
## Vorbereitung
|
||
|
||
### Container anlegen
|
||
|
||
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.
|
||
|
||
Nach dem Start verbindest du dich per SSH:
|
||
|
||
```bash
|
||
ssh root@<IP-des-Containers>
|
||
```
|
||
|
||
### Zweite Platte einbinden
|
||
|
||
Damit große Dateien die Systemdisk nicht belasten, legen wir die Daten auf eine eigene Festplatte.
|
||
Beim anlegen des Containers kann unter dem Punkt Disks eine zweite Festplatte hinzugefügt werden.
|
||
Hierzu einfach das "+" unten links im Fenster anklicken. Das sich öffenende Menü ist nahezu selbsterklärend.
|
||
- Mount Point ID: wird automatisch gesetzt und kann so bleiben
|
||
- Storage: wähle hier ie Festplatte aus die du möchtest.
|
||
- Disk Größe: Wähe hier die Speichergröße aus, die du bereitstellen willst (z.B. 500)
|
||
- Pfad: dies ist der Pfad über den auf die Festplatte zugegriffen wird. In unserem Tutorial `/mnt/hdd`
|
||
- Backup: nimm hier den Haken raus wenn die Daten auf der Festplatte nicht in einem Backup erscheinen sollen. In unserem Fall kannst du das machen, da wir später eine andere Backuproutine implementieren werden.
|
||
|
||
Im Container prüfen:
|
||
|
||
```bash
|
||
ls -ld /mnt/hdd
|
||
```
|
||
|
||
Wenn du hier ein Verzeichnis siehst, ist die Platte korrekt eingebunden.
|
||
|
||
---
|
||
|
||
## Umsetzung
|
||
|
||
### 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
|
||
mkdir -p /srv/nextcloud/app
|
||
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
|
||
```
|
||
|
||
Nach diesem Schritt findest du die entpackte Anwendung im Verzeichnis `nextcloud`.
|
||
|
||
### Datenbank einrichten
|
||
|
||
Für die Datenbank verwenden wir PostgreSQL. Wir legen eine neue Datenbank und einen Benutzer an:
|
||
|
||
```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;"
|
||
```
|
||
|
||
Damit ist eine leere Datenbank mit passenden Rechten vorbereitet.
|
||
|
||
### 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.
|
||
|
||
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`).
|
||
|
||
```bash
|
||
ls /run/php/
|
||
```
|
||
|
||
**Erwartung:** Du siehst eine Datei wie `php8.3-fpm.sock`. Merke dir den **exakten Namen**.
|
||
|
||
2. **vHost-Datei mit Nano anlegen/öffnen**
|
||
|
||
```bash
|
||
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
|
||
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.
|
||
|
||
---
|
||
|
||
### Proxy-Host im NPM einrichten
|
||
|
||
Jetzt verbinden wir die öffentliche Domain mit deinem Container. Öffne die **Nginx Proxy Manager**‑Oberfläche und lege einen **Proxy Host** an:
|
||
|
||
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)**:
|
||
|
||
```
|
||
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`).
|
||
|
||
---
|
||
|
||
In der Nginx Proxy Manager Oberfläche legst du nun einen Proxy Host an:
|
||
|
||
* 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:
|
||
|
||
* 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
|
||
'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,
|
||
],
|
||
```
|
||
|
||
### 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:
|
||
|
||
```
|
||
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
|
||
crontab -u www-data -e
|
||
```
|
||
|
||
Dort hinzufügen:
|
||
|
||
```
|
||
*/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.
|
||
|
||
---
|
||
|
||
## Nächste Schritte
|
||
|
||
* Vorheriges Kapitel: **Vaultwarden (Kapitel 6)**
|
||
* Nächstes Kapitel: **Affine (Kapitel 8)**
|