Combining RUN commands in Docker - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

Output of combined RUN commands in Dockerfile

What will be the output of the following Dockerfile snippet when building the image?

FROM alpine:latest
RUN echo "Step 1" && echo "Step 2" && echo "Step 3"

Docker

FROM alpine:latest
RUN echo "Step 1" && echo "Step 2" && echo "Step 3"

A

Step 1
Step 2 && Step 3

B Step 1 Step 2 Step 3

C Step 1 && Step 2 && Step 3

D

Step 1
Step 2
Step 3

💡 Hint

Think about how the shell interprets the && operator inside a RUN command.

The && operator runs commands sequentially only if the previous command succeeds. Each echo prints its output on a new line, so the output will be three lines.

❓ Configuration

intermediate

Combining RUN commands to reduce image layers

Which Dockerfile snippet correctly combines multiple commands into a single RUN instruction to minimize image layers?

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

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

💡 Hint

Consider how combining commands with && affects image layers and command execution.

Using && chains commands so the next runs only if the previous succeeds, and combining them in one RUN creates a single image layer. Using multiple RUN instructions creates multiple layers. Using ; runs commands regardless of success, and & runs commands in background, which is not suitable here.

❓ Troubleshoot

advanced

Why does this combined RUN command fail?

Given this Dockerfile snippet, why does the build fail?

RUN apt-get update && apt-get install -y curl || exit 1 && echo "Done"

Docker

RUN apt-get update && apt-get install -y curl || exit 1 && echo "Done"

A The 'exit 1' is ignored because '&&' has higher precedence than '||', causing unexpected command flow.

B The 'echo "Done"' runs even if 'apt-get install' fails, causing build failure.

C The 'apt-get install' command syntax is invalid, causing the failure.

D The 'apt-get update' command is missing a required flag, causing failure.

💡 Hint

Think about how shell operators && and || combine and their precedence.

In shell, && has higher precedence than ||. So the command is parsed as (apt-get update && apt-get install -y curl) || (exit 1 && echo "Done"). If 'apt-get install' fails, 'exit 1' runs but 'echo "Done"' also runs because of the &&. This causes unexpected behavior and build failure.

🔀 Workflow

advanced

Optimizing Dockerfile RUN commands for caching

You want to install dependencies and clean cache in a Dockerfile. Which RUN command order optimizes Docker build caching?

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

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

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

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

💡 Hint

Think about which commands should run first to maximize cache reuse.

Running apt-get update first updates package lists, then installing packages uses that updated list. Cleaning cache last reduces image size. This order allows Docker to cache layers effectively. Other orders break this logic or run commands unnecessarily.

✅ Best Practice

expert

Best practice for combining RUN commands to handle errors

Which RUN command best ensures that if any command fails, the Docker build stops immediately, and all commands run in a single layer?

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

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

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

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

💡 Hint

Consider how to make the shell stop on any error inside a RUN command.

Using set -e causes the shell to exit immediately if any command fails. Chaining commands with && also stops on failure, but set -e is more reliable for complex commands. Using ; runs commands regardless of errors, and & runs commands in background, which is not desired.

Practice

1. Why is it recommended to combine multiple commands in a single RUN instruction in a Dockerfile?

easy

A. To make the Dockerfile longer and more complex

B. To run commands in parallel for faster builds

C. To reduce the number of image layers and keep the image size smaller

D. To avoid using the shell in Dockerfile commands

Solution

1. Step 1: Understand Docker image layers

   Each RUN instruction creates a new image layer, increasing image size.

2. Step 2: Combine commands to reduce layers

   Combining commands with && in one RUN reduces layers and image size.

3. Final Answer:

   To reduce the number of image layers and keep the image size smaller -> Option C

4. Quick Check:

   Combining RUN commands = fewer layers [OK]

Hint: Combine commands with && to reduce image layers [OK]

Common Mistakes:

• Thinking combining commands makes builds faster
• Believing each command runs in parallel
• Ignoring image size impact of multiple RUNs

2. Which of the following is the correct syntax to combine two commands in a single RUN instruction in a Dockerfile?

easy

A. RUN apt-get update && apt-get install -y curl

B. RUN apt-get update; apt-get install -y curl

C. RUN apt-get update | apt-get install -y curl

D. RUN apt-get update &&& apt-get install -y curl

Solution

1. Step 1: Identify correct command chaining operator

   The && operator chains commands so the second runs only if the first succeeds.

2. Step 2: Check each option's syntax

   RUN apt-get update && apt-get install -y curl uses && correctly; others use invalid or unsafe separators.

3. Final Answer:

   RUN apt-get update && apt-get install -y curl -> Option A

4. Quick Check:

   Use && to chain commands safely [OK]

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

Common Mistakes:

• Using semicolon without error checking
• Using invalid operators like | or &&&
• Not chaining commands properly causing build errors

3. What will be the result of this Dockerfile snippet?

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

medium

A. Creates three separate layers for each command

B. Only updates package lists and installs curl, but does not clean files

C. Fails because rm command is invalid in RUN

D. Updates package lists, installs curl, and cleans temporary files in one layer

Solution

1. Step 1: Analyze the chained RUN commands

   The commands update packages, install curl, then remove apt cache files in one RUN.

2. Step 2: Understand layer creation

   All commands combined in one RUN create a single image layer with all changes.

3. Final Answer:

   Updates package lists, installs curl, and cleans temporary files in one layer -> Option D

4. Quick Check:

   Combined RUN commands = single layer with all steps [OK]

Hint: One RUN with && creates one layer with all commands [OK]

Common Mistakes:

• Thinking each command creates a separate layer
• Assuming rm command is invalid in RUN
• Ignoring cleaning temporary files effect

4. You wrote this Dockerfile line:

RUN apt-get update & apt-get install -y git

What is the problem with this command?

medium

A. The & operator is correct and recommended for RUN commands

B. The single & runs commands in background, causing build errors

C. The commands will run sequentially without errors

D. The command will install git twice

Solution

1. Step 1: Understand the & operator in shell

   Single & runs the first command in background, not waiting for completion.

2. Step 2: Impact on Docker build

   This causes the second command to run immediately, possibly before update finishes, leading to errors.

3. Final Answer:

   The single & runs commands in background, causing build errors -> Option B

4. Quick Check:

   Use && not & to chain RUN commands [OK]

Hint: Use &&, not &, to chain commands in RUN [OK]

Common Mistakes:

• Using & instead of && for chaining
• Assuming commands run sequentially with &
• Ignoring build errors caused by background commands

5. You want to install curl and git in one RUN command and clean up apt cache to keep the image small. Which Dockerfile line correctly does this?

hard

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

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

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

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

Solution

1. Step 1: Combine update and install commands safely

   Use && to chain update and install commands to ensure sequential success.

2. Step 2: Clean apt cache in the same RUN

   Remove temporary files with rm -rf /var/lib/apt/lists/* in the same RUN to keep image small.

3. Step 3: Check options for correctness

   RUN apt-get update && apt-get install -y curl git && rm -rf /var/lib/apt/lists/* chains all commands correctly in one RUN; others use semicolons or background & causing issues or inefficiencies.

4. Final Answer:

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

5. Quick Check:

   Chain with && and clean in one RUN [OK]

Hint: Chain update, install, and cleanup with && in one RUN [OK]

Common Mistakes:

• Using semicolons instead of && without error checking
• Running install commands separately (inefficient)
• Using & causing background execution errors