Reducing image size strategies in Docker - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use multi-stage builds in Docker?

What is the main reason to use multi-stage builds when creating Docker images?

A To run multiple containers from one Dockerfile simultaneously

B To separate build dependencies from runtime, reducing final image size

C To speed up the container startup time by caching layers

D To allow Docker images to run on different operating systems automatically

💡 Hint

Think about how build tools and runtime requirements differ.

Multi-stage builds let you copy only the necessary artifacts from a build stage to the final image, leaving behind bulky build tools and dependencies. This reduces the final image size.

💻 Command Output

intermediate

Output of Docker image size after cleaning cache

What will be the effect on the Docker image size after running RUN apt-get clean && rm -rf /var/lib/apt/lists/* in a Dockerfile?

Docker

FROM ubuntu:22.04
RUN apt-get update && apt-get install -y curl \
    && apt-get clean && rm -rf /var/lib/apt/lists/*

A The image size increases due to added cleanup commands

B No change in image size because cache files are stored outside the image

C The image size decreases because package cache files are removed

D Build will fail because rm command is invalid in Dockerfile

💡 Hint

Consider where package cache files are stored and if they remain in the image layers.

Cleaning the apt cache and removing package lists deletes unnecessary files from the image layers, reducing the final image size.

❓ Configuration

advanced

Choosing base images for smaller Docker images

Which base image choice will generally produce the smallest Docker image for a Node.js app?

A node:alpine

B node:latest

C ubuntu:22.04

D debian:stable-slim

💡 Hint

Think about minimal Linux distributions optimized for small size.

Alpine Linux is a minimal distribution designed for small size, so node:alpine images are much smaller than full Ubuntu or Debian base images.

❓ Troubleshoot

advanced

Why does the Docker image remain large despite cleanup commands?

You added cleanup commands to your Dockerfile to remove temporary files after installing packages, but the final image size is still large. What is the most likely reason?

A The Dockerfile must use COPY instead of RUN for cleanup to work

B Docker caches all files permanently regardless of cleanup commands

C Cleanup commands only work on Alpine images, not Ubuntu-based ones

D Each RUN command creates a new layer; cleanup must be in the same RUN as install

💡 Hint

Think about how Docker layers work and when files get saved.

Docker creates a new image layer after each RUN command. If cleanup is done in a separate RUN, the files exist in previous layers and still increase image size. Combining install and cleanup in one RUN keeps the image smaller.

🔀 Workflow

expert

Optimizing Dockerfile for smallest image with build artifacts

You have a Dockerfile that compiles a Go application and then copies the binary to a minimal image. Which multi-stage Dockerfile snippet correctly produces the smallest final image?

Docker

FROM golang:1.20 AS builder
WORKDIR /app
COPY . .
RUN go build -o myapp

FROM scratch
COPY --from=builder /app/myapp /myapp
CMD ["/myapp"]

A Use <code>FROM scratch</code> as final stage and copy only the binary from builder

B Use <code>FROM golang:1.20</code> as final stage and copy all files from builder

C Use <code>FROM ubuntu</code> as final stage and copy the binary and source files

D Use <code>FROM alpine</code> as final stage and copy the entire /app directory

💡 Hint

Consider the smallest base image possible and copying only what is needed.

Using scratch as the final base image and copying only the compiled binary results in the smallest image. Other options include unnecessary files or larger base images.

Practice

1. Which of the following is the best initial step to reduce the size of a Docker image?

easy

A. Start with a small base image like Alpine or slim variants

B. Install all available packages to avoid missing dependencies

C. Use the latest Ubuntu image without modifications

D. Add unnecessary files to the image for future use

Solution

1. Step 1: Understand base image impact

   The base image sets the starting size; smaller bases mean smaller final images.

2. Step 2: Compare options

   Alpine and slim variants are minimal, unlike full Ubuntu or adding unnecessary files.

3. Final Answer:

   Start with a small base image like Alpine or slim variants -> Option A

4. Quick Check:

   Small base image = smaller Docker image [OK]

Hint: Choose minimal base images first to reduce size [OK]

Common Mistakes:

• Using full OS images without slimming
• Installing unnecessary packages
• Adding extra files without need

2. Which Dockerfile command sequence correctly cleans up package manager caches to reduce image size?

easy

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

B. RUN apt-get install curl && apt-get update

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

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

Solution

1. Step 1: Understand package installation order

   First update package lists, then install packages, finally clean cache to reduce image size.

2. Step 2: Analyze commands

   RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/* updates, installs, then removes cache correctly; others have wrong order causing errors or no cleanup.

3. Final Answer:

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

4. Quick Check:

   Update -> install -> clean cache = correct order [OK]

Hint: Update before install, clean cache after install [OK]

Common Mistakes:

• Cleaning cache before installing packages
• Skipping apt-get update
• Wrong command order causing errors

3. Given this Dockerfile snippet, what will be the approximate size effect on the final image?

FROM node:18-alpine
RUN apk add --no-cache git
COPY . /app
RUN npm install

medium

A. The image will be small because Alpine and --no-cache reduce size

B. The image will be large because npm install always adds big size

C. The image will be large because git is installed without cache cleanup

D. The image size is unaffected by base image or package installs

Solution

1. Step 1: Analyze base image and package install

   Using Alpine base and apk with --no-cache avoids cache files, keeping image small.

2. Step 2: Consider npm install impact

   npm install adds dependencies but starting from Alpine keeps overall size smaller than heavier bases.

3. Final Answer:

   The image will be small because Alpine and --no-cache reduce size -> Option A

4. Quick Check:

   Alpine + --no-cache = smaller image [OK]

Hint: Use Alpine + --no-cache to keep image small [OK]

Common Mistakes:

• Assuming npm install always makes image large
• Ignoring --no-cache effect
• Not considering base image size

4. You wrote this Dockerfile to reduce image size but the final image is still large:

FROM python:3.12
RUN pip install flask
RUN rm -rf /root/.cache/pip

What is the main issue causing the large image?

medium

A. The pip cache is not cleaned because it is stored elsewhere

B. You should combine RUN commands to reduce layers

C. The base image python:3.12 is already large and cannot be reduced

D. Flask installation always creates large images regardless

Solution

1. Step 1: Understand Docker layers

   Each RUN creates a new layer; cleaning cache in a separate RUN keeps cache in previous layer.

2. Step 2: Combine commands to remove cache in same layer

   Combining pip install and cache removal in one RUN prevents cache from persisting in earlier layers.

3. Final Answer:

   You should combine RUN commands to reduce layers -> Option B

4. Quick Check:

   Combine RUN commands to clean caches in one layer [OK]

Hint: Combine install and cleanup in one RUN to reduce layers [OK]

Common Mistakes:

• Cleaning cache in separate RUN commands
• Assuming base image size can't be optimized
• Believing package size can't be reduced

5. You want to build a Docker image for a Go application but keep it as small as possible. Which multi-stage Dockerfile snippet achieves this best?

FROM golang:1.20 AS builder
WORKDIR /app
COPY . .
RUN go build -o myapp

FROM alpine:latest
COPY --from=builder /app/myapp /usr/local/bin/myapp
CMD ["myapp"]

hard

A. This build copies all source files to Alpine, increasing image size unnecessarily

B. Using Alpine as final image is bad because it lacks Go runtime

C. This multi-stage build compiles in golang image and copies only binary to Alpine, minimizing size

D. You should install Go in Alpine to build and run in one stage

Solution

1. Step 1: Understand multi-stage build purpose

   Build stage uses full Go image; final stage uses minimal Alpine with only binary copied.

2. Step 2: Analyze final image contents

   Only the compiled binary is copied, no source or build tools, keeping image small.

3. Final Answer:

   This multi-stage build compiles in golang image and copies only binary to Alpine, minimizing size -> Option C

4. Quick Check:

   Multi-stage build + minimal final image = small size [OK]

Hint: Use multi-stage builds to copy only final artifacts [OK]

Common Mistakes:

• Copying source files to final image
• Installing build tools in final image
• Building and running in same large image