Layer caching and ordering in Docker - Step-by-Step Execution

Process Flow - Layer caching and ordering

Start Dockerfile

↓

Read first instruction

↓

Check cache for layer

↓

Use cached

↓

Add layer to image

↓

Next instruction?

No→Finish image

Yes↓

Repeat for next instruction

Docker reads each instruction, checks if a cached layer exists, reuses it if yes, otherwise builds a new layer, then moves to the next instruction.

Execution Sample

Docker

FROM python:3.12
RUN pip install flask
COPY app.py /app/
RUN pip install requests
CMD ["python", "/app/app.py"]

This Dockerfile installs Flask, copies app.py, installs requests, then runs the app.

Process Table

Step	Instruction	Cache Hit?	Action	Image Layers Count
1	FROM python:3.12	No	Build base python image layer	1
2	RUN pip install flask	No	Run pip install flask, create new layer	2
3	COPY app.py /app/	No	Copy app.py into image, create new layer	3
4	RUN pip install requests	No	Run pip install requests, create new layer	4
5	CMD ["python", "/app/app.py"]	No	Execute CMD instruction (no new layer)	4
6	End of Dockerfile		Image build complete	4

💡 All instructions processed; final image has 4 layers.

Status Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
Image Layers Count	0	1	2	3	4	4
Cache Hit	N/A	No	No	No	No	No

Key Moments - 3 Insights

Why no cache hits in this build?

This simulates a first-time build with no prior cache available. Docker executes all instructions and creates layers from scratch. In subsequent identical builds, cache hits would occur for matching instructions.

What happens if we change app.py after building the image?

Docker will detect the COPY instruction changes and rebuild that layer and all layers after it (step 3 and onward), invalidating cache for those steps.

Why is layer ordering important for caching?

Because Docker caches layers in order, if an early layer changes, all following layers must be rebuilt (see execution_table steps 3 and 4). Placing frequently changing instructions later helps cache more layers.

Visual Quiz - 3 Questions

Look at the execution table, at which step does Docker first create a new layer?

A Step 2

B Step 1

C Step 3

D Step 5

💡 Hint

Check the 'Cache Hit?' and 'Action' columns for Step 1.

Look at the execution table, which step does NOT create a new layer (layers count unchanged)?

A Step 5

B Step 4

C Step 2

D Step 3

💡 Hint

Look at the 'Image Layers Count' column; it stays 4.

If the COPY instruction changes, what happens to the layers after it?

A They are reused from cache

B Only the COPY layer rebuilds

C They are rebuilt

D Build stops immediately

💡 Hint

Refer to the key moment about layer ordering and cache invalidation.

Concept Snapshot

Docker builds images layer by layer.
Certain instructions (e.g., RUN, COPY) create a new layer.
Docker caches layers to speed up builds.
If an instruction or its inputs change, following layers rebuild.
Order instructions to maximize cache reuse.
Use COPY late if files change often.

Full Transcript

Docker builds images by reading each instruction in the Dockerfile one by one. For each instruction, it checks if a matching cached layer exists. If yes, Docker reuses that layer to save time. If no, it runs the instruction and creates a new layer. This process repeats until all instructions are processed. The order of instructions matters because if an early layer changes, all layers after it must be rebuilt. For example, installing packages early and copying files later helps reuse cache better. The CMD instruction often hits cache because it usually doesn't change the image contents. Understanding this helps optimize Docker builds for speed.