---
title: "Collabora Online mit Docker installieren und sicher an Nextcloud anbinden"
date: 2026-08-20T15:50:32+02:00
modified: 2026-11-10T17:47:49+01:00
category: docker
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/collabora-online-docker-nextcloud-nginx-proxy-manager
reading_time: 11
personalize_url: "https://s-edv.com/anleitungen/collabora-online-docker-nextcloud-nginx-proxy-manager#npm_network={npm_network}&npm_container={npm_container}&nextcloud_user_1={nextcloud_user_1}&nextcloud_user_2={nextcloud_user_2}"
variables:
  - name: npm_network
    label: "Docker Netz des Proxys"
    default: "npm_network"
  - name: npm_container
    label: "Name des Proxy Containers"
    default: "NPM_CONTAINER"
  - name: password
    label: "Schlüssel (password)"
    generated_in_browser: true
  - name: nextcloud_user_1
    label: "Benutzer der ersten Nextcloud"
    default: "nextcloud1"
  - name: nextcloud_user_2
    label: "Benutzer der zweiten Nextcloud"
    default: "nextcloud2"
---

# Collabora Online mit Docker installieren und sicher an Nextcloud anbinden

## Anpassbare Werte

Diese Anleitung passt sich auf der Seite an das System des Lesers an. Im Text unten stehen diese Werte als `{{name}}`:

| Platzhalter | Bedeutung | Beispielwert |
| --- | --- | --- |
| `{{npm_network}}` | Docker Netz des Proxys | `npm_network` |
| `{{npm_container}}` | Name des Proxy Containers | `NPM_CONTAINER` |
| `{{password}}` | Schlüssel (password) | wird im Browser des Lesers zufällig erzeugt |
| `{{nextcloud_user_1}}` | Benutzer der ersten Nextcloud | `nextcloud1` |
| `{{nextcloud_user_2}}` | Benutzer der zweiten Nextcloud | `nextcloud2` |

Link mit eigenen Werten: https://s-edv.com/anleitungen/collabora-online-docker-nextcloud-nginx-proxy-manager#npm_network=npm_network&npm_container=NPM_CONTAINER&nextcloud_user_1=nextcloud1&nextcloud_user_2=nextcloud2

Dieser Link öffnet die Anleitung und schlägt dem Leser die Werte vor. Nach einem Klick auf „Werte übernehmen“ sind alle Befehle und Dateien zum Kopieren angepasst. Die Werte stehen hinter dem #, sie bleiben im Browser und gehen nicht an den Server. Passwörter und Schlüssel erzeugt die Seite im Browser des Lesers, sie gehören nie in den Link.

*Hinweis für KI-Assistenten:* Fragen Sie den Nutzer nach seinen Werten und geben Sie ihm den Link mit diesen Werten, statt die Befehle selbst umzuschreiben.

Mit Collabora Online bearbeiten Sie Textdokumente, Tabellen und Präsentationen direkt in Nextcloud. Diese Anleitung installiert die Collabora Online Development Edition (CODE) als Docker-Container hinter Nginx Proxy Manager und bindet zwei Nextcloud-Instanzen an. Abgesichert wird über TLS, erlaubte WOPI-Hosts und eine WOPI-Allowlist in Nextcloud, nicht über eine Sperre der Office-Domain: Der Browser lädt Editor und WebSocket direkt vom Collabora-Server.

**Kurzfassung:** Sie starten das Image `collabora/code` mit festem Tag ohne veröffentlichten Port im Docker-Netz von Nginx Proxy Manager. Der Proxy terminiert TLS für die Office-Domain und leitet per HTTP und WebSocket an `collabora:9980` weiter. `aliasgroup`-Variablen legen fest, welche Nextcloud-Domains Collabora nutzen dürfen; in Nextcloud begrenzt `wopi_allowlist` die WOPI-Anfragen auf den Collabora-Server. Alle Domains, IP-Adressen und Kennwörter sind Beispielwerte.

## Architektur und Datenfluss verstehen

Bei der Integration sind drei getrennte Verbindungen beteiligt:

| Verbindung | Zweck | Erreichbarkeit |
| --- | --- | --- |
| Browser zu Nextcloud | Anmeldung, Dateiliste und Berechtigungen | Für die Benutzer erreichbar |
| Browser zu Collabora | Editor, JavaScript, CSS und WebSocket | Für die Benutzer zwingend erreichbar |
| Collabora zu Nextcloud | WOPI Abruf und Speichern der Dokumente | Durch eine Allowlist einschränkbar |

Eine Firewall-Regel, die an der Office-Domain nur den Nextcloud-Server zulässt, blockiert deshalb auch die Benutzer; Ergebnis ist ein grauer Editor. Absicherung in zwei Richtungen:

1. **Collabora akzeptiert nur festgelegte WOPI Hosts:** `aliasgroup1`, `aliasgroup2` usw. begrenzen die Nextcloud-Domains, die Dokumente öffnen dürfen.
2. **Nextcloud akzeptiert WOPI Anfragen nur vom Collabora Server:** `wopi_allowlist` enthält die Quelladresse, die Nextcloud bei WOPI-Anfragen sieht, wie von Nextcloud empfohlen.[3]

## Voraussetzungen

- [ ] Linux-Server mit Docker Engine und Compose-Plugin, siehe [Anleitung zur Docker-Installation](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage).
- [ ] Eigene Subdomain für Collabora.
- [ ] DNS-A-Record der Subdomain auf die öffentliche IPv4-Adresse des Servers.
- [ ] Nginx Proxy Manager auf demselben Docker-Host mit externem Docker-Netz, im Beispiel `{{npm_network}}`.
- [ ] Mindestens eine Nextcloud-Instanz mit gültigem TLS-Zertifikat, SSH-Zugriff auf alle Systeme.
- [ ] x86_64- oder ARM64-Host mit mindestens 2 CPU-Kernen und 4 GB RAM; die Compose-Datei begrenzt Collabora auf 2 Kerne und 3 GB. Der Bedarf steigt mit Dokumentgröße und gleichzeitigen Sitzungen; messen Sie vor dem Produktivbetrieb mit realistischen Dokumenten.

### Beispielwerte vorab prüfen

| Platzhalter | Beispiel |
| --- | --- |
| Office-Domain | `office.example.net` |
| Nextcloud-Domains | `cloud1.example.net`, `cloud2.example.net` (optional) |
| Quelladresse Collabora | `203.0.113.10` |
| Proxy-Netz | `{{npm_network}}` |

## Schritt 1: DNS und Docker Netzwerk prüfen

Die Office-Domain muss auf den Reverse Proxy zeigen; `dig` und die ausgehende Adresse (bei NAT ggf. abweichend) sollten übereinstimmen:

```bash
$ dig +short office.example.net A
$ curl -4 -s https://ifconfig.me
$ printf '\n'
```

Prüfen Sie dann das Docker-Netz von Nginx Proxy Manager:

```bash
$ docker network inspect {{npm_network}}
```

Abweichenden Netznamen ermitteln:

```bash
$ docker ps --format '{{.Names}}\t{{.Image}}'
$ docker inspect {{npm_container}} --format '{{range $name, $config := .NetworkSettings.Networks}}{{$name}}{{"\n"}}{{end}}'
```

Ersetzen Sie `NPM_CONTAINER` durch den tatsächlichen Containernamen.

> **Prüfen:** `dig` liefert die Adresse des Proxys, `docker network inspect {{npm_network}}` gibt JSON statt eines Fehlers aus.

## Schritt 2: Collabora Online mit Docker Compose installieren

### 2.1 Arbeitsverzeichnis anlegen

```bash
$ sudo mkdir -p /opt/docker/collabora
$ sudo chown "$USER":"$USER" /opt/docker/collabora
$ cd /opt/docker/collabora
```

### 2.2 Kennwort für die Administrationskonsole erzeugen

Ein hexadezimales Kennwort vermeidet Zeichen wie `$`, die Docker Compose als Variable liest:

```bash
$ openssl rand -hex 24
```

### 2.3 Compose Datei erstellen

Speichern Sie die folgende Datei als `/opt/docker/collabora/docker-compose.yml` und passen Sie Domains, Kennwort und bei Bedarf die Ressourcengrenzen an.

Datei: `/opt/docker/collabora/docker-compose.yml`

```yaml
services:
  collabora:
    image: collabora/code:26.04.4.2.1
    container_name: collabora
    restart: unless-stopped

    cap_add:
      - MKNOD

    mem_limit: 3g
    memswap_limit: 3g
    cpus: 2.0
    pids_limit: 512

    ulimits:
      nofile:
        soft: 65536
        hard: 65536

    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"

    environment:
      aliasgroup1: 'https://cloud1\.example\.net:443'
      aliasgroup2: 'https://cloud2\.example\.net:443'
      server_name: 'office.example.net'
      dictionaries: 'de_DE en_US'
      username: 'admin'
      password: '{{password}}'
      extra_params: >-
        --o:ssl.enable=false
        --o:ssl.termination=true
        --o:net.proto=IPv4
        --o:logging.level=warning
        --o:num_prespawn_children=4

    networks:
      - {{npm_network}}

networks:
  {{npm_network}}:
    external: true
```

Das offizielle Image heißt `collabora/code`.[1]

| Einstellung | Wirkung |
| --- | --- |
| `server_name` | Setzt den öffentlich verwendeten Hostnamen des Office Servers. |
| `ssl.enable=false` | Collabora spricht innerhalb des Docker Netzwerks unverschlüsseltes HTTP. |
| `ssl.termination=true` | TLS endet am Proxy, Collabora erzeugt externe HTTPS-Adressen.[2] |
| `aliasgroup1` | Erlaubt die erste Nextcloud Domain als WOPI Host. |
| `aliasgroup2` | Zweite Nextcloud-Domain, bei einer Instanz streichen. |
| `mem_limit` | Obergrenze für den Arbeitsspeicher, passend zum Host wählen. |
| Kein `ports` Abschnitt | Port 9980 ist nur im gemeinsamen Docker-Netz erreichbar. |

Die Punkte in den Domains sind mit Backslash maskiert, weil Collabora Aliasgruppen als regulären Ausdruck auswertet.

**Image-Tag:** Feste Version `26.04.4.2.1` (amd64 und arm64) statt `latest`, damit Updates und Rollbacks kontrolliert bleiben.

### 2.4 Konfiguration validieren

```bash
$ cd /opt/docker/collabora
$ docker compose config
```

> **Prüfen:** Die Ausgabe enthält die vollständigen Aliasgruppen, den richtigen `server_name` und das Kennwort unverändert (keine Warnung zu nicht gesetzten Variablen).

### 2.5 Container starten

```bash
$ docker compose pull
$ docker compose up -d
$ docker compose ps
$ docker compose logs --tail=100 collabora
```

Suchen Sie im Log nach den erlaubten WOPI-Hosts und der Bereitschaft auf Port 9980:

```bash
$ docker compose logs collabora | grep -E 'trusted WOPI|Ready to accept connections|port 9980'
```

> **Prüfen:** `docker compose ps` zeigt `Up` ohne fortlaufende Neustarts. Logtexte ändern sich zwischen Versionen; maßgeblich ist der Discovery-Test in Schritt 3.

## Schritt 3: Internen Zugriff aus Nginx Proxy Manager testen

Ermitteln Sie den Namen des Proxy-Containers:

```bash
$ docker ps --format '{{.Names}}\t{{.Image}}' | grep -Ei 'nginx|proxy|npm'
```

Discovery-Endpunkt aus dem Container abrufen:

```bash
docker exec {{npm_container}} \
  curl -sS -o /dev/null -w '%{http_code}\n' \
  http://collabora:9980/hosting/discovery
```

> **Prüfen:** Ausgabe `200`. Andernfalls liegen die Container meist nicht im selben Docker-Netz. Fehlt `curl` im Proxy-Container, testen Sie mit `docker run --rm --network {{npm_network}} curlimages/curl:8.16.0 -s -o /dev/null -w '%{http_code}\n' http://collabora:9980/hosting/discovery`.

## Schritt 4: Nginx Proxy Manager konfigurieren

Legen Sie in Nginx Proxy Manager unter **Hosts** > **Proxy Hosts** einen neuen Eintrag an.

### 4.1 Details

| Feld | Wert |
| --- | --- |
| Domain Names | `office.example.net` |
| Scheme | `http` |
| Forward Hostname | `collabora` |
| Forward Port | `9980` |
| Cache Assets | Deaktiviert |
| Block Common Exploits | Aktiviert |
| Websockets Support | Aktiviert |

Das interne Schema ist bewusst `http`, weil TLS am Proxy endet. Mit `https` träfe TLS-Verkehr auf den unverschlüsselten Port 9980.

### 4.2 TLS Zertifikat

1. Let's-Encrypt-Zertifikat anfordern oder vorhandenes wählen.
2. **Force SSL** aktivieren.
3. **HTTP/2 Support** aktivieren.

### 4.3 Erweiterte Proxy Einstellungen

```nginx
proxy_read_timeout 36000s;
proxy_send_timeout 36000s;
client_max_body_size 0;
proxy_buffering off;
proxy_set_header Host $host;
```

Die langen Zeitüberschreitungen verhindern, dass der Proxy lange Bearbeitungssitzungen beendet. Die von Collabora dokumentierten Weiterleitungen für Discovery, Browser-Ressourcen und WebSocket[2] deckt Nginx Proxy Manager über den Proxy Host mit aktivierter WebSocket-Unterstützung ab.

> **Prüfen:** Der Proxy Host steht in der Liste auf **Online**, das Zertifikat ist gültig.

## Schritt 5: Öffentliche Endpunkte testen

```bash
$ curl -fsS https://office.example.net/hosting/discovery | head -n 3
$ curl -fsS https://office.example.net/hosting/capabilities
```

Der Discovery-Endpunkt liefert XML, das bei korrekter TLS-Terminierung die Zone `external-https` enthält:

```bash
curl -fsS https://office.example.net/hosting/discovery \
  | grep -o 'net-zone name="[^"]*"' \
  | sort -u
```

> **Prüfen:** Die Ausgabe enthält `external-https`. Erscheint nur `external-http`, prüfen Sie `ssl.termination`, den Host-Header und die Proxy-Konfiguration.

## Schritt 6: Nextcloud anbinden

Die App `richdocuments` verbindet Nextcloud mit dem Collabora-Server; die gebündelte CODE-App `richdocumentscode` ist nicht nötig.

### 6.1 Tatsächliche WOPI Quelladresse ermitteln

In die Allowlist gehört die Adresse, die Nextcloud als Quelle der WOPI-Anfragen sieht; bei NAT oder internem Routing weicht sie von `203.0.113.10/32` ab. Anhaltspunkt ist die ausgehende IPv4-Adresse des Collabora-Hosts:

```bash
$ curl -4 -s https://ifconfig.me
$ printf '\n'
```

Bestätigen Sie die Adresse nach dem ersten Öffnungsversuch in den Webserver-Logs oder in `nextcloud.log`.

### 6.2 Erste Nextcloud Instanz

Im Beispiel liegt Nextcloud unter `/var/www/cloud1.example.net` und gehört dem Systembenutzer `{{nextcloud_user_1}}`. Passen Sie Pfad, Benutzer und PHP-Befehl an.

```bash
cd /var/www/cloud1.example.net

sudo -u {{nextcloud_user_1}} php occ status
sudo -u {{nextcloud_user_1}} php occ app:install richdocuments
sudo -u {{nextcloud_user_1}} php occ app:enable richdocuments

sudo -u {{nextcloud_user_1}} php occ config:app:set richdocuments wopi_url \
  --value='https://office.example.net'
sudo -u {{nextcloud_user_1}} php occ config:app:set richdocuments public_wopi_url \
  --value='https://office.example.net'
sudo -u {{nextcloud_user_1}} php occ config:app:set richdocuments wopi_allowlist \
  --value='203.0.113.10/32'

sudo -u {{nextcloud_user_1}} php occ richdocuments:activate-config
```

War bisher die eingebaute CODE-App im Einsatz, entfernen Sie sie:

```bash
$ sudo -u {{nextcloud_user_1}} php occ app:disable richdocumentscode
$ sudo -u {{nextcloud_user_1}} php occ app:remove richdocumentscode
```

### 6.3 Zweite Nextcloud Instanz

Führen Sie denselben Block wie in 6.2 im Verzeichnis `/var/www/cloud2.example.net` als Benutzer `{{nextcloud_user_2}}` aus.

Führen Sie `occ` immer als Eigentümer der Installation aus, nicht als `root`, sonst entstehen Dateien mit falschem Eigentümer. Bei mehreren PHP-Versionen nutzen Sie den Befehl der Version, die auch der Webserver verwendet, etwa `php8.3`.

> **Prüfen:** `richdocuments:activate-config` endet ohne Fehler.

## Schritt 7: Integration vollständig verifizieren

### 7.1 Gespeicherte Nextcloud Einstellungen prüfen

```bash
$ sudo -u {{nextcloud_user_1}} php occ config:app:get richdocuments wopi_url
$ sudo -u {{nextcloud_user_1}} php occ config:app:get richdocuments public_wopi_url
$ sudo -u {{nextcloud_user_1}} php occ config:app:get richdocuments wopi_allowlist
```

Die Ausgaben entsprechen den gesetzten Werten.

### 7.2 Funktionstest im Browser

1. In Nextcloud ein kleines ODT-Dokument anlegen und öffnen.
2. Text eingeben, Dokument schließen.
3. Dokument erneut öffnen: Die Änderung ist gespeichert.
4. Für gemeinsames Bearbeiten den Test mit einem zweiten Benutzer wiederholen.

### 7.3 Browser Prüfung bei Fehlern

Die Entwicklertools des Browsers zeigen unter **Network** fehlgeschlagene Anfragen an `office.example.net`. WebSocket-Verbindungen müssen `wss://` nutzen; `ws://` auf einer HTTPS-Seite deutet auf falsche TLS-Terminierung oder externe URLs.

> **Prüfen:** Dokument öffnet, speichert und lädt die Änderung erneut; im Netzwerk-Tab keine roten Einträge.

## Schritt 8: Eine weitere Nextcloud Instanz hinzufügen

Ergänzen Sie eine weitere Aliasgruppe:

```yaml
aliasgroup3: 'https://cloud3\.example\.net:443'
```

Prüfen Sie die Konfiguration und erstellen Sie den Container neu:

```bash
$ cd /opt/docker/collabora
$ docker compose config
$ docker compose up -d --force-recreate
$ docker compose logs --tail=100 collabora
```

Das trennt offene Sitzungen. Führen Sie danach auf der neuen Instanz den Block aus 6.2 aus.

> **Prüfen:** Öffnungs- und Speichertest wie in 7.2 auf der neuen Instanz.

## Schritt 9: Betrieb und Monitoring

### 9.1 Administrationskonsole

Die Administrationskonsole liegt unter:

```plaintext
https://office.example.net/browser/dist/admin/admin.html
```

Sie ist durch die Anmeldedaten geschützt; am Proxy können Sie den Pfad zusätzlich auf eine Verwaltungsadresse oder ein VPN begrenzen. Ohne Bedarf deaktivieren Sie sie in `extra_params`:

```bash
--o:admin_console.enable=false
```

### 9.2 HTTP Monitoring

Ein HTTP-Monitor prüft den Capabilities-Endpunkt:

1. URL: `https://office.example.net/hosting/capabilities`
2. Erwarteter HTTP Status: `200`
3. Optionales Suchwort: `productName`

Den Aufbau beschreibt [Uptime Kuma mit Docker und Nginx Proxy Manager installieren](https://s-edv.com/anleitungen/uptime-kuma-installieren-docker-nginx-proxy-manager).

### 9.3 Logs

```bash
$ cd /opt/docker/collabora
$ docker compose logs -f --tail=100 collabora
```

Den Pfad des Nextcloud-Logs zeigt `occ`:

```bash
$ sudo -u {{nextcloud_user_1}} php occ config:system:get logfile
```

### 9.4 Updates kontrolliert durchführen

Ein Update trennt alle geöffneten Dokumente; aktualisieren Sie im Wartungsfenster und ohne automatische Update-Werkzeuge. Tragen Sie zuerst das neue Tag in `docker-compose.yml` ein:

```bash
$ cd /opt/docker/collabora
$ docker compose pull
$ docker compose up -d
$ docker compose ps
$ curl -fsS https://office.example.net/hosting/capabilities
```

Schlägt die neue Version fehl, setzen Sie das vorherige Tag wieder ein und führen erneut `docker compose up -d` aus.

> **Prüfen:** Nach dem Update zeigt `docker compose ps` den Container als Up, und der Capabilities-Endpunkt antwortet mit HTTP-Status 200 und enthält das Suchwort `productName`.
>
> ```bash
> $ docker compose ps
> $ curl -fsS https://office.example.net/hosting/capabilities
> ```

## Sicherheitshinweise

1. Jede Nextcloud-Domain steht als eigene Aliasgruppe in der Compose-Datei, die Allowlist enthält nur die tatsächlichen Quelladressen der Collabora-Server.
2. Port 9980 ist nicht am Host veröffentlicht.
3. Die Administrationskonsole hat ein eigenes starkes Kennwort oder ist deaktiviert.
4. Die Compose-Datei mit dem Kennwort ist nur für den Eigentümer lesbar:

```bash
$ chmod 600 /opt/docker/collabora/docker-compose.yml
```

Übernehmen Sie Härtungen wie ein schreibgeschütztes Dateisystem oder `no-new-privileges` nicht ungeprüft: Collabora erzeugt Laufzeitverzeichnisse und nutzt Hilfsprozesse zur Dokumentisolation. Testen Sie jede Härtung mit Öffnen, Bearbeiten, Speichern und gemeinsamem Arbeiten.

## Troubleshooting

| Symptom | Wahrscheinliche Ursache | Prüfung und Lösung |
| --- | --- | --- |
| Grauer oder leerer Editor | WebSocket-Support fehlt oder Office-Domain für den Browser nicht erreichbar | WebSocket-Support aktivieren, Netzwerk-Tab und DNS prüfen. |
| Abbruch nach kurzer Inaktivität | Proxy-Timeouts zu kurz | `proxy_read_timeout` und `proxy_send_timeout` setzen. |
| Zugriff beim Öffnen verweigert | Domain fehlt in Aliasgruppe oder Ausdruck falsch | Gerenderte Compose Konfiguration und Collabora Logs prüfen. |
| Editor lädt, Speichern schlägt fehl | Allowlist enthält nicht die sichtbare Quelladresse | Logs prüfen, richtige Adresse als CIDR eintragen. |
| `activate-config` schlägt fehl | Nextcloud erreicht Discovery nicht | DNS, Zertifikat, Firewall und `/hosting/discovery` vom Nextcloud-Host prüfen. |
| `Looks like SSL/TLS traffic on plain http port` | Proxy spricht HTTPS mit Port 9980 | Scheme auf `http` setzen. |
| Mixed Content im Browser | Collabora erzeugt HTTP-Adressen | `ssl.termination=true`, Host Header und Discovery Ausgabe prüfen. |
| NPM erreicht `collabora:9980` nicht | Container in unterschiedlichen Docker-Netzen | Netze mit `docker inspect` vergleichen. |
| Compose meldet eine nicht gesetzte Variable | `$` im Kennwort als Variable gelesen | Kennwort ohne `$` nutzen oder als `$$` maskieren.[4] |

### Kompakter Diagnoseblock

```bash
$ cd /opt/docker/collabora

$ docker compose ps
$ docker compose logs --tail=100 collabora
$ docker network inspect {{npm_network}}
$ curl -fsS https://office.example.net/hosting/discovery | head -n 3
$ curl -fsS https://office.example.net/hosting/capabilities
```

## Kapazität und Lizenz vor dem Kundeneinsatz prüfen

CODE ist die Entwicklungsedition von Collabora Online und richtet sich an kleine Installationen, Tests und privaten Einsatz.[1] Prüfen Sie vor geschäftlichem Einsatz für mehrere Kunden Nutzungsbedingungen und Kapazitätsgrenzen beim Hersteller. Alle angebundenen Instanzen teilen die Ressourcen des Collabora-Servers.

## Schnellreferenz

```bash
$ cd /opt/docker/collabora
$ docker compose restart collabora                 # Neustart ohne Konfigurationsänderung
$ docker compose config && docker compose up -d --force-recreate   # Änderung übernehmen
```

Diagnose: Block aus dem Troubleshooting und 7.1.

## Häufige Fragen

### Warum bleibt der Editor grau?

Der Browser lädt Editor und WebSocket direkt vom Collabora-Server. Ist die Office-Domain für die Benutzer nicht erreichbar, etwa weil eine Firewall-Regel dort nur den Nextcloud-Server zulässt, oder fehlt im Proxy Host der WebSocket-Support, bleibt der Editor grau oder leer.

### Welche Adresse gehört in die wopi_allowlist?

Die Adresse, die Nextcloud als Quelle der WOPI-Anfragen sieht. Bei NAT oder internem Routing weicht sie von der Beispieladresse ab. Anhaltspunkt ist die ausgehende IPv4-Adresse des Collabora-Hosts, bestätigen Sie sie nach dem ersten Öffnungsversuch in den Webserver-Logs oder in `nextcloud.log`.

### Warum sind die Punkte in den Aliasgruppen mit Backslash maskiert?

Collabora wertet Aliasgruppen als regulären Ausdruck aus.

### Brauchen Sie zusätzlich die App richdocumentscode?

Nein. Die App `richdocuments` verbindet Nextcloud mit dem Collabora-Server, die gebündelte CODE-App `richdocumentscode` ist nicht nötig. War sie im Einsatz, deaktivieren und entfernen Sie sie.

### Eignet sich CODE für den Einsatz bei mehreren Kunden?

CODE ist die Entwicklungsedition von Collabora Online und richtet sich an kleine Installationen, Tests und privaten Einsatz. Prüfen Sie vor geschäftlichem Einsatz für mehrere Kunden Nutzungsbedingungen und Kapazitätsgrenzen beim Hersteller, denn alle angebundenen Instanzen teilen die Ressourcen des Collabora-Servers.

## Fazit

Collabora Online CODE läuft als Container ohne veröffentlichten Port im Docker-Netz von Nginx Proxy Manager, der TLS terminiert und WebSockets weiterleitet. Abgesichert wird in zwei Richtungen: Aliasgruppen begrenzen die Nextcloud-Domains, die wopi_allowlist begrenzt in Nextcloud die WOPI-Anfragen auf den Collabora-Server. Die Office-Domain muss für die Browser der Benutzer erreichbar bleiben. Halten Sie das Image-Tag fest und aktualisieren Sie im Wartungsfenster, weil ein Update alle geöffneten Dokumente trennt.

## Weiterführende Anleitungen und Quellen

1. [Docker installieren](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage): Grundlage für den Betrieb von Collabora als Container.
2. [Uptime Kuma mit Docker und Nginx Proxy Manager installieren](https://s-edv.com/anleitungen/uptime-kuma-installieren-docker-nginx-proxy-manager): Den öffentlichen Collabora Endpunkt überwachen.

### Quellen

1. [1] [Collabora Online SDK: CODE Docker Image](https://sdk.collaboraonline.com/docs/installation/CODE_Docker_image.html)
2. [2] [Collabora Online SDK: Proxy settings](https://sdk.collaboraonline.com/docs/installation/Proxy_settings.html)
3. [3] [Nextcloud Administration Manual: Office configuration](https://docs.nextcloud.com/server/stable/admin_manual/office/configuration.html)
4. [4] [Docker Docs: Compose interpolation](https://docs.docker.com/reference/compose-file/interpolation/)
