Copying from build stage to final stage in Docker - Mini Project: Build & Apply

Copying from build stage to final stage

📖 Scenario: You are creating a Docker image for a simple web application. To keep the final image small, you want to use a multi-stage build. The first stage will build the application, and the second stage will copy only the necessary files from the build stage.

🎯 Goal: Build a multi-stage Dockerfile where the final stage copies the built application files from the build stage.

📋 What You'll Learn

Create a build stage named builder using the node:18 image

In the build stage, create a directory /app and add a file index.js with the content console.log('Hello from build stage');

Create a final stage using the node:18-slim image

Copy the index.js file from the builder stage to the final stage's /app directory

Set the working directory to /app in the final stage

Set the default command to run node index.js

💡 Why This Matters

🌍 Real World

Multi-stage builds are used in real projects to separate building and running environments. This keeps the final Docker image small and secure by excluding build tools.

💼 Career

Understanding multi-stage Docker builds is important for DevOps roles, as it improves deployment efficiency and image management.

1

Create the build stage

Create a build stage named builder using the node:18 image. Inside it, create a directory /app and add a file index.js with the content console.log('Hello from build stage'); using a RUN command.

Docker

# Create build stage named builder with node:18
# Create /app directory and add index.js file with console.log message

Hint

Use FROM node:18 AS builder to name the build stage. Use RUN mkdir /app to create the directory. Use echo to create the index.js file with the exact content.

2

Create the final stage

Create the final stage using the node:18-slim image. This stage will be the last FROM instruction in the Dockerfile.

Docker

FROM node:18 AS builder
RUN mkdir /app && echo "console.log('Hello from build stage');" > /app/index.js

# Create final stage using node:18-slim

Hint

Use FROM node:18-slim to start the final stage.

3

Copy files from build stage to final stage

In the final stage, copy the index.js file from the builder stage's /app directory to the final stage's /app directory using the COPY --from=builder command. Then set the working directory to /app.

Docker

FROM node:18 AS builder
RUN mkdir /app && echo "console.log('Hello from build stage');" > /app/index.js

FROM node:18-slim
# Copy index.js from builder stage to /app
# Set working directory to /app

Hint

Use COPY --from=builder /app/index.js /app/index.js to copy the file. Use WORKDIR /app to set the working directory.

4

Set the default command

In the final stage, add a CMD instruction to run node index.js when the container starts.

Docker

FROM node:18 AS builder
RUN mkdir /app && echo "console.log('Hello from build stage');" > /app/index.js

FROM node:18-slim
COPY --from=builder /app/index.js /app/index.js
WORKDIR /app
# Set default command to run node index.js

Hint

Use CMD ["node", "index.js"] to set the default command.

Practice

1. What is the main purpose of using COPY --from= in a multi-stage Docker build?

easy

A. To copy files from the host machine to the build stage

B. To copy files from a previous build stage to the final image

C. To copy files from the final image back to the build stage

D. To copy files between two running containers

Solution

1. Step 1: Understand multi-stage builds

   Multi-stage builds allow you to create intermediate stages for building your app.

2. Step 2: Purpose of COPY --from=

   The COPY --from= command copies files from these intermediate stages into the final image, keeping it clean and small.

3. Final Answer:

   To copy files from a previous build stage to the final image -> Option B

4. Quick Check:

   COPY --from= copies from build stage [OK]

Hint: COPY --from= copies from build stage, not host or containers [OK]

Common Mistakes:

• Confusing COPY --from= with copying from host
• Thinking it copies files between containers
• Assuming it copies files back to build stage

2. Which of the following is the correct syntax to copy the file /app/build/output.bin from a build stage named builder to the final image's /app directory?

easy

A. COPY --from=builder /app/build/output.bin /app

B. COPY /app/build/output.bin /app --from=builder

C. COPY builder:/app/build/output.bin /app

D. COPY /app/build/output.bin builder:/app

Solution

1. Step 1: Recall COPY --from= syntax

   The correct syntax is COPY --from=stage source_path destination_path.

2. Step 2: Match the paths and stage name

   COPY --from=builder /app/build/output.bin /app correctly uses --from=builder followed by source and destination paths.

3. Final Answer:

   COPY --from=builder /app/build/output.bin /app -> Option A

4. Quick Check:

   Correct COPY --from= syntax is COPY --from=stage src dst [OK]

Hint: COPY --from= comes before source and destination paths [OK]

Common Mistakes:

• Placing --from= after source and destination
• Using colon syntax like builder:/path (invalid)
• Swapping source and destination paths

3. Given this Dockerfile snippet, what files will be present in the final image's /app directory?

FROM node:18 AS builder
WORKDIR /app
RUN echo "build file" > build.txt

FROM alpine
COPY --from=builder /app/build.txt /app/

medium

A. No /app directory created

B. An empty /app directory

C. The file build.txt with content "build file"

D. The file build.txt but empty

Solution

1. Step 1: Check build stage output

   The builder stage creates /app/build.txt with content "build file".

2. Step 2: COPY from builder to final image

   The final stage copies /app/build.txt from builder to /app/ in the final image.

3. Final Answer:

   The file build.txt with content "build file" -> Option C

4. Quick Check:

   File copied with content preserved [OK]

Hint: COPY --from= copies actual files, not empty placeholders [OK]

Common Mistakes:

• Assuming directory is empty after copy
• Thinking file content is lost
• Assuming /app directory is missing

4. Identify the error in this Dockerfile snippet that tries to copy from a build stage named builder:

FROM golang:1.20 AS builder
WORKDIR /app
RUN go build -o myapp

FROM alpine
COPY /app/myapp --from=builder /usr/local/bin/myapp

medium

A. The --from=builder flag is placed after the source path

B. The build stage name builder is missing

C. The destination path /usr/local/bin/myapp is invalid

D. The RUN go build command is incorrect

Solution

1. Step 1: Check COPY command syntax

   The correct syntax is COPY --from=builder source destination. The flag must come before paths.

2. Step 2: Identify error in given command

   The command places --from=builder after the source path, which is invalid syntax.

3. Final Answer:

   The --from=builder flag is placed after the source path -> Option A

4. Quick Check:

   --from= must come before source path [OK]

Hint: Place --from= before source path in COPY command [OK]

Common Mistakes:

• Putting --from= after source path
• Forgetting to name the build stage
• Assuming destination path is invalid without checking

5. You want to build a Docker image for a Python app. The build stage installs dependencies and creates a dist/app.tar.gz file. The final stage should only copy this archive and extract it to /app. Which Dockerfile snippet correctly copies and extracts the archive from the build stage named builder?

hard

A. FROM python:3.12 AS builder\nWORKDIR /src\nRUN pip install -r requirements.txt\nRUN tar czf dist/app.tar.gz .\n\nFROM python:3.12-slim\nWORKDIR /app\nCOPY --from=builder /src/dist/app.tar.gz /app/\nRUN tar xzf /app/app.tar.gz

B. FROM python:3.12 AS builder\nWORKDIR /src\nRUN pip install -r requirements.txt\nRUN tar czf dist/app.tar.gz .\n\nFROM python:3.12-slim\nWORKDIR /app\nCOPY /src/dist/app.tar.gz --from=builder ./\nRUN tar xzf app.tar.gz

C. FROM python:3.12 AS builder\nWORKDIR /src\nRUN pip install -r requirements.txt\nRUN tar czf dist/app.tar.gz .\n\nFROM python:3.12-slim\nWORKDIR /app\nCOPY --from=builder /dist/app.tar.gz ./\nRUN tar xzf app.tar.gz

D. FROM python:3.12 AS builder\nWORKDIR /src\nRUN pip install -r requirements.txt\nRUN tar czf dist/app.tar.gz .\n\nFROM python:3.12-slim\nWORKDIR /app\nCOPY --from=builder /src/dist/app.tar.gz ./\nRUN tar xzf app.tar.gz

Solution

1. Step 1: Verify COPY --from= syntax and source path

   The builder stage (WORKDIR /src) creates dist/app.tar.gz at /src/dist/app.tar.gz. Correctly uses COPY --from=builder /src/dist/app.tar.gz ./ with --from=builder first and absolute source path.

2. Step 2: Confirm extraction command and paths

   Final stage WORKDIR /app, copy to ./ places app.tar.gz there. RUN tar xzf app.tar.gz extracts correctly.

3. Final Answer:

   COPY --from=builder /src/dist/app.tar.gz ./\nRUN tar xzf app.tar.gz -> Option D

4. Quick Check:

   COPY --from= before source path, extract in correct directory [OK]

Hint: COPY --from= before source path; extract where file copied [OK]

Common Mistakes:

• Placing --from= after source path
• Using wrong source path like /dist/app.tar.gz instead of /src/dist/app.tar.gz
• Extracting archive from wrong directory