Development container patterns in Docker - Step-by-Step Execution

Process Flow - Development container patterns

Start: Define base image

↓

Add dependencies & tools

↓

Set working directory

↓

Copy source code

↓

Expose ports & volumes

↓

Define entrypoint or command

↓

Build container image

↓

Run container for development

↓

Code changes reflected via mounted volume

↓

Debug & test inside container

↓

Stop container when done

This flow shows how a development container is built step-by-step, from base image to running with live code changes.

Execution Sample

Docker

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

This Dockerfile sets up a Python development container with dependencies installed and runs the app.

Process Table

Step	Dockerfile Instruction	Action	Resulting Image State	Notes
1	FROM python:3.12-slim	Set base image	Image starts from python 3.12 slim	Base OS and Python ready
2	WORKDIR /app	Set working directory	Working directory set to /app	Commands run inside /app
3	COPY requirements.txt ./	Copy requirements file	requirements.txt available in /app	Needed for dependency install
4	RUN pip install -r requirements.txt	Install dependencies	Python packages installed	App dependencies ready
5	COPY . ./	Copy source code	All app files copied to /app	App code ready to run
6	CMD ["python", "app.py"]	Set default command	Container runs python app.py on start	Defines container behavior
7	docker build -t dev-container .	Build image	Image named dev-container created	Ready to run container
8	docker run -v $(pwd):/app -p 5000:5000 dev-container	Run container with volume and port	Container runs with live code sync	Code changes reflect immediately
9	Modify code on host	Edit source files	Changes appear inside container	Live development enabled
10	Stop container	End session	Container stops running	Development session ends

💡 Container stops when developer finishes coding or testing

Status Tracker

Variable	Start	After Step 3	After Step 5	After Step 8	Final
Image Layers	Empty	Base python:3.12-slim	Added requirements.txt and source code	Built image with all files and dependencies	Image ready for development
Container State	Not running	Not running	Not running	Running with volume mounted	Stopped after development

Key Moments - 3 Insights

Why do we mount the source code as a volume instead of copying it only once?

Mounting the source code as a volume (see step 8) allows live code changes on the host to immediately appear inside the container without rebuilding the image (step 5 only copies once). This enables fast development feedback.

What happens if we don't set the working directory with WORKDIR?

Without WORKDIR (step 2), commands like COPY and RUN might place files or run in unexpected locations, making the container harder to manage. Setting WORKDIR ensures all actions happen inside /app.

Why do we separate installing dependencies from copying source code?

Separating RUN pip install (step 4) from copying source code (step 5) helps Docker cache dependencies. If source code changes but requirements.txt doesn't, Docker reuses the cached layer, speeding up builds.

Visual Quiz - 3 Questions

Look at the execution table at step 8. What is the main benefit of running the container with the volume option?

A The container image size is reduced

B Code changes on the host immediately reflect inside the container

C The container runs faster without dependencies

D The container automatically restarts on failure

💡 Hint

Check the 'Resulting Image State' and 'Notes' columns at step 8 in the execution table

At which step does the container image get created and ready to run?

A Step 7

B Step 5

C Step 3

D Step 9

💡 Hint

Look for the 'docker build' command in the execution table

If we remove the WORKDIR instruction, what would likely happen?

A The container would run faster

B Dependencies would not install

C Files might be copied to unexpected locations

D The container would not start

💡 Hint

Refer to the key moment about WORKDIR and step 2 in the execution table

Concept Snapshot

Development container patterns:
- Use a base image (e.g., python:3.12-slim)
- Set WORKDIR for consistent paths
- Copy dependencies file and install them
- Copy source code separately
- Use volumes to sync live code changes
- Define CMD or ENTRYPOINT to run app
- Build and run container with port and volume mappings
- Enables fast, isolated development environment

Full Transcript

Development container patterns involve creating a container image starting from a base image like python:3.12-slim. We set a working directory to keep commands organized. We copy the dependencies file and install packages before copying the full source code. This separation helps caching and speeds up rebuilds. When running the container, we mount the source code as a volume so that changes on the host immediately reflect inside the container, enabling live development. The container runs the app using a defined command. This pattern creates an isolated, reproducible environment for coding, testing, and debugging without affecting the host system.