Omonbude Emmanuel
Backend Engineer
Fullstack Web Developer
Mobile Application Developer
  • Residence:
  • Phone:
  • Email:


Omonbude Emmanuel | Nov. 7, 2023, 7:32 p.m.


Hey there, fellow developer! Ever felt the frustration of deploying your Django app and running into issues because things work differently on different machines? Say goodbye to those headaches because we're about to dive into the wonderful world of Docker, a game-changer for developers like you.

Docker makes your life easier by wrapping up your entire Django project and all its necessities into a neat, portable box called a "container." It ensures that your app runs the same way everywhere, from your laptop to your colleague's computer and even in the cloud. 

In this article, we'll explore the process of dockerizing a Django application, enabling you to run your Django project seamlessly across different environments.


Before you begin, make sure you have the following installed on your system:

Docker: The platform for developing, shipping, and running applications in containers.
Docker Compose: A tool for defining and running multi-container Docker applications.

If you're using Ubuntu operating system, you can follow the link below to my previous posts on how to install docker and docker-compose.

The project is already on github, you can clone it from


Step 1: Setting Up Your Django Project:

to create the django project we run the command:


django-admin startproject project


and to create our app, we run the command:

python startapp index


Step 2: Dockerfile:

Create a Dockerfile in the root of your Django project. This file contains instructions for building a Docker image for your application. Here's a sample.


FROM python:3.8 # Set environment variables


#This means that as soon as a message is generated (e.g., by a print statement), it's immediately visible, making it easier to see real-time output and diagnose issues more quickly, especially in environments like Docker where log messages may be crucial for debugging.


# Create and set the working directory

RUN mkdir /code



COPY . /code/  # Copy the current directory contents into the container at /code

# Install any needed packages specified in requirements.txt

RUN pip install -r requirements.txt


# Copy the entrypoint script and make it executable

COPY /code/

RUN chmod +x /code/

# Copy the script and set execute permissions

# Expose the port the application runs on


# Run Django development server

CMD ["python", "", "runserver", ""]


Step 3: Docker Compose:

Create a docker-compose.yml file to define your application's services, networks, and volumes. This file simplifies the process of running multiple Docker containers.


version: '3'

  # Django web application
    container_name: my-django-app
      context: .
      dockerfile: Dockerfile
      - .env
      - "8000:8000"
      - .:/code
      - db
      - DEBUG=True  # Set your Django application environment variables here
    command: sh ./

  # PostgreSQL database
    image: postgres:14.1-alpine
    container_name: my-postgres-db
      - postgres_data:/var/lib/postgresql/data
          - "5432:5432"
      - .env # Include the environment file here




1. Docker Compose Version:
version: '3': Specifies the version of the Docker Compose file format being used.
2. Services:

  • Django Web Application (web service):
    container_name: Specifies the name of the Docker container for the Django application.
    build: Specifies the build context and Dockerfile for building the custom Docker image.
    env_file: Includes environment variables from the .env file for the Django application.
    ports: Maps port 8000 on the host to port 8000 in the container.
    volumes: Mounts the current directory (.) to the /code directory in the container, facilitating code synchronization.
    depends_on: Declares a dependency on the db service, ensuring the PostgreSQL database starts before the Django application.
    environment: Sets additional environment variables for the Django application.
    command: Executes the script when the container starts.
  • PostgreSQL Database (db service):
    image: Specifies the PostgreSQL image and version to use.
    container_name: Specifies the name of the Docker container for the PostgreSQL database.
    volumes: Creates a named volume (postgres_data) to persist PostgreSQL data.
    ports: Maps port 5432 on the host to port 5432 in the container for PostgreSQL connections.
    env_file: Includes environment variables from the .env file for PostgreSQL configuration.

3. Volumes:
volumes: Defines a named volume (postgres_data) to persist data for the PostgreSQL database.

This setup file makes sure your Django web app and PostgreSQL database team up smoothly. It uses Docker Compose tricks like handling dependencies, adding environment stuff, and dealing with data storage to create a friendly space for your Django project. 

Step 4: Entry Point

The script in the context of a Dockerized Django application serves as the entry point or the initial command that runs when the Docker container starts. This script is often used to perform any necessary setup or configuration tasks before starting the main application.



set -e

python3 migrate --no-input

python3 collectstatic --no-input

python runserver


Step 5: .env file

The .env file is a configuration file commonly used to store environment variables for your application. It follows a simple key=value format, where each line represents a variable and its corresponding value. This file is particularly useful for managing sensitive information, configuration parameters, or anything that might change between different environments (e.g., development, testing, production). In this case, we'd be storing details for our postgres database

create a .env file in your main directory  and add the following details


You can change it to your following details


Step 6: settings file

We need to configure our file to connect it to the postgres database 


    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': os.environ.get('POSTGRES_DB'),
        'USER': os.environ.get('POSTGRES_USER'),
        'PASSWORD': os.environ.get('POSTGRES_PASSWORD'),
        'HOST': os.environ.get('POSTGRES_HOST', 'db'),
        'HOST': 'db',
        'PORT': 5432,

STATIC_URL = '/static/'

STATICFILES_DIRS = [ os.path.join(BASE_DIR, 'static')]

STATIC_ROOT = os.path.join(BASE_DIR, 'static_cdn')

MEDIA_URL = '/media_cdn/'

MEDIA_ROOT = os.path.join(BASE_DIR, 'media_cdn')


Step 7: Build and start the Docker containers:

  1. Build Docker Containers:

    • Run the following command to build the Docker containers defined in your docker-compose.yml file:
      docker-compose build 

    This command instructs Docker Compose to build the images specified in the services of your docker-compose.yml.

  2. Start Docker Containers:

    • Once the build process is complete, start the containers with the following command:
      docker-compose up 

    This command starts the services defined in your docker-compose.yml.

  3. Access Your Dockerized Django App:

    • After the containers are up and running, you should be able to access your Django web application. Open a web browser and go to http://localhost:8000 (or the port you specified in the docker-compose.yml if different).
  4. Stopping the Containers:

    • When you're done working, you can stop the containers using the following command:
      docker-compose down


Additional Tips:

  • If you want to run the containers in the background, you can add the -d flag to the docker-compose up command:
    docker-compose up -d

  • To see logs and monitor container output, you can run the following command in a separate terminal window:
    docker-compose logs -f

  • To run a command in django app inside the docker container run the command 
    docker-compose run web python3 createsuperuser 
    this command creates superuser in our web service.

  • To open terminal in web service
    docker compose exec -it web bash



In conclusion, Dockerizing your Django application offers significant advantages in terms of reproducibility, portability, isolation, scalability, and manageability. By leveraging Docker's containerization technology, you can streamline your application development and deployment process, ensuring consistent performance and seamless operation across different environments.

May your containers run seamlessly, your deployments be effortless, and your Django endeavors be infused with the innovation and efficiency that Dockerization brings. Happy coding, and welcome to the era of Dockerized Django!

© 2023 Omonbude Emmanuel

Omonbude Emmanuel