OpenCloud mit Docker: schlanke ownCloud-/Nextcloud-Alternative

OpenCloud (Repo opencloud-eu/opencloud) ist der in Go geschriebene Nachfolger von ownCloud Infinite Scale (oCIS): ein einzelnes Binary, das alle Microservices bündelt und im Gegensatz zu ownCloud oder Nextcloud KEINE externe Datenbank braucht; Identitäten (IDM/LDAP) und Metadaten verwaltet es intern. Diese Anleitung zeigt das Selbsthosten mit Docker auf einem Linux-Server, für KMU wie Heimserver bis hin zum Raspberry Pi 4.

Voraussetzungen

Voraussetzungen:

1. Linux-Server: Debian 12 (Bookworm) oder Ubuntu 24.04 LTS.
2. Docker & Docker Compose v2: Pflicht; das alte Compose v1 aus Debian 12 scheitert an den modularen Compose-Files. Prüfen mit docker compose version.
3. Domain mit DNS-Eintrag: cloud.DEINE-DOMAIN.de muss per A-/AAAA-Record schon auf den Server zeigen, sonst kein Let’s-Encrypt-Zertifikat.
4. Offene Ports: 80 und 443 (Traefik), bei eigenem Reverse-Proxy stattdessen 9200 (OpenCloud) und 9980 (Collabora).
5. Hardware: Minimum laut Hersteller 1 GHz Single-Core und 512 MB RAM (bis 10 Nutzer, x86_64 oder ARM64). Kleinteam bis 20 Nutzer: ca. 2 Kerne und 2 GB RAM; bis 1000 Nutzer: 2 GHz Dual-Core und 8 GB RAM. Wichtiger als CPU sind Disk-IOPS (SSD/NVMe). Im Test belegte OpenCloud 7.2.4 nach dem Start rund 200 MB RAM.
6. GPU? Nicht nötig, auch kein nvidia-container-toolkit: OpenCloud ist ein reiner Datei-/Collaboration-Dienst.

Schritt 1: Compose-Repo klonen

Offiziell empfohlen ist das Repo opencloud-eu/opencloud-compose mit modularen Compose-Files (Basis plus Traefik oder eigener Proxy, optional Collabora/OnlyOffice/Keycloak). Klonen Sie es:

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

Es enthält u. a. die Basis docker-compose.yml, traefik/ (Let’s Encrypt), external-proxy/ (Nginx/Caddy davor), weboffice/ (Collabora), yjs/ (Echtzeit-Bearbeitung) und die Vorlage .env.example.

Verifizieren: ls listet mindestens docker-compose.yml, traefik, external-proxy und .env.example (versteckte Datei, sichtbar mit ls -a).

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

Kopieren und bearbeiten Sie die Beispiel-Konfiguration. INITIAL_ADMIN_PASSWORD muss VOR dem ersten Start stehen, da es nur beim allerersten init wirkt.

cp .env.example .env
nano .env

Produktions-.env:

# --- Domain (OC_URL bildet die Compose-Datei daraus selbst) ---
OC_DOMAIN=cloud.DEINE-DOMAIN.de

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

# --- Image für Produktion auf stabile Linie + festen Tag pinnen ---
OC_DOCKER_IMAGE=opencloudeu/opencloud
OC_DOCKER_TAG=7.2.4

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

# --- Sicherheit / Betrieb (Vorlage steht auf true) ---
INSECURE=false
DEMO_USERS=false
LOG_LEVEL=info

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

Zu den Werten:

1. Image-Linie: Repo-Default ist opencloudeu/opencloud-rolling (sehr häufige Builds). Produktiv nutzen Sie opencloudeu/opencloud mit festem Tag (hier 7.2.4) statt latest. Die Linien haben eigene Versionsnummern: 6.2.0 oder 8.0.1 gibt es nur als opencloud-rolling, mit opencloudeu/opencloud endet der Pull mit „not found“.
2. TRAEFIK_ACME_CASERVER leer = Produktions-CA; zum Ausprobieren die Let’s-Encrypt-Staging-URL wegen der Rate-Limits.
3. INSECURE=false für Produktion. .env.example setzt INSECURE=true, was Zertifikatsprüfungen überspringt (nur für lokale Tests mit Self-Signed-Zertifikaten). Compose reicht den Wert als OC_INSECURE weiter.
4. COMPOSE_FILE-Reihenfolge: Basis zuerst, dann ggf. Web-Office, dann Proxy. Ohne Proxy-File ist kein Reverse-Proxy konfiguriert.

Verifizieren: docker compose config --services listet opencloud und traefik. docker compose config | grep -E 'OC_URL|OC_INSECURE|IDM_ADMIN_PASSWORD' zeigt Ihre Domain, "false" und Ihr Passwort.

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

Alternativ zu den modularen Files eine eigenständige compose.yaml für einen Single-Stack mit Traefik. Sie spiegelt das offizielle Verhalten: User 1000:1000, Startbefehl opencloud init || true; opencloud server, Named-Volumes für Config und Daten, Traefik mit Let’s Encrypt.

services:
  traefik:
    image: traefik:v3.7.12
    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:-7.2.4}
    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 läuft als nicht-root User 1000:1000
    user: "1000:1000"
    environment:
      OC_DOMAIN: ${OC_DOMAIN}
      OC_URL: https://${OC_DOMAIN}
      IDM_ADMIN_PASSWORD: ${INITIAL_ADMIN_PASSWORD}
      PROXY_HTTP_ADDR: 0.0.0.0:9200
      PROXY_TLS: "false"
      OC_INSECURE: "${INSECURE:-false}"
      IDM_CREATE_DEMO_USERS: "false"
      OC_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:

Der OpenCloud-Proxy lauscht intern auf 9200, darauf zeigt das Traefik-Label. TLS macht Traefik, daher PROXY_TLS=false. Die Named-Volumes opencloud-config (/etc/opencloud) und opencloud-data (/var/lib/opencloud) halten Konfiguration und Nutzdaten/Metadaten.

Im Test nachgeschärft: OpenCloud liest das Startpasswort aus IDM_ADMIN_PASSWORD. Als INITIAL_ADMIN_PASSWORD direkt im Container ignoriert opencloud init den Wert und erzeugt ein Zufallspasswort, das nur im Log steht; das offizielle Repo übersetzt die .env-Variable genau so. Außerdem muss Traefik zur Docker-Version passen: traefik:v3.3 scheiterte an Docker 29 mit „client version 1.24 is too old“ und fand keinen Container, die Repo-Version (v3.7.12) lief.

Verifizieren: docker compose config gibt die Datei ohne Fehler aus. docker compose pull lädt beide Images ohne „not found“.

Schritt 4: Stack starten und Logs prüfen

Mit offiziellem Repo und gesetztem COMPOSE_FILE genügt:

docker compose up -d

Alternativ die Files explizit per -f angeben:

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

Status und Logs prüfen. Der erste Start dauert, weil opencloud init Konfiguration und interne Zertifikate erzeugt und Traefik das Zertifikat anfordert:

docker compose ps
docker compose logs -f opencloud

Lauscht der Server und hat Traefik ein gültiges Zertifikat, ist OpenCloud unter Ihrer Domain erreichbar.

Verifizieren: docker compose ps zeigt alle Container als Up. curl -I https://cloud.DEINE-DOMAIN.de liefert 200, curl -I http://cloud.DEINE-DOMAIN.de eine Weiterleitung auf HTTPS. Im Log erscheint beim ersten Start „generated OpenCloud Config“; steht dort ein Zufallspasswort, wurde Ihr Passwort nicht übernommen.

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

Öffnen Sie https://cloud.DEINE-DOMAIN.de und melden Sie sich als admin mit dem INITIAL_ADMIN_PASSWORD an. (Lokal ohne Domain: https://localhost:9200, Self-Signed-Warnung manuell akzeptieren.)

OpenCloud arbeitet mit Spaces statt klassischer Ordnerfreigaben:

1. Persönlicher Space je Nutzer.
2. Projekt-Spaces für Teams, gezielt geteilt und mit Quota.
3. Berechtigungen und Mitglieder pro Space, übersichtlicher als verschachtelte Einzelfreigaben.

Legen Sie einen Projekt-Space an, laden Sie Nutzer ein und testen Sie den Upload. Benutzer und Gruppen verwalten Sie in der Web-UI (interner LibreIDM/LDAP).

Verifizieren: Die Anmeldung als admin klappt, der neue Projekt-Space erscheint in der Liste, und eine hochgeladene Testdatei lässt sich wieder herunterladen.

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

Für den öffentlichen Betrieb brauchen Sie echtes TLS, auf zwei Wegen:

1. Traefik (empfohlen, im Repo): belegt 80/443 (TRAEFIK_PORT_HTTP=80, TRAEFIK_PORT_HTTPS=443) und holt Let’s-Encrypt-Zertifikate. Pflicht: TRAEFIK_ACME_MAIL; TRAEFIK_ACME_CASERVER bleibt leer.
2. Eigener Reverse-Proxy (Nginx/Caddy): external-proxy/-Files nutzen; OpenCloud veröffentlicht 9200 (Collabora 9980), Ihr Proxy terminiert TLS.

External-Proxy-Modus inklusive Collabora in der .env:

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

Minimale Nginx-Weiterleitung:

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;
    }
}

Verifizieren: nginx -t meldet syntax is ok, curl -I https://cloud.DEINE-DOMAIN.de liefert 200, und echo | openssl s_client -connect cloud.DEINE-DOMAIN.de:443 -servername cloud.DEINE-DOMAIN.de 2>/dev/null | openssl x509 -noout -issuer nennt Let’s Encrypt statt „TRAEFIK DEFAULT CERT“.

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

Für gemeinsames Bearbeiten im Browser ergänzen Sie Collabora; bei Traefik über zusätzliche Compose-Files in der .env:

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

Anschließend neu hochfahren:

docker compose up -d

Relevante Variablen: COLLABORA_DOMAIN, WOPISERVER_DOMAIN, COLLABORA_ADMIN_USER/COLLABORA_ADMIN_PASSWORD, COLLABORA_SSL_ENABLE. Im External-Proxy-Modus muss Ihr Proxy Port 9980 weiterreichen. Collabora braucht eine eigene Subdomain mit DNS-Eintrag und rund 1 bis 2 GB RAM zusätzlich.

Verifizieren: docker compose ps zeigt den Collabora-Container als Up. Eine .docx-Datei in OpenCloud öffnet sich per Klick im Browser-Editor.

Schritt 8: Desktop- und Mobile-Sync einrichten

Synchronisiert wird über Clients:

1. Desktop: OpenCloud Desktop-Client für Windows, macOS und Linux; Server-URL https://cloud.DEINE-DOMAIN.de eintragen, anmelden.
2. Mobil: Apps für iOS und Android synchronisieren Spaces und Foto-Uploads.

Dank internem IDM (optional Keycloak/OIDC) gilt dasselbe Konto in allen Clients.

Verifizieren: Eine auf dem Desktop in den Sync-Ordner gelegte Datei erscheint nach wenigen Sekunden in der Web-UI und auf dem Smartphone.

Schritt 9: Update-Workflow und Backup

Neue Images ziehen und neu starten; Compose ersetzt nur geänderte Container:

docker compose pull
docker compose up -d
docker image prune -f   # optional: alte Images aufräumen

Mit festem Tag erhöhen Sie für ein Update gezielt OC_DOCKER_TAG in der .env, vorher git pull im Repo (Compose-Files und Traefik-Version passend zur neuen Version), dann pull und up -d. So vermeiden Sie ungewollte Sprünge der rolling-Linie.

Backup: Sichern Sie bei gestopptem Container (oder per konsistentem Snapshot) die Volumes samt .env. Named Volumes liegen nicht im Projektordner; Compose stellt den Projektnamen voran, im offiziellen Repo also opencloud-compose_opencloud-data. Den genauen Namen zeigt docker volume ls:

docker compose stop
docker run --rm \
  -v opencloud-compose_opencloud-config:/src/config:ro \
  -v opencloud-compose_opencloud-data:/src/data:ro \
  -v "$PWD":/backup alpine \
  tar czf /backup/opencloud-backup-$(date +%F).tar.gz -C /src config data
cp .env opencloud-env-$(date +%F).bak
docker compose start

Bewahren Sie die .env getrennt und sicher auf: Sie enthält Passwörter und Secrets und ist absichtlich aus der Versionskontrolle ausgeschlossen.

Verifizieren: tar tzf opencloud-backup-*.tar.gz | head listet config/opencloud.yaml und data/idm/idm.boltdb. Nach dem Update zeigt docker compose exec opencloud opencloud version die neue Versionsnummer.

Troubleshooting

1. Login-Fehler 500 / Permission-Probleme: Bind-Mounts müssen UID/GID 1000 gehören: sudo chown -R 1000:1000 opencloud-data opencloud-config (Issue #195 im Compose-Repo). Named-Volumes sind unkomplizierter.
2. Compose-File schlägt fehl: vermutlich Compose v1 (docker-compose); Compose-v2-Plugin installieren, docker compose aufrufen.
3. Traefik liefert 404 und „TRAEFIK DEFAULT CERT“: Log meldet „client version 1.24 is too old“, Traefik ist zu alt für Docker. Version aus dem aktuellen Repo nutzen (git pull).
4. Let’s Encrypt stellt kein Zertifikat aus: DNS muss VOR dem Start stimmen, 80/443 offen sein; zum Testen Staging-URL in TRAEFIK_ACME_CASERVER.
5. Alles läuft unter cloud.opencloud.test: OC_DOMAIN nicht angepasst; echte Domain eintragen, neu starten.
6. Admin-Passwort wirkt nicht: INITIAL_ADMIN_PASSWORD greift nur beim ersten init; danach in der Web-UI unter Einstellungen > Sicherheit ändern.
7. LDAP-Verbindungsfehler nach Wochen/Monaten: Das interne LibreIDM-Zertifikat (ldap.crt/ldap.key) kann ablaufen. Beide Dateien im Config-Volume löschen und neu starten, sie werden neu erzeugt. Produktiv empfiehlt OpenCloud OpenLDAP oder Keycloak statt des internen IDM.

Häufige Fragen

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

Nein. Internes IDM/LDAP und Metadaten-Store sind im Go-Binary enthalten; MySQL/MariaDB oder PostgreSQL entfallen.

Was ist der Unterschied zwischen opencloud-rolling und opencloud?

Siehe Schritt 2: opencloud-rolling ist der häufig gebaute Repo-Default, produktiv nehmen Sie opencloudeu/opencloud mit festem Tag. Die Tags sind nicht austauschbar.

Kann ich OpenCloud hinter meinem vorhandenen Nginx oder Caddy betreiben?

Ja, über die external-proxy/-Files (Schritt 6).

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

In der Web-UI unter Einstellungen > Sicherheit; INITIAL_ADMIN_PASSWORD wird nach dem ersten init ignoriert.

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

Nein. Relevanter sind Disk-IOPS (SSD/NVMe) und genug RAM für die Nutzerzahl.

Läuft OpenCloud auf einem Raspberry Pi?

Ja, bis ca. 10 Nutzer reicht ein Raspberry Pi 4 (ARM64). Nutzen Sie schnelle Speichermedien statt SD-Karten.

Fazit

OpenCloud ist eine schlanke Alternative zu Nextcloud und ownCloud: ein Go-Binary, keine externe Datenbank, Spaces und ein modulares Compose-Setup. Produktiv zählen drei Dinge: stabile Image-Linie mit festem Tag, Domain und INITIAL_ADMIN_PASSWORD vor dem ersten Start, echtes TLS über Traefik oder eigenen Proxy. Updates und Backups sind dann in wenigen Befehlen erledigt.

Weiterführende Anleitungen und Quellen

Passende Anleitungen:

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

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

1. OpenCloud Compose – offizielles Deployment-Repo (GitHub)
2. OpenCloud Docs – Docker Compose Base (Getting Started)
3. OpenCloud Docs – Requirements (Hardware/Storage)
4. OpenCloud Docs – Single Container Docker und Common Issues