Development vs production Dockerfiles - Visual Side-by-Side Comparison

Process Flow - Development vs production Dockerfiles

Start: Write Dockerfile

↓

Choose environment

↓

Development

↓

Add dev tools

↓

Build dev image

↓

Run with debug

↓

Test & Debug

Shows the flow of creating Dockerfiles for development and production environments, highlighting different steps and goals.

Execution Sample

Docker

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

A simple Dockerfile that copies app code, installs dependencies, and runs the app.

Process Table

Step	Dockerfile Type	Action	Effect	Resulting Image Size
1	Development	Use full python:3.12 image	Includes dev tools and debugging	Large (~1GB)
2	Development	Copy all source code	Full app code available	No size change
3	Development	Install all dependencies	Ready to run with debug	Medium increase
4	Development	Set CMD to run app with debug	Container runs with debug mode	No size change
5	Production	Use python:3.12-slim image	Smaller base image	Small (~200MB)
6	Production	Copy only necessary files	Exclude tests and docs	Smaller size
7	Production	Install only runtime dependencies	No dev tools installed	Smaller increase
8	Production	Set CMD to run app normally	Runs app without debug	No size change
9	Exit	Build complete	Images ready for respective environments	-

💡 Both Dockerfiles built; development image is larger with debug tools, production image is smaller and optimized.

Status Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	After Step 7	Final
Image Size	Base size	Base + source code	Base + source + deps	Slim base size	Slim base + runtime deps	Final image size
Debug Tools	None	Included in dev image	Included	None	None	Only in dev image
Source Code	None	Full copy	Full copy	Partial copy	Partial copy	Full in dev, partial in prod

Key Moments - 3 Insights

Why is the development image much larger than the production image?

Because the development Dockerfile includes full Python with dev tools and copies all source code, as shown in execution_table rows 1-4, increasing size.

Why do we copy fewer files in the production Dockerfile?

To keep the image small and secure by excluding tests and docs, as shown in execution_table row 6.

Why do we install fewer dependencies in production?

Production installs only runtime dependencies to reduce size and surface area, as shown in execution_table row 7.

Visual Quiz - 3 Questions

Look at the execution table, what is the image size after step 5 in the production Dockerfile?

A Large (~1GB)

B Small (~200MB)

C Medium increase

D No size change

💡 Hint

Check the 'Resulting Image Size' column at step 5 for production Dockerfile.

At which step does the development Dockerfile set the command to run the app with debug?

A Step 4

B Step 3

C Step 2

D Step 6

💡 Hint

Look at the 'Action' column for development Dockerfile steps in the execution table.

If we copied all files in production like in development, how would the image size change?

A It would stay the same

B It would become smaller

C It would become larger

D It would become zero

💡 Hint

Refer to variable_tracker row 'Image Size' comparing after step 2 and step 6.

Concept Snapshot

Development Dockerfile:
- Uses full image with dev tools
- Copies all source code
- Installs all dependencies
- Runs app with debug

Production Dockerfile:
- Uses slim image
- Copies only needed files
- Installs runtime dependencies only
- Runs app normally

Goal: Dev for debugging, Prod for small, fast, secure image.

Full Transcript

This visual execution compares development and production Dockerfiles. Development Dockerfiles use a full Python image with debugging tools, copy all source code, and install all dependencies, resulting in a larger image. Production Dockerfiles use a slim base image, copy only necessary files, and install only runtime dependencies, making the image smaller and optimized. The execution table shows step-by-step actions and their effects on image size and content. Variable tracking highlights how image size and included tools change. Key moments clarify why development images are larger and why production images exclude extra files and dependencies. The quiz tests understanding of image sizes, commands, and file copying differences. The snapshot summarizes the main differences and goals for each Dockerfile type.