Image layers concept in Docker - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a Docker image layer?

A Docker image layer is a read-only file system change that represents a step in the image build process. Layers stack on top of each other to form the final image.

beginner

How do Docker image layers help with efficiency?

Docker image layers allow reusing unchanged layers across images, saving disk space and speeding up downloads and builds.

intermediate

What happens if you change a file in a Docker image layer?

A new layer is created with the change. The previous layers remain unchanged and are reused if possible.

intermediate

Why is the order of commands in a Dockerfile important for image layers?

Because each command creates a new layer, ordering commands to minimize changes in early layers helps reuse cached layers and speeds up builds.

beginner

Can you modify a Docker image layer after it is created?

No, Docker image layers are immutable. Changes create new layers on top of existing ones.

What does each Docker image layer represent?

A A network configuration

B A running container

C A change or instruction in the Dockerfile

D A user session

Each layer corresponds to a Dockerfile instruction that changes the image.

Why are Docker image layers immutable?

A To allow caching and reuse of layers

B To allow editing layers directly

C To prevent image creation

D To slow down builds

Immutability allows Docker to cache and reuse layers efficiently.

What happens if you reorder commands in a Dockerfile?

A It has no effect

B It deletes all layers

C It changes the container runtime

D It can affect build speed and cache usage

Reordering commands can improve or reduce cache reuse, affecting build speed.

How does Docker save disk space with image layers?

A By sharing unchanged layers between images

B By deleting old images automatically

C By compressing containers

D By running fewer containers

Docker shares layers that are the same across images to save space.

If you change a file in a Docker image, what does Docker do?

A Modifies the existing layer

B Creates a new layer with the change

C Deletes the image

D Restarts the container

Docker adds a new layer on top with the file change; existing layers stay unchanged.

Explain how Docker image layers work and why they are important.

Think about how changes in a Dockerfile create layers and how Docker uses them.

Describe the impact of Dockerfile command order on image layers and build efficiency.

Consider how Docker caches layers and how changing commands affects this.

Practice

1. What does each layer in a Docker image represent?

easy

A. A user account inside the container

B. A separate container running inside Docker

C. A network connection between containers

D. A change made by a single Dockerfile command

Solution

1. Step 1: Understand Dockerfile commands

   Each command in a Dockerfile creates a change in the image.

2. Step 2: Connect changes to layers

   Docker saves each change as a separate layer to reuse if unchanged.

3. Final Answer:

   A change made by a single Dockerfile command -> Option D

4. Quick Check:

   Layer = Dockerfile command change [OK]

Hint: Think of layers as snapshots after each Dockerfile step [OK]

Common Mistakes:

• Confusing layers with running containers
• Thinking layers are user accounts
• Believing layers are network connections

2. Which Dockerfile command creates a new image layer?

easy

A. START

B. ENVIRONMENT

C. RUN

D. COPYFILE

Solution

1. Step 1: Identify valid Dockerfile commands

   RUN is a valid Dockerfile command to execute commands in the image.

2. Step 2: Check other options

   ENVIRONMENT, COPYFILE, and START are not valid Dockerfile commands.

3. Final Answer:

   RUN -> Option C

4. Quick Check:

   RUN creates layers [OK]

Hint: Only standard Dockerfile commands create layers [OK]

Common Mistakes:

• Using incorrect or non-existent Dockerfile commands
• Confusing ENVIRONMENT with ENV
• Thinking COPYFILE is a Docker command

3. Given this Dockerfile snippet:

FROM ubuntu
RUN apt-get update
RUN apt-get install -y curl
COPY . /app

How many layers will this image have (excluding the base image)?

medium

A. 3

B. 2

C. 1

D. 4

Solution

1. Step 1: Count commands creating layers

   RUN apt-get update, RUN apt-get install -y curl, and COPY . /app each create a layer.

2. Step 2: Exclude base image layer

   FROM ubuntu is the base image, not counted here.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   3 commands create layers [OK]

Hint: Count RUN, COPY, ADD commands for layers [OK]

Common Mistakes:

• Counting FROM as a new layer
• Ignoring COPY command creates a layer
• Miscounting number of RUN commands

4. You notice your Docker image size is very large. Which Dockerfile practice can help reduce image layers and size?

medium

A. Combine multiple RUN commands into one using &&

B. Add a new RUN command for each small step

C. Use multiple COPY commands for each file

D. Use FROM multiple times in one Dockerfile

Solution

1. Step 1: Understand layer creation

   Each RUN command creates a new layer, increasing image size.

2. Step 2: Combine commands to reduce layers

   Using && to combine commands in one RUN reduces layers and image size.

3. Final Answer:

   Combine multiple RUN commands into one using && -> Option A

4. Quick Check:

   Fewer RUN commands = fewer layers [OK]

Hint: Merge RUN commands with && to shrink layers [OK]

Common Mistakes:

• Adding many small RUN commands
• Using multiple COPY commands unnecessarily
• Misusing multiple FROM commands in one Dockerfile

5. You want to optimize a Docker image build where a large file changes frequently. Which approach best minimizes rebuild time and image size?

hard

A. Place COPY of the large file at the start of the Dockerfile

B. Place COPY of the large file at the end of the Dockerfile

C. Combine COPY of the large file with RUN commands in one layer

D. Avoid using COPY and download the file inside RUN

Solution

1. Step 1: Understand layer caching

   Docker caches layers; if a layer changes, later layers rebuild.

2. Step 2: Place frequently changing files last

   Putting COPY of large changing files last limits rebuild to that layer only.

3. Final Answer:

   Place COPY of the large file at the end of the Dockerfile -> Option B

4. Quick Check:

   Last COPY limits rebuild scope [OK]

Hint: Put changing files COPY last to speed rebuilds [OK]

Common Mistakes:

• Copying large files early causing full rebuilds
• Combining COPY with RUN causing bigger layers
• Downloading files inside RUN increasing image size