Detailed explanation of Dockerfile to create a custom Docker image and comparison of CMD and ENTRYPOINT instructions

1. Overview

There are three ways to create a Docker image:

• Docker commit command: Generate an image from a container;
• Dockerfile file + docker build command;
• Import from local file system: OpenVZ templates.

For a general description of these three methods, please refer to yeasy/docker_practice's Creating an Image.

I recently learned about the configuration of the Dockerfile file. Here is a brief summary and a comparison of the CMD and ENTRYPOINT instructions that I have been confused about before.

2. Dockerfile Summary

Dockerfile consists of command lines and supports comment lines starting with #.

Generally, a Dockerfile is divided into four parts: base image information, maintainer information, image operation instructions, and instructions to be executed when the container is started.

The first instruction of the Dockerfile file must be FROM, followed by various image operation instructions, and finally CMD or ENTRYPOINT to specify the command to be executed when the container is started.

The following is an introduction to the various instructions in Dockerfile from yeasy/docker_practice:

instruction

The general format of instructions is INSTRUCTION arguments, and instructions include FROM, MAINTAINER, RUN, etc.

FROM

The format is FROM <image> or FROM <image>:<tag>.

The first instruction must be a FROM instruction. Also, if you are creating multiple images in the same Dockerfile, you can use multiple FROM instructions (once for each image).

MAINTAINER

The format is MAINTAINER <name>, which specifies the maintainer information.

RUN

The format is RUN <command> or RUN ["executable", "param1", "param2"].

The former will run the command in the shell terminal, namely /bin/sh -c; the latter is executed using exec. Specifying the use of other terminals can be achieved through the second method, such as RUN ["/bin/bash", "-c", "echo hello"].

Each RUN instruction will execute the specified command based on the current image and submit it as a new image. When the command is long, you can use \ to wrap it.

CMD

Support three formats

CMD ["executable","param1","param2"] Use exec to execute, which is the recommended method;

CMD command param1 param2 is executed in /bin/sh and provided to applications that need interaction;

CMD ["param1","param2"] provides default parameters to ENTRYPOINT;

Specifies the command to be executed when starting the container. Each Dockerfile can only have one CMD command. If multiple commands are specified, only the last one will be executed.

If the user specifies a command to run when starting the container, the command specified by CMD will be overwritten.

EXPOSE

The format is EXPOSE <port> [<port>...].

Tell the Docker server the port number that the container exposes for use by interconnected systems. When starting the container, you need to pass -P, and the Docker host will automatically assign a port to forward to the specified port.

ENV

The format is ENV <key> <value>. Specifies an environment variable that will be used by subsequent RUN instructions and persisted while the container is running.

For example

ENV PG_MAJOR 9.3

ENV PG_VERSION 9.3.4

RUN curl -SL http://example.com/postgres-$PG_VERSION.tar.xz | tar -xJC /usr/src/postgress && …

ENV PATH /usr/local/postgres-$PG_MAJOR/bin:$PATH

ADD

The format is ADD <src> <dest>.

This command will copy the specified <src> to <dest> in the container. Where <src> can be a relative path to the directory where the Dockerfile is located; it can also be a URL; or it can be a tar file (automatically decompressed into a directory).

COPY

The format is COPY <src> <dest>.

Copy the local host's <src> (relative path to the directory where the Dockerfile is located) to the container's <dest>.

When using a local directory as the source directory, it is recommended to use COPY.

ENTRYPOINT

Two formats:

ENTRYPOINT ["executable", "param1", "param2"]

ENTRYPOINT command param1 param2 (executed in shell).

The command to be executed after the configuration container is started and cannot be overwritten by the parameters provided by docker run.

There can be only one ENTRYPOINT in each Dockerfile. When multiple ENTRYPOINTs are specified, only the last one takes effect.

VOLUME

The format is VOLUME ["/data"].

Create a mount point that can be mounted from the local host or other containers, generally used to store databases and data that needs to be maintained.

USER

The format is USER daemon.

Specify the user name or UID when running the container. Subsequent RUNs will also use the specified user.

When the service does not require administrator privileges, you can specify the running user through this command. And you can create the required users before, for example: RUN groupadd -r postgres && useradd -r -g postgres postgres. To temporarily obtain administrator privileges, you can use gosu, but sudo is not recommended.

WORKDIR

The format is WORKDIR /path/to/workdir.

Configure the working directory for subsequent RUN, CMD, and ENTRYPOINT instructions.

Multiple WORKDIR directives can be used. If the parameters of subsequent commands are relative paths, they will be based on the paths specified by the previous commands. For example

WORKDIR /a

WORKDIR b

WORKDIR c

RUN pwd

The final path is /a/b/c.

ONBUILD

The format is ONBUILD [INSTRUCTION].

Configure the operation instructions to be executed when the created image is used as the base image for other newly created images.

For example, the Dockerfile creates an image-A with the following content.

[...]

ONBUILD ADD ./app/src

ONBUILD RUN /usr/local/bin/python-build --dir /app/src

[...]

If you create a new image based on image-A, and use FROM image-A to specify the base image in the new Dockerfile, the ONBUILD instruction content will be automatically executed, which is equivalent to adding two instructions at the end.

FROM image-A #Automatically run the following ADD . /app/src RUN /usr/local/bin/python-build --dir /app/src

For images that use the ONBUILD instruction, it is recommended to indicate this in the tag, for example ruby:1.9-onbuild.

3. Create an image

After writing the Dockerfile file, create a custom image by running the docker build command. The Docker build command format is as follows:

docker build [options] <path>

This command will read the Dockerfile in the specified path (including subdirectories) and send all the contents in the path to the Docker server, which will create the image. Therefore, it is generally recommended that the directory where the Dockerfile is placed is an empty directory. You can also use the .dockerignore file (add a matching pattern per line) to let Docker ignore the directories and files under the path.

For example, the following Dockerfile sample is used to create the image test:0.0.1, where the -t option is used to specify the tag of the image. The contents of the Dockerfile are as follows:

FROM ubuntu:14.04
MAINTAINER [email protected]

RUN mkdir /opt/leh
RUN touch /opt/leh/test

CMD echo "Hello lienhua34"

Next, run the docker build command to generate the image test:0.0.1.

lienhua34@test$ sudo docker build -t test:0.0.1 .
Sending build context to Docker daemon 3.072 kB
Step 1: FROM ubuntu:14.04
 ---> a5a467fddcb8
Step 2: MAINTAINER [email protected]
 ---> Running in ce9e7b02f075
 ---> 332259a92e74
Removing intermediate container ce9e7b02f075
Step 3: RUN mkdir /opt/leh
 ---> Running in e93f0a98040f
 ---> 097e177cf37f
Removing intermediate container e93f0a98040f
Step 4: RUN touch /opt/leh/test
 ---> Running in f1531d3dea1a
 ---> 0f68852f8356
Removing intermediate container f1531d3dea1a
Step 5: CMD echo "Hello lienhua34"
 ---> Running in cf3c5ce2af46
 ---> 811ce27ce692
Removing intermediate container cf3c5ce2af46
Successfully built 811ce27ce692

Then start the container of the image to view the results.

lienhua34@test$ sudo docker images
REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
test 0.0.1 811ce27ce692 32 seconds ago 187.9 MB
lienhua34@test$ sudo docker run -ti test:0.0.1
Hello lienhua34

Each instruction in the Dockerfile file generates a layer of the image (Note: an image cannot exceed 127 layers). The instructions in the Dockerfile are executed one by one. Each step creates a new container, executes instructions in the container and commits the changes. When all instructions are executed, the final image id is returned.

4. Comparison of the CMD and ENTRYPOINT instructions in the Dockerfile file

The functions of the CMD instruction and the ENTRYPOINT instruction are to specify the command for the image after the container is started. So what are the respective advantages between them?

In order to better compare the differences between the CMD instruction and the ENTRYPOINT instruction, we list the descriptions of these two instructions here.

CMD

Support three formats

CMD ["executable","param1","param2"] Use exec to execute, which is the recommended method;

CMD command param1 param2 is executed in /bin/sh and provided to applications that need interaction;

CMD ["param1","param2"] provides default parameters to ENTRYPOINT;

Specifies the command to be executed when starting the container. Each Dockerfile can only have one CMD command. If multiple commands are specified, only the last one will be executed.

If the user specifies a command to run when starting the container, the command specified by CMD will be overwritten.

ENTRYPOINT

Two formats:

ENTRYPOINT ["executable", "param1", "param2"]

ENTRYPOINT command param1 param2 (executed in shell).

The command to be executed after the configuration container is started and cannot be overwritten by the parameters provided by docker run.

There can be only one ENTRYPOINT in each Dockerfile. When multiple ENTRYPOINTs are specified, only the last one takes effect.

From the above description, we can see that there are two common points:

1. You can specify the shell or exec function call to execute the command;
2. When there are multiple CMD instructions or ENTRYPOINT instructions, only the last one takes effect;

The differences between them are as follows:

Difference 1: The command specified by the CMD instruction when the container is started can be overwritten by the command specified by docker run, while the command specified by the ENTRYPOINT instruction cannot be overwritten. Instead, the parameters specified by docker run are used as parameters of the command specified by ENTRYPOINT.

Difference 2: The CMD instruction can set default parameters for the ENTRYPOINT instruction, and can be overwritten by parameters specified by docker run;

The following is a detailed explanation of the above two differences.

4.1 Difference 1

The command specified by the CMD instruction when the container is started can be overwritten by the command specified by docker run; however, the command specified by the ENTRYPOINT instruction cannot be overwritten. Instead, the parameters specified by docker run are used as the parameters of the command specified by ENTRYPOINT.

Below is an executable shell script named startup, whose function is to output command line parameters only. The content is as follows,

#!/bin/bash

echo "in startup, args: $@"

Specify the command when starting the container through CMD:

Now we create a new Dockerfile file, which copies the startup script to the /opt directory of the container and specifies to run the startup script when the container starts through the CMD instruction. Its contents are as follows,

FROM ubuntu:14.04
MAINTAINER [email protected]

ADD startup /opt
RUN chmod a+x /opt/startup

CMD ["/opt/startup"]

Then we generate the test:latest image by running the docker build command.

lienhua34@test$ sudo docker build -t test .
Sending build context to Docker daemon 4.096 kB
Step 1: FROM ubuntu:14.04
 ---> a5a467fddcb8
Step 2: MAINTAINER [email protected]
 ---> Using cache
 ---> 332259a92e74
Step 3: ADD startup /opt
 ---> 3c26b6a8ef1b
Removing intermediate container 87022b0f30c5
Step 4: RUN chmod a+x /opt/startup
 ---> Running in 4518ba223345
 ---> 04d9b53d6148
Removing intermediate container 4518ba223345
Step 5: CMD /opt/startup
 ---> Running in 64a07c2f5e64
 ---> 18a2d5066346
Removing intermediate container 64a07c2f5e64
Successfully built 18a2d5066346

Then use docker run to start two test:latest image containers. The first docker run command does not specify a command to start the container. The second docker run command specifies the command to start the container as "/bin/bash -c 'echo Hello'".

lienhua34@test$ sudo docker run -ti --rm=true test
in startup, args: 
lienhua34@test$ sudo docker run -ti --rm=true test /bin/bash -c 'echo Hello'
Hello

From the above running results, you can see that the run command specified when the docker run command starts the container overrides the command specified by the CMD instruction in the Dockerfile file.

Specify the command when the container starts by ENTRYPOINT:

Replace CMD in the above Dockerfile with ENTRYPOINT, the content is as follows,

FROM ubuntu:14.04
MAINTAINER [email protected]

ADD startup /opt
RUN chmod a+x /opt/startup

ENTRYPOINT ["/opt/startup"]

Similarly, run docker build to generate the test:latest image.

lienhua34@test$ sudo docker build -t test .
Sending build context to Docker daemon 4.096 kB
Step 1: FROM ubuntu:14.04
 ---> a5a467fddcb8
Step 2: MAINTAINER [email protected]
 ---> Using cache
 ---> 332259a92e74
Step 3: ADD startup /opt
 ---> Using cache
 ---> 3c26b6a8ef1b
Step 4: RUN chmod a+x /opt/startup
 ---> Using cache
 ---> 04d9b53d6148
Step 5: ENTRYPOINT /opt/startup
 ---> Running in cdec60940ad7
 ---> 78f8aca2edc2
Removing intermediate container cdec60940ad7
Successfully built 78f8aca2edc2

Then use docker run to start two test:latest image containers. The first docker run command does not specify a command to start the container. The second docker run command specifies the command to start the container as "/bin/bash -c 'echo Hello'".

lienhua34@test$ sudo docker run -ti --rm=true test
in startup, args: 
lienhua34@test$ sudo docker run -ti --rm=true test /bin/bash -c 'echo Hello'
in startup, args: /bin/bash -c echo Hello

From the above running results, it can be seen that the container running command specified by the docker run command cannot overwrite the command specified by the ENTRYPOINT instruction in the Dockerfile file, but is passed as a parameter to the command specified by the ENTRYPOINT instruction.

4.2 Difference 2

The CMD instruction can set default parameters for the ENTRYPOINT instruction, and can be overwritten by parameters specified by docker run;

Use the same startup script as above. Write Dockerfile, the content is as follows,

FROM ubuntu:14.04
MAINTAINER [email protected]
 
ADD startup /opt
RUN chmod a+x /opt/startup

ENTRYPOINT ["/opt/startup", "arg1"]
CMD ["arg2"]

Run the docker build command to generate the test:latest image.

lienhua34@test$ sudo docker build -t test .
Sending build context to Docker daemon 4.096 kB
Step 1: FROM ubuntu:14.04
 ---> a5a467fddcb8
Step 2: MAINTAINER [email protected]
 ---> Using cache
 ---> 332259a92e74
Step 3: ADD startup /opt
 ---> Using cache
 ---> 3c26b6a8ef1b
Step 4: RUN chmod a+x /opt/startup
 ---> Using cache
 ---> 04d9b53d6148
Step 5: ENTRYPOINT /opt/startup arg1
 ---> Running in 54947233dc3d
 ---> 15a485253b4e
Removing intermediate container 54947233dc3d
Step 6 : CMD arg2
 ---> Running in 18c43d2d90fd
 ---> 4684ba457cc2
Removing intermediate container 18c43d2d90fd
Successfully built 4684ba457cc2

Next, run docker run to start two test:latest image containers. The first docker run command does not specify any parameters, and the second docker run command specifies the parameter arg3. The results are as follows:

lienhua34@test$ sudo docker run -ti --rm=true test
in startup, args: arg1 arg2
lienhua34@test$ sudo docker run -ti --rm=true test arg3
in startup, args: arg1 arg3

From the running results of the first container above, we can see that the CMD instruction sets the default parameters for the ENTRYPOINT instruction; from the running results of the second container, we can see that the parameters specified by the docker run command overwrite the parameters specified by the CMD instruction.

4.3 Notes

The CMD instruction provides default parameters for the ENTRYPOINT instruction based on the image hierarchy, not based on whether it is in the same Dockerfile file. This means that if the Dockerfile specifies the startup command specified by ENTRYPOINT in the base image, the CMD in the Dockerfile still sets the default parameters for the ENTRYPOINT in the base image.

For example, we have the following Dockerfile:

FROM ubuntu:14.04
MAINTAINER [email protected]
 
ADD startup /opt
RUN chmod a+x /opt/startup

ENTRYPOINT ["/opt/startup", "arg1"]

Generate the test:0.0.1 image by running the docker build command, then create a container for the image and view the running results.

lienhua34@test$ sudo docker build -t test:0.0.1 .
Sending build context to Docker daemon 6.144 kB
Step 1: FROM ubuntu:14.04
 ---> a5a467fddcb8
Step 2: MAINTAINER [email protected]
 ---> Running in 57a96522061a
 ---> c3bbf1bd8068
Removing intermediate container 57a96522061a
Step 3: ADD startup /opt
 ---> f9884fbc7607
Removing intermediate container 591a82b2f382
Step 4: RUN chmod a+x /opt/startup
 ---> Running in 7a19f10b5513
 ---> 16c03869a764
Removing intermediate container 7a19f10b5513
Step 5: ENTRYPOINT /opt/startup arg1
 ---> Running in b581c32b25c3
 ---> c6b1365afe03
Removing intermediate container b581c32b25c3
Successfully built c6b1365afe03
lienhua34@test$ sudo docker run -ti --rm=true test:0.0.1
in startup, args: arg1

Next, create a new Dockerfile file. The base image is the newly generated test:0.0.1. Use CMD to specify that you want to print the string "in test:0.0.2" through echo. The file contents are as follows,

FROM test:0.0.1
MAINTAINER [email protected]

CMD ["/bin/bash", "-c", "echo in test:0.0.2"]

Run the docker build command to generate the test:0.0.2 image, and then run docker run to start a container of the test:0.0.2 image to view the results.

lienhua34@test$ sudo docker build -t test:0.0.2 .
Sending build context to Docker daemon 6.144 kB
Step 1: FROM test:0.0.1
 ---> c6b1365afe03
Step 2: MAINTAINER [email protected]
 ---> Running in deca95cf4c15
 ---> 971b5a819b48
Removing intermediate container deca95cf4c15
Step 3 : CMD /bin/bash -c echo in test:0.0.2
 ---> Running in 4a31c4652e1e
 ---> 0ca06ba31405
Removing intermediate container 4a31c4652e1e
Successfully built 0ca06ba31405
lienhua34@test$ sudo docker run -ti --rm=true test:0.0.2
in startup, args: arg1 /bin/bash -c echo in test:0.0.2

From the above results, we can see that when the container started by the image test:0.0.2 is running, the string "in test:0.0.2" is not printed, but the command specified by the CMD instruction is used as the parameter of the running script startup specified by ENTRYPOINT in the base image test:0.0.1.

The above is the full content of this article. I hope it will be helpful for everyone’s study. I also hope that everyone will support 123WORDPRESS.COM.