Building images with docker build - Step-by-Step Execution

Process Flow - Building images with docker build

Write Dockerfile

↓

Run 'docker build'

↓

Docker reads Dockerfile

↓

Execute each instruction step-by-step

↓

Create image layers

↓

Tag image with name:tag

↓

Image ready to use

This flow shows how Docker reads your Dockerfile, executes each instruction to create layers, and builds a final image tagged for use.

Execution Sample

Docker

FROM alpine:3.18
RUN apk add --no-cache curl
CMD ["curl", "--version"]

This Dockerfile builds an image based on Alpine Linux, installs curl, and sets the default command to show curl version.

Process Table

Step	Dockerfile Instruction	Action	Result	Image Layer Created
1	FROM alpine:3.18	Pull base image alpine:3.18 if not local	Base image alpine:3.18 ready	Layer 1: base alpine
2	RUN apk add --no-cache curl	Run apk command inside container	curl installed in image	Layer 2: curl installed
3	CMD ["curl", "--version"]	Set default command for container	Default command set	No new layer (metadata)
4	docker build completes	Image built and tagged	Image ready to run	Final image composed of layers 1 and 2 plus metadata

💡 All Dockerfile instructions processed, image built successfully

Status Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
Image Layers	[]	[base alpine]	[base alpine, curl installed]	[base alpine, curl installed]	[base alpine, curl installed]
Default Command	None	None	None	["curl", "--version"]	["curl", "--version"]

Key Moments - 3 Insights

Why does the CMD instruction not create a new image layer?

CMD sets metadata for the container's default command and does not change the filesystem, so no new layer is created. See execution_table step 3.

What happens if the base image alpine:3.18 is already on the system?

Docker skips pulling the base image and uses the local copy, speeding up build. This is implied in execution_table step 1.

How does Docker build handle each RUN instruction?

Each RUN instruction executes commands inside a temporary container and commits the changes as a new image layer. See execution_table step 2.

Visual Quiz - 3 Questions

Look at the execution table, what image layers exist after step 2?

A [base alpine]

B [base alpine, curl installed]

C [curl installed]

D No layers created yet

💡 Hint

Check the 'Image Layer Created' column for step 2 in the execution_table

At which step does Docker set the default command for the container?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look at the 'Dockerfile Instruction' and 'Action' columns in execution_table

If you add another RUN instruction after step 2, how would the variable 'Image Layers' change after that step?

A It stays the same

B The base alpine layer is replaced

C A new layer is added to the list

D The default command changes

💡 Hint

Refer to variable_tracker and key_moments about RUN instructions creating new layers

Concept Snapshot

docker build reads a Dockerfile line by line
Each instruction creates a new image layer except metadata commands like CMD
RUN executes commands inside a container and commits changes as a layer
FROM sets the base image
The final image is tagged and ready to run containers

Full Transcript

Building images with docker build starts by writing a Dockerfile with instructions like FROM, RUN, and CMD. When you run 'docker build', Docker reads the Dockerfile step-by-step. It pulls the base image if needed, then executes RUN commands inside temporary containers, creating new image layers for each. CMD sets the default command but does not create a new layer. After processing all instructions, Docker combines the layers and metadata into a final image tagged for use. This process allows you to create custom images with your software and settings ready to run.