Seafile auf Sliplane deployen

Seafile auf Sliplane deployen

Lukas Mauser - Co-Founder von sliplane.ioLukas Mauser
10 min

Seafile ist eine Open-Source-Plattform für File Sharing und Zusammenarbeit, die du selbst hosten kannst. Du bekommst File Syncing, Sharing und Team-Collaboration-Tools — quasi dein eigenes privates Dropbox oder Google Drive. In diesem Guide zeig ich dir, wie du Seafile auf Sliplane mit dem Compose Parser deployst, inklusive optionaler Erweiterungen wie dem SeaDoc Document Server und Elasticsearch für Volltextsuche.

Seafile gibt es in zwei Editionen:

  • Community Edition — kostenlos und Open Source, perfekt für den privaten Gebrauch oder kleine Teams
  • Pro Edition — bringt Features wie Volltextsuche, Online-Office-Integration und mehr (Details)

Wir starten mit der Community Edition und zeigen dir danach, wie du auf Pro upgradest.

Step 1: Projekt und Server erstellen

Log dich bei Sliplane ein und erstell ein neues Projekt.

Projects Page

Create Project Dialog

Klick dann auf "Deploy Service" im Projekt und füg einen Server hinzu, auf dem Seafile laufen soll. Seafile empfiehlt mindestens 2 GB RAM für die Community Edition (Base Server auf Sliplane) und 4 GB für die Pro Edition mit Elasticsearch (Medium Server). Für den Anfang reicht ein Base Server für die Community Edition — upgraden kannst du später jederzeit.

Select a Server

Create New Server

Step 2: Compose Parser öffnen

Wähl den Server aus, den du gerade erstellt hast, und klick auf "Add Service".

Add Service Button

Klick auf das Terminal-Icon oben rechts im Drawer. Damit öffnest du den Command Parser, in den du Docker Compose Files einfügen kannst, um Multi-Container-Anwendungen mit einem Klick zu deployen — Sliplane parst die Datei und extrahiert die Service Config.

Add Service Drawer

Step 3: Compose File einfügen

Füg das folgende Compose File in den Parser ein.

Das Compose File enthält drei Services: MariaDB als Datenbank, Redis für Caching und den eigentlichen Seafile Service. Es basiert auf dem offiziellen Seafile Community Docker Compose File, leicht angepasst für Sliplane:

services:
  db:
    image: mariadb:10.11
    environment:
      MARIADB_AUTO_UPGRADE: "1"
      MYSQL_LOG_CONSOLE: "true"
      MYSQL_ROOT_PASSWORD: "${MYSQL_ROOT_PASSWORD}"
    volumes:
      - seafile-mysql-data:/var/lib/mysql

  redis:
    image: redis
    command: /bin/sh -lc 'exec redis-server --requirepass "$$REDIS_PASSWORD"'
    environment:
      REDIS_PASSWORD: "${REDIS_PASSWORD}"

  seafile:
    image: seafileltd/seafile-mc:13.0-latest
    ports:
      - "80:80"
    volumes:
      - seafile-shared-data:/shared
    environment:
      CACHE_PROVIDER: "redis"
      ENABLE_FACE_RECOGNITION: "false"
      ENABLE_GO_FILESERVER: "true"
      ENABLE_NOTIFICATION_SERVER: "false"
      ENABLE_SEADOC: "true"
      ENABLE_SEAFILE_AI: "false"
      INIT_SEAFILE_ADMIN_EMAIL: "${SEAFILE_ADMIN_EMAIL:-example@email.de}"
      INIT_SEAFILE_ADMIN_PASSWORD: "${SEAFILE_ADMIN_PASSWORD}"
      INIT_SEAFILE_MYSQL_ROOT_PASSWORD: "${MYSQL_ROOT_PASSWORD}"
      INNER_NOTIFICATION_SERVER_URL: "http://notification-server:8083"
      JWT_PRIVATE_KEY: "${JWT_PRIVATE_KEY}"
      MD_FILE_COUNT_LIMIT: "100000"
      MEMCACHED_HOST: "memcached"
      MEMCACHED_PORT: "11211"
      NON_ROOT: "false"
      NOTIFICATION_SERVER_URL: "http://sdoc-notifcation-host/notification"
      PORT: "80"
      REDIS_HOST: "redis"
      REDIS_PASSWORD: "$REDIS_PASSWORD"
      REDIS_PORT: "6379"
      SEADOC_SERVER_URL: "https://sdoc-server-host/sdoc-server"
      SEAFILE_AI_SECRET_KEY: "${JWT_PRIVATE_KEY}"
      SEAFILE_AI_SERVER_URL: "http://seafile-ai:8888"
      SEAFILE_LOG_TO_STDOUT: "false"
      SEAFILE_MYSQL_DB_CCNET_DB_NAME: "ccnet_db"
      SEAFILE_MYSQL_DB_HOST: "db"
      SEAFILE_MYSQL_DB_PASSWORD: "${SEAFILE_MYSQL_DB_PASSWORD}"
      SEAFILE_MYSQL_DB_PORT: "3306"
      SEAFILE_MYSQL_DB_SEAFILE_DB_NAME: "seafile_db"
      SEAFILE_MYSQL_DB_SEAHUB_DB_NAME: "seahub_db"
      SEAFILE_MYSQL_DB_USER: "seafile"
      SEAFILE_SERVER_HOSTNAME: "$$SLIPLANE_DOMAIN"
      SEAFILE_SERVER_PROTOCOL: "https"
      SITE_ROOT: "/"
      SLIPLANE_GRACE_PERIOD: "120"
      TIME_ZONE: "Etc/UTC"
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started

volumes:
  seafile-mysql-data:
  seafile-shared-data:

Command Parser

Nach dem Einfügen extrahiert der Parser die folgenden Environment Variables:

MYSQL_ROOT_PASSWORD=secure-mysql-root-password
REDIS_PASSWORD=secure-redis-password
JWT_PRIVATE_KEY=secure-jwt-key
SEAFILE_ADMIN_EMAIL=me@example.com
SEAFILE_ADMIN_PASSWORD=asecure-admin-password
SEAFILE_MYSQL_DB_PASSWORD=secure-db-password
SEAFILE_SERVER_HOSTNAME=$SLIPLANE_DOMAIN

Compose File mit Environment Variables

Passwörter und Secrets werden zufällig generiert, du kannst sie aber mit eigenen Werten überschreiben.

Step 4: Konfigurieren und Deployen

Klick oben rechts auf "Add Service". Drei Services werden extrahiert: Redis, MariaDB und Seafile.

Extrahierte Services

Mach den Seafile Service public, indem du den Public-Switch aktivierst — HTTP als Protokoll und die Standard-Healthcheck-Einstellungen kannst du so lassen. Redis und MariaDB bleiben private.

Expose Service Dialog

Klick auf Deploy und warte, bis das Deployment durch ist.

Deployte Services

Step 5: Seafile aufrufen

Sobald alle Services deployed sind und laufen, kannst du Seafile über die Sliplane-Domain aufrufen, die du in den Service Settings findest. Log dich mit der Admin-E-Mail und dem Passwort ein, die du vorher als Environment Variables gesetzt hast.

Seafile Welcome Screen

Nach dem Login kannst du direkt Dateien hochladen und teilen. Du kannst auch den Seafile Desktop Client mit deiner Instanz verbinden — einfach die gleiche Domain und Credentials eingeben.

SeaDoc Document Server hinzufügen

SeaDoc ermöglicht es dir, Dokumente direkt in Seafiles Web-Interface zu bearbeiten und als Vorschau anzuzeigen. Da SeaDoc Seafiles Domain in seinen Environment Variables referenziert, mussten wir Seafile zuerst deployen.

Step 1: Compose Parser erneut öffnen

Geh zu deinem Projekt, klick auf "Deploy Service", wähl den gleichen Server und öffne den Compose Parser.

Step 2: SeaDoc Compose File einfügen

services:
  seadoc:
    image: seafileltd/sdoc-server:2.0-latest
    environment:
      DB_HOST: "${DB_HOST}"
      DB_NAME: "seahub_db"
      DB_PASSWORD: "${DB_PASSWORD}"
      DB_PORT: "3306"
      DB_USER: "seafile"
      HOST: "0.0.0.0"
      JWT_PRIVATE_KEY: "${JWT_PRIVATE_KEY}"
      NON_ROOT: "false"
      SEAHUB_SERVICE_URL: "https://${SEAFILE_SERVER_HOSTNAME}"
      TIME_ZONE: "Etc/UTC"
    volumes:
      - seadoc-data:/shared

volumes:
  seadoc-data:

Step 3: Environment Variables ausfüllen

Der Parser extrahiert diese Variablen — geh jeden Wert durch und ersetze ihn mit dem richtigen Wert aus deinen Seafile Service Settings, die du vorher beim Deployment der Datenbank und des Seafile Service verwendet hast:

DB_HOST=replace-with-your-mariadb-internal-hostname
# NICHT das Root-Passwort, sondern das Passwort für den "seafile" Datenbank-User, das du im Compose File für den Seafile Service gesetzt hast
DB_PASSWORD=replace-with-your-mysql-db-password
JWT_PRIVATE_KEY=replace-with-your-secure-jwt-key
SEAHUB_SERVICE_URL=replace-with-your-public-seafile-server-hostname

Achte drauf, dass DB_HOST dem internen Hostname des MariaDB Service entspricht und DB_PASSWORD dem Passwort, das du vorher gesetzt hast.

Step 4: SeaDoc deployen

Klick auf "Add Service", mach SeaDoc public und klick auf Deploy.

Um zu testen, ob es funktioniert, geh in dein Seafile Web-Interface, erstell ein Dokument und versuch es im Browser zu bearbeiten. Du solltest den SeaDoc Editor sehen, der das Dokument zum Bearbeiten öffnet.

Pro Edition deployen

Um auf die Pro Edition zu upgraden, musst du das Docker Image tauschen und deine Registry Credentials hinterlegen.

Step 1: Image aktualisieren

Geh in die Seafile Service Settings und ersetze die Image URL mit dem Pro Edition Image:

seafileltd/seafile-pro-mc:13.0-latest

Step 2: Registry Credentials hinzufügen

Das Pro Image ist privat, du musst dich also authentifizieren. Unter dem Image URL Feld klick auf Select Credential > Add New. Im Dialog:

  1. Wähl "Other" als Registry
  2. Trag einen Namen, Username und Passwort für die Docker Registry ein (bekommst du von Seafile nach dem Kauf der Pro Edition)
  3. Klick auf "Add Credential" um die Credentials zu speichern

Wähl die neu erstellten Credentials aus und klick auf Save and Redeploy.

Elasticsearch hinzufügen (nur Pro Edition)

Elasticsearch ermöglicht Volltextsuche über alle deine Dateien in Seafile Pro. Du brauchst dafür mindestens einen Medium Server (4 GB RAM).

Step 1: Elasticsearch deployen

Füg einen neuen privaten Service über den Compose Parser mit folgender Config hinzu:

services:
  elasticsearch:
    image: elasticsearch:8.15.0
    environment:
      - discovery.type=single-node
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms2g -Xmx2g"
      - "xpack.security.enabled=false"
    volumes:
      - "seafile-elasticsearch-data:/usr/share/elasticsearch/data"

volumes:
  seafile-elasticsearch-data:

Zum Zeitpunkt dieses Artikels ist Elasticsearch 8.15.0 die neueste stabile Version, die mit Seafile kompatibel ist. Prüf auf Docker Hub, ob es neuere Versionen gibt.

Step 2: Seafile für Elasticsearch konfigurieren

Der Seafile Container muss wissen, wo Elasticsearch läuft. Das wird über seafevents.conf konfiguriert, die im Seafile Volume unter /shared/seafile/conf/seafevents.conf liegt.

Sobald Elasticsearch läuft, verbinde dich per SSH mit deinem Seafile Container und füg folgendes in die Datei ein:

[INDEX FILES]
enabled = true
interval = 10m
external_es_server = true
es_host = your-elasticsearch-internal-hostname.internal
es_port = 9200

Ersetze your-elasticsearch-internal-hostname mit dem tatsächlichen internen Hostname des Elasticsearch Service, den du in den Service Settings auf Sliplane findest.

Nach dem Speichern klick auf Redeploy beim Seafile Service im Sliplane Dashboard.

Setup erweitern

Der gleiche Ansatz — zusätzliche Services über den Compose Parser deployen — funktioniert auch für weitere optionale Seafile-Komponenten:

  • Notification Server — Echtzeit-Benachrichtigungen bei Dateiänderungen
  • AI Server — KI-basierte Features wie Smart Search und Empfehlungen

Details zur Konfiguration findest du in der offiziellen Seafile-Dokumentation.

FAQ

Was kostet es, Seafile auf Sliplane zu betreiben?

Das hängt von der Last und Edition ab, aber du kannst mit der Community Edition auf einem Base Server ab 9 €/Monat starten. Falls du an Ressourcen-Limits stößt, kannst du deinen Server einfach upgraden, ohne etwas an deinem Setup ändern zu müssen.

Kann ich eine eigene Domain verwenden?

Ja! Du kannst eine Custom Domain in den Seafile Service Settings auf Sliplane hinterlegen. SSL-Zertifikate werden automatisch verwaltet.

Kann ich den Seafile Desktop oder Mobile Client verbinden?

Ja. Trag einfach deine Sliplane-Domain (oder Custom Domain) im Client ein und log dich mit deinen Admin Credentials ein. Der Desktop Client ist für Windows, macOS und Linux verfügbar. Mobile Apps gibt es für iOS und Android.

Zusammenfassung

Du hast jetzt eine voll funktionsfähige Seafile-Instanz auf Sliplane. Angefangen mit der Community Edition mit MariaDB und Redis kannst du dein Setup Schritt für Schritt erweitern — mit SeaDoc für Dokumentenbearbeitung, einem Upgrade auf die Pro Edition für erweiterte Features und Elasticsearch für Volltextsuche. Alles ohne Server-Management oder komplizierte Deployment-Skripte.

Willkommen in der Container-Cloud

Sliplane macht es einfach, Container in der Cloud zu deployen und bei Bedarf zu skalieren. Probier es jetzt aus!

Mit GitHub anmelden