diff --git a/Kapitel 6/Free Rohtext.md b/Kapitel 6/Free Rohtext.md new file mode 100644 index 0000000..311b6b6 --- /dev/null +++ b/Kapitel 6/Free Rohtext.md @@ -0,0 +1,934 @@ +# Kapitel 6 – Nextcloud (Nginx + PostgreSQL + Redis, NPM-Setup) + +Nextcloud ist eine vollständig selbst gehostete Cloud-Lösung – eine private Alternative zu Diensten wie Google Drive, Dropbox oder OneDrive. +Sie läuft auf deinem eigenen UCC-Server und speichert alle Dateien, Fotos und Dokumente ausschließlich unter deiner Kontrolle. + +Für Content Creator, Streamer und kleine Teams ist Nextcloud ideal: +Du kannst Dateien austauschen, gemeinsam an Projekten arbeiten, große Videodateien bereitstellen und automatische Backups deiner Aufnahmen ablegen – alles ohne externe Anbieter. + +> [!TIP] +> Nextcloud kann viel mehr als nur Dateien speichern. +> Über integrierte Apps kannst du Kalender, Kontakte, Aufgabenlisten oder Notizen synchronisieren – und alles läuft zentral auf deinem eigenen Server. + +### Ziel dieses Kapitels + +Wir installieren Nextcloud in einem eigenen **Ubuntu 24.04 LXC-Container** und kombinieren drei wichtige Komponenten: + +- **Nginx** als interner Webserver +- **PostgreSQL** als leistungsstarke Datenbank +- **Redis** für schnellen Cache und Datei-Sperrverwaltung + +Anschließend binden wir die Instanz über den **Nginx Proxy Manager (NPM)** sicher an deine Domain an und richten automatische Cron-Jobs für Hintergrundprozesse ein. +So entsteht eine vollwertige, stabile Cloud-Plattform, die auf jedem Gerät erreichbar ist – verschlüsselt und unter deiner Kontrolle. + +> [!NOTE] +> Wir bauen hier direkt auf den Grundlagen aus den vorherigen Kapiteln auf. +> Du brauchst also keine neuen Tools, nur denselben Proxmox-Host, den du bereits nutzt. + +👉 *Screenshot geeignet: Nextcloud-Dashboard als Beispiel mit Datei-Upload, Kalender und Notizen.* + +## Voraussetzungen & Ressourcen + +Nextcloud ist eine umfangreiche Cloud-Lösung, die mehr Ressourcen benötigt als kleinere Dienste wie Pi-hole oder Vaultwarden. +Damit alle Funktionen – Dateiablage, Freigaben, Kalender und Medienvorschauen – zuverlässig arbeiten, sollte der Container sorgfältig vorbereitet werden. + +### Anforderungen an den Container + +- **Betriebssystem:** Ubuntu 24.04 LTS + Ubuntu ist stabil, aktuell und wird von Nextcloud offiziell empfohlen. +- **CPU:** 2 Kerne +- **RAM:** 4 GB +- **Speicherplatz:** 32 GB für das System +- **Zweite Festplatte:** 500 GB für Benutzerdaten +- **Netzwerk:** Statische IPv4-Adresse per DHCP-Reservierung (z. B. `192.168.1.60`) + +> [!TIP] +> Weise die IP-Adresse im Router per **DHCP-Reservierung** zu. +> So bleibt sie dauerhaft gleich und verursacht keine Konflikte mit automatisch vergebenen Adressen. + +> [!NOTE] +> Da dieser LXC ein paar Besonderheiten erfordert, findest du im weiteren Verlauf noch einmal die detaillierte Installation für diesen Container. +> Der Abschnitt erklärt Schritt für Schritt, wie du ihn richtig anlegst und konfigurierst. + +👉 *Screenshot geeignet: Proxmox-Maske „Neuen LXC erstellen“ mit aktivierter Option „Nesting“.* + +### Voraussetzungen im UCC + +Nextcloud wird später über den bereits eingerichteten **Nginx Proxy Manager (NPM)** erreichbar gemacht. +Dieser übernimmt die SSL-Verschlüsselung und die Verbindung zwischen Internet und deiner Cloud. +Für dieses Kapitel genügt es, wenn der Proxy bereits läuft und deine Domain erreichbar ist. + +> [!NOTE] +> Die konkrete Einrichtung des Proxy Hosts erfolgt im Hauptteil des Tutorials, +> sobald der Container fertig installiert und Nextcloud erreichbar ist. + +👉 *Screenshot geeignet: UCC-Strukturübersicht mit NPM-Container und geplantem Nextcloud-LXC.* + +### Speicherstruktur im UCC + +Nextcloud trennt die Anwendung strikt von den Benutzerdaten. +Dadurch bleiben alle Dateien erhalten, selbst wenn die Anwendung neu installiert oder aktualisiert wird. + +- **Anwendungsdaten:** `/srv/nextcloud/app` +- **Benutzerdaten:** `/mnt/hdd/nextcloud_data` + +> [!TIP] +> Sichere regelmäßig den Ordner `/mnt/hdd/nextcloud_data`. +> Er enthält sämtliche hochgeladenen Dateien, Fotos und Dokumente. + +👉 *Screenshot geeignet: Datei-Explorer mit Struktur /srv/nextcloud/app und /mnt/hdd/nextcloud_data.* + +### Dienste im Überblick + +Im Container installieren wir drei zentrale Dienste: + +1. **Nginx** – Webserver für PHP-Anfragen +2. **PostgreSQL** – Datenbank für Benutzer und Freigaben +3. **Redis** – Cache und Datei-Sperrverwaltung (File Locking) + +Diese Kombination bildet die stabile Grundlage für eine performante und sichere Nextcloud-Instanz. + +> [!NOTE] +> Redis ersetzt die ältere PHP-Cache-Methode APCu und verhindert typische Fehlermeldungen wie „File is locked“. + +👉 *Screenshot geeignet: Übersichtsgrafik mit Verbindung Nginx ↔ PHP ↔ Redis + PostgreSQL.* + +--- + +## Schritt für Schritt + +Bevor wir mit der eigentlichen Installation beginnen, aktualisieren wir das System und installieren einige Basis-Werkzeuge. +Diese Programme stellen sicher, dass spätere Installationen und Paketquellen reibungslos funktionieren. + +## LXC-Container anlegen (Sonderkonfiguration) + +Nextcloud benötigt im Vergleich zu den vorherigen Containern ein paar zusätzliche Einstellungen. +Diese sorgen dafür, dass Redis, PostgreSQL und PHP-FPM korrekt funktionieren und der Container Zugriff auf die zweite Festplatte erhält. + +### Container erstellen + +1. Melde dich an der **Proxmox-Weboberfläche** an. +2. Klicke oben rechts auf **Erstellen → LXC-Container**. +3. In der Maske **Allgemein**: + - Hostname: `nextcloud` + - Kennwort: ein sicheres Administrator-Passwort + - Template: `Ubuntu 24.04 LTS` +4. In der Maske **Ressourcen**: + - CPU-Kerne: `2` + - Arbeitsspeicher: `4096 MB` + - Swap: `512 MB` +5. In der Maske **Festplatten**: + - Erste Platte (System): `32 GB` + - Zweite Platte (Daten): **Mount Point = `/mnt/hdd`**, Größe z. B. `500 GB` + - Backup: deaktivieren +6. In der Maske **Netzwerk**: + - IPv4-Adresse: statisch, z. B. `192.168.1.60/24` + - Gateway: IP-Adresse deines Routers, z. B. `192.168.1.1` +7. Klicke auf **Erstellen**, um den Container zu erzeugen. + +👉 *Screenshot geeignet: Proxmox-Dialog „Neuen LXC erstellen“ mit aktivierter Option „Nesting“ und Mount-Point /mnt/hdd.* + +### Erweiterte Optionen aktivieren + +Nach dem Erstellen öffne den Container in der Proxmox-Oberfläche: + +1. Wechsle in den Reiter **Optionen**. +2. Wähle den Eintrag **Features** aus. +3. Klicke auf **Bearbeiten** und aktiviere folgende Punkte: + - ✅ **Nesting** + - ✅ **Keyctl** + +> [!NOTE] +> Diese Optionen sind notwendig, damit PHP, Redis und Docker-ähnliche Prozesse im Container laufen können. +> Ohne „Nesting“ kann PHP-FPM keine Sockets erstellen, und ohne „Keyctl“ funktioniert die Authentifizierung einiger Bibliotheken nicht. + +👉 *Screenshot geeignet: Proxmox-Optionen-Dialog mit aktivierten Features „Nesting“ und „Keyctl“.* + +### Container starten und Verbindung testen + +Starte den Container über **Start → Konsole** oder mit Rechtsklick → **Start**. +Wenn der Status grün angezeigt wird, öffne die Konsole und überprüfe, ob die zweite Festplatte eingebunden ist: + +```bash +ls -ld /mnt/hdd +``` + +Wenn das Ergebnis in etwa so aussieht: + +``` +drwxr-xr-x 2 root root 4096 ... +``` + +ist der Mount erfolgreich. + +> [!TIP] +> Sollte das Verzeichnis nicht existieren, öffne im Container den Pfad `/mnt/` +> und überprüfe, ob der Mount Point richtig eingetragen wurde. +> Du kannst ihn in Proxmox im Reiter **Ressourcen** nachträglich bearbeiten. + +👉 *Screenshot geeignet: Proxmox-Konsole mit Ausgabe des Befehls `ls -ld /mnt/hdd`.* + +### Verbindung zum Container herstellen + +Öffne ein Terminal oder – unter Windows – das Programm **PuTTY**. +Verbinde dich mit der IP-Adresse deines Nextcloud-Containers: + +```bash +ssh root@192.168.1.60 +``` + +> [!NOTE] +> Falls in deinem Container der direkte Root-Login deaktiviert ist, melde dich mit einem normalen Benutzer an, +> zum Beispiel: +> ```bash +> ssh benutzername@192.168.1.60 +> ``` +> und wechsle danach per: +> ```bash +> sudo -i +> ``` +> in die Root-Umgebung. + +Wenn die Anmeldung erfolgreich war, sollte die Eingabeaufforderung des Containers erscheinen, +entweder `root@nextcloud:~#` oder – falls du als Benutzer eingeloggt bist – `$`. + +👉 *Screenshot geeignet: geöffnete SSH-Sitzung mit sichtbarem Prompt.* + +### System aktualisieren + +Aktualisiere die vorhandenen Pakete und lade aktuelle Sicherheitsupdates: + +```bash +apt update && apt upgrade -y +``` + +> [!NOTE] +> Dieser Schritt kann einige Minuten dauern. +> Führe ihn immer aus, bevor du neue Software installierst – so vermeidest du Versionskonflikte. + +### Basis-Tools installieren + +Einige Programme werden für Paketverwaltung, Zertifikate und Entpacken von Archiven benötigt. +Sie werden mit einem einzigen Befehl installiert: + +```bash +apt install -y curl gnupg2 ca-certificates lsb-release apt-transport-https software-properties-common unzip nano sudo +``` + +> [!TIP] +> Diese Werkzeuge brauchst du später auch für Nginx, PHP und Redis. +> Wenn du sie jetzt installierst, sparst du dir Nacharbeiten bei fehlenden Abhängigkeiten. + +👉 *Screenshot geeignet: Terminal mit erfolgreicher Paketinstallation.* + +### Dienste installieren + +Nextcloud besteht aus mehreren Diensten, die gemeinsam arbeiten. +Damit alle Komponenten optimal zusammenspielen, installieren wir sie jetzt in der richtigen Reihenfolge: +**Nginx** als Webserver, **Redis** für Caching und Datei-Sperren sowie **PostgreSQL** als Datenbank. + +### Paketquellen aktualisieren + +Zuerst stellen wir sicher, dass alle benötigten Paketquellen eingebunden sind. +Ubuntu 24.04 bringt viele Pakete bereits mit, doch einige PHP-Module werden über ein zusätzliches Repository bereitgestellt. + +```bash +add-apt-repository ppa:ondrej/php -y +apt update +``` + +> [!NOTE] +> Dieses Repository stammt von Ondřej Surý, einem der offiziellen PHP-Maintainer. +> Es wird weltweit in professionellen Serverumgebungen genutzt, um aktuelle PHP-Versionen und Sicherheitsupdates zu erhalten. + +👉 *Screenshot geeignet: Terminal mit erfolgreicher Einbindung des PHP-Repository.* + +### Webserver, Datenbank und Cache installieren + +Installiere nun alle notwendigen Pakete in einem Schritt: + +```bash +apt install -y nginx redis-server postgresql php8.3-fpm php8.3-pgsql php8.3-cli php8.3-common php8.3-gd php8.3-mbstring php8.3-xml php8.3-zip php8.3-curl php8.3-bz2 php8.3-intl php8.3-gmp php8.3-imagick php8.3-redis +``` + +Dieser Befehl richtet die komplette Laufzeitumgebung ein – von Webserver bis zu den PHP-Erweiterungen. + +> [!TIP] +> Durch die Installation von Redis und PostgreSQL in einem gemeinsamen Schritt sparst du Zeit und stellst sicher, dass alle Abhängigkeiten korrekt aufgelöst werden. + +👉 *Screenshot geeignet: Terminal mit erfolgreicher Installation der Dienste.* + +### Dienste aktivieren und starten + +Nach der Installation müssen alle Dienste aktiviert und gestartet werden, damit sie automatisch mit dem System hochfahren. + +```bash +systemctl enable --now nginx +systemctl enable --now php8.3-fpm +systemctl enable --now redis-server +systemctl enable --now postgresql +``` + +> [!NOTE] +> Wenn kein Fehler erscheint, laufen alle vier Dienste korrekt. +> Mit `systemctl status ` kannst du jederzeit prüfen, ob sie aktiv sind. + +👉 *Screenshot geeignet: Ausgabe von `systemctl status nginx` mit dem Status „active (running)“.* + +### Verzeichnisse anlegen + +Nextcloud trennt streng zwischen Programmdateien und Benutzerdaten. +Das sorgt für mehr Sicherheit und einfachere Backups, da die eigentlichen Dateien getrennt vom System liegen. + +Erstelle zuerst die notwendigen Verzeichnisse und setze die richtigen Berechtigungen: + +```bash +mkdir -p /srv/nextcloud/app +mkdir -p /mnt/hdd/nextcloud_data +chown -R www-data:www-data /mnt/hdd/nextcloud_data +chmod 750 /mnt/hdd/nextcloud_data +``` + +> [!NOTE] +> Das Verzeichnis `/srv/nextcloud/app` enthält später die Anwendung selbst, +> während `/mnt/hdd/nextcloud_data` alle hochgeladenen Dateien, Fotos und Dokumente speichert. + +👉 *Screenshot geeignet: Terminal mit erfolgreich erstellter Verzeichnisstruktur.* + +### PHP konfigurieren + +Nextcloud basiert auf PHP. Einige Standardwerte sind für größere Anwendungen jedoch zu niedrig gesetzt. +Wir passen deshalb die Konfiguration an, damit Uploads, Vorschauen und lange Prozesse problemlos funktionieren. + +#### Datei `php.ini` bearbeiten + +Öffne die Konfigurationsdatei des PHP-Prozesses: + +```bash +nano /etc/php/8.3/fpm/php.ini +``` + +Suche nach den folgenden Parametern und ändere sie wie unten gezeigt: + +```ini +upload_max_filesize = 10G +post_max_size = 10G +memory_limit = 1024M +max_execution_time = 3600 +max_input_time = 3600 +date.timezone = Europe/Berlin + +opcache.enable=1 +opcache.memory_consumption=128 +opcache.max_accelerated_files=10000 +opcache.interned_strings_buffer=16 +``` + +> [!TIP] +> Diese Werte erlauben auch sehr große Uploads, zum Beispiel Videoaufnahmen oder Backups. +> `opcache` beschleunigt PHP, indem häufig genutzte Skripte im Arbeitsspeicher bleiben. + +Speichern mit **Strg + O**, bestätigen mit **Enter**, schließen mit **Strg + X**. + +👉 *Screenshot geeignet: Editor mit geöffnetem php.ini-Abschnitt und angepassten Werten.* + +#### Datei `www.conf` bearbeiten + +In dieser Datei wird gesteuert, wie viele gleichzeitige PHP-Prozesse laufen dürfen. + +```bash +nano /etc/php/8.3/fpm/pool.d/www.conf +``` + +Ändere oder ergänze folgende Zeilen: + +```ini +pm = dynamic +pm.max_children = 12 +pm.start_servers = 3 +pm.min_spare_servers = 2 +pm.max_spare_servers = 6 +``` + +> [!NOTE] +> Diese Werte sind ein guter Ausgangspunkt für Systeme mit 4 GB RAM. +> Bei mehr Arbeitsspeicher kannst du `pm.max_children` später erhöhen. + +Speichern und den PHP-Dienst neu laden: + +```bash +systemctl reload php8.3-fpm +``` + +👉 *Screenshot geeignet: Terminal mit Ausgabe „Reloading PHP 8.3 FPM configuration“.* + +### PostgreSQL initialisieren + +Nextcloud nutzt eine relationale Datenbank, um Benutzerkonten, Freigaben, Dateiinformationen und App-Daten zu speichern. +Wir verwenden hier **PostgreSQL**, weil sie stabiler und performanter als MariaDB ist – besonders bei vielen gleichzeitigen Zugriffen. + +#### Datenbankdienst aktivieren + +Nach der Installation richten wir den Datenbankdienst so ein, dass er in der Container-Umgebung zuverlässig startet. +Ubuntu erstellt bei der Installation automatisch einen Standard-Cluster („main“). +Dieser funktioniert in vollwertigen Systemen sofort, **nicht aber immer in LXC-Containern**, +weil dort manche Systemfunktionen – etwa Shared Memory oder Prozesskommunikation – anders behandelt werden. + +Darum löschen wir den automatisch angelegten Cluster und erstellen ihn direkt neu. +So passt PostgreSQL seine Struktur an die Container-Umgebung an und läuft stabil. + +```bash +pg_dropcluster 16 main --stop +pg_createcluster 16 main --start +systemctl enable postgresql +systemctl start postgresql +``` + +> [!NOTE] +> Dieser Schritt wird nur bei Containern benötigt. +> Auf einem vollwertigen Server ohne LXC-Umgebung kannst du die Befehle `pg_dropcluster` und `pg_createcluster` weglassen. + +👉 *Screenshot geeignet: Terminal mit Ausgabe nach `pg_createcluster 16 main --start`.* + +#### Benutzer und Datenbank anlegen + +Melde dich nun als PostgreSQL-Systembenutzer an: + +```bash +su - postgres +``` + +Starte anschließend die SQL-Shell: + +```bash +psql +``` + +Lege die Datenbank und den Benutzer an: + +```sql +CREATE DATABASE nextcloud; +CREATE USER nextcloud WITH PASSWORD 'DEIN_SICHERES_PASSWORT'; +GRANT ALL PRIVILEGES ON DATABASE nextcloud TO nextcloud; +\q +``` + +> [!TIP] +> Wähle ein starkes Passwort mit Sonderzeichen und Groß-/Kleinschreibung. +> Es wird später in der Nextcloud-Konfiguration eingetragen. + +👉 *Screenshot geeignet: PostgreSQL-Konsole mit ausgeführten SQL-Befehlen.* + +#### Rechte auf das Schema vergeben + +Öffne erneut die SQL-Shell, diesmal direkt für die neue Datenbank: + +```bash +psql -d nextcloud +``` + +Ergänze die Berechtigungen: + +```sql +GRANT ALL ON SCHEMA public TO nextcloud; +ALTER SCHEMA public OWNER TO nextcloud; +\q +``` + +Danach kannst du die PostgreSQL-Sitzung verlassen: + +```bash +exit +``` + +👉 *Screenshot geeignet: Terminal mit abgeschlossener Datenbankeinrichtung.* + +> [!NOTE] +> Damit ist die Datenbank vollständig vorbereitet. +> Nextcloud kann bei der Installation direkt darauf zugreifen, ohne dass nachträgliche Anpassungen nötig sind. + +### Redis konfigurieren + +Redis ist ein schneller Zwischenspeicher (Cache), den Nextcloud für Datei-Sperren und temporäre Daten verwendet. +Ohne Redis kann es bei gleichzeitigen Zugriffen zu Fehlern wie **„File is locked“** kommen. +Die Einrichtung erfolgt lokal im Container – eine Authentifizierung ist hier nicht nötig, da kein externer Zugriff erlaubt wird. + +#### Zugriff für den Webserver erlauben + +Der Webserver läuft unter dem Benutzer **www-data**. +Damit dieser auf den Redis-Socket zugreifen kann, fügen wir ihn der Redis-Gruppe hinzu: + +```bash +usermod -aG redis www-data +``` + +> [!NOTE] +> Diese Berechtigung ist erforderlich, damit PHP über den lokalen Socket mit Redis kommunizieren kann. +> Ohne sie würde Nextcloud beim ersten Start eine Warnung im Adminbereich anzeigen. + +👉 *Screenshot geeignet: Terminal mit erfolgreicher Ausgabe des usermod-Befehls.* + +#### Redis-Konfiguration anpassen + +Öffne die Konfigurationsdatei: + +```bash +nano /etc/redis/redis.conf +``` + +Suche nach den folgenden Zeilen und stelle sicher, dass sie wie unten aussehen. +Falls sie auskommentiert sind (`#` am Zeilenanfang), entferne das Zeichen. + +```ini +supervised systemd +unixsocket /var/run/redis/redis-server.sock +unixsocketperm 770 +``` + +> [!TIP] +> Diese drei Einstellungen sorgen dafür, dass Redis über eine lokale Datei („Socket“) erreichbar ist. +> So läuft die Kommunikation vollständig intern, ohne dass ein Netzwerkport geöffnet werden muss. + +Speichern mit **Strg + O**, bestätigen mit **Enter**, schließen mit **Strg + X**. + +👉 *Screenshot geeignet: geöffnete redis.conf im Editor mit hervorgehobenen Socket-Einstellungen.* + +#### Redis neu starten + +Damit die Änderungen aktiv werden: + +```bash +systemctl restart redis-server +systemctl restart php8.3-fpm +``` + +> [!NOTE] +> Nach dem Neustart ist Redis sofort einsatzbereit. +> Eine zusätzliche Anmeldung oder Passwortabfrage ist in dieser Umgebung nicht nötig. + +👉 *Screenshot geeignet: Terminal mit erfolgreichem Neustart der Dienste.* + +#### Funktionsprüfung + +Zur Kontrolle kannst du den Redis-Server kurz testen: + +```bash +redis-cli ping +``` + +Wenn `PONG` zurückgegeben wird, läuft der Dienst korrekt. + +👉 *Screenshot geeignet: Terminal mit der Ausgabe „PONG“.* + +### Nextcloud herunterladen + +Nextcloud wird direkt von der offiziellen Projektseite geladen. +Wir installieren sie manuell, damit du jederzeit die genaue Version kontrollierst und später Updates gezielt durchführen kannst. +Automatische Installationspakete (z. B. Snap) sind für Server ungeeignet, weil sie Konfigurationen stark einschränken. + +#### Installationsverzeichnis wechseln und aktuelle Version laden + +```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 nextcloud +``` + +> [!NOTE] +> Der Befehl `curl -LO` lädt immer die aktuellste stabile Version von Nextcloud herunter. +> Du kannst sie auf der offiziellen Seite [https://nextcloud.com/changelog/](https://nextcloud.com/changelog/) überprüfen. + +👉 *Screenshot geeignet: Terminal mit Download- und Entpackvorgang.* + +#### Dateiberechtigungen prüfen + +Nach dem Entpacken muss das gesamte Verzeichnis dem Benutzer **www-data** gehören, +da dieser später den Webserver-Prozess ausführt. + +```bash +ls -l /srv/nextcloud/app +``` + +Die Ausgabe sollte so aussehen: + +``` +drwxr-x--- 15 www-data www-data 4096 ... +``` + +> [!TIP] +> Wenn ein anderer Benutzer als Eigentümer angezeigt wird, +> wiederhole den Befehl `chown -R www-data:www-data /srv/nextcloud/app/nextcloud`. + +👉 *Screenshot geeignet: Terminal mit Ausgabe der korrekten Besitzerrechte.* + +Damit ist Nextcloud auf dem Server installiert. +Im nächsten Schritt konfigurieren wir PHP und Nginx so, dass die Weboberfläche erreichbar ist. + +### Nginx konfigurieren + +Nginx übernimmt innerhalb des Containers die lokale Auslieferung der Nextcloud-Dateien und die Kommunikation mit PHP. +Die eigentliche HTTPS-Verschlüsselung erfolgt später im Nginx Proxy Manager, +darum genügt es hier, Nginx nur auf Port 80 (HTTP) laufen zu lassen. + +#### Neue Konfigurationsdatei anlegen + +```bash +nano /etc/nginx/sites-available/nextcloud.conf +``` + +Füge folgenden Inhalt ein: + +```nginx +server { + listen 80; + server_name cloud.DEINE-DOMAIN.tld; + + root /srv/nextcloud/app/nextcloud; + index index.php index.html; + + client_max_body_size 10G; + fastcgi_buffers 64 4K; + + add_header Referrer-Policy "no-referrer" always; + add_header X-Content-Type-Options "nosniff" always; + add_header X-Frame-Options "SAMEORIGIN" always; + add_header X-XSS-Protection "1; mode=block" always; + + location = /robots.txt { + allow all; + log_not_found off; + access_log off; + } + + location ~ ^/(?:\.htaccess|data|config|db_structure\.xml|README) { + deny all; + } + + location ~ \.php(?:$|/) { + include fastcgi_params; + fastcgi_split_path_info ^(.+\.php)(/.*)$; + 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; + fastcgi_intercept_errors on; + fastcgi_request_buffering off; + } +} +``` + +> [!NOTE] +> Diese Konfiguration leitet PHP-Dateien direkt an den lokalen PHP-Prozess weiter +> und begrenzt den Zugriff auf sensible Systemdateien. +> Die Upload-Größe ist bereits auf 10 GB erweitert – ideal für große Video- oder Projektdateien. + +👉 *Screenshot geeignet: Editor mit geöffneter nextcloud.conf und eingefügtem Inhalt.* + +#### Website aktivieren und Standardseite entfernen + +Aktiviere die neue Konfiguration und entferne die alte Standardseite: + +```bash +ln -s /etc/nginx/sites-available/nextcloud.conf /etc/nginx/sites-enabled/ +rm /etc/nginx/sites-enabled/default +``` + +#### Konfiguration prüfen und Nginx neu laden + +Bevor du den Webserver neu startest, prüfe die Syntax: + +```bash +nginx -t && systemctl reload nginx +``` + +Wenn die Meldung **„syntax is ok“** erscheint, ist alles korrekt. +Jetzt ist Nginx bereit, Anfragen lokal entgegenzunehmen. + +👉 *Screenshot geeignet: Terminalausgabe mit „nginx: configuration file /etc/nginx/nginx.conf test is successful“.* + +### Nextcloud-Konfiguration vorbereiten + +Nextcloud legt beim ersten Start automatisch eine Konfigurationsdatei an. +Wir erstellen sie jedoch schon jetzt manuell, damit alle wichtigen Einstellungen – insbesondere für Proxy, HTTPS und Redis – von Anfang an korrekt sind. + +#### Datei anlegen + +```bash +nano /srv/nextcloud/app/nextcloud/config/config.php +``` + +Füge den folgenden Inhalt ein und passe die markierten Werte an deine Umgebung an: + +```php + [ + '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', + 'redis' => [ + 'host' => '/var/run/redis/redis-server.sock', + 'port' => 0, + 'timeout' => 1.5, + ], +); +``` + +> [!NOTE] +> Ersetze `DEINE-DOMAIN.tld` durch deine echte Domain und trage bei `trusted_proxies` die IP-Adresse deines Proxy-Managers ein. +> So erkennt Nextcloud später automatisch, dass alle HTTPS-Verbindungen über den Proxy laufen. + +👉 *Screenshot geeignet: geöffnete config.php im Editor mit angepassten Domain- und Proxy-Werten.* + +#### Dateirechte setzen + +Die Konfiguration darf nur vom Webserver gelesen werden: + +```bash +chown -R www-data:www-data /srv/nextcloud/app/nextcloud/config +chmod 640 /srv/nextcloud/app/nextcloud/config/config.php +``` + +> [!TIP] +> Diese Berechtigungen schützen die Datei vor unbefugtem Zugriff. +> Selbst wenn jemand SSH-Zugang zum Container hätte, könnte er die Datei ohne Administratorrechte nicht lesen. + +👉 *Screenshot geeignet: Terminal mit Ausgabe der Befehle und gesetzten Berechtigungen.* + +Damit ist Nextcloud vollständig vorbereitet. +Im nächsten Schritt richten wir im **Nginx Proxy Manager (NPM)** den externen Zugriff und das SSL-Zertifikat ein. + +### Nextcloud im Proxy Manager einrichten + +Nextcloud ist jetzt im Container über Port 80 erreichbar. +Damit du sie auch über das Internet unter `https://cloud.DEINE-DOMAIN.tld` aufrufen kannst, +legen wir im **Nginx Proxy Manager (NPM)** einen neuen Proxy Host an. + +#### Anmelden im NPM-Dashboard + +Öffne im Browser: + +``` +https://proxy.DEINE-DOMAIN.tld +``` + +Alternativ kannst du dich auch über die interne IP deines NPM-Containers anmelden, +zum Beispiel: + +``` +http://192.168.1.10:81 +``` + +> [!NOTE] +> Aus Sicherheitsgründen sollte die Verwaltungsoberfläche des NPM **nicht von außen erreichbar** sein. +> Der Zugriff über die lokale IP im Heimnetz ist vollkommen ausreichend. + +Melde dich mit deinem Administrator-Konto an. +Sobald das Dashboard sichtbar ist, klicke links im Menü auf **Hosts → Proxy Hosts** +und anschließend oben rechts auf **Add Proxy Host**. + +👉 *Screenshot geeignet: NPM-Dashboard mit geöffnetem Menü „Proxy Hosts“.* + +#### Proxy Host anlegen + +Fülle die Felder wie folgt aus: + +| Feld | Wert | +|------|------| +| **Domain Names** | `cloud.DEINE-DOMAIN.tld` | +| **Scheme** | `http` | +| **Forward Hostname/IP** | IP-Adresse des Nextcloud-Containers, z. B. `192.168.1.60` | +| **Forward Port** | `80` | +| **Block Common Exploits** | ✅ aktiviert | +| **Websockets Support** | ✅ aktiviert | + +> [!NOTE] +> Nextcloud selbst läuft nur über HTTP. +> Der Proxy Manager übernimmt die HTTPS-Verschlüsselung und kümmert sich automatisch um das Zertifikat. + +👉 *Screenshot geeignet: ausgefüllte Proxy-Maske mit Beispielwerten.* + +#### SSL-Zertifikat erstellen + +1. Wechsle in den Reiter **SSL**. +2. Wähle **Request a new SSL Certificate**. +3. Aktiviere die Optionen: + - ✅ Force SSL + - ✅ HTTP/2 Support + - ✅ HSTS (optional, empfohlen) +4. Gib deine E-Mail-Adresse ein (wird von Let’s Encrypt benötigt). +5. Klicke auf **Save**. + +Nach wenigen Sekunden erscheint das Zertifikat mit dem Status *Active*. + +👉 *Screenshot geeignet: SSL-Reiter mit aktiviertem Let’s-Encrypt-Zertifikat.* + +> [!TIP] +> Wenn die Zertifikatserstellung fehlschlägt, prüfe zuerst die Portweiterleitungen (80 und 443) +> und ob deine Domain auf die öffentliche IP deines UCC zeigt. + +#### Erweiterte Einstellungen für große Uploads + +Nextcloud erlaubt Uploads bis zu mehreren Gigabyte. +Damit der Proxy diese Dateien nicht vorher abbricht, aktivieren wir erweiterte Timeout-Werte. + +1. Öffne beim selben Proxy Host den Reiter **Advanced**. +2. Füge folgenden Text ein: + +```nginx +client_max_body_size 30G; +proxy_read_timeout 3600; +proxy_send_timeout 3600; +``` + +3. Klicke auf **Save**. + +> [!NOTE] +> Diese Werte verhindern Abbrüche bei großen Dateiübertragungen oder langsamen Verbindungen. + +👉 *Screenshot geeignet: Reiter „Advanced“ mit den eingetragenen Timeout-Werten.* + +#### Verbindung testen + +Öffne im Browser: + +``` +https://cloud.DEINE-DOMAIN.tld +``` + +Wenn alles korrekt eingerichtet ist, erscheint der Nextcloud-Setup-Assistent. +Damit ist der externe Zugriff über den Proxy erfolgreich hergestellt. + +> [!TIP] +> Sollte stattdessen die Nginx-Standardseite erscheinen, +> prüfe im Proxy Host, ob **Forward Hostname/IP** und **Port 80** richtig eingetragen sind +> und ob keine Tippfehler bei der Domain vorliegen. + +### Nextcloud im Browser einrichten + +Nachdem der Proxy Host eingerichtet ist, kannst du die Installation von Nextcloud direkt im Browser abschließen. +Öffne die Adresse deiner Cloud: + +``` +https://cloud.DEINE-DOMAIN.tld +``` + +Nach kurzer Ladezeit erscheint das Einrichtungsformular von Nextcloud. + +👉 *Screenshot geeignet: Browserfenster mit dem Nextcloud-Setup-Assistenten.* + +#### Administrator-Konto anlegen + +Im oberen Bereich legst du das erste Benutzerkonto an. +Dieses Konto ist der Administrator deiner Instanz. + +| Feld | Beschreibung | +|------|--------------| +| **Benutzername** | frei wählbar, z. B. `admin` | +| **Passwort** | ein sicheres Kennwort mit Sonderzeichen | + +> [!TIP] +> Verwende ein starkes Passwort, da dieses Konto vollen Zugriff auf alle Daten, Benutzer und Einstellungen hat. +> Du kannst später weitere Benutzer mit eingeschränkten Rechten anlegen. + +👉 *Screenshot geeignet: Ausgefüllte Felder für Benutzername und Passwort.* + +#### Speicherort der Daten festlegen + +Unter **Datenverzeichnis** trägst du das bereits angelegte Verzeichnis ein: + +``` +/mnt/hdd/nextcloud_data +``` + +> [!NOTE] +> Hier werden später alle hochgeladenen Dateien gespeichert – Dokumente, Fotos, Videos oder Backups. +> Achte darauf, dass du den Pfad exakt einträgst, sonst legt Nextcloud ein neues Verzeichnis im Container an. + +👉 *Screenshot geeignet: Setup-Formular mit eingetragenem Pfad /mnt/hdd/nextcloud_data.* + +#### Datenbankzugang eintragen + +Im unteren Teil folgen die Felder für den Datenbankzugang. +Wähle als Typ **PostgreSQL** und trage deine Zugangsdaten wie folgt ein: + +| Feld | Wert | +|------|------| +| **Datenbankbenutzer** | `nextcloud` | +| **Datenbankpasswort** | `DEIN_SICHERES_PASSWORT` | +| **Datenbankname** | `nextcloud` | +| **Host** | `localhost` | + +> [!TIP] +> Alle Werte stammen aus der PostgreSQL-Einrichtung im vorherigen Abschnitt. +> Wenn du das Passwort vergessen hast, kannst du es in der Datenbank mit `\password nextcloud` neu setzen. + +👉 *Screenshot geeignet: Formularabschnitt „Datenbank-Konfiguration“ mit ausgefüllten Feldern.* + +#### Installation starten + +Klicke anschließend auf **Installation abschließen**. +Nextcloud erstellt nun alle Tabellen in der Datenbank und richtet die Grundstruktur ein. +Der Vorgang dauert je nach Systemleistung ein bis zwei Minuten. + +Nach Abschluss wird automatisch die Hauptseite geöffnet. +Du siehst das **Dashboard** mit Willkommensnachricht, Benutzerbereich und Menüleiste. + +👉 *Screenshot geeignet: Startseite der frisch installierten Nextcloud.* + +> [!NOTE] +> Wenn der Vorgang fehlschlägt oder eine Fehlermeldung wie „Datenbankverbindung fehlgeschlagen“ erscheint, +> prüfe nochmals den Datenbanknamen, das Passwort und den Hostnamen (`localhost`). +> Danach einfach die Seite neu laden und den Vorgang wiederholen. + +### Cronjob für Hintergrundprozesse + +Nextcloud erledigt viele Aufgaben automatisch im Hintergrund – zum Beispiel das Erstellen von Vorschaubildern, das Aktualisieren von Freigaben oder das Entfernen alter Sitzungen. +Damit das zuverlässig funktioniert, richten wir einen systemweiten Cronjob ein. + +#### Cronjob für den Webserver-Benutzer anlegen + +Öffne die Cron-Konfiguration für den Benutzer **www-data**. +Das ist der Benutzer, unter dem Nextcloud und PHP laufen. + +```bash +crontab -u www-data -e +``` + +Wenn du gefragt wirst, welchen Editor du verwenden möchtest, wähle **nano**. +Scrolle anschließend ganz ans Ende der Datei und füge folgende Zeile ein: + +```bash +*/5 * * * * php -f /srv/nextcloud/app/nextcloud/cron.php +``` + +> [!NOTE] +> Dieser Eintrag sorgt dafür, dass alle 5 Minuten das interne Skript `cron.php` ausgeführt wird. +> Es verarbeitet automatisch Wartungs-, Daten- und Hintergrundaufgaben. + +Speichern mit **Strg + O**, bestätigen mit **Enter**, schließen mit **Strg + X**. + +👉 *Screenshot geeignet: Editor mit geöffneter Crontab und eingetragener Zeile.* + +#### Funktionsprüfung + +Warte ein paar Minuten und öffne danach das Admin-Panel in Nextcloud. +Unter **Einstellungen → Verwaltung → Grundlegende Einstellungen** sollte der Hinweis +„Hintergrundjobs: Cron (empfohlen)“ erscheinen. + +> [!TIP] +> Wenn dort noch „AJAX“ steht, wähle **Cron (empfohlen)** und speichere die Einstellung. +> Danach übernimmt das System automatisch alle Hintergrundaufgaben. + +👉 *Screenshot geeignet: Nextcloud-Adminbereich mit aktivierter Cron-Option.* + +Damit ist der automatisierte Hintergrunddienst aktiv. +Nextcloud führt ab jetzt alle Aufgaben regelmäßig und ohne manuelles Eingreifen aus. +