Minimizing layers in Docker - Commands & Configuration

Introduction

Docker images are made of layers created by each command in a Dockerfile. Minimizing layers helps keep images smaller and faster to download and run.

When you want your Docker images to use less disk space on your computer or server

When you need to speed up the time it takes to build and push images to a registry

When you want to reduce the time it takes to pull images on other machines

When you want to keep your Docker images clean and easier to manage

When you want to avoid unnecessary layers that increase image size without adding value

Config File - Dockerfile

Dockerfile

FROM python:3.11-slim

# Combine update and install in one RUN to minimize layers
RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*

# Set working directory
WORKDIR /app

# Copy application code
COPY app.py /app/app.py

# Run the application
CMD ["python", "app.py"]

FROM: sets the base image.

RUN: combines update and install commands with cleanup in one layer to reduce image size.

WORKDIR: sets the working directory inside the container.

COPY: adds application code.

CMD: defines the command to run the app.

Commands

Builds the Docker image named 'my-app' with tag '1.0' using the Dockerfile in the current directory. This creates the image with minimized layers as defined.

Terminal

docker build -t my-app:1.0 .

Expected Output

Sending build context to Docker daemon  3.07kB

Step 1/6 : FROM python:3.11-slim

 ---> 3a1b2c3d4e5f

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

 ---> Using cache

 ---> 7f8e9d0a1b2c

Step 3/6 : WORKDIR /app

 ---> Using cache

 ---> 1a2b3c4d5e6f

Step 4/6 : COPY app.py /app/app.py

 ---> Using cache

 ---> 9a8b7c6d5e4f

Step 5/6 : CMD ["python", "app.py"]

 ---> Using cache

 ---> 0f1e2d3c4b5a

Successfully built 0f1e2d3c4b5a

Successfully tagged my-app:1.0

Shows the details of the built image to verify its size and tag.

Terminal

docker images my-app:1.0

Expected Output

REPOSITORY   TAG      IMAGE ID       CREATED         SIZE

my-app       1.0      0f1e2d3c4b5a   2 minutes ago   120MB

Displays the layers of the image to confirm that the number of layers is minimized.

Terminal

docker history my-app:1.0

Expected Output

IMAGE          CREATED         CREATED BY                                      SIZE      COMMENT

0f1e2d3c4b5a   2 minutes ago   CMD ["python" "app.py"]                        0B        

1a2b3c4d5e6f   2 minutes ago   WORKDIR /app                                    0B        

9a8b7c6d5e4f   2 minutes ago   COPY app.py /app/app.py                          1.2kB     

7f8e9d0a1b2c   2 minutes ago   RUN apt-get update && apt-get install -y curl…  45MB      

3a1b2c3d4e5f   3 days ago      FROM python:3.11-slim                            75MB      

Key Concept

Each command in a Dockerfile creates a layer, so combining commands reduces the total layers and image size.

Common Mistakes

Using multiple RUN commands for related tasks like update and install separately

Each RUN creates a new layer, increasing image size unnecessarily

Combine related commands with && in a single RUN to create one layer

Not cleaning up temporary files after package installation

Temporary files remain in the layer, making the image larger

Remove cache or temporary files in the same RUN command after installation

Summary

Docker images are built in layers, one per command in the Dockerfile.

Combining commands like update and install in one RUN reduces layers and image size.

Cleaning up temporary files in the same RUN command keeps images smaller and cleaner.

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