ARG and ENV instructions in Docker - Mini Project: Build & Apply

Using ARG and ENV Instructions in Dockerfiles

📖 Scenario: You are creating a Docker image for a simple web application. You want to use build-time variables and environment variables inside the Dockerfile to customize the image.

🎯 Goal: Build a Dockerfile that uses ARG to accept a build-time variable and ENV to set an environment variable inside the container.

📋 What You'll Learn

Create a build argument named APP_VERSION with default value 1.0

Set an environment variable named APP_ENV with value production

Use the APP_VERSION argument to label the image

Print the values of APP_VERSION and APP_ENV inside the container

💡 Why This Matters

🌍 Real World

Dockerfiles often need to accept variables at build time and set environment variables for the running container. This project shows how to do both simply.

💼 Career

Understanding ARG and ENV is essential for DevOps roles that involve containerization and building Docker images for deployment.

1

Create a Dockerfile with base image

Create a Dockerfile starting with the base image alpine:latest.

Docker

# Start your Dockerfile with the base image alpine:latest
# Your code here

Hint

The first line in a Dockerfile usually specifies the base image using FROM.

2

Add ARG instruction for build-time variable

Add an ARG instruction named APP_VERSION with default value 1.0.

Docker

FROM alpine:latest
# Add ARG instruction for APP_VERSION with default 1.0
# Your code here

Hint

Use ARG APP_VERSION=1.0 to define a build argument with a default value.

3

Use ARG to label image and add ENV instructions

Add a LABEL instruction using APP_VERSION to label the image, ENV APP_VERSION=${APP_VERSION} to make it available at runtime, and ENV APP_ENV=production.

Docker

FROM alpine:latest
ARG APP_VERSION=1.0
# Add LABEL using APP_VERSION, ENV APP_VERSION=${APP_VERSION}, ENV APP_ENV=production
# Your code here

Hint

Use LABEL version=${APP_VERSION} to label with the ARG, ENV APP_VERSION=${APP_VERSION} to expose ARG at runtime, and ENV APP_ENV=production.

4

Print ARG and ENV values in container

Add a CMD instruction to print the values of APP_VERSION and APP_ENV using echo.

Docker

FROM alpine:latest
ARG APP_VERSION=1.0
LABEL version=${APP_VERSION}
ENV APP_VERSION=${APP_VERSION}
ENV APP_ENV=production
# Add CMD to print APP_VERSION and APP_ENV
# Your code here

Hint

Use CMD echo "App version is $APP_VERSION and environment is $APP_ENV" to print the variables.

Practice

1. What is the main difference between ARG and ENV instructions in a Dockerfile?

easy

A. ARG defines build-time variables, ENV defines runtime environment variables.

B. ARG defines runtime environment variables, ENV defines build-time variables.

C. ARG and ENV are exactly the same and interchangeable.

D. ARG is used to set default ports, ENV sets user permissions.

Solution

1. Step 1: Understand ARG usage

   ARG defines variables that are only available during the image build process. They cannot be accessed after the image is built.

2. Step 2: Understand ENV usage

   ENV sets environment variables that persist in the built image and are available at runtime inside containers.

3. Final Answer:

   ARG defines build-time variables, ENV defines runtime environment variables. -> Option A

4. Quick Check:

   ARG = build-time, ENV = runtime [OK]

Hint: Remember: ARG is build-time, ENV is runtime [OK]

Common Mistakes:

• Confusing ARG as runtime variable
• Thinking ENV variables are only for build-time
• Assuming ARG persists in the final image
• Mixing up the purpose of ARG and ENV

2. Which of the following is the correct syntax to declare a build argument named VERSION with a default value 1.0 in a Dockerfile?

easy

A. ARG VERSION : 1.0

B. ENV VERSION=1.0

C. ARG VERSION=1.0

D. ENV VERSION : 1.0

Solution

1. Step 1: Recall ARG syntax

   The correct syntax to declare a build argument with a default value is ARG name=value. So ARG VERSION=1.0 is valid.

2. Step 2: Check other options

   ENV is for environment variables, not build arguments. The colon syntax is invalid in Dockerfile.

3. Final Answer:

   ARG VERSION=1.0 -> Option C

4. Quick Check:

   ARG syntax uses equals sign (=) [OK]

Hint: ARG uses '=' to assign default values [OK]

Common Mistakes:

• Using ENV instead of ARG for build arguments
• Using colon (:) instead of equals (=)
• Omitting the default value syntax
• Confusing ARG and ENV syntax

3. Given the Dockerfile snippet:

ARG APP_VERSION=2.0
ENV APP_VERSION=$APP_VERSION
RUN echo $APP_VERSION

What will be the output of the RUN echo $APP_VERSION command during build if no build argument is passed?

medium

A. Error: variable not found

B. $APP_VERSION

C. empty line

D. 2.0

Solution

1. Step 1: Understand ARG default value

   ARG APP_VERSION=2.0 sets a default build argument value of "2.0" if none is passed.

2. Step 2: ENV uses ARG value

   ENV APP_VERSION=$APP_VERSION sets an environment variable using the ARG value, so it becomes "2.0".

3. Step 3: RUN command output

   RUN echo $APP_VERSION prints the environment variable value "2.0" during build.

4. Final Answer:

   2.0 -> Option D

5. Quick Check:

   ARG default used in ENV, echoed as 2.0 [OK]

Hint: ARG default flows into ENV if no override [OK]

Common Mistakes:

• Expecting empty output if no build arg passed
• Thinking $APP_VERSION is literal string
• Assuming error if variable not passed
• Confusing build-time and runtime variable scopes

4. Identify the error in this Dockerfile snippet:

ARG PORT
ENV PORT=8080
EXPOSE $PORT

medium

A. You cannot use variables in the EXPOSE instruction.

B. The ENV variable PORT overrides ARG but EXPOSE uses $PORT which is not expanded.

C. The ARG variable PORT is not given a default value.

D. The ENV instruction must come before ARG.

Solution

1. Step 1: Check variable usage in EXPOSE

   The EXPOSE instruction does not support variable expansion. Using $PORT will not work.

2. Step 2: Validate other statements

   Not giving a default to ARG PORT is allowed. ENV can override ARG. The order of ARG and ENV is not restricted.

3. Final Answer:

   You cannot use variables in the EXPOSE instruction. -> Option A

4. Quick Check:

   EXPOSE does not expand variables [OK]

Hint: EXPOSE needs literal port numbers, no variables allowed [OK]

Common Mistakes:

• Assuming EXPOSE supports variable expansion
• Thinking ARG must have default value
• Believing ENV must come after ARG
• Confusing build-time and runtime variable scopes

5. You want to build a Docker image that accepts a build argument APP_ENV with default production and sets an environment variable APP_ENV inside the container accordingly. Which Dockerfile snippet correctly achieves this?

hard

A. ENV APP_ENV=production
ARG APP_ENV
ENV APP_ENV=$APP_ENV

B. ARG APP_ENV=production
ENV APP_ENV=$APP_ENV

C. ARG APP_ENV
ENV APP_ENV=production

D. ENV APP_ENV=$APP_ENV
ARG APP_ENV=production

Solution

1. Step 1: Set ARG with default value

   ARG APP_ENV=production defines the build argument with default "production" if none is passed.

2. Step 2: Set ENV using ARG value

   ENV APP_ENV=$APP_ENV sets the runtime environment variable to the ARG value, so it reflects the build argument or default.

3. Step 3: Validate other options

   ENV APP_ENV=production ARG APP_ENV ENV APP_ENV=$APP_ENV sets ENV before ARG which is invalid. ARG APP_ENV ENV APP_ENV=production does not set default for ARG. ENV APP_ENV=$APP_ENV ARG APP_ENV=production uses ENV before ARG which is incorrect.

4. Final Answer:

   ARG APP_ENV=production ENV APP_ENV=$APP_ENV -> Option B

5. Quick Check:

   ARG default then ENV from ARG [OK]

Hint: Declare ARG with default, then ENV using ARG variable [OK]

Common Mistakes:

• Setting ENV before ARG
• Not providing default value for ARG
• Overwriting ENV without ARG reference
• Confusing build-time and runtime variable order