ENTRYPOINT vs CMD difference in Docker - Practice Questions

Challenge - 5 Problems

🧠 Conceptual

intermediate

Difference between ENTRYPOINT and CMD in Docker

Which statement best describes the difference between ENTRYPOINT and CMD in a Dockerfile?

A <code>CMD</code> sets the main command that always runs, while <code>ENTRYPOINT</code> provides default arguments that can be overridden at runtime.

B <code>ENTRYPOINT</code> sets the main command that always runs, while <code>CMD</code> provides default arguments that can be overridden at runtime.

C <code>ENTRYPOINT</code> and <code>CMD</code> are interchangeable and have no difference in behavior.

D <code>CMD</code> is used only for environment variables, while <code>ENTRYPOINT</code> runs the main command.

💡 Hint

Think about which instruction defines the fixed command and which one sets default parameters.

ENTRYPOINT defines the executable that always runs when the container starts. CMD provides default arguments to ENTRYPOINT or runs a command if ENTRYPOINT is not set. CMD can be overridden by command line arguments when running the container.

💻 Command Output

intermediate

Output of Docker container with ENTRYPOINT and CMD

Given this Dockerfile snippet, what will be the output when running docker run myimage?

ENTRYPOINT ["echo"]
CMD ["Hello World"]

A No output, container exits immediately

B echo Hello World

C Hello World

D Error: invalid command

💡 Hint

Remember how ENTRYPOINT and CMD combine when both are arrays.

ENTRYPOINT sets the command echo. CMD provides the default argument Hello World. Running the container executes echo Hello World, printing Hello World.

🔀 Workflow

advanced

Combining ENTRYPOINT and CMD for flexible container commands

You want a Docker container that always runs python3 but allows users to pass different scripts or arguments when running the container. Which Dockerfile setup achieves this?

A

ENTRYPOINT ["python3"]
CMD ["script.py"]

B CMD ["python3", "script.py"]

C

ENTRYPOINT ["script.py"]
CMD ["python3"]

D

CMD ["script.py"]
ENTRYPOINT ["python3"]

💡 Hint

Think about which instruction fixes the executable and which provides default arguments.

Setting ENTRYPOINT to python3 fixes the executable. CMD provides a default script script.py. Users can override script.py by passing arguments to docker run.

❓ Troubleshoot

advanced

Why does overriding CMD not change the command when ENTRYPOINT is set?

You have this Dockerfile:

ENTRYPOINT ["/bin/bash"]
CMD ["-c", "echo Hello"]

Running docker run myimage ls does not list files but opens a bash shell. Why?

A Because the Dockerfile syntax is invalid and causes fallback to default shell.

B Because <code>CMD</code> always overrides <code>ENTRYPOINT</code> and <code>ls</code> is ignored.

C Because <code>docker run</code> ignores command line arguments when ENTRYPOINT is set.

D Because <code>ENTRYPOINT</code> is fixed to <code>/bin/bash</code> and <code>ls</code> is passed as argument, overriding CMD but not changing ENTRYPOINT.

💡 Hint

Consider how command line arguments interact with ENTRYPOINT and CMD.

ENTRYPOINT fixes the executable to /bin/bash. When you run docker run myimage ls, ls replaces the CMD arguments but does not change the ENTRYPOINT. So the container runs /bin/bash ls, which opens bash with ls as argument, not executing ls as a command.

✅ Best Practice

expert

Best practice for making a Docker container behave like a command-line tool

You are creating a Docker image for a CLI tool. You want users to run commands like docker run tool image.jpg and have tool process image.jpg. Which Dockerfile setup is best?

A Use <code>ENTRYPOINT</code> to set the tool executable and <code>CMD</code> to provide default arguments or none.

B Use only <code>CMD</code> to set the tool executable and arguments.

C Do not use <code>ENTRYPOINT</code> or <code>CMD</code>; require users to specify full command.

D Use <code>ENTRYPOINT</code> to set default arguments and <code>CMD</code> to set the executable.

💡 Hint

Think about fixing the executable and allowing flexible arguments.

Setting ENTRYPOINT to the CLI tool executable fixes the command. CMD can provide default arguments or be empty. This lets users pass arguments like filenames when running the container, making it behave like a normal CLI tool.

Practice

1. What is the primary role of ENTRYPOINT in a Dockerfile?

easy

A. It provides default arguments for the command.

B. It specifies environment variables for the container.

C. It sets the main command that always runs when the container starts.

D. It defines the working directory inside the container.

Solution

1. Step 1: Understand ENTRYPOINT purpose

   ENTRYPOINT defines the main command that runs every time the container starts, making it fixed.

2. Step 2: Compare with CMD

   CMD provides default arguments or a default command only if ENTRYPOINT is not set, so it is not the main command itself.

3. Final Answer:

   It sets the main command that always runs when the container starts. -> Option C

4. Quick Check:

   ENTRYPOINT = main fixed command [OK]

Hint: ENTRYPOINT fixes the command, CMD sets defaults [OK]

Common Mistakes:

• Confusing CMD as the main command
• Thinking ENTRYPOINT sets environment variables
• Mixing ENTRYPOINT with working directory

2. Which of the following is the correct syntax to set ENTRYPOINT in a Dockerfile?

easy

A. ENTRYPOINT = "/bin/bash -c"

B. ENTRYPOINT ["/bin/bash", "-c"]

C. ENTRYPOINT [/bin/bash, "-c"]

D. ENTRYPOINT: /bin/bash -c

Solution

1. Step 1: Recall ENTRYPOINT syntax

   ENTRYPOINT uses JSON array syntax to specify the executable and its arguments, e.g. ["executable", "arg1"].

2. Step 2: Identify correct option

   ENTRYPOINT ["/bin/bash", "-c"] uses the correct JSON array format. Options A, B, and D use invalid syntax for Dockerfile ENTRYPOINT.

3. Final Answer:

   ENTRYPOINT ["/bin/bash", "-c"] -> Option B

4. Quick Check:

   ENTRYPOINT uses JSON array syntax [OK]

Hint: Use JSON array syntax for ENTRYPOINT [OK]

Common Mistakes:

• Using shell form without brackets for ENTRYPOINT
• Adding equal sign or colon incorrectly
• Using plain string without quotes

3. Given this Dockerfile snippet:

ENTRYPOINT ["echo"]
CMD ["Hello", "World"]

What will be the output when running the container without extra arguments?

medium

A. Hello World

B. echo Hello World

C. No output

D. Error: command not found

Solution

1. Step 1: Understand ENTRYPOINT and CMD interaction

   ENTRYPOINT sets the fixed command 'echo'. CMD provides default arguments 'Hello' and 'World'.

2. Step 2: Combine command and arguments

   Running the container runs 'echo Hello World', printing 'Hello World'.

3. Final Answer:

   Hello World -> Option A

4. Quick Check:

   ENTRYPOINT + CMD = echo Hello World [OK]

Hint: ENTRYPOINT command + CMD args run together [OK]

Common Mistakes:

• Thinking CMD overrides ENTRYPOINT command
• Expecting full command string printed
• Assuming no output without arguments

4. You wrote this Dockerfile:

ENTRYPOINT echo
CMD Hello World

But when you run the container, it produces unexpected output. What is the problem?

medium

A. Dockerfile must end with CMD, not ENTRYPOINT.

B. CMD cannot have multiple words without quotes.

C. ENTRYPOINT cannot be used with CMD.

D. ENTRYPOINT must be in JSON array form to avoid shell parsing errors.

Solution

1. Step 1: Check ENTRYPOINT syntax

   ENTRYPOINT without JSON array uses shell form, but 'echo' alone may cause parsing issues or unexpected behavior.

2. Step 2: Correct syntax requirement

   Using JSON array form like ["echo"] ensures proper command execution without shell interpretation errors.

3. Final Answer:

   ENTRYPOINT must be in JSON array form to avoid shell parsing errors. -> Option D

4. Quick Check:

   ENTRYPOINT needs JSON array for safety [OK]

Hint: Use JSON array for ENTRYPOINT to avoid errors [OK]

Common Mistakes:

• Using plain string ENTRYPOINT causing errors
• Misunderstanding CMD syntax rules
• Thinking ENTRYPOINT and CMD cannot be combined

5. You want a Docker container that always runs python app.py, but allows users to add extra arguments like --debug. How should you write ENTRYPOINT and CMD in the Dockerfile?

hard

A. ENTRYPOINT ["python", "app.py"] and CMD ["--debug"]

B. ENTRYPOINT ["python"] and CMD ["app.py", "--debug"]

C. CMD ["python", "app.py", "--debug"] only

D. ENTRYPOINT ["python", "app.py", "--debug"] only

Solution

1. Step 1: Fix main command with ENTRYPOINT

   Set ENTRYPOINT to ["python", "app.py"] so this command always runs.

2. Step 2: Provide default extra arguments with CMD

   Set CMD to ["--debug"] so users can override or add arguments when running the container.

3. Step 3: Understand combined behavior

   Docker runs ENTRYPOINT command plus CMD arguments, allowing flexibility with fixed main command.

4. Final Answer:

   ENTRYPOINT ["python", "app.py"] and CMD ["--debug"] -> Option A

5. Quick Check:

   ENTRYPOINT fixes command, CMD adds default args [OK]

Hint: ENTRYPOINT fixes command, CMD adds default args [OK]

Common Mistakes:

• Putting all commands in CMD only
• Using ENTRYPOINT without CMD for defaults
• Mixing order causing command override