Instala tu propio servidor de almacenamiento en la nube con Seafile + HTTPS en una Raspberry Pi y conviértete en el responsable de tu propios datos

Fuente: http://xkcd.com/1117/

Fuente: http://xkcd.com/1117/

Cloud” es una de esas palabras rimbombantes tan de moda en la tecnología, como lo fue en su momento “outsourcing“, “virtualización“, “datamining” y más recientemente cualquier cosa que empiece con el prefijo “ciber“. Todas las empresas quieren implementar los últimos desarrollos tecnológicos, aunque a veces ni siquiera los entiendan ni identifiquen los potenciales riesgos a los que se enfrentan (problemas de privacidad, de cumplimiento, de disponibilidad, de dependencia de proveedores, etc.). Igualmente, como usuarios somos susceptibles a caer ante la tentación de usar nuevas tecnologías ya sea por las campañas de marketing salvaje que nos saturan (para estar en la onda “cool”), la presión de nuestros propios colegas o la necesidad operativa para no quedarse relegado con tecnologías “obsoletas”.

Este es el caso del “Cloud” (computación en la nube): Delegación de servicios y procesos informáticos a un proveedor que te ofrece una serie de servicios adicionales sin la necesidad de que dispongas de plataformas, infraestructuras y/o aplicaciones. Dentro de los beneficios obtenidos de este tipo de modelos se encuentra el precio de los servicios (casi siempre calculado con base en el uso por tiempo), la escalabilidad (ya que el proveedor suela contar con replicación en diferentes datacenters) y rendimiento (ya que el uso de los recursos es monitorizado y gestionado automáticamente). No estoy en contra de esta tecnología, por el contrario, es interesante implementarla pero es recomendable la ejecución previa de un análisis de riesgos que nos permita identificar amenazas, vulnerabilidades y gestionar controles de seguridad con base en los datos “compartidos” y “delegados” al proveedor de Cloud.

Uno de los elementos principales a tener en cuenta es la privacidad. Debido a la “omnipresencia” provista por la computación en la nube, los datos son replicados en múltiples lugares para garantizar su recuperación en caso de problemas y su disponibilidad independientemente de la ubicación. No obstante, ¿sabes en dónde estarán físicamente almacenados tus datos? ¿quién tendrá acceso a los mismos? y ¿se aplican los controles de cumplimiento y legislación local del país de origen de dichos datos en cada lugar en donde son replicados (como la LOPD española – por ejemplo – si el CPD está en USA)?

Dejando de lado el ámbito empresarial y limitándonos al uso del Cloud como usuarios, ¿nos otorgan estas soluciones los niveles de seguridad que queremos implementar para nuestros propios datos? He aquí un par de ejemplos en donde este criterio ha sido vulnerado:

  • Microsoft analizó y bloqueó los datos de un usuario almacenados en su servicio SkyDrive (ahora OneDrive) por contenido ofensivo. Sin embargo, ¿por qué Microsoft estaba espiando los datos personales de un usuario de su servicio sin su permiso? (info)
  • Las fotos y videos privados de múltiples celebridades almacenados en el servicio iCloud de Apple fueron extraidas y publicadas de forma no autorizada en Internet (info)
  • Análisis (no comprobados) de un consultor independiente apuntaban a que el servicio de almacenamiento en la nube Dropbox tenía acceso a todos los archivos almacenados en el equipo del usuario, fuera de la carpeta que explícitamente se había indicado para que fuera sincronizada (info)

La respuesta del usuario promedio podría ser: “Mis datos almacenados en la nube no tienen valor sino únicamente para mi” o “no tengo nada que ocultar”. Pero, ¿son estas las justificaciones para permitir la pérdida de privacidad y potencial espionaje? Yo creo que no.

Es por eso que en términos personales he optado por renunciar a este tipo de servicios e implementar mi propio servidor de almacenamiento en la nube aprovechando el hardware provisto por una Raspberry Pi y usando la solución Seafile, que cuenta con altas prestaciones en términos de encriptación y disponibilidad.

Al igual que Seafile, existen otras muchas soluciones similares, dentro de las que se encuentran (por solo nombrar algunas):

Es importante aclarar que esta aplicación cuenta con una documentación bastante detallada, que se recomienda verificar como complemento a este manual.

No siendo más, procedamos con la instalación de Seafile en una Raspberry Pi.

Instalar el servidor de Seafile

Pre-requisitos

Antes de proceder, es necesario que se haya definido previamente lo siguiente:

  • Conexión a Internet y redirección de puertos: La Raspberry Pi debe estar conectada a Internet ya sea directamente o detrás de un router/firewall, con posibilidad de apertura de puertos (NAT/PAT). Se debe permitir tráfico entrante a los siguientes puertos:
    • 8000
    • 8082
  • Si se quiere emplear HTTPS con stunnel (como se explicará más adelante) hay que hacer la siguiente redirección de puertos:
    • 8000 -> 8001
    • 8082 -> 8083

La siguiente es un ejemplo de configuración (router inalámbrico Livebox Fibra Orange):

  • Un nombre de host y de dominio válidos y/o una dirección IP fija: Si deseas que el servicio se pueda acceder desde internet, necesitas alguna de estas dos cosas. En el caso que tengas una dirección IP dinámica (que por lo general es lo que ofrecen las ISP), entonces puedes registrar un nombre de dominio asociado empleando servicios como no-ip.com o cualquiera de los enumerados aquí.
  • Un directorio en el cual almacenar los datos que se van a sincronizar: Este directorio debe tener suficiente espacio. Preferiblemente un disco duro externo.

Actualizar el sistema operativo de la Raspberry Pi

En mi caso tengo instalado Raspbian.

root@raspberrypi /opt # apt-get update
root@raspberrypi /opt # apt-get upgrade

Descargar el paquete de instalación de la página oficial de Seafile

En la página de Seafile se encuentra el paquete específico para Raspberry Pi. Se puede encontrar en la página principal del proyecto o en su repositorio de código en GitHub. Descargar la última versión.

root@raspberrypi /opt # wget https://github.com/haiwen/seafile-rpi/releases/download/v6.2.5/seafile-server_6.2.5_stable_pi.tar.gz

Descomprimir el paquete

root@raspberrypi /opt # tar xvfz seafile-server_6.2.5_stable_pi.tar.gz

Instalar dependencias

root@raspberrypi /opt # apt-get install python-imaging
root@raspberrypi /opt # apt-get install python-requests
root@raspberrypi /opt # apt-get install sqlite3

Ejecutar el script de instalación

Este script instalará los componentes Seafile (seaf-server) para la gestión de la sincronización de archivos y Ccnet (ccnet-server) para la comunicación interna entre componentes.

root@raspberrypi /opt/ # cd seafile-server-6.2.5
root@raspberrypi /opt/ # ./setup-seafile.sh

You are running this script as ROOT. Are you sure to continue?
[yes|no] yes

-----------------------------------------------------------------
This script will guide you to config and setup your seafile server.

Make sure you have read seafile server manual at

        https://github.com/haiwen/seafile/wiki

Note: This script will guide your to setup seafile server using sqlite3,
which may have problems if your disk is on a NFS/CIFS/USB.
In these cases, we sugguest you setup seafile server using MySQL.

Press [ENTER] to continue
-----------------------------------------------------------------

Checking packages needed by seafile ...

Checking python on this machine ...
Find python: python2.7

  Checking python module: setuptools ... Done.
  Checking python module: python-imaging ... Done.
  Checking python module: python-sqlite3 ... Done.

Checking for sqlite3 ...Done.

Checking Done.

Configurar el servicio

En este punto, es importante tener a mano el nombre de host y de dominio y la ruta en donde se almacenarán los datos:

What would you like to use as the name of this seafile server?
Your seafile users will be able to see the name in their seafile client.
You can use a-z, A-Z, 0-9, _ and -, and the length should be 3 ~ 15
[server name]: server


What is the ip or domain of this server?
For example, www.mycompany.com, or, 192.168.1.101

[This server's ip or domain]: server.com

Where would you like to store your seafile data?
Note: Please use a volume with enough free space.
[default: /opt/seafile-data ] 

What tcp port do you want to use for seafile fileserver?
8082 is the recommended port.
[default: 8082 ]


This is your config information:

server name:        server        
server ip/domain:   server.com 
seafile data dir:   /opt-seafile-data
fileserver port:    8082

If you are OK with the configuration, press [ENTER] to continue.

Generating ccnet configuration in /opt/ccnet...

done
Successly create configuration dir /opt/ccnet.

Generating seafile configuration in /media/Seafile ...

Done.

Configurar SeaHub (Interface Web)

Este paso es opcional y depende si quieres una consola web o no. De acuerdo con la arquitectura de la aplicación, éste es un componente independiente, pero lo recomendable es instalarlo ya que desde aquí se permitirá el acceso vía web a los usuarios y se contará con una consola de administración gráfica.

-----------------------------------------------------------------
Seahub is the web interface for seafile server.
Now let's setup seahub configuration. Press [ENTER] to continue
-----------------------------------------------------------------


Creating seahub database now, it may take one minute, please wait...


Done.

creating seafile-server-latest symbolic link ... done

Finalizar la instalación de componentes

En este punto se nos indicarán los scripts para la gestión de los componentes y los puertos de comunicación, que usaremos más adelante.

Your seafile server configuration has been completed successfully.
-----------------------------------------------------------------

run seafile server:     ./seafile.sh { start | stop | restart }
run seahub  server:     ./seahub.sh  { start <port> | stop | restart <port> }

-----------------------------------------------------------------
If the server is behind a firewall, remember to open these tcp ports:
-----------------------------------------------------------------

port of seafile fileserver:   8082
port of seahub:               8000

When problems occur, refer to

      https://github.com/haiwen/seafile/wiki

for more information.

Iniciar el servidor de Seafile

root@raspberrypi /opt/seafile-server-6.2.5 # ./seafile.sh start

Starting seafile server, please wait ...
Seafile server started

Done.

Iniciar el servidor de SeaHub y parametrizarlo

root@raspberrypi /opt/seafile-server-6.2.5 # ./seahub.sh start 8000

Starting seahub at port 8000 ...

----------------------------------------
It's the first time you start the seafile server. Now let's create the admin account
----------------------------------------

What is the email for the admin account?
[ admin email ] [email protected]

What is the password for the admin account?
[ admin password ]

Enter the password again:
[ admin password again ]



----------------------------------------
Successfully created seafile admin
----------------------------------------



Loading ccnet config from /opt/ccnet
Loading seafile config from /mnt/usbdisk/Seafile

Seahub is started

Done.

Ingresar en la consola como administrador

En este paso ya todo el proceso de instalación está finalizado y Seafile estará totalmente operativo.

Para validarlo, simplemente ingresar a la dirección IP o al hostname definido en el puerto 8000 (http://[nombre o dirección]:8000):

Configurar Seafile para que inicie en cada reinicio

root@raspberrypi /opt/seafile-server-4.0.6 #crontab -e

@reboot sudo /opt/seafile-server-latest/seafile.sh start
@reboot sudo /opt/seafile-server-latest/seahub.sh start

Otra opción es agregarlo a /etc/rc.local como lo uso yo (esto solo aplica para Raspbian 7):

#Seafile & Seahub
/opt/seafile-server-latest/seafile.sh start
/opt/seafile-server-latest/seahub.sh start
exit 0

Si usas Raspbian 8 (o cualquier otra distribución que soporte systemd), se le deben ejecutar las siguientes instrucciones para que cargue los servicios cuando el sistema operativo inicie:

root@raspberrypi ~ # systemctl enable seafile
Created symlink from /etc/systemd/system/multi-user.target.wants/seafile.service to /etc/systemd/system/seafile.service.
root@raspberrypi ~ # systemctl enable seahub
Created symlink from /etc/systemd/system/multi-user.target.wants/seahub.service to /etc/systemd/system/seahub.service.

Más información en este enlace.

Configurar el acceso vía HTTPS (opcional)

Configuración para nginx y Apache

Para configurar el acceso seguro vía HTTPS (no soportado de forma nativa por Seafile) es necesario ejecutar pasos adicionales dependiendo del servidor web que se emplee:

Estas configuraciones implican que adicionalmente a los servicios de Seafile nativos es necesario instalar uno de estos dos servidores web. El problema es que estos servicios consumirán recursos adicionales en la Raspberry Pi, un dispositivo con hardware y rendimiento limitado.

Configuración para gunicorn (servidor web nativo de Seafile) y stunnel

La alternativa que describo en este manual permite agregar la capa de seguridad HTTPS sin penalizar el desempeño, funcionando exclusivamente con el servidor web nativo de seafile: gunicorn. Para ello, se hará uso de stunnel, un servicio de tunelización TLS para aplicaciones que no cuentan con soporte nativo de este protocolo.

Para que todo el servicio funcione, es necesario contar con un certificado digital válido para el nombre y dominio de la Raspberry Pi. Este punto es importante, porque si el certificado digital no cuenta con una lista de revocación válida (certificate revocation list – CRL), entonces el cliente de Seafile generará errores y no permitirá la conexión. Por ello, se hará uso de Let’s Encrypt y CertBot.

Instalación de CertBot y generación de certificados digitales

Para instalar CertBot, simplemente ejecutar el siguiente comando (se asume que la instalación se hace en Raspbian 9:

$ sudo apt-get install certbot

Después de la instalación, es necesario hacer un paso intermedio, que consiste en habilitar el puerto 80 temporalmente para permitir tráfico entrante. Esto debido a que CertBot (vía Let’s Encrypt) requiere realizar una validación de que el nombre de dominio al cual le generará el certificado es un dominio válido y existente.

Cuando esté habilitado el tráfico entrante al puerto 80, ejecutar el siguiente comando:

$ sudo certbot certonly --standalone -d server.com

Cambiar “server.com” por el nombre de dominio o dirección IP de la Raspberry Pi.

Al finalizar el proceso, se habrán creado 4 archivos en la ruta /etc/letsencrypt/live/[nombre dominio]:

root@RaspberryPi /etc/letsencrypt/live/server.com # ls -ltra
total 12
-rw-r--r-- 1 root root  543 Feb 12 21:06 README
lrwxrwxrwx 1 root root   47 Feb 12 21:06 privkey.pem -> ../../archive/server.com/privkey1.pem
lrwxrwxrwx 1 root root   49 Feb 12 21:06 fullchain.pem -> ../../archive/server.com/fullchain1.pem
lrwxrwxrwx 1 root root   45 Feb 12 21:06 chain.pem -> ../../archive/server.com/chain1.pem
lrwxrwxrwx 1 root root   44 Feb 12 21:06 cert.pem -> ../../archive/server.com/cert1.pem

Para este caso, necesitaremos solamente fullchain.pem (el certificado completo incluyendo CRL y toda la jerarquía) y privkey.pem (la clave privada).

Los certificados digitales de Let’s Encrypt son válidos únicamente por 90 días. No obstante, CertBot se encarga de actualizarlos de forma automática.

No olvidar cerrar el puerto 80.

Instalación de stunnel

Finalizada la generación de certificados, se procede con la instalación de stunnel (en este caso, la versión 4):

$ sudo apt-get install stunnel

Luego, editar el fichero /etc/default/stunnel4 y cambiar la variable “ENABLED” a 1.

Para poder gestionar el servicio empleando systemctl, es necesario crear un archivo de parámetros llamado “stunnel.service” en /lib/systemd/system:

root@RaspberryPi /lib/systemd/system # cd /lib/systemd/system
root@RaspberryPi /lib/systemd/system # pico stunnel.service
[Unit]
Description=SSL tunnel for network daemons
After=network.target
After=syslog.target

[Install]
WantedBy=multi-user.target
Alias=stunnel.target

[Service]
Type=forking
ExecStart=/usr/bin/stunnel4 /etc/stunnel/stunnel.conf
ExecStop=/usr/bin/killall -9 stunnel

# Give up if ping don't get an answer
TimeoutSec=600

Restart=always
PrivateTmp=false

Y luego lo habilitamos para funcionar vía systemctl:

root@RaspberryPi /lib/systemd/system # systemctl enable stunnel.service
Created symlink /etc/systemd/system/stunnel.target → /lib/systemd/system/stunnel.service.
Created symlink /etc/systemd/system/multi-user.target.wants/stunnel.service → /lib/systemd/system/stunnel.service.

Parametrización de stunnel e inicialización

Editamos el archivo /etc/stunnel/stunnel.conf. Cambiar “server.com” por el nombre de dominio asignado a la Raspberry Pi:

root@RaspberryPi /etc/stunnel # more stunnel.conf
setuid          = stunnel4
setgid          = stunnel4
debug           = 7
output          = /var/log/stunnel.log
pid             = /var/run/stunnel4/stunnel.pid
socket          = l:TCP_NODELAY=1
ciphers         = ALL:!ADH:!EXPORT56:RC4+RSA:+HIGH:+MEDIUM:!LOW:!SSLv2:!EXP:!eNULL
options         = -NO_SSLv3

[https-seafile]
accept          = 8001
cert            = /etc/letsencrypt/live/server.com/fullchain.pem
key             = /etc/letsencrypt/live/server.com/privkey.pem
connect         = 8000
TIMEOUTclose    = 0

[https-seahub]
accept          = 8083
cert            = /etc/letsencrypt/live/server.com/fullchain.pem
key             = /etc/letsencrypt/live/server.com/privkey.pem
connect         = 8082
TIMEOUTclose    = 0

En este archivo creamos dos túneles HTTPS:

  • Uno para seafile, que escuchará en el puerto 8001 y redireccionará el tráfico al puerto local 8000, y
  • Otro para seahub, que escuchará en el puerto 8083 y redireccionará el tráfico al puerto local 8082.

Ambos túneles emplearán el mismo certificado digital creado anteriormente.

Hecho esto, iniciamos stunnel:

root@RaspberryPi / #systemctl start stunnel

Con esto, lo que hemos hecho es lo siguiente:

Para ver que todo esté funcionando correctamente, en vez de ir a http://[nombre o dirección]:8000 iremos a https://[nombre o dirección]:8000.

Si hay problemas, se puede revisar el log de stunnel:

root@RaspberryPi /etc/stunnel # tail /var/log/stunnel.log -f
2018.02.16 09:46:43 LOG7[main]: Service [https-seahub] accepted (FD=3) from 107.1XX.253.XXX:32794
2018.02.16 09:46:43 LOG7[11982]: Service [https-seahub] started
2018.02.16 09:46:43 LOG7[11982]: Option TCP_NODELAY set on local socket
2018.02.16 09:46:43 LOG5[11982]: Service [https-seahub] accepted connection from 107.1XX.253.XXX:32794
2018.02.16 09:46:43 LOG6[11982]: Peer certificate not required
2018.02.16 09:46:43 LOG7[11982]: TLS state (accept): before SSL initialization
2018.02.16 09:46:43 LOG3[11982]: SSL_accept: 1408F09C: error:1408F09C:SSL routines:ssl3_get_record:http request
2018.02.16 09:46:43 LOG5[11982]: Connection reset: 0 byte(s) sent to TLS, 0 byte(s) sent to socket
2018.02.16 09:46:43 LOG7[11982]: Local descriptor (FD=3) closed
2018.02.16 09:46:43 LOG7[11982]: Service [https-seahub] finished (0 left)

A partir de ahora tanto la consola de administración como la sincronización de archivos en los clientes Windows y móviles se hará por protocolo HTTPS.

Actualización del servidor de Seafile

En el caso que se quiera realizar una actualización del software del servidor de Seafile, el proceso está bastante automatizado. En este caso, se realizará una actualización de la versión 6.2.5 a la 6.2.6 como ejemplo.

Descargar la nueva versión del paquete de Seafile

root@raspberrypi:~# wget https://github.com/haiwen/seafile-rpi/releases/download/v6.2.5/seafile-server_6.2.6_stable_pi.tar.gz

Descomprimir el paquete

root@raspberrypi:~# tar xvfz seafile-server_6.2.6_stable_pi.tar.gz

Detener los servicios de Seafile y SeaHub

root@raspberrypi:~# /opt/seafile-server-6.2.5/seafile.sh stop
root@raspberrypi:~# /opt/seafile-server-6.2.5/seahub.sh stop

Localizar y ejecutar el script de actualización

En la carpeta /upgrade del directorio del paquete descomprimido se encuentran una serie de scripts de actualización. Simplemente, ejecutar el script relacionado con la versión instalada actualmente:

root@raspberrypi:~/seafile-server-6.2.6/upgrade# ls
add_collate.sh        minor-upgrade.sh          upgrade_1.3_1.4.sh  upgrade_1.7_1.8.sh  upgrade_2.2_3.0.sh  upgrade_4.1_4.2.sh  upgrade_5.0_5.1.sh  win32
db_update_1.3_1.4.py  regenerate_secret_key.sh  upgrade_1.4_1.5.sh  upgrade_1.8_2.0.sh  upgrade_3.0_3.1.sh  upgrade_4.2_4.3.sh  upgrade_5.1_6.0.sh
db_update_helper.py   sql                       upgrade_1.5_1.6.sh  upgrade_2.0_2.1.sh  upgrade_3.1_4.0.sh  upgrade_4.3_4.4.sh  upgrade_6.0_6.1.sh
fix_mysql_user.py     upgrade_1.2_1.3.sh        upgrade_1.6_1.7.sh  upgrade_2.1_2.2.sh  upgrade_4.0_4.1.sh  upgrade_4.4_5.0.sh  upgrade_6.1_6.2.sh

En este caso, como tengo instalada la versión 6.2.5 y quiero pasar a la 6.2.6, simplemente ejecuto el script “minor-upgrade.sh”. Si es un cambio mayor de versión, ejecuto el script que corresponda:

root@raspberrypi:/opt/seafile-server-6.2.6/upgrade# ./minor-upgrade.sh

-------------------------------------------------------------
This script would upgrade your seafile server from 6.2.5 to 6.2.6
Press [ENTER] to contiune
-------------------------------------------------------------



Updating seafile/seahub database ...

[INFO] You are using SQLite3
[INFO] updating seafile database...
[INFO] updating seahub database...
Done

migrating avatars ...

Done

updating /opt/seafile-server-latest symbolic link to /opt/seafile-server-6.2.6 ...



-----------------------------------------------------------------
Upgraded your seafile server successfully.
-----------------------------------------------------------------

Reiniciar el nuevo servidor actualizado

root@raspberrypi:~# /opt/seafile-server-latest/seafile.sh start
root@raspberrypi:~# /opt/seafile-server-latest/seahub.sh start

Instalación del cliente de Seafile

En la página oficial de descargas de Seafile se encuentran los clientes para Windows, Mac, Android, Linux y en modo terminal (CLI).

Instalar y configurar el cliente de Seafile en Windows

Después de descargar el cliente, simplemente instalarlo. al finalizar la instalación, indicar la ubicación en donde se desea que queden almacenados los archivos sincronizados:

Configurar el acceso para la sincronización con los datos recién creados del servidor Seafile:

En este punto – y dependiendo si se ha usado HTTPS o no- se debe ingresar la URL correspondiente.

Crear el disco virtual de almacenamiento. Las carpetas creadas en Seafile se denominan “Bibliotecas” (Library):

El agente ya estará listo para sincronizar:

Una característica MUY INTERESANTE de Seafile es la capacidad de crear bibliotecas cifradas. Esto lo hace a través de una contraseña y algoritmos de encriptacion robustos (AES 256/CBC). Las bibliotecas cifradas siempre requerirán de la contraseña en el momento de ser compartidas o accedidas ya sea a través de la consola web o del agente local:

Al sincronizar, nos pedirá la contraseña:

Instalar el agente de Seafile en Android

Desde Google Play simplemente descargar la aplicación de Seafile y configurarla con los datos del servidor:

Configurar la cuenta registrada en el servidor de Seafile:

Y sincronizar:

Inclusive, en Android si la carpeta está cifrada se pedirá la contraseña para efectuar la sincronización:

Desinstalar Dropbox y quitarte de encima el problema de que no respeten tu privacidad

¡Adiós Dropbox! (aunque si aún quieres seguirlo utilizando, puedes mejorar tu seguridad encriptando todos tus datos con InstantCryptor, CloudFogger, Cryptomator o Boxcryptor)

¿Interesante? Si te ha gustado, no olvides comentar y/o compartirlo por las redes sociales. Compartir es crecer 😉

Comments

  • Buenas,

    Antes de nada agradecerte las molestias que te has tomado para hacer este magnífico tutorial.

    Me surge un problema a la hora de que el programa se arranque tras el reinicio. He seguido los pasos descritos en el apartado 11 (tanto contrab como rc.local) y no consigo que el programa arranque tras reiniciar. ¿Qué puedo hacer?

    Gracias de antemano.

    Barukh September 18, 2015
    • Hola de nuevo:
      Échale un vistazo a este artículo: “Cómo activar el soporte para rc.local de initscripts (SysVInit) en systemd”. Supongo que en tu caso tendrás Raspbian 8 y por eso es el problema.
      Adicionalmente, creo que a partir de la versión 5 de Seafile ya se incluyen scripts para compatibilidad con systemd y solo tienes que hacer lo siguiente:
      root@raspberrypi ~ # systemctl enable seafile
      Created symlink from /etc/systemd/system/multi-user.target.wants/seafile.service to /etc/systemd/system/seafile.service.
      root@raspberrypi ~ # systemctl enable seahub
      Created symlink from /etc/systemd/system/multi-user.target.wants/seahub.service to /etc/systemd/system/seahub.service.
      Espero que te sirva.

      david December 30, 2015
  • Hola Barukh:

    Valida que bajo /opt exista un link a la última versión de Seafile que tengas en tu Raspberry Pi:

    lrwxrwxrwx 1 root root 20 Sep 4 19:47 seafile-server-latest -> seafile-server-4.3.2

    En el caso que no, puedes crear el link de la siguiente manera:

    root@raspberrypi ~ # ln -s /opt/seafile-server-4.3.2 /opt/seafile-server-latest

    Asumiendo que la última versión que tienes es la 4.3.2.

    Así mismo, valida los permisos en los scripts de inicio:

    root@raspberrypi /opt/seafile-server-latest # ls -ltra sea*.sh
    -rwxr-xr-x 1 pi pi 6541 Aug 21 14:23 seahub.sh
    -rwxr-xr-x 1 pi pi 4279 Aug 21 14:23 seafile.sh
    -rwxr-xr-x 1 pi pi 2755 Aug 21 14:23 seaf-gc.sh
    -rwxr-xr-x 1 pi pi 3236 Aug 21 14:23 seaf-fuse.sh
    -rwxr-xr-x 1 pi pi 1860 Aug 21 14:23 seaf-fsck.sh

    y en /etc/rc.local:

    root@raspberrypi /opt/seafile-server-latest # ls -ltra /etc/rc.local
    -rwxr-xr-x 1 root root 640 Sep 4 19:50 /etc/rc.local

    Espero que te sirva.

    Saludos,

    David

    david September 23, 2015
  • Hola David, he seguido este tutorial, instalé seafile y el mismo me funciona a la perfección, el único inconveniente es que solo me funciona dentro de la mi interna. Me puedo conectar desde fuera a través de un DDNS, puedo ver los archivos pero no me permite ni subir ni bajar archivos. Qué puedo hacer?

    Rubén Hidalgo October 4, 2015
  • Me comí el párrafo “dentro de mi red interna” en el comentario anterior…

    Rubén Hidalgo October 4, 2015
  • Hola Rubén:
    ¿Has seguido los pasos que indican aquí? http://manual.seafile.com/deploy/deploy_seafile_behind_nat.html. A nivel de firewall se requiere que los puertos 8000 y 8082 (que es por donde se establecen las transferencias de archivos) estén abiertos.
    Saludos,
    David

    david October 6, 2015
  • como puedo hacer que la coneccion sea por https?

  • Buenas tardes José Antonio:
    Con un año de retraso pero es mejor tarde que nunca.
    He agregado un apartado para usar stunnel para encriptar la comunicación vía HTTPS.
    Saludos,
    David

    david February 16, 2018

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.