Explanation of Dockerfile instructions and basic structure

Using Dockerfile allows users to create custom images.

Basic structure

Dockerfile consists of command lines and supports comment lines starting with #. Generally, Dockerfile is divided into four parts: base image information, maintainer information, image operation instructions, and instructions executed when the container is started.

For example:

// Basic image information FROM daocloud.io/node:7 
// Maintainer information MAINTAINER abel.yang <[email protected]>
LABEL Description="This image is built for web"
//Mirror operation command RUN mkdir -p /opt/apps/epp
COPY . /opt/apps/epp
WORKDIR /opt/apps/epp/epp-web/server
ENV LANG C.UTF-8
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo Asia/Shanghai > /etc/timezone
EXPOSE 3001
//Execute command CMD [ "npm", "start" ] when the container starts

Among them, you must first specify the image name on which it is based, and then it is recommended to indicate the maintainer information. This is followed by image operation instructions, such as the RUN instruction, which will execute the following commands on the image.

Each time a RUN instruction is executed, a new layer is added to the image and submitted. Finally, there is the CMD instruction, which specifies the operation command when running the container.

instruction

INSTRUCTION arguments, instructions include FROM, MAINTAINER, RUN, etc.

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, specifying the maintainer information.

RUN

The format is RUN 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 another terminal 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.

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 , which is not recommended over sudo .

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 .

Create an image

After writing the Dockerfile, you can create an image using the docker build command.

docker build -t image name.
// Note. Don't forget.

Below are two examples of Dockerfiles on Dockerhub.

# Nginx
#
# VERSION 0.0.1
FROM ubuntu
MAINTAINER Victor Vieux <[email protected]>
RUN apt-get update && apt-get install -y inotify-tools nginx apache2 openssh-server
# Install inotify-tools, nginx, apache2, openssh-server based on the parent image of ubuntu to create a new Nginx image.

# Firefox over VNC
#
#VERSION 0.3
FROM ubuntu
# Install vnc,xvfb in order to create a 'fake' display and firefox
RUN apt-get update && apt-get install -y x11vnc firefox
RUN mkdir /.vnc
# Setup a pssword
RUN x11vnc -storepasswd 1234 ~/.vnc/passwd
#Autostart firefox
RUN bash -c 'echo "firefox" >> /.bashrc'
EXPOSE 5900
CMD ["x11vnc", "-forever", "-usepw", "-create"]
# Based on the Ubuntu parent image, install firefox and vnc software. After starting, users can use firefox through vnc via port 5900.

Summarize

The above is the full content of this article. I hope that the content of this article will have certain reference learning value for your study or work. Thank you for your support of 123WORDPRESS.COM. If you want to learn more about this, please check out the following links