CMD and ENTRYPOINT are used in Docker to set the default command and fixed entry point when container starts. CMD provides default commands that can be overwritten, suitable for scenarios where flexible running mode is required; ENTRYPOINT executes specific commands regularly, and runtime parameters will be appended thereafter, suitable for ensuring that certain initialization steps or main process are always executed. The two can also be used in combination to take into account flexibility and control. The choice is based on the degree of flexibility or consistency of the desired container behavior.

When you're building Docker images, two instructions that often confuse newcomers are CMD and ENTRYPOINT . They both define what command gets run when a container starts, but they behave differently—especially when users pass arguments at runtime.

Understanding CMD: Default Command with Flexibility

The main purpose of CMD is to provide defaults for a running container. These defaults can include an executable and its arguments, but they're meant to be easily overridden by the user.

For example:

 CMD ["nginx", "-g", "daemon off;"]

This tells Docker to start nginx in the foreground if no other command is provided when the container runs. But if someone runs your image like this:

 docker run my-image echo "Hello"

Then "nginx", "-g", "daemon off;" will be replaced entirely with echo "Hello" .

So think of CMD as a suggestion —it's good for setting up default behavior, but it's not set in stone.

Key points:

• It defines the default command and/or arguments.
• Easily overridden by passing a new command at runtime.
• If you have multiple CMD lines in a Dockerfile, only the last one takes effect.

ENTRYPOINT: Setting a Fixed Starting Point

On the other hand, ENTRYPOINT sets the actual entry point of the container. It's more about fixing the command that runs, making sure some part of it doesn't change unless explicitly configured to do so.

Here's a typical use case:

 ENTRYPOINT ["docker-entrypoint.sh"]

In this case, even if someone adds a command at runtime, it will be passed as an argument to the entrypoint script. For example:

 docker run my-image redis-server --port 8888

That means the container actually runs:

 docker-entrypoint.sh redis-server --port 8888

This setup is useful when you want to make sure certain initialization steps always happen before launching the main process.

Key points:

• Defines the primary command that runs when the container starts.
• Arguments from the command line get appended to it (unless you override it with --entrypoint ).
• CMD values ??can act as default arguments to ENTRYPOINT .

When to Use CMD vs ENTRYPOINT

Choosing between them depends on how flexible or strict you want your container behavior to be.

Use CMD when:

• You want to allow easy customization of what runs.
• The image might be used in different ways depending on context.
• You're building something general-purpose, like a base image.

Use ENTRYPOINT when:

• You want to enforce a specific executable always runs.
• Your container behaves like a wrapper around a specific command or service.
• You need to do pre-processing (like configuration setup) before starting the main app.

Also, combining them is common and powerful:

 ENTRYPOINT ["nginx", "-g", "daemon off;"]
CMD ["-p", "8080:80"]

In this case, any extra flags you pass at runtime will be added after the ENTRYPOINT , letting you customize behavior without breaking the core command.

So while CMD gives flexibility and defaults, ENTRYPOINT ensures consistency and control over execution. Knowing how to use each—or combine them—can help you build better Docker images that work the way you expect.

Basically that's it.

The above is the detailed content of What is the difference between CMD and ENTRYPOINT in a Dockerfile?. For more information, please follow other related articles on the PHP Chinese website!