Dockerizing a Django Application: A Step-by-Step Guide

Dockerizing your Django application can provide numerous benefits, including consistent deployment environments, ease of scaling, and simplified dependency management. This guide will walk you through the process of creating a Docker image for your Django application.


  • Python and pip installed on your machine
  • Docker installed on your machine
  • Django installed (or create a new Django project)
  • IDE (Visual Studio Code, PyCharm, etc.)

Step 1: Create a Django Application

If you don't have an existing Django application, you can create a new one using the Django admin tool.

Open your terminal and run the following commands:

pip install django
django-admin startproject my_django_app
cd my_django_app
python startapp myapp

This will create a new Django application in the my_django_app directory.

Step 2: Update

Edit the file in the my_django_app directory to configure the database and allowed hosts.

# my_django_app/my_django_app/

# Add this to the existing settings

# Add these lines to configure the database for Docker
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',  # Or other database engine
        'NAME': BASE_DIR / 'db.sqlite3',

Step 3: Create a Dockerfile

Create a file named Dockerfile in the root directory of your Django project. This file will contain instructions for building the Docker image.

# Use the official Python image from the Docker Hub
FROM python:3.11-slim

# Set environment variables

# Set the working directory

# Install dependencies
COPY requirements.txt /app/
RUN pip install -r requirements.txt

# Copy the project files to the working directory
COPY . /app/

# Run the Django development server
CMD ["python", "", "runserver", ""]


  • FROM python:3.11-slim: Use the official Python image as the base image.
  • ENV PYTHONDONTWRITEBYTECODE 1 and ENV PYTHONUNBUFFERED 1: Set environment variables for Python.
  • WORKDIR /app: Set the working directory inside the container to /app.
  • COPY requirements.txt /app/ and RUN pip install -r requirements.txt: Copy requirements.txt to the container and install the dependencies.
  • COPY . /app/: Copy the rest of the project files to the container.
  • CMD ["python", "", "runserver", ""]: Run the Django development server.

Step 4: Create requirements.txt

Create a requirements.txt file in the root directory of your Django project to list the project dependencies.


You can generate this file by running:

pip freeze > requirements.txt

Step 5: Build the Docker Image

Run the following command to build the Docker image:

docker build -t my-django-app .


  • docker build: The Docker command to build an image.
  • -t my-django-app: Tags the image with the name my-django-app.
  • .: Specifies the current directory as the build context.

Step 6: Run the Docker Container

Run the following command to start a Docker container from the image:

docker run -p 8000:8000 my-django-app


  • docker run: The Docker command to run a container.
  • -p 8000:8000: Maps port 8000 of the container to port 8000 on the host machine.
  • my-django-app: The name of the Docker image to run.

Step 7: Verify the Application

Open a web browser and navigate to http://localhost:8000. You should see your Django application running.

Additional Docker Commands

7.1 List Docker Images

To list all Docker images on your system, run:

docker images

7.2 List Running Containers

To list all running Docker containers, run:

docker ps

7.3 Stop a Running Container

To stop a running Docker container, run:

docker stop <container_id>

Replace <container_id> with the actual container ID obtained from the docker ps command.

7.4 Remove a Docker Container

To remove a Docker container, run:

docker rm <container_id>

Replace <container_id> with the actual container ID.

7.5 Remove a Docker Image

To remove a Docker image, run:

docker rmi my-django-app


In this guide, you have learned how to dockerize a Django application. We covered:

  • Creating a simple Django application.
  • Writing a Dockerfile to build and run the Django application.
  • Building the Docker image.
  • Running the Docker container.
  • Verifying the application.

By following these steps, you can easily package your Django application into a Docker container, providing a consistent and portable deployment environment.