Minimizing layers in Docker - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a layer in a Docker image?

A layer is a set of filesystem changes created by each command in a Dockerfile. Layers stack to form the final image.

beginner

Why should you minimize layers in a Docker image?

Fewer layers mean smaller image size, faster builds, and quicker downloads, making containers more efficient.

intermediate

How can you combine commands to reduce layers in a Dockerfile?

Use the shell's '&&' to join commands in a single RUN instruction, so they create only one layer.

intermediate

What is the effect of using multiple RUN commands versus a single RUN command with combined commands?

Multiple RUN commands create multiple layers; combining commands in one RUN creates a single layer, reducing total layers.

beginner

Give an example of minimizing layers by combining commands in a Dockerfile.

Instead of: RUN apt-get update RUN apt-get install -y curl Use: RUN apt-get update && apt-get install -y curl

What happens when you use multiple RUN commands in a Dockerfile?

A RUN commands do not affect layers

B Each RUN command creates a new layer

C All RUN commands combine into one layer automatically

D RUN commands delete previous layers

Each RUN command creates a new layer in the Docker image.

Which method helps reduce the number of layers in a Docker image?

A Using COPY instead of RUN

B Using multiple RUN commands separately

C Combining commands with '&&' in a single RUN

D Adding comments between RUN commands

Combining commands with '&&' in one RUN instruction creates only one layer.

Why is minimizing layers important in Docker images?

A It makes images smaller and faster to build and download

B It increases image size for better performance

C It disables caching

D It makes images incompatible with Docker Hub

Fewer layers reduce image size and improve build and download speed.

Which Dockerfile instruction creates a new layer?

A RUN

B ENV

C LABEL

D ARG

RUN creates a new layer; ENV, LABEL, and ARG do not create layers.

What is a simple way to clean up temporary files in the same layer to minimize layers?

A Use COPY instead of RUN

B Remove files in a separate RUN command

C Ignore temporary files

D Remove files in the same RUN command after use

Cleaning files in the same RUN command keeps the layer small and avoids extra layers.

Explain how minimizing layers in a Dockerfile improves container efficiency.

Think about how layers affect image size and build speed.

Describe a practical way to reduce layers when installing software in a Dockerfile.

Focus on how to write RUN commands efficiently.

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