Thomas/Homelab--Bratonein-Kontrollzentrum--Tutorial
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9ca377e5df393a05d71eb600e4c9dcee5fc8ee30
Homelab--Bratonein-Kontroll…/Kapitel 7/Tutorial.md

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

Nach dem Start verbindest du dich per SSH:

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:

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

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

    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

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

  3. 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:

  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:

'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

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

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

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

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

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

  3. FPM neu laden

    systemctl reload php*-fpm

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