Skonfiguruj Firefox Sync Server na Debian 9 lub Ubuntu 16.04

• Wymagania wstępne
• Zainstaluj niezbędne pakiety
• Budowanie serwera
• Konfiguracja serwera synchronizacji
• Uruchamianie serwera synchronizacji
• Konfiguracja serwera WWW
• Skonfiguruj klienta (Firefox)

Firefox Sync to funkcja synchronizacji przeglądarki, która umożliwia udostępnianie danych i preferencji (takich jak zakładki, historia, hasła, otwarte karty i zainstalowane dodatki) na wszystkich urządzeniach. Mozilla oferuje również aplikację „serwera synchronizacji” do użytku z Firefox Sync dla użytkowników i firm, które wolą hostować własne dane synchronizacji. W tym artykule pokazano, jak skonfigurować serwer Mozilla Sync.

Wymagania wstępne

• Nowo wdrożona instancja serwera Vultr Debian 8, Debian 9 lub Ubuntu 16.04.
• Użytkownik sudo .

Zainstaluj niezbędne pakiety

Zaktualizuj system:

sudo apt-get update
sudo apt-get upgrade
sudo apt-get dist-upgrade

Aby zbudować i uruchomić Serwer synchronizacji, musisz zainstalować następujące pakiety:

• python-dev
• git
• build-essential (Kompilator C ++, kompilator GCC, make i inne wymagane narzędzia).
• sqlite3(jeśli chcesz użyć bazy danych MySQL zamiast SQLite, możesz wymienić sqlite3pakiet na mariadb-serverlub mysql-server).
• nginx(serwer WWW. Od Ciebie zależy, z którego serwera chcesz korzystać apache2lub nginx).

Zainstaluj pakiety:

sudo apt-get install -y git git-core python-dev python-virtualenv build-essential sqlite3 nginx

Budowanie serwera

Sklonujemy repozytorium Git serwera synchronizacji, wpisując następujące polecenie, a następnie wchodząc do folderu:

git clone https://github.com/mozilla-services/syncserver
cd syncserver

Uruchom komendę build, która pobierze zależności i skompiluje kod.

make build

Konfiguracja serwera synchronizacji

Konfiguracja serwera synchronizacji jest bardzo prosta, w pliku konfiguracyjnym ( ./syncserver.ini) można zmienić tylko kilka parametrów .

Otwórz plik konfiguracyjny w swoim ulubionym edytorze tekstu (na przykład nano ./syncserver.ini).

[server:main]
use = egg:gunicorn
host = 0.0.0.0
port = 5000
workers = 1
timeout = 30

[app:main]
use = egg:syncserver

[syncserver]
# This must be edited to point to the public URL of your server,
# i.e. the URL as seen by Firefox.
public_url = http://localhost:5000/

# This defines the database in which to store all server data.
#sqluri = sqlite:////tmp/syncserver.db

# This is a secret key used for signing authentication tokens.
# It should be long and randomly-generated.
# The following command will give a suitable value on *nix systems:
#
#    head -c 20 /dev/urandom | sha1sum
#
# If not specified then the server will generate a temporary one at startup.
#secret = INSERT_SECRET_KEY_HERE

# Set this to "false" to disable new-user signups on the server.
# Only request by existing accounts will be honoured.
# allow_new_users = false

# Set this to "true" to work around a mismatch between public_url and
# the application URL as seen by python, which can happen in certain reverse-
# proxy hosting setups.  It will overwrite the WSGI environ dict with the
# details from public_url.  This could have security implications if e.g.
# you tell the app that it's on HTTPS but it's really on HTTP, so it should
# only be used as a last resort and after careful checking of server config.
force_wsgi_environ = false

[browserid]
# Uncomment and edit the following to use a local BrowserID verifier
# rather than posting assertions to the mozilla-hosted verifier.
# Audiences should be set to your public_url without a trailing slash.
#backend = tokenserver.verifiers.LocalVerifier
#audiences = https://localhost:5000

# By default, syncserver will accept identity assertions issues by
# any server. You can restrict this by setting the below to a list
# of allowed issuer domains.
#allowed_issuers = www.mysite.com myfriendsdomain.org

Adres twojego serwera musi być określony za pomocą parametru public_url:

public_url = http://fsync.example.com

Uwaga : domyślna wartość public_url„http: // localhost: 5000 /” będzie działać do celów testowych na komputerze lokalnym.

W sqluriopcji usuniemy komentarz i umieścimy lokalizację lub URIpozwoli to serwerowi połączyć się z bazą danych i przechowywać informacje:

sqluri = sqlite:////path/to/database/file.db

Jeśli chcesz użyć innego typu DB:

sqluri = pymysql://username:[email protected]/sync

Dla secretparametru „ ” będziemy musieli wygenerować tajny klucz dla tokenów uwierzytelniających:

head -c 20 /dev/urandom | sha1sum

Usuń komentarz z wiersza tajnego parametru, a następnie skopiuj / wklej zwrócony ciąg do tajnego parametru:

secret = db8a203aed5fe3e4594d4b75990acb76242efd35

Uwaga : Jeśli nie wprowadzisz niczego w tym parametrze, serwer wygeneruje jeden, ale będzie różny przy każdym ponownym uruchomieniu serwera.

W przypadku allow\_new\_usersparametru „ ” usuń komentarz i ustaw go tak, trueaby nasze konto mogło połączyć się z naszym serwerem po raz pierwszy:

allow_new_users = true

Następnie zmodyfikujemy audiencesparametr „ ” i wstawimy to samo, co public_uriparametr „ ”, nie zapominając o odkomentowaniu wiersza:

audiences = http://fsync.example.com

Na koniec po prostu dodaj następujący wiersz na końcu pliku:

forwarded_allow_ips = *

Ta linia pomoże ci uniknąć komunikatów o błędach i problemów z autoryzacją.

Uruchamianie serwera synchronizacji

Aby uruchomić serwer synchronizacji, możesz uruchomić następujące polecenie:

./path/to/syncserver/local/bin/gunicorn --threads 4 --paste /path/to/syncserver/syncserver.ini &

... albo ten:

make serve &

Pierwsza opcja pozwala wybrać lokalizację pliku konfiguracyjnego; a także umieścić argument --threads 4, który pozwala przypisać większą moc do serwera synchronizacji.

Aby uruchomić serwer przy każdym uruchomieniu instancji, możesz dodać następujący wiersz do swojego crontab, wpisując crontab -epolecenie:

@reboot ./path/to/syncserver/local/bin/gunicorn --paste /path/to/syncserver/syncserver.ini &

Konfiguracja serwera WWW

Możesz używać różnych serwerów internetowych, które są zgodne z WSGIprotokołem. Na przykład:

• Nginx z uWSGI.
• Apache w połączeniu z mod_wsgi.

Nginx

W przypadku Nginx musisz użyć wbudowanego serwera proxy Nginx, jak pokazano poniżej:

server {
        listen  80;
        server_name fsync.example.com;

        location / {
                proxy_set_header Host $http_host;
                proxy_set_header X-Forwarded-Proto $scheme;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header X-Real-IP $remote_addr;
                proxy_redirect off;
                proxy_read_timeout 120;
                proxy_connect_timeout 10;
                proxy_pass http://127.0.0.1:5000/;
        }
}

Nginx + uWSGI

Użytkownicy Nginx mogą korzystać tylko z gniazda WSGI.

Zainstaluj uWSGIprzez Pip:

pip install uwsgi

Zainstaluj, uWSGIpobierając źródłowy plik archiwum:

wget https://projects.unbit.it/downloads/uwsgi-latest.tar.gz
tar zxvf uwsgi-latest.tar.gz
cd <dir>
make

Uwaga : po kompilacji będziesz mieć plik uwsgibinarny w bieżącym katalogu.

Po zainstalowaniu uruchom go z następującymi opcjami:

uwsgi --plugins python27 --manage-script-name \
--mount /<location>=/path/to/syncserver/syncserver.wsgi \
--socket /path/to/uwsgi.sock

Następnie użyj następującej konfiguracji Nginx:

location /<location>/ {
  include uwsgi_params;
  uwsgi_pass unix:/path/to/uwsgi.sock;
}

Apacz

Zainstaluj mod_wsgi:

apt-get install libapache2-mod-wsgi

Następnie użyj następującego vhosta:

<VirtualHost *:80>
  ServerName sync.example.com
  DocumentRoot /path/to/syncserver
  WSGIProcessGroup sync
  WSGIDaemonProcess sync user=sync group=sync processes=2 threads=25 python-path=/path/to/syncserver/local/lib/python2.7/site-packages/
  WSGIPassAuthorization On
  WSGIScriptAlias / /path/to/syncserver/syncserver.wsgi
  CustomLog /var/log/apache2/sync.example.com-access.log combined
  ErrorLog  /var/log/apache2/sync.example.com-error.log
</VirtualHost>

Skonfiguruj klienta (Firefox)

Po zainstalowaniu i skonfigurowaniu serwera należy skonfigurować klienta Firefox na komputery stacjonarne, aby mógł rozmawiać z nowym serwerem synchronizacji. Zanim zaczniesz, jeśli masz już połączenie z serwerami Firefox Sync, musisz się wylogować. W przeciwnym razie połączenie z nowym serwerem może nie działać.

Najpierw otwórz nową kartę i wprowadź następujący adres:

about:config

W pasku wyszukiwania wprowadź identity.sync.tokenserver.urii zmień jego wartość na adres URL swojego serwera za pomocą ścieżki token/1.0/sync/1.5:

http://sync.example.com/token/1.0/sync/1.5