Docker Entrypoint vs CMD: What Is the Difference and How to Choose?

Docker is a platform that lets us run and manage applications inside containers. Before we can run an application inside a container, we must create a Docker image of the application using Dockerfiles. A Dockerfile is a text file that contains instructions that are executed by Docker to create the Docker image. Each instruction is composed of a directive and an argument. CMD and ENTRYPOINT are two such directives.

In this blog post, we’ll explore CMD and ENTRYPOINT, figure out what they do, understand the key difference between them, and most importantly learn when to use which. Let’s get started!

Prerequisites

To follow along with the examples in this post, you need a code editor. You also need to have Docker Desktop installed and running on your system. If you don’t have Docker Desktop, you can download it from the link: Get Docker.

What Is CMD in Dockerfile?

Let’s take a closer look at what CMD does inside a Dockerfile by diving into an example.

To follow along, open your code editor and create a directory named docker-demo. Inside this directory, create a file called Dockerfile. You can choose any name you prefer for the directory but the file must be named Dockerfile.

Next, copy and paste the following code into the Dockerfile.

FROM alpine
CMD ["echo", "Hello World!"]

In this Dockerfile, we have two instructions. Each instruction consists of a directive followed by an argument. Note that it’s a good practice to write the directives in UPPERCASE to distinguish them from the arguments.

In our case, we have two directives: FROM and CMD. The FROM directive is followed by the argument alpine, which is the parent image that our custom image is going to be built on top of. The parent image will be downloaded from Docker Hub, a cloud-based storage location for Docker images.

Next, we have the CMD directive that provides the default command (["echo", "Hello World!"]), which will be executed when a container is created from the custom Docker image (which we have not created yet).

In our example, the argument to CMD is ["echo", "Hello World!"]. The first string echo represents the executable and the second string Hello World! is the argument passed to the executable. When we run a container from the custom Docker image, the command ["echo", "Hello World!"] will be executed and we’ll see Hello World! printed in the terminal.  

To see the CMD directive in action, we need to build an image first and then run it as a container. While inside the docker-demo directory, run the following command to create a custom Docker image named custom-image:v1.

docker build . -t custom-image:v1

Don’t forget to use dot (.) after the build command. It indicates that the current directory (i.e. "docker-demo") should be used as the build context.

Running the command above will give you the following output:

Next, let's verify that the image has been created by listing the images in our system. Run the following command:

docker image list

Executing the command above will give you the following output:

As you can see, our custom image, custom-image:v1, is listed. Now, let's run this Docker image as a container by running the following command:

docker container run custom-image:v1

You will see that Hello World! is printed on the console, as shown below:

When we ran the Docker image named custom-image:v1 as a container, the command specified by the CMD directive (["echo", "Hello World!"]) was executed, resulting in the Hello World! message being displayed in the terminal.

The important thing to remember about the CMD directive is that we can override the default command when running the container. Let's demonstrate this by running the following command:

docker container run custom-image:v1 echo Hello KodeKloud!

After running this command, you’ll see Hello kodeKloud! printed on the terminal, as shown below:

The argument echo Hello KodeKloud! that we passed in the command line took precedence over the default argument ("Hello World!") specified in the Dockerfile.

Now that you have a clear understanding of the CMD directive and its functionality, let's explore the ENTRYPOINT directive and how it differs from CMD.

What Is ENTRYPOINT in Dockerfile?

Replace the code inside the Dockerfile with the following:

FROM alpine
ENTRYPOINT ["echo", "Hello World!"]

As you can see, the only change we have made in the Dockerfile is replacing CMD with ENTRYPOINT.

Next, let’s build a custom Docker image named custom-image:v2 by executing the following command:

docker build . -t custom-image:v2

Running the command above will provide you with the following output:

Now, let's verify that the image has been created by listing the images in our system. Run the following command:

docker image list

Executing the command above will display the following output:

As you can see, our custom image, custom-image:v2, is listed. Now, let's run this Docker image as a container by running the following command:

docker container run custom-image:v2

You will see that Hello World! is printed on the console, as shown below:

This result is identical to what we obtained with the CMD directive. So, what’s the difference between them?

Unlike the CMD directive, we can’t override the default command of the ENTRYPOINT directive. Let’s see this in action by executing the following command:

docker container run custom-image:v2 echo Hello kodeKloud!

After running the above command, you’ll receive an output like this:

As you can see, the argument ("echo Hello KodeKloud!") we passed in the command line is appended to the default argument ("Hello World!") specified in the Dockerfile. It doesn’t replace the default argument.

Now you should have a clear understanding of the functionality of the ENTRYPOINT directive inside a Dockerfile.

Up until now, we have used the CMD and ENTRYPOINT directives individually in the Dockerfile. However, they can also be used together. Let's explore how in the next section.

Using CMD & ENTRYPOINT Together

Replace the contents of your Dockerfile with the following:

FROM alpine
ENTRYPOINT ["echo", "Hello"]
CMD ["World!"]

In this Dockerfile, the ENTRYPOINT directive specifies the default command that will get executed when a container is run from the custom Docker image. The CMD directive, on the other hand,  provides the default argument for the `ENTRYPOINT` directive.

Let’s create a Docker image from this Dockerfile by running the following command:

docker build . -t custom-image:v3

Executing the command above will generate the following output:

Now, let's verify that the image has been created by listing the images in our system. Run the following command:

docker image list

Executing the command above will display the following output:

As you can see, our custom image, custom-image:v3, is listed. Now, let's run this Docker image as a container by running the following command:

docker container run custom-image:v3

You will observe that Hello World! is printed on the console, as shown below:

You might be wondering what’re the benefits of using CMD and ENTRYPOINT directives together in the same Dockerfile. Well, the combination is useful when you not only want to provide a default command to run but also give users the flexibility to provide command-line arguments so that they can get the custom output they want.

In the Dockerfile above, we can’t override the default command specified by the ENTRYPOINT directive. However, we can override the arguments specified by the CMD directive. For example, we could pass another argument from the command line to override the text World!. The argument we pass will then be appended to Hello.

To see this in action, run the following command:

docker container run custom-image:v3 KodeKloud!

Executing the command above will display the following output:

As you can see, the text World! is replaced by the text KodeKloud! and we see Hello KodeKloud! printed on the terminal.

Difference Between CMD & ENTRYPOINT

Both CMD and ENTRYPOINT directives serve the same purpose. They provide default commands to be executed when a Docker image is run as a container. However, they differ in how their arguments behave.

The main distinction is that the argument passed to the ENTRYPOINT directive cannot be overridden, while the argument passed to the CMD directive can. This means that the ENTRYPOINT directive sets a fixed command that cannot be modified when running the container, whereas the CMD directive allows for flexibility in specifying alternative arguments.

Choosing between CMD and ENTRYPOINT depends on your specific requirements. However, it is a common practice to use both directives together. The ENTRYPOINT directive is used to define the default command, while the CMD directive is used to pass default arguments to the ENTRYPOINT directive.

Here is a summary of the difference between CMD and ENTRYPOINT in a table form:

Conclusion

In this blog post, we learned what purpose CMD and ENTRYPOINT directives server inside a Dockerfile. We also understood how they differ in their functionality and when we should choose each. Now, you should be able to use these directives confidently in your Dockerfile when building Docker images.

Interested in learning more about Docker? Check out the following courses from KodeKloud:

• Docker for the Absolute Beginner: This course will help you understand Docker using lectures and demos. You’ll get a hands-on learning experience and coding exercises that will validate your Docker skills.  Additionally, assignments will challenge you to apply your skills in real-life scenarios.
• Docker Certified Associate Exam Course: This course covers all the required topics from the Docker Certified Associate Exam curriculum. The course offers several opportunities for practice and self-assessment. There are hundreds of research questions in multiple-choice format, practice tests at the end of each section, and multiple mock exams that closely resemble the actual exam pattern.