FROM instruction for base image in Docker - Step-by-Step Execution

Process Flow - FROM instruction for base image

Start Dockerfile

↓

Read FROM instruction

↓

Pull base image if not local

↓

Set base image as build stage

↓

Continue with next instructions

↓

Build image on top of base

Docker reads the FROM instruction first, pulls the base image if needed, and sets it as the starting point for the build.

Execution Sample

Docker

FROM ubuntu:22.04
RUN apt-get update
RUN apt-get install -y curl

This Dockerfile starts from the Ubuntu 22.04 base image, updates package lists, and installs curl.

Process Table

Step	Instruction	Action	Result
1	FROM ubuntu:22.04	Check local images; pull if missing	Base image ubuntu:22.04 set
2	RUN apt-get update	Run update command inside base image	Package lists updated
3	RUN apt-get install -y curl	Install curl package	curl installed
4	End of Dockerfile	Build complete	Final image created

💡 All instructions executed; image built on ubuntu:22.04 base

Status Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
Base Image	None	ubuntu:22.04	ubuntu:22.04	ubuntu:22.04	ubuntu:22.04 with curl
Packages Installed	None	None	None	curl	curl
Package Lists	Outdated	Updated	Updated	Updated	Updated

Key Moments - 2 Insights

Why does Docker pull the base image during the FROM instruction?

Docker pulls the base image if it is not already on the local machine to ensure the build starts from the correct environment, as shown in execution_table step 1.

Can you have multiple FROM instructions in one Dockerfile?

Yes, multiple FROM instructions create multiple build stages, but each FROM sets a new base image, starting a new stage. This example shows a single FROM for simplicity.

Visual Quiz - 3 Questions

Look at the execution table, what is the base image set after step 1?

A None

B curl

C ubuntu:22.04

D apt-get

💡 Hint

Check the 'Result' column in step 1 of the execution_table.

At which step are package lists updated?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Action' and 'Result' columns in the execution_table for step 2.

If the base image was already local, what would change in step 1?

A Docker would skip pulling and use local image

B Docker would pull the image anyway

C Docker would fail the build

D Docker would remove the local image

💡 Hint

Refer to the 'Action' description in step 1 about checking local images.

Concept Snapshot

FROM instruction sets the base image for your Docker build.
Docker pulls this image if not present locally.
All following instructions build on top of this base.
You can have multiple FROMs for multi-stage builds.
Always specify a valid image name and tag.

Full Transcript

The FROM instruction in a Dockerfile tells Docker which base image to use for building your container image. When Docker reads FROM, it checks if the image is available locally. If not, it downloads (pulls) the image from a registry. This base image becomes the starting point for all following build steps. For example, FROM ubuntu:22.04 sets the base to Ubuntu 22.04. Then commands like RUN apt-get update run inside that base. The build ends when all instructions are done, producing a new image layered on top of the base. Multiple FROM instructions can create multi-stage builds, each starting fresh with a new base image.

Practice

1. What does the FROM instruction do in a Dockerfile?

easy

A. It sets the base image for the Docker build.

B. It copies files from the host to the container.

C. It runs commands inside the container.

D. It exposes ports for the container.

Solution

1. Step 1: Understand the role of FROM

   The FROM instruction defines the starting point or base image for building a Docker image.

2. Step 2: Compare with other instructions

   Other instructions like COPY, RUN, and EXPOSE have different purposes, not setting the base image.

3. Final Answer:

   It sets the base image for the Docker build. -> Option A

4. Quick Check:

   FROM = base image [OK]

Hint: FROM always sets the base image in Dockerfile [OK]

Common Mistakes:

• Confusing FROM with COPY or RUN instructions
• Thinking FROM exposes ports
• Assuming FROM copies files

2. Which of the following is the correct syntax for the FROM instruction to use the Ubuntu 22.04 image?

easy

A. FROM ubuntu/22.04

B. FROM ubuntu-22.04

C. FROM ubuntu:22.04

D. FROM ubuntu@22.04

Solution

1. Step 1: Recall Docker image tag syntax

   The correct format is image_name:tag, so ubuntu:22.04 is valid.

2. Step 2: Check other options

   Options with dashes, slashes, or @ are invalid for tags in FROM instruction.

3. Final Answer:

   FROM ubuntu:22.04 -> Option C

4. Quick Check:

   Use colon for tag in FROM [OK]

Hint: Use colon ':' to specify image tag in FROM [OK]

Common Mistakes:

• Using dash '-' instead of colon ':' for tags
• Using slash '/' incorrectly in image name
• Using '@' instead of ':' for tags

3. Given this Dockerfile snippet:

FROM python:3.12-slim
RUN python --version

What will be the output when building this Docker image?

medium

A. Python 3.11.x

B. Python 3.12.x

C. Error: python command not found

D. Python 2.7.x

Solution

1. Step 1: Identify base image version

   The base image is python:3.12-slim, which includes Python version 3.12.

2. Step 2: Understand RUN command output

   The RUN command executes python --version, which prints the Python version installed in the image.

3. Final Answer:

   Python 3.12.x -> Option B

4. Quick Check:

   FROM python:3.12-slim runs Python 3.12 [OK]

Hint: Tag in FROM matches Python version output [OK]

Common Mistakes:

• Assuming default Python version is 3.11 or 2.7
• Thinking slim images lack Python
• Confusing build output with runtime

4. Identify the error in this Dockerfile snippet:

FROM alpine
FROM ubuntu:20.04
RUN echo "Hello"

medium

A. FROM instruction must be last line.

B. Missing tag for alpine image causes error.

C. Multiple FROM instructions without stage names cause error.

D. There is no error in this Dockerfile snippet.

Solution

1. Step 1: Check multiple FROM usage

   Multiple FROM instructions are allowed for multi-stage builds even without stage names (AS). Earlier stages are discarded unless referenced (by name or index).

2. Step 2: Verify other parts

   FROM alpine defaults to :latest (valid image). The RUN applies to the final stage (ubuntu:20.04) and is syntactically correct.

3. Final Answer:

   There is no error in this Dockerfile snippet. -> Option D

4. Quick Check:

   Multiple FROM without AS is valid [OK]

Hint: Multiple FROM instructions do not require stage names [OK]

Common Mistakes:

• Assuming multiple FROM lines always work without names
• Thinking RUN syntax is wrong here
• Believing FROM must be last line

5. You want to build a multi-stage Dockerfile using node:18 as the build stage (named 'build') and nginx:alpine as the final stage. Which FROM instructions correctly set this up?

hard

A. FROM node:18 AS build
FROM nginx:alpine

B. FROM node:18
FROM nginx:alpine AS build

C. FROM node:18
FROM nginx:alpine

D. FROM node:18 AS build
FROM nginx:alpine AS build

Solution

1. Step 1: Understand multi-stage build syntax

   Use AS to name the build stage, e.g., FROM node:18 AS build.

2. Step 2: Set final stage without conflicting names

   The final stage uses FROM nginx:alpine without a stage name or with a different name.

3. Step 3: Check options

   FROM node:18 AS build FROM nginx:alpine correctly names the build stage and then starts the final stage. Others misuse stage names or omit them incorrectly.

4. Final Answer:

   FROM node:18 AS build FROM nginx:alpine -> Option A

5. Quick Check:

   Use AS to name build stage first [OK]

Hint: Name build stage with AS, final stage without or different name [OK]

Common Mistakes:

• Naming both stages the same
• Placing AS on final stage incorrectly
• Omitting AS for build stage in multi-stage