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.