Seafile, una nube opensource

Motivación

    Llevaba un tiempo buscando alternativas de almacenamiento en la nube desde que se anunció la muerte de Ubuntu ONE a mediados de 2014. Vale que los chicos de Canonical no reinventaron la rueda, pero su servicio funcionaba bastante bien. Tenía sus bugs y los clientes de Windows y Mac eran demasiado básicos, es cierto, pero cumplía bastante bien con mis necesidades.

    Antes de descubrir Ubuntu ONE utilizaba Google Drive para albergar documentos en la nube... pero realmente es algo que nunca me ha gustado mucho, puesto que hoy Google da miedo. Sabe demasiado y tampoco es cuestión de que filtre contenido a entidades dudosas como la NSA. Ya me dirán a mi por qué un servicio secreto de un país extranjero pudiera estar interesado en leer mi hoja de gastos mensual... En fin. Lo único bueno es que si algún día perdemos el móvil o la contraseña de GMail podremos escribirle una carta a la NSA o a la CIA para que nos los chiven :-).

    A pesar de ello, aunque más bien por motivos laborales, me vi en la obligación de coquetear con Office 365 y su flamante One Drive. Pero esa solución no me gustaba, porque era de ir de Guatemala a Guatepeor (pido disculptas a los guatemaltecos, pero es una expresión muy arraigada en la cultura española). Llevo trabajando casi un año como administrador de varios repositorios de SharePoint Online y aunque One Drive sea seguro y una delicia con su integración de Office Online, yo mismo he podido observar hasta qué punto un administrador puede ojear este tipo de archivos (con permiso de los usuarios finales, claro está). Pero claro, ¿y si un administrador de Microsoft que esté descontento desea mirar mi One Drive?

   Aunque él, a priori, no tenga permiso de administración sobre mi cuenta puede proclamarse como tal sin que yo reciba una notificación al respecto. Recordemos, que en pleno siglo XXI ya han robado contraseñas de eBay, Adobe e incluso de la PlayStation Network, recordando señores que la consolas de sobremesa de Sony suelen ser las más vendidas. No es que sea un terrorista en potencia, pero no quiero que los hackers que robaron en su día las fotos de centenares de famosas que posaron con sus iPhones como Dios les trajo al mundo puedan hacerse por ejemplo con el código fuente del último juego que esté programando.

   La cosa es que leyendo el número 91 de la revista francesa "Linux Pratique" leí un reportage sobre Seafile que me resultó interesante y tras trastear un poco con una de mis Raspberries Pi tengo que decir que funciona bastante bien, puesto que permite hacer lo que andaba buscando: Un usuario puede gestionar/sincronizar varias bibliotecas (carpetas), tiene soporte para multiusuario y permite la compartición de una biblioteca con varios usuarios... y ni Google, ni Microsoft, ni Facebook tienen por qué enterarse de la existencia de mis archivos.

Descripción del Software.

    Seafile es una solución que consta de dos partes: Un programa servidor donde gestionamos los usuarios, grupos, bibliotecas y albergamos todos los datos; Y un programa cliente por cada ordenador que necesite conectarse.

    El servidor a su vez puede parametrarse con el navegador web gracias a un servidor web que lleva embebido y a su vez se puede instalar con muy pocas líneas de consola. Por desgracia, por defecto parte del tráfico se realiza en claro, a través del protocolo HTTP. No obstante, aparentemente esto se limita únicamente al login (lo cual no es poco...) y además Seafile nos permite proteger las bibliotecas con contraseñas, permitiendo a su vez el cifraje del contenido. De todas formas en esta entrada explicaré también como modificar y utilizar un servidor Apache 2 local para forzar el uso de SSL (protocolo HTTPS) de forma que nuestra comunicación sea 100% cifrada.

Instalación del servidor.

    Necesitamos una máquina Linux y tener derechos de administrador. En este caso voy a explicar el proceso para instalarlo en una Raspberry PI, máquina que se adapta a mis necesidades. No obstante, recomiendo encarnizadamente (sobretodo si trabajas para una empresa) utilizar un servidor serio, como pudiera ser una máquina Red Hat EL o una Ubuntu Server. El servicio funciona muy bien en una Raspberry PI, pero porque apenas lo utilizo para dos usuarios y utilizo una cuota de espacio reducida (10 Go). Si también pretendes utilizar una Raspberry PI vete mentalizando en comprarte un disco duro externo.

    Los programas necesarios para instalar el servidor son los siguientes: Python 2.7, Python Setup Tools, Python Imaging y SQLite 3. Estos pueden instalarse con el siguiente comando en las máquinas debianitas (Ubuntus inclusive):

apt-get install python2.7 python-setuptools python-imaging sqlite3

Entra en el directorio /srv y descarga la versión deseada. En este caso voy a descargar la versión estable 4.3.0:
  Debian 64 bits:

wget https://bintray.com/artifact/download/seafile-org/seafile/seafile-server_4.3.0_x86-64.tar.gz

  Debian 32 bits:

wget https://bintray.com/artifact/download/seafile-org/seafile/seafile-server_4.3.0_i386.tar.gz

  Raspberry PI:

https://github.com/haiwen/seafile-rpi/releases/download/v4.3.0/seafile-server_4.3.0_pi.tar.gz

Nota: Si tienes problemas con las URL, puedes conseguir las más actuales desde https://www.seafile.com/en/download.

Creamos los directorios necesarios:

mkdir -p /srv/seafile/installed

Y descomprimimos el tar.gz y lo guardamos en installed:

tar -c /srv/seafile -zxf seafile-server_*.tar.gz
mv seafile-server_*.tar.gz /srv/seafile/installed

 A continuación ejecutamos el instalable:

/srv/seafile/seafile-server-4.3.0/setup-seafile.sh

    El instalable nos preguntará el nombre del servidor y la IP/dominio de éste. Si vas a usarlo únicamente en tu red local, indica sin miedo la dirección IP del servidor donde estás realizando esta instalación. Si por el contrario quieres hacer que el servicio esté también disponible fuera de casa, te recomiendo registrarte en un servicio de dominios dinámicos, como pudiera ser http://freedns.afraid.org, para encargar un subdominio gratuito y utilizarlo para rellenar dicho parámetro de la instalación.

    También se te preguntará por el directorio donde guardar los datos que vas a ir albergando tus bibliotecas (en caso de que vayas a usar una Raspberry PI, sería interesante indicar aquí el directorio de un disco duro externo) y el puerto por donde se atenderán las peticiones (por defecto 8082). Si quires que tu nube sea accesible desde fuera de casa, recuerda mapear una regla en tu router para que el puerto 8082 apunte al 8082 de esta máquina.

Primer arranque.

 Ejecutaremos seafile.sh y después el seahub.sh, en ese orden y ambos con el parámetro start:

/srv/seafile/seafile-server-latest/seafile.sh start
/srv/seafile/seafile-server-latest/seahub.sh start

    En este primer arranque la aplicación nos pedirá que ofrezcamos el correo electrónico del administrador (se utilizan las direcciones de correo como los identificadores de cuenta, es decir, hace falta dar un correo electrónico para poder loguearnos después en la cuenta que estamos creando) y la contraseña que tendrá la cuenta.

Creación del servicio.

    Vamos a añadir el siguiente script, basado en el que hay disponible en el manual de Seafile y en el suministrado por la revista francesa Linux Pratique, pero adaptado a mis necesidades. Este script deberá almacenarse en /etc/init.d/seafile:

### BEGIN INIT INFO
# Provides:             seafile
# Required-Start:       $network
# Required-Stop:        $network
# Default-Start:        2 3 4 5
# Default-Stop:         0 1 6
### END INIT INFO

seafile_dir="/srv/seafile"
scripts_path="${seafile_dir}/seafile-server-latest"
seafile_init_log=${seafile_dir}/logs/seafile.init.log
seahub_init_log=${seafile_dir}/logs/seahub.init.log

case "$1" in
        start|restart)
                ${scripts_path}/seafile.sh $1 >> ${seafile_init_log}
                ${scripts_path}/seahub.sh $1 >> ${seahub_init_log}
        ;;
        stop)
                ${scripts_path}/seahub.sh $1 >> ${seahub_init_log}
                ${scripts_path}/seafile.sh $1 >> ${seafile_init_log}
        ;;
        *)
                echo "Usage: $0 {start|stop|start}"
                exit 1
        ;;
esac

Y a continuación registramos el servicio:

chmod a+x /etc/init.d/seafile
update-rc.d seafile defaults

Y probamos:

service seafile stop
service seafile start

    Al cabo de un minuto podrás acceder a la interfaz web, insertando la dirección IP del servicio y accediendo por el puerto 8000. Ejemplo: http://192.168.0.20:8000

    En esa página web podrás crear todas las cuentas de usuario que creas necesario, crear bibliotecas, gestionarlas a grupos, etcétera.

    Tu nube ya está lista para usarse. Ahora, sólo tienes que instalar uno de los diferentes clientes disponibles para Windows, Linux, Mac OS X, iOS o Android: https://www.seafile.com/en/download.
 

Configurando SSL.

    Si vas a hacer accesible tu nube fuera de casa (es decir, que sea accesible por internet) resulta recomendable configurar Seafile para utilizar el protocolo HTTPS en detrimento del HTTP.

    El primer paso es instalar un servidor apache:

apt-get install apache2

    A continuación necesitamos instalar una serie de programas "privativos". Revisa que en tu /etc/apt/sources.list tenga habilitado los repositorios non-free, contrib y las fuentes (deb-src).

Ejemplo de sources.list de Raspberry PI:

root@Editor /home/sebas # cat /etc/apt/sources.list
deb http://mirrordirector.raspbian.org/raspbian/ wheezy main contrib non-free rpi
deb-src http://mirrordirector.raspbian.org/raspbian/ wheezy main contrib non-free rpi

     Y actualizamos las listas:

apt-get update

   Instalamos el paquete python-flup:

apt-get install python-flup

    Y ejecutamos las siguientes líneas para instalar el paquete libapache-mod-fastcgi:

apt-get update && apt-get -y upgrade
apt-get install postfix ntp ntpdate
apt-get install apache2-mpm-worker php5-fpm php-apc
apt-get install debhelper dpatch libtool cdbs libapr1-dev apache2-threaded-dev
apt-get -b source libapache-mod-fastcgi
dpkg -i libapache2-mod-fastcgi*.deb

    Activamos los siguientes módulos de Apache:

a2enmod rewrite
a2enmod fastcgi
a2enmod proxy_http

    Editamos el fichero de configuración de Apache (apache2.conf) para añadir la siguiente línea al final:

FastCGIExternalServer /var/www/seahub.fcgi -host 127.0.0.1:8000

    Entramos en /srv/seafile/conf y generamos aquí el certificado SSL:

openssl genrsa -out privkey.pem 2048
openssl req -new -x509 -key privkey.pem -out cacert.pem -days 1095

    Se te preguntará una serie de datos. Muy importante: El nombre del host debe de concidir con el dominio (subdominio también) de la máquina. Es decir, no pongas la IP local de tu máquina. Si has reservado por ejemplo el dominio "manolo.com", ese debe de ser el nombre del host en la generación del certificado. Si empleas un subdominio, por ejemplo "cloud.manolo.com", ese deberá de ser el nombre del host. Si no, los navegadores catalogarán tu certificado como "No confiable".

Nota: Tendrás que renovar el certificado cada 1095 días y los navegadores se chivarán de que se trata de un certificado auto firmado.

    A continuación editamos el fichero /etc/apache2/sites-enabled/000-default-ssl con el siguiente contenido:
<IfModule mod_ssl.c>
<VirtualHost *:443>

    ServerName my.domain.com
    DocumentRoot /var/www
    Alias /media  /srv/seafile/seafile-server-latest/seahub/media

    SSLEngine On
    SSLCertificateFile /srv/seafile/conf/cacert.pem
    SSLCertificateKeyFile /srv/seafile/conf/privkey.pem

    RewriteEngine On

   
        Order allow,deny
        Allow from all
   
   
        Order allow,deny
        Allow from all
   

    #
    # seafile fileserver
    #
    ProxyPass /seafhttp http://127.0.0.1:8082
    ProxyPassReverse /seafhttp http://127.0.0.1:8082
    RewriteRule ^/seafhttp - [QSA,L]
    #
    # seahub
    #
    RewriteRule ^/(media.*)$ /$1 [QSA,L,PT]
    RewriteCond %{REQUEST_FILENAME} !-f
    RewriteRule ^(.*)$ /seahub.fcgi$1 [QSA,L,E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
</VirtualHost>
</IfModule>


    Verificamos de nuevo que la configuración de nuestro Apache sea correcta:

a2enmod rewrite ssl actions include

    Y reiniciamos Apache:

service apache2 restart

    A continuación, editaremos el fichero /srv/seafile/ccnet/ccnet.conf y modificaremos el valor de SERVICE_URL para usar el protocolo https. Si vas a poner una regla en tu router, sería recomendable ponerle las cosas difíciles a los hackers, haciendo que el puerto de acceso del HTTPS no sea el 443. Es decir, puedes crear una regla para que el puerto externo 7799 apunte al puerto 443 (el correspondiente al https) de este servidor. De esta forma, deberías de modificar el valor de la variable de la siguiente forma:

SERVICE_URL = https://my.domain.com:7799

Pero si te vas a limitar a usar el puerto 443 por defecto, déjalo de la siguiente forma:

SERVICE_URL = https://my.domain.com

Siguiendo dicho patrón, editamos el  /srv/seafile/seahub_settings.py para editar la linea
FILE_SERVER_ROOT:

FILE_SERVER_ROOT = 'https://my.domain.com:7799/seafhttp'

Y por último editamos el script /etc/init.d/seafile para reemplazar la primera línea "${scripts_path}/seahub.sh $1 >> ${seahub_init_log}" por "${scripts_path}/seahub.sh start-fastcgi >> ${seahub_init_log}" y reiniciamos el servicio:

service seafile stop
service seafile start

 Bibliografía:

• Linux Pratique (Francia), nº91, Septiembre/Octubre 2015. Páginas de la 10 a la 16: "Seafile: Reprenez le contrôle de vos fichiers sur Ubuntu Server et Raspbian" por Sébastien Maccagnoni-Munch.
• "How to install Apache2 + PHP-FPM on Raspberry Pi", de "Raspberry-hosting.com": https://raspberry-hosting.com/en/faq/how-install-apache2-php-fpm-raspberry-pi
• Manual de Seafile: "Config Seahub with Apache". http://manual.seafile.com/deploy/deploy_with_apache.html