Seafile Banana PI – un home cloud personale

banana pi seafile home cloud

Introduzione a Seafile su Banana PI

Per chi non conoscesse questa board, il Banana PI è una piastra stile Raspberry ma più performante: dual core, un giga di ram, attacco sata per l’hard disk e scheda ethernet 10/100/1000. Se ne aveste bisogno, ho scritto varie guide su come installare e configurare il sistema operativo. In questa guida prendo in considerazione il s.o. bananian basato su debian.

Seafile è un ottimo progetto con una efficiente comunità di supporto, un software multipiattaforma che useremo per creare un home cloud personale in stile dropbox, ma con tutti i vantaggi di un server casalingo (soprattutto il fatto che i dati sono su un database in vostro possesso e non affidati a terzi). Seafile è disponibile nella versione free e pro con alcune differenze. In questa guida ci occupiamo della versione free che ha ottime funzionalità. È possibile effettuare in seguito l’upgrade alla versione pro in caso fosse necessario. Per le differenze, vi invito a leggere la loro documentazione. È possibile registrare anche diversi utenti, condividere le librerie e quant’altro, come con dropbox e simili.

Utilizzando il Banana come server per seafile potremo quindi sincronizzare tutti i dispositivi desiderati, indipendentemente dal sistema operativo, e avere così i nostri documenti e le foto a portata di mano.

Premessa:

È importante iniziare con un sistema aggiornato e funzionante, registrare un dominio (che sia a pagamento o uno gratuito, cambia poco) e ottenere un certificato ssl (nella guida spiegheremo come ottenerne uno gratuito) per avere connessioni criptate (tramite l’uso di nginx configurato come reverse proxy) a prova di attacchi indesiderati.

Bisognerà disporre di un hard disk collegato in USB o in sata per contenere una grande quantità di dati, che difficilmente riusciranno a stare nella scheda sd del BPI. Io consiglio un collegamento tramite sata che è sicuramente più veloce, soprattutto in caso di un disco SSD. È disponibile una guida per montare direttamente il sistema operativo sul disco sata, per aumentare la velocità del sistema e prevenire l’usura della schedina sd.

Ovviamente dovremo avere accesso all’interfaccia di configurazione del router per aprire le porte necessarie e settare il DDNS (ove fosse necessario).

Siccome nelle proprie abitazioni raramente si dispone di un ip pubblico statico, in questa guida prendiamo in considerazione il caso di un ip pubblico dinamico.

Registrazione di un Dynamic DNS

Se il nostro ISP ci ha fornito di un ip pubblico dinamico, l’unico modo di instradare correttamente il nome dominio sul proprio indirizzo ip è quello di registrarsi su un sito di DDNS (ovvero un sito che aggiornerà automaticamente il puntamento del proprio dominio, al cambiare dell’ indirizzo ip). In questa guida utilizzerò Dynu.com, che fornisce sia un servizio di Dynamic DNS, sia la registrazione di un nome di dominio gratuito (esempio.dynu.com). Senza soffermarmi troppo sulla questione, la scelta del servizio ricade soprattutto sulla compatibilità che il servizio di DDNS ha con il mio router: è infatti sul router che si andrà a settare la configurazione necessaria per avere un aggiornamento automatico dell’indirizzo ip pubblico. È possibile installare un client anche su qualsiasi dispositivo connesso che effettuerà il push di aggiornamento dell’ip.  Ci sono tantissimi altri siti che offrono servizi DDNS, basta googlare.

Una volta registrato il proprio dominio (in questa guida userò un dominio fittizio: esempio.dynu.com) e configurato il DDNS per l’aggiornamento automatico dell’ip, possiamo iniziare a configurare il banana pi.

Installazione e configurazione Seafile

Effettuate il login tramite ssh e aggiornate il sistema:

apt-get update

apt-get upgrade

installiamo i pacchetti necessari:

apt-get install python2.7 python-setuptools python-simplejson python-imaging sqlite3 python python-flup python-urllib3 gcc make sudo bzip2 nginx

 

Aggiungiamo l’utente seafile (con login disattivata) che comanderà il demone:

adduser seafile --disabled-login

Diventiamo l’utente seafile:

su seafile

Scarichiamo il tar contenente la versione più recente, nel mio caso, la stable 6.0.5 (controllare le ultime versioni qui):

wget https://github.com/haiwen/seafile-rpi/releases/download/v6.0.5/seafile-server_6.0.5_stable_pi.tar.gz

tar xfv seafile*

cd seafile-server-*

Ora installiamo seafile con il comando

./setup-seafile.sh

Ci verrà chiesto il nome del server (a piacimento), il dominio (usate il vostro o quello di dynu) e le porte utilizzate (potete lasciare quelle di default, se non già utilizzate per altri servizi). Inoltre dovrete selezionare la directory nella quale verrà salvato il database (è importante che sia sull’hard disk). Infine email e password dell’amministratore.

Ora si può attivare il servizio:

./seafile.sh start

./seahub.sh start 8000

Apriamo le porte 8000 e 8082 sul router (indirizzandole verso l’ip interno del banana pi) e proviamo ad accedere via web all’indirizzo ip del banana per vedere se riusciamo a raggiungerlo.

NB: Per risolvere il nome di dominio pubblico anche all’interno della rete e poter così accedere al server sia dall’interno che dall’esterno, sarà necessario instradare correttamente le richieste al dns, modificando il file hosts dei client o del router (che fa da dns). Questo passaggio è sottile, ma fondamentale se volete utilizzare il server sia all’interno che all’esterno della rete domestica (ad esempio con il cellulare). Se aveste problemi, googlate.

Una volta testato il servizio via web possiamo configurare il reverse proxy e le chiavi SSL (prima ne generiamo di autosegnate, in seguito in caso di successo, richiederemo delle chiavi autenticate).

Configurazione SSL e nginx reverse proxy

Cambiamo alcuni parametri:

nano /home/seafile/conf/ccnet.conf

modificare così:

SERVICE_URL = https://DOMAIN:8001

e salvare.

nano /home/seafile/conf/seahub_settings.py

aggiungere

FILE_SERVER_ROOT = 'https://DOMAIN:8001/seafhttp'

e stoppare seahub:

/home/seafile/seafile-server-latest/seahub.sh stop

e riavviarlo con l’estensione fastcgi (sulla porta 8001 che farà da proxy):

/home/seafile/seafile-server-latest/seahub.sh start-fastcgi

Per tornare root digitate:

exit

Creiamo il certificato autosegnato e le chiavi da passare al proxy:

mkdir /etc/nginx/ssl

cd /etc/nginx/ssl

openssl genrsa -out seahub.key 4096

openssl req -new -sha512 -key seahub.key -out seahub.csr

openssl x509 -req -sha512 -days 3650 -in seahub.csr -signkey seahub.key -out seahub.crt

Configuriamo il nginx per utilizzare le chiavi autosegnate:

nano /etc/nginx/sites-available/seahub

e inserire quanto segue:

server {
listen 8001; # <----------------------------------- PORTA DI NGINX
ssl on; # <---------------------------------------- SSL
ssl_certificate /etc/nginx/ssl/seahub.crt; # <----- SSL
ssl_certificate_key /etc/nginx/ssl/seahub.key; # <- SSL
server_name esempio.dynu.com.tld; # <- ***INSERIRE IL PROPRIO DOMINIO***
error_page 497 https://$host:$server_port$request_uri;

location / {
fastcgi_pass 127.0.0.1:8000;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param PATH_INFO $fastcgi_script_name;

fastcgi_param SERVER_PROTOCOL $server_protocol;
fastcgi_param QUERY_STRING $query_string;
fastcgi_param REQUEST_METHOD $request_method;
fastcgi_param CONTENT_TYPE $content_type;
fastcgi_param CONTENT_LENGTH $content_length;
fastcgi_param SERVER_ADDR $server_addr;
fastcgi_param SERVER_PORT $server_port;
fastcgi_param SERVER_NAME $server_name;
fastcgi_param HTTPS on;
fastcgi_param HTTP_SCHEME https;

access_log /var/log/nginx/seahub.access.log;
error_log /var/log/nginx/seahub.error.log;
}
location /seafhttp {
rewrite ^/seafhttp(.*)$ $1 break;
proxy_pass http://127.0.0.1:8082;
client_max_body_size 0;
}

location '/.well-known/acme-challenge' {
default_type "text/plain";
root /media/amule/seafile/certbot-webroot;
}

# # include /etc/nginx/mime.types; # <- DECOMMENTARE IN CASO DI CSS NON CARICATO CORRETTAMENTE
# }
}

 

Attiviamo il proxy, linkandolo tra gli autorizzati:

ln -s /etc/nginx/sites-available/seahub /etc/nginx/sites-enabled/seahub

e riavviamo nginx

/etc/init.d/nginx restart

Se nginx non è configurato correttamente verrà un segnale di errore. In questo caso ricontrollate il file sopra modificato alla ricerca di errori, o controllate conflitti con altri webserver presenti sul vostro server (per esempio, porte già utilizzate, eccetera).

Avvio automatico di seafile al riavvio del sistema.

Nel caso il server venisse riavviato, dobbiamo creare un file per l’avvio automatico del demone di seafile al riavvio del sistema:

nano /etc/init.d/seafile-server

e inseriamo lo script:

#!/bin/sh
### BEGIN INIT INFO
# Provides:          seafile-server
# Required-Start:    $local_fs $remote_fs $network
# Required-Stop:     $local_fs
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Starts Seafile Server
# Description:       starts Seafile Server
### END INIT INFO

# Passen Sie den Wert von "user" entsprechend Ihrer Systemvorgaben an
user=seafile

# Passen Sie den Wert von "script_path" an den Pfad Ihrer Seafile Installation an
seafile_dir=/home/seafile
script_path=${seafile_dir}/seafile-server-latest
seafile_init_log=${seafile_dir}/logs/seafile.init.log
seahub_init_log=${seafile_dir}/logs/seahub.init.log

fastcgi=true

case "$1" in
start)
sudo -u ${user} ${script_path}/seafile.sh start >> ${seafile_init_log}
if [  $fastcgi = true ];
then
sudo -u ${user} ${script_path}/seahub.sh start-fastcgi ${fastcgi_port} >> ${seahub_init_log}
else
sudo -u ${user} ${script_path}/seahub.sh start >> ${seahub_init_log}
fi
;;
restart)
sudo -u ${user} ${script_path}/seafile.sh restart >> ${seafile_init_log}
if [  $fastcgi = true ];
then
sudo -u ${user} ${script_path}/seahub.sh restart-fastcgi ${fastcgi_port} >> ${seahub_init_log}
else
sudo -u ${user} ${script_path}/seahub.sh restart >> ${seahub_init_log}
fi
;;
stop)
sudo -u ${user} ${script_path}/seafile.sh $1 >> ${seafile_init_log}
sudo -u ${user} ${script_path}/seahub.sh $1 >> ${seahub_init_log}
;;
*)
echo "Usage: /etc/init.d/seafile {start|stop|restart}"
exit 1
;;
esac

 

diamo permessi di esecuzione al file:

chmod +x /etc/init.d/seafile-server

e infine aggiorniamo:

update-rc.d seafile-server defaults

Lo script attiva anche i comandi del demone da terminale:

/etc/init.d/seafile {start|stop|restart}

Non dimenticatevi che dovete cambiare la porta aperta sul router dalla 8000 alla 8001 avendo inserito un proxy per cifrare le connessioni.

Se tutto è a posto potete installare configurare i vari client accedendo al server:

https://esempio.dynu.com:8001

NB: Alcuni client hanno problemi di sincronizzazione dei file, anche se viene correttamente utilizzato il client web. In tal caso, accedere alle impostazioni di seafile client, tab avanzato e spuntare “Do not verify server certificate in HTTPS syncing”. Il problema probabilmente è dato dal fatto che il server possiede un certificato autosegnato. Se volete le cose fatte bene, continuate a seguire la guida.

Ottenere un certificato SSL valido con letsencrypt

Let’s Encrypt è una società che fornisce certificati validi e autentici, con l’unica limitazione che scadono ogni tre mesi. Tuttavia è possibile utilizzare una funzione di rinnovo automatico per continuare ad usufruire della firma.

In questo paragrafo andremo a sostituire il certificato autosegnato precedentemente installato con uno autentico fornito da letsencrypt.

(Sto ancora scrivendo i passaggi per questa procedura, ndr)

Conclusione

Seafile Banana PI, un’ottima soluzione.

Non tratterò l’installazione e la configurazione dei client, in quanto sono abbastanza semplici e intuitivi.

Alla prossima guida.

TD.

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.

*