Docker containerization in Django - Mini Project: Build & Apply

Docker containerization

📖 Scenario: You are creating a simple Django web application that you want to run inside a Docker container. Docker helps package your app with all its settings and dependencies so it runs the same everywhere.

🎯 Goal: Build a Docker setup for a Django app by creating a Dockerfile, setting a port configuration, writing the command to run the app inside the container, and finally adding a docker-compose.yml file to manage the container easily.

📋 What You'll Learn

Create a Dockerfile with Python base image and Django setup

Add a port variable to expose Django's default port 8000

Write the command to run Django's development server inside the container

Create a docker-compose.yml file to run the container with port mapping

💡 Why This Matters

🌍 Real World

Docker helps developers package their Django apps with all dependencies so they run the same on any computer or server. This avoids the 'it works on my machine' problem.

💼 Career

Many companies use Docker to deploy web apps. Knowing how to containerize Django apps is a valuable skill for backend and DevOps roles.

1

Create the Dockerfile with Python base and Django install

Create a file named Dockerfile with these exact lines:
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .

Django

# Your code here

Hint

Use the official Python 3.12 slim image. Set working directory to /app. Copy requirements.txt and install dependencies. Then copy the rest of the app files.

2

Add a port variable to expose Django's port

In the same Dockerfile, add a line to expose port 8000 by writing EXPOSE 8000 after the last COPY command.

Django

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
# Your code here

Hint

This tells Docker which port the container will listen on. Django's default development server uses port 8000.

3

Add the command to run Django development server

In the Dockerfile, add a line at the end to run the Django server with CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"].

Django

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
EXPOSE 8000
# Your code here

Hint

This command starts Django's development server and makes it listen on all network interfaces inside the container.

4

Create docker-compose.yml to run the container with port mapping

Create a file named docker-compose.yml with these exact lines:
version: '3.9'
services:
web:
build: .
ports:
- '8000:8000'

Django

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

# Your docker-compose.yml content here

Hint

This file tells Docker Compose to build the image from the current folder and map port 8000 on your computer to port 8000 in the container.

Practice

1. What is the main purpose of using Docker with a Django application?

easy

A. To write Django code faster

B. To automatically generate Django templates

C. To replace the Django ORM with a container

D. To package the app and its environment for easy sharing and deployment

Solution

1. Step 1: Understand Docker's role

   Docker packages an app with all its dependencies so it runs the same everywhere.

2. Step 2: Connect to Django app deployment

   This packaging makes sharing and deploying Django apps consistent and easy.

3. Final Answer:

   To package the app and its environment for easy sharing and deployment -> Option D

4. Quick Check:

   Docker packages app + environment = B [OK]

Hint: Docker bundles app + environment for consistent deployment [OK]

Common Mistakes:

• Thinking Docker speeds up coding
• Confusing Docker with Django features
• Believing Docker replaces Django components

2. Which of the following is the correct way to start a Django app inside a Dockerfile?

easy

A. EXPOSE python manage.py runserver

B. RUN python manage.py runserver

C. CMD python manage.py runserver 0.0.0.0:8000

D. COPY python manage.py runserver

Solution

1. Step 1: Identify Dockerfile commands

   CMD sets the command to run when the container starts.

2. Step 2: Match command to Django app start

   Running 'python manage.py runserver 0.0.0.0:8000' starts the Django server accessible outside the container.

3. Final Answer:

   CMD python manage.py runserver 0.0.0.0:8000 -> Option C

4. Quick Check:

   CMD runs app on container start = A [OK]

Hint: Use CMD to run Django server with 0.0.0.0 binding [OK]

Common Mistakes:

• Using RUN instead of CMD to start server
• Misusing EXPOSE as a command
• Confusing COPY with execution commands

3. Given this Dockerfile snippet for a Django app:

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt ./
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

What happens when you build and run this container?

medium

A. The container fails because requirements.txt is missing

B. The Django app runs and listens on port 8000 inside the container

C. The app runs but listens only on localhost inside the container

D. The container runs but does not start the Django server

Solution

1. Step 1: Analyze Dockerfile commands

   The Dockerfile installs dependencies, copies code, and runs the Django server on 0.0.0.0:8000.

2. Step 2: Understand container networking

   Binding to 0.0.0.0 means the app listens on all interfaces inside the container, ready for port mapping.

3. Final Answer:

   The Django app runs and listens on port 8000 inside the container -> Option B

4. Quick Check:

   CMD runs server on 0.0.0.0:8000 = A [OK]

Hint: 0.0.0.0 means app listens inside container for external access [OK]

Common Mistakes:

• Assuming app is accessible without port mapping
• Confusing 0.0.0.0 with localhost
• Thinking COPY runs code

4. You wrote this Dockerfile for your Django app:

FROM python:3.12
COPY . /app
WORKDIR /app
RUN pip install -r requirements.txt
CMD python manage.py runserver

When you build and run the container, the server does not start. What is the likely problem?

medium

A. The CMD command is missing the IP and port to bind to

B. The WORKDIR command is in the wrong place

C. The requirements.txt file is not copied before pip install

D. The base image python:3.12 does not support Django

Solution

1. Step 1: Check CMD command correctness

   Running 'python manage.py runserver' defaults to binding on 127.0.0.1, which is inside the container only.

2. Step 2: Understand container network binding

   Without binding to 0.0.0.0, the server is not accessible outside the container, so it seems like it does not start.

3. Final Answer:

   The CMD command is missing the IP and port to bind to -> Option A

4. Quick Check:

   Missing 0.0.0.0 binding causes server invisibility = D [OK]

Hint: Always bind Django server to 0.0.0.0 in Docker CMD [OK]

Common Mistakes:

• Assuming default runserver binds externally
• Thinking WORKDIR order breaks container
• Believing base image lacks Django support

5. You want to optimize your Django Docker container to reduce image size and speed up builds. Which approach is best?

hard

A. Use a multi-stage Dockerfile to install dependencies separately and copy only needed files

B. Install all Python packages globally on the host machine

C. Copy the entire project folder after installing dependencies

D. Use the latest full Python image without slimming

Solution

1. Step 1: Understand multi-stage builds

   Multi-stage Dockerfiles let you build dependencies in one stage and copy only necessary files to the final image, reducing size.

2. Step 2: Compare other options

   Installing packages on host or copying everything increases image size and reduces portability.

3. Final Answer:

   Use a multi-stage Dockerfile to install dependencies separately and copy only needed files -> Option A

4. Quick Check:

   Multi-stage builds optimize image size and build speed = C [OK]

Hint: Multi-stage Dockerfiles keep images small and builds fast [OK]

Common Mistakes:

• Installing packages outside container
• Copying unnecessary files increases size
• Using large base images without slimming