Docker containerization in Django - Step-by-Step Execution

Concept Flow - Docker containerization

Write Dockerfile

↓

Build Docker Image

↓

Run Docker Container

↓

Container runs Django app

↓

Access app via browser or API

↓

Stop or remove container

This flow shows how you write a Dockerfile, build an image, run a container, and then access your Django app inside the container.

Execution Sample

Django

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"]

This Dockerfile sets up a Python environment, installs dependencies, copies the Django app, and runs the development server.

Execution Table

Step	Action	Details	Result
1	Read Dockerfile	FROM python:3.12-slim	Base image set to Python 3.12 slim
2	Set working directory	WORKDIR /app	Working directory inside container is /app
3	Copy requirements	COPY requirements.txt ./	requirements.txt copied to /app
4	Install dependencies	RUN pip install -r requirements.txt	Python packages installed
5	Copy app files	COPY . ./	All app files copied to /app
6	Set command	CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]	Container will run Django server on port 8000
7	Build image	docker build -t django-app .	Docker image 'django-app' created
8	Run container	docker run -p 8000:8000 django-app	Container runs, Django app accessible at localhost:8000
9	Access app	Open browser at http://localhost:8000	Django app homepage loads
10	Stop container	Ctrl+C or docker stop	Container stops running

💡 Container stops when user stops it or system shuts down

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	Final
Docker Image	None	Base python:3.12-slim	With dependencies installed	With app files copied	Ready to run Django server
Container State	Not running	Not running	Not running	Not running	Running Django server on port 8000

Key Moments - 3 Insights

Why do we copy requirements.txt and run pip install separately before copying the whole app?

This allows Docker to cache the installed dependencies layer. If requirements.txt doesn't change, Docker skips reinstalling packages, speeding up builds (see execution_table steps 3 and 4).

Why do we use 0.0.0.0:8000 instead of localhost:8000 in the CMD?

0.0.0.0 makes the Django server listen on all network interfaces inside the container, allowing access from outside the container (see execution_table step 6).

What happens if we don't map port 8000 when running the container?

The Django app runs inside the container but is not accessible from the host machine's browser (see execution_table step 8).

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what happens during this step?

A The container starts running the Django server

B The Django app files are copied into the container

C Python packages are installed inside the container

D The working directory is set inside the container

💡 Hint

Check the 'Action' and 'Details' columns at step 4 in the execution_table

At which step does the container become accessible from the host machine's browser?

A Step 8: Run container with port mapping

B Step 6: Set command

C Step 7: Build image

D Step 9: Access app

💡 Hint

Look for when the container is run with port mapping in the execution_table

If you change requirements.txt, which step will Docker NOT cache and must rerun?

A Step 3: Copy requirements.txt

B Step 4: Install dependencies

C Step 5: Copy app files

D Step 6: Set command

💡 Hint

Changing requirements.txt affects the pip install step in the execution_table

Concept Snapshot

Docker containerization for Django:
- Write Dockerfile with base image, copy files, install dependencies
- Build image with 'docker build'
- Run container with 'docker run -p hostPort:containerPort'
- Use 0.0.0.0 in runserver to allow external access
- Access app via localhost:port in browser
- Stop container when done

Full Transcript

Docker containerization for Django involves writing a Dockerfile that starts from a Python base image, sets a working directory, copies the requirements.txt file, installs dependencies, copies the Django app files, and sets the command to run the Django development server on all interfaces at port 8000. The Docker image is built using 'docker build', then run with 'docker run' mapping port 8000 to the host. This allows accessing the Django app in a browser at localhost:8000. The container runs until stopped by the user. Key points include caching dependencies by copying requirements.txt first, using 0.0.0.0 to listen on all interfaces, and port mapping to expose the app outside the container.