Image layers concept in Docker - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Docker image layers

Which statement best describes Docker image layers?

A Layers are stacked read-only filesystems that build the final image.

B Layers are temporary and deleted after container creation.

C Each layer is a full copy of the entire image filesystem.

D Layers are only used for container runtime, not image building.

💡 Hint

Think about how Docker reuses parts of images to save space.

Docker images are made of stacked read-only layers. Each layer adds or modifies files. This stacking allows efficient storage and sharing.

💻 Command Output

intermediate

Inspecting image layers with Docker CLI

What is the output of the command docker history alpine?

Docker

docker history alpine

A A list showing image layers with size, creation time, and commands used.

B A list of running containers based on alpine image.

C The full Dockerfile used to build alpine image.

D An error stating 'alpine' image not found.

💡 Hint

Try to recall what docker history shows about images.

docker history lists the layers of an image, showing size, creation time, and commands that created each layer.

🔀 Workflow

advanced

Optimizing Dockerfile to reduce image layers

You want to reduce the number of layers in your Docker image. Which Dockerfile snippet achieves this best?

Docker

RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*

A RUN apt-get update; apt-get install -y curl; rm -rf /var/lib/apt/lists/*

B

RUN apt-get update
RUN apt-get install -y curl
RUN rm -rf /var/lib/apt/lists/*

C RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*

D

RUN apt-get update && apt-get install -y curl
RUN rm -rf /var/lib/apt/lists/*

💡 Hint

Think about how Docker creates a new layer for each RUN instruction.

Combining commands with && in a single RUN instruction creates only one layer, reducing image size.

❓ Troubleshoot

advanced

Diagnosing unexpected large Docker image size

Your Docker image is unexpectedly large. Which cause is most likely related to image layers?

A You used COPY instead of ADD for files.

B You used ENV variables in the Dockerfile.

C You did not specify a base image in the Dockerfile.

D You used multiple RUN commands that add temporary files without cleanup.

💡 Hint

Think about how layers keep all changes, even deleted files if not cleaned properly.

Each RUN creates a layer. If temporary files are created and not removed in the same RUN, they remain in the layer, increasing image size.

✅ Best Practice

expert

Choosing the best practice for layer caching in Docker builds

Which Dockerfile practice best leverages layer caching to speed up rebuilds?

A Place frequently changing commands at the top of the Dockerfile.

B Order commands from least to most frequently changing to maximize cache reuse.

C Combine all commands into one RUN instruction regardless of change frequency.

D Avoid using COPY or ADD commands to prevent cache invalidation.

💡 Hint

Think about how Docker caches layers and when cache is invalidated.

Docker caches layers in order. If a layer changes, all following layers are rebuilt. Ordering commands from least to most frequently changing maximizes cache reuse.

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