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.