What is the difference between entrypoint and cmd under docker?

The difference between entrypoint and cmd under docker is: 1. The CMD command runs an executable file and provides parameters. Parameters can be specified for ENTRYPOINT; 2. The ENTRYPOINT command itself can also contain parameters, and the changed parameters will not is covered.

The difference between entrypoint and cmd under docker is:

1. CMD command:

CMD provides some commands and parameters when the container is running. The usage is as follows:

• CMD ["executable", "param1", "param2"] (exec form , this is the preferred form)

• CMD ["param1","param2"] (as default parameters to ENTRYPOINT)

• CMD command param1 param2 (shell form)

First usage: run an executable file and provide parameters.

Second usage: Specify parameters for ENTRYPOINT.

The third usage (shell form): is a command executed with the "/bin/sh -c" method.

If you specify:

CMD [“/bin/echo”, “this is a echo test ”]

run after build (assuming the image is named ec):

docker run ec

will output:

this is a echo test

Doesn’t it feel weird? Like startup items, you can temporarily understand it this way.

Note:

docker runIf the parameters are specified in the command, the parameters in the CMD will be overwritten: (Here To explain, for example: docker run -it ubuntu /bin/bash The parameters of the command refer to /bin/bash instead of -it, -it is just a parameter of docker, not a parameter of the container, as described below The parameters are all the same.)

The same ec image startup above:

docker run ec /bin/bash

will not output:

this is a echo test

Because the CMD command is overwritten by "/bin/bash" .

2. ENTRYPOINT instruction

literally means entry point, and its function is exactly what it means. It allows your container to function like an executable program.

The container function behaves like an executable program. What does this mean?

Just give an example to make it easier to talk:

Example 1:

Use the following ENTRYPOINT to construct the image:

ENTRYPOINT ["/bin/echo"]

Then the container after the image built by docker The function is like a /bin/echo program:

For example, the name of the image I built is imageecho, then I can use it like this:

docker  run  -it  imageecho  “this is a test”

"this is a test" will be output here This string of characters, and the container corresponding to this imageecho image behaves like an echo program. The parameter "this is a test" you added will be added after ENTRYPOINT, and it will become like this /bin/echo "this is a test". Now you should understand what the entry point means.

Example 2:

ENTRYPOINT ["/bin/cat"]

You can run the constructed image like this (assuming it is named st):

docker run -it st /etc/fstab

This is equivalent to: /bin/cat /etc /fstab What this command does. After running, the contents in /etc/fstab will be output.

ENTRYPOINT has two ways of writing:

Writing method one:

ENTRYPOINT ["executable", "param1", "param2"] (the preferred exec form)

Writing method two:

ENTRYPOINT command param1 param2 (shell form)

You can also docker run Use –entrypoint to specify the command (but you can only use the first writing method).

The following is the running situation when I set ENTRYPOINT to ["/bin/sh -c"]:

• linux-oj9e:/home/lfly/project /docker # docker run -it t2 /bin/bash

• ##root@4c8549e7ce3e:/# ps

##PID TTY TIME CMD
1 ? 00:00:00 sh

• ##9 ? 00:00:00 bash

• ##19 ? 00:00:00 ps

• You can see that the process with PID 1 is running sh, and bash is just a child process of sh,

  /bin/bash
is only used as the parameter after

. CMD can provide parameters for ENTRYPOINT, and ENTRYPOINT itself can also contain parameters, but you can write the parameters that may need to be changed into CMD and the parameters that do not need to be changed into ENTRYPOINT. For example:

FROM  ubuntu:14.10
ENTRYPOINT  ["top", "-b"]
CMD  ["-c"]