FROM instruction for base image in Docker - Mini Project: Build & Apply

Using the FROM Instruction to Set a Base Image in Docker

📖 Scenario: You want to create a simple Docker container that runs a Python application. To do this, you need to start with a base image that already has Python installed.

🎯 Goal: Build a Dockerfile that uses the FROM instruction to specify the official Python 3.12 base image.

📋 What You'll Learn

Create a Dockerfile

Use the FROM instruction with the exact base image python:3.12-slim

💡 Why This Matters

🌍 Real World

Dockerfiles are used to create container images that package applications with their environment. Starting with a base image is the first step in building a container.

💼 Career

Understanding the <code>FROM</code> instruction is essential for DevOps engineers and developers working with containers and continuous deployment pipelines.

1

Create a Dockerfile with the FROM instruction

Create a file named Dockerfile and write the FROM instruction with the exact base image python:3.12-slim.

Docker

# Your code here

Hint

The FROM instruction must be the first line in your Dockerfile.

2

Add a label to describe the image

Add a LABEL instruction below the FROM line with the exact key description and value "Python 3.12 slim base image".

Docker

FROM python:3.12-slim
# Your code here

Hint

Use the syntax LABEL key="value" to add metadata.

3

Set the working directory

Add a WORKDIR instruction below the LABEL line to set the working directory to /app.

Docker

FROM python:3.12-slim
LABEL description="Python 3.12 slim base image"
# Your code here

Hint

The WORKDIR instruction sets the directory where commands will run inside the container.

4

Display the Dockerfile content

Write a command to display the contents of the Dockerfile to verify your instructions.

Docker

FROM python:3.12-slim
LABEL description="Python 3.12 slim base image"
WORKDIR /app
# Your code here

Hint

Use RUN cat Dockerfile to print the Dockerfile content during build.

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