Build context concept in Docker - Step-by-Step Execution

Process Flow - Build context concept

User runs docker build

↓

Docker CLI sends build context folder

↓

Docker daemon receives context

↓

Docker daemon reads Dockerfile

↓

Docker daemon executes instructions using context files

↓

Image layers created

↓

Build completes, image ready

This flow shows how Docker sends the build context folder to the daemon, which uses it to build the image step-by-step.

Execution Sample

Docker

docker build -t myapp .

This command builds a Docker image named 'myapp' using the current folder as the build context.

Process Table

Step	Action	Details	Result
1	Run docker build	Command: docker build -t myapp .	Starts build, context is current folder
2	Send build context	Docker CLI sends all files in '.' folder	Context files transferred to daemon
3	Read Dockerfile	Docker daemon reads Dockerfile in context	Instructions loaded
4	Execute instructions	Uses context files for COPY, ADD commands	Image layers created
5	Complete build	All steps done	Image 'myapp' created locally

💡 Build finishes after all Dockerfile instructions run using the provided context files

Status Tracker

Variable	Start	After Step 2	After Step 4	Final
build_context	empty	current folder files sent	files available for Dockerfile commands	used fully for image build
image_layers	none	none	layers created per instruction	final image layers ready

Key Moments - 2 Insights

Why does Docker send the whole folder as context even if only one file is needed?

Docker sends the entire folder specified as context (here '.') because it cannot know in advance which files the Dockerfile will use. See execution_table step 2 where all files are sent.

What happens if a needed file is outside the build context folder?

Docker cannot access files outside the build context. This causes build errors during execution (step 4). The context must include all needed files.

Visual Quiz - 3 Questions

Look at the execution table, what is sent to the Docker daemon at step 2?

A All files in the current folder (build context)

B Only the Dockerfile

C No files, just instructions

D Only files listed in Dockerfile

💡 Hint

Check the 'Details' column in step 2 of the execution_table

At which step does Docker create image layers?

A Step 1

B Step 2

C Step 4

D Step 5

💡 Hint

Look at the 'Result' column in step 4 of the execution_table

If the build context folder is changed to a subfolder, what changes in the execution?

A Docker sends files from the parent folder

B Docker sends files from the subfolder as context

C Docker ignores the context and uses current folder

D Docker sends no files

💡 Hint

Recall that the context folder is what Docker CLI sends as per step 2

Concept Snapshot

Docker build context is the folder sent to the daemon during build.
It includes all files in that folder and subfolders.
Dockerfile instructions like COPY use files from this context.
If files are outside context, build fails.
Use '.' to send current folder as context.
Context size affects build speed.

Full Transcript

When you run 'docker build -t myapp .', Docker sends the current folder as the build context to the Docker daemon. The daemon reads the Dockerfile inside this context and executes each instruction. Files in the context folder are available for commands like COPY or ADD. Docker creates image layers step-by-step using these files. The build finishes when all instructions run successfully, producing the image named 'myapp'. If needed files are outside the context folder, the build will fail because Docker cannot access them. The build context is important because it defines what files Docker can use during the build.

Practice

1. What does the build context specify when running docker build?

easy

A. The name of the Docker image to create

B. The folder Docker uses to find files for building the image

C. The network settings for the container

D. The port mapping for the container

Solution

1. Step 1: Understand the role of build context

   The build context is the directory Docker looks into to find files needed for the image build.

2. Step 2: Identify the correct description

   Among the options, only the folder used to find files matches the build context definition.

3. Final Answer:

   The folder Docker uses to find files for building the image -> Option B

4. Quick Check:

   Build context = folder path [OK]

Hint: Build context is the folder path at the end of docker build [OK]

Common Mistakes:

• Confusing build context with image name
• Thinking build context is network or port settings
• Assuming build context is a Dockerfile option

2. Which of the following is the correct syntax to specify the build context when building a Docker image?

easy

A. docker build -context /path/to/context -t myimage

B. docker build /path/to/context -t myimage

C. docker build -t myimage /path/to/context

D. docker build -buildcontext /path/to/context -t myimage

Solution

1. Step 1: Recall docker build command syntax

   The build context path is given as the last argument in the command, after options like -t.

2. Step 2: Check each option

   docker build -t myimage /path/to/context places the context path last, which is correct. Options C and D use invalid flags. docker build /path/to/context -t myimage places context before -t, which is incorrect syntax.

3. Final Answer:

   docker build -t myimage /path/to/context -> Option C

4. Quick Check:

   Context path is last argument in docker build [OK]

Hint: Build context path is always last in docker build command [OK]

Common Mistakes:

• Using invalid flags like -context or -buildcontext
• Placing context path before options
• Omitting the context path entirely

3. Given this command:
docker build -t appimage .
and a .dockerignore file that excludes node_modules/, what will happen to the node_modules folder during build?

medium

A. It will be sent to the Docker daemon as part of the build context

B. It will be copied into the image automatically

C. It will cause an error during build

D. It will be excluded from the build context and not sent

Solution

1. Step 1: Understand .dockerignore effect

   The .dockerignore file tells Docker which files or folders to exclude from the build context sent to the daemon.

2. Step 2: Apply to node_modules folder

   Since node_modules/ is listed in .dockerignore, it will be excluded and not sent during build.

3. Final Answer:

   It will be excluded from the build context and not sent -> Option D

4. Quick Check:

   .dockerignore excludes files from build context [OK]

Hint: Files in .dockerignore are NOT sent in build context [OK]

Common Mistakes:

• Thinking excluded files cause build errors
• Assuming excluded files are still copied into image
• Confusing build context with container runtime files

4. You run docker build -t myapp without specifying a build context. What will happen?

medium

A. Docker will throw an error about missing build context

B. Docker will use the current directory as the build context

C. Docker will build an empty image

D. Docker will use the root directory as build context

Solution

1. Step 1: Check docker build command requirements

   The docker build command requires a build context path as the last argument.

2. Step 2: Analyze missing context behavior

   If no context is given, Docker will report an error about missing build context.

3. Final Answer:

   Docker will throw an error about missing build context -> Option A

4. Quick Check:

   Build context is mandatory argument [OK]

Hint: Always specify build context path in docker build [OK]

Common Mistakes:

• Assuming current directory is default context
• Expecting build to succeed without context
• Confusing build context with Dockerfile location

5. You want to build a Docker image but exclude large log files and temporary folders from the build context to speed up the build. Which approach is best?

hard

A. Use a .dockerignore file listing logs and temp folders

B. Manually delete logs and temp folders before building

C. Specify the build context as the parent directory

D. Use the --exclude flag in docker build

Solution

1. Step 1: Identify how to exclude files from build context

   The .dockerignore file is designed to exclude files and folders from the build context sent to Docker.

2. Step 2: Evaluate other options

   Manually deleting files is error-prone. Specifying parent directory increases context size. There is no --exclude flag in docker build.

3. Final Answer:

   Use a .dockerignore file listing logs and temp folders -> Option A

4. Quick Check:

   .dockerignore controls build context contents [OK]

Hint: Use .dockerignore to exclude unwanted files from build context [OK]

Common Mistakes:

• Trying to exclude files with non-existent flags
• Forgetting to create .dockerignore file
• Using wrong directory as build context