Development and Deployment of Django on Fedora

Development

Install cookiecutter globally and then generate a bootstrapped Django project:

$ pip install cookiecutter==1.4.0
$ cookiecutter https://github.com/pydanny/cookiecutter-django.git

This command runs cookiecutter with the cookiecutter-django repo, allowing us to enter project-specific details. (We named the project and the repo django_cookiecutter_fedora.)

NOTE: Check out the Local Setup section from the previous post for more information on this command as well as the generated project structure.

Before we can start our Django Project, we are still left with few steps…

$ create database django_cookiecutter_fedora;
CREATE DATABASE

$ cd django_cookiecutter_fedora
$ pyvenv-3.5 .venv
$ source .venv/bin/activate
$ ./utility/install_python_dependencies.sh

Sanity Check

Apply the migrations and then run the local development server:

$ python manage.py makemigrations
$ python manage.py migrate
$ python manage.py runserver

Ensure all is well by navigating to http://localhost:8000/ in your browser to view the Project quick start page:

Once done, kill the development server, initialize a new Git repo, commit, and git push to Github.

Deployment

With the Project setup and running locally, we can now move on to deployment where we will utilize the following tools:

• Fedora 24
• Postgres
• Nginx
• gunicorn

$ ssh root@SERVER_IP_ADDRESS
# dnf upgrade

# adduser <name-of-user>
# passwd <name-of-user>
Changing password for user <name-of-user>.
New password:
Retype new password:
passwd: all authentication tokens updated successfully.

# usermod <name-of-user> -a -G wheel

$ sudo su
# dnf install postgresql-server postgresql-contrib postgresql-devel
# dnf install python3-devel python-devel gcc nginx git

# sudo postgresql-setup initdb
# sudo systemctl start postgresql

# sudo su - postgres
$ psql
postgres=#

postgres=# CREATE USER <user-name> WITH PASSWORD '<password-for-user>';
CREATE ROLE
postgres=# CREATE DATABASE django_cookiecutter_fedora;
CREATE DATABASE
postgres=# GRANT ALL ON DATABASE django_cookiecutter_fedora TO <user-name>;
GRANT

postgres=# \q
$ exit

# sudo systemctl enable postgresql
# sudo systemctl restart postgresql

# sudo git clone <github-repo-url> /opt/<name of the repo>

# cd /opt/django_cookiecutter_fedora/
# sudo pip3 install virtualenv
# sudo pyvenv-3.5 .venv

$ sudo su
# source .venv/bin/activate

# dnf install libtiff-devel libjpeg-devel libzip-devel freetype-devel
# dnf install lcms2-devel libwebp-devel tcl-devel tk-devel

# dnf install redhat-rpm-config

# ./utility/install_python_dependencies.sh

Sanity Check (take 2)

Apply all the migrations:

$ python manage.py makemigrations
$ python manage.py migrate

Now run the server:

$ python manage.py runserver 0.0.0.0:8000

To ensure things are working fine, just visit the server’s IP address in your browser - e.g., :8000. Kill the server when done.

Gunicorn Setup

Before setting up Gunicorn, we need to make some changes to the production settings, in the /config/settings/production.py module. Take a look at the production settings here, which are the minimal settings needed for deploying our Django Project to a production server.

To update these, open the file in VI:

$ sudo vi config/settings/production.py

First, select all and delete:

:%d

And then copy the new settings and paste them into the now empty file by entering INSERT mode and then pasting. Make sure to update the ALLOWED_HOSTS variable as well (very, very important!) with your server’s IP address or hostname. Exit INSERT mode and then save and exit:

:wq

Once done, we need to add some environment variables to the .bashrc file, since the majority of the config settings come from environment variables within the production.py file.

Again, use VI to edit this file:

$ vi ~/.bashrc

Enter INSERT mode and add the following:

# Environment Variables
export DJANGO_SETTINGS_MODULE='config.settings.production'
export DJANGO_SECRET_KEY='CHANGEME!!!m_-0ujru4yw4@!u7048_(#1a*y_g2v3r'
export DATABASE_URL='postgres:///django_cookiecutter_fedora'

Two things to note:

1. Notice how we updated the DJANGO_SETTINGS_MODULE variable to use the production settings.
2. It’s a good practice to change your DJANGO_SECRET_KEY to a more complex string. Do this now if you want.

Again, exit INSERT mode, and then save and exit VI.

Now just reload the .bashrc file:

$ source ~/.bashrc

Ready to test?! Inside the root directory, with the virtualenv activated, execute the gunicorn server:

$ gunicorn --bind <ip-address or hostname>:8000 config.wsgi:application

This will make our web application, again, serve on :8000.

Keep in mind that as soon as we log out of our server this command will stop and hence we would no longer be able to serve our web app. So, we have to make our gunicorn server execute as a service so that it can be started, stopped, and monitored.

Nginx Config

Follow these steps for adding a configuration file for making our Django Project serve via Nginx:

$ cd /etc/nginx/conf.d
$ sudo vi django_cookiecutter_fedora.conf

Add the following, making sure to update the server, server_name, and location:

upstream app_server {
    server 127.0.0.1:8001 fail_timeout=0;
}

server {
    listen 80;
    server_name <remote-server-ip>;
    access_log /var/log/nginx/django_project-access.log;
    error_log /var/log/nginx/django_project-error.log info;

    keepalive_timeout 5;

    # path for staticfiles
    location /static {
            autoindex on;
            alias /opt/django_cookiecutter_fedora/staticfiles/;
    }

    location / {
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $http_host;
        proxy_redirect off;

        if (!-f $request_filename) {
            proxy_pass http://app_server;
            break;
        }
    }
}

Save and exit VI, and then restart the Nginx server:

$ sudo systemctl restart nginx.service

That’s it!

Gunicorn Start Script

Now let’s create a Gunicorn start script which will run as an executable, making our bootstrapped Django web application run via the Gunicorn server, routed through Nginx.

Within the project root, run:

$ sudo mkdir deploy log
$ cd deploy
$ sudo vi gunicorn_start

The contents of the gunicorn_start script can be found here. It is divided into 3 significant parts, which are, for the most part, self-explanatory. For any questions, please comment below.

NOTE: Make sure the USER and GROUP variables match the same user and group for the non-root user.

Paste the contents into VI, and then save and exit.

Finally, let’s make it executable:

$ sudo chmod +x gunicorn_start

Start the server:

$ sudo ./gunicorn_start

Once again visit the your server’s IP address in the browser and you will see your Django web app running!

Did you get a 502 Bad gateway error? Just follow these steps and it will probably be enough to make your application work…

$ sudo dnf install policycoreutils-devel
$ sudo cat /var/log/audit/audit.log | grep nginx | grep denied | audit2allow -M mynginx
$ sudo semodule -i mynginx.pp

Systemd

To make our gunicorn_start script run as a system service so that, even if we are no longer logged into the server, it still serves our Django web application, we need to create a systemd service.

Just change the working directory to /etc/systemd/system, and then create a service file:

$ cd /etc/systemd/system
$ sudo vi django-bootstrap.service

Add the following:

#!/bin/sh

[Unit]
Description=Django Web App
After=network.target

[Service]
PIDFile=/var/run/cric.pid
ExecStart=/bin/sh /opt/django_cookiecutter_fedora/deploy/gunicorn_start
Restart=on-abort

[Install]
WantedBy=multi-user.target

Save and exit, and then start the service and enable it:

$ sudo systemctl start django-bootstrap.service

NOTE: If you encounter an error, run journalctl -xe to see more details.

Finally, enable the service so that it runs forever and restarts on arbitrary shut downs:

$ sudo systemctl enable django-bootstrap.service

Sanity Check (final!)

Check for the status of the service:

$ sudo systemctl status django-bootstrap.service

Now just visit your server’s IP address (or hostname) and you will see a Django error page. To fix this, run the following command in your project’s root directory (with your virtualenv activated):

$ python manage.py collectstatic

Now you are good to go, and you will see the Django web app running on the web browser with all the static files (HTML/CSS/JS) files working.

For further reference grab the code from the repository. Add your questions, comments, and concerns below. Cheers!