Nextcloud hat sich als quell­of­fe­ne Cloud-Lösung etabliert. Neben den Klienten für Desktop- und Mo­bil­be­triebs­sys­te­me umfasst die Software eine Server-Kom­po­nen­te. Wir zeigen, wie sich ein Nextcloud-Server in einer Docker-Umgebung in­stal­lie­ren lässt.

Free Cloud Server Trial
Virtual Private Server auf En­ter­pri­se-Level
  • KVM-basierte vServer für Ent­wick­ler
  • In­te­griert in die IONOS Compute Engine
  • Ska­lier­bar bis zur En­ter­pri­se-Cloud

Nextcloud unter Docker in­stal­lie­ren

Bei Nextcloud handelt es sich um eine quell­of­fe­ne Cloud-Lösung, die als Ab­spal­tung aus dem ownCloud-Projekt her­vor­ging. Der Funk­ti­ons­um­fang ist ver­gleich­bar mit pro­prie­tä­ren Cloud-Lösungen wie Microsoft 365 oder Google Workspace. Nextcloud syn­chro­ni­siert Daten wie Kalender und Kontakte zwischen Personen und Geräten. Neben der ob­li­ga­to­ri­schen Datei-Syn­chro­ni­sa­ti­on sind Funk­tio­nen für team­in­ter­ne Kol­la­bo­ra­ti­on und Kom­mu­ni­ka­ti­on enthalten. Nextcloud dient auch als Grundlage der seit 2020 im Betrieb be­find­li­chen „Bun­des­cloud“.

Wie bei ver­gleich­ba­ren Cloud-Lösungen üblich, umfasst Nextcloud eine Server-Kom­po­nen­te sowie Klienten für Desktop- und Mobil-Be­triebs­sys­te­me. Der Nextcloud-Server verwaltet die Daten und kom­mu­ni­ziert mit den Klienten; ferner wird eine kli­en­ten­un­ab­hän­gi­ge Web­ober­flä­che be­reit­ge­stellt.

Wir zeigen die In­stal­la­ti­on eines Nextcloud-Servers auf Ubuntu-Linux. Dabei nutzen wir Docker Compose und beziehen uns auf eine In­stal­la­ti­on auf Cloud-In­fra­struk­tur. Es ist auch möglich, den Server auf eigener Hardware zu in­stal­lie­ren und Nextcloud bei­spiels­wei­se auf einem Raspberry Pi ein­zu­rich­ten.

Tipp

Nextcloud und ownCloud haben viele Ge­mein­sam­kei­ten. In unserem Ratgeber-Artikel ownCloud vs. Nextcloud stellen wir Ihnen auch die Un­ter­schie­de vor.

Ar­chi­tek­tur von Nextcloud auf Docker

Schauen wir uns zunächst an, welche Kom­po­nen­ten Nextcloud-Server unter Docker umfasst und wie diese zu­sam­men­hän­gen. Neben der ei­gent­li­chen Nextcloud-Software kommen drei weitere, con­tai­ne­ri­sier­te Dienste zum Einsatz. Um den Container-Verbund zu pro­vi­sio­nie­ren 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 ver­schlüs­sel­te HTTPS-Ver­bin­dun­gen beim Zugriff auf Nextcloud zu rea­li­sie­ren
  2. Let’s Encrypt: wird genutzt, um SSL-Zer­ti­fi­ka­te au­to­ma­ti­siert ein­zu­rich­ten
  3. MariaDB: dient zur Spei­che­rung der bei der Nextcloud-Nutzung ser­ver­sei­tig an­fal­len­den Daten
  4. Nextcloud-Server: stellt die ei­gent­li­che Nextcloud-Funk­tio­na­li­tät zur Verfügung; kom­mu­ni­ziert mit den Nextcloud-Klienten und hostet die Web­ober­flä­che

In­stal­la­ti­on von Nextcloud-Server vor­be­rei­ten

Auf einem frisch auf­ge­setz­ten Ubuntu-Linux müssen wir zunächst die Docker-Engine und Docker Compose in­stal­lie­ren. Die Docker-Engine stellt die Container-Kern­funk­tio­na­li­tä­ten bereit, während Docker Compose die Ver­wal­tung zu­sam­men­ge­hö­ri­ger Container-Verbünde er­mög­licht. Sofern die Docker-Engine und Docker Compose bereits in­stal­liert sind, können Sie diesen Abschnitt über­sprin­gen.

Docker-Engine auf Ubuntu in­stal­lie­ren

Wir zeigen hier die In­stal­la­ti­on unter Ubuntu-Linux und beziehen uns dabei auf die of­fi­zi­el­le In­stal­la­ti­ons­an­lei­tung. Für andere Linux-Dis­tri­bu­tio­nen finden sich ent­spre­chen­de An­lei­tun­gen auf der Docker-Website. Beginnen wir nun mit der In­stal­la­ti­on der Docker-Engine:

  1. Eventuell vor­han­de­ne Docker-In­stal­la­ti­on entfernen:
sudo apt-get remove docker docker-engine docker.io containerd runc
  1. Installer auf den neuesten Stand bringen:
sudo apt-get update
  1. Re­po­si­to­rys vor­be­rei­ten:
sudo apt-get install \
ca-certificates \
curl \
gnupg \
lsb-release
  1. Dockers of­fi­zi­el­len GPG-Schlüssel hin­zu­fü­gen:
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
  1. Stabiles Docker-Re­po­si­to­ry ein­rich­ten:
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. Re­po­si­to­rys auf den neuesten Stand bringen:
sudo apt-get update
  1. Docker-Engine samt Ab­hän­gig­kei­ten in­stal­lie­ren:
sudo apt-get install docker-ce docker-ce-cli containerd.io
  1. Zu guter Letzt führen wir zu Test­zwe­cken den „Hello World“-Container aus.

Wenn die Docker-Engine korrekt in­stal­liert wurde, wird der Container aus­ge­führt und eine ent­spre­chen­de Nachricht aus­ge­ge­ben.

sudo docker run hello-world

Docker Compose auf Ubuntu in­stal­lie­ren

Wenden wir uns als nächstes der In­stal­la­ti­on von Docker Compose zu. Der In­stal­la­ti­ons­pro­zess ist einfacher und weniger um­fang­reich als die In­stal­la­ti­on der Docker-Engine. Im Einzelnen benötigen wir die folgenden Schritte:

  1. Ubuntus Universe-Re­po­si­to­ry ak­ti­vie­ren:
sudo add-apt-repository universe
  1. Pa­ket­ver­wal­tung auf den neuesten Stand bringen:
sudo apt update
  1. Docker Compose in­stal­lie­ren:
sudo apt install docker-compose
  1. Über­prü­fen, ob Docker Compose er­folg­reich in­stal­liert wurde:
docker-compose --version

Wird eine Ver­si­ons­num­mer angezeigt, wurde Docker Compose er­folg­reich in­stal­liert.

In­stal­la­ti­on von Nextcloud-Server durch­füh­ren

Sobald die Docker-Engine und Docker Compose in­stal­liert sind, legen wir mit der ei­gent­li­chen Nextcloud-In­stal­la­ti­on los. Wir werden einzelne Docker-Container für die ver­schie­de­nen Dienste kon­fi­gu­rie­ren. Zur Kon­fi­gu­ra­ti­on der Container und der be­nö­tig­ten Docker-Volumen und Docker-Netzwerke kommen zwei Kon­fi­gu­ra­ti­ons­da­tei­en zum Einsatz:

Datei Erklärung
docker-compose.yaml Docker-Compose-An­wei­sun­gen im YAML-Format für den Aufbau der Multi-Container Anwendung
.env Textdatei mit Um­ge­bungs­va­ria­blen; pro Zeile eine Va­ria­blen­de­fi­ni­ti­on

Wie erwähnt dient Docker Compose zur Ver­wal­tung von Multi-Container-An­wen­dun­gen. Dazu kommen Docker-Compose-An­wei­sun­gen zum Einsatz, die de­fi­nie­ren, wie die Anwendung aufgebaut wird und wie die einzelnen Kom­po­nen­ten mit­ein­an­der in­ter­agie­ren. Docker-Compose-An­wei­sun­gen be­schrei­ben die einzelnen Services, Docker-Elemente und Ein­stel­lun­gen und werden in der Sprache YAML („Yet Another Markup Language“, dt.: „noch eine weitere Markup-Sprache“) ge­schrie­ben. Wir bauen die dabei zum Einsatz kommende Datei docker-compose.yaml schritt­wei­se auf.

Neben der docker-compose.yaml wird eine weitere Datei benötigt. Diese enthält Um­ge­bungs­va­ria­blen, die in die Docker-Compose-An­wei­sun­gen ein­ge­bun­den werden. Stan­dard­mä­ßig legt man die Um­ge­bungs­va­ria­blen samt Werten in einer .env-Datei im Pro­jekt­ord­ner ab. Die .env-Datei wird nicht in Ver­si­ons­kon­troll­sys­tem auf­ge­nom­men; dies schützt sensible Daten wie Pass­wör­ter vor ver­se­hent­li­cher Of­fen­ba­rung.

Die Nutzung einer .env-Datei macht es trivial, ver­schie­de­ne Ein­stel­lun­gen für un­ter­schied­li­che An­wen­dungs­um­ge­bun­gen zu de­fi­nie­ren. Um bei­spiels­wei­se un­ter­schied­li­che Ein­stel­lun­gen für eine Live-Site und eine Staging-Site zu nutzen, ändert man lediglich die jeweilige .env-Datei.

Für Nextcloud-Server benötigte Struk­tu­ren anlegen

Um mit der In­stal­la­ti­on von Nextcloud-Server zu beginnen, benötigen wir eine Handvoll an Struk­tu­ren. Diese legen wir mit den folgenden Schritten an:

  1. Projekt-Ordner anlegen. Wir erstellen den Ordner nextcloud-docker im Heim­ver­zeich­nis 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 kom­mu­ni­zie­ren innerhalb des Netzwerks.
docker network create nextcloud_network

Haben wir die Struk­tu­ren angelegt, fahren wir mit der In­stal­la­ti­on von Nextcloud-Server fort.

Reverse Proxy für Nextcloud-Server kon­fi­gu­rie­ren

Wir beginnen die In­stal­la­ti­on von Nextcloud-Server mit der Kon­fi­gu­ra­ti­on des Reverse Proxy. Dazu kommt Nginx zum Einsatz. Da wir unsere Anwendung aus Con­tai­nern zu­sam­men­set­zen, spielt sich der Großteil der In­stal­la­ti­ons-Routine in der Datei docker-compose.yaml ab. Wir zeigen hier de­tail­liert, wie Sie diese Datei be­ar­bei­ten. Folgen Sie denselben Mustern in den nach­fol­gen­den In­stal­la­ti­ons­schrit­ten:

  1. Datei docker-compose.yaml zum Be­ar­bei­ten öffnen.

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

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

Um die Datei zu schließen, verwenden wir die Tas­ten­kom­bi­na­ti­on [Strg] + [X] bzw. [Ctrl] + [X]. Die Frage nach Speichern der Datei be­ant­wor­ten wir mit „y“ für „yes“/„ja“. Die Nutzung des exis­tie­ren­den Da­tei­na­mens be­stä­ti­gen wir mit der [Enter]-Taste.

Al­ter­na­tiv lassen wir den Editor offen und nutzen die Tas­ten­kom­bi­na­ti­on [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 ba­sie­ren­des Nginx-Image zu nutzen. Ferner legen wir fest, dass der Reverse Proxy mit den anderen Diensten über das Docker-Netzwerk nextcloud_network kom­mu­ni­zie­ren soll.

Wir mappen die Standard HTTP- und HTTPS-Ports 80 bzw. 443 vom Host-System auf den Container. So werden die ein­ge­hen­den Ver­bin­dun­gen über den Proxy geleitet. Als letzten Schritt der Kon­fi­gu­ra­ti­on legen wir ver­schie­de­ne Docker-Volumen an und legen fest, dass der Reverse Proxy au­to­ma­tisch neu gestartet wird sofern er nicht explizit gestoppt wurde.

Let’s Encrypt Dienst für Nextcloud-Server kon­fi­gu­rie­ren

Fahren wir fort mit der In­stal­la­ti­on von Let’s Encrypt. Dies er­mög­licht die ver­schlüs­sel­te Kom­mu­ni­ka­ti­on mit dem Nextcloud-Server über HTTPS.

  1. Datei docker-compose.yaml zum Be­ar­bei­ten öffnen:
nano ~/nextcloud-docker/docker-compose.yaml
  1. Weiteren Service-Block hin­zu­fü­gen.

Gehen Sie vor, wie im vor­he­ri­gen Abschnitt be­schrie­ben, und achten Sie dabei auf die Ein­rü­ckung: Der Beginn des mit let­sen­crypt: be­gin­nen­den Blocks muss auf derselben Ebene wie proxy: stehen. Dies gilt auch für nach­fol­gen­de 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 de­fi­nie­ren wir einen neuen Dienst unter dem Namen let­sen­crypt, der auf dem Container let­sen­crypt-nginx-proxy-companion basiert. Dabei legen wir fest, dass der Dienst vom Reverse-Proxy-Dienst abhängig ist und im selben Docker-Netzwerk kom­mu­ni­ziert. Weiterhin de­fi­nie­ren wir die für den Da­ten­aus­tausch be­nö­tig­ten Docker-Volumen. Auch für diesen Dienst legen wir fest, dass er au­to­ma­tisch neu gestartet wird, sofern er nicht explizit gestoppt wurde.

Tipp

Sie wollen eine Profi-Ver­schlüs­se­lung für Ihre Website? Kaufen Sie ein eigenes SSL-Zer­ti­fi­kat günstig bei IONOS!

MariaDB-Dienst für Nextcloud-Server kon­fi­gu­rie­ren

Mit der Kon­fi­gu­ra­ti­on von Reverse Proxy und Let’s Encrypt haben wir die Hälfte der In­stal­la­ti­on geschafft. Machen wir nun weiter mit der MariaDB-Datenbank. Diese wird benötigt, um die bei der Nextcloud-Nutzung an­fal­len­den Daten zu verwalten. Dabei erfolgte die ei­gent­li­che Spei­che­rung per Docker-Volumen außerhalb des Con­tai­ners.

  1. Datei docker-compose.yaml zum Be­ar­bei­ten ö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

Mitt­ler­wei­le sollten die meisten Ein­stel­lun­gen geläufig sein. Wir de­fi­nie­ren 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 Spei­che­rung der Daten fest.

Neu in diesem Kon­fi­gu­ra­ti­ons-Block ist die Nutzung von Um­ge­bungs­va­ria­blen. Im en­vi­ron­ment-Abschnitt geben wir die Namen der für die MariaDB be­nö­tig­ten Um­ge­bungs­va­ria­blen an. Die ei­gent­li­chen Werte werden beim späteren Ausführen von Docker Compose aus der .env-Datei aus­ge­le­sen.

Nextcloud-Server-Container kon­fi­gu­rie­ren

Nun ist es so weit: Wir kommen zur In­stal­la­ti­on der ei­gent­li­chen Nextcloud-Server-Software.

  1. Datei docker-compose.yaml zum Be­ar­bei­ten ö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 kom­mu­ni­ziert. Um si­cher­zu­stel­len, dass der Nextcloud-Container zuletzt gestartet wird, legen wir die anderen Dienste als Ab­hän­gig­kei­ten fest. Ferner de­fi­nie­ren wir die be­nö­tig­ten Docker-Volumen und Um­ge­bungs­va­ria­blen.

Nextcloud-Server-Kon­fi­gu­ra­ti­on ab­schlie­ßen

Um die Nextcloud-Server-Kon­fi­gu­ra­ti­on ab­zu­schlie­ß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 ent­spre­chen­den Werten.

  1. Datei docker-compose.yaml zum Be­ar­bei­ten öffnen:
nano ~/nextcloud-docker/docker-compose.yaml
  1. Die nach­fol­gen­den Blöcke einfügen.

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

volumes:
    nextcloud:
    db:
networks:
    nextcloud_network:
  1. Leere .env-Datei zum Be­ar­bei­ten öffnen:
nano ~/nextcloud-docker/.env
  1. Um­ge­bungs­va­ria­blen samt Werten in .env-Datei schreiben:

Wir kopieren den folgenden Code in das Editor-Fenster und ersetzen vor dem Speichern die <Platz­hal­ter> mit den ge­wünsch­ten 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 über­prü­fen, dass das Eintragen der Werte geklappt hat:
cat ~/nextcloud-docker/.env

Voll­stän­di­ge Nextcloud-Server-Kon­fi­gu­ra­ti­on

Bevor wir die erstellte Kon­fi­gu­ra­ti­on an Docker Compose übergeben und damit die Container erzeugen und starten, über­prü­fen wir, dass alles Benötigte an Ort und Stelle ist.

  1. Be­stehen­de Kon­fi­gu­ra­ti­on ausgeben:
cat ~/nextcloud-docker/docker-compose.yaml
  1. Mit unserer Vorlage ab­glei­chen. Die aus­ge­ge­be­ne Kon­fi­gu­ra­ti­on sollte mit dem folgenden Code über­ein­stim­men:
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 über­ein­stimmt, können Sie mit dem letzten Schritt fort­fah­ren.

Nextcloud-Server-In­stal­la­ti­on ab­schlie­ßen

Um Nextcloud-Server als Multi-Container-Anwendung aus den Docker-Compose-An­wei­sun­gen zu erzeugen, führen wir den folgenden Befehl auf der Kom­man­do­zei­le aus:

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

Im Anschluss über­prü­fen wir, ob die Container gestartet wurden:

docker ps -a

Die an­ge­zeig­te Liste laufender Container sollte die vier in der docker-compose.yaml-Datei de­fi­nier­ten Container enthalten.

Tipp

Sie wollen einen eigenen Server mit Nextcloud als Cloud-Speicher-Lösung rea­li­sie­ren? Mit Managed Nextcloud Hosting von IONOS pro­fi­tie­ren Sie nicht nur von einem passenden Hardware-Konstrukt, sondern auch einer un­kom­pli­zier­ten „Ein-Klick“-In­stal­la­ti­on der Nextcloud-Software! 

Zum Hauptmenü