# Nextcloud-Installation mit Docker [Nextcloud](https://www.ionos.de/digitalguide/server/tools/was-ist-nextcloud/ "Was ist 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. ## 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](https://www.ionos.de/digitalguide/server/konfiguration/docker-compose-tutorial/) 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](https://www.ionos.de/digitalguide/server/konfiguration/raspberry-pi-nextcloud/ "Raspberry Pi Nextcloud") einzurichten. --- ### Tipp Nextcloud und ownCloud haben viele Gemeinsamkeiten. In unserem Ratgeber-Artikel [ownCloud vs. Nextcloud](https://www.ionos.de/digitalguide/server/tools/owncloud-vs-nextcloud-zwei-cloud-speicher-im-test/) 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](https://www.ionos.de/digitalguide/server/knowhow/docker-tools-das-oekosystem-der-container-plattform/ "Docker-Tools | Das Ökosystem der Container-Plattform") 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](https://docs.docker.com/engine/install/ubuntu/ "Install Docker Engine on Ubuntu - Docker Documentation") auf der Docker-Website. Beginnen wir nun mit der Installation der Docker-Engine: 1. Eventuell vorhandene Docker-Installation entfernen: ```none sudo apt-get remove docker docker-engine docker.io containerd runc ``` 2. Installer auf den neuesten Stand bringen: ```none sudo apt-get update ``` 3. Repositorys vorbereiten: ```none sudo apt-get install \ ca-certificates \ curl \ gnupg \ lsb-release ``` 4. Dockers offiziellen GPG-Schlüssel hinzufügen: ```none curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg ``` 5. Stabiles Docker-Repository einrichten: ```none 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 ``` 6. Repositorys auf den neuesten Stand bringen: ```none sudo apt-get update ``` 7. Docker-Engine samt Abhängigkeiten installieren: ```none sudo apt-get install docker-ce docker-ce-cli containerd.io ``` 8. 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. ```none 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: ```none sudo add-apt-repository universe ``` 2. Paketverwaltung auf den neuesten Stand bringen: ```none sudo apt update ``` 3. Docker Compose installieren: ```none sudo apt install docker-compose ``` 4. Überprüfen, ob Docker Compose erfolgreich installiert wurde: ```none 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: ```none mkdir ~/nextcloud-docker/ ``` 2. **Dateien anlegen**. Wir erzeugen die Dateien *docker-compose.yaml* und *.env* im Projekt-Ordner: ```none touch ~/nextcloud-docker/docker-compose.yaml touch ~/nextcloud-docker/.env ``` 3. **Docker-Netzwerk erzeugen**. Wir nutzen den *docker*-Befehl, um ein neues Netzwerk anzulegen. Die vier Container kommunizieren innerhalb des Netzwerks. ```none 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“: ```none nano ~/nextcloud-docker/docker-compose.yaml ``` 2. 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. ```none 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: ```none nano ~/nextcloud-docker/docker-compose.yaml ``` 2. 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. ```none 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](https://www.ionos.de/sicherheit/ssl-zertifikat "SSL Zertifikate kaufen » Günstige Verschlüsselung für Ihre Website – IONOS") 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: ```none nano ~/nextcloud-docker/docker-compose.yaml ``` 2. Weiteren Service-Block einfügen: ```none 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: ```none nano ~/nextcloud-docker/docker-compose.yaml ``` 2. Weiteren Service-Block eintragen: ```none 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: ```none nano ~/nextcloud-docker/docker-compose.yaml ``` 2. 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. ```none volumes: nextcloud: db: networks: nextcloud_network: ``` 3. Leere *.env*-Datei zum Bearbeiten öffnen: ```none nano ~/nextcloud-docker/.env ``` 4. 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. ```none # MariaDB MYSQL_ROOT_PASSWORD=toor MYSQL_PASSWORD=mysql MYSQL_DATABASE=nextcloud MYSQL_USER=nextcloud # Nextcloud VIRTUAL_HOST= LETSENCRYPT_HOST= LETSENCRYPT_EMAIL= ``` 5. Nach dem Speichern zeigen wir den Inhalt der *.env*-Datei an, um zu überprüfen, dass das Eintragen der Werte geklappt hat: ```none 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: ```none cat ~/nextcloud-docker/docker-compose.yaml ``` 2. Mit unserer Vorlage abgleichen. Die ausgegebene Konfiguration sollte mit dem folgenden Code übereinstimmen: ```none 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: ```none cd ~/nextcloud-docker/ && docker-compose up -d ``` Im Anschluss überprüfen wir, ob die **Container gestartet** wurden: ```none 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](https://www.ionos.de/office-loesungen/managed-nextcloud-hosting "Managed Nextcloud von IONOS") profitieren Sie nicht nur von einem passenden Hardware-Konstrukt, sondern auch einer unkomplizierten **„Ein-Klick“-Installation** der Nextcloud-Software! --- This is a markdown version of: [https://www.ionos.de/digitalguide/server/konfiguration/nextcloud-installation-mit-docker/](https://www.ionos.de/digitalguide/server/konfiguration/nextcloud-installation-mit-docker/) for AI/LLM consumption.