Example of using Dockerfile to build an nginx image

Introduction to Dockerfile

Docker can automatically build images by reading the contents of the Dockerfile. The Dockerfile is a text file that contains all the commands that need to be executed during the build process. It can also be understood that Dockerfile is a script interpreted by the Docker program, which consists of instructions one by one. Each instruction corresponds to a command under the Linux system. The Docker program translates these Dockerfile instructions into real Linux commands. Dockerfile has its own writing format and supported commands. The Docker program resolves the dependencies between these commands, similar to Makefile.

The Docker program will read the Dockerfile and generate a customized image according to the instructions. Compared with black boxes like images, obvious scripts like Dockerfile are more easily accepted by users, as they clearly show how the image is generated. With Dockerfile, when we need to customize our own additional requirements, we only need to add or modify instructions on Dockerfile and regenerate the image, saving the trouble of typing commands.

How to build a docker image: commit, dockerfile

1. Use commit to build the image:

Commit is an image built based on the original image. The purpose of using this method to build an image is to save some configuration information and modified information in the image. It is equivalent to a snapshot of a mirror.

2. Use dockerfile to build the image:

Dockerfile is used to quickly build the required (custom) image.

Instructions for Dockerfile:

FROM: specifies the base image (FROM is a required instruction and must be the first instruction).

RUN: Used to execute command line commands. Its basic format:

The shell format is: RUN <command>. Just enter the command in the bash environment. A Dockerfile is allowed to use RUN for no more than 127 layers. Therefore, use RUN once, use '\' to wrap the line, and use '&&' to execute the next command. This format is generally used;

exec format: RUN <"executable file", "parameter 1", "parameter 2">, this method is like the format in function call;

COPY: Copy a file. Its basic format:

Format 1: COPY <source path>...<destination path>

Format 2: COPY [“<source path 1>”,….”<destination path>”]

ADD: A more advanced file copying function. It adds some functions based on COPY. If the file copied is a compressed file, it will be decompressed directly without using RUN to decompress it.

CMD: container startup command. Its basic format:

Shell format: CMD <command>

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

The parameter list format is: CMD ["parameter 1", "parameter 2"...], after specifying the ENTRYPOINT instruction, use CMD to specify specific parameters

ENTRYPOINT: Entry point. Its basic format is divided into exec and shell.

The purpose of ENTRYPOINT is the same as CMD, which is to specify the container startup program and parameters. ENTRYPOINT can be replaced during operation, but it is more cumbersome than CMD and needs to be specified through the --entrypoint parameter of docker run. When ENTRYPOINT is specified, the meaning of CMD changes. Instead of running the command directly, the contents of CMD are passed as parameters to the ENTRYPOINT instruction. When executed, it becomes: <ENTRYPOINT> "<CMD>"

ENV: Set environment variables. (You can use the variables used here) Its basic format is:

Format 1: ENV <key> <value>

Format 2: ENV <key1>=<value1> <key2>=<value>...

ARG: Build parameters. The effect of build parameters is the same as ENV, both of which set environment variables. The difference is that the environment variables built by ARG will not exist when the container runs in the future. Its basic format:

Format 1: ARG <parameter name> [=<default value>]

Format 2: This default value can be overridden in the build command docker build using --build-arg <parameter name>=<value>

VOLUME: Defines an anonymous volume. Its basic format:

Format 1: VOLUME ["<path1>", "<path2>"...]

Format 2: VOLUME <path>

EXPOSE: Expose the port. The EXPOSE instruction declares the port provided by the runtime container. The port will not be opened due to this declaration when the container is started. Its basic format:

Format 1: EXPOSE <port1> [<port2>...]

WORKDIR: Specifies the working directory. Its basic format:

Format 1: WORKDIR <working directory path>

USER: Specifies the current user. USER helps you switch to a specified user. Its basic format:

Format 1: USER <username>

HEALTCHECK: Health check to determine whether the status of the container is normal. Its basic format:

Format 1: HEALTCHECK [options] CMD <command> : Set the command to check the health of the container

Format 2: HEALTCHECK NONE: If the base image has health check instructions, use this format to block its health check instructions.

Build the nginx image:

Create a directory and write the Dockerfile in it:

[root@docker ~]# mkdir mynginx
[root@docker ~]# cd mynginx/
[root@docker mynginx]# pwd
/root/mynginx
[root@docker mynginx]#

Download the nginx source package to the created directory (mynginx directory):

[root@docker ~]# wget -P /root/mynginx/ http://nginx.org/download/nginx-1.15.2.tar.gz

Write Dockerfile:

[root@docker mynginx]# vi Dockerfile

Its contents are as follows:

FROM centos
RUN ping -c 1 www.baidu.com
RUN yum -y install gcc make pcre-devel zlib-devel tar zlib
ADD nginx-1.15.2.tar.gz /usr/src/
RUN cd /usr/src/nginx-1.15.2 \
  && mkdir /usr/local/nginx \
  && ./configure --prefix=/usr/local/nginx && make && make install \
  && ln -s /usr/local/nginx/sbin/nginx /usr/local/sbin/ \
  && nginx
RUN rm -rf /usr/src/nginx-1.15.2
EXPOSE 80

Run the docker command to build the image:

[root@docker mynginx]# docker build -t nginx:v3 .
Sending build context to Docker daemon 1.029MB
Step 1/7: FROM centos
 ---> 5182e96772bf
Step 2/7 : RUN ping -c 1 www.baidu.com
 ---> Using cache
 ---> 2f70f8abaf2a
Step 3/7 : RUN yum -y install gcc make pcre-devel zlib-devel tar zlib
 ---> Using cache
 ---> dbdda4b7ae6f
Step 4/7 : ADD nginx-1.15.2.tar.gz /usr/src/
 ---> Using cache
 ---> 18ace6285668
Step 5/7 : RUN cd /usr/src/nginx-1.15.2 && mkdir /usr/local/nginx && ./configure --prefix=/usr/local/nginx && make && make install && ln -s /usr/local/nginx/sbin/nginx /usr/local/sbin/ && nginx
 ---> Using cache
 ---> 99629488ede9
Step 6/7 : RUN rm -rf /usr/src/nginx-1.15.2
 ---> Using cache
 ---> 869fbad71879
Step 7/7: EXPOSE 80
 ---> Using cache
 ---> 384bed72ea6f
Successfully built 384bed72ea6f
Successfully tagged nginx:v3

If two "Successfully" are output, the build is successful!

Start the custom image:

Use docker images to view the built image:

Start the custom image:

[root@docker ~]# docker run -dit -p 80:80 --name nginx nginx:v3
ecaafe1190447878b98dfb0198e92439db60ff7dab57a1674e0e9e7282a9c858
[root@docker ~]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
ecaafe119044 nginx:v3 "/bin/bash" 3 seconds ago Up 2 seconds 0.0.0.0:80->80/tcp nginx

Note: At this point, no matter how you start the container, it will always be in the exited state.

After various solutions, I finally figured out where the problem was. It turns out that when the container is started, it is started in the background corresponding to a thread. It is already started at startup, but after executing the command, it exits and does not run in the background. Therefore, use the -dit parameter to let it run in the background.

[root@docker ~]# docker run -dit -p 80:80 --name nginx nginx:v3
ecaafe1190447878b98dfb0198e92439db60ff7dab57a1674e0e9e7282a9c858
[root@docker ~]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
ecaafe119044 nginx:v3 "/bin/bash" 3 seconds ago Up 2 seconds 0.0.0.0:80->80/tcp nginx

However.......

At this time, another problem occurred. Although it was up, the web page interface of nginx could not be accessed, and it showed that the connection was refused! ! ! !

[root@docker ~]# curl 192.168.100.22
curl: (7) Failed connect to 192.168.100.22:80; Connection refused [root@docker ~]# elinks --dump 192.168.100.22
ELinks: Connection refused

Then, after asking Baidu, searching on FQ and looking at Google, I finally found the problem. It turns out that you only need to use exec to enter the container and start nginx.

[root@docker ~]# docker exec -it nginx bash
[root@ecaafe119044 /]# nginx
[root@ecaafe119044 /]# exit
exit

[root@docker ~]# curl 192.168.100.22
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
  body {
    width: 35em;
    margin: 0 auto;
    font-family: Tahoma, Verdana, Arial, sans-serif;
  }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/" rel="external nofollow" >nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/" rel="external nofollow" >nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

so! The nginx image has been purchased successfully! ! ! !

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.