Choosing small base images (alpine, slim) in Docker - Step-by-Step Execution

Process Flow - Choosing small base images (alpine, slim)

Start Dockerfile

↓

Choose base image

↓

Alpine

↓

Add app files

↓

Install dependencies

↓

Build and run container

↓

Check image size and performance

This flow shows how choosing a small base image like Alpine or Slim affects the Docker build and final image size.

Execution Sample

Docker

FROM python:3.12-alpine
COPY app.py /app/
RUN pip install flask
CMD ["python", "/app/app.py"]

This Dockerfile uses the small Alpine base image to build a Python app with Flask.

Process Table

Step	Action	Base Image Size	Effect on Image Size	Resulting Image Size
1	Start with python:3.12-alpine	50 MB	Very small base image	50 MB
2	Copy app.py	No size change	Adds app code	50 MB + app.py size
3	Run pip install flask	Adds Flask and dependencies	Increases size moderately	Approx 70 MB total
4	Set CMD to run app	No size change	Sets container start command	Approx 70 MB total
5	Build complete	Final image size	Small and efficient image	Approx 70 MB
6	Compare with python:3.12-slim	Base size ~120 MB	Larger base image	Approx 140 MB total

💡 Build finishes with a small image using Alpine (~70 MB) versus larger Slim (~140 MB)

Status Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
Base Image Size	N/A	50 MB	50 MB	50 MB	50 MB
App Size	N/A	app.py added	app.py + Flask libs	app.py + Flask libs	app.py + Flask libs
Total Image Size	N/A	50 MB + app.py	Approx 70 MB	Approx 70 MB	Approx 70 MB

Key Moments - 3 Insights

Why does the image size increase after 'pip install flask'?

Because installing Flask adds libraries and dependencies, increasing the image size as shown in step 3 of the execution_table.

Why is the Alpine base image smaller than the Slim base image?

Alpine is a minimal Linux distribution designed to be very small (~50 MB), while Slim is a stripped-down version of Debian but still larger (~120 MB), as shown in step 6.

Does copying app.py increase the image size significantly?

No, copying app.py adds only the size of that file, which is usually small compared to installed libraries, as seen in step 2.

Visual Quiz - 3 Questions

Look at the execution_table, what is the approximate total image size after installing Flask on Alpine?

A 5 MB

B 70 MB

C 37 MB

D 50 MB

💡 Hint

Check step 3 and 5 in the execution_table for image size after pip install flask.

At which step does the image size increase due to adding application code?

A Step 2

B Step 1

C Step 4

D Step 6

💡 Hint

Look at step 2 in the execution_table where app.py is copied.

If you switch from Alpine to Slim base image, how does the base image size change?

A It stays the same

B It becomes smaller

C It becomes larger

D It disappears

💡 Hint

Refer to step 6 in the execution_table comparing Alpine and Slim base sizes.

Concept Snapshot

Choosing small base images:
- Alpine: minimal (~50 MB), very small image size
- Slim: reduced Debian (~120 MB), larger than Alpine
- Smaller base means smaller final image
- Add only needed dependencies
- Smaller images start faster and use less space

Full Transcript

This visual execution shows how choosing a small base image like Alpine or Slim affects Docker image size. Starting with Alpine base image of about 50 MB, copying app code adds little size. Installing Flask adds libraries increasing size to about 70 MB total. Using Slim base image starts larger (~120 MB), resulting in a bigger final image (~140 MB). Key points: installing dependencies increases size, Alpine is smaller than Slim, copying app code adds minimal size. Choosing Alpine helps keep images small and efficient.

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