Building images in Compose in Docker - Step-by-Step Execution

Process Flow - Building images in Compose

Write Dockerfile

↓

Define service in docker-compose.yml with build context

↓

Run 'docker compose build'

↓

Docker reads Dockerfile

↓

Docker builds image step-by-step

↓

Image created and tagged

↓

Ready to run containers with new image

This flow shows how Docker Compose builds an image from a Dockerfile by reading the build context and creating the image step-by-step before running containers.

Execution Sample

Docker

version: '3.8'
services:
  web:
    build: ./app
    image: myapp:latest

This Compose file defines a service 'web' that builds an image from the './app' directory and tags it as 'myapp:latest'.

Process Table

Step	Action	Details	Result
1	Read docker-compose.yml	Find 'web' service with build context './app'	Prepare build context './app'
2	Start build	Run 'docker compose build web'	Docker starts reading Dockerfile in './app'
3	Parse Dockerfile	Read instructions like FROM, COPY, RUN	Prepare image layers
4	Execute FROM	Base image pulled or found locally	Base image ready
5	Execute COPY	Copy files from './app' to image	Files added to image layer
6	Execute RUN	Run commands inside image	Commands executed, changes saved
7	Complete build	All instructions processed	Image 'myapp:latest' created
8	Tag image	Assign tag 'myapp:latest'	Image tagged and ready
9	Exit	Build finished successfully	Ready to run containers with new image

💡 Build completes after processing all Dockerfile instructions and tagging the image.

Status Tracker

Variable	Start	After Step 4	After Step 6	Final
Image Layers	empty	base image layer added	files and commands layers added	complete image with all layers
Image Tag	none	none	none	myapp:latest

Key Moments - 3 Insights

Why does Docker need a build context folder?

Docker uses the build context folder (like './app') to access files needed during the build, such as those copied into the image. Without it, COPY commands would fail (see execution_table step 5).

What happens if the base image is not found locally?

Docker pulls the base image from the registry during the FROM instruction (step 4), so the build can continue with the correct starting point.

Why is the image tagged after build?

Tagging (step 8) gives the image a name to identify it easily when running containers or pushing to a registry.

Visual Quiz - 3 Questions

Look at the execution table, at which step are files copied into the image?

A Step 5

B Step 3

C Step 6

D Step 7

💡 Hint

Check the 'Action' and 'Details' columns for the COPY instruction in the execution_table.

According to variable_tracker, what is the state of 'Image Layers' after step 6?

A empty

B files and commands layers added

C base image layer added

D complete image with all layers

💡 Hint

Look at the 'Image Layers' row and the 'After Step 6' column in variable_tracker.

If the build context path is wrong, what will likely happen during the build?

A Docker will skip the build

B Docker will build successfully with empty files

C Docker will fail at the COPY step

D Docker will tag the image anyway

💡 Hint

Refer to key_moments about the importance of build context and execution_table step 5.

Concept Snapshot

Docker Compose builds images by reading a Dockerfile in a specified build context folder.
The 'build' key in docker-compose.yml points to this folder.
Running 'docker compose build' executes Dockerfile instructions step-by-step.
The final image is tagged as specified and ready to run containers.
Build context must include all files needed for COPY commands.
Base images are pulled if not found locally.

Full Transcript

This visual execution shows how Docker Compose builds images. First, you write a Dockerfile and define a service in docker-compose.yml with a build context folder. When you run 'docker compose build', Docker reads the Dockerfile instructions one by one. It starts by pulling or using a base image, then copies files from the build context, runs commands inside the image, and finally creates and tags the image. Variables like image layers grow as instructions run. Key points include the need for a correct build context folder and tagging the image after build. The execution table and variable tracker help visualize each step clearly.

Practice

1. What does the build key do in a Docker Compose file?

easy

A. It sets the network mode for the container.

B. It runs a container from an existing image.

C. It specifies environment variables for the container.

D. It tells Compose how to build a Docker image from a directory or Dockerfile.

Solution

1. Step 1: Understand the role of build in Compose

   The build key tells Docker Compose to create an image from source files, usually by specifying a directory with a Dockerfile.

2. Step 2: Compare with other keys

   Other keys like image specify existing images, and environment sets variables, so they do not build images.

3. Final Answer:

   It tells Compose how to build a Docker image from a directory or Dockerfile. -> Option D

4. Quick Check:

   build = build image [OK]

Hint: Remember: build = create image from source [OK]

Common Mistakes:

• Confusing build with image key
• Thinking build runs containers
• Mixing build with environment variables

2. Which of the following is the correct syntax to specify a custom Dockerfile in a Compose service?

easy

A. build: ./app
dockerfile: Dockerfile.custom

B. build:
path: ./app
file: Dockerfile.custom

C. build:
context: ./app
dockerfile: Dockerfile.custom

D. build:
source: ./app
file: Dockerfile.custom

Solution

1. Step 1: Recall correct keys under build

   The correct keys are context for directory and dockerfile for custom Dockerfile name.

2. Step 2: Check each option

   build: context: ./app dockerfile: Dockerfile.custom uses context and dockerfile correctly. Others use invalid keys like path, file, or source.

3. Final Answer:

   build: context: ./app dockerfile: Dockerfile.custom -> Option C

4. Quick Check:

   Use context and dockerfile keys [OK]

Hint: Use 'context' and 'dockerfile' keys exactly [OK]

Common Mistakes:

• Using 'path' or 'file' instead of 'context' and 'dockerfile'
• Indentation errors under build
• Putting dockerfile outside build block

3. Given this Compose snippet:

services:
  web:
    build:
      context: ./webapp
    image: mywebapp:latest

What happens when you run docker compose up --build?

medium

A. It builds the image from ./webapp and tags it as mywebapp:latest, then starts the container.

B. It pulls the image mywebapp:latest from Docker Hub and runs it.

C. It builds the image but does not tag it as mywebapp:latest.

D. It starts the container without building or pulling any image.

Solution

1. Step 1: Understand build and image keys together

   The build key builds an image from the given context. The image key tags the built image with the given name.

2. Step 2: Effect of --build flag

   The --build flag forces Compose to build the image before starting containers.

3. Final Answer:

   It builds the image from ./webapp and tags it as mywebapp:latest, then starts the container. -> Option A

4. Quick Check:

   build + image = build and tag image [OK]

Hint: build + image tags image before running [OK]

Common Mistakes:

• Thinking image pulls from Docker Hub automatically
• Assuming build does not tag image
• Ignoring --build flag effect

4. You wrote this Compose service:

services:
  api:
    build: ./api
    dockerfile: Dockerfile.api

When running docker compose build, you get an error. What is wrong?

medium

A. You must specify context instead of build.

B. The dockerfile key must be inside the build block, not at the same level.

C. The build key cannot be a string; it must be a dictionary.

D. Docker Compose does not support custom Dockerfile names.

Solution

1. Step 1: Check Compose syntax for build and dockerfile

   The dockerfile key must be nested inside the build dictionary, not at the same level as build.

2. Step 2: Identify the error cause

   Here, build is a string, and dockerfile is separate, causing Compose to fail parsing.

3. Final Answer:

   The dockerfile key must be inside the build block, not at the same level. -> Option B

4. Quick Check:

   dockerfile inside build block [OK]

Hint: Put dockerfile under build, not beside it [OK]

Common Mistakes:

• Placing dockerfile outside build block
• Using build as string with dockerfile key separately
• Assuming dockerfile key is global

5. You want to build two services in Compose, frontend and backend, each with different Dockerfiles in the same directory ./app. How do you configure the build section for both services correctly?

hard

A. Use context: ./app for both, and specify different dockerfile names under each service's build.

B. Use different context paths for each service pointing to the same directory.

C. Use one service with build and the other with image only.

D. You cannot build two images from the same directory with different Dockerfiles.

Solution

1. Step 1: Understand build context and dockerfile usage

   You can use the same context directory but specify different dockerfile names to build different images from the same folder.

2. Step 2: Check options for multiple services

   Use context: ./app for both, and specify different dockerfile names under each service's build. correctly uses the same context with different Dockerfiles. Use different context paths for each service pointing to the same directory. is redundant, C limits building, and D is false.

3. Final Answer:

   Use context: ./app for both, and specify different dockerfile names under each service's build. -> Option A

4. Quick Check:

   Same context + different dockerfile names [OK]

Hint: Same folder, different dockerfile names per service [OK]

Common Mistakes:

• Trying to use different contexts for same folder
• Thinking multiple Dockerfiles in one folder is unsupported
• Not specifying dockerfile key for each service