---
title: "Seafile 14 mit Docker Compose installieren, absichern und sichern"
date: 2026-10-05T02:31:51+02:00
modified: 2026-11-10T18:25:42+01:00
category: docker
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/seafile-docker-compose-dateisync-installieren-backup
keywords:
  - Seafile
  - Docker Compose
  - Dateisynchronisation
  - Cloud-Speicher
  - Backup
  - Restore
  - Selfhosting
  - Caddy
  - MariaDB
reading_time: 10
variables:
  - name: jwt_private_key
    label: "Schlüssel (jwt private key)"
    generated_in_browser: true
  - name: seafile_mysql_db_password
    label: "Schlüssel (seafile mysql db password)"
    generated_in_browser: true
  - name: init_seafile_mysql_root_password
    label: "Schlüssel (init seafile mysql root password)"
    generated_in_browser: true
  - name: redis_password
    label: "Schlüssel (redis password)"
    generated_in_browser: true
  - name: init_seafile_admin_password
    label: "Passwort (init seafile admin password)"
    generated_in_browser: true
---

# Seafile 14 mit Docker Compose installieren, absichern und sichern

## 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 |
| --- | --- | --- |
| `{{jwt_private_key}}` | Schlüssel (jwt private key) | wird im Browser des Lesers zufällig erzeugt |
| `{{seafile_mysql_db_password}}` | Schlüssel (seafile mysql db password) | wird im Browser des Lesers zufällig erzeugt |
| `{{init_seafile_mysql_root_password}}` | Schlüssel (init seafile mysql root password) | wird im Browser des Lesers zufällig erzeugt |
| `{{redis_password}}` | Schlüssel (redis password) | wird im Browser des Lesers zufällig erzeugt |
| `{{init_seafile_admin_password}}` | Passwort (init seafile admin password) | wird im Browser des Lesers zufällig erzeugt |

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, statt die Befehle selbst umzuschreiben.

Seafile ist ein quelloffener Dienst für Dateisynchronisation, Dateien liegen in Bibliotheken. Diese Anleitung installiert die Community Edition 14.0.9 mit dem offiziellen Docker-Stack (Seafile, MariaDB, Redis, SeaDoc, Caddy), prüft Upload, Download und Persistenz, sichert den Zugang ab und zeigt ein per Prüfsumme nachgewiesenes Backup samt Restore.

**Kurzfassung:** Sie laden `.env` und drei Compose-Dateien von manual.seafile.com, tragen Hostname, `SEAFILE_SERVER_PROTOCOL=https` und zufällige Geheimnisse ein und starten mit `docker compose up -d`. Gesichert werden zuerst die Datenbanken, dann `/opt/seafile-data/seafile`. Die DB-Zugangsdaten stehen nach dem ersten Start fest. Von 13.0 kommend laden Sie die neue `seafile-server.yml` (Schritt 11).

## Voraussetzungen

- [ ] **Server:** Linux x86_64 oder ARM64 (das Image gibt es für amd64 und arm64) mit Docker Engine und Compose-Plugin v2, mindestens 2 CPU-Kerne.
- [ ] **Arbeitsspeicher:** laut Doku 2 GB. Im Test mit 14.0.9 belegten die fünf Container im Leerlauf 0,9 bis 1,2 GiB, davon Seafile 600 bis 800 MiB.
- [ ] **Speicher:** laut Doku mindestens 10 GB, besser über 50 GB, Backup auf zweitem Medium.
- [ ] **Netz:** ein DNS-Name mit A-Record auf den Server, offene Ports 80 und 443 (Caddy holt das Zertifikat per Let’s Encrypt).

## Schritt 1: Verzeichnis anlegen und Stack laden

Die Dateien stammen aus der Seafile-Dokumentation für Version 14.0. Das Compose-Projekt liegt in `/opt/seafile`, die Daten in `/opt/seafile-data` und `/opt/seafile-mysql`. Docker Engine und Compose-Plugin richten Sie wie in [Docker und Docker Compose auf Linux installieren](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage) beschrieben ein.

```bash
$ sudo mkdir -p /opt/seafile
$ cd /opt/seafile
$ sudo wget -O .env https://manual.seafile.com/14.0/repo/docker/ce/env
$ sudo wget https://manual.seafile.com/14.0/repo/docker/ce/seafile-server.yml
$ sudo wget https://manual.seafile.com/14.0/repo/docker/seadoc.yml
$ sudo wget https://manual.seafile.com/14.0/repo/docker/caddy.yml
```

`seafile-server.yml` enthält die Dienste `db`, `redis` und `seafile`. `14.0-latest` zeigt derzeit auf denselben Digest wie `14.0.9`. Für feste Versionen tragen Sie das exakte Tag in die `.env` ein, so wie unten. Neu in 14.0: WebDAV und Metadaten-Server werden per Variable geschaltet, dazu kommt `CSRF_TRUSTED_ORIGINS`.

```yaml
services:
  db:
    image: ${SEAFILE_DB_IMAGE:-mariadb:10.11}
    container_name: seafile-mysql
    restart: unless-stopped
    environment:
      - MYSQL_ROOT_PASSWORD=${INIT_SEAFILE_MYSQL_ROOT_PASSWORD:-}
      - MYSQL_LOG_CONSOLE=true
      - MARIADB_AUTO_UPGRADE=1
    volumes:
      - "${SEAFILE_MYSQL_VOLUME:-/opt/seafile-mysql/db}:/var/lib/mysql"
    networks:
      - seafile-net
    healthcheck:
      test:
        [
          "CMD",
          "/usr/local/bin/healthcheck.sh",
          "--connect",
          "--mariadbupgrade",
          "--innodb_initialized",
        ]
      interval: 20s
      start_period: 30s
      timeout: 5s
      retries: 10

  redis:
    image: ${SEAFILE_REDIS_IMAGE:-redis}
    container_name: seafile-redis
    restart: unless-stopped
    command:
      - /bin/sh
      - -c
      - exec redis-server --requirepass "$$REDIS_PASSWORD" --save "" --appendonly no
    environment:
      - REDIS_PASSWORD=${REDIS_PASSWORD:-}
    networks:
      - seafile-net

  seafile:
    image: ${SEAFILE_IMAGE:-seafileltd/seafile-mc:14.0-latest}
    container_name: seafile
    restart: unless-stopped
    # ports:
    #   - "80:80"
    volumes:
      - ${SEAFILE_VOLUME:-/opt/seafile-data}:/shared
    environment:
      - SEAFILE_MYSQL_DB_HOST=${SEAFILE_MYSQL_DB_HOST:-db}
      - SEAFILE_MYSQL_DB_PORT=${SEAFILE_MYSQL_DB_PORT:-3306}
      - SEAFILE_MYSQL_DB_USER=${SEAFILE_MYSQL_DB_USER:-seafile}
      - SEAFILE_MYSQL_DB_PASSWORD=${SEAFILE_MYSQL_DB_PASSWORD:?Variable is not set or empty}
      - INIT_SEAFILE_MYSQL_ROOT_PASSWORD=${INIT_SEAFILE_MYSQL_ROOT_PASSWORD:-}
      - SEAFILE_MYSQL_DB_CCNET_DB_NAME=${SEAFILE_MYSQL_DB_CCNET_DB_NAME:-ccnet_db}
      - SEAFILE_MYSQL_DB_SEAFILE_DB_NAME=${SEAFILE_MYSQL_DB_SEAFILE_DB_NAME:-seafile_db}
      - SEAFILE_MYSQL_DB_SEAHUB_DB_NAME=${SEAFILE_MYSQL_DB_SEAHUB_DB_NAME:-seahub_db}
      - TIME_ZONE=${TIME_ZONE:-Etc/UTC}
      - INIT_SEAFILE_ADMIN_EMAIL=${INIT_SEAFILE_ADMIN_EMAIL:-me@example.com}
      - INIT_SEAFILE_ADMIN_PASSWORD=${INIT_SEAFILE_ADMIN_PASSWORD:-asecret}
      - SEAFILE_SERVER_HOSTNAME=${SEAFILE_SERVER_HOSTNAME:?Variable is not set or empty}
      - SEAFILE_SERVER_PROTOCOL=${SEAFILE_SERVER_PROTOCOL:-http}
      - SITE_ROOT=${SITE_ROOT:-/}
      - NON_ROOT=${NON_ROOT:-false}
      - JWT_PRIVATE_KEY=${JWT_PRIVATE_KEY:?Variable is not set or empty}
      - SEAFILE_LOG_TO_STDOUT=${SEAFILE_LOG_TO_STDOUT:-false}
      - ENABLE_GO_FILESERVER=${ENABLE_GO_FILESERVER:-true}
      - ENABLE_SEAFDAV=${ENABLE_SEAFDAV:-false}
      - SEAFDAV_WORKERS=${SEAFDAV_WORKERS:-5}
      - ENABLE_SEADOC=${ENABLE_SEADOC:-true}
      - SEADOC_SERVER_URL=${SEAFILE_SERVER_PROTOCOL:-http}://${SEAFILE_SERVER_HOSTNAME:?Variable is not set or empty}/sdoc-server
      - CACHE_PROVIDER=${CACHE_PROVIDER:-redis}
      - REDIS_HOST=${REDIS_HOST:-redis}
      - REDIS_PORT=${REDIS_PORT:-6379}
      - REDIS_PASSWORD=${REDIS_PASSWORD:-}
      - MEMCACHED_HOST=${MEMCACHED_HOST:-memcached}
      - MEMCACHED_PORT=${MEMCACHED_PORT:-11211}
      - ENABLE_NOTIFICATION_SERVER=${ENABLE_NOTIFICATION_SERVER:-false}
      - INNER_NOTIFICATION_SERVER_URL=${INNER_NOTIFICATION_SERVER_URL:-http://notification-server:8083}
      - NOTIFICATION_SERVER_URL=${NOTIFICATION_SERVER_URL:-${SEAFILE_SERVER_PROTOCOL:-http}://${SEAFILE_SERVER_HOSTNAME:?Variable is not set or empty}/notification}
      - ENABLE_SEAFILE_AI=${ENABLE_SEAFILE_AI:-false}
      - SEAFILE_AI_SERVER_URL=${SEAFILE_AI_SERVER_URL:-http://seafile-ai:8888}
      - SEAFILE_AI_SECRET_KEY=${JWT_PRIVATE_KEY:?Variable is not set or empty}
      - ENABLE_METADATA_MANAGEMENT=${ENABLE_METADATA_MANAGEMENT:-False}
      - INNER_METADATA_SERVER_URL=${INNER_METADATA_SERVER_URL:-http://seafile-md-server:8084}
      - MD_FILE_COUNT_LIMIT=${MD_FILE_COUNT_LIMIT:-100000}
      - CSRF_TRUSTED_ORIGINS=${CSRF_TRUSTED_ORIGINS}
    labels:
      caddy: ${SEAFILE_SERVER_PROTOCOL:-http}://${SEAFILE_SERVER_HOSTNAME:?Variable is not set or empty}
      caddy.reverse_proxy: "{{upstreams 80}}"
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:80 || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 10s
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    networks:
      - seafile-net

networks:
  seafile-net:
    name: seafile-net
```

`caddy.yml` startet Caddy, der Hostnamen aus Container-Labels liest. Er bindet den Docker-Socket ein, das entspricht Root-Zugriff auf den Host.

```yaml
services:

  caddy:
    image: ${SEAFILE_CADDY_IMAGE:-lucaslorentz/caddy-docker-proxy:2.12-alpine}
    restart: unless-stopped
    container_name: seafile-caddy
    ports:
      - 80:80
      - 443:443
    environment:
      - CADDY_INGRESS_NETWORKS=seafile-net
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ${SEAFILE_CADDY_VOLUME:-/opt/seafile-caddy}:/data/caddy
    networks:
      - seafile-net
    healthcheck:
      test: ["CMD-SHELL", "curl --fail http://localhost:2019/metrics || exit 1"]
      start_period: 20s
      interval: 20s
      timeout: 5s
      retries: 3

networks:
  seafile-net:
    name: seafile-net
```

> **Prüfen:** `ls /opt/seafile` zeigt `.env`, `seafile-server.yml`, `seadoc.yml` und `caddy.yml`.

## Schritt 2: .env mit eigenen Werten füllen

Zufallswerte liefert `openssl rand -hex 24`, `JWT_PRIVATE_KEY` braucht mindestens 32 Zeichen. Gekürzte `.env`: Als Hostname muss ein echter Domainname stehen: `localhost` lehnte die Ersteinrichtung im Test mit „localhost is not a valid ip or domain“ ab.

```bash
COMPOSE_FILE='seafile-server.yml,caddy.yml,seadoc.yml'
COMPOSE_PATH_SEPARATOR=','
SEAFILE_IMAGE=seafileltd/seafile-mc:14.0.9
SEAFILE_DB_IMAGE=mariadb:10.11
SEAFILE_CADDY_IMAGE=lucaslorentz/caddy-docker-proxy:2.12-alpine
SEADOC_IMAGE=seafileltd/sdoc-server:2.0.9
BASIC_STORAGE_PATH=/opt
SEAFILE_VOLUME=$BASIC_STORAGE_PATH/seafile-data
SEAFILE_MYSQL_VOLUME=$BASIC_STORAGE_PATH/seafile-mysql/db
SEAFILE_CADDY_VOLUME=$BASIC_STORAGE_PATH/seafile-caddy
SEADOC_VOLUME=$BASIC_STORAGE_PATH/seadoc-data
SEAFILE_SERVER_HOSTNAME=seafile.example.de
SEAFILE_SERVER_PROTOCOL=https
TIME_ZONE=Europe/Berlin
JWT_PRIVATE_KEY={{jwt_private_key}}
SEAFILE_MYSQL_DB_PASSWORD={{seafile_mysql_db_password}}
INIT_SEAFILE_MYSQL_ROOT_PASSWORD={{init_seafile_mysql_root_password}}
REDIS_PASSWORD={{redis_password}}
INIT_SEAFILE_ADMIN_EMAIL=admin@example.de
INIT_SEAFILE_ADMIN_PASSWORD={{init_seafile_admin_password}}
```

Die Compose-Warnung `The "CSRF_TRUSTED_ORIGINS" variable is not set` ist harmlos, solange Seafile unter dem eigenen Hostnamen läuft. `INIT_SEAFILE_ADMIN_PASSWORD` gilt nur beim ersten Start. Schützen Sie die Datei mit `sudo chmod 600 .env`.

> **Prüfen:** `sudo docker compose config -q` endet ohne Ausgabe. Fehlt ein Pflichtwert, bricht Compose ab: `required variable JWT_PRIVATE_KEY is missing a value: Variable is not set or empty`.

## Schritt 3: Starten und Gesundheit prüfen

```bash
$ cd /opt/seafile
$ sudo docker compose up -d
$ sudo docker compose ps
$ sudo docker compose logs seafile --tail 20
```

Erst liefert der Proxy `502`, dann `302` auf die Anmeldeseite. Nach 40 bis 50 Sekunden ist `seafile` `healthy`, im Log stehen `Seafile server started`, `Successfully created seafile admin` und `Seahub is started`.

> **Prüfen:** `curl -s https://seafile.example.de/api2/ping/` antwortet `"pong"`, `curl -s https://seafile.example.de/api2/server-info/` liefert `"version": "14.0.9"`.

## Schritt 4: Anmelden und Version prüfen

Melden Sie sich mit `INIT_SEAFILE_ADMIN_EMAIL` an. „Systemverwaltung, Info“ zeigt Edition und Version.

![Seafile-Systemverwaltung, Seite Info: Community Edition, Version 14.0.9, 2 Bibliotheken, 2 Dateien, 1 Benutzerkonto](https://s-edv.com/uploads/2026/10/0b9b6947807a5c5dcaf722e84db5b7d250ccc52969cfa72d26bf2c98c89af8da-1024.png)
*Nach dem Update meldet die Info-Seite Version 14.0.9.*

> **Prüfen:** Die Anmeldung führt zur Dateiansicht mit der Standardbibliothek „Meine Bibliothek“. Ein falsches Passwort scheitert an der API mit `Unable to login with provided credentials.` (HTTP 400).

## Schritt 5: Upload und Download prüfen

Der Funktionstest läuft über die Web-API. Ersetzen Sie Adresse und Zugangsdaten.

```bash
$ U=https://seafile.example.de
$ T=$(curl -s -d "username=admin@example.de&password={{init_seafile_admin_password}}" $U/api2/auth-token/ | sed 's/.*"token": *"\([^"]*\)".*/\1/')
$ RID=$(curl -s -H "Authorization: Token $T" -d "name=Testbibliothek" $U/api2/repos/ | sed 's/.*"repo_id":"\([^"]*\)".*/\1/')
$ UL=$(curl -s -H "Authorization: Token $T" "$U/api2/repos/$RID/upload-link/?p=/" | tr -d '"')
$ echo "marker-vor-backup" > marker.txt
$ dd if=/dev/urandom of=blob.bin bs=1M count=5
$ sha256sum blob.bin
$ curl -s -H "Authorization: Token $T" -F file=@marker.txt -F file=@blob.bin -F parent_dir=/ "$UL?ret-json=1"
$ DL=$(curl -s -H "Authorization: Token $T" "$U/api2/repos/$RID/file/?p=/blob.bin&reuse=1" | tr -d '"')
$ curl -s -o dl.bin "$DL"
$ sha256sum dl.bin
```

![Seafile-Bibliothek Testbibliothek mit den Dateien blob.bin (5,2 MB) und marker.txt (29 B)](https://s-edv.com/uploads/2026/10/6bbc3a15765f615292223349eaf13ef129349be9b854be843496d4a22f612f53-1024.png)
*Die per API hochgeladenen Dateien erscheinen in der Weboberfläche.*

> **Prüfen:** Beide Prüfsummen sind identisch. Ohne Token antwortet `/api2/repos/` mit `Authentication credentials were not provided.` (HTTP 403).

## Schritt 6: HTTPS und Protokoll korrekt setzen

Caddy beantragt das Zertifikat automatisch, sobald der Hostname öffentlich auflösbar und Port 80 erreichbar ist. Port 80 leitet mit `308` auf HTTPS um. Entscheidend ist `SEAFILE_SERVER_PROTOCOL=https` in der `.env`. Stand dort `http` bei Aufruf über HTTPS, scheiterte die Anmeldung mit `403 Forbidden`, im Log `/opt/seafile-data/seafile/logs/seahub.log` stand `Origin checking failed`. Mit `https` und `docker compose up -d` klappte sie.

Mit eigenem Reverse Proxy entfernen Sie `caddy.yml` aus `COMPOSE_FILE`, veröffentlichen den Seafile-Port nur auf `127.0.0.1` und setzen `CSRF_TRUSTED_ORIGINS` auf die öffentliche Adresse.

> **Prüfen:** `curl -sI http://seafile.example.de` liefert `308` mit HTTPS-Ziel. Ohne DNS-Eintrag zeigt `docker compose logs caddy`: `no valid A records found for seafile.example.de; no valid AAAA records found`.

## Schritt 7: Zugang absichern

`/accounts/register/` liefert im Standardzustand `404`, unter „Systemverwaltung, Einstellungen, Benutzer“ ist „Selbstregistrierung zulassen“ ausgeschaltet. Diese Einstellungen liegen in der Tabelle `constance_config` und haben Vorrang vor den Konfigurationsdateien.

![Seafile-Systemverwaltung, Einstellungen: Branding und Benutzer mit ausgeschalteter Selbstregistrierung](https://s-edv.com/uploads/2026/10/7c71c3eb10ef2eb9efc279fc302f61d4d4f6ae0949e82a96df9775296dac14f0-1024.png)
*Selbstregistrierung ist im Auslieferungszustand ausgeschaltet.*

Redis ist mit `REDIS_PASSWORD` geschützt und nur im Compose-Netz erreichbar. Weitere Härtung mit Healthchecks, Secrets und Non-Root-Betrieb beschreibt [Docker Compose absichern: Secrets, Healthchecks und Non-Root](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root).

> **Prüfen:** `sudo ss -ltn` zeigt nur Port 80 und 443 (plus SSH); 3306 und 6379 tauchen nicht auf.

## Schritt 8: Persistenz prüfen

`docker compose down` entfernt nur Container, nicht die Daten unter `/opt`.

```bash
$ cd /opt/seafile
$ sudo docker compose down
$ sudo docker compose up -d
```

> **Prüfen:** Die Dateiliste enthält weiterhin `blob.bin` und `marker.txt`.

## Schritt 9: Backup mit Datenbank zuerst

Gesichert werden drei Datenbanken, das Verzeichnis `seafile` und die `.env` mit den Zugangsdaten. Zuerst die Datenbank, dann verweist jeder Eintrag auf vorhandene Objekte.

```bash
cd /opt/seafile
. ./.env
B=/backup/seafile
sudo mkdir -p $B/databases $B/data
for d in ccnet_db seafile_db seahub_db; do
  sudo docker exec -e MYSQL_PWD="$SEAFILE_MYSQL_DB_PASSWORD" seafile-mysql mariadb-dump -useafile --opt $d | sudo tee $B/databases/$d.sql > /dev/null
done
sudo cp -a /opt/seafile-data/seafile $B/data/
sudo cp .env $B/env.bak
```

> **Prüfen:** `ls -la /backup/seafile/databases` zeigt drei SQL-Dateien.

## Schritt 10: Restore auf eine frische Instanz

Starten Sie die Instanz mit derselben `.env` zunächst leer, auf einem neuen Server oder nach dem Löschen der Datenordner; das legt die Datenbank-Benutzer an. Danach legen Sie die Datenbanken leer neu an: 14.0 erzeugt Tabellen mit `utf8mb4`, Dumps einer von 13.0 aktualisierten Instanz enthalten `utf8mb3` (siehe Troubleshooting). Warten Sie den leeren Start vollständig ab: Wird Seafile vor Abschluss der Ersteinrichtung gestoppt, kann der Container danach in einer Schleife starten mit `ln: /opt/seafile/conf: cannot overwrite directory`.

```bash
cd /opt/seafile
. ./.env
B=/backup/seafile
sudo docker compose up -d
until sudo docker compose ps seafile | grep -q "(healthy)"; do sleep 5; done
sudo docker compose stop seafile seadoc
sudo rsync -aHAX $B/data/seafile/ /opt/seafile-data/seafile/
for d in ccnet_db seafile_db seahub_db; do
  sudo docker exec -e MYSQL_PWD="$SEAFILE_MYSQL_DB_PASSWORD" seafile-mysql mariadb -useafile -e "DROP DATABASE $d; CREATE DATABASE $d CHARACTER SET utf8mb4;"
  sudo docker exec -i -e MYSQL_PWD="$SEAFILE_MYSQL_DB_PASSWORD" seafile-mysql mariadb -useafile $d < $B/databases/$d.sql
done
sudo docker compose start seafile seadoc
```

> **Prüfen:** Nach dem Start listet die API `blob.bin` und `marker.txt` wieder auf, der Download von `blob.bin` hat dieselbe SHA-256-Prüfsumme wie vor dem Backup, `marker.txt` enthält den ursprünglichen Text. Alte API-Tokens bleiben gültig.

## Schritt 11: Updates, Rollback und Entfernen

Für Updates innerhalb von 14.0 genügt laut Doku: Backup erstellen, neues Image-Tag in der `.env` eintragen, `docker compose pull` und `docker compose up -d`. Ein Rollback gelingt über das Backup aus Schritt 9 und das alte Tag.

### Umstieg von Seafile 13.0 auf 14.0

Seafile migriert die Datenbank beim ersten Start selbst, Compose-Datei und Einstellungen passen Sie vorher an:

1. Backup nach Schritt 9.
2. `sudo docker compose down`, alte `seafile-server.yml` umbenennen und die 14.0-Fassung laden (Befehl aus Schritt 1). `caddy.yml` und `seadoc.yml` bleiben gleich.
3. In der `.env` `SEAFILE_IMAGE=seafileltd/seafile-mc:14.0.9` setzen.
4. Nur wenn genutzt: WebDAV über `ENABLE_SEAFDAV=true` in der `.env` (`enabled` und `workers` aus `seafdav.conf` löschen), Metadaten-Server über `ENABLE_METADATA_MANAGEMENT=True`; `METADATA_SERVER_URL` heißt jetzt `INNER_METADATA_SERVER_URL`.
5. In `seahub_settings.py` entfallen `ENABLE_CHANGE_PASSWORD`, `DISABLE_ADFS_USER_PWD_LOGIN` und `ENABLE_SSO_USER_CHANGE_PASSWORD`. Traffic-Limits heißen `monthly_download_traffic_limit` statt `monthly_rate_limit`.
6. `sudo docker compose up -d`.

Im Test meldete das Log beim Update von 13.0.28 auf 14.0.9 `Upgraded your seafile server successfully.`, nach 40 Sekunden war der Container `healthy`. Anmeldung, Dateien samt Prüfsumme und ein alter API-Token blieben gültig.

> **Warnung:** Zum vollständigen Entfernen stoppen Sie mit `docker compose down` und löschen `/opt/seafile-data`, `/opt/seafile-mysql`, `/opt/seafile-caddy` und `/opt/seadoc-data`. Alle Bibliotheken sind damit unwiderruflich weg.

> **Prüfen:** `docker compose pull` nennt die neuen Digests, `/api2/server-info/` zeigt danach die erwartete Version.

## Troubleshooting

| Symptom | Ursache und Abhilfe |
| --- | --- |
| Anmeldung liefert `403 Forbidden`, Log: `Origin checking failed ... does not match any trusted origins` | `SEAFILE_SERVER_PROTOCOL` steht auf `http`, der Zugriff läuft über HTTPS. Auf `https` setzen, `docker compose up -d`. |
| Login-Seite zeigt `Page unavailable` (HTTP 500), Log: `Error happened during creating seafile admin.` | Das DB-Passwort in der `.env` weicht vom beim ersten Start gesetzten ab. Ursprünglichen Wert zurücktragen und den Container neu anlegen; danach lief alles wieder. |
| `required variable JWT_PRIVATE_KEY is missing a value` | Pflichtvariable leer oder gelöscht, in `.env` eintragen. |
| Caddy: `no valid A records found` | Hostname hat keinen öffentlichen DNS-Eintrag, Zertifikat kann nicht ausgestellt werden. |
| `502` direkt nach dem Start | Seafile startet noch, nach einer Minute erneut prüfen. |
| `rsync: command not found` | Paket `rsync` installieren. |
| Restore von `seahub_db`: `ERROR 1005 ... errno: 150 "Foreign key constraint is incorrectly formed"` | Frische 14.0-Datenbank nutzt `utf8mb4`, der Dump `utf8mb3`. Datenbank leer neu anlegen wie in Schritt 10. |
| Nach Restore Neustartschleife, Log: `ln: /opt/seafile/conf: cannot overwrite directory` | Leere Instanz wurde vor Abschluss der Ersteinrichtung gestoppt. Datenordner erneut leeren und Schritt 10 mit Warten auf `healthy` wiederholen. |

## Häufige Fragen

### Wie viel RAM braucht der Stack wirklich?

Die Doku nennt 2 GB, mit 14.0.9 gemessen wurden im Leerlauf 0,9 bis 1,2 GiB.

### Was tun bei vergessenem Admin-Passwort?

`docker exec -it seafile /opt/seafile/seafile-server-latest/reset-admin.sh` legt laut Doku ein neues Admin-Konto an.

### Gibt Seafile gelöschten Speicher sofort frei?

Nein, erst nach der Garbage Collection (Doku: „Seafile GC“).

### Redis oder Memcached?

Seit Seafile 13 ist Redis der Standard-Cache und im Stack enthalten, Memcached wird nicht mehr mitgeliefert. Ab 14.0 setzen viele Funktionen Redis voraus.

## Fazit

Der offizielle Stack läuft ohne Anpassung mit rund 1 GiB RAM im Leerlauf. Stolpersteine sind das Protokoll in der `.env`, die nach dem ersten Start festen DB-Zugangsdaten und der Zeichensatz beim Restore. Dump, Verzeichnis `seafile` und `.env` genügen für eine vollständige Wiederherstellung.

## Weiterführende Anleitungen und Quellen

- [FileBrowser Quantum mit Docker Compose](https://s-edv.com/anleitungen/filebrowser-quantum-docker-compose-dateimanager-selfhosting): schlanker Dateimanager im Browser.
- [Backrest mit Docker Compose](https://s-edv.com/anleitungen/backrest-docker-compose-restic-backups-weboberflaeche): verschlüsselte Offsite-Kopien des Backups.
- [Nextcloud nativ auf Ubuntu](https://s-edv.com/anleitungen/nextcloud-nativ-ubuntu-lemp-nginx-mariadb-php-fpm): Alternative mit Office- und Kalenderfunktionen.
- [Seafile-Handbuch: Installation der Community Edition mit Docker](https://manual.seafile.com/14.0/setup/setup_ce_by_docker/)
- [Seafile-Handbuch: Backup und Wiederherstellung](https://manual.seafile.com/14.0/administration/backup_recovery/)
- [Seafile-Handbuch: Upgrade von 13.0 auf 14.0 mit Docker](https://manual.seafile.com/14.0/upgrade/upgrade_docker_14.0/)
- [Seafile-Handbuch: Upgrade-Hinweise je Hauptversion](https://manual.seafile.com/14.0/upgrade/upgrade_notes/)
- [Seafile-Handbuch: Systemanforderungen](https://manual.seafile.com/14.0/setup/system_requirements/)
- [Docker Hub: Tags von seafile-mc](https://hub.docker.com/r/seafileltd/seafile-mc/tags)
- [Repository haiwen/seafile](https://github.com/haiwen/seafile)

## Eckdaten

|   |   |
| --- | --- |
| Image | `seafileltd/seafile-mc:14.0.9`, `mariadb:10.11`, `redis`, `seafileltd/sdoc-server:2.0.9`, `lucaslorentz/caddy-docker-proxy:2.12-alpine` |
| Ports | 80 und 443 (Caddy), Seafile intern 80 |
| Volumes | `/opt/seafile-data`, `/opt/seafile-mysql/db`, `/opt/seafile-caddy`, `/opt/seadoc-data` |
| Wichtige Variablen | `SEAFILE_SERVER_HOSTNAME`, `SEAFILE_SERVER_PROTOCOL`, `JWT_PRIVATE_KEY`, `SEAFILE_MYSQL_DB_PASSWORD`, `INIT_SEAFILE_*` |
| Healthcheck | `curl -f http://localhost:80` im Container |
| Architekturen | amd64, arm64 |
