Seafile

# Shell-Skript zur Installation von Docker (mit sudo ausführen:
#!/bin/bash
for pkg in docker.io docker-doc docker-compose docker-compose-v2 podman-docker containerd runc; do
apt-get remove $pkg;
done
apt-get update
apt-get install ca-certificates curl
install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
chmod a+r /etc/apt/keyrings/docker.asc
echo \
 "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian \
 $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
tee /etc/apt/sources.list.d/docker.list > /dev/null
apt-get update
apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
systemctl start docker
systemctl enable docker
usermod -aG docker "$SUDO_USER"

chmod +x dockerinstall.sh
sudo ./dockerinstall.sh

# 1. Benötigte Pakete für die Key-Verwaltung installieren
sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl

# 2. Den offiziellen Caddy-GPG-Key hinzufügen
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg

# 3. Die Caddy-Paketquelle hinzufügen
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list

# 4. Paketliste aktualisieren und Caddy installieren
sudo apt update
sudo apt install caddy

mkdir seafile
cd seafile

nano .env

# Datenbank (Generiere hier ein neues, langes Passwort!)
DB_ROOT_PASSWORD=EinmöglichstkomplexesundgeheimesPasswortwiezumBeispiel123456
DB_PASSWORD=dto

# Seafile Admin
SEAFILE_ADMIN_EMAIL=mail@adresse.tld
SEAFILE_ADMIN_PASSWORD=nocheingeheimeslpasswort

# Wichtig: Die echte Domain ohne Protokoll
SEAFILE_SERVER_HOSTNAME=(sub)domain.des.servers

# Zeitzone
TIME_ZONE=Europe/Berlin

# JWT Schlüssel (Neu generieren: openssl rand -base64 32)
JWT_PRIVATE_KEY=Mit openssl rand -base64 32 generieren und hier einfügen!

services:
  db:
    image: mariadb:10.11
    container_name: seafile-mysql
    restart: unless-stopped
    environment:
      - MYSQL_ROOT_PASSWORD=${DB_ROOT_PASSWORD}
      - MARIADB_AUTO_UPGRADE=1
    volumes:
      - /opt/seafile/shared/db:/var/lib/mysql
    networks:
      - seafile-internal

  memcached:
    image: memcached:1.6
    container_name: seafile-memcached
    entrypoint: memcached -m 256
    networks:
      - seafile-internal

  seafile:
    image: seafileltd/seafile-mc:latest
    container_name: seafile
    restart: unless-stopped
    ports:
      - "127.0.0.1:8080:80"   # Web-UI (nur lokal für Caddy)
      - "127.0.0.1:8082:8082" # Fileserver (nur lokal für Caddy)
    environment:
      - DB_HOST=db
      - DB_ROOT_PASSWD=${DB_ROOT_PASSWORD}
      - TIME_ZONE=${TIME_ZONE}
      - SEAFILE_ADMIN_EMAIL=${SEAFILE_ADMIN_EMAIL}
      - SEAFILE_ADMIN_PASSWORD=${SEAFILE_ADMIN_PASSWORD}
      - SEAFILE_SERVER_HOSTNAME=${SEAFILE_SERVER_HOSTNAME}
      - SEAFILE_SERVER_LETSENCRYPT=false # Caddy macht SSL, nicht Seafile!
      - JWT_PRIVATE_KEY=${JWT_PRIVATE_KEY}
    volumes:
      - /opt/seafile/shared/seafile-data:/shared
    depends_on:
      - db
      - memcached
    networks:
      - seafile-internal

networks:
  seafile-internal:
    driver: bridge

# Die Domain beim Hoster
sub.domain.tld {
    # Logging (optional, aber nützlich)
    log {
        output file /var/log/caddy/seafile_access.log
    }

    # Der eigentliche Proxy zur Seafile Web-UI
    reverse_proxy 127.0.0.1:8080

    # Spezielle Behandlung für den Fileserver (Upload/Download)
    handle_path /seafhttp* {
        reverse_proxy 127.0.0.1:8082
    }

    # Sicherheit: HSTS aktivieren
    header {
        Strict-Transport-Security "max-age=31536000; includeSubDomains; preload"
    }
}

sudo systemctl restart caddy

docker compose up -d

sudo nano /opt/seafile/shared/seafile-data/seafile/conf/seahub_settings.py
	

# -*- coding: utf-8 -*-
SECRET_KEY = "wurde automatisch erzeugt; nicht ändern!"
SERVICE_URL = "https://sub.domain.tld"

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'seahub_db',
        'USER': 'seafile',
        'PASSWORD': 'nichtändern',
        'HOST': 'db',
        'PORT': '3306',
        'OPTIONS': {'charset': 'utf8mb4'},
    }
}


CACHES = {
    'default': {
        'BACKEND': 'django_pylibmc.memcached.PyLibMCCache',
        'LOCATION': 'memcached:11211',
    },
    'locmem': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
    },
}
COMPRESS_CACHE_BACKEND = 'locmem'
TIME_ZONE = 'Europe/Berlin'
FILE_SERVER_ROOT = "https://sub.domain.tld/seafhttp"
CSRF_TRUSTED_ORIGINS = ["https://sub.domain.tld"]


# E-Mail Einstellungen
EMAIL_USE_TLS = False
EMAIL_HOST = "mail.domain.tld"                  # SMTP-Server deines Providers
EMAIL_PORT = 465                                # Port für TLS (meist 587)
EMAIL_HOST_USER = "seafile@domain.dlt"          # Dein Benutzername/E-Mail
EMAIL_HOST_PASSWORD = "TrIuMp,66,="             # Dein Passwort
EMAIL_FROM_USER = "seafile@domain.tld"          # Absender-Adresse
SERVER_EMAIL = "seafile@domain.tld"             # Adresse für System-Benachrichtigungen
DEFAULT_FROM_EMAIL = EMAIL_FROM_USER
EMAIL_USE_SSL = True 

	

sudo nano /opt/seafile-backup.sh
	

#!/bin/bash

# --- KONFIGURATION ---
BACKUP_DIR="/opt/seafile/shared/backups" # Verzeichnis auf dem HOST
CONTAINER_NAME="seafile-mysql"
DB_USER="root"
DB_PASS="DEIN_PASSWORT_OHNE_LEERZEICHEN"
KEEP_DAYS=7 # Wie viele Tage sollen die lokalen SQL-Dumps behalten werden?

# Datum für den Dateinamen
DATE=$(date +%Y-%m-%d_%H-%M)
FILENAME="seafile_complete_$DATE.sql"

# Verzeichnis erstellen, falls nicht vorhanden
mkdir -p $BACKUP_DIR

# --- DUMP ERSTELLEN ---
echo "Starte Datenbank-Backup für Seafile..."

docker exec $CONTAINER_NAME mariadb-dump \
    -u $DB_USER \
    -p$DB_PASS \
    --databases ccnet_db seafile_db seahub_db > $BACKUP_DIR/$FILENAME

# Prüfen, ob der Dump erfolgreich war
if [ $? -eq 0 ]; then
    echo "Backup erfolgreich: $FILENAME"
    # Optional: Erfolgsmeldung per Mail (falls 'mailutils' installiert sind)
    # echo "Seafile Backup erfolgreich erstellt am $DATE" | mail -s "Seafile Backup OK" mail@deine-domain.de
else
    echo "FEHLER: Backup fehlgeschlagen!" >&2
    exit 1
fi

# --- ALTE DUMPS LÖSCHEN ---
# Löscht Dateien, die älter als KEEP_DAYS sind, um Platz zu sparen
find $BACKUP_DIR -name "seafile_complete_*.sql" -mtime +$KEEP_DAYS -exec rm {} \;

echo "Bereinigung abgeschlossen."
	

sudo chmod +x /opt/seafile-backup.sh
	

sudo /opt/seafile-backup.sh
	

sudo crontab -e
            

no crontab for andreas - using an empty one

Select an editor.  To change later, run 'select-editor'.
  1. /bin/nano        <---- easiest
  2. /usr/bin/vim.basic
  3. /usr/bin/vim.tiny
  4. /bin/ed

Choose 1-4 [1]: 1
            

0 7 * * * /opt/seafile-backup.sh
            

#!/bin/bash

# 1. Sicherstellen, dass der Mount-Punkt leer/sauber ist
fusermount -u /opt/seafile-fuse 2>/dev/null

# 2. Mount im Container starten
docker exec seafile /opt/seafile/seafile-server-latest/seaf-fuse.sh start /shared/fuse

# 3. Kurz warten, bis das Dateisystem bereit ist
sleep 5

# 4. Der Backup-Befehl (hier rsync)
# Hier werden jetzt alle Dateien im Klartext kopiert
rsync -av --delete /opt/seafile-fuse/ /opt/seafile/filebackup

# 5. Sauber unmounten
docker exec seafile /opt/seafile/seafile-server-latest/seaf-fuse.sh stop

sudo umount -l /opt/seafile-fuse 2>/dev/null

            

chmod +x backupfiles.sh
            

sudo ./backupfiles.sh