KernelCoffee

Another sip of code ?

Auto-Herbergement : Mozilla Sync Server Avec Nginx Et Gunicorn Sur Centos

| Comments

Mozilla Sync : Qu’est ce que c’est ?

Le service Sync de Mozilla permet de synchroniser et sauvegarder l’ensemble des favoris, cookies, onglets… de Firefox sur un serveur distant.

Qu’est ce que cela signifie ?

Et bien cela signifie qu’en cas de perte de données/crash/vol de l’ordi les données ne sont pas perdu mais sauvegardé a distance. Un des avantages de cette technologie est qu’il est possible de synchroniser plusieurs machines avec un même compte, comme par exemple : un ordinateur chez soi, un ordinateur portable et celui du bureau.

Objectif

Le but de ce tutoriel est d’installer un service Sync sur un serveur personnel. Ce service est hébergé derrière un serveur web Nginx et utilisera MySql et Gunicorn.

Installation

J’assume que si vous êtes ici, c’est que vous savez vous débrouiller avec un terminal et que votre serveur est déjà configuré avec :

  • MySql-server
  • Nginx ( + certificat ssl)

Mozilla a publie les instructions pour Nginx dans sa documentation, mais je la trouve incomplète et est faite pour un serveur sous Debian.
Ce qui suis est donc plus ou moins une version sous CentOS avec plus de details sur comment lancer le service avec gunicorn et nginx.

Avant de commencer la procédure nous avons besoin :

  • D’un serveur personnel sous CentOS (réalisé sous CentOS 6.x).
  • python-devel
  • mercurial
  • mysql
  • python-virtualenv On peut installer le tout avec la commande suivante
1
$ sudo yum install python-devel mercurial sqlite python-virtualenv mysql-devel

Par habitude je fais toujours tourner chaque service avec un utilisateur différent.

1
$ sudo adduser mozilla

Puis on se connecte a ce compte via la commande “su”.

1
$ sudo su mozilla

N’oublier pas de revenir dans le dossier de l’utilisateur mozilla via la commande “cd”.
L’ensemble des instructions suivante sont réalisées en tant qu’utilisateur mozilla.

On récupéré la dernière version de Sync server et on la compile

1
2
3
4
mozilla$ cd ~
mozilla$ hg clone https://hg.mozilla.org/services/server-full
mozilla$ cd server-full
mozilla$ make build

On en profite pour installer mysql et gunicorn via easy_install fourni avec le serveur sync

1
2
3
mozilla$ cd ~/server-full
mozilla$ bin/easy_install Mysql-Python
mozilla$ bin/easy_install gunicorn

Configuration

Maintenant que Sync est installé, configurons le pour qu’il soit pleinement exploitable.

Commençons par créer la base mysql et son utilisateur. Personnellement j’utilise ce script les créer :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#!/bin/sh

DB_NAME=<database_name>
DB_USER=$DB_NAME
DB_PASSWORD=<password>

echo "
CREATE DATABASE '$DB_NAME';
CREATE USER '$DB_USER'@'localhost' IDENTIFIED BY '$DB_PASSWORD';
GRANT ALL PRIVILEGES ON $DB_NAME.* TO '$DB_USER'@'localhost' WITH GRANT OPTION;
" > request.sql

mysql -u root -p < request.sql

rm request.sql

n’oubliez pas de personnaliser DB_NAME, DB_USER et DB_PASSWORD.

Ensuite dans le fichier server-full/developpement.ini modifiez :

1
2
3
4
5
6
[server:main]
use = egg:Gunicorn #modification pour dire a Sync qu'on utilise Gunicorn
host = 0.0.0.0
port = 5000
use_threadpool = True
threadpool_workers = 60

Ensuite dans le fichier server-full/etc/sync.conf modifiez les blocks :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[storage]
backend = syncstorage.storage.sql.SQLStorage
sqluri = mysql://<user>:<password>@localhost/<database> #modification pour utiliser MySql
standard_collections = false
use_quota = true
quota_size = 51200 #augmentation du quota a 50Mo au lieu de 5Mo
pool_size = 100
pool_recycle = 3600
reset_on_return = true
display_config = true
create_tables = true

[auth]
backend = services.user.sql.SQLUser
sqluri = mysql://<user>:<password>@localhost/<database> #mofication pour utiliser Mysql
pool_size = 100
pool_recycle = 3600
create_tables = true
# Uncomment the next line to disable creation of new user accounts.
#allow_new_users = false

[nodes]
fallback_node = https://www.yourserver.net #modification 

Gunicorn et Nginx

Mon fichier de configuration Nginx pour Sync

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
server {
    listen      80;
    server_name sync.kernelcoffee.org;
    rewrite     ^   https://$server_name$request_uri? permanent;
}

server {
    listen  443 ssl;
    server_name sync.kernelcoffee.org;

    ssl_certificate /etc/ssl/certs/ssl.crt;
    ssl_certificate_key /etc/ssl/certs/ssl.key;

    location / {
        proxy_pass_header Server;
        proxy_set_header Host $http_host;
        proxy_redirect off;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Scheme $scheme;
        proxy_connect_timeout 10;
        proxy_read_timeout 10;
        proxy_pass http://localhost:5000/;
    }
}

Nginx va recevoir les requêtes http(s), rediriger si besoin en https et assurer la communication avec Gunicorn en interne.
C’est Gunicorn qui va faire tourner le service Sync, Nginx assure la passerelle avec l’extérieur.

Fichier init

In progress
il me reste a stopper proprement le service / This script doesn’t stop the service gracefully yet.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
#!/bin/bash
# /etc/init.d/sync
# version 0.1 2013-03-12 (YYYY-MM-DD)

### BEGIN INIT INFO
# Provides:   sync
# Required-Start: $local_fs $remote_fs
# Required-Stop:  $local_fs $remote_fs
# Should-Start:   $network
# Should-Stop:    $network
# Default-Start:  2 3 4 5
# Default-Stop:   0 1 6
# Short-Description:    Mozilla Sync server
# Description:    Starts the mozilla sync server
### END INIT INFO

# Source function library.
. /etc/rc.d/init.d/functions

prog=sync
SYNC_USER=mozilla
SYNC_HOME=/home/mozilla/server-full
CPU_COUNT=2
pidfile=/var/run/mozilla/sync.pid
lockfile=/var/run/mozilla/sync.lock
conffile=${SYNC_HOME}/development.ini
GUNICORN=${SYNC_HOME}/bin/gunicorn_paster
GUNICORN_ARGS="--daemon --pid $pidfile --workers $CPU_COUNT"
INVOCATION="$GUNICORN $GUNICORN_ARGS $conffile"

start () {
    echo -n "Starting $prog"
    daemon --user ${SYNC_USER} --pidfile  ${pidfile} $INVOCATION
    RETVAL=$?
    echo
    [ $RETVAL = 0 ] && touch ${lockfile}
    return $RETVAL
}

stop() {
    echo "Stopping $prog"
    killproc -p ${PIDFILE} ${prog}
    RETVAL=$?
    echo
    [ RETVAL = 0 ] && rm -f ${lockfile} ${pidfile}
}

case "$1" in
    start)
        start
        ;;
    stop)
        stop
        ;;
    restart)
        stop
        start
        ;;
    *)
        echo $"Usage: $prog {start|stop|restart|help}"
        RETVAL=2
esac

exit $RETVAL

Pour utiliser ce script il faut également créer le dossier /var/run/mozilla ou seront stocker le fichier pid et lock

1
2
$ sudo mkdir /var/run/mozilla
$ sudo chown mozilla:mozilla /var/run/mozilla

on peut également lancer le service via la commande :

1
$ server-full/bin/gunicorn_paster server-full/development.ini

Maintenant que tout est en place, démarrons le serveur et assurons nous qu’il se lance au démarrage de la machine.

1
2
$ /etc/init.d/sync start
$ chkconfig sync on

NOTICE

Si comme moi vous utilisez des certificat SSL auto-généré, pensez a aller une 1ère fois sur l’adresse de votre serveur Sync afin de les accepter sinon Firefox refusera de s’y synchroniser.


Source: Mozilla Documentation run-sync howto and nginx

Comments