Diese Anleitung zeigt Dir Schritt für Schritt, wie Du OpenCloud mit Docker auf einem Linux-Server selbst hostest. OpenCloud (Repo opencloud-eu/opencloud) ist der in Go geschriebene Nachfolger von ownCloud Infinite Scale (oCIS): ein einzelnes, schlankes Binary, das alle Microservices bündelt und im Gegensatz zu klassischem ownCloud oder Nextcloud KEINE externe Datenbank braucht. Identitäten (IDM/LDAP) und Metadaten verwaltet OpenCloud intern. Damit eignet es sich für KMU und ambitionierte Heimserver-Nutzer, die eine moderne, ressourcenschonende Alternative zu Nextcloud/ownCloud suchen – es läuft sogar auf einem Raspberry Pi 4.

Kurzfassung: Offizielles Compose-Repo klonen, .env mit Domain und Admin-Passwort füllen, dann mit Traefik und Let’s Encrypt starten. Die drei Kernbefehle:

git clone https://github.com/opencloud-eu/opencloud-compose.git
cd opencloud-compose
cp .env.example .env   # OC_DOMAIN, INITIAL_ADMIN_PASSWORD und TRAEFIK_ACME_MAIL setzen
docker compose up -d

Login danach unter https://cloud.DEINE-DOMAIN.de mit Benutzer admin und dem in INITIAL_ADMIN_PASSWORD gesetzten Passwort.

Voraussetzungen

Bevor Du startest, sollte Folgendes bereitstehen:

Linux-Server: Debian 12 (Bookworm) oder Ubuntu 24.04 LTS sind getestet und geeignet.
Docker & Docker Compose v2: Compose v2 ist Pflicht. Das alte Compose v1 aus den Debian-12-Standardpaketen ist zu alt und scheitert an den modularen Compose-Files. Prüfe mit docker compose version (mit Leerzeichen, nicht docker-compose).
Domain mit DNS-Eintrag: Eine (Sub-)Domain wie cloud.DEINE-DOMAIN.de muss per A-/AAAA-Record bereits auf die öffentliche IP des Servers zeigen – sonst kann Let’s Encrypt kein Zertifikat ausstellen.
Offene Ports: 80 und 443 müssen von außen erreichbar sein (Traefik übernimmt sie). Bei eigenem Reverse-Proxy stattdessen 9200 (OpenCloud) und 9980 (Collabora).
Hardware: Minimum ca. 1 GHz Single-Core und 512 MB RAM (bis ~10 Nutzer, ARM64/Raspberry Pi 4 reicht). Für ein Kleinteam bis 20 Nutzer plane ca. 2 Kerne und 2 GB RAM ein, für bis zu 1000 Nutzer empfiehlt OpenCloud 2 GHz Dual-Core und 8 GB RAM. Wichtiger als rohe CPU sind hohe Disk-IOPS – nimm SSD/NVMe.
GPU? OpenCloud ist ein reiner Datei-/Collaboration-Dienst ohne LLM- oder Bildgenerierung. Eine GPU bringt hier nichts und nvidia-container-toolkit ist nicht nötig. Plane GPUs nur ein, wenn Du auf demselben Host getrennt davon KI-Dienste betreibst.

Schritt 1: Compose-Repo klonen

OpenCloud empfiehlt offiziell das Deployment über das Repo opencloud-eu/opencloud-compose. Es enthält modulare Compose-Files, die Du je nach Setup kombinierst (Basis plus Traefik oder eigener Proxy, optional Collabora/OnlyOffice/Keycloak). Klone es auf den Server:

git clone https://github.com/opencloud-eu/opencloud-compose.git
cd opencloud-compose
ls

Im Verzeichnis findest Du unter anderem die Basis docker-compose.yml, einen Ordner traefik/ (Reverse-Proxy mit Let’s Encrypt), external-proxy/ (für Nginx/Caddy davor), weboffice/ (Collabora/OnlyOffice) sowie eine .env.example als Vorlage.

Schritt 2: .env anlegen (Domain, Admin-Passwort, Image-Tag)

Kopiere die Beispiel-Konfiguration und bearbeite sie. Das ist der wichtigste Schritt – vor allem INITIAL_ADMIN_PASSWORD muss VOR dem ersten Start stehen, da es nur beim allerersten init wirkt.

cp .env.example .env
nano .env

Eine sinnvolle Produktions-.env sieht so aus:

# --- Domain & URL ---
OC_DOMAIN=cloud.DEINE-DOMAIN.de
OC_URL=https://cloud.DEINE-DOMAIN.de

# --- Admin-Zugang (nur beim ersten init wirksam!) ---
INITIAL_ADMIN_PASSWORD=DEIN-SICHERES-PASSWORT

# --- Image fuer Produktion auf stabile Linie + festen Tag pinnen ---
OC_DOCKER_IMAGE=opencloudeu/opencloud
OC_DOCKER_TAG=6.2.0

# --- Traefik / Let's Encrypt ---
TRAEFIK_ACME_MAIL=admin@DEINE-DOMAIN.de
TRAEFIK_ACME_CASERVER=
TRAEFIK_DASHBOARD=false

# --- Sicherheit / Betrieb ---
OC_INSECURE=false
DEMO_USERS=false
LOG_LEVEL=info

# --- Welche Compose-Files kombiniert werden ---
COMPOSE_FILE=docker-compose.yml:traefik/opencloud.yml

Wichtig zu den Werten:

Image-Linie: Default im Repo ist opencloudeu/opencloud-rolling (sehr häufige Builds). Für stabilen Produktionsbetrieb setzt Du auf opencloudeu/opencloud mit festem Tag (hier 6.2.0) statt latest.
TRAEFIK_ACME_CASERVER leer bedeutet Produktions-CA. Zum Ausprobieren kannst Du hier die Staging-URL von Let’s Encrypt eintragen, um die strengen Rate-Limits nicht zu treffen.
OC_INSECURE=false ist richtig für Produktion. true nur für lokale Tests mit Self-Signed-Zertifikaten.
COMPOSE_FILE-Reihenfolge ist relevant: Basis-File zuerst, dann (falls genutzt) Web-Office, dann die Proxy-Files. Vergisst Du das Proxy-File, ist gar kein Reverse-Proxy konfiguriert.

Schritt 3: compose.yaml verstehen (vollständiges Beispiel)

Die offiziellen Files sind modular. Wenn Du lieber EINE eigenständige, copy-paste-fertige Datei möchtest (etwa für einen einfachen Single-Stack mit Traefik), kannst Du folgende compose.yaml verwenden. Sie spiegelt das offizielle Verhalten wider: Container als User 1000:1000, opencloud init || true; opencloud server als Startbefehl, Named-Volumes für Config und Daten und Traefik mit Let’s Encrypt davor.

services:
  traefik:
    image: traefik:v3.3
    restart: always
    command:
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.web.http.redirections.entrypoint.to=websecure"
      - "--entrypoints.web.http.redirections.entrypoint.scheme=https"
      - "--entrypoints.websecure.address=:443"
      - "--certificatesresolvers.le.acme.tlschallenge=true"
      - "--certificatesresolvers.le.acme.email=${TRAEFIK_ACME_MAIL}"
      - "--certificatesresolvers.le.acme.storage=/certs/acme.json"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - "/var/run/docker.sock:/var/run/docker.sock:ro"
      - "traefik-certs:/certs"

  opencloud:
    image: ${OC_DOCKER_IMAGE:-opencloudeu/opencloud}:${OC_DOCKER_TAG:-6.2.0}
    restart: always
    # 1) init erzeugt beim ersten Start die Config, danach startet der Server
    entrypoint: ["/bin/sh", "-c"]
    command: ["opencloud init || true; opencloud server"]
    # Container laeuft als nicht-root User 1000:1000
    user: "1000:1000"
    environment:
      OC_DOMAIN: ${OC_DOMAIN}
      OC_URL: https://${OC_DOMAIN}
      INITIAL_ADMIN_PASSWORD: ${INITIAL_ADMIN_PASSWORD}
      PROXY_HTTP_ADDR: 0.0.0.0:9200
      PROXY_TLS: "false"
      OC_INSECURE: "${OC_INSECURE:-false}"
      DEMO_USERS: "false"
      LOG_LEVEL: info
    volumes:
      - opencloud-config:/etc/opencloud
      - opencloud-data:/var/lib/opencloud
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.opencloud.rule=Host(`${OC_DOMAIN}`)"
      - "traefik.http.routers.opencloud.entrypoints=websecure"
      - "traefik.http.routers.opencloud.tls.certresolver=le"
      - "traefik.http.services.opencloud.loadbalancer.server.port=9200"

volumes:
  opencloud-config:
  opencloud-data:
  traefik-certs:

Hinweise zu dieser Datei: Der OpenCloud-Proxy-Service lauscht intern auf Port 9200 – deshalb verweist das Traefik-Label genau darauf. TLS macht hier Traefik, daher steht PROXY_TLS=false. Die beiden Named-Volumes opencloud-config (/etc/opencloud) und opencloud-data (/var/lib/opencloud) sorgen für die Persistenz von Konfiguration und Nutzdaten/Metadaten. Eine externe SQL-Datenbank gibt es bewusst nicht.

Schritt 4: Stack starten und Logs prüfen

Wenn Du das offizielle Repo nutzt und COMPOSE_FILE in der .env gesetzt hast, genügt:

docker compose up -d

Alternativ kannst Du die Files explizit per -f angeben (ohne COMPOSE_FILE-Variable):

docker compose -f docker-compose.yml -f traefik/opencloud.yml up -d

Prüfe danach Status und Logs. Der erste Start dauert etwas, weil opencloud init die Konfiguration und interne Zertifikate erzeugt und Traefik das Let’s-Encrypt-Zertifikat anfordert:

docker compose ps
docker compose logs -f opencloud

Wenn in den Logs der Server lauscht und Traefik ein gültiges Zertifikat geholt hat, ist OpenCloud unter Deiner Domain erreichbar.

Schritt 5: Ersteinrichtung in der Web-UI und Spaces nutzen

Rufe nun https://cloud.DEINE-DOMAIN.de im Browser auf. Melde Dich mit Benutzer admin und dem in INITIAL_ADMIN_PASSWORD gesetzten Passwort an. (Lokal ohne Domain läuft der Single-Container unter https://localhost:9200; dort musst Du die Self-Signed-Zertifikatswarnung manuell akzeptieren.)

OpenCloud organisiert Daten nicht in klassischen Ordnerfreigaben, sondern im Spaces-Konzept:

Jeder Nutzer hat einen persönlichen Space für seine eigenen Dateien.
Für Teams und Projekte legst Du Projekt-Spaces an, die Du gezielt mit Personen teilst und mit Quota versiehst.
Berechtigungen und Mitglieder verwaltest Du pro Space – das ist übersichtlicher als verschachtelte Einzelfreigaben.

Lege als erstes einen Projekt-Space an, lade weitere Nutzer ein und teste den Upload. Neue Benutzer und Gruppen verwaltest Du als Admin direkt in der Web-UI (interner LibreIDM/LDAP).

Schritt 6: Reverse-Proxy und HTTPS (Traefik vs. eigener Proxy)

Für den öffentlichen Betrieb brauchst Du echtes TLS. Es gibt zwei saubere Wege:

Traefik (empfohlen, im Repo enthalten): Traefik belegt Port 80/443 (TRAEFIK_PORT_HTTP=80, TRAEFIK_PORT_HTTPS=443) und holt automatisch Let’s-Encrypt-Zertifikate. Pflicht ist TRAEFIK_ACME_MAIL; TRAEFIK_ACME_CASERVER bleibt für Produktion leer. Der DNS-Eintrag muss vorher stehen.
Eigener Reverse-Proxy (Nginx/Caddy): Hast Du bereits einen Proxy, nutzt Du die external-proxy/-Files. Dann exponiert OpenCloud Port 9200 (und Collabora 9980), und Dein Proxy terminiert TLS und leitet weiter.

So aktivierst Du den External-Proxy-Modus inklusive Collabora über COMPOSE_FILE in der .env:

COMPOSE_FILE=docker-compose.yml:weboffice/collabora.yml:external-proxy/opencloud.yml:external-proxy/collabora.yml

Eine minimale Nginx-Weiterleitung auf den OpenCloud-Port könnte so aussehen:

server {
    listen 443 ssl;
    server_name cloud.DEINE-DOMAIN.de;

    ssl_certificate     /etc/letsencrypt/live/cloud.DEINE-DOMAIN.de/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/cloud.DEINE-DOMAIN.de/privkey.pem;

    client_max_body_size 10G;

    location / {
        proxy_pass         http://127.0.0.1:9200;
        proxy_set_header   Host              $host;
        proxy_set_header   X-Forwarded-Proto $scheme;
        proxy_set_header   X-Forwarded-For   $proxy_add_x_forwarded_for;
    }
}

Schritt 7: Web-Office optional aktivieren (Collabora/OnlyOffice)

Zum gemeinsamen Bearbeiten von Dokumenten direkt im Browser kannst Du Collabora oder OnlyOffice ergänzen. Bei Traefik aktivierst Du Collabora über zusätzliche Compose-Files in der .env:

COMPOSE_FILE=docker-compose.yml:weboffice/collabora.yml:traefik/opencloud.yml:traefik/collabora.yml

Anschließend neu hochfahren:

docker compose up -d

Relevante Env-Variablen für Collabora sind unter anderem COLLABORA_DOMAIN, WOPISERVER_DOMAIN, COLLABORA_ADMIN_USER/COLLABORA_ADMIN_PASSWORD und COLLABORA_SSL_ENABLE. Im External-Proxy-Modus läuft Collabora auf Port 9980, den Dein Proxy weiterreichen muss.

Schritt 8: Desktop- und Mobile-Sync einrichten

Dateien synchronisierst Du wie bei Nextcloud/ownCloud über Clients:

Desktop: Den OpenCloud Desktop-Client gibt es für Windows, macOS und Linux. Bei der Einrichtung trägst Du Deine Server-URL https://cloud.DEINE-DOMAIN.de ein und meldest Dich an.
Mobil: Apps für iOS und Android binden denselben Account ein und synchronisieren Spaces sowie Foto-Uploads.

Da die Anmeldung über den internen IDM (oder optional Keycloak/OIDC) läuft, funktioniert dasselbe Konto in allen Clients.

Schritt 9: Update-Workflow und Backup

Updates sind dank Container schmerzlos. Ziehe neue Images und starte neu – Compose ersetzt nur geänderte Container:

docker compose pull
docker compose up -d
docker image prune -f   # optional: alte Images aufraeumen

Weil Du in Produktion einen festen Tag gepinnt hast, erhöhst Du für ein Update gezielt OC_DOCKER_TAG in der .env und führst dann pull und up -d aus. So vermeidest Du ungewollte Sprünge der rolling-Linie.

Backup: Sichere bei gestopptem Container (oder per konsistentem Snapshot) die Volumes/Verzeichnisse samt .env:

docker compose down
tar czf opencloud-backup-$(date +%F).tar.gz opencloud-data opencloud-config .env
docker compose up -d

Bewahre die .env getrennt und sicher auf – sie enthält Passwörter und Secrets und ist absichtlich aus der Versionskontrolle ausgeschlossen.

Troubleshooting

Login-Fehler 500 / Permission-Probleme: Bei Bind-Mounts müssen die Verzeichnisse dem Container-User UID/GID 1000 gehören. Fix: sudo chown -R 1000:1000 opencloud-data opencloud-config (bekanntes Issue #195 im Compose-Repo). Named-Volumes sind hier unkomplizierter.
Compose-File schlägt fehl / unbekannte Syntax: Du nutzt vermutlich noch Compose v1 (docker-compose). Installiere das Compose-v2-Plugin und rufe docker compose (mit Leerzeichen) auf.
Let’s Encrypt stellt kein Zertifikat aus: Die Domain muss VOR dem Start per DNS auf den Server zeigen, und Port 80/443 müssen offen sein. Zum Testen TRAEFIK_ACME_CASERVER auf die Staging-URL setzen, um Rate-Limits zu vermeiden.
Alles läuft unter cloud.opencloud.test: Du hast OC_DOMAIN/OC_URL nicht angepasst. Trage Deine echte Domain ein und starte neu.
Admin-Passwort wirkt nicht: INITIAL_ADMIN_PASSWORD greift nur beim allerersten init. Späteres Ändern in der .env hat keinen Effekt – ändere das Passwort danach in der Web-UI unter Einstellungen > Sicherheit.
LDAP-Verbindungsfehler nach Wochen/Monaten: Das interne LibreIDM-Zertifikat (ldap.crt/ldap.key) kann ablaufen. Lösche die beiden Dateien im Config-Volume und starte den Container neu – sie werden neu generiert. Für Produktion empfiehlt OpenCloud OpenLDAP oder Keycloak statt des internen IDM.

Häufige Fragen

Brauche ich für OpenCloud eine externe Datenbank wie bei Nextcloud?

Nein. OpenCloud bündelt alles in einem Go-Binary und bringt internen IDM/LDAP sowie einen Metadaten-Store mit. Eine externe MySQL/MariaDB oder PostgreSQL ist nicht nötig – das ist einer der größten Unterschiede zur klassischen Nextcloud-/ownCloud-Installation.

Was ist der Unterschied zwischen opencloud-rolling und opencloud?

Das Image opencloudeu/opencloud-rolling bekommt sehr häufig Builds und ist der Default im Compose-Repo. Für stabilen Produktionsbetrieb nimmst Du opencloudeu/opencloud und pinnst einen festen Versions-Tag (z. B. 6.2.0) statt latest.

Kann ich OpenCloud hinter meinem vorhandenen Nginx oder Caddy betreiben?

Ja. Nutze die external-proxy/-Compose-Files. Dann exponiert OpenCloud Port 9200 (und Collabora 9980), und Dein vorhandener Proxy terminiert TLS und leitet die Anfragen weiter.

Wie ändere ich nachträglich das Admin-Passwort?

Über die Web-UI unter Einstellungen > Sicherheit. Der Wert INITIAL_ADMIN_PASSWORD in der .env wird nach dem ersten init ignoriert; ein erneutes Setzen dort ändert nichts.

Brauche ich eine GPU oder das nvidia-container-toolkit?

Nein. OpenCloud ist ein Datei- und Collaboration-Dienst ohne KI-Inferenz. Eine GPU bringt keinen Vorteil. Relevanter sind hohe Disk-IOPS (SSD/NVMe) und genug RAM für die Nutzerzahl.

Läuft OpenCloud auf einem Raspberry Pi?

Ja. Für kleine Installationen bis ca. 10 Nutzer reichen rund 1 GHz Single-Core und 512 MB RAM; ein Raspberry Pi 4 (ARM64) genügt. Achte auf schnelle Speichermedien statt langsamer SD-Karten.

Fazit

OpenCloud ist eine erfrischend schlanke Alternative zu Nextcloud und ownCloud: ein Go-Binary, keine externe Datenbank, sauberes Spaces-Konzept und ein offizielles, modulares Compose-Setup. Für den produktiven Betrieb merkst Du Dir drei Dinge: stabile Image-Linie mit festem Tag pinnen, Domain und INITIAL_ADMIN_PASSWORD vor dem ersten Start setzen und echtes TLS über Traefik oder einen eigenen Reverse-Proxy bereitstellen. Danach läuft die Cloud ressourcenschonend – vom Raspberry Pi im Heimnetz bis zum KMU-Server für hunderte Nutzer – und Updates sowie Backups sind dank Docker Compose in wenigen Befehlen erledigt.

Weiterführende Anleitungen und Quellen

Passende Anleitungen aus unserem Wissensbereich:

Docker Compose Grundlagen: Stacks aufbauen und verwalten – Basis für das Verständnis der modularen Compose-Files.
Traefik als Docker-Reverse-Proxy mit HTTPS einrichten – Details zu Let’s Encrypt, Labels und Entrypoints.
Nextcloud AIO als self-hosted Cloud mit Docker einrichten – zum direkten Vergleich mit der Nextcloud-Variante.
Immich als Google-Photos-Alternative mit Docker – passende Foto-Lösung neben OpenCloud.
Alle Anleitungen der Kategorie Cloud

Quellen (offizielle OpenCloud-Doku und Repos, Stand 2026):