How to Dockerize a Python Django Application

Docker is an open source project that provides an open platform for developers and system administrators to build and package applications as a lightweight container and run them anywhere. Docker automates the deployment of applications in software containers.
Django is a web application framework written in Python that follows the MVC (Model-View-Controller) architecture. It is free and released under an open source license. It’s fast and designed to help developers get their apps online as quickly as possible.
In this tutorial, I will show you step by step how to create a docker image for an existing Django application in Ubuntu 16.04. We will learn how to dockerize a Python Django application and then use a docker-compose script to deploy the application as a container to a docker environment.
To deploy our Python Django application, we need other docker images: an nginx docker image for the web server and a PostgreSQL image for the database.

What should we do?

1. Install Docker-ce
2. Install Docker-compose
3. Configure the project environment
4. Build and run
5. test

Step 1 - Install Docker-ce

In this tutorial, we will install docker-ce community edition from the docker repository. We will install docker-ce community edition and docker-compose (which supports version 3 of compose files).

Before installing docker-ce, install the required docker dependencies using the apt command.

sudo apt install -y
apt-transport-https
ca-certificates
curl
software-properties-common

Now add the docker key and repository by running the following command.

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

Install Docker-ce

Update the repository and install docker-ce.

sudo apt update
sudo apt install -y docker-ce

Once the installation is complete, start the docker service and enable it to launch every time at system boot.

systemctl start docker
systemctl enable docker

Next, we will add a new user named omar and add him to the docker group.

useradd -m -s /bin/bash omar
usermod -a -G docker omar

Start Docker

Log in as the omar user and run the docker command as shown below

su-omar
docker run hello-world

Make sure you get the hello-world message from Docker

Check Docker installation

The Docker-ce installation has been completed.

Step 2 - Install Docker-compose

In this tutorial, we will use the latest docker-compose which supports version 3 of the compose file. We will install docker-compose manually

Use the curl command to download the latest version of docker-compose to the /usr/local/bin directory and use the chmod command to give it execution permissions.

Run the following command:

sudo curl -L 
https://github.com/docker/compose/releases/download/1.21.0/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Now check the docker-compose version.

docker-compose version

Make sure you have the latest version of docker-compose installed: 1.21

Install Docker-compose

The latest version of docker-compose that supports version 3 of the compose file is installed.

Step 3 - Configure the Project Environment

In this step, we will configure the Python Django project environment. We will create a new directory guide01 and make it the main directory for our project files, such as Dockerfile, Django project, nginx configuration file, etc.

Log in to the omar user.

su - omar

Create a new directory, guide01, and change into it.

mkdir -p guide01
cd guide01/

Now in the guide01 directory, create two new directories project and config.

mkdir project/ config/

Notice:

• project directory: All our python Django project files will be placed in this directory.
• config directory: the directory of project configuration files, including nginx configuration files, python pip's requirements.txt files, etc.
  

Create a new requirements.txt file

Next, create a new requirements.txt file in the config directory using the vim command.

vim config/requirements.txt

Paste the following configuration:

Django==2.0.4
gunicorn==19.7.0
psycopg2==2.7.4

Save and exit.

Create the Nginx virtual host file django.conf
Create an nginx configuration directory under the config directory and add the virtual host configuration file django.conf.

mkdir -p config/nginx/
vim config/nginx/django.conf

Paste the following configuration:

upstream web {
ip_hash;
server web:8000;
}
#portal
server {
location / {
proxy_pass http://web/;
}
listen 8000;
server_name localhost;
location /static {
autoindex on;
alias /src/static/;
}
}

Save and exit.

Create Dockerfile
Create a new file Dockerfile in the guide01 directory.

Run the following command:

vim Dockerfile

Now paste the following Dockerfile script:

FROM python:3.5-alpine
ENV PYTHONUNBUFFERED 1
RUN apk update &&
apk add --virtual build-deps gcc python-dev musl-dev &&
apk add postgresql-dev bash
RUN mkdir /config
ADD /config/requirements.txt /config/
RUN pip install -r /config/requirements.txt
RUN mkdir /src
WORKDIR /src

Save and exit.

Notice:

We want to build a Docker image for our Django project based on Alpine Linux, a minimal Linux distribution. Our Django project will run on Alpine Linux with Python 3.5, and add the postgresql-dev package to support the PostgreSQL database. We will then install all the Python packages listed on requirements.txt using the python pip command and create a new directory /src for our project.

Create a Docker-compose script

Use the vim command to create a docker-compose.yml file in the guide01 directory.

vim docker-compose.yml

Paste the following configuration content:

version: '3'
services:
db:
image: postgres:10.3-alpine
container_name: postgres01
nginx:
image: nginx:1.13-alpine
container_name: nginx01
ports:
- "8000:8000"
volumes:
- ./project:/src
- ./config/nginx:/etc/nginx/conf.d
depends_on:
- web
web:
build: .
container_name: django01
command: bash -c "python manage.py makemigrations && python manage.py migrate && python manage.py collectstatic --noinput && gunicorn hello_django.wsgi -b 0.0.0.0:8000"
depends_on:
-db
volumes:
- ./project:/src
expose:
- "8000"
restart: always

Save and exit.

Notice:

Using this docker-compose file script, we will create three services. Create a database service named db using the alpine Linux version of PostgreSQL, create an nginx service again using the alpine Linux version of Nginx, and create our python Django container using the custom docker image generated from the Dockerfile.

Configure the project environment

Configuring the Django project

Copy the Django project files to the project directory.

cd ~/django
cp -r * ~/guide01/project/

Go into the project directory and edit the application settings settings.py.

cd ~/guide01/project/
vim hello_django/settings.py

Notice:

We will deploy a simple Django application named "hello_django".

In the ALLOW_HOSTS line, add the service name web.

ALLOW_HOSTS = ['web']

Now change the database settings. We will use the PostgreSQL database to run a service called db with the default user and password.

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

As for the STATIC_ROOT configuration directory, add this line to the end of the file.

STATIC_ROOT = os.path.join(BASE_DIR, 'static/')

Save and exit.

Configuring the Django project

Now we are ready to build and run the Django project under the docker container.

Step 4 - Build and run the Docker image

In this step, we want to build a Docker image for our Django project using the configuration in the guide01 directory.

Enter the guide01 directory.

cd ~/guide01/
Now build the docker image using the docker-compose command.

docker-compose build

Run the docker image

Start all services in the docker-compose script.

docker-compose up -d

Wait a few minutes for Docker to build our Python image and download the nginx and postgresql docker images.

Build the image using docker-compose

Once completed, use the following commands to check running containers and list docker images on your system.

docker-compose ps
docker-compose images

Now, you will have three containers running on your system, listing the Docker images as shown below.

docke-compose ps command

Our Python Django application is now running inside a docker container, and a docker image has been created to serve it for us.

Step 5 - Testing

Open a web browser and type the server address with port 8000, mine is: http://ovh01:8000/.

Now you will see the default Django homepage.

Default Django project homepage

Next, test the administration pages by adding the /admin path to the URL.

http://ovh01:8000/admin/

You will then see the Django admin login page.

Django administration

Dockerizing the Python Django application has been completed successfully.

Summarize

The above is the full content of this article. I hope that the content of this article will have certain reference learning value for your study or work. Thank you for your support of 123WORDPRESS.COM. If you want to learn more about this, please check out the following links