Docker containerization in Django - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to specify the base image in a Dockerfile for a Django app.

Django

FROM [1]

Drag options to blanks, or click blank then click option'

Apython:3.12-slim

Bnode:latest

Cubuntu:20.04

Dnginx:alpine

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing a Node.js or Nginx image which are not for Python apps.

Using a full Ubuntu image which is larger and less specific.

The base image python:3.12-slim is suitable for running Django apps with Python 3.12.

2fill in blank

medium

Complete the command to install Django inside the Docker container.

Django

RUN pip install [1]

Drag options to blanks, or click blank then click option'

Anumpy

Bflask

Crequests

Ddjango

Attempts:

3 left

💡 Hint

Common Mistakes

Installing Flask instead of Django.

Installing unrelated packages like requests or numpy.

We install django because it is the framework we want to run inside the container.

3fill in blank

hard

Fix the error in the Dockerfile command to copy the project files.

Django

COPY [1] /app/

Drag options to blanks, or click blank then click option'

Arequirements.txt

Bsrc

C.

DDockerfile

Attempts:

3 left

💡 Hint

Common Mistakes

Copying only requirements.txt or Dockerfile which misses other files.

Copying a folder named src which may not exist.

Using . copies all files from the current directory into the container's /app/ folder.

4fill in blank

hard

Fill both blanks to expose the Django default port and set the working directory.

Django

EXPOSE [1]
WORKDIR [2]

Drag options to blanks, or click blank then click option'

A8000

B/app

C/usr/src/app

D8080

Attempts:

3 left

💡 Hint

Common Mistakes

Exposing port 8080 which is not Django's default.

Setting working directory to a path not used in the Dockerfile.

Django's default development server runs on port 8000, and setting WORKDIR /app sets the working directory inside the container.

5fill in blank

hard

Fill all three blanks to run the Django development server with correct options.

Django

CMD ["python", "[1]", "[2]", "0.0.0.0:[3]"]

Drag options to blanks, or click blank then click option'

Apython

Bmanage.py

C8000

Drunserver

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'runserver' as the first argument instead of 'python'.

Using port 8080 instead of 8000.

Omitting 'manage.py' which is required to run Django commands.

The command runs python manage.py runserver 0.0.0.0:8000 to start the Django server accessible from outside 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