arno/etesync-server
1
0
Fork 0
mirror of https://github.com/etesync/server synced 2024-11-29 20:18:07 +00:00
Code Issues Releases Wiki Activity

Update to etebase using Daphne

Simon Vandevelde 2020-09-27 14:48:27 +02:00
parent ce1162ed31
commit 21f372b5be
1 changed files with 63 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

134
Production-setup-using-Daphne-and-Nginx.md

@ -1,70 +1,70 @@
## uWSGI This page details how to create a production setup for the Etebase server.
There exist many ways of doing this, but this guide uses `Daphne` as ASGI and `Nginx` as web server.
It's not a good idea to just run the basic debug server and expose it to the outside world. We do because its not a good idea to just run the basic debug server and expose it to the outside world.
Instead, a component stack should be built. Instead, a component stack should be built.
The [uWSGI docs](https://uwsgi-docs.readthedocs.io/en/latest/tutorials/Django_and_nginx.html) state the following: In this guide, we will create the following stack:
>A web server faces the outside world. It can serve files (HTML, images, CSS, etc) directly from the file system. However, it can’t talk directly to Django applications; it needs something that will run the application, feed it requests from web clients (such as browsers) and return responses. > `the web client <-> Nginx <-> the socket <-> Daphne <-> Django`
>A Web Server Gateway Interface - WSGI - does this job. WSGI is a Python standard.
>uWSGI is a WSGI implementation. In this tutorial we will set up uWSGI so that it creates a Unix socket, and serves responses to the web server via the uwsgi protocol. At the end, our complete stack of components will look like this:
> `the web client <-> the web server <-> the socket <-> uwsgi <-> Django`
Note that different WSGI's exist and can be used, like for example Gunicorn. ## Daphne
However, in this tutorial uWSGI is used.
### Installing uWSGI ### Installing Daphne
Installation of uWSGI is easily done via pip. Installation of Daphne is easily done via pip.
Root needs access to uWSGI later, so install it as superuser. Make sure to install it inside of your virtual environment if you are using one.
``` ```
sudo pip3 install uwsgi $ cd path/to/etebase
$ source venv/bin/activate # In case you haven't activated the venv yet.
$ pip3 install daphne
``` ```
### Testing uWSGI ### Testing Daphne
We can already test whether our uWSGI installation works. We can already test whether our daphne installation works.
``` ```
cd path/to/server-skeleton $ cd path/to/etebase
source venv/bin/activate # In case you haven't activated the venv yet. $ source venv/bin/activate # In case you haven't activated the venv yet.
uwsgi --http :8000 --module etesync_server.wsgi --virtualenv venv $ daphne -b 0.0.0.0 -p 8000 etebase_server.asgi:application
``` ```
This command runs the EteSync module, exposes it on port 8000 and uses the `venv` virtual environment. This command runs the Etebase application and exposes it on port 8000.
You can now surf to the IP address followed by port 8000 in the browser to check if it works (you should see "It works!") On the machine itself, you can now surf to `localhost:8000` to check if it works.
If you're on a different machine than the one running the server, surf to its local IP address followed by the port number, e.g. `192.168.x.x:8000`.
## Nginx ## Nginx
Nginx will form our proper web server. Nginx will be used as our proper web server.
### Installing Nginx ### Installing Nginx
Installation if done via apt. Installation can be done via apt.
``` ```
sudo apt-get install nginx $ sudo apt-get install nginx
``` ```
### Setup Nginx ### Setup Nginx
First of all, create Django's static files so that Nginx can access them. First of all, we create Django's static files so that Nginx can access them.
``` ```
./manage.py collectstatic $ ./manage.py collectstatic
``` ```
Now we need to configure Nginx, using a configuration file. Now we need to configure Nginx, using a configuration file.
Create a new file called `etesync_nginx.conf` and paste the following into it. Create a new file called `etebase_nginx.conf` and paste the following into it.
Don't forget to change `server_name` and the path to `/static`. Don't forget to change `server_name` and the path to `/static`.
``` ```
# mysite_nginx.conf # etebase_nginx.conf
# the upstream component nginx needs to connect to # the upstream component nginx needs to connect to
upstream django { upstream etebase {
# server unix:///tmp/etesync_server.sock; # for a file socket # server unix:///tmp/etebase_server.sock; # for a file socket
server 127.0.0.1:8001; # for a web port socket (we'll use this first) server 127.0.0.1:8001; # for a web port socket (we'll use this first)
} }
@ -80,77 +80,69 @@ server {
client_max_body_size 75M; # adjust to taste client_max_body_size 75M; # adjust to taste
location /static/ { location /static/ {
alias /path/to/server_skeleton/static; # Project's static files alias /path/to/etebase; # Project's static files
} }
# Finally, send all non-media requests to the Django server.
location / { location / {
uwsgi_pass django; proxy_pass http://etebase;
include /etc/nginx/uwsgi_params; # the uwsgi_params file, this path by default
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_redirect off;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Host $server_name;
} }
} }
``` ```
Move this file to `/etc/nginx/sites-available` and symlink it to `/etc/nginx/sites-enabled`. Now we move this file to `/etc/nginx/sites-available` and symlink it to `/etc/nginx/sites-enabled`.
After restarting Nginx and launching uWSGI (on port 8001), you should be able to surf to the same url as before and see "It works!". After restarting Nginx and launching Daphne (on port 8001), you should be able to surf to the same url as before and see "It works!".
``` ```
sudo cp etesync_nginx.conf /etc/nginx/sites-available/ $ sudo cp etebase_nginx.conf /etc/nginx/sites-available/
sudo ln -s /etc/nginx/sites-available/etesync_nginx.conf /etc/nginx/sites-enabled/etesync_nginx.conf $ sudo ln -s /etc/nginx/sites-available/etebase_nginx.conf /etc/nginx/sites-enabled/etebase_nginx.conf
systemctl restart nginx $ systemctl restart nginx
uwsgi --socket :8001 --module etesync_server.wsgi --virtualenv venv $ daphne -b 0.0.0.0 -p 8000 etebase_server.asgi:application
``` ```
If you encounter any errors, the Nginx log is located in `/var/log/nginx/error.log`. If you encounter any errors, the Nginx log is located in `/var/log/nginx/error.log`.
### Finalize Nginx & uWSGI setup ### Finalize Nginx & Daphne setup
For testing purposes, uWSGI exposes the Django application on port 8001. For testing purposes, Daphne exposes the Django application on port 8001.
A more elegant solution would be to expose the application using a file socket. A more elegant solution would be to expose the application using a Unix file socket.
Change `/etc/nginx/sites-available/etesync_nginx.conf` to accept file sockets by commenting in `server unix:///tmp/etesync_server.sock;` and commenting out `server 127.0.0.1:8001;`. Change `/etc/nginx/sites-available/etebase_nginx.conf` to accept file sockets by commenting in `server unix:///tmp/etebase_server.sock;` and commenting out `server 127.0.0.1:8001;`.
The first part should now look like this: The first part should now look like this:
``` ```
# the upstream component nginx needs to connect to # the upstream component nginx needs to connect to
upstream django { upstream etebase {
server unix:///tmp/etesync_server.sock; # for a file socket server unix:///tmp/etebase_server.sock; # for a file socket
# server 127.0.0.1:8001; # for a web port socket (we'll use this first) # server 127.0.0.1:8001; # for a web port socket (we'll use this first)
} }
``` ```
This will create a file socket at `/tmp/etesync_server.sock`. This will create a file socket at `/tmp/etebase_server.sock`.
Now, configure uWSGI to also work using a file socket. Now, we change the way we run Daphne to use the same file socket.
Because a lot of parameters are needed, create a `uwsgi.ini` and copy the following in it.
Don't forget to replace `<user>` by the name of the user for the server.
``` ```
[uwsgi] $ systemctl restart nginx
chdir = /path/to/server-skeleton/ $ daphne -u /tmp/etebase_server.sock etebase_server.asgi:application
socket = /tmp/etesync_server.sock
chown-socket = <user>:www-data
chmod-socket = 660
module = etesync_server.wsgi
master = true
uid = <user>
virtualenv = venv
```
Now to run uWSGI, all you need to do is tell it to use the `.ini` server.
Restart Nginx and check if everything still works.
```
systemctl restart nginx
sudo uwsgi --ini uwsgi.ini # has to be executed as root
``` ```
### That's it! ### That's it!
You now have a working EteSync server over HTTP. You now have a working Etebase server over HTTP.
Don't forget to change `allowed_hosts` to your domain name in `etesync-server.ini` and to set `server_name` to your domain name in `/etc/nginx/sites-available/etesync_nginx.conf`. Don't forget to change `allowed_hosts` to your domain name in `etebase-server.ini` and to set `server_name` to your domain name in `/etc/nginx/sites-available/etebase_nginx.conf`.
An optional next step is to have your uWSGI run automatically at boot. More explanation can be found here: [Run uWSGI at boot](https://github.com/etesync/server/wiki/Run-uWSGI-at-boot) An optional next step is to have your Daphne run automatically at boot. More explanation can be found here: [Run Daphne at boot](https://github.com/etesync/server/wiki/Run-Daphne-at-boot)
It is also *highly* recommended **to enable SSL for your EteSync server!** It is also *highly* recommended **to enable SSL for your Etebase server!**
A page detailing SSL setup can be found here: [Setup HTTPS for EteSync](https://github.com/etesync/server/wiki/Setup-HTTPS-for-EteSync) A page detailing SSL setup can be found here: [Setup HTTPS for Etebase](https://github.com/etesync/server/wiki/Setup-HTTPS-for-Etebase)