Shulou(Shulou.com)06/02 Report--

This article mainly explains "the process of analyzing the reserved word instruction in Dockerfile". The content of the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "the process of analyzing the reserved word instruction in Dockerfile".

What is Dockerfile?

Concept:

Dockerfile is a build file used to build a Docker image, a script made up of a series of commands and parameters

There are three steps to build:

Write Dockerfile files

Docker build

Docker run

Centos case:

Centos case:

FROM scratch # Real basic 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 GPL-2.0-only 00" CMD ["/ bin/bash"] # Command executed on the last line

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

We won't, but we can first see how others write and copy homework. I think we are all familiar with it. Commonly known as CV Dafa?

Second, the analysis of Dockerfile construction process.

Getting started:

Each reserved word instruction (today's focus) must be an uppercase letter followed by at least one parameter.

Such as:

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

Instructions are executed sequentially from top to bottom

# indicates a comment.

# this is the comment

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

Just like below, you can set a baby.

Dockerfile execution flow analysis: docker runs a container from the underlying image and executes an instruction and modifies the container to perform docker commit-like operations to submit a new mirror layer. Docker then runs a new container based on the image just submitted to execute the next instruction in dockerfile until all instructions are executed

There are cases later, which are easier to understand in retrospect.

A little layman:

At this stage, we think of Dockerfile, Docker images, and Docker containers as three different phases of the software.

Dockerfile is oriented to development-- > Docker image becomes the delivery standard-> Docker container involves deployment and operation and maintenance.

Everything needed for a process is defined in Dockerfile, and previously dependent environment variables, dependency packages, runtime environments, and so on, are written to the Dockerfile file. It's really much easier than you downloaded so much software and configured so much from the Liunx server before, at least it's much easier for me to deploy it with Docker.

Docker image is a Docker image generated by docker build after a file is defined with Dockerfile. The service will only be provided when the Docker image is run.

The Docker container is running to provide services.

3. Dockerfile reserved word instruction

The Dockerfiel reserved word instructions are roughly as follows:

FROMMAINTANINERRUNEXPOSEWORKDIRENVADDCOPYVOLUMECMDENTRYPOINTONBUILD

3.1 、 FROM

The base image, that is, the mirror on which the current new image is created.

# create image FROM openjdk:83.2 and MAINTAINER based on openjdk:8

Name and email address of the mirror maintainer

MAINTAINER would rather be crush@163.com3.3 and RUN in spring.

Instructions to be run when the container is built

RUN mkdir-p / conf/my.cn3.4, EXPOSE

The port on which the current container is exposed

# expose the required ports of MyCat EXPOSE 8066 90663.5, WORKDIR

Specify the working directory in which the terminal logs in by default after the container is created

# Container data volume for data preservation and persistence WORKDIR / usr/local/mycat3.6, ENV

Used to set environment variables during the construction of an image

# used to set the environment variable ENV MYCAT_HOME=/usr/local/mycat in the process of building an image

This environment variable can be used in any subsequent RUN instruction, just as you specify the environment variable prefix before the command; you can also use these environment variables directly in other instructions.

Such as:

RUN $MYCAT_HOME/mycat3.7, ADD and COPY

ADD:

Copy the files in the host directory into the mirror, and the ADD command automatically processes URL and decompresses the tar package

ADD centos-6-docker.tar.xz /

COPY:

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

Copy the file / directory in the build context directory to the location in the mirror of the new layer

COPY src destCOPY ["src"dest"] 3.8, VOLUME

Container data volumes for data persistence and data preservation.

# expose the address of the mycat configuration file to the mapping address, and map the host folders VOLUME / usr/local/mycat3.9, CMD and ENTRYPOINT directly at startup

CMD

CMD instructions are similar to RUN, but are also in two formats:

Shell format: CMDexec format: CMD [executable file "," parameter 1 "," parameter 2 ".]

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

ENTRYPOINT

Specify a command to run when the container starts.

The purpose of ENTRYPOINT, like CMD, is to start the program and parameters in the specified container.

Difference:

To briefly explain the difference here, you can think of CMD as overlay

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

Both instructions are written in the Dockerfile file, and only CMD / bin/bash is executed, not CMD cat / conf/my.cnf, because CMD / bin/bash directly overwrites the previous one.

Unlike ENTRYPOINT, you can simply understand ENTRYPOINT as an append.

It is mainly reflected in docker run. If you use the end of CMD at the end of the dockerfile file, you cannot append additional commands at run time, otherwise the CMD command in Dockerfile will be overwritten.

At the end of the last action in the Dockerfile file, ENTRYPOINT, you can append some commands to the docker run command.

3.10 、 ONBUILD

When building an inherited Dockerfile, the command is run, and the parent image is triggered after the quilt inherits the onbuild of the parent image.

4. Actual combat case 4.1, create a self-made Centos image 4.1.1, introduce:

Let's pull a centos from Ali Cloud to see what the problems are, and then we'll customize it.

Docker pull centos # pull Image docker run-it centos # run Image # = Test = vim ceshi.txtifconfig pwd

Why is this? Because the Centos in the docker repository is a stripped-down version, it has only the kernel and nothing else.

Require a custom Centos to solve the above problems.

4.1.2. Write Dockerfile files

Write a Dockerfile file for our custom Centos

FROM centosMAINTAINER would rather spring ENV MYPATH / usr/localWORKDIR $MYPATHRUN yum-y install vimRUN yum-y install net-toolsEXPOSE 80 CMD echo $MYPATHCMD echo "success" CMD / bin/bash # will only run the last one

And then copy this in.

Mkdir-p / usr/local/docker/mycentos # create your own storage location vim Dockerfile

4.1.3. Construct centos image docker build-f / usr/local/docker/mycentos/Dockerfile-t mycentos:1.1.

Explanation:

-f: followed by the Dockerfile file

-t: followed by the image name and version number.

The last 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.

Execute:

Seeing the last one means success.

Docker images to view all images:

4.1.4. Run Centos image docker run-it mycentos:1.3pwdifconfig

The reason we go into the container directory is to change from / to / usr/local because it is already specified in the dockerfile file.

ENV MYPATH / usr/localWORKDIR $MYPATH4.1.5, view the change history of the image docker history mycentos:1.1

You can also see here that the mirror image is built layer by layer from the instructions in the Dockerfile file.

4.2.Example ONBUILD

Take the lead in building a husband's image.

Write a dockerfile file named dockerfile2

FROM centosRUN yum-y install curlONBUILD RUN echo "my quilt image inherits, output this statement" CMD ["crul", "- s", "http://ip.cn"]docker build-f / usr/local/docker/mycentos/Dockerfile2-t my_father_centos."

Build an image to inherit a husband image

Write a dockerfile file and name it dockerfile3 ha

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 statement in the parent mirror is output.

Thank you for your reading, the above is the content of "analyzing the process of word retention instruction in Dockerfile". After the study of this article, I believe you have a deeper understanding of the process of analyzing word retention instruction in Dockerfile, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.