Seafile es una nube privada de archivos centrada en la sincronización, y con Docker la tienes funcionando en unos minutos. En esta guía levantas el servidor junto a una base de datos MariaDB, una caché Redis y un proxy Caddy con un solo archivo docker-compose.yml, aprendes a configurarlo en el primer arranque, a cifrar tus bibliotecas y a publicarlo con HTTPS. La misma explicación está disponible en inglés.

Puntos clave

  • Seafile es una plataforma de código abierto para sincronizar y compartir archivos que alojas en tu propio servidor, con clientes para escritorio, móvil y web.
  • A diferencia de Nextcloud, guarda los datos en bloques deduplicados y versionados al estilo de Git, un modelo que sincroniza carpetas con muchos ficheros de forma muy rápida.
  • El montaje de la versión 13 usa cuatro contenedores: el servidor (imagen seafileltd/seafile-mc), una base de datos MariaDB, una caché Redis y el proxy Caddy, que gestiona el HTTPS automático.
  • Fija una versión concreta de la imagen (por ejemplo seafileltd/seafile-mc:13.0.25) en lugar de :latest; así decides tú cuándo saltas de versión.
  • Las bibliotecas cifradas se protegen en el cliente con AES-256; la contraseña no se guarda en el servidor, por lo que nadie (ni tú) puede recuperar los datos si la olvidas.

¿Qué es Seafile y en qué se diferencia de Nextcloud?

Seafile es una plataforma de sincronización y almacenamiento de archivos de código abierto, desarrollada por la empresa Haiwen desde 2012. Como Nextcloud, te permite montar tu propio sustituto de Google Drive o Dropbox, con clientes de escritorio, aplicaciones móviles y una interfaz web llamada Seahub.

La diferencia está en el motor de almacenamiento. Nextcloud guarda cada archivo tal cual en el sistema de ficheros; Seafile, en cambio, parte cada archivo en bloques de aproximadamente 1 MB, los deduplica y los versiona como si fueran commits de Git. Ese diseño hace que la sincronización de carpetas con miles de archivos pequeños o con ficheros muy grandes sea notablemente más rápida y ligera en ancho de banda, porque solo viajan los bloques que han cambiado.

A cambio, Seafile es más especializado: brilla en sincronizar y compartir, pero no trae el ecosistema de aplicaciones de Nextcloud (calendario, contactos, correo, ofimática integrada). Si lo que buscas es una sincronización rápida y sólida de ficheros, Seafile es una opción excelente; si quieres una suite completa de colaboración, quizá te encaje mejor Nextcloud.

¿Qué necesitas y qué componentes lo forman?

Necesitas una máquina Linux con Docker y el plugin Compose ya instalados. Si aún no lo tienes, sigue primero la guía para instalar Docker en Ubuntu 24.04. Para un uso doméstico o de equipo pequeño basta con 2 GB de RAM y un par de núcleos.

Desde la versión 12, Seafile reorganizó su despliegue en Docker alrededor de variables de entorno y de varios contenedores con una responsabilidad clara cada uno:

  • Servidor Seafile (seafileltd/seafile-mc): el núcleo, que reúne el motor de ficheros y la interfaz web Seahub. La partícula mc del nombre viene de que la imagen incluía históricamente memcached.
  • Base de datos MariaDB: guarda usuarios, permisos y metadatos de las bibliotecas.
  • Caché Redis: en la versión 13 sustituye a memcached como caché por defecto.
  • Proxy Caddy: termina el TLS y obtiene certificados de Let’s Encrypt de forma automática.

En este tutorial definimos los cuatro dentro del mismo docker-compose.yml, así que no hace falta instalarlos por separado.

El docker-compose.yml de Seafile

Crea una carpeta para el proyecto y guarda dentro este docker-compose.yml. Sustituye cada valor cambia_esta_clave... por una contraseña propia y segura, y ajusta SEAFILE_SERVER_HOSTNAME con tu dominio o la IP del servidor antes de arrancar:

services:
  db:
    image: mariadb:10.11
    container_name: seafile-mysql
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: cambia_esta_clave_root
      MYSQL_LOG_CONSOLE: "true"
      MARIADB_AUTO_UPGRADE: "1"
    volumes:
      - db_data:/var/lib/mysql
    healthcheck:
      test: ["CMD", "healthcheck.sh", "--connect", "--innodb_initialized"]
      interval: 20s
      timeout: 5s
      retries: 5
    networks:
      - seafile-net

  redis:
    image: redis:7.4
    container_name: seafile-redis
    restart: unless-stopped
    networks:
      - seafile-net

  seafile:
    image: seafileltd/seafile-mc:13.0.25
    container_name: seafile
    restart: unless-stopped
    ports:
      - "80:80"
    volumes:
      - seafile_data:/shared
    environment:
      SEAFILE_MYSQL_DB_HOST: db
      SEAFILE_MYSQL_DB_USER: seafile
      SEAFILE_MYSQL_DB_PASSWORD: cambia_esta_clave_db
      INIT_SEAFILE_MYSQL_ROOT_PASSWORD: cambia_esta_clave_root
      JWT_PRIVATE_KEY: cambia_esta_clave_jwt_de_32_o_mas_caracteres
      SEAFILE_SERVER_HOSTNAME: seafile.midominio.com
      SEAFILE_SERVER_PROTOCOL: http
      CACHE_PROVIDER: redis
      REDIS_HOST: redis
      REDIS_PORT: 6379
      TIME_ZONE: Europe/Madrid
      INIT_SEAFILE_ADMIN_EMAIL: admin@midominio.com
      INIT_SEAFILE_ADMIN_PASSWORD: cambia_esta_clave_admin
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    networks:
      - seafile-net

volumes:
  db_data:
  seafile_data:

networks:
  seafile-net:

Fíjate en un par de detalles. El servidor no arranca hasta que MariaDB pasa su healthcheck, gracias a depends_on con la condición service_healthy. La clave JWT_PRIVATE_KEY es obligatoria desde la versión 12 y debe tener al menos 32 caracteres; genera una con openssl rand -hex 32. Y todo el estado importante (bases de datos, configuración y los bloques de tus archivos) vive en los volúmenes db_data y seafile_data, montado este último en /shared.

Variables de entorno y primer arranque

Con el archivo listo, arranca la pila en segundo plano y sigue el registro del servidor mientras se instala:

docker compose up -d
docker compose ps
docker compose logs -f seafile

La primera vez, la imagen crea las tres bases de datos (ccnet_db, seafile_db y seahub_db), aplica el esquema y da de alta la cuenta de administrador que definiste en INIT_SEAFILE_ADMIN_EMAIL e INIT_SEAFILE_ADMIN_PASSWORD, por lo que el arranque tarda un poco más de lo habitual. Cuando el registro deje de moverse, abre http://seafile.midominio.com (o la IP del servidor) e inicia sesión con esas credenciales.

Conviene entender qué hace cada variable clave del Compose:

  • SEAFILE_SERVER_HOSTNAME fija el dominio con el que se generan los enlaces; si lo cambias más tarde, tendrás que editarlo y recrear el contenedor.
  • SEAFILE_SERVER_PROTOCOL empieza en http para la primera prueba; lo pondrás en https al añadir el proxy.
  • CACHE_PROVIDER: redis selecciona Redis como caché, la opción por defecto en la versión 13.
  • INIT_SEAFILE_* solo se usan en el primer arranque; después, gestionas usuarios y contraseñas desde el panel de administración de Seahub.

¿Cómo cifrar una biblioteca?

En Seafile, cada carpeta de nivel superior es una biblioteca. Al crear una, puedes marcar la casilla Cifrar y establecer una contraseña. A partir de ahí, los archivos se cifran y descifran en tu dispositivo con AES-256 en modo CBC: al servidor solo llegan bloques ya cifrados.

Lo importante es que la contraseña de la biblioteca no se guarda en el servidor. Seafile solo almacena un valor de verificación («magic») que le permite comprobar que la contraseña es correcta, pero nunca la propia clave. Esto tiene dos consecuencias. La primera, buena: aunque alguien robe el disco del servidor, no puede leer el contenido de una biblioteca cifrada. La segunda, delicada: si olvidas la contraseña, los datos son irrecuperables, así que apúntala en tu gestor de contraseñas.

Ten en cuenta un matiz: cuando abres una biblioteca cifrada desde el navegador, la contraseña viaja al servidor para descifrar los bloques en memoria durante la sesión. El cifrado extremo a extremo real lo obtienes con el cliente de escritorio, que hace todo el trabajo en tu propio equipo. Para datos muy sensibles, usa el cliente en lugar de la interfaz web.

¿Cómo publicarlo con HTTPS?

Servir Seafile por HTTP plano solo vale para la primera prueba en tu red local: las contraseñas y los archivos viajarían sin cifrar. La versión 13 trae Caddy como proxy inverso oficial, que pide y renueva el certificado de Let’s Encrypt sin que tengas que tocar nada. Añade este servicio al Compose, quita la sección ports del servicio seafile, cambia SEAFILE_SERVER_PROTOCOL a https y añade al servidor las etiquetas del proxy:

  caddy:
    image: lucaslorentz/caddy-docker-proxy:2.12-alpine
    container_name: seafile-caddy
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - caddy_data:/data
      - /var/run/docker.sock:/var/run/docker.sock:ro
    networks:
      - seafile-net
    labels:
      caddy: https://seafile.midominio.com
      caddy.reverse_proxy: "{{upstreams 80}}"

Recuerda declarar también el volumen caddy_data: en la sección volumes:. Si prefieres reutilizar el proxy de la serie en lugar de Caddy, puedes ponerlo igualmente detrás de Traefik: el principio es el mismo, apuntar el proxy al puerto 80 del contenedor seafile.

Preguntas frecuentes

¿Seafile es mejor que Nextcloud?

Depende de para qué. Seafile gana en velocidad y eficiencia de sincronización, sobre todo con muchos archivos, gracias a su almacenamiento por bloques. Nextcloud gana en amplitud: además de ficheros, ofrece calendario, contactos, ofimática en línea y cientos de aplicaciones. Si quieres una sincronización rápida y sencilla, elige Seafile; si buscas una suite completa de colaboración, Nextcloud. Puedes probar ambos, porque los dos se levantan con Docker en minutos.

¿Puedo recuperar una biblioteca cifrada si olvido la contraseña?

No. La contraseña de una biblioteca cifrada no se guarda en el servidor, así que nadie puede restablecerla ni descifrar los bloques por ti. Es el precio de un cifrado real: la seguridad depende de que solo tú tengas la clave. Guárdala en un gestor de contraseñas y considera anotar una pista de recuperación en un lugar seguro antes de subir datos importantes.

¿Por qué no debo usar la etiqueta latest de la imagen?

Porque :latest (o la etiqueta rodante 13.0-latest) cambia sin avisarte y puede arrastrarte a una versión nueva durante un simple reinicio, justo cuando las actualizaciones mayores de Seafile requieren pasos de migración. Al fijar seafileltd/seafile-mc:13.0.25 decides tú cuándo actualizas, lees antes las notas de la versión y evitas sorpresas con la base de datos.

Conclusión

Con un único docker-compose.yml tienes una nube de archivos privada, rápida y con datos que no salen de tu servidor: servidor, base de datos, caché y proxy con HTTPS automático. El siguiente paso lógico es crear tus primeras bibliotecas (alguna cifrada), instalar el cliente de escritorio y programar copias de seguridad de los volúmenes. Si además quieres sincronizar carpetas entre equipos sin servidor central, echa un vistazo a Syncthing, que resuelve un problema parecido con un enfoque distinto.

Fuentes

  1. Manual oficial de Seafile: instalación con Docker
  2. Código fuente de Seafile (haiwen/seafile en GitHub)
  3. Imagen oficial seafile-mc en Docker Hub

Ruta: Bases de datos y almacenamiento self-hosted con Docker