How to Create a Dockerfile for a Django App with Minimal Setup

Containerizing applications has become the go-to method for developers to ensure their applications run consistently across environments. This is extremely useful when you want to deploy to some non-unix machines.

In this guide, we’ll show you how to create a minimal Dockerfile for a Django app, perfect for beginners and those seeking simplicity.

What Is Docker, and Why Use It with Django?

Docker allows developers to package their applications and dependencies into lightweight containers. For Django apps, this means no more "it works on my machine" issues. Containers ensure portability, dependency isolation, and ease of collaboration.

Prerequisites

Before we dive in, ensure you have a working Django app, Docker installed on your system (Download Docker here), and a basic understanding of Django and Docker concepts.

Creating a Minimal Dockerfile for Your Django App

A Dockerfile is a script that contains a series of instructions for Docker to build your application image. Here's a simple yet functional Dockerfile for a Django project.

Choose a Base Image

We’ll use the lightweight Python Slim image to save space while ensuring all required dependencies are present:

FROM python:3.10-slim

The python:3.10-slim image provides Python without unnecessary extras, reducing build size.

Set the Working Directory

Define a directory inside the container where your app code will live:

WORKDIR /app

This keeps the container’s file system organized.

Install Dependencies

Copy your requirements.txt file to the container and install the dependencies:

COPY requirements.txt /app/

RUN pip install --no-cache-dir -r requirements.txt

--no-cache-dir prevents cached files from bloating the container.

Copy the Application Code

Add your Django project files to the container:

COPY . /app/

This copies all your local files into the container’s /app/ directory.

Expose a Port

Expose port 8000, which is Django’s default development server port:

EXPOSE 8000

Set the Command to Run the App

Define the default command to start your app:

CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

This tells Docker to run the Django development server when the container starts. Note: This is suitable for development only.

Building and Running Your Container

Build the Docker image:

docker build -t django-app .

This creates an image named django-app.

Run the container:

docker run -p 8000:8000 django-app

Visit http://localhost:8000 to see your Django app in action.

Enhancements for Production

For production, consider using gunicorn as the application server, adding a reverse proxy like nginx for handling HTTP requests, and separating services with docker-compose, including a database container.

Common Errors and Fixes

Dependencies Missing

Check if your requirements.txt is correctly listed and accessible. Rebuild the container with:

docker build --no-cache -t django-app .

Server Not Running

Ensure your Django app works locally before containerizing it. Check the logs with:

docker logs <container_id> </container_id>

Conclusion

With this minimal Dockerfile, you’ve taken your first steps into containerizing Django apps. While this setup is ideal for development, remember to enhance it for production use. Experiment, learn, and enjoy the magic of containers!

For further reading, check out Docker Documentation and Django Documentation.

The whole Dockerfile content is here

# Use a lightweight Python image as the base FROM python:3.10-slim

# Set the working directory in the container WORKDIR /app

# Copy the requirements file into the container COPY requirements.txt /app/

# Install dependencies RUN pip install --no-cache-dir -r requirements.txt

# Copy the application code into the container COPY . /app/

# Expose port 8000 for the Django development server EXPOSE 8000

# Set the command to run the Django development server CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]