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.