Thomas/Homelab--Bratonein-Kontrollzentrum--Tutorial

Files

Thomas Dannenberg 768d25c91f Kapitel 7/Tutorial.md aktualisiert

2025-09-04 06:59:47 +00:00

15 KiB

Raw Blame History

🛠️ 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.

Beim Anlegen des Containers kann unter dem Punkt Disks direkt eine zweite Festplatte hinzugefügt werden:

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

Nach dem Start verbindest du dich per SSH:

ssh root@<IP-des-Containers>

Im Container prüfen:

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:

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

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.

PostgreSQL-Version prüfen

ls /etc/postgresql/

Du bekommst z. B. 15 zurück. Diese Zahl brauchst du für den Pfad zur Konfigurationsdatei.

Konfiguration anpassen

nano /etc/postgresql/15/main/pg_hba.conf

Ersetze 15 ggf. durch deine Version.

Folgende Zeile:

local   all             postgres                                peer

ändern in:

local   all             postgres                                md5

Zusätzlich am Ende ergänzen:

host    all             all             127.0.0.1/32            md5

Speichern (STRG+O, Enter), schließen (STRG+X)

PostgreSQL neu starten

systemctl restart postgresql

Passwort für postgres-Benutzer setzen

Du brauchst jetzt ein Passwort, sonst kannst du dich nicht einloggen.

su - postgres

Dann:

psql -c "ALTER USER postgres WITH PASSWORD '149774Thomas!!';"

Anschließend:

exit

Benutzer und Datenbank für Nextcloud anlegen

psql -U postgres -h 127.0.0.1

In der psql-Konsole:

CREATE DATABASE nextcloud;
CREATE USER nextcloud WITH ENCRYPTED PASSWORD '149774Thomas!!';
GRANT ALL PRIVILEGES ON DATABASE nextcloud TO nextcloud;
\q

Verbindung testen

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:

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:

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:

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:

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.

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).
```
ls /run/php/
```
Erwartung: Du siehst eine Datei wie php8.3-fpm.sock. Merke dir den exakten Namen.

vHost-Datei mit Nano anlegen/öffnen

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!):

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
  }
}

Konfiguration aktivieren und prüfen
```
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:

Domain: cloud.deine-domain.tld
Forward Hostname / IP: die IP deines Nextcloud‑LXC (z. B. 10.0.0.42)
Forward Port: 80
SSL: „Request a new SSL Certificate“ aktivieren → E‑Mail eintragen → Force SSL und HTTP/2 aktivieren (HSTS optional)

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:

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

Datei öffnen
```
nano /srv/nextcloud/app/nextcloud/config/config.php
```
Nano‑Hinweis: Speichern mit STRG+O, Enter. Beenden mit STRG+X.

Diese Einträge ergänzen bzw. anpassen (Platzhalter ersetzen):

'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 (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.

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.

php.ini (FPM) bearbeiten

nano /etc/php/*/fpm/php.ini

Wichtige Einstellungen (suche die Zeilen und passe sie an):

; 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).

PHP‑FPM‑Pool tunen
```
nano /etc/php/*/fpm/pool.d/www.conf
```
Sinnvolle Startwerte (für 4–8 GB RAM im LXC):
```
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.
FPM neu laden
```
systemctl reload php*-fpm
```
Schnelltest (temporär) Erzeuge kurz eine Info‑Seite, um zu prüfen, ob die Werte wirklich beim Webserver ankommen:
```
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):
```
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:

systemctl reload php*-fpm

Cronjobs aktivieren

Damit Hintergrundaufgaben laufen, tragen wir einen Cronjob für den Webserver-User ein:

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)

15 KiB Raw Blame History Unescape Escape

🛠️ Kapitel 7 – Nextcloud (Tutorial, Nginx)

Einleitung

Voraussetzungen

Vorbereitung

Container anlegen

Umsetzung

System vorbereiten

PostgreSQL einrichten

System vorbereiten

Verzeichnisse anlegen

Nextcloud herunterladen

Datenbank einrichten

Nginx konfigurieren

Proxy-Host im NPM einrichten

Erstinstallation im Browser

Redis konfigurieren

Nextcloud config.php für den Reverse Proxy – Schritt für Schritt

PHP konfigurieren (php.ini & PHP‑FPM‑Pool) – Schritt für Schritt

Cronjobs aktivieren

Ergebnis

Häufige Fehlerbilder & schnelle Fixes

Nächste Schritte

15 KiB

Raw Blame History

Nextcloud `config.php` für den Reverse Proxy – Schritt für Schritt