Minimizing layers in Docker - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the Dockerfile line to start from the official Python image.

Docker

FROM [1]

Drag options to blanks, or click blank then click option'

Aalpine:3.18

Bnode:18

Cpython:3.12-slim

Dubuntu:latest

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing a non-Python base image like Ubuntu or Node.

The FROM instruction sets the base image. Using python:3.12-slim starts from a minimal Python image.

2fill in blank

medium

Complete the RUN command to update package lists in one layer.

Docker

RUN apt-get update && apt-get [1] -y curl

Drag options to blanks, or click blank then click option'

Aupgrade

Binstall

Cremove

Dclean

Attempts:

3 left

💡 Hint

Common Mistakes

Using upgrade or remove instead of install.

The command apt-get install -y installs packages without asking for confirmation, combined with update in one layer.

3fill in blank

hard

Fix the error in combining commands to minimize layers.

Docker

RUN apt-get update [1] apt-get install -y curl

Drag options to blanks, or click blank then click option'

A||

B;

C|

D&&

Attempts:

3 left

💡 Hint

Common Mistakes

Using semicolon or pipe which do not ensure success before next command.

The && operator ensures the second command runs only if the first succeeds, combining commands in one layer.

4fill in blank

hard

Fill both blanks to combine copying files and installing dependencies in one RUN command.

Docker

COPY requirements.txt /app/requirements.txt
RUN pip [2] -r /app/requirements.txt [1] rm /app/requirements.txt

Drag options to blanks, or click blank then click option'

A&&

Binstall

Cupdate

D&&&

Attempts:

3 left

💡 Hint

Common Mistakes

Using invalid separators or wrong pip commands.

Use && to chain commands and pip install to install dependencies.

5fill in blank

hard

Fill all three blanks to create a minimal Dockerfile that installs curl and cleans cache in one RUN.

Docker

FROM python:3.12-slim
RUN apt-get update [1] apt-get install -y [2] [3] apt-get clean

Drag options to blanks, or click blank then click option'

A&&

Bcurl

D|

Attempts:

3 left

💡 Hint

Common Mistakes

Using pipe instead of &&, or missing package name.

Use && to chain commands safely and install curl before cleaning cache.

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