Docker ENTRYPOINT and CMDDockerfile best practices for running containersryanwhocodesBlockedUnblockFollowFollowingJun 17Docker commands for running containers are configured using the Dockerfile instructions ENTRYPOINT and CMD, which are written as entrypoint and command in Docker Compose YAML files.

Entrypoints are used to always run specific commands and configuration setup before those that are defined using CMD / command.

This tutorial will explain the differences between them and how to best use them in your Dockerfiles.

Table of Contents* What Is a Container Entrypoint?* Dockerfile ENTRYPOINT* The Exec Syntax* Using an Entrypoint Script* Docker Compose Entrypoint* Overriding Entrypoint* CMD / Command* CMD in Dockerfiles* Docker Compose Command* Overriding CMD* Best Practices* Usage of Best Practices* Syntax Best Practices* Summary* External LinksWhat Is a Container Entrypoint?The entrypoint sets the command and parameters that will be executed first when a container is run.

Any command line arguments passed to docker run <image> will be appended to the ENTRYPOINT command, and will override all elements specified using CMD.

For example, docker run <image> bash will add the command argument bash to the end of the entrypoint.

Dockerfile ENTRYPOINTDockerfiles use all uppercase letters for the entrypoint instruction.

There are several ways you can define this.

The Exec SyntaxThe exec form is where you specify commands and arguments as a JSON array.

This means you need to use double quotes rather than single quotes.

ENTRYPOINT ["executable", "param1", "param2"]Using this syntax, Docker will not use a command shell, which means that normal shell processing does not happen.

If you need shell processing features, then you can start the JSON array with the shell command.

ENTRYPOINT [ "sh", "-c", "echo $HOME" ]Using an Entrypoint ScriptAnother option is to use a script to run entrypoint commands for the container.

By convention, it often includes entrypointing the name.

In this script, you can setup the app as well as load any configuration and environment variables.

Here is an example of how you can run it in a Dockerfile with the ENTRYPOINT exec syntax.



sh /ENTRYPOINT ["/docker-entrypoint.

sh"]CMD ["postgres"]Docker Compose EntrypointThe entrypoint instruction that you use in your Docker Compose files is the same, except you use lowercase letters.

entrypoint: /code/entrypoint.

shYou can also define the entrypoint with lists in your docker-compose.


entrypoint: – php – -d – zend_extension=/usr/local/lib/php/xdebug.

so – -d – memory_limit=-1 – vendor/bin/phpunitOverriding EntrypointYou can override entrypoint instructions using the flag –entrypoint.

Example for the Docker CLI run command:$ docker run -it –entrypoint /usr/bin/redis-cli example/redis –helpHere is how you might use it with the Docker Compose CLI:$ docker run -it –entrypoint /usr/bin/redis-cli example/redis –helpCMD / CommandThe main purpose of a CMD (Dockerfiles), which is written as command in Docker Compose files, is to provide defaults when executing a container.

These will be executed after the entrypoint.

For example, if you run docker run <image>, then the commands and parameters specified by CMD / command in your Dockerfiles are executed.

CMD in DockerfilesIn Dockerfiles, you can define CMD defaults that include an executable.

For example:CMD ["executable","param1","param2"]If they omit the executable, you must specify an ENTRYPOINT instruction as well.

CMD ["param1","param2"] # (as default parameters to ENTRYPOINT)NOTE: There can only be one CMD instruction in a Dockerfile.

If you list more than one CMD, then only the last CMD will take effect.

Docker Compose CommandWhen using Docker Compose, you can define the same instruction in your docker-compose.

yml, but it is written in lowercase as the full word command.

command: ["bundle", "exec", "thin", "-p", "3000"]Overriding CMDYou can override the commands specified by CMD when you run a container.

docker run rails_app rails consoleIf the user specifies arguments to docker run, then they will override the default specified in CMD.

Best PracticesAlthough there are different ways to use these instructions, Docker gives some guidance on best practices for their use and syntax.

Usage of Best PracticesDocker recommends using ENTRYPOINT to set the image’s main command, and then using CMD as the default flags.

Here is an example Dockerfile that uses both instructions.

FROM ubuntuENTRYPOINT ["top", "-b"]CMD ["-c"]Syntax Best PracticesAs well as the exec syntax, Docker allows shell syntax as another valid option for both ENTRYPOINT and CMD.

This executes this command as a string and performs variable substitution.

ENTRYPOINT command param1 param2CMD command param1 param2However, this tutorial did not emphasise it, due the exec syntax being seen as best practice.

The Dockerfile reference explains more about some of the issues.

The shell form prevents any CMD or run command line arguments from being used, but has the disadvantage that your ENTRYPOINT will be started as a subcommand of /bin/sh -c, which does not pass signals.

This means that the executable will not be the container’s PID 1 — and will not receive Unix signals — so your executable will not receive a SIGTERM from docker stop <container>.

SummaryBoth CMD and ENTRYPOINT instructions define which command gets executed when running a container.

There are a few rules that describe how they interact.

Dockerfiles should specify at least one of CMD or ENTRYPOINT commands.

ENTRYPOINT should be defined when using the container as an executable.

CMD should be used as a way of defining default arguments for an ENTRYPOINT command or for executing an ad-hoc command in a container.

CMD will be overridden when running the container with alternative arguments.

External Linksdocker.

comDocker reference documentation | Docker docsDockerfile reference — Docker docsDockerfile best practices — Docker docsentrypoint in Docker Compose files — Docker docsentrypoint option for Docker run — Docker docs.

. More details

Leave a Reply