Choosing small base images (alpine, slim) in Docker - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why choose Alpine as a base image?

Which of the following is the main reason to choose Alpine Linux as a Docker base image?

A It includes all development tools by default for easy compiling.

B It is the official image for all programming languages.

C It has a very small size, reducing image bloat and download time.

D It automatically updates packages to the latest versions.

💡 Hint

Think about what helps reduce the size of Docker images.

Alpine Linux is chosen mainly because it is very small (around 5MB), which helps keep Docker images lightweight and fast to download.

💻 Command Output

intermediate

Output size difference between base images

Given the following Dockerfiles, which option correctly shows the approximate size difference when building the images?

FROM python:3.12-alpine
RUN python --version
---
FROM python:3.12-slim
RUN python --version

A Both images are about 200MB in size.

B Alpine image is about 50MB, Slim image is about 120MB.

C Alpine image is about 300MB, Slim image is about 100MB.

D Alpine image is about 120MB, Slim image is about 50MB.

💡 Hint

Alpine is known for being smaller than slim.

The Alpine-based Python image is roughly 50MB, while the slim variant is larger, around 120MB, because it includes more libraries.

❓ Configuration

advanced

Choosing the right base image for a Node.js app

You want to build a Node.js app Docker image that is as small as possible but still supports native modules compilation. Which base image should you choose?

A node:20-slim

B node:20-alpine

C node:20-buster

D node:20-windows

💡 Hint

Alpine uses musl libc which can cause issues with native modules.

While Alpine is smaller, it can cause compatibility issues with native modules that expect glibc. The slim variant balances size and compatibility.

❓ Troubleshoot

advanced

Troubleshooting missing libraries in Alpine image

You built a Docker image using python:3.12-alpine and your app crashes with an error about missing libc. What is the most likely cause?

A Alpine uses musl libc instead of glibc, causing compatibility issues.

B The image is missing Python entirely.

C The Dockerfile did not specify a working directory.

D The app requires Windows libraries not available on Alpine.

💡 Hint

Think about the difference between musl and glibc.

Alpine uses musl libc, which is different from the standard glibc. Some apps or libraries expect glibc and fail on Alpine.

✅ Best Practice

expert

Optimizing multi-stage Docker builds with small base images

In a multi-stage Docker build, which approach best uses small base images to minimize final image size while ensuring build tools are available?

A Use a Windows base image for the build stage and Alpine for the final stage.

B Use Alpine in both build and final stages to keep everything small.

C Use the same large base image for both stages to avoid compatibility issues.

D Use a full build image (like debian) in the first stage, then copy only the final app files into a minimal Alpine image in the final stage.

💡 Hint

Think about separating build dependencies from runtime environment.

Using a full image with build tools in the first stage allows compiling, then copying only needed files into a small Alpine image keeps the final image minimal.

Practice

1. Why do developers often choose small base images like alpine or slim when building Docker containers?

easy

A. To reduce image size and speed up container startup

B. To increase the number of installed packages by default

C. To make the container run only on Windows systems

D. To disable networking inside the container

Solution

1. Step 1: Understand the purpose of small base images

   Small base images like alpine or slim are designed to be lightweight, which means they have fewer files and smaller size.

2. Step 2: Connect size to performance

   Smaller images download faster and start containers quicker, improving efficiency.

3. Final Answer:

   To reduce image size and speed up container startup -> Option A

4. Quick Check:

   Small base images = smaller size and faster startup [OK]

Hint: Small images mean faster downloads and startups [OK]

Common Mistakes:

• Thinking small images have more packages by default
• Assuming small images restrict OS compatibility
• Believing small images disable networking

2. Which of the following is the correct way to specify the Alpine base image in a Dockerfile?

easy

A. IMAGE alpine:latest

B. FROM alpine/latest

C. BASE alpine:latest

D. FROM alpine:latest

Solution

1. Step 1: Recall Dockerfile syntax for base images

   The correct keyword to specify a base image is FROM, followed by the image name and tag separated by a colon.

2. Step 2: Check each option

   FROM alpine:latest uses FROM alpine:latest, which is correct syntax. Options A, B, and C use incorrect keywords or separators.

3. Final Answer:

   FROM alpine:latest -> Option D

4. Quick Check:

   Base image syntax = FROM image:tag [OK]

Hint: Use FROM keyword with colon-separated tag [OK]

Common Mistakes:

• Using slash instead of colon between image and tag
• Using BASE or IMAGE instead of FROM
• Omitting the tag separator

3. Given this Dockerfile snippet:

FROM python:3.12-alpine
RUN python --version

What will be the expected output when building this image?

medium

A. Python 3.12.x (Alpine variant)

B. Error: python command not found

C. Python 2.7.x default version

D. No output, build fails silently

Solution

1. Step 1: Identify the base image and its contents

   The base image is python:3.12-alpine, which includes Python 3.12 installed on Alpine Linux.

2. Step 2: Understand the RUN command effect

   The command python --version will print the Python version installed in the image during build.

3. Final Answer:

   Python 3.12.x (Alpine variant) -> Option A

4. Quick Check:

   python:3.12-alpine includes Python 3.12 [OK]

Hint: Tagged python alpine images include Python by default [OK]

Common Mistakes:

• Assuming python is missing in alpine variant
• Confusing Python 2 with Python 3
• Expecting silent build without output

4. You wrote this Dockerfile:

FROM node:18-slim
RUN apk add curl

But the build fails with "apk: command not found". What is the problem?

medium

A. You must install curl before FROM statement

B. Node 18-slim image does not support RUN commands

C. The slim image uses apt, not apk, so apk command is missing

D. The command should be RUN apt-get add curl

Solution

1. Step 1: Identify the base image OS

   The node:18-slim image is based on Debian, which uses apt package manager, not apk.

2. Step 2: Understand the error cause

   Using apk (Alpine package manager) on Debian-based image causes "command not found" error.

3. Final Answer:

   The slim image uses apt, not apk, so apk command is missing -> Option C

4. Quick Check:

   Debian slim uses apt, not apk [OK]

Hint: Use apt on slim (Debian), apk on alpine [OK]

Common Mistakes:

• Trying apk on Debian-based images
• Placing RUN commands before FROM
• Using unsupported RUN syntax

5. You want a small Docker image for a Python app but need some common Linux tools like curl and bash. Which base image choice balances size and compatibility best?

hard

A. python:3.12-alpine (smallest but may need extra setup)

B. python:3.12-slim (slightly larger but includes common tools)

C. python:3.12-full (largest, includes all tools by default)

D. python:3.12-minimal (no tools, smallest size)

Solution

1. Step 1: Compare alpine and slim images

   Alpine is smallest but often lacks common tools, requiring manual installs. Slim is bigger but includes many common Linux utilities.

2. Step 2: Match needs to image choice

   Since you need tools like curl and bash, slim is a better balance of size and compatibility than alpine.

3. Final Answer:

   python:3.12-slim (slightly larger but includes common tools) -> Option B

4. Quick Check:

   Slim balances size and tools better than alpine [OK]

Hint: Choose slim for tools, alpine for smallest size [OK]

Common Mistakes:

• Picking alpine without adding needed tools
• Assuming minimal includes tools
• Choosing full image without size concern