CMD vs ENTRYPOINT in Docker 🐳 | Key Differences Explained

This comprehensive study note explores two of the most important instructions in a Dockerfile: CMD and ENTRYPOINT. Mastering these instructions is crucial not only for building robust, configurable containerized applications but also for navigating container orchestration and technical interviews.

1. Why Do We Need Container Instructions?

When building container images, we need a way to define what command execution runs when a container starts from that image. While a Dockerfile sets up the filesystem, dependencies, and environment, instructions like CMD and ENTRYPOINT dictate the runtime executable behavior.

Understanding how these instructions handle arguments, defaults, and runtime overrides prevents unexpected application startup failures in production environments.

2. Core Mental Model & Behavior Summary

The fundamental distinction between CMD and ENTRYPOINT lies in how they handle command-line arguments passed during a docker run execution:

• CMD: Acts as a default command that can be completely overwritten at runtime when you pass alternative arguments to docker run.
• ENTRYPOINT: Acts as a fixed executable where any arguments passed during docker run are appended to the entrypoint command rather than replacing it.
• Combined (ENTRYPOINT + CMD): When used together, ENTRYPOINT serves as the base executable command, and CMD supplies the default arguments to that executable.

3. Deep Dive into CMD (Default Overridable Command)

The CMD instruction provides defaults for an executing container. If you specify CMD in your Dockerfile, those defaults can be seamlessly overridden by providing a new command string when running the container.

Step-by-Step Hands-On: CMD Demo

1. Create the Dockerfile:

   DOCKERFILE

   Copy

   FROM ubuntu
   CMD ["echo", "hello from CMD"]
   

2. Build the Docker Image:

   BASH

   Copy

   docker build -t cmd-demo .
   

3. Run the Container (Using Default CMD):

   BASH

   Copy

   docker run cmd-demo
   

   • Output:
     TEXT

     Copy

     hello from CMD
     

4. Override the Default Command at Runtime:

   BASH

   Copy

   docker run cmd-demo echo "hi another"
   

   • Output:
     TEXT

     Copy

     hi another
     

   Note: Notice how the entire default command (hello from CMD) was completely replaced by the runtime argument (hi another).

4. Deep Dive into ENTRYPOINT (Fixed Executable with Argument Appending)

Unlike CMD, the ENTRYPOINT instruction configures a container that will run as an executable. When you pass arguments to docker run with an entrypoint image, those arguments are appended to the entrypoint command.

Working with Custom Dockerfile Names (-f Flag)

When testing multiple Dockerfiles in the same directory, you can name them uniquely (e.g., new-Dockerfile) and reference them during the build process using the -f flag.

Step-by-Step Hands-On: ENTRYPOINT Demo

1. Create a Custom new-Dockerfile:

   DOCKERFILE

   Copy

   FROM ubuntu
   ENTRYPOINT ["echo", "hello from entrypoint"]
   

2. Build the Image Using -f:

   BASH

   Copy

   docker build -t entrypoint-demo -f new-Dockerfile .
   

3. Run the Container (Default Behavior):

   BASH

   Copy

   docker run entrypoint-demo
   

   • Output:
     TEXT

     Copy

     hello from entrypoint
     

4. Attempt to Override/Append at Runtime:

   BASH

   Copy

   docker run entrypoint-demo "try override"
   

   • Output:
     TEXT

     Copy

     hello from entrypoint try override
     

   Note: Instead of replacing the original text (like CMD did), ENTRYPOINT kept the original command and appended "try override" to the end.

5. Combining ENTRYPOINT and CMD

You can combine both instructions in a single Dockerfile. In this architectural pattern, ENTRYPOINT defines the base binary or command, and CMD provides the default arguments that can be overridden at runtime.

Step-by-Step Hands-On: Combo Demo

1. Create a combo Dockerfile:

   DOCKERFILE

   Copy

   FROM ubuntu
   ENTRYPOINT ["echo"]
   CMD ["hello from combo file"]
   

2. Build the Combo Image:

   BASH

   Copy

   docker build -t combo-demo -f combo .
   

3. Run without Runtime Arguments (Uses Default CMD):

   BASH

   Copy

   docker run combo-demo
   

   • Output:
     TEXT

     Copy

     hello from combo file
     

4. Run with Runtime Arguments (Overrides CMD arguments):

   BASH

   Copy

   docker run combo-demo "hi Shubham"
   

   • Output:
     TEXT

     Copy

     hi Shubham
     

   Note: Here, echo remained the fixed ENTRYPOINT, while "hello from combo file" was replaced by "hi Shubham" supplied via the runtime override.

6. Comparative Synthesis: CMD vs ENTRYPOINT

7. Summary and Key Takeaways

• CMD Default Behavior: Serves as a default command that is completely overwritten when new arguments are passed to docker run.
• ENTRYPOINT Behavior: Configures a container to run as an executable where runtime arguments are appended rather than replacing the instruction.
• Custom Dockerfile Names: You can build images from non-standard filenames using the Docker build flag -f <filename>.
• Overriding CMD: Passing docker run image-name new-command completely discards the CMD string defined in the image.
• Appending ENTRYPOINT: Passing arguments to an entrypoint-enabled container attaches those arguments directly to the end of the entrypoint array.
• Synergistic Combo Pattern: Using ENTRYPOINT for the core executable and CMD for default arguments gives container users maximum flexibility without sacrificing base execution logic.
• Interview Relevance: Clearly understanding how runtime arguments interact with CMD vs ENTRYPOINT is a standard fundamental question in DevOps and containerization interviews.