Image layers concept in Docker - Step-by-Step Execution

Process Flow - Image layers concept

Start Dockerfile

↓

Read first instruction

↓

Create first image layer

↓

Read next instruction

↓

Create next image layer

↓

Repeat for all instructions

↓

Final image = stack of layers

↓

Use image layers for caching & reuse

Docker reads each instruction in a Dockerfile and creates a separate image layer for it. These layers stack to form the final image, enabling caching and reuse.

Execution Sample

Docker

FROM ubuntu:20.04
RUN apt-get update
RUN apt-get install -y curl
COPY app.sh /app.sh
CMD ["/app.sh"]

This Dockerfile creates an image with Ubuntu base, updates packages, installs curl, copies a script, and sets the script as the container start command.

Process Table

Step	Dockerfile Instruction	Layer Created	Layer Description	Cache Used
1	FROM ubuntu:20.04	Layer 1	Base image layer with Ubuntu 20.04	No
2	RUN apt-get update	Layer 2	Updates package lists	No
3	RUN apt-get install -y curl	Layer 3	Installs curl package	No
4	COPY app.sh /app.sh	Layer 4	Copies app.sh script into image	No
5	CMD ["/app.sh"]	Layer 5	Sets default command to run app.sh	No
6	Build complete	-	Final image is stack of 5 layers	-

💡 All Dockerfile instructions processed; final image built as stacked layers

Status Tracker

Layer Number	Instruction	Layer Created
Start	-	No layers
After 1	FROM ubuntu:20.04	Layer 1 (Ubuntu base)
After 2	RUN apt-get update	Layer 2 (Package update)
After 3	RUN apt-get install -y curl	Layer 3 (Curl installed)
After 4	COPY app.sh /app.sh	Layer 4 (Script copied)
After 5	CMD ["/app.sh"]	Layer 5 (Command set)
Final	-	5 layers stacked as final image

Key Moments - 3 Insights

Why does Docker create a new layer for each instruction instead of one big layer?

Docker creates a new layer per instruction to enable caching and reuse. If a layer's instruction doesn't change, Docker reuses that layer from cache, speeding up builds (see execution_table rows 2-5).

What happens if I change the app.sh script and rebuild?

Only the COPY instruction layer (Layer 4) and layers after it will be rebuilt. Earlier layers like base image and package installs are reused from cache (see variable_tracker after step 4).

Does the CMD instruction create a big layer like RUN or COPY?

No, CMD just sets metadata for the container start command and creates a very small layer (see execution_table step 5). It doesn't add files or run commands.

Visual Quiz - 3 Questions

Look at the execution table, which step creates the layer that installs curl?

A Step 3

B Step 2

C Step 4

D Step 5

💡 Hint

Check the 'Dockerfile Instruction' column for 'RUN apt-get install -y curl' in execution_table

At which step does Docker finish building the final image?

A Step 5

B Step 4

C Step 6

D Step 3

💡 Hint

Look for the row with 'Build complete' in the execution_table

If you change the app.sh file and rebuild, which layer will Docker rebuild?

A Layer 2

B Layer 4

C Layer 1

D Layer 3

💡 Hint

Refer to key_moments answer about changing app.sh and which layer is affected

Concept Snapshot

Docker builds images by reading each Dockerfile instruction and creating a separate image layer.
Each layer stacks on top of the previous, forming the final image.
Layers enable caching: unchanged layers are reused to speed up builds.
RUN and COPY create layers with file system changes; CMD sets metadata.
Changing a file only rebuilds layers from that point onward.

Full Transcript

Docker images are built step-by-step from a Dockerfile. Each instruction like FROM, RUN, COPY, and CMD creates a separate image layer. These layers stack to form the final image. This layering helps Docker cache and reuse parts of the image if they don't change, making rebuilds faster. For example, installing packages creates one layer, copying files another. If you change a file, only the layers after that change are rebuilt. CMD sets the container start command but creates a small metadata layer. This visual trace shows each step creating a layer and how the final image is assembled.