Dockerizing Python Django Application on Ubuntu 20.04

Docker is a free and open-source platform that allows you to build, package, and run applications in a lightweight container. It helps you to separate your applications from your infrastructure so you can deliver software quickly.

Django is an open-source web application framework that follows the Model-View-Controller architecture. Written in Python, it is used for rapidly developed, pragmatically designed, and secure websites.

In this tutorial, we will explain how to deploy Python Django web application in the Docker environment.

Step 1 – Install Docker and Docker Compose

First, you will need to install Docker and Docker Compose in your system. By default, the latest version of Docker is not available in the Ubuntu 20.04 default repository, so you will need to add the repository for that.

First, install all dependencies with the following command:

apt-get install apt-transport-https curl gnupg2 software-properties-common tree -y

Once all the dependencies are installed, import the GPG key with the following command:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -

Next, add the Docker official repository with the following command:

add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -
cs) stable"

Once the repository has been added, install the Docker and Docker Compose with the following command:

apt-get install docker-ce docker-compose -y

Once both packages are installed, verify the installed version of Docker with the following command:

docker -v

Output:

Docker version 19.03.13, build 4484c46d9d

You can also check the Docker Compose version using the following command:

docker-compose -v

Output:

docker-compose version 1.25.0, build unknown

Step 2 – Create a Dockerfile

Next, you will need to create a Dockerfile to build a container image for your Django application.

First, create a project directory named myapp with the following command:

mkdir ~/myapp

Next, change the directory to myapp and create a new Dockerfile with the following command:

cd ~/myapp
nano Dockerfile

Add the following lines:

FROM python:3
ENV PYTHONUNBUFFERED=1
RUN mkdir /code
WORKDIR /code
COPY requirements.txt /code/
RUN pip install -r requirements.txt
COPY . /code/

Save and close the file when you are finished.

The above file will pull the official Python image from Dockerhub, create a code directory inside the container, and install the requirements listed in the requirements.txt file.

Next, create a requirements.txt file and add the required modules:

nano requirements.txt

Add the following lines:

Django==3.0.7
psycopg2-binary==2.8.5

Save and close the file when you are finished.

Step 3 – Create a Docker-compose.yml File

Docker compose is a tool used for defining and running multi-container Docker applications. You can create a docker-compose.yml file with the following command:

nano ~/myapp/docker-compose.yml

Add the following lines:

version: "3.7"

services:
db:
image: postgres
environment:
- POSTGRES_DB=postgres
- POSTGRES_USER=postgres
- POSTGRES_PASSWORD=postgres
web:
build: .
command: python manage.py runserver 0.0.0.0:8000
volumes:
- .:/code
ports:
- "8000:8000"
depends_on:
- db

Save and close the file when you are finished.

The above file will create the database service named db using the PostgreSQL image and create our python Django container using the custom docker images generated from our Dockerfile.

Step 4 – Create a Django Project

Next, you will need to download the sample Django project named composeexample inside your project directory.

First, change the directory to ~/myapp and run the following command:

cd ~/myapp
docker-compose run web django-admin startproject composeexample

This will download the composeexample project in the current directory.

Next, copy the required directory and files from the downloaded directory with the following command:

mv composeexample /opt/
mv /opt/composeexample/* .

Your project directory structure will look like the following:

tree

Output:

.
├── composeexample
│ ├── asgi.py
│ ├── __init__.py
│ ├── __pycache__
│ │ ├── __init__.cpython-39.pyc
│ │ ├── settings.cpython-39.pyc
│ │ ├── urls.cpython-39.pyc
│ │ └── wsgi.cpython-39.pyc
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
├── docker-compose.yml
├── Dockerfile
├── manage.py
└── requirements.txt

Next, you will need to edit the settings.py file and define your database settings and allowed hosts:

nano composeexample/settings.py

Change the following lines:

ALLOWED_HOSTS = ['your-server-ip']

DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql',
'NAME': 'postgres',
'USER': 'postgres',
'PASSWORD': 'postgres',
'HOST': 'db',
'PORT': 5432,
}
}

Save and close the file when you are finished.

Step 5 – Build and Run the Docker Image

Next, change the directory to your project and build the image with the following command:

docker-compose build

This will download the required images to your system:

---> ad21d53c5de1
Step 7/7 : COPY . /code/
---> 0d912d4c215b

Successfully built 0d912d4c215b
Successfully tagged myapp_web:latest

Next, start the all containers by running the following command:

docker-compose up -d

You should get the following output:

Pulling db (postgres:)...
latest: Pulling from library/postgres
bb79b6b2107f: Pull complete
e3dc51fa2b56: Pull complete
f213b6f96d81: Pull complete
2780ac832fde: Pull complete
ae5cee1a3f12: Pull complete
95db3c06319e: Pull complete
475ca72764d5: Pull complete
8d602872ecae: Pull complete
c4fca31f2e3d: Pull complete
a00c442835e0: Pull complete
2e2305af3390: Pull complete
6cff852bb872: Pull complete
25bb0be11543: Pull complete
4738c099c4ad: Pull complete
Digest: sha256:8f7c3c9b61d82a4a021da5d9618faf056633e089302a726d619fa467c73609e4
Status: Downloaded newer image for postgres:latest
Creating myapp_db_1 ... done
Creating myapp_web_1 ... done

Now, you can verify the running containers with the following command:

docker-compose ps

You should get the following output:

Name Command State Ports
-----------------------------------------------------------------------------
myapp_db_1 docker-entrypoint.sh postgres Up 5432/tcp
myapp_web_1 python manage.py runserver ... Up 0.0.0.0:8000->8000/tcp

You can also list all downloaded images with the following command:

docker-compose images

You should get the following output:

Container Repository Tag Image Id Size
-----------------------------------------------------------
myapp_db_1 postgres latest c96f8b6bc0d9 314.1 MB
myapp_web_1 myapp_web latest 0d912d4c215b 928.6 MB

If you have any problem running the container, you can verify the container log with the following command:

docker-compose logs

Step 6 – Access Django Web UI

At this point, the Django container is started and running on port 8000. You can access it using the URL http://your-server-ip:8000. You should see your Django application dashboard on the following screen:

 

Conclusion

Congratulations! You have successfully deployed the Django application with Docker on Ubuntu 20.04. You should now be able to deploy your Python application easily with Docker. Try it today on dedicated server hosting from Atlantic.Net!