Process parsing of reserved word instructions in Dockerfile

I have learned Docker briefly before, in order to quickly deploy a project. The process went by very quickly, and I was somewhat unfamiliar with writing Dockerfile files.

So I wrote this article. I hope this can help you all! ! !

1. What is Dockerfile?

concept:

Dockerfile is a build file used to build a Docker image. It is a script consisting of a series of commands and parameters.

Three steps to build:

• Writing a Dockerfile
• docker build
• docker run

Centos Example:

CentOS example:

FROM scratch #The real base image,
ADD centos-7-x86_64-docker.tar.xz /

# label description LABEL \  
    org.label-schema.schema-version="1.0" \
    org.label-schema.name="CentOS Base Image" \
    org.label-schema.vendor="CentOS" \
    org.label-schema.license="GPLv2" \
    org.label-schema.build-date="20201113" \
    org.opencontainers.image.title="CentOS Base Image" \
    org.opencontainers.image.vendor="CentOS" \
    org.opencontainers.image.licenses="GPL-2.0-only" \
    org.opencontainers.image.created="2020-11-13 00:00:00+00:00"

CMD ["/bin/bash"] #The command executed in the last line

Where did I find it? I found it on hub.docker.com: centos.

We don’t know how to do it, but we can first look at how others write it. I think everyone is familiar with copying homework. Commonly known as CV method😂.

2. Analysis of Dockerfile construction process

Getting Started:

Each reserved word directive (the focus of today's post) must be大寫字母and must be跟隨至少一個參數.

like:

FROM scratch #The real base image,
ADD centos-7-x86_64-docker.tar.xz /

Instructions are executed sequentially from top to bottom.

# indicates a comment.

#This is a comment

Each instruction creates a new image layer and commits the image.

Just like the following, you can do it like nesting dolls.

Dockerfile execution process analysis: docker runs a container from a base image

• Execute a command and make changes to the container
• Perform an operation similar to docker commit to submit a new image layer.
• docker then runs a new container based on the image just submitted
• Execute the next instruction in dockerfile until all instructions are executed.

There are cases later in the text, which will make it easier to understand if you look back at them in conjunction with the cases.

Small extra:

• At this stage, we view Dockerfile , Docker image and Docker container as three different stages of software.
• Dockerfile is for development ---> Docker image becomes the delivery standard ---> Docker container involves deployment and operation and maintenance
• Everything needed for the process is defined in Dockerfile . The environment variables, dependent packages, runtime environment, etc. that were previously required are all written into the Dockerfile file. Compared to downloading so many software and configuring so many things in the Liunx server before, it is really much simpler. At least for a newbie like me, using Docker to deploy is really much simpler.
• Docker image is a Docker image generated during Docker build after a file is defined using Dockerfile . When Docker image is run, it will actually start providing services.

Docker containers can provide services as soon as they are running.

3. Dockerfile reserved word instructions

Dockerfiel reserved word instructions are as follows:

1. FROM
2. MAINTANINER
3. RUN
4. EXPOSE
5. WORKDIR
6. ENV
7. ADD
8. COPY
9. VOLUME
10. CMD
11. ENTRYPOINT
12. ONBUILD

3.1 FROM

Base image, that is, the image based on which the current new image is created.

#Create image based on openjdk:8 FROM openjdk:8

3.2 MAINTAINER

The name and email address of the image maintainer

MAINTAINER Ning Zaichun [email protected]

3.3 RUN

Instructions to run when building the container

RUN mkdir -p /conf/my.cn

3.4 EXPOSE

The port exposed by the current container

#Expose the required ports of MyCat EXPOSE 8066 9066

3.5 WORKDIR

Specify the default working directory for the terminal to log in to after creating the container

#Container data volume, used for data storage and persistence work WORKDIR /usr/local/mycat

3.6 ENV

Used to set environment variables during image building

#Used to set the environment variable ENV MYCAT_HOME=/usr/local/mycat during the image building process

This environment variable can be used in any subsequent RUN instructions, just as if the environment variable prefix was specified before the command; these environment variables can also be used directly in other instructions.

like:

RUN $MYCAT_HOME/mycat

3.7. ADD and COPY

ADD:

Copy the files in the host directory into the image, and the ADD command will automatically process the URL and decompress the tarball.

ADD centos-6-docker.tar.xz /

COPY:

Similar to ADD, copy files and directories to the image.

Copies the files/directories from the <source path> in the build context directory to the <target path> location in the new layer of the image

COPY src dest COPY ["src" "dest"]

3.8 VOLUME

Container data volumes are used for data persistence and storage.

#Expose the mapping address of the mycat configuration file address and directly map the host folder VOLUME /usr/local/mycat when starting

3.9 CMD and ENTRYPOINT

CMD

The CMD command is similar to the RUN command and also has two formats:

• shell format: CMD<command>
• exec format: CMD ["executable file", "parameter 1", "parameter 2".....]

There can be multiple CMD instructions in Dockerfile , but only the last one takes effect. CMD will be replaced by the parameters after docker run .

ENTRYPOINT

Specifies a command to run when the container starts.

The purpose of ENTRYPOINT is the same as CMD, which is to specify the container startup program and parameters.

the difference:

Here is a brief explanation of the difference. You can understand CMD as overwriting

CMD cat /conf/my.cnfCMD /bin/bash

Both of these instructions are written in the Dockerfile file. Only CMD /bin/bash will be executed, but CMD cat /conf/my.cnf will not be executed because CMD /bin/bash directly overwrites the previous one.

ENTRYPOINT is different. You can simply understand ENTRYPOINT as appending.

This is mainly reflected in docker run . If dockerfile ends with CMD , no additional commands can be added during runtime, otherwise the CMD command in Dockerfile will be overwritten.

When the last line in the Dockerfile ends with ENTRYPOINT , you can append some commands after the docker run command.

3.10 ONBUILD

When building an inherited Dockerfile , the command is run. After the parent image is inherited by the child, the parent image's onbuild is triggered.

4. Actual combat cases

4.1. Make your own CentOS image

4.1.1、Introduction:

Let's first pull a centos from Alibaba Cloud to see what problems there are, and then we can customize it.

docker pull centos # Pull the image docker run -it centos # Run the image # ===== Test ====vim ceshi.txtifconfig pwd

Why is this so? Because the Centos in the docker repository is a streamlined version, which only has the kernel and nothing else.

A customized Centos is required to solve the above problems.

4.1.2. Write Dockerfile

Write a Dockerfile for our custom Centos

FROM centosMAINTAINER 宁在春<[email protected]>ENV MYPATH /usr/localWORKDIR $MYPATHRUN yum -y install vimRUN yum -y install net-toolsEXPOSE 80 CMD echo $MYPATHCMD echo "success"CMD /bin/bash #Only the last one will be executed 

Then copy this in.

mkdir -p /usr/local/docker/mycentos # Create your own storage location vim Dockerfile

4.1.3. Build centos image

docker build -f /usr/local/docker/mycentos/Dockerfile -t mycentos:1.1 .

explain:

• -f: followed by the Dockerfile file
• -t: The image name and version number followed.
• The final decimal point: indicates the current directory.
• docker build -f Dockerfile file -t image name: tag .
• When the dockerfile file is named dockerfile and is in the current directory, it can be abbreviated as:
• docker build -t image name:tag .docker build -t mycentos:1.1 .

implement:

Seeing the last one means success.

docker images View all images:

4.1.4. Run Centos image

docker run -it mycentos:1.3pwdifconfig

The reason why the directory we enter the container is switched from / to /usr/local is because it is already stated in the Dockerfile file.

ENV MYPATH /usr/localWORKDIR $MYPATH

4.1.5. View the change history of the image

docker history mycentos:1.1 

It can also be seen here that the image is built layer by layer by the instructions in the Dockerfile file.

4.2 ONBUILD Example

Be the first to build a husband mirror

Write a dockerfile file and name it dockerfile2

FROM centosRUN yum -y install curlONBUILD RUN echo "I was inherited by the sub-image, output this statement" CMD ["crul", "-s","http://ip.cn"]

docker build -f /usr/local/docker/mycentos/Dockerfile2 -t my_father_centos .

Build a mirror image

Write a dockerfile file and name it dockerfile3

FROM my_father_centosRUN yum -y install curlCMD ["crul", "-s","http://ip.cn"]
docker build -f /usr/local/docker/mycentos/Dockerfile3 -t my_son_centos . 

You can see that the statements in the parent image are output.

This is the end of this article about reserved word instructions in Dockerfile. For more relevant Dockerfile reserved word instructions, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope everyone will support 123WORDPRESS.COM in the future!