Homelab--Bratonein-Kontrollzentrum--Tutorial/Kapitel 6/Free Rohtext.md

# 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 <dienstname>` 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
<?php
$CONFIG = array (
  '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,
  '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.

### Feinschliff & Optimierung

Nach der Grundinstallation zeigt das Admin-Panel von Nextcloud häufig mehrere Hinweise an.  
Das sind keine Fehler, sondern Empfehlungen, um Stabilität und Kompatibilität zu verbessern.  
Wir gehen sie jetzt einzeln durch, erklären den Hintergrund und zeigen die exakten Schritte.

#### MIME-Type für `.mjs` aktivieren

Nach der Installation erscheint oft der Hinweis:

> „Ihr Webserver liefert .mjs-Dateien nicht mit dem JavaScript MIME-Typ.“

Das bedeutet, dass moderne JavaScript-Dateien (`.mjs`) nicht korrekt als JavaScript erkannt werden.  
Dadurch funktionieren einige Apps wie Kalender oder Talk nicht richtig.

1. Öffne die Nginx-Konfiguration:
   ```bash
   nano /etc/nginx/sites-available/nextcloud.conf
   ```
2. Suche den Block `server { … }`.  
   Direkt unter der Zeile `server_name cloud.DEINE-DOMAIN.tld;` fügst du Folgendes ein:
   ```nginx
   types { application/javascript mjs; }
   ```
   Diese Zeile sorgt dafür, dass `.mjs`-Dateien den korrekten MIME-Typ erhalten.
3. Speichern mit **Strg + O**, bestätigen mit **Enter**, schließen mit **Strg + X**.
4. Konfiguration prüfen:
   ```bash
   nginx -t
   ```
   Wenn „syntax is ok“ und „test is successful“ erscheint:
   ```bash
   systemctl reload nginx
   ```

> [!NOTE]  
> Danach sollte der Hinweis im Nextcloud-Adminbereich verschwinden.  
> Browser laden `.mjs`-Dateien jetzt korrekt.

👉 *Screenshot geeignet: Editor mit eingefügtem MIME-Type und erfolgreicher Syntaxprüfung.*

#### OCM- und OCS-Provider auflösen

Dieser Hinweis erscheint, wenn Nextcloud keine externen Freigaben (Federation) erkennt.  
Die Ursache ist eine fehlende Routen-Definition in Nginx.

1. Öffne wieder die Datei:
   ```bash
   nano /etc/nginx/sites-available/nextcloud.conf
   ```
2. Scrolle bis ans Ende des Blocks `server { … }` und füge unterhalb der bestehenden `location`-Einträge ein:
   ```nginx
   location ~ ^/(?:ocm-provider|ocs-provider)/ {
     try_files $uri $uri/ =404;
     index index.php;
   }
   ```
3. Datei speichern, testen und neu laden:
   ```bash
   nginx -t && systemctl reload nginx
   ```

> [!NOTE]  
> Dadurch können andere Server und Benutzer wieder Dateien über Federation austauschen.  
> Im Admin-Panel sollte der entsprechende Hinweis verschwinden.

👉 *Screenshot geeignet: geöffnete nextcloud.conf mit neuem Location-Block.*

#### `.well-known`-Weiterleitungen aktivieren

Nextcloud nutzt spezielle URLs wie `/.well-known/carddav`, damit Kalender- und Kontakt-Apps (DAV-Clients) automatisch den richtigen Pfad finden.  
Fehlt diese Weiterleitung, funktionieren CalDAV, CardDAV und WebFinger nicht.

1. Öffne erneut die Datei:
   ```bash
   nano /etc/nginx/sites-available/nextcloud.conf
   ```
2. Füge unterhalb der bestehenden `location`-Einträge diese Zeilen ein:
   ```nginx
   location = /.well-known/webfinger { return 301 /index.php/.well-known/webfinger; }
   location = /.well-known/nodeinfo { return 301 /index.php/.well-known/nodeinfo; }
   location ~ ^/.well-known/acme-challenge { default_type "text/plain"; root /var/www/letsencrypt; }
   location = /.well-known/carddav { return 301 /remote.php/dav; }
   location = /.well-known/caldav { return 301 /remote.php/dav; }
   ```
3. Speichern und prüfen:
   ```bash
   nginx -t && systemctl reload nginx
   ```
4. Kontrolle mit:
   ```bash
   curl -I https://cloud.DEINE-DOMAIN.tld/.well-known/carddav
   ```
   Wenn `HTTP/1.1 301 Moved Permanently` erscheint, funktioniert die Weiterleitung.

> [!TIP]  
> Ohne diese Weiterleitungen können Kalender- und Kontakte-Apps keine Verbindung herstellen.  
> Nach der Änderung verschwindet die Warnung im Admin-Panel.

👉 *Screenshot geeignet: Terminal mit erfolgreichem curl-Test.*

#### Debug-Modus deaktivieren

Der Debug-Modus zeigt zusätzliche Fehlermeldungen und Warnungen, die im Produktivbetrieb nicht nötig sind.  
Er sollte immer deaktiviert sein, bevor du die Cloud dauerhaft nutzt.

1. Öffne die Konfiguration:
   ```bash
   nano /srv/nextcloud/app/nextcloud/config/config.php
   ```
2. Suche nach einem vorhandenen Eintrag `'debug' => true,`  
   oder füge am Ende der Liste folgende Zeile hinzu:
   ```php
   'debug' => false,
   ```
3. Speichern und schließen.

> [!NOTE]  
> Nach dieser Änderung verschwindet die Warnung „Debug-Modus aktiv“.  
> Die Cloud läuft nun mit normalen Log-Einstellungen.

👉 *Screenshot geeignet: config.php mit deaktiviertem Debug-Modus.*

#### Wartungsfenster festlegen

Nextcloud kann Hintergrundaufgaben gebündelt in einem festen Zeitfenster ausführen.  
Damit wird die Serverlast gleichmäßig verteilt und störende Prozesse laufen z. B. nachts.

Führe im Container aus:

```bash
sudo -u www-data php /srv/nextcloud/app/nextcloud/occ config:system:set maintenance_window_start --value="2"
```

Damit beginnt das Wartungsfenster täglich um **2 Uhr morgens**.

> [!TIP]  
> Du kannst den Wert anpassen, z. B. `--value="4"` für 4 Uhr morgens.  
> Die Zahl steht für die **Startstunde** des Wartungsfensters in 24-Stunden-Notation.

👉 *Screenshot geeignet: Terminal mit erfolgreicher OCC-Ausgabe.*

#### Fehlende Indizes hinzufügen

In neuen Nextcloud-Versionen erscheinen manchmal Meldungen wie  
*„Fehlende Indizes in der Datenbank gefunden“.*  
Das betrifft die Geschwindigkeit bei Datenbankabfragen.

1. Im Container ausführen:
   ```bash
   sudo -u www-data php /srv/nextcloud/app/nextcloud/occ db:add-missing-indices
   ```
2. Nach wenigen Sekunden meldet Nextcloud, welche Tabellen aktualisiert wurden.

> [!NOTE]  
> Danach ist die Warnung verschwunden und Datenbankabfragen laufen schneller.

👉 *Screenshot geeignet: Terminal mit Ausgabe „All indices added successfully“.*

#### Standard-Telefonregion festlegen

Dieser Hinweis betrifft Telefonnummern in Benutzerprofilen.  
Ohne Standard-Region können Nummern ohne Landesvorwahl nicht validiert werden.

1. Öffne die Datei:
   ```bash
   nano /srv/nextcloud/app/nextcloud/config/config.php
   ```
2. Ergänze am Ende:
   ```php
   'default_phone_region' => 'DE',
   ```
3. Speichern und schließen.

> [!NOTE]  
> Danach akzeptiert Nextcloud auch Telefonnummern ohne Vorwahl als gültig.

👉 *Screenshot geeignet: config.php mit eingetragener Standard-Region.*

### Ergebnis

Nach diesen Schritten ist deine Nextcloud-Installation technisch vollständig optimiert:

- Keine Warnmeldungen mehr im Admin-Panel  
- Stabiler Betrieb ohne Fehlermeldungen  
- Externe Freigaben und DAV-Synchronisierung funktionieren  
- Datenbank und Webserver laufen effizient und sicher  

👉 *Screenshot geeignet: Admin-Übersicht ohne Warnmeldungen (alle Punkte grün).*

--- 

## Zusammenfassung & nächste Schritte

Mit diesem Kapitel hast du eine vollständig funktionsfähige Nextcloud-Instanz eingerichtet –  
von der Datenbank über den Webserver bis hin zur sicheren Veröffentlichung über den Proxy.

Du hast gelernt:

- wie du einen eigenen Ubuntu-LXC mit aktivierten Sonderfunktionen (Nesting, Keyctl) anlegst  
- wie du Nginx, PostgreSQL, Redis und PHP so kombinierst, dass sie perfekt zusammenarbeiten  
- wie du Nextcloud manuell installierst und über Nginx Proxy Manager verschlüsselt veröffentlichst  
- wie du per Cronjob alle Hintergrundaufgaben automatisch ausführen lässt  
- wie du typische Warnmeldungen im Adminbereich Schritt für Schritt beseitigst  

Damit ist der technische Teil abgeschlossen.  
Nextcloud läuft stabil, sicher und performant in deinem UCC-System –  
und du kannst sie ab jetzt täglich nutzen, um Daten zu synchronisieren, Dateien zu teilen oder Teams zu organisieren.

> [!TIP]  
> Du kannst Nextcloud von allen Geräten aus aufrufen:  
> - **Browser:** `https://cloud.DEINE-DOMAIN.tld`  
> - **Desktop-App:** über die Nextcloud-App für Windows, macOS oder Linux  
> - **Smartphone:** Nextcloud-App aus dem Play Store oder App Store  

> [!NOTE]  
> Falls du den Zugriff nur intern erlauben möchtest, kannst du in Nginx Proxy Manager  
> einfach eine Access-List mit lokalen IP-Bereichen anlegen.  
> So bleibt deine Nextcloud im Heimnetz sichtbar, aber von außen geschützt.

Als nächstes folgen im Premium-Kapitel erweiterte Funktionen für Komfort und Automatisierung:  
- automatisierte Backups der Datenbank und Konfiguration  
- sichere Wiederherstellung älterer Versionen  
- Integration eines Mailservers für Benachrichtigungen  
- Performance-Tuning für Redis, OPcache und PHP  
- Optimierte Vorschaugenerierung und Bildverarbeitung mit Imagick

Damit bringst du deine Cloud auf professionelles Niveau –  
aber bleibst jederzeit Herr deiner eigenen Daten.

👉 *Screenshot geeignet: Übersicht Nextcloud-Dashboard mit aktivierter Synchronisierung und grünem Systemstatus.*