Nextcloud nativ auf Ubuntu installieren: LEMP-Stack mit Nginx, MariaDB und PHP-FPM

Nextcloud ist eine Open-Source-Plattform für Dateiablage, Kalender, Kontakte und Zusammenarbeit. Statt des All-in-One-Docker-Images installieren Sie hier direkt auf dem Server, mit direktem Zugriff auf PHP, MariaDB und Nginx. Diese Anleitung führt Schritt für Schritt durch eine Nextcloud-35-Installation auf Ubuntu 24.04 LTS mit dem LEMP-Stack (Linux, Nginx, MariaDB, PHP-FPM) inklusive Redis-Caching und Let’s-Encrypt-TLS, Zeitbedarf etwa 90 bis 120 Minuten.

Voraussetzungen

1. Ubuntu 24.04 LTS (64-Bit, Server-Installation; Ubuntu 26.04 LTS funktioniert ebenfalls)
2. Mindestens 2 CPU-Kerne (x86_64 oder arm64) und 2 GB RAM, für Produktivbetrieb mit mehreren Benutzern 4 GB
3. Mindestens 20 GB Speicher für System und Programm, Nutzerdaten idealerweise auf eigenem Volume
4. Domain mit DNS-A-Eintrag auf die Server-IP (Pflicht für Let’s Encrypt)
5. Root- oder sudo-Zugang, SSH-Key-Authentifizierung empfohlen (siehe SSH-Key-Authentifizierung einrichten)
6. Grundkenntnisse in der Linux-Kommandozeile

Nativ vs. Docker-AIO: Wann lohnt sich welcher Weg?

Die Unterschiede zum All-in-One-Docker-Image:

Für den Docker-Weg siehe die Nextcloud-AIO-Docker-Anleitung.

Stack-Komponenten und empfohlene Versionen (Stand September 2026)

Schritt 1: System vorbereiten und Pakete installieren

Aktualisieren Sie das System und installieren Sie alle benötigten Pakete in einem einzigen Durchgang. Die Liste deckt Pflicht- und empfohlene PHP-Erweiterungen ab, damit der Admin-Bereich keine Warnungen zeigt. sodium und exif sind unter Ubuntu 24.04 bereits in php8.3-common enthalten.

sudo apt update && sudo apt upgrade -y

sudo apt install -y \
  nginx \
  php8.3-fpm php8.3-mysql php8.3-mbstring php8.3-xml php8.3-curl \
  php8.3-gd php8.3-zip php8.3-bcmath php8.3-intl php8.3-gmp \
  php8.3-apcu php8.3-redis php8.3-imagick php8.3-bz2 \
  mariadb-server mariadb-client \
  redis-server \
  certbot python3-certbot-nginx \
  wget unzip ufw

sudo systemctl enable --now mariadb redis-server php8.3-fpm nginx

Verifizieren: systemctl status php8.3-fpm mariadb redis-server nginx zeigt für alle vier Dienste active (running), php8.3 -m | grep -E 'sodium|exif' listet beide Module.

Schritt 2: MariaDB absichern und Datenbank anlegen

Der Sicherungsassistent entfernt anonyme Nutzer und Remote-Root-Login. Danach legen Sie eine dedizierte Datenbank mit dem Pflicht-Zeichensatz utf8mb4 und der Collation utf8mb4_unicode_ci an.

sudo mysql_secure_installation
sudo mariadb <<SQL
CREATE DATABASE nextcloud DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'nc_user'@'localhost' IDENTIFIED BY 'STARKES_DB_PASSWORT';
GRANT ALL PRIVILEGES ON nextcloud.* TO 'nc_user'@'localhost';
FLUSH PRIVILEGES;
SQL

Verifizieren: sudo mariadb -e "SHOW DATABASES;": Die Datenbank nextcloud erscheint in der Liste.

Schritt 3: PHP-FPM optimieren

Erstellen Sie eine Nextcloud-spezifische INI-Datei. opcache.save_comments=1 ist Pflicht, weil Nextcloud PHP-Docblock-Annotationen für die Dependency Injection auswertet.

sudo tee /etc/php/8.3/fpm/conf.d/99-nextcloud.ini <<'EOF'
memory_limit = 512M
upload_max_filesize = 16G
post_max_size = 16G
max_execution_time = 3600
max_input_time = 3600
output_buffering = 0
date.timezone = Europe/Berlin

opcache.enable = 1
opcache.enable_cli = 1
opcache.memory_consumption = 128
opcache.interned_strings_buffer = 16
opcache.max_accelerated_files = 10000
opcache.revalidate_freq = 1
opcache.save_comments = 1

apc.enable_cli = 1
EOF

# Symlink fuer CLI (occ-Befehle nutzen ebenfalls diese Einstellungen)
sudo ln -sf /etc/php/8.3/fpm/conf.d/99-nextcloud.ini \
            /etc/php/8.3/cli/conf.d/99-nextcloud.ini

sudo systemctl restart php8.3-fpm

Verifizieren: php8.3 -r "echo ini_get('memory_limit');" gibt 512M aus.

Schritt 4: Redis über Unix-Socket konfigurieren

Redis über einen Unix-Socket einzubinden spart gegenüber TCP (127.0.0.1:6379) den Netzwerk-Stack. www-data braucht dafür die Gruppe redis.

sudo bash -c 'cat >> /etc/redis/redis.conf' <<'EOF'
unixsocket /run/redis/redis-server.sock
unixsocketperm 770
requirepass STARKES_REDIS_PASSWORT
EOF

sudo usermod -aG redis www-data
sudo systemctl restart redis-server

Verifizieren: ls -la /run/redis/ zeigt den Socket redis-server.sock mit den Rechten srwxrwx---.

Schritt 5: Nextcloud herunterladen und entpacken

Laden Sie latest.zip mit SHA256-Prüfsumme herunter und prüfen Sie sie vor dem Entpacken. Das Data-Verzeichnis muss außerhalb des Nginx-Webroot liegen, sonst wären Nutzerdateien direkt über HTTP abrufbar.

cd /tmp
wget https://download.nextcloud.com/server/releases/latest.zip
wget https://download.nextcloud.com/server/releases/latest.zip.sha256
sha256sum -c latest.zip.sha256

unzip -q latest.zip
sudo mv nextcloud /var/www/nextcloud
sudo chown -R www-data:www-data /var/www/nextcloud

# Data-Verzeichnis AUSSERHALB des Webroot
sudo mkdir -p /var/nextcloud-data
sudo chown -R www-data:www-data /var/nextcloud-data
sudo chmod 750 /var/nextcloud-data

Verifizieren: sha256sum -c latest.zip.sha256 muss mit latest.zip: OK abschließen. Danach: ls /var/www/nextcloud/ zeigt index.php, occ und weitere Dateien.

Schritt 6: Nginx-Konfiguration anlegen

Die Konfiguration sperrt Verzeichnisse wie /config und /data mit return 404, setzt die Security-Header, gleicht client_max_body_size an das PHP-Limit an und liefert .mjs-Dateien mit dem richtigen MIME-Typ aus. Ersetzen Sie cloud.example.com überall durch Ihre Domain. Aktivieren Sie die Seite erst in Schritt 7, weil die Zertifikatsdateien noch fehlen und nginx -t sonst abbricht.

sudo tee /etc/nginx/sites-available/nextcloud.conf <<'NGINX'
upstream php-handler {
    server unix:/run/php/php8.3-fpm.sock;
}

server {
    listen 80;
    listen [::]:80;
    server_name cloud.example.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    listen [::]:443 ssl;
    http2 on;
    server_name cloud.example.com;

    ssl_certificate     /etc/letsencrypt/live/cloud.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/cloud.example.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;

    root /var/www/nextcloud;
    index index.php index.html;

    client_max_body_size 16G;
    fastcgi_buffers 64 4K;
    gzip on;
    gzip_vary on;
    gzip_comp_level 4;
    gzip_types text/plain text/css application/json application/javascript text/xml application/xml;

    add_header Strict-Transport-Security "max-age=15552000; includeSubDomains" always;
    add_header Referrer-Policy "no-referrer" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-Download-Options "noopen" always;
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Permitted-Cross-Domain-Policies "none" always;
    add_header X-Robots-Tag "noindex, nofollow" always;
    fastcgi_hide_header X-Powered-By;

    include mime.types;
    types {
        text/javascript mjs;
        application/wasm wasm;
    }

    location ~ /\. { deny all; }
    location ~ ^/(?:build|tests|config|lib|3rdparty|templates|data)(?:$|/) { return 404; }
    location ~ ^/(?:\.|autotest|occ|issue|indie|db_|console) { return 404; }

    location = /.well-known/carddav { return 301 /remote.php/dav; }
    location = /.well-known/caldav  { return 301 /remote.php/dav; }
    location /.well-known/acme-challenge { try_files $uri $uri/ =404; }
    location /.well-known/pki-validation { try_files $uri $uri/ =404; }

    location / {
        rewrite ^ /index.php;
    }

    location ~ ^/(?:index|remote|public|cron|core/ajax/update|status|ocs/v[12]|updater/.+|oc[ms]-provider/.+)\.php(?:$|/) {
        fastcgi_split_path_info ^(.+?\.php)(/.*)$;
        set $path_info $fastcgi_path_info;
        try_files $fastcgi_script_name =404;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $path_info;
        fastcgi_param modHeadersAvailable true;
        fastcgi_param front_controller_active true;
        fastcgi_pass php-handler;
        fastcgi_intercept_errors on;
        fastcgi_request_buffering off;
        fastcgi_max_temp_file_size 0;
    }

    location ~ \.(?:css|js|mjs|woff2?|svg|gif|map|png|html|ttf|ico|jpg|jpeg|webp|wasm|tflite)$ {
        try_files $uri /index.php$request_uri;
        expires 6M;
        access_log off;
    }
}
NGINX

Verifizieren: grep -c cloud.example.com /etc/nginx/sites-available/nextcloud.conf liefert 0, wenn Sie alle Platzhalter ersetzt haben; grep server_name zeigt zweimal Ihre Domain.

Schritt 7: TLS-Zertifikat mit Let’s Encrypt beziehen

Certbot bezieht das Zertifikat über die Standardseite auf Port 80 (aus dem Internet erreichbar), danach aktivieren Sie die Nextcloud-Seite. Die Erneuerung übernimmt certbot.timer.

sudo certbot certonly --nginx -d cloud.example.com \
  --non-interactive --agree-tos -m admin@example.com

sudo ln -s /etc/nginx/sites-available/nextcloud.conf \
           /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx

Verifizieren: curl -I https://cloud.example.com liefert HTTP-Statuscode 200 oder 302, der Strict-Transport-Security-Header ist gesetzt.

Schritt 8: Nextcloud per CLI installieren

Ersetzen Sie alle Platzhalter durch Ihre Werte.

cd /var/www/nextcloud
sudo -u www-data php occ maintenance:install \
  --database='mysql' \
  --database-name='nextcloud' \
  --database-user='nc_user' \
  --database-pass='STARKES_DB_PASSWORT' \
  --admin-user='admin' \
  --admin-pass='STARKES_ADMIN_PASSWORT' \
  --admin-email='admin@example.com' \
  --data-dir='/var/nextcloud-data'

Verifizieren: Die Ausgabe endet mit Nextcloud was successfully installed. Außerdem existiert jetzt /var/www/nextcloud/config/config.php.

Schritt 9: config.php nach der Installation anpassen

Nach der Installation ist nur localhost als vertrauenswürdige Domain eingetragen. Hier setzen Sie außerdem den Cache (APCu lokal, Redis für Locking und verteilten Cache) und das Wartungsfenster.

Caching-Strategie im Überblick

Setzen Sie alle Werte über occ config:system:set:

sudo -u www-data php occ config:system:set trusted_domains 0 --value='cloud.example.com'
sudo -u www-data php occ config:system:set overwrite.cli.url --value='https://cloud.example.com'
sudo -u www-data php occ config:system:set default_phone_region --value='DE'
sudo -u www-data php occ config:system:set memcache.local --value='\OC\Memcache\APCu'
sudo -u www-data php occ config:system:set memcache.locking --value='\OC\Memcache\Redis'
sudo -u www-data php occ config:system:set memcache.distributed --value='\OC\Memcache\Redis'
sudo -u www-data php occ config:system:set redis host --value='/run/redis/redis-server.sock'
sudo -u www-data php occ config:system:set redis port --value=0 --type=integer
sudo -u www-data php occ config:system:set redis password --value='STARKES_REDIS_PASSWORT'
sudo -u www-data php occ config:system:set redis timeout --value=1.5 --type=float
sudo -u www-data php occ config:system:set maintenance_window_start --value=1 --type=integer

maintenance_window_start=1 legt aufwendige Hintergrundaufgaben auf 01:00 bis 05:00 Uhr UTC.

Verifizieren: sudo -u www-data php occ config:system:get memcache.locking gibt \OC\Memcache\Redis aus, sudo -u www-data php occ status zeigt installed: true ohne Redis-Fehlermeldung.

Schritt 10: Systemd-Timer für Hintergrundaufgaben

Ein systemd-Timer protokolliert jeden Lauf im Journal. Erstellen Sie Service- und Timer-Unit:

sudo tee /etc/systemd/system/nextcloudcron.service <<'EOF'
[Unit]
Description=Nextcloud cron.php
After=network.target

[Service]
User=www-data
ExecStart=/usr/bin/php -f /var/www/nextcloud/cron.php
KillMode=process
EOF

sudo tee /etc/systemd/system/nextcloudcron.timer <<'EOF'
[Unit]
Description=Nextcloud cron.php alle 5 Minuten

[Timer]
OnBootSec=5min
OnUnitActiveSec=5min
Unit=nextcloudcron.service

[Install]
WantedBy=timers.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable --now nextcloudcron.timer

# Nextcloud auf systemd-Cron umstellen
sudo -u www-data php /var/www/nextcloud/occ background:cron

Verifizieren: systemctl list-timers nextcloudcron.timer: Der Timer ist aktiv und zeigt die nächste geplante Ausführung.

Schritt 11: Datenbank-Indizes, Reparatur und Firewall

Diese drei occ-Befehle ergänzen fehlende Indizes, reparieren Metadaten und stellen den File-Cache auf 64-Bit-IDs um.

sudo -u www-data php /var/www/nextcloud/occ db:add-missing-indices
sudo -u www-data php /var/www/nextcloud/occ maintenance:repair --include-expensive
sudo -u www-data php /var/www/nextcloud/occ db:convert-filecache-bigint

Firewall freischalten. Geben Sie SSH vor dem Aktivieren frei, sonst sperren Sie sich auf einem entfernten Server aus:

sudo ufw allow OpenSSH
sudo ufw allow 'Nginx Full'
sudo ufw enable

Verifizieren: https://cloud.example.com zeigt im Browser den Nextcloud-Login. Unter Verwaltung → Überblick erscheinen keine roten Warnungen.

Troubleshooting / Typische Fehler

Fehler 413 „Request Entity Too Large“ bei Uploads

client_max_body_size (Nginx) sowie upload_max_filesize und post_max_size (PHP) müssen übereinstimmen, hier 16G. Nach Änderung: sudo systemctl reload nginx php8.3-fpm.

Zugriff mit der eigenen Domain schlägt fehl

Nur localhost ist als Trusted Domain eingetragen. Lösung: Befehl trusted_domains aus Schritt 9 ausführen.

Nextcloud startet nicht, kryptische DI-Fehler

Ursache meist: opcache.save_comments=0 oder fehlender CLI-Symlink der INI-Datei. Prüfen Sie mit php8.3 -r "echo ini_get('opcache.save_comments');", die Ausgabe muss 1 sein.

Redis-Verbindungsfehler in den Nextcloud-Logs

Ursachen: www-data fehlt in der Gruppe redis (groups www-data), der Socket-Pfad in config.php weicht von redis.conf ab, oder das Redis-Passwort stimmt nicht. Nach einer Gruppenänderung PHP-FPM neu starten.

PHP-FPM Socket nicht gefunden nach PHP-Versionsupgrade

Nach einem Wechsel auf PHP 8.4 lautet der Socket /run/php/php8.4-fpm.sock. Passen Sie den upstream-Block an und führen Sie sudo nginx -t && sudo systemctl reload nginx aus.

Falsche Dateirechte nach Extraktion

Fehlt nach dem Entpacken als root das chown, bricht die Installation mit Berechtigungsfehlern ab. Lösung: sudo chown -R www-data:www-data /var/www/nextcloud /var/nextcloud-data.

Häufige Fragen

Warum APCu für memcache.local und nicht Redis?

APCu arbeitet im Speicher von PHP-FPM ohne Socket-Umweg und ist auf einem Einzelserver schneller. Daher APCu für .local, Redis für .locking und .distributed.

Wie aktualisieren Sie Nextcloud auf eine neue Version?

Per Web-Updater (Verwaltung → Überblick) oder per CLI: sudo -u www-data php /var/www/nextcloud/updater/updater.phar, danach sudo -u www-data php occ upgrade. Legen Sie vorher ein Backup von /var/www/nextcloud, /var/nextcloud-data und einen mysqldump an. Major-Versionen lassen sich nicht überspringen.

Wie überprüfen Sie die Konfigurationsqualität?

Rufen Sie scan.nextcloud.com mit Ihrer Domain auf; dort werden Sicherheitsheader und HSTS bewertet. Verwaltung → Überblick zeigt fehlende PHP-Erweiterungen, Cron- und Cache-Probleme.

Können Sie PostgreSQL statt MariaDB verwenden?

Ja, Nextcloud unterstützt PostgreSQL 14 bis 18. Im occ maintenance:install-Befehl verwenden Sie dann --database='pgsql' statt 'mysql' und installieren php8.3-pgsql statt php8.3-mysql.

Wie richten Sie regelmäßige Backups ein?

mysqldump nextcloud täglich per Timer oder cron, dazu /var/nextcloud-data und config/config.php versioniert sichern, etwa mit Restic. Die ausführliche 3-2-1-Backup-Anleitung beschreibt das Vorgehen.

Fazit

Eine native Nextcloud-Installation auf dem LEMP-Stack ist aufwendiger als das Docker-AIO-Image, gibt Ihnen aber direkten Zugriff auf jede Komponente und eine saubere systemd-Integration. Nginx, MariaDB, PHP 8.3-FPM, Redis über Unix-Socket und APCu lassen sich mit Linux-Bordmitteln verwalten. Den Preis tragen Sie bei Updates: PHP-, MariaDB- und Nextcloud-Versionen müssen Sie selbst aufeinander abstimmen.

Weiterführende Anleitungen und Quellen

1. Nextcloud mit Docker einrichten (All-in-One): die eigene Cloud – der schnellere Alternativweg
2. WordPress nativ auf Ubuntu installieren (LAMP ohne Docker) – analoges Vorgehen für den LAMP-Stack
3. VPS absichern und härten: UFW, SSH-Keys und Fail2Ban – Pflichtlektüre vor jedem Produktivbetrieb
4. 3-2-1-Backup-Strategie umsetzen – Backups für Nextcloud-Daten und Datenbank
5. Nextcloud Admin Manual: Source Installation (offiziell)
6. Nextcloud Admin Manual: Nginx-Konfiguration (offiziell)
7. Nextcloud Admin Manual: Caching-Konfiguration (offiziell)