Nextcloud auf VPS installieren: Anleitung mit Docker

Einführung

Du möchtest deine eigene Cloud einrichten? In dieser Schritt-für-Schritt-Anleitung zeige ich dir, wie du Nextcloud auf einem VPS (Virtual Private Server) installierst. Ich habe dazu auch ein Video auf Youtube erstellt, dass dich durch den Prozess führt:

Nextcloud auf einem VPS installieren (Link zu Youtube)

Im Folgenden findet ihr die Schritte kurz dargestellt, die im Video gezeigt werden.

Nextcloud Server: Eine Plattform für Datensouveränität

Nextcloud ist eine Open-Source-Software für Self-Hosting von Dateien und Daten, die eine Vielzahl von Funktionen wie Dateisynchronisierung, Kalender, Kontakte, E-Mail und mehr bietet. Es kann als Alternative zu Cloud-Diensten von Drittanbietern wie Dropbox oder Google Drive verwendet werden.

Entwicklungsverlauf

Ein kleiner Überblick über die Entwicklung von Nextcloud:

Mehr als nur Dateispeicher

Nextcloud ist wie eine digitale Zentrale, die dir nicht nur das Speichern von Dateien erleichtert, sondern auch eine ganze Palette anderer Funktionen bietet.

• Dateisynchronisation und -freigabe: Nextcloud ermöglicht die Synchronisation von Dateien zwischen verschiedenen Geräten und die einfache Freigabe von Dateien mit anderen Nutzern.
• Zusammenarbeit an Dokumenten: Integrierte Office-Suite ermöglicht die gemeinsame Bearbeitung von Dokumenten in Echtzeit.
• Kalender, Kontakte und E-Mail: Nextcloud bietet Funktionen zur Verwaltung von Kalendern, Kontakten und E-Mails.
• Vielzahl von Apps: Ein App Store bietet eine große Auswahl an zusätzlichen Funktionen, die die Funktionalität des Servers erweitern.

Gründe für die Installation auf einem VPS

Die Installation auf einem VPS ist aus mehreren Gründen besonders praktisch.

Zentraler Zugriff

Ein VPS erlaubt es euch, von beliebigen Orten mit Internetverbindung auf eure Dokumente zuzugreifen. So seid ihr nicht auf das lokale Netzwerk beschränkt. Das ermöglicht den Zugriff von überall.

Datensicherheit

Deine Daten sind in professionellen Rechenzentren sicher aufgehoben - geschützt vor Stromausfällen, Bränden oder anderen physischen Risiken.

Skalierbarkeit

Mit einem VPS könnt ihr die Serverressourcen anpassen, je nachdem wie eure Anforderungen wachsen – das bedeutet mehr Speicherplatz oder Rechenleistung bei Bedarf.

Professionelles Hosting-Umfeld

Ein VPS bietet ein professionelles Hosting-Umfeld mit dedizierten IP-Adressen und einer schnellen Internetverbindung.

Diese Aspekte machen die Verwendung eines VPS für Paperless zu einer attraktiven Option für Unternehmen und Privatpersonen, die nach einer effizienten und sicheren Lösung für ihr Dokumentenmanagement suchen.

Voraussetzungen

• Computer mit Visual Studio Code: Für die Arbeit auf dem Server.

• Ein Server, auf dem Docker installiert werden kann (das ist eine Software, die uns die Installation enorm erleichtert)

• Domain mit der Option, Subdomains zu erstellen: Für den Zugriff auf Nextcloud.

• Mail-Server mit SMTP-Unterstützung: Optional für Benachrichtigungen.

Server mieten

Als erstes benötigen wir einen Server. Ich empfehle euch, einen VPS bei einem Anbieter eurer Wahl zu mieten. Ich persönlich nutze Netcup. Hier wird eine einfache und schnelle Möglichkeit geboten, einen VPS zu mieten.

Ihr könnt auch hier nach Gutscheinen schauen.

Die Kosten fangen momentan bei 3,99€ pro Monat an, zusätzlich eine nervige neu eingeführte Einrichtungsgebühr von 5€. Irgendwie finde ich das für VPS kontraproduktiv, da sie eine Möglichkeit bieten sollten, schnell und flexibel zu starten. Die Root-Server (ab 9,81€ pro Monat) bieten durch die dedizierten CPU-Kerne eine deutlich bessere Performance.

Zukünftig werde ich wohl öfter zu Hetzner greifen, um etwas zu testen, da sie keine Einrichtungsgebühr haben.

Wenn ihr einen VPS gemietet habt, findet ihr die IP-Adresse im CCP. Ansonsten sollte diese auch in der E-Mail stehen.

Domain mieten

Als nächstes benötigen wir eine Domain. Auch hier solltet ihr einen Anbieter eurer Wahl nutzen. Domain und Server müssen sich nicht beim selben Anbieter befinden. Dennoch nutze ich auch dafür Netcup. An dieser Stelle habt ihr zwei Möglichkeiten:

1. Zusätzliche Domain mieten
2. Webhosting-Paket mit Inklusiv-Domain mieten

Die zusätzliche Domain hat den Vorteil, dass sie günstiger ist (momentan 5,04€ pro Jahr für eine .de-Domain). Die Webhosting-Pakete (ab 2,17€ pro Monat) bieten euch jedoch zusätzliche Funktionen, wie z.B. E-Mail-Postfächer und Webspace.

Domain konfigurieren

Nachdem ihr die Domain gemietet habt, müsst ihr sie konfigurieren. Dazu loggt ihr euch in das CCP ein und klickt auf “Domains”. Dort wählt ihr eure Domain aus und klickt auf “DNS”.

Dort fügt ihr zwei neue A-Records hinzu. Der Host ist ”@” (für die Hauptdomain) und ”*” (für alle Subdomains). Als Ziel tragt ihr die IP-Adresse eures Servers ein.

Wenn ihr das Webhosting-Paket habt, löscht zunächst die Einträge für ”@” und ”*” sowohl bei den A-Records als auch bei den AAAA-Records. Der Rest muss so bleiben, wie er ist, damit die E-Mail-Postfächer und der Webspace funktionieren.

Jetzt müsst ihr warten, bis die DNS-Änderungen überall propagiert sind. Das kann bis zu 24 Stunden dauern. Ihr könnt es im Terminal mit ping eure-domain.de testen. Wenn die IP-Adresse eures Servers zurückkommt, ist die Domain bereit.

Server neu installieren

Ihr könnt euch nun im Control Panel Server einloggen und dort euren Server auswählen. Unter “Medien” und dann “Images” könnt ihr ein neues Betriebssystem auswählen. Ich empfehle Ubuntu 24.04 LTS (Updates bis April 2029).

Während der Installation solltet ihr einen Benutzer erstellen.

SSH-Verbindung herstellen

Nachdem die Installation abgeschlossen ist, könnt ihr euch per SSH mit eurem Server verbinden. Dazu nutzen wir VSCode. Installiert euch das Remote-SSH-Plugin und klickt auf das Symbol in der linken unteren Ecke. Dort könnt ihr “Remote-SSH: Connect to Host…” auswählen und eure SSH-Verbindung konfigurieren. Der Befehl ssh benutzer@ip sollte euch auch verbinden.

Wenn die Verbindung steht, könnt ihr den Home-Ordner eures Benutzers im Explorer öffnen und dort eure Dateien bearbeiten. Außerdem könnt ihr das Terminal nutzen, um Befehle auszuführen:

# System-Pakete auf den neuesten Stand bringen
sudo apt update     # Paketlisten aktualisieren
sudo apt upgrade    # Installierte Pakete upgraden

Docker und Docker-Compose installieren

Als nächstes installieren wir Docker. Dazu führen wir folgende Befehle aus:

# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Caddy vorbereiten

Wir nutzen Caddy als Reverse-Proxy, um Nextcloud über HTTPS erreichbar zu machen.

Wir brauchen erst ein Netzwerk, um Caddy mit den anderen Containern zu verbinden:

sudo docker network create proxy

Nun erstellen wir einen Ordner für Caddy und legen die Dateien an:

mkdir -p caddy/{data,config}
touch caddy/docker-compose.yml caddy/Caddyfile

In der docker-compose.yml-Datei tragen wir folgendes ein:

networks:
    proxy:
        external: true
        name: proxy

services:
    caddy:
        image: caddy:2
        container_name: caddy
        restart: unless-stopped
        ports:
            - 80:80
            - 443:443
        volumes:
            - ./data:/data
            - ./config:/config
            - ./Caddyfile:/etc/caddy/Caddyfile:ro
        networks:
            - proxy

Nextcloud installieren

Perfekt! Die Grundlagen stehen. Lass uns jetzt mit der eigentlichen Nextcloud-Installation loslegen. Dazu erstellen wir einen neuen Ordner und legen die Dateien an:

mkdir -p nextcloud/data
touch nextcloud/docker-compose.yml

In die docker-compose.yml-Datei tragen wir folgendes ein:

networks:
    proxy:
        external: true
        name: proxy

services:
    nextcloud:
        container_name: nextcloud
        image: nextcloud
        restart: always
        volumes:
            - ./data:/var/www/html/
        networks:
            - proxy

Nun kann der Container gestartet werden:

sudo docker compose -f nextcloud/docker-compose.yml up -d

Nextcloud Proxy konfigurieren

Zum Schluss tragen wir die Konfiguration für Nextcloud in das Caddyfile ein:

{
	acme_ca https://acme-v02.api.letsencrypt.org/directory
	email mail@deployn.de
}

nextcloud.pixan.de {
	reverse_proxy nextcloud:80
}

Und wir starten Caddy:

sudo docker compose -f caddy/docker-compose.yml up -d

Nextcloud konfigurieren

Wir können uns nun unter der Domain einloggen und Nextcloud konfigurieren. Dazu legen wir einen Admin-Benutzer an. Jetzt könnten wir andere Benutzer hinzufügen und Dateien hochladen. Aber das wollen wir an dieser Stelle nicht machen, sondern die Installation optimieren.

💡 Häufige Probleme

• Wenn die Domain nicht erreichbar ist: DNS-Einträge und Propagation prüfen
• Bei Verbindungsproblemen: Firewall-Regeln kontrollieren
• Falls Nextcloud nicht startet: Container-Logs überprüfen mit docker logs nextcloud

Alias anlegen

Wir werden gleich noch ein paar Mal Nextcloud löschen und neu installieren. Damit wir nicht immer die gleichen Befehle eingeben müssen, legen wir uns ein Alias an. Dazu öffnen wir die .bashrc-Datei und fügen ganz unten folgendes ein:

alias caddy-reload='sudo docker compose -f ~/caddy/docker-compose.yml exec caddy caddy reload --config /etc/caddy/Caddyfile'
alias caddy-down='sudo docker compose -f ~/caddy/docker-compose.yml down'
alias caddy-up='sudo docker compose -f ~/caddy/docker-compose.yml up -d'
alias nc-down='sudo docker compose -f ~/nextcloud/docker-compose.yml down'
alias nc-up='sudo docker compose -f ~/nextcloud/docker-compose.yml up -d'
alias nc-remove='sudo rm -rf ~/nextcloud/data'
alias nc-init='mkdir -p ~/nextcloud/data'

Danach führen wir source ~/.bashrc aus, um die Änderungen zu übernehmen.

nc-down
nc-remove

Nextcloud ist wieder gelöscht und wir können von vorne anfangen.

Datenbank hinzufügen

Wir wollen nicht SQLite nutzen, sondern eine Datenbank hinzufügen, dazu passen wir unsere Aliases an:

alias caddy-reload='sudo docker compose -f ~/caddy/docker-compose.yml exec caddy caddy reload --config /etc/caddy/Caddyfile'
alias caddy-down='sudo docker compose -f ~/caddy/docker-compose.yml down'
alias caddy-up='sudo docker compose -f ~/caddy/docker-compose.yml up -d'
alias nc-down='sudo docker compose -f ~/nextcloud/docker-compose.yml down'
alias nc-up='sudo docker compose -f ~/nextcloud/docker-compose.yml up -d'
alias nc-remove='sudo rm -rf ~/nextcloud/{data,db}'
alias nc-init='mkdir -p ~/nextcloud/{data,db}'

Danach führen wir source ~/.bashrc aus, um die Änderungen zu übernehmen.

nc-init

Nun müssen wir die Datenbank hinzufügen. Dazu updaten wir die docker-compose.yml-Datei im nextcloud-Ordner:

networks:
    proxy:
        external: true
        name: proxy
    internal:
        external: false

services:
    nextcloud:
        container_name: nextcloud
        image: nextcloud
        restart: always
        volumes:
            - ./data:/var/www/html/
        networks:
            - proxy
            - internal
        environment:
            - MYSQL_HOST=db
            - MYSQL_DATABASE=nextcloud
            - MYSQL_USER=nextcloud
            - MYSQL_PASSWORD=nextcloud_password
        depends_on:
            - db
    db:
        container_name: nextcloud-db
        image: mariadb:11.4
        restart: unless-stopped
        volumes:
            - ./db:/var/lib/mysql
        networks:
            - internal
        environment:
            - MYSQL_ROOT_PASSWORD=root_password
            - MYSQL_DATABASE=nextcloud
            - MYSQL_USER=nextcloud
            - MYSQL_PASSWORD=nextcloud_password

Danach können wir die Container starten:

nc-up

Redis hinzufügen

Wir wollen noch Redis hinzufügen, wir löschen alles nochmal

nc-down
nc-remove

Dann ändern wir die Aliases:

alias caddy-reload='sudo docker compose -f ~/caddy/docker-compose.yml exec caddy caddy reload --config /etc/caddy/Caddyfile'
alias caddy-down='sudo docker compose -f ~/caddy/docker-compose.yml down'
alias caddy-up='sudo docker compose -f ~/caddy/docker-compose.yml up -d'
alias nc-down='sudo docker compose -f ~/nextcloud/docker-compose.yml down'
alias nc-up='sudo docker compose -f ~/nextcloud/docker-compose.yml up -d'
alias nc-remove='sudo rm -rf ~/nextcloud/{data,db,redis}'
alias nc-init='mkdir -p ~/nextcloud/{data,db,redis}'

Danach führen wir source ~/.bashrc aus, um die Änderungen zu übernehmen.

nc-init

Nun müssen wir Redis hinzufügen. Wir benötigen unsere UserID und GruppenID:

id

Danach updaten wir die docker-compose.yml-Datei im nextcloud-Ordner:

networks:
    proxy:
        external: true
        name: proxy
    internal:
        external: false

services:
    nextcloud:
        container_name: nextcloud
        image: nextcloud
        restart: always
        volumes:
            - ./data:/var/www/html/
        networks:
            - proxy
            - internal
        environment:
            - MYSQL_HOST=db
            - MYSQL_DATABASE=nextcloud
            - MYSQL_USER=nextcloud
            - MYSQL_PASSWORD=nextcloud_password
            - REDIS_HOST=redis
        depends_on:
            - db
            - redis
    db:
        container_name: nextcloud-db
        image: mariadb:11.4
        restart: unless-stopped
        volumes:
            - ./db:/var/lib/mysql
        networks:
            - internal
        environment:
            - MYSQL_ROOT_PASSWORD=root_password
            - MYSQL_DATABASE=nextcloud
            - MYSQL_USER=nextcloud
            - MYSQL_PASSWORD=nextcloud_password
    redis:
        container_name: nextcloud-redis
        image: redis:7
        restart: unless-stopped
        cap_add:
            - SYS_RESOURCE
        user: "1000:1000"
        volumes:
            - ./redis:/data
        networks:
            - internal

Danach können wir die Container starten:

nc-up

Weitere Optimierungen

Wir versuchen die Installation weiter zu verbessern. Wir fangen nochmal von vorne an:

nc-down
nc-remove

Dann ändern wir das Caddyfile:

{
  # General Options
  log { 
    level ERROR
  } 

  # TLS Options
  auto_https disable_redirects
  email mail@deployn.de
  acme_ca https://acme-v02.api.letsencrypt.org/directory

  # Server Options
  servers { 
    protocols h1 h2 h2c
  } 
}

http://nextcloud.pixan.de {
  redir https://{host}{uri} permanent
} 

https://nextcloud.pixan.de {

  header {
    Strict-Transport-Security "max-age=15552000; includeSubDomains; preload"
    X-Forwarded-Proto "https"
    X-Forwarded-Host {host}
    X-Forwarded-For {remote}
    X-Real-IP {remote}
  } 

  redir /.well-known/carddav /remote.php/dav/ 301
  redir /.well-known/caldav /remote.php/dav/ 301

  # Respond Handlers
  reverse_proxy nextcloud:80
}

sudo docker network inspect proxy

Und die docker-compose.yml-Datei im nextcloud-Ordner:

networks:
    proxy:
        external: true
        name: proxy
    internal:
        external: false

services:
    nextcloud:
        container_name: nextcloud
        image: nextcloud
        restart: always
        volumes:
            - ./data:/var/www/html/
        networks:
            - proxy
            - internal
        environment:
            - MYSQL_HOST=db
            - MYSQL_DATABASE=nextcloud
            - MYSQL_USER=nextcloud
            - MYSQL_PASSWORD=nextcloud_password
            - REDIS_HOST=redis
            - NEXTCLOUD_TRUSTED_DOMAINS=nextcloud.pixan.de
            - PHP_UPLOAD_LIMIT=10G
            - OVERWRITEPROTOCOL=https
            - OVERWRITEHOST=nextcloud.pixan.de
            - TRUSTED_PROXIES=172.18.0.0/12
            - APACHE_DISABLE_REWRITE_IP=1
        depends_on:
            - db
            - redis
    cron:
        container_name: nextcloud-cron
        image: nextcloud
        restart: unless-stopped
        volumes:
            - ./data:/var/www/html/
        networks:
            - internal
        entrypoint: /cron.sh
        depends_on:
            - db
            - redis
    db:
        container_name: nextcloud-db
        image: mariadb:11.4
        restart: unless-stopped
        command: --transaction-isolation=READ-COMMITTED --log-bin=binlog --binlog-format=ROW
        volumes:
            - ./db:/var/lib/mysql
        networks:
            - internal
        environment:
            - MYSQL_ROOT_PASSWORD=root_password
            - MYSQL_DATABASE=nextcloud
            - MYSQL_USER=nextcloud
            - MYSQL_PASSWORD=nextcloud_password
    redis:
        container_name: nextcloud-redis
        image: redis:7
        restart: unless-stopped
        cap_add:
            - SYS_RESOURCE
        user: "1000:1000"
        volumes:
            - ./redis:/data
        networks:
            - internal

sudo docker compose -f nextcloud/docker-compose.yml exec -u 33 nextcloud bash

php occ db:add-missing-indices
php occ maintenance:repair --include-expensive
php occ config:system:set maintenance_window_start --type=integer --value=1

Nextcloud All in One

Wir fangen nochmal von vorne an, diesmal sogar ohne Caddy:

nc-down
nc-remove
caddy-down

sudo docker run \
--init \
--sig-proxy=false \
--name nextcloud-aio-mastercontainer \
--restart always \
--publish 80:80 \
--publish 8080:8080 \
--publish 8443:8443 \
--volume nextcloud_aio_mastercontainer:/mnt/docker-aio-config \
--volume /var/run/docker.sock:/var/run/docker.sock:ro \
nextcloud/all-in-one:latest

Danach https://VPS-IP-Adresse:8080 im Browser öffnen und Nextcloud konfigurieren.

Fazit

Nextcloud auf einem VPS zu installieren ist eine großartige Möglichkeit, um seine eigene Cloud einzurichten. Mit Docker und Caddy ist die Installation einfach und flexibel. Ich hoffe, dieser Blogpost hat euch geholfen, eure eigene Nextcloud-Instanz zu starten. Wenn ihr Fragen oder Anregungen habt, schreibt gerne einen Kommentar.