How to Deploy a Django Project
Tags: django, python, webdev, tutorial
Published: 2023-03-28 15:00:00

In the [Django tutorial series](https://www.ericsdevblog.com/posts/django-for-beginners-1?ref=Dev_Community/), we talked about how to create a basic Django application. But there is a significant part that is missing from the tutorial, that is how to deploy our app so that it is accessible to the public.

In this article, we'll talk about how to deploy a Django project manually on a Linux server using uWSGI and Nginx. Assume you are using Ubuntu 22.4 LTS.

First of all, you must prepare your server like we discussed in [this article](https://www.ericsdevblog.com/posts/how-to-set-up-a-web-server?ref=Dev_Community/), so that it is secure and safe to use. And also make sure your software is up to date by running the following commands.

```cmd
sudo apt update
```

```cmd
sudo apt upgrade
```

## Clone your project using Git

After you've set up the server, you'll need to upload the Django project to the server. Git is an ideal tool for this purpose. Git is an open-source version control software that can track the changes in the source code. It is designed for coordinating work among programmers.

Git should be preinstalled on your system by default, but just in case it is not there, you can install it using the following command:

```cmd
sudo apt install git
```

And then, go to the `home` directory, and clone our project from GitHub to the server.

```cmd
cd ~
```

```cmd
git clone https://github.com/ericsdevblog/django-tutorial.git
```

This command will create a `django-tutorial` directory and put our project in it. Here is a small Linux trick, you can check the content of a directory using the following command:

```cmd
ls
```

If you need to list the hidden items as well:

```cmd
ls -a
```

Next time, when you make changes to our project, instead of uploading the entire project again, you only need to run the `git pull` command.

## Create virtual environment & install requirements

Now that you have cloned your Django project, you need to create an isolated virtual Python environment for it. However, on Debian based systems, the `venv` package, which you'll need to create a virtual environment, is not included by default, but you can install it using the following command:

```cmd
sudo apt install python3.10-venv
```

Go to the application's root directory:

```cmd
cd <path_to_root_directory>
```

Create a virtual environment:

```cmd
python3 -m venv env
```

Run the `ls` command again, and you should see an `env` directory. The virtual environment is created inside. Now, all you need to do is activate the environment and install all the necessary requirements for this project.

Activate the virtual environment:

```cmd
source env/bin/activate
```

Remember, if you install required packages without activating the virtual environment, the packages will be installed globally, instead of in the virtual environment we just created.

If the activation is successful, your terminal prompt should look like this.

```text
(env) eric@djangoDeployDemo:~/django-tutorial/djangoTutorial$
```

`(env)` means you are currently working inside a virtual environment called `env`.

You can also deactivate virtual environment using the following command:

```cmd
deactivate
```

Install requirements:

```cmd
pip install -r requirements.txt
```

## Install uWSGI

uWSGI is a software application that "aims at developing a full stack for building hosting services". It is named after the Web Server Gateway Interface (WSGI), which was the first plugin supported by the project.

uWSGI is often used for serving Python web applications in conjunction with web servers such as Cherokee and Nginx, which offer direct support for uWSGI's native uWSGI protocol.

Before you can install uWSGI, you need to install the Python development package first.

```cmd
sudo yum groupinstall "Development Tools"
sudo yum install python-devel
```

Next, install the latest stable version of uWSGI:

```cmd
pip install uwsgi
```

### Test Your Django Project

Now, we can test our Django project with uWSGI. First, make sure our site actually works:

```cmd
python manage.py runserver 0.0.0.0:8000
```

And if that works, run it with uWSGI:

```cmd
uwsgi --http :8000 --module django_blog.wsgi
```

`module django_blog.wsgi`: load the specified `wsgi` module.

Visit the server IP from your browser, if the site appears, it means uWSGI is able to serve your Django application from your `virtualenv`, and this stack operates correctly:

```text
the web client <-> uWSGI <-> Django
```

Now, normally we won’t have the browser speaking directly to uWSGI. That’s a job for the web server, which will act as a go-between.

## Install Nginx

Nginx is an open-source high-performance web server. Compared to Apache, it is much more flexible and lightweight.

First, we need to add the Nginx repository:

```cmd
sudo yum install epel-release
```

Install Nginx using `yum` command:

```cmd
sudo yum install nginx
```

After this, we can start the Nginx server by typing:

```cmd
sudo systemctl start nginx
```

Now we need to check if the Nginx server is working properly by visiting it in a web browser on port 80. You should get a message from Nginx: “Welcome to Nginx!”. If not, it is probably because something else is running on port 80, and you need to reconfigure Nginx to serve on a different port. For this tutorial, we'll use port 8000.

### Configure Nginx for Your Site

To configure Nginx so that it works for our Django site, we need to edit the `uwsgi_params` file, which is available in the `nginx` directory of the uWSGI distribution, or from [GitHub](https://github.com/nginx/nginx/blob/master/conf/uwsgi_params).

We need to copy this file to the Django project directory, and later we'll need to tell Nginx to use this file.

Now create a file called `django_blog_nginx.conf` in the `/etc/nginx/sites-available/` directory, and add the following configurations:

```text
# django_blog_nginx.conf

# the upstream component nginx needs to connect to

upstream django {
    # server unix:///<path_to_your_site>/mysite.sock; # for a file socket
    server 127.0.0.1:8001; # for a web port socket (we'll use this first)
}

# configuration of the server

server {
    # the port your site will be served on
    listen      8000;
    # the domain name it will serve for
    server_name example.com; # substitute your machine's IP address or FQDN
    charset     utf-8;

    # max upload size
    client_max_body_size 75M;   # adjust to taste

    # Django media
    location /media  {
        alias <path_to_your_site>/media;  # your Django project's media files - amend as required
    }

    location /static {
        alias <path_to_your_site>/static; # your Django project's static files - amend as required
    }

    # Finally, send all non-media requests to the Django server.
    location / {
        uwsgi_pass  django;
        include     <path_to_your_site>/uwsgi_params; # the uwsgi_params file you installed
    }

}
```

This configuration file tells Nginx to serve the site on port 8000. Nginx will handle the static file and media files, as well as requests that require Django's intervention. For a large project, it is always better to let one server handel static/media files, and another handle Django applications. But for now, this is all we need to do.

Symlink to this file from `/etc/nginx/sites-enabled` so Nginx can use it:

```cmd
sudo ln -s /etc/nginx/sites-available/django_blog_nginx.conf /etc/nginx/sites-enabled/
```

### Deploy Static Files

Before running Nginx, we have to collect all Django static files in the static folder. First of all, we have to edit `settings.py` adding:

```python
STATIC_ROOT = os.path.join(BASE_DIR, "static/")
```

and then run

```cmd
python manage.py collectstatic
```

### Test Nginx Server

Since we made changes to the Nginx server configuration, we need to restart the server so that these changes can take effect:

```cmd
sudo systemctl restart nginx
```

Upload a new image (`media.png`) to the `/media` directory, can then visit `http://<your_domain>:8000/media/media.png` in the browser to see if Nginx is serving the media files correctly. If it doesn't work, try stopping and starting the Nginx server again. This will inform you if there is a problem and where it is.

## Run the Django Application with Nginx and uWSGI

Now that we have uWSGI and Nginx properly installed and configured, we can start our Django application:

```cmd
uwsgi --socket django_blog.sock --module django_blog.wsgi --chmod-socket=664
```

### Configuring uWSGI to run with a `.ini` file

We can put relevant uWSGI configurations into a file, and then ask uWSGI to parse the configurations on start up.

Create a file called `django_blog_uwsgi.ini`:

```ini
# django_blog_uwsgi.ini file

[uwsgi]

# Django-related settings

# the base directory (full path)

chdir           = /path/to/your/project

# Django's wsgi file

module          = project.wsgi

# the virtualenv (full path)

home            = /path/to/virtualenv

# process-related settings

# master

master          = true

# maximum number of worker processes

processes       = 10

# the socket (use the full path to be safe

socket          = /path/to/your/project/mysite.sock

# ... with appropriate permissions - may be needed

# chmod-socket    = 664

# clear environment on exit

vacuum          = true
```

And run `uwsgi` using this file:

```cmd
uwsgi --ini mysite_uwsgi.ini # the --ini option is used to specify a file
```

## Install uWSGI System-Wide

So far, uWSGI is only installed in our virtual environment, and we’ll need it installed system-wide for deployment purposes.

Deactivate your virtual environment:

```cmd
deactivate
```

and install uWSGI system-wide:

```cmd
sudo pip3 install uwsgi
```

The uWSGI wiki describes several [installation procedures](https://projects.unbit.it/uwsgi/wiki/Install). Before installing uWSGI system-wide, it’s worth considering which version to choose and the most appropriate way of installing it.

Check again that we can still run uWSGI just like we did before:

```cmd
uwsgi --ini mysite_uwsgi.ini # the --ini option is used to specify a file
```