Nextcloud-Installation mit Docker

Nextcloud hat sich als quelloffene Cloud-Lösung etabliert. Neben den Klienten für Desktop- und Mobilbetriebssysteme umfasst die Software eine Server-Komponente. Wir zeigen, wie sich ein Nextcloud-Server in einer Docker-Umgebung installieren lässt.

Free Cloud Server Trial
Cloud Server kostenlos testen

Dank Startguthaben testen Sie Cloud Server bei IONOS 1 Monat lang kostenlos (oder bis das Guthaben verbraucht ist) und erleben die perfekte Kombination aus Leistung und Sicherheit!

Nextcloud unter Docker installieren

Bei Nextcloud handelt es sich um eine quelloffene Cloud-Lösung, die als Abspaltung aus dem ownCloud-Projekt hervorging. Der Funktionsumfang ist vergleichbar mit proprietären Cloud-Lösungen wie Microsoft 365 oder Google Workspace. Nextcloud synchronisiert Daten wie Kalender und Kontakte zwischen Personen und Geräten. Neben der obligatorischen Datei-Synchronisation sind Funktionen für teaminterne Kollaboration und Kommunikation enthalten. Nextcloud dient auch als Grundlage der seit 2020 im Betrieb befindlichen „Bundescloud“.

Wie bei vergleichbaren Cloud-Lösungen üblich, umfasst Nextcloud eine Server-Komponente sowie Klienten für Desktop- und Mobil-Betriebssysteme. Der Nextcloud-Server verwaltet die Daten und kommuniziert mit den Klienten; ferner wird eine klientenunabhängige Weboberfläche bereitgestellt.

Wir zeigen die Installation eines Nextcloud-Servers auf Ubuntu-Linux. Dabei nutzen wir Docker Compose und beziehen uns auf eine Installation auf Cloud-Infrastruktur. Es ist auch möglich, den Server auf eigener Hardware zu installieren und Nextcloud beispielsweise auf einem Raspberry Pi einzurichten.

Tipp

Nextcloud und ownCloud haben viele Gemeinsamkeiten. In unserem Ratgeber-Artikel ownCloud vs. Nextcloud stellen wir Ihnen auch die Unterschiede vor.

Architektur von Nextcloud auf Docker

Schauen wir uns zunächst an, welche Komponenten Nextcloud-Server unter Docker umfasst und wie diese zusammenhängen. Neben der eigentlichen Nextcloud-Software kommen drei weitere, containerisierte Dienste zum Einsatz. Um den Container-Verbund zu provisionieren und als Einheit zu steuern, nutzen wir das Docker-Tool Compose. Hier ein Überblick der einzelnen Dienste:

  1. Nginx Reverse Proxy: wird benötigt, um verschlüsselte HTTPS-Verbindungen beim Zugriff auf Nextcloud zu realisieren
  2. Let’s Encrypt: wird genutzt, um SSL-Zertifikate automatisiert einzurichten
  3. MariaDB: dient zur Speicherung der bei der Nextcloud-Nutzung serverseitig anfallenden Daten
  4. Nextcloud-Server: stellt die eigentliche Nextcloud-Funktionalität zur Verfügung; kommuniziert mit den Nextcloud-Klienten und hostet die Weboberfläche

Installation von Nextcloud-Server vorbereiten

Auf einem frisch aufgesetzten Ubuntu-Linux müssen wir zunächst die Docker-Engine und Docker Compose installieren. Die Docker-Engine stellt die Container-Kernfunktionalitäten bereit, während Docker Compose die Verwaltung zusammengehöriger Container-Verbünde ermöglicht. Sofern die Docker-Engine und Docker Compose bereits installiert sind, können Sie diesen Abschnitt überspringen.

Docker-Engine auf Ubuntu installieren

Wir zeigen hier die Installation unter Ubuntu-Linux und beziehen uns dabei auf die offizielle Installationsanleitung. Für andere Linux-Distributionen finden sich entsprechende Anleitungen auf der Docker-Website. Beginnen wir nun mit der Installation der Docker-Engine:

  1. Eventuell vorhandene Docker-Installation entfernen:
sudo apt-get remove docker docker-engine docker.io containerd runc
  1. Installer auf den neuesten Stand bringen:
sudo apt-get update
  1. Repositorys vorbereiten:
sudo apt-get install \
ca-certificates \
curl \
gnupg \
lsb-release
  1. Dockers offiziellen GPG-Schlüssel hinzufügen:
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
  1. Stabiles Docker-Repository einrichten:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
  1. Repositorys auf den neuesten Stand bringen:
sudo apt-get update
  1. Docker-Engine samt Abhängigkeiten installieren:
sudo apt-get install docker-ce docker-ce-cli containerd.io
  1. Zu guter Letzt führen wir zu Testzwecken den „Hello World“-Container aus.

Wenn die Docker-Engine korrekt installiert wurde, wird der Container ausgeführt und eine entsprechende Nachricht ausgegeben.

sudo docker run hello-world

Docker Compose auf Ubuntu installieren

Wenden wir uns als nächstes der Installation von Docker Compose zu. Der Installationsprozess ist einfacher und weniger umfangreich als die Installation der Docker-Engine. Im Einzelnen benötigen wir die folgenden Schritte:

  1. Ubuntus Universe-Repository aktivieren:
sudo add-apt-repository universe
  1. Paketverwaltung auf den neuesten Stand bringen:
sudo apt update
  1. Docker Compose installieren:
sudo apt install docker-compose
  1. Überprüfen, ob Docker Compose erfolgreich installiert wurde:
docker-compose --version

Wird eine Versionsnummer angezeigt, wurde Docker Compose erfolgreich installiert.

Installation von Nextcloud-Server durchführen

Sobald die Docker-Engine und Docker Compose installiert sind, legen wir mit der eigentlichen Nextcloud-Installation los. Wir werden einzelne Docker-Container für die verschiedenen Dienste konfigurieren. Zur Konfiguration der Container und der benötigten Docker-Volumen und Docker-Netzwerke kommen zwei Konfigurationsdateien zum Einsatz:

Datei Erklärung
docker-compose.yaml Docker-Compose-Anweisungen im YAML-Format für den Aufbau der Multi-Container Anwendung
.env Textdatei mit Umgebungsvariablen; pro Zeile eine Variablendefinition

Wie erwähnt dient Docker Compose zur Verwaltung von Multi-Container-Anwendungen. Dazu kommen Docker-Compose-Anweisungen zum Einsatz, die definieren, wie die Anwendung aufgebaut wird und wie die einzelnen Komponenten miteinander interagieren. Docker-Compose-Anweisungen beschreiben die einzelnen Services, Docker-Elemente und Einstellungen und werden in der Sprache YAML („Yet Another Markup Language“, dt.: „noch eine weitere Markup-Sprache“) geschrieben. Wir bauen die dabei zum Einsatz kommende Datei docker-compose.yaml schrittweise auf.

Neben der docker-compose.yaml wird eine weitere Datei benötigt. Diese enthält Umgebungsvariablen, die in die Docker-Compose-Anweisungen eingebunden werden. Standardmäßig legt man die Umgebungsvariablen samt Werten in einer .env-Datei im Projektordner ab. Die .env-Datei wird nicht in Versionskontrollsystem aufgenommen; dies schützt sensible Daten wie Passwörter vor versehentlicher Offenbarung.

Die Nutzung einer .env-Datei macht es trivial, verschiedene Einstellungen für unterschiedliche Anwendungsumgebungen zu definieren. Um beispielsweise unterschiedliche Einstellungen für eine Live-Site und eine Staging-Site zu nutzen, ändert man lediglich die jeweilige .env-Datei.

Für Nextcloud-Server benötigte Strukturen anlegen

Um mit der Installation von Nextcloud-Server zu beginnen, benötigen wir eine Handvoll an Strukturen. Diese legen wir mit den folgenden Schritten an:

  1. Projekt-Ordner anlegen. Wir erstellen den Ordner nextcloud-docker im Heimverzeichnis des Nutzers:
mkdir ~/nextcloud-docker/
  1. Dateien anlegen. Wir erzeugen die Dateien docker-compose.yaml und .env im Projekt-Ordner:
touch ~/nextcloud-docker/docker-compose.yaml
touch ~/nextcloud-docker/.env
  1. Docker-Netzwerk erzeugen. Wir nutzen den docker-Befehl, um ein neues Netzwerk anzulegen. Die vier Container kommunizieren innerhalb des Netzwerks.
docker network create nextcloud_network

Haben wir die Strukturen angelegt, fahren wir mit der Installation von Nextcloud-Server fort.

Reverse Proxy für Nextcloud-Server konfigurieren

Wir beginnen die Installation von Nextcloud-Server mit der Konfiguration des Reverse Proxy. Dazu kommt Nginx zum Einsatz. Da wir unsere Anwendung aus Containern zusammensetzen, spielt sich der Großteil der Installations-Routine in der Datei docker-compose.yaml ab. Wir zeigen hier detailliert, wie Sie diese Datei bearbeiten. Folgen Sie denselben Mustern in den nachfolgenden Installationsschritten:

  1. Datei docker-compose.yaml zum Bearbeiten öffnen.

Der folgende Befehl öffnet die noch leere Datei im Editor „Nano“:

nano ~/nextcloud-docker/docker-compose.yaml
  1. Nachfolgenden Code-Block in Nano einfügen und Datei speichern.

Um die Datei zu schließen, verwenden wir die Tastenkombination [Strg] + [X] bzw. [Ctrl] + [X]. Die Frage nach Speichern der Datei beantworten wir mit „y“ für „yes“/„ja“. Die Nutzung des existierenden Dateinamens bestätigen wir mit der [Enter]-Taste.

Alternativ lassen wir den Editor offen und nutzen die Tastenkombination [Strg] + [O] („Write out“, „in Datei schreiben“), um den Editor-Text in die Datei zu schreiben.

version: '3'
services:
    proxy:
        image: jwilder/nginx-proxy:alpine
        labels:
            - "com.github.jrcs.letsencrypt_nginx_proxy_companion.nginx_proxy=true"
        container_name: nextcloud-proxy
        networks:
            - nextcloud_network
        ports:
            - 80:80
            - 443:443
        volumes:
            - ./proxy/conf.d:/etc/nginx/conf.d:rw
            - ./proxy/vhost.d:/etc/nginx/vhost.d:rw
            - ./proxy/html:/usr/share/nginx/html:rw
            - ./proxy/certs:/etc/nginx/certs:ro
            - /etc/localtime:/etc/localtime:ro
            - /var/run/docker.sock:/tmp/docker.sock:ro
        restart: unless-stopped

Was bedeuten nun die einzelnen Einträge? Zunächst weisen wir Docker Compose an, einen neuen Dienst mit Namen proxy anzulegen und dabei ein auf Alpine-Linux basierendes Nginx-Image zu nutzen. Ferner legen wir fest, dass der Reverse Proxy mit den anderen Diensten über das Docker-Netzwerk nextcloud_network kommunizieren soll.

Wir mappen die Standard HTTP- und HTTPS-Ports 80 bzw. 443 vom Host-System auf den Container. So werden die eingehenden Verbindungen über den Proxy geleitet. Als letzten Schritt der Konfiguration legen wir verschiedene Docker-Volumen an und legen fest, dass der Reverse Proxy automatisch neu gestartet wird sofern er nicht explizit gestoppt wurde.

Let’s Encrypt Dienst für Nextcloud-Server konfigurieren

Fahren wir fort mit der Installation von Let’s Encrypt. Dies ermöglicht die verschlüsselte Kommunikation mit dem Nextcloud-Server über HTTPS.

  1. Datei docker-compose.yaml zum Bearbeiten öffnen:
nano ~/nextcloud-docker/docker-compose.yaml
  1. Weiteren Service-Block hinzufügen.

Gehen Sie vor, wie im vorherigen Abschnitt beschrieben, und achten Sie dabei auf die Einrückung: Der Beginn des mit letsencrypt: beginnenden Blocks muss auf derselben Ebene wie proxy: stehen. Dies gilt auch für nachfolgende Service-Blöcke.

letsencrypt:
    image: jrcs/letsencrypt-nginx-proxy-companion
    container_name: nextcloud-letsencrypt
    depends_on:
        - proxy
    networks:
        - nextcloud_network
    volumes:
        - ./proxy/certs:/etc/nginx/certs:rw
        - ./proxy/vhost.d:/etc/nginx/vhost.d:rw
        - ./proxy/html:/usr/share/nginx/html:rw
        - /etc/localtime:/etc/localtime:ro
        - /var/run/docker.sock:/var/run/docker.sock:ro
    restart: unless-stopped

Wiederum definieren wir einen neuen Dienst unter dem Namen letsencrypt, der auf dem Container letsencrypt-nginx-proxy-companion basiert. Dabei legen wir fest, dass der Dienst vom Reverse-Proxy-Dienst abhängig ist und im selben Docker-Netzwerk kommuniziert. Weiterhin definieren wir die für den Datenaustausch benötigten Docker-Volumen. Auch für diesen Dienst legen wir fest, dass er automatisch neu gestartet wird, sofern er nicht explizit gestoppt wurde.

Tipp

Sie wollen eine Profi-Verschlüsselung für Ihre Website? Kaufen Sie ein eigenes SSL-Zertifikat günstig bei IONOS!

MariaDB-Dienst für Nextcloud-Server konfigurieren

Mit der Konfiguration von Reverse Proxy und Let’s Encrypt haben wir die Hälfte der Installation geschafft. Machen wir nun weiter mit der MariaDB-Datenbank. Diese wird benötigt, um die bei der Nextcloud-Nutzung anfallenden Daten zu verwalten. Dabei erfolgte die eigentliche Speicherung per Docker-Volumen außerhalb des Containers.

  1. Datei docker-compose.yaml zum Bearbeiten öffnen:
nano ~/nextcloud-docker/docker-compose.yaml
  1. Weiteren Service-Block einfügen:
db:
    image: mariadb
    container_name: nextcloud-mariadb
    networks:
        - nextcloud_network
    volumes:
        - db:/var/lib/mysql
        - /etc/localtime:/etc/localtime:ro
    environment:
        - MYSQL_ROOT_PASSWORD
        - MYSQL_PASSWORD
        - MYSQL_DATABASE
        - MYSQL_USER
    restart: unless-stopped

Mittlerweile sollten die meisten Einstellungen geläufig sein. Wir definieren einen Dienst db, der auf dem Docker-Image mariadb basiert. Im Anschluss legen wir das bereits für die anderen Dienste zum Einsatz kommende Netzwerk nextcloud_network sowie ein Docker-Volumen für die Speicherung der Daten fest.

Neu in diesem Konfigurations-Block ist die Nutzung von Umgebungsvariablen. Im environment-Abschnitt geben wir die Namen der für die MariaDB benötigten Umgebungsvariablen an. Die eigentlichen Werte werden beim späteren Ausführen von Docker Compose aus der .env-Datei ausgelesen.

Nextcloud-Server-Container konfigurieren

Nun ist es so weit: Wir kommen zur Installation der eigentlichen Nextcloud-Server-Software.

  1. Datei docker-compose.yaml zum Bearbeiten öffnen:
nano ~/nextcloud-docker/docker-compose.yaml
  1. Weiteren Service-Block eintragen:
app:
    image: nextcloud:latest
    container_name: nextcloud-app
    networks:
        - nextcloud_network
    depends_on:
        - letsencrypt
        - proxy
        - db
    volumes:
        - nextcloud:/var/www/html
        - ./app/config:/var/www/html/config
        - ./app/custom_apps:/var/www/html/custom_apps
        - ./app/data:/var/www/html/data
        - ./app/themes:/var/www/html/themes
        - /etc/localtime:/etc/localtime:ro
    environment:
        - VIRTUAL_HOST
        - LETSENCRYPT_HOST
        - LETSENCRYPT_EMAIL
    restart: unless-stopped

Wir legen einen Dienst mit Namen app an, der auf dem Docker-Image nextcloud beruht und im bereits bekannten Netzwerk nextcloud_network kommuniziert. Um sicherzustellen, dass der Nextcloud-Container zuletzt gestartet wird, legen wir die anderen Dienste als Abhängigkeiten fest. Ferner definieren wir die benötigten Docker-Volumen und Umgebungsvariablen.

Nextcloud-Server-Konfiguration abschließen

Um die Nextcloud-Server-Konfiguration abzuschließen, benötigen wir ein paar weitere Einträge in der docker-compose.yaml-Datei. Ferner legen wir die .env-Datei an und füllen diese mit den entsprechenden Werten.

  1. Datei docker-compose.yaml zum Bearbeiten öffnen:
nano ~/nextcloud-docker/docker-compose.yaml
  1. Die nachfolgenden Blöcke einfügen.

Es handelt sich bei diesen nicht um Service-Blöcke; die Einrückung muss auf derselben Ebene wie services: erfolgen.

volumes:
    nextcloud:
    db:
networks:
    nextcloud_network:
  1. Leere .env-Datei zum Bearbeiten öffnen:
nano ~/nextcloud-docker/.env
  1. Umgebungsvariablen samt Werten in .env-Datei schreiben:

Wir kopieren den folgenden Code in das Editor-Fenster und ersetzen vor dem Speichern die <Platzhalter> mit den gewünschten Werten.

# MariaDB
MYSQL_ROOT_PASSWORD=toor
MYSQL_PASSWORD=mysql
MYSQL_DATABASE=nextcloud
MYSQL_USER=nextcloud
# Nextcloud
VIRTUAL_HOST=<your.domain></your.domain>
LETSENCRYPT_HOST=<your.domain></your.domain>
LETSENCRYPT_EMAIL=<your@email></your@email>
  1. Nach dem Speichern zeigen wir den Inhalt der .env-Datei an, um zu überprüfen, dass das Eintragen der Werte geklappt hat:
cat ~/nextcloud-docker/.env

Vollständige Nextcloud-Server-Konfiguration

Bevor wir die erstellte Konfiguration an Docker Compose übergeben und damit die Container erzeugen und starten, überprüfen wir, dass alles Benötigte an Ort und Stelle ist.

  1. Bestehende Konfiguration ausgeben:
cat ~/nextcloud-docker/docker-compose.yaml
  1. Mit unserer Vorlage abgleichen. Die ausgegebene Konfiguration sollte mit dem folgenden Code übereinstimmen:
version: '3'
services:
    proxy:
        image: jwilder/nginx-proxy:alpine
        labels:
            - "com.github.jrcs.letsencrypt_nginx_proxy_companion.nginx_proxy=true"
        container_name: nextcloud-proxy
        networks:
            - nextcloud_network
        ports:
            - 80:80
            - 443:443
        volumes:
            - ./proxy/conf.d:/etc/nginx/conf.d:rw
            - ./proxy/vhost.d:/etc/nginx/vhost.d:rw
            - ./proxy/html:/usr/share/nginx/html:rw
            - ./proxy/certs:/etc/nginx/certs:ro
            - /etc/localtime:/etc/localtime:ro
            - /var/run/docker.sock:/tmp/docker.sock:ro
        restart: unless-stopped
    letsencrypt:
        image: jrcs/letsencrypt-nginx-proxy-companion
        container_name: nextcloud-letsencrypt
        depends_on:
            - proxy
        networks:
            - nextcloud_network
        volumes:
            - ./proxy/certs:/etc/nginx/certs:rw
            - ./proxy/vhost.d:/etc/nginx/vhost.d:rw
            - ./proxy/html:/usr/share/nginx/html:rw
            - /etc/localtime:/etc/localtime:ro
            - /var/run/docker.sock:/var/run/docker.sock:ro
        restart: unless-stopped
    db:
        image: mariadb
        container_name: nextcloud-mariadb
        networks:
            - nextcloud_network
        volumes:
            - db:/var/lib/mysql
            - /etc/localtime:/etc/localtime:ro
        environment:
            - MYSQL_ROOT_PASSWORD
            - MYSQL_PASSWORD
            - MYSQL_DATABASE
            - MYSQL_USER
        restart: unless-stopped
    app:
        image: nextcloud:latest
        container_name: nextcloud-app
        networks:
            - nextcloud_network
        depends_on:
            - letsencrypt
            - proxy
            - db
        volumes:
            - nextcloud:/var/www/html
            - ./app/config:/var/www/html/config
            - ./app/custom_apps:/var/www/html/custom_apps
            - ./app/data:/var/www/html/data
            - ./app/themes:/var/www/html/themes
            - /etc/localtime:/etc/localtime:ro
        environment:
            - VIRTUAL_HOST
            - LETSENCRYPT_HOST
            - LETSENCRYPT_EMAIL
        restart: unless-stopped
volumes:
    nextcloud:
    db:
networks:
    nextcloud_network:

Wenn Ihre Version der YAML-Datei mit unserer übereinstimmt, können Sie mit dem letzten Schritt fortfahren.

Nextcloud-Server-Installation abschließen

Um Nextcloud-Server als Multi-Container-Anwendung aus den Docker-Compose-Anweisungen zu erzeugen, führen wir den folgenden Befehl auf der Kommandozeile aus:

cd ~/nextcloud-docker/ && docker-compose up -d

Im Anschluss überprüfen wir, ob die Container gestartet wurden:

docker ps -a

Die angezeigte Liste laufender Container sollte die vier in der docker-compose.yaml-Datei definierten Container enthalten.

Tipp

Sie wollen einen eigenen Server mit Nextcloud als Cloud-Speicher-Lösung realisieren? Mit Managed Nextcloud Hosting von IONOS profitieren Sie nicht nur von einem passenden Hardware-Konstrukt, sondern auch einer unkomplizierten „Ein-Klick“-Installation der Nextcloud-Software! 

War dieser Artikel hilfreich?