Minimizing layers in Docker - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why minimize layers in a Docker image?

What is the main benefit of minimizing the number of layers in a Docker image?

A It reduces the final image size and improves build speed

B It increases the number of containers that can run simultaneously

C It allows running containers without root privileges

D It automatically updates the base image to the latest version

💡 Hint

Think about how Docker stores image data and how layers affect storage.

Each Dockerfile command creates a new layer. Fewer layers mean less overhead and smaller images, which speeds up builds and deployments.

💻 Command Output

intermediate

Output of combined RUN commands

What will be the size difference between these two Dockerfiles after building?

Dockerfile A:

FROM alpine
RUN apk add curl
RUN apk add git

Dockerfile B:

FROM alpine
RUN apk add curl && apk add git

A Dockerfile B will have a smaller image size because it creates fewer layers

B Dockerfile B will fail to build due to syntax error

C Both images will have the same size because the packages installed are identical

D Dockerfile A will have a smaller image size because it separates commands

💡 Hint

Consider how Docker layers are created for each RUN command.

Dockerfile A creates two layers for two RUN commands. Dockerfile B combines them into one RUN command, creating one layer, which reduces image size.

❓ Configuration

advanced

Correct Dockerfile to minimize layers and clean cache

Which Dockerfile snippet correctly installs packages and cleans cache in a single layer to minimize image size?

A

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

B

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

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

D */stsil/tpa/bil/rav/ fr- mr && tig lruc y- llatsni teg-tpa && etadpu teg-tpa NUR

💡 Hint

Think about how to combine commands to avoid extra layers and clean cache in the same layer.

Option C combines update, install, and cleanup in one RUN command, creating a single layer and reducing image size. Options A and B create multiple layers. Option C uses semicolons which work but is less common and may cause issues in some shells.

❓ Troubleshoot

advanced

Why does this Docker image grow unexpectedly large?

A developer wrote this Dockerfile snippet:

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

Why does the final image size remain large despite cleaning the cache?

A Because the base image is too large to reduce

B Because each RUN creates a new layer, the cache files remain in previous layers

C Because apt-get install does not actually install curl in this syntax

D Because rm -rf command is incorrect and does not delete files

💡 Hint

Think about how Docker layers store filesystem changes.

Each RUN command creates a new layer. Even if cache files are deleted in a later layer, they still exist in earlier layers, so the image size does not reduce.

🔀 Workflow

expert

Optimal Dockerfile layering order for build cache efficiency

Given these Dockerfile commands, which order minimizes rebuild time when only application code changes?

1. COPY package.json /app/
2. RUN npm install
3. COPY . /app

A RUN npm install → COPY package.json /app/ → COPY . /app

B COPY . /app → COPY package.json /app/ → RUN npm install

C COPY . /app → RUN npm install → COPY package.json /app/

D COPY package.json /app/ → RUN npm install → COPY . /app

💡 Hint

Consider which files change frequently and how Docker caches layers.

Copying package.json and running npm install first caches dependencies. Then copying the rest of the code allows rebuilds without reinstalling packages if only app code changes.

Practice

1. Why is it important to minimize the number of layers in a Docker image?

easy

A. Because more layers increase the number of containers you can run

B. Because fewer layers make the image smaller and faster to build and run

C. Because layers determine the number of CPUs used by the container

D. Because layers control the network speed of the container

Solution

1. Step 1: Understand what layers are in Docker images

   Each command in a Dockerfile creates a new layer that adds to the image size.

2. Step 2: Recognize the effect of fewer layers

   Fewer layers mean less image size and faster build and startup times.

3. Final Answer:

   Because fewer layers make the image smaller and faster to build and run -> Option B

4. Quick Check:

   Minimizing layers = smaller, faster images [OK]

Hint: Less layers = smaller image size and faster builds [OK]

Common Mistakes:

• Thinking layers affect CPU or network speed
• Believing more layers improve container count
• Confusing layers with container limits

2. Which of the following Dockerfile RUN commands minimizes layers correctly?

easy

A. RUN apt-get update && apt-get install -y curl
RUN 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
RUN rm -rf /var/lib/apt/lists/*

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

Solution

1. Step 1: Identify how RUN commands create layers

   Each RUN line creates a new layer, so combining commands with && keeps one layer.

2. Step 2: Check which option combines commands in one RUN

   RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/* uses && to combine all commands in one RUN, minimizing layers.

3. Final Answer:

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

4. Quick Check:

   Combine commands with && in one RUN [OK]

Hint: Use && to chain commands in one RUN line [OK]

Common Mistakes:

• Using multiple RUN lines instead of one
• Using semicolons without && which may not stop on error
• Splitting cleanup into separate RUN commands

3. Given this Dockerfile snippet, how many layers will be created?

FROM ubuntu:latest
RUN apt-get update && apt-get install -y git
RUN rm -rf /var/lib/apt/lists/*
RUN echo "Done"

medium

A. 2 layers

B. 3 layers

C. 4 layers

D. 1 layer

Solution

1. Step 1: Count layers created by each RUN command

   Each RUN command creates one layer. There are three RUN commands here.

2. Step 2: Note that FROM references the base image

   The FROM uses pre-existing base image layers; it does not create new ones. Layers created: 3 from RUNs plus 1 for the base image.

3. Final Answer:

   4 layers -> Option C

4. Quick Check:

   Count RUN commands + base image layer = 4 [OK]

Hint: Each RUN adds a layer; count the RUN commands plus base image [OK]

Common Mistakes:

• Adding a layer for the base image FROM
• Assuming multiple commands in one RUN create multiple layers
• Forgetting to count all three RUN commands

4. You have this Dockerfile snippet:

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

What is the best way to fix it to minimize layers?

medium

A. Combine all commands into one RUN line using &&

B. Add a separate RUN line to clean cache after install

C. Use multiple RUN lines but add comments

D. Remove the cleanup command entirely

Solution

1. Step 1: Identify the problem of multiple RUN lines

   Each RUN creates a layer, so three RUN lines create three layers.

2. Step 2: Combine commands to reduce layers

   Using one RUN line with && chains commands into a single layer.

3. Final Answer:

   Combine all commands into one RUN line using && -> Option A

4. Quick Check:

   One RUN with && reduces layers [OK]

Hint: Put all commands in one RUN with && to reduce layers [OK]

Common Mistakes:

• Keeping multiple RUN lines
• Removing cleanup causing larger images
• Adding comments but not reducing layers

5. You want to install Node.js and clean up temporary files in a Dockerfile. Which Dockerfile snippet minimizes layers and keeps the image small?

Option A:
RUN curl -fsSL https://deb.nodesource.com/setup_18.x | bash -
RUN apt-get install -y nodejs
RUN apt-get clean
RUN rm -rf /var/lib/apt/lists/*

Option B:
RUN curl -fsSL https://deb.nodesource.com/setup_18.x | bash - && apt-get install -y nodejs && apt-get clean && rm -rf /var/lib/apt/lists/*

Option C:
RUN curl -fsSL https://deb.nodesource.com/setup_18.x | bash -; apt-get install -y nodejs
RUN apt-get clean && rm -rf /var/lib/apt/lists/*

Option D:
RUN curl -fsSL https://deb.nodesource.com/setup_18.x | bash - && apt-get install -y nodejs
RUN apt-get clean
RUN rm -rf /var/lib/apt/lists/*

hard

A. Combine all commands in one RUN line with &&

B. Use multiple RUN lines for each command

C. Split install and cleanup into two RUN lines

D. Combine install commands but separate cleanup

Solution

1. Step 1: Understand that each RUN creates a layer

   Multiple RUN lines create multiple layers, increasing image size.

2. Step 2: Combine all commands with && in one RUN

   Combine all commands in one RUN line with && chains all commands in one RUN, minimizing layers and cleaning up in the same layer.

3. Final Answer:

   Combine all commands in one RUN line with && -> Option A

4. Quick Check:

   One RUN with all commands chained = minimal layers [OK]

Hint: Chain all install and cleanup commands in one RUN [OK]

Common Mistakes:

• Splitting install and cleanup into separate RUN lines
• Not cleaning temporary files in the same layer
• Using semicolons instead of && which may not stop on errors