Zum Hauptinhalt springen
S-EDV news
← Alle Anleitungen
📘 Anleitung Docker 05.10.2026 · 10 min Lesezeit Geprüft 14.10.2026

Seafile 14 mit Docker Compose installieren, absichern und sichern

Seafile Community Edition 14.0.9 per Docker Compose auf einem Server mit 3 GB RAM: Installation mit Caddy, Umstieg von 13.0, typische Fehler wie falsches Protokoll oder Zeichensatz beim Restore, Backup mit Datenbank zuerst und ein nachgewiesener Restore.

Werbung Mit * markierte Links sind Werbelinks: Bei einem Kauf erhalten wir eine Provision, der Preis bleibt gleich. Als Amazon-Partner verdiene ich an qualifizierten Verkäufen. Mehr dazu

Titelbild: Seafile mit Docker Compose, Dateien, Sync, Backup

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.

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 beschrieben ein.

$ 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.

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.

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

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.

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=HIER_ZUFALLSWERT_EINTRAGEN
SEAFILE_MYSQL_DB_PASSWORD=HIER_ZUFALLSWERT_EINTRAGEN
INIT_SEAFILE_MYSQL_ROOT_PASSWORD=HIER_ZUFALLSWERT_EINTRAGEN
REDIS_PASSWORD=HIER_ZUFALLSWERT_EINTRAGEN
INIT_SEAFILE_ADMIN_EMAIL=admin@example.de
INIT_SEAFILE_ADMIN_PASSWORD=HIER_STARKES_PASSWORT_EINTRAGEN

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.

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

$ 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.

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
Nach dem Update meldet die Info-Seite Version 14.0.9.

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.

$ U=https://seafile.example.de
$ T=$(curl -s -d "username=admin@example.de&password=HIER_STARKES_PASSWORT_EINTRAGEN" $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)
Die per API hochgeladenen Dateien erscheinen in der Weboberfläche.

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.

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
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.

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.

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

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.

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

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.

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

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.

docker compose pull nennt die neuen Digests, /api2/server-info/ zeigt danach die erwartete Version.

Troubleshooting

SymptomUrsache und Abhilfe
Anmeldung liefert 403 Forbidden, Log: Origin checking failed ... does not match any trusted originsSEAFILE_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 valuePflichtvariable leer oder gelöscht, in .env eintragen.
Caddy: no valid A records foundHostname hat keinen öffentlichen DNS-Eintrag, Zertifikat kann nicht ausgestellt werden.
502 direkt nach dem StartSeafile startet noch, nach einer Minute erneut prüfen.
rsync: command not foundPaket 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 directoryLeere 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

Eckdaten

Imageseafileltd/seafile-mc:14.0.9, mariadb:10.11, redis, seafileltd/sdoc-server:2.0.9, lucaslorentz/caddy-docker-proxy:2.12-alpine
Ports80 und 443 (Caddy), Seafile intern 80
Volumes/opt/seafile-data, /opt/seafile-mysql/db, /opt/seafile-caddy, /opt/seadoc-data
Wichtige VariablenSEAFILE_SERVER_HOSTNAME, SEAFILE_SERVER_PROTOCOL, JWT_PRIVATE_KEY, SEAFILE_MYSQL_DB_PASSWORD, INIT_SEAFILE_*
Healthcheckcurl -f http://localhost:80 im Container
Architekturenamd64, arm64
SeafileDocker ComposeDateisynchronisationCloud-SpeicherBackupRestoreSelfhostingCaddyMariaDB