ARG and ENV instructions in Docker - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

Output of ARG and ENV in Dockerfile build

Given the Dockerfile below, what will be the output of the command docker build . when it prints the environment variable?

Docker

FROM alpine
ARG APP_VERSION=1.0
ENV APP_VERSION=$APP_VERSION
RUN echo "App version is $APP_VERSION"

A App version is null

B App version is

C App version is $APP_VERSION

D App version is 1.0

💡 Hint

Remember ARG is available only during build, ENV sets environment variables for runtime and build.

The ARG APP_VERSION is set to 1.0 during build. The ENV instruction sets APP_VERSION to the ARG value, so the RUN command prints the value 1.0.

🧠 Conceptual

intermediate

Difference between ARG and ENV in Dockerfile

Which statement correctly describes the difference between ARG and ENV instructions in a Dockerfile?

A ARG is only available during build time; ENV is available during build and runtime.

B ENV is only available during build time; ARG is available during build and runtime.

C Both ARG and ENV are only available during runtime.

D ARG and ENV are identical and interchangeable.

💡 Hint

Think about when you can access these variables: during image build or when running the container.

ARG variables exist only during the image build process. ENV variables persist in the image and are available when the container runs.

❓ Troubleshoot

advanced

Why does ENV not get the ARG value at runtime?

Consider this Dockerfile snippet:

ARG PORT=8080
ENV PORT=80
CMD echo $PORT

What will be the output when running the container, and why?

A Empty output, because PORT is not set at runtime.

B 8080, because ARG PORT is used at runtime.

C 80, because ENV PORT overrides ARG PORT and is used at runtime.

D Syntax error during build.

💡 Hint

ENV sets the environment variable inside the image, ARG does not persist after build.

ENV PORT=80 sets the environment variable PORT inside the image. ARG PORT=8080 is only available during build and does not affect runtime environment variables.

🔀 Workflow

advanced

Passing build-time ARG and runtime ENV variables

You want to build a Docker image with a build-time variable VERSION defaulting to 1.0, and also allow overriding a runtime environment variable APP_MODE when running the container. Which Dockerfile and run command combination achieves this?

A

Dockerfile:
ENV VERSION=1.0
ARG APP_MODE=production
RUN echo $APP_MODE

Run: docker run -e VERSION=development image

B

Dockerfile:
ARG VERSION=1.0
ENV APP_MODE=production
RUN echo $VERSION

Run: docker run -e APP_MODE=development image

C

Dockerfile:
ARG VERSION=1.0
ENV APP_MODE=production
RUN echo $APP_MODE

Run: docker run image

D

Dockerfile:
ENV VERSION=1.0
ENV APP_MODE=production
RUN echo $VERSION

Run: docker run -e APP_MODE=development image

💡 Hint

Remember ARG is for build-time, ENV sets default runtime variables, and -e overrides runtime variables.

ARG VERSION=1.0 sets a build-time variable. ENV APP_MODE=production sets a default runtime variable. The run command overrides APP_MODE with development.

✅ Best Practice

expert

Secure handling of sensitive data with ARG and ENV

Which approach is best to avoid leaking sensitive data like passwords in Docker images using ARG and ENV?

A Use ARG for sensitive data and do not set it as ENV to avoid storing it in the image layers.

B Use ENV for sensitive data so it is available at runtime and build time.

C Hardcode sensitive data in the Dockerfile for consistency.

D Use ENV and ARG together to store sensitive data in both build and runtime.

💡 Hint

Think about which variables persist in the final image layers and which do not.

ARG variables are not persisted in the final image layers, so sensitive data passed as ARG is not stored in the image. ENV variables are stored in image layers and can be seen by anyone with the image.

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