Dockerfile使用_dockerfile如何使用

1.Dockerfile是什么

官网地址

https://docs.docker.com/reference/dockerfile/
1

概念

是什么

Dockerfile 是用于构建 Docker 镜像的文本文件，它包含一系列的指令（instructions）和参数，用于描述如何构建和配置镜像。

Dockerfile 是基于一种声明式语法，它允许您定义从基础镜像开始的一系列操作，包括安装软件包、复制文件、设置环境变量、暴露端口等。

以下是一个简单的 Dockerfile 示例：

# 指定基础镜像
FROM ubuntu:latest

# 设置工作目录
WORKDIR /app

# 复制文件到镜像中
COPY . .

# 安装依赖
RUN apt-get update && apt-get install -y python3

# 设置环境变量
ENV PATH="/app:${PATH}"

# 暴露端口
EXPOSE 8080

# 容器启动时执行的命令
CMD ["python3", "app.py"]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在上述示例中，每个指令都以关键字开始，后跟指令的参数。以下是一些常用的 Dockerfile 指令：

• FROM：指定基础镜像。
• WORKDIR：设置工作目录。
• COPY：复制文件或目录到镜像中。
• RUN：在镜像构建过程中执行命令。
• ENV：设置环境变量。
• EXPOSE：声明容器运行时需要监听的端口。
• CMD：容器启动时执行的默认命令。

可以根据需要在 Dockerfile 中添加更多指令，并根据自己的需求来定制镜像。一旦编写好 Dockerfile，可以使用 docker build 命令根据 Dockerfile 构建镜像，例如：

docker build -t myimage:tag .
1

上述命令将在当前目录下的 Dockerfile 中定义的指令基础上构建一个名为 myimage 的镜像，并打上指定的标签。

Dockerfile 的语法相对简单，但提供了丰富的功能，可以通过组合和定制指令来创建满足特定需求的镜像。

docker build与docker run

docker build 和 docker run 是 Docker 命令行工具中的两个常用命令，用于构建和运行 Docker 容器。

docker build:

docker build 命令用于根据 Dockerfile 构建 Docker 镜像。Dockerfile 是一个文本文件，包含了一系列的指令和参数，描述了如何构建镜像。通过 docker build 命令，可以将 Dockerfile 转换为一个可运行的镜像。

示例命令：

docker build -t myimage:tag .
1

上述命令将在当前目录下的 Dockerfile 中定义的指令基础上构建一个名为 myimage 的镜像，并打上指定的标签。

docker run:

docker run 命令用于基于指定的镜像创建并运行一个 Docker 容器。它从指定的镜像中启动一个容器，并执行容器中指定的命令。

示例命令：

docker run -d -p 8080:80 myimage:tag
1

上述命令将在名为 myimage 的镜像上创建一个容器，并将容器的 80 端口映射到主机的 8080 端口上。-d 选项表示以后台模式运行容器。

通过 docker run 命令可以运行镜像，并指定容器的各种配置选项，如端口映射、环境变量、数据卷等。

需要注意的是，docker build 用于构建镜像，而 docker run 用于运行容器。构建镜像是创建一个可重复部署的镜像的过程，而运行容器是在镜像的基础上创建一个实际运行的容器实例。

保留字指令

FROM

作用是指定正在构建的镜像所基于的基础镜像。基础镜像是用于构建新镜像的起点，它包含了操作系统和一些预安装的软件包或工具。

在 Dockerfile 中，FROM 是一个指令（instruction），用于指定基础镜像（base image）以及构建后续层的镜像。

FROM 指令的作用是指定正在构建的镜像所基于的基础镜像。基础镜像是用于构建新镜像的起点，它包含了操作系统和一些预安装的软件包或工具。

FROM 指令的语法如下：

FROM <基础镜像>
1

其中：

• <基础镜像>：指定用作基础的镜像。可以是官方提供的公共镜像，也可以是自己构建的或从 Docker Hub 或其他镜像仓库中获取的镜像。

FROM 指令必须是 Dockerfile 的第一条指令，并且每个 Dockerfile 只能有一个 FROM 指令。

FROM 指令定义了构建镜像的起点，后续的指令将在基础镜像的基础上进行操作，例如安装软件包、配置环境变量、添加文件等。

以下是一个示例：

FROM ubuntu:20.04
1

上述指令指定了基础镜像为官方提供的 Ubuntu 20.04 镜像。

在构建镜像时，Docker 引擎会从 Docker Hub 或本地镜像仓库中获取指定的基础镜像，并将其作为构建层的起点。后续的指令将在该基础镜像上执行，并逐步构建出最终的镜像。

通过选择不同的基础镜像，您可以构建出满足不同需求的镜像，例如基于不同操作系统、不同版本的软件等。

请注意，Dockerfile 中的 FROM 指令是必需的，因为它定义了构建过程的起点。在没有 FROM 指令的情况下，Docker 将无法构建镜像。

MAINTAINER

指令用于指定镜像的维护者信息，包括维护者的姓名和电子邮件地址。

在早期的 Docker 版本中，MAINTAINER 是一个指令，用于指定维护者的信息。维护者是指负责维护和更新镜像的个人或团队。

MAINTAINER 指令的语法如下：

MAINTAINER <维护者信息>
1

其中 <维护者信息> 是对维护者的描述，通常包括姓名和电子邮件地址。

例如：

MAINTAINER John Doe <john@example.com>
1

然而，自 Docker 1.13 版本起，官方建议使用 LABEL 指令来替代 MAINTAINER 指令，以提供更灵活和可扩展的元数据信息，LABEL 指令允许指定键值对形式的标签，用于描述镜像的相关信息，例如维护者、版本号、描述、文档链接等。

以下是一个示例：

LABEL maintainer="John Doe <john@example.com>"
1

上述指令使用 LABEL 指令来添加一个名为 “maintainer” 的标签，值为 “John Doe <john@example.com>”。

通过使用 LABEL 指令，可以添加任意数量的标签和元数据信息，以便更好地描述和管理镜像。这些标签可以在运行容器时使用 docker inspect 命令或其他工具来查看。

综上所述，MAINTAINER 指令在当前版本的 Docker 中已经不建议使用，而是使用更灵活的 LABEL 指令来添加元数据信息。

RUN

在容器内部运行指定的命令，有两种格式：shell格式、exec格式。
RUN是在docker build时运行

在 Dockerfile 中，RUN 是一个指令（instruction），用于在正在构建的 Docker 镜像中执行命令。

RUN 指令的作用是在容器内部运行指定的命令，并生成一个新的镜像层。这些命令可以是任何有效的 Shell 命令，例如安装软件包、运行脚本、设置环境变量等。

RUN 指令的语法如下：

RUN <命令>
1

其中 <命令> 是要在容器内部执行的命令。可以是单个命令或多个命令的组合，可以使用 Shell 的语法，如管道、重定向等。

以下是一些示例：

RUN apt-get update && apt-get install -y curl
1

上述指令在容器内部执行了两个命令，分别是更新软件包列表 (apt-get update) 和安装 curl 软件包 (apt-get install -y curl)。

RUN echo "Hello, Docker!"
1

上述指令在容器内部执行了一个命令，打印出 “Hello, Docker!”。

RUN 指令可以有多个，每个 RUN 指令都会生成一个新的镜像层。为了减小镜像大小，可以使用 && 运算符将多个命令组合在一起，以便在单个 RUN 指令中执行。

请注意，每个 RUN 指令都会在容器内启动一个临时的 Shell 进程来执行命令，并在命令完成后关闭。因此，如果需要在一个 RUN 指令中使用变量或执行复杂的 Shell 脚本，可以使用反斜杠 \ 来换行，或者将命令写在一个单独的脚本文件中并在 RUN 指令中调用。

RUN 指令的执行结果将会保存到当前镜像的文件系统中，并成为下一层镜像的基础。

EXPOSE

声明容器在运行时将要监听的网络端口

在 Dockerfile 中，EXPOSE 是一个指令（instruction），用于声明容器在运行时将要监听的网络端口。

EXPOSE 指令的作用是向 Docker 守护进程和用户提供一个提示，说明容器内的应用程序将会监听指定的端口。这并不会自动将容器的端口暴露给主机，而是提供了一种文档化的方式，用于描述容器运行时需要使用的网络端口。

EXPOSE 指令的语法如下：

EXPOSE <端口1> [<端口2>...]
1

其中 <端口1>, <端口2>, … 是要声明的端口号。可以指定一个或多个端口。

以下是一个示例：

EXPOSE 80
1

上述指令声明容器将监听端口 80。

EXPOSE 8080 9000-9010
1

上述指令声明容器将监听端口 8080，以及端口范围 9000 到 9010。

EXPOSE 指令的作用主要有两个方面：

1. 文档化：通过在 Dockerfile 中使用 EXPOSE 指令，可以清楚地记录容器在运行时需要监听的端口，使用户或开发人员了解容器的网络配置和使用要求。
2. 与-p 参数配合使用：在运行容器时，可以使用 Docker 命令的 -p 参数将容器内部的端口映射到主机上的端口，从而实现对容器中应用程序的访问。

请注意，EXPOSE 指令并不会自动将容器的端口映射到主机上。要将容器的端口暴露给主机，需要在运行容器时使用 -p 参数或者 Docker Compose 的端口映射配置。

WORKDIR

用于设置容器内部的工作目录

#指定在创建容器后，终端默认登录进来的工作目录。
#比如如下命令，运行ubuntu后，执行pwd，看到的是ubuntu的根目录，这个根目录就是WORKDIR可以指定的工作目录

[root@localhost ~]# docker run -it ubuntu /bin/bash
root@c37f4925ffec:/# pwd
/
root@c37f4925ffec:/# 
1
2
3
4
5
6
7

在 Dockerfile 中，WORKDIR 是一个指令（instruction），用于设置容器内部的工作目录。

WORKDIR 指令的作用是指定容器内部的工作目录，即在容器中运行命令时的默认目录。它类似于 cd 命令，用于切换当前工作目录。

WORKDIR 指令的语法如下：

WORKDIR <工作目录路径>
1

其中 <工作目录路径> 是容器内部的路径，可以是绝对路径或相对路径。

以下是一个示例：

WORKDIR /app
1

上述指令指定容器内的工作目录为 /app。

在 Dockerfile 的后续指令中，可以使用相对于工作目录的路径来执行命令或操作文件。这样可以使命令更简洁，不需要在每个命令中指定完整的路径。

例如，假设在 Dockerfile 中设置了工作目录为 /app，则可以使用以下方式执行命令：

RUN npm install        # 相当于在 /app 目录下执行 npm install
RUN python script.py   # 相当于在 /app 目录下执行 python script.py
1
2

如果在 WORKDIR 指令之后的指令中使用相对路径，Docker 引擎将会自动将其解析为相对于工作目录的路径。

请注意，WORKDIR 指令可以多次使用，后续的指令将在新的工作目录下执行。如果使用相对路径，则相对路径将会基于上一次 WORKDIR 指令之后的工作目录。

使用 WORKDIR 指令可以使 Dockerfile 更具可读性，减少在每个命令中指定完整路径的繁琐。同时，还可以确保容器中的命令和文件操作都在指定的工作目录下进行。

USER

指定该镜像以什么样的用户去执行，如果不指定，默认是root

在 Dockerfile 中，USER 是一个指令（instruction），用于设置在容器内部运行命令时使用的用户或用户组。

USER 指令的作用是指定在容器内部运行命令时所使用的用户。可以使用用户的用户名或用户的 UID（用户标识符）来指定用户。

USER 指令的语法如下：

USER <用户>[:<用户组>]
1

其中 <用户> 是要指定的用户，可以是用户名或 UID。<用户组> 是可选的，用于指定用户所属的用户组。

以下是一些示例：

USER myuser
1

上述指令指定容器内部运行命令时使用用户名为 “myuser” 的用户。

USER 1000
1

上述指令指定容器内部运行命令时使用 UID 为 1000 的用户。

USER myuser:mygroup
1

上述指令指定容器内部运行命令时使用用户名为 “myuser” 的用户，并且该用户属于 “mygroup” 用户组。

USER 指令通常与 RUN 指令一起使用，以切换到指定的用户身份来执行命令。这可以用于提高容器的安全性，以及限制在容器中执行命令的权限。

请注意，USER 指令对应的用户或用户组必须在镜像中存在。您可以使用 RUN 指令在构建镜像时创建所需的用户和用户组。

以下是一个示例，展示了如何在 Dockerfile 中创建新用户并设置为容器的默认用户：

RUN groupadd -r mygroup && useradd -r -g mygroup myuser
USER myuser:mygroup
1
2

在上述示例中，RUN 指令用于创建一个名为 “myuser” 的用户，并将其加入到 “mygroup” 用户组中。然后，USER 指令将默认用户设置为 “myuser”。

通过使用 USER 指令，可以控制在容器内部运行命令时所使用的用户身份，从而实现更细粒度的权限控制和安全性。

ENV

用来在构建镜像过程中，设置环境变量

用来在构建镜像过程中，设置环境变量

ENV MY_PATH /usr/mytest
这个环境变量可以在后续的任何RUN指令中使用，这就如同在命令前面指定了环境变量前缀一样;也可以在其它指令中直接使用这些环境变量。
比如: WORKDIR $MY_PATH 就相当于 WORKDIR /usr/mytest
1
2
3
4
5

在 Dockerfile 中，ENV 是一个指令（instruction），用于设置环境变量。

ENV 指令的作用是在容器内部设置一个环境变量，使其在容器运行时可用。环境变量可以在容器中的各个进程之间共享数据，并且可以用于配置应用程序的行为。

ENV 指令的语法如下：

ENV <变量名>=<值>
1

其中 <变量名> 是要设置的环境变量的名称，<值> 是该环境变量的值。

以下是一些示例：

ENV MY_VAR=my_value
1

上述指令设置了一个名为 “MY_VAR” 的环境变量，其值为 “my_value”。

ENV PORT=8080
1

上述指令设置了一个名为 “PORT” 的环境变量，其值为 “8080”。

可以在 Dockerfile 中的任意位置使用 ENV 指令来设置环境变量。后续的指令和容器中的应用程序可以使用这些环境变量。

以下是一个示例，展示了如何在 Dockerfile 中使用 ENV 指令设置环境变量并在容器中使用它：

ENV MY_VAR=my_value
ENV PORT=8080

RUN echo $MY_VAR
1
2
3
4

在上述示例中，通过 ENV 指令设置了两个环境变量 “MY_VAR” 和 “PORT”。然后，在 RUN 指令中使用了环境变量 “$MY_VAR”，它将会被解析为 “my_value”。

使用 ENV 指令可以方便地设置容器内部的环境变量，使得容器的行为可以根据这些变量的值进行配置和调整。

ADD

用于将文件、目录或远程 URL 添加到容器中，且会自动处理URL，和解压rar压缩包

在 Dockerfile 中，ADD 是一个指令（instruction），用于将文件、目录或远程 URL 添加到容器中。

ADD 指令的作用是将源文件或目录复制到容器的文件系统中。它可以从 Docker 构建上下文（build context）中的本地文件系统中复制文件，也可以从远程 URL 下载文件并添加到容器中。

ADD 指令的语法如下：

ADD <源路径> <目标路径>
1

其中 <源路径> 是要添加到容器中的文件、目录或远程 URL，<目标路径> 是容器内部的目标路径。

以下是一些示例：

ADD app.py /app/
1

上述指令将本地文件系统中的 “app.py” 文件复制到容器内部的 “/app/” 目录下。

ADD mydir /mydir/
1

上述指令将本地文件系统中的 “mydir” 目录复制到容器内部的 “/mydir/” 目录下。

ADD https://example.com/file.txt /app/
1

上述指令将从远程 URL “https://example.com/file.txt” 下载文件，并将其复制到容器内部的 “/app/” 目录下。

请注意以下几点：

• 如果 <目标路径> 是一个以 “/” 结尾的目录路径，那么源路径的基本名称将用作目标路径中的文件或目录名。
• 如果 <目标路径> 是一个不存在的目录，Docker 将自动创建该目录。
• 如果 <源路径> 是一个目录，Docker 将递归复制该目录及其内容。
• 如果 <源路径> 是一个文件或 URL，Docker 将复制该文件或从 URL 下载文件。
• 如果 <源路径> 是一个通配符表达式，Docker 将复制匹配该表达式的文件或目录。

需要注意的是，ADD 指令在构建镜像时会自动解压缩被复制的文件，如果 <源路径> 是一个压缩文件（例如 .tar、.gzip、.bz2 等），Docker 会自动将其解压缩。

在实际使用时，建议使用 COPY 指令代替 ADD 指令，除非需要使用 ADD 指令特定的功能，例如远程 URL 下载或自动解压缩功能。

COPY

用于将文件或目录从主机复制到正在构建的 Docker 镜像中。

在 Dockerfile 中，COPY 是一个指令（instruction），用于将文件或目录从主机复制到正在构建的 Docker 镜像中。

COPY 指令的作用是将指定的文件或目录从构建上下文（build context）复制到容器内的指定位置。构建上下文是指在构建镜像过程中 Docker 引擎使用的文件和目录集合，通常是 Dockerfile 所在的目录及其子目录。

COPY 指令的语法如下：

COPY <源路径> <目标路径>
1

其中：

• <源路径>：指定要复制的文件或目录在构建上下文内的路径。可以是相对路径或绝对路径。
• <目标路径>：指定要将文件或目录复制到容器内的路径。必须是容器内的绝对路径。

COPY 指令将会复制构建上下文内的文件或目录到容器内的指定位置，这样在运行容器时就可以访问这些文件或目录。请注意，COPY 指令只能复制构建上下文内的文件和目录，而不能复制主机上的文件。

以下是一些示例：

COPY app.py /app/
1

上述指令将构建上下文内的 app.py 文件复制到容器内的 /app/ 目录。

COPY data/ /data/
1

上述指令将构建上下文内的 data/ 目录复制到容器内的 /data/ 目录。

COPY 指令可以与其他 Dockerfile 指令（如 RUN、CMD 等）结合使用，以创建一个包含所需文件和目录的镜像。

请注意，COPY 指令的路径是相对于构建上下文的，并且会将指定的文件或目录复制到容器的指定路径下。因此，在使用 COPY 指令时，请确保文件和目录在构建上下文内，并提供正确的路径。

VOLUME

在容器中创建一个挂载点，与容器数据卷相关，用于数据保存和持久化工作

在 Dockerfile 中，VOLUME 是一个指令（instruction），用于在容器中创建一个挂载点（mount point）。

VOLUME 指令的作用是在容器内部创建一个目录，并将其标记为挂载点。挂载点可以用于持久化数据，或者与主机上的目录进行共享。

VOLUME 指令的语法如下：

VOLUME <路径>
1

其中 <路径> 是要创建的挂载点的路径。

以下是一个示例：

VOLUME /data
1

上述指令在容器内部创建了一个挂载点 /data。

在运行容器时，可以使用 -v 或 --volume 参数来将主机上的目录与容器内的挂载点进行绑定，从而实现数据的持久化或主机与容器之间的文件共享。

例如，可以使用以下命令运行容器并将主机上的 /host/data 目录与容器内的 /data 挂载点进行绑定：

docker run -v /host/data:/data myimage
1

通过这样的绑定，容器内的 /data 目录中的数据将与主机上的 /host/data 目录中的数据同步。

需要注意的是，VOLUME 指令在 Dockerfile 中只是将目录标记为挂载点，并不会实际创建该目录。在运行容器时，Docker 引擎会自动创建挂载点所对应的目录，如果该目录已经存在，则会使用现有的目录。

VOLUME 指令通常在镜像中用于定义持久化数据的位置，例如数据库文件、日志文件等。它允许容器与主机之间共享数据，并且在容器删除或重新创建时保留数据。

CMD

配置容器启动时要执行的默认应用程序或命令

CMD 指令可以有多个，但只有最后一个 CMD 指令会生效。

CMD 指令可以被 docker run 命令中的参数覆盖。

在 Dockerfile 中，CMD 是一个指令（instruction），用于设置容器启动时要执行的默认命令。

CMD 指令的作用是指定容器运行时的默认命令，该命令将在容器启动时执行。它可以是一个命令字符串，也可以是一个包含命令及其参数的列表形式。

CMD 指令的语法有以下几种形式：

CMD ["可执行文件", "参数1", "参数2", ...]
CMD command param1 param2 ...
CMD ["命令", "参数1 参数2", "参数3"]
1
2
3

以下是一些示例：

CMD ["python", "app.py"]
1

上述指令指定容器启动时要执行的命令是 python app.py，其中 python 是可执行文件，app.py 是参数。

CMD echo "Hello, Docker!"
1

上述指令指定容器启动时要执行的命令是 echo "Hello, Docker!"。

CMD ["sh", "-c", "echo Hello World"]
1

上述指令指定容器启动时要执行的命令是 sh -c "echo Hello World"。

CMD 指令可以有多个，但只有最后一个 CMD 指令会生效。如果在 Dockerfile 中有多个 CMD 指令，只有最后一个 CMD 指令会被执行，前面的 CMD 指令将被忽略。

CMD 指令可以被 docker run 命令中的参数覆盖。例如，可以使用以下命令运行容器时覆盖默认的 CMD 命令：

docker run myimage python script.py
1

上述命令将覆盖镜像中的默认 CMD 命令，执行 python script.py。

需要注意的是，CMD 指令通常用于设置容器的默认行为，但它也可以在运行容器时被替换或覆盖。如果通过 docker run 命令提供了其他命令，它们将替代 CMD 指令提供的默认命令。

ENTRYPOINT

配置容器启动时要执行的默认应用程序或命令

与 CMD 指令不同的是，ENTRYPOINT 指令的参数不会被 docker run 命令中的参数覆盖。

在 Dockerfile 中，ENTRYPOINT 是一个指令（instruction），用于配置容器启动时要执行的默认应用程序或命令。

ENTRYPOINT 指令的作用是指定容器运行时的默认入口点，即容器启动时要执行的主要命令或可执行文件。它可以是一个命令字符串，也可以是一个包含命令及其参数的列表形式。

ENTRYPOINT 指令的语法有以下几种形式：

ENTRYPOINT ["可执行文件", "参数1", "参数2", ...]
ENTRYPOINT command param1 param2 ...
ENTRYPOINT ["命令", "参数1 参数2", "参数3"]
1
2
3

以下是一些示例：

ENTRYPOINT ["python", "app.py"]
1

上述指令指定容器启动时要执行的命令是 python app.py，其中 python 是可执行文件，app.py 是参数。

ENTRYPOINT echo "Hello, Docker!"
1

上述指令指定容器启动时要执行的命令是 echo "Hello, Docker!"。

ENTRYPOINT ["sh", "-c", "echo Hello World"]
1

上述指令指定容器启动时要执行的命令是 sh -c "echo Hello World"。

与 CMD 指令不同的是，ENTRYPOINT 指令的参数不会被 docker run 命令中的参数覆盖。如果在运行容器时提供了其他命令，它们将被作为 ENTRYPOINT 指令中命令的参数。

例如，如果 Dockerfile 中包含以下 ENTRYPOINT 指令：

ENTRYPOINT ["python", "app.py"]
1

可以运行以下命令来覆盖默认的 ENTRYPOINT 命令：

docker run myimage python script.py
1

上述命令将覆盖镜像中的默认 ENTRYPOINT 命令，执行 python script.py。

需要注意的是，如果在 Dockerfile 中同时使用了 CMD 和 ENTRYPOINT 指令，ENTRYPOINT 指令的参数将作为主要命令，而 CMD 指令的参数将作为默认参数。这意味着在运行容器时，可以提供额外的参数来覆盖 CMD 指令的默认参数。

ARG

用于定义构建参数

在 Dockerfile 中，ARG 是一个指令（instruction），用于定义构建参数（build-time arguments）。

ARG 指令的作用是定义一个变量，该变量可以在构建过程中使用，并且可以通过 --build-arg 参数在构建镜像时进行设置。

ARG 指令的语法如下：

ARG <变量名>[=<默认值>]
1

其中 <变量名> 是要定义的参数的名称，<默认值> 是可选的默认值。

以下是一个示例：

ARG VERSION=1.0
1

上述指令定义了一个名为 VERSION 的构建参数，并设置默认值为 1.0。

在 Dockerfile 中，可以通过使用 ${<变量名>} 的语法来引用构建参数。例如，在 RUN 指令中可以这样使用：

RUN echo "Version: ${VERSION}"
1

上述指令将输出构建参数 VERSION 的值。

在构建镜像时，可以使用 --build-arg 参数来传递构建参数的值。例如：

docker build --build-arg VERSION=2.0 -t myimage .
1

上述命令将使用值 2.0 替代默认的 1.0 来构建镜像，并将构建参数 VERSION 设置为 2.0。

需要注意的是，构建参数在构建过程中起作用，但在运行容器时不会被传递到容器内部。如果需要在容器运行时访问这些参数，可以使用环境变量来传递。

HEALTHCHECK

用于定义容器的健康检查行为

HEALTHCHECK 是 Dockerfile 中的一条指令，用于定义容器的健康检查行为。

HEALTHCHECK 指令的作用是在容器运行时定期检查容器内部应用程序的健康状态，并根据检查结果报告容器的健康情况。

HEALTHCHECK 指令的语法如下：

HEALTHCHECK [选项] CMD <命令>
1

其中 <命令> 是要执行的命令或脚本，用于检查容器内部应用程序的健康状态。可以使用任何有效的 Shell 命令或脚本。

HEALTHCHECK 指令支持以下选项：

• --interval=<持续时间>: 指定健康检查的间隔时间，默认为30秒。
• --timeout=<持续时间>: 指定健康检查命令的超时时间，默认为30秒。
• --start-period=<持续时间>: 指定容器启动后的等待时间，用于第一次进行健康检查，默认为0秒。
• --retries=<次数>: 指定在健康检查失败后重试的次数，默认为3次。

以下是一个示例：

HEALTHCHECK --interval=5s --timeout=3s CMD curl -f http://localhost/ || exit 1
1

上述指令定义了一个健康检查，每5秒执行一次命令 curl -f http://localhost/ || exit 1。如果命令返回非零状态码或超时，则认为容器不健康。

在运行容器时，可以使用 --health-cmd、--health-interval、--health-timeout 等选项来覆盖 Dockerfile 中定义的健康检查行为。

例如，可以使用以下命令运行容器并覆盖健康检查的命令：

docker run --health-cmd="curl -f http://localhost/ || exit 1" myimage
1

需要注意的是，健康检查不会自动修复容器内部的问题，它只是报告容器的健康情况。根据健康检查的结果，可以使用其他工具或编排系统来采取进一步的操作，例如重新启动容器或通知管理员。

ONBUILD

用于定义在派生镜像中延迟执行的操作

ONBUILD 是 Dockerfile 中的一条指令，用于定义在派生镜像中延迟执行的操作。

ONBUILD 指令的作用是在当前镜像被作为基础镜像构建派生镜像时，定义一些操作或指令，这些操作或指令将在派生镜像的构建过程中被延迟执行。

ONBUILD 指令的语法如下：

ONBUILD <指令>
1

其中 <指令> 可以是任何有效的 Dockerfile 指令，例如 RUN、COPY、CMD 等。

当一个镜像被用作基础镜像构建其他镜像时，ONBUILD 指令中定义的操作将被记录并延迟到派生镜像的构建过程中执行。换句话说，ONBUILD 指令相当于在当前镜像中定义了一些构建步骤，这些步骤将在派生镜像的构建过程中自动执行。

以下是一个示例：

ONBUILD COPY . /app
ONBUILD RUN make /app
1
2

上述指令定义了两个 ONBUILD 操作。当当前镜像被用作基础镜像构建派生镜像时，首先会将当前目录中的文件复制到派生镜像中的 /app 目录下，然后运行 make /app 命令。

ONBUILD 指令常用于创建可重用的基础镜像，以供其他镜像构建使用。它通常用于将一些通用的构建步骤延迟到派生镜像的构建过程中，以简化派生镜像的构建过程。

需要注意的是，ONBUILD 指令只有在当前镜像被用作基础镜像构建派生镜像时才会执行。如果当前镜像直接被用于构建容器，ONBUILD 指令将不会执行。

SHELL

用于设置默认的 Shell 环境

SHELL 是 Dockerfile 中的一条指令，用于设置默认的 Shell 环境。

SHELL 指令的作用是指定在 Dockerfile 中执行命令时要使用的默认 Shell 程序。默认情况下，Docker 使用 /bin/sh -c 作为默认的 Shell。

SHELL 指令的语法如下：

SHELL ["<Shell 程序>", "<Shell 参数>"]
1

其中 <Shell 程序> 是要使用的 Shell 程序的路径或名称，可以是绝对路径或相对路径。<Shell 参数> 是可选的参数，用于配置 Shell 程序的行为。

以下是一些示例：

SHELL ["/bin/bash", "-c"]
1

上述指令将设置 /bin/bash -c 作为默认的 Shell 程序。

SHELL ["pwsh", "-NoProfile", "-Command"]
1

上述指令将设置 pwsh -NoProfile -Command 作为默认的 Shell 程序，这是 PowerShell 的命令行版本。

通过使用 SHELL 指令，您可以选择在 Dockerfile 中使用不同的 Shell 环境，并根据需要配置 Shell 的参数。这可以让您更灵活地执行命令和脚本，并适应特定的应用程序需求。

需要注意的是，SHELL 指令只会影响 Dockerfile 中后续的命令和脚本的执行。对于交互式终端会话（例如 docker run -it），可以通过 -it 选项显式指定要使用的 Shell。

2.Dockerfile使用

前置

这里使用Dockerfile创建一个有jdk8的centos

首先要通过如下命令拉取一个centos的镜像

docker pull centos
1

然后去oracle官网下载一个jdk8

https://www.oracle.com/cn/java/technologies/downloads/
1

放到linux中

编写Dockerfile

在上面的存放jdk的目录下执行命令

[root@localhost wzy]# vim Dockerfile
1

将下面内容复制进去

FROM centos
MAINTAINER wzy<152310@163.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

#centos Linux已被停止维护，添加下面参数，否则yum会报错
RUN cd /etc/yum.repos.d/
RUN sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*
RUN sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*
RUN yum makecache
RUN yum update -y

#安装 vim编辑 器
#RUN yum -y install vim

#安装ifconfig命令查看网络IP
RUN yum -y install net-tools

#安装iava8及lib库
RUN yum -y install glibc.i686
RUN mkdir /usr/local/java

#ADD 是相对路径jar,把jdk-8u411-linux-x64.tar.gz添加到容器中,安装包必须要和Dockerfile文件在同一位置
ADD jdk-8u411-linux-x64.tar.gz  /usr/local/java/

#配置java环境变量
ENV JAVA_HOME /usr/local/java/jdk1.8.0_411
ENV JRE_HOME $JAVA_HOME/jre
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH
ENV PATH $JAVA_HOME/bin:$PATH

EXPOSE 80

CMD echo $MYPATH
CMD echo "success-------------- 0k"
CMD /bin/bash
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

然后查看Dockerfile是否生成

[root@localhost wzy]# vim Dockerfile
[root@localhost wzy]# ll
总用量 143464
drwxr-xr-x. 2 root root        42 4月  11 20:05 docker_data
-rw-r--r--. 1 root root       726 5月   5 16:18 Dockerfile
-rwxrw-rw-. 1 root root 146902735 5月   5 15:32 jdk-8u411-linux-x64.tar.gz
drwxr-xr-x. 2 root root         6 4月  10 19:21 myregistry
drwxr-xr-x. 5 root root        41 4月  18 19:12 mysql
drwxr-xr-x. 5 root root        41 4月  25 20:24 mysqlslave
drwxr-xr-x. 3 root root        36 4月  23 20:10 redis
[root@localhost wzy]# 
1
2
3
4
5
6
7
8
9
10
11

执行构建

使用 docker build -t 镜像名:TAG .

TAG是版本标签，最后的.一定要带上

时间略长，完成后如下：

[root@localhost wzy]# docker build -t javacentos:1.5 .
[+] Building 403.9s (16/16) FINISHED                                    docker:default
 => [internal] load build definition from Dockerfile                              0.0s
 => => transferring dockerfile: 1.15kB                                            0.0s
 => [internal] load metadata for docker.io/library/centos:latest                  0.0s
 => [internal] load .dockerignore                                                 0.0s
 => => transferring context: 2B                                                   0.0s
 => [ 1/11] FROM docker.io/library/centos:latest                                  0.0s
 => [internal] load build context                                                 0.0s
 => => transferring context: 111B                                                 0.0s
 => CACHED [ 2/11] WORKDIR /usr/local                                             0.0s
 => [ 3/11] RUN cd /etc/yum.repos.d/                                              0.6s
 => [ 4/11] RUN sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*     0.8s
 => [ 5/11] RUN sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault  0.8s
 => [ 6/11] RUN yum makecache                                                   120.2s
 => [ 7/11] RUN yum update -y                                                   251.6s 
 => [ 8/11] RUN yum -y install net-tools                                          4.4s 
 => [ 9/11] RUN yum -y install glibc.i686                                         8.2s 
 => [10/11] RUN mkdir /usr/local/java                                             0.8s 
 => [11/11] ADD jdk-8u411-linux-x64.tar.gz  /usr/local/java/                     12.9s 
 => exporting to image                                                            3.3s 
 => => exporting layers                                                           3.3s 
 => => writing image sha256:bab2caaa8c22674d3f2b85677c779de018aecf879b2575757bc4  0.0s 
 => => naming to docker.io/library/javacentos:1.5    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

查看生成的镜像，第一个便是

[root@localhost wzy]# docker images
REPOSITORY                                         TAG       IMAGE ID       CREATED          SIZE
javacentos                                         1.5       bab2caaa8c22   32 seconds ago   982MB
0.0.0.0:5000/wzynewubt                             1.0       e0b810b1a75f   3 weeks ago      125MB
registry.cn-hangzhou.aliyuncs.com/bigworth/stock   1.0       67785ab85293   3 weeks ago      191MB
ubuntu                                             latest    efb62633a173   4 weeks ago      72.8MB
tomcat                                             latest    fb5657adc892   2 years ago      680MB
redis                                              6.2.6     7614ae9453d1   2 years ago      113MB
redis                                              latest    7614ae9453d1   2 years ago      113MB
mysql                                              latest    3218b38490ce   2 years ago      516MB
registry                                           latest    b8604a3fe854   2 years ago      26.2MB
centos                                             latest    5d0da3dc9764   2 years ago      231MB
[root@localhost wzy]# 
1
2
3
4
5
6
7
8
9
10
11
12
13

验证

运行新镜像的容器实例

pwd进入的是Dockerfile配置的工作目录/usr/local

java -version输出的也是上面下载的java版本

[root@localhost wzy]# docker run -it bab2caaa8c22 /bin/bash
[root@e58873ee0dd4 local]# pwd
/usr/local
[root@e58873ee0dd4 local]# java -version
java version "1.8.0_411"
Java(TM) SE Runtime Environment (build 1.8.0_411-b09)
Java HotSpot(TM) 64-Bit Server VM (build 25.411-b09, mixed mode)
[root@e58873ee0dd4 local]# 
1
2
3
4
5
6
7
8

3.虚悬镜像

仓库和标签都是none的镜像

docker使用或部署时出现错误可能会导致虚悬镜像的产生。

查看虚悬镜像

docker image ls -f dangling=true

删除虚悬镜像

docker image prune

4.docker部署jar包

准备java项目代码

准备java项目代码，打jar包

在cmd用java -jar验证jar包无问题后再使用

注意：需要打包的项目和其父项目的pom中都必须有如下maven插件，且父项目pom要有parent依赖。然后才能进行打包，否则java -jar可能会出现找不到主类错误

<build>
      <plugins>
          <plugin>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-maven-plugin</artifactId>
          </plugin>
        </plugins>
 </build>
1
2
3
4
5
6
7
8

代码：

访问：

http://localhost:8081/my/cte
1

然后把jar包放入linux中，注意对比传输过后的文件大小是否一致，如果不一致后面会构建失败

编写Dockerfile文件

如下，使用java8

在jar包所在目录写编写Dockerfile，使用vim Dockerfile：

将如下内容粘贴进去

#基础镜像使用java
FROM java:8

#作者
MAINTAINER wzy

#VOLUME指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp
VOLUME /tmp

#将jar包添加到容器中并更名为wzy_docker.jar
ADD KingdeeDemo-1.0-SNAPSHOT.jar wzy_docker.jar

# 运行jar包
RUN bash -c 'touch /wzy_docker.jar'
ENTRYPOINT ["java","-jar","/wzy_docker.jar"]

#暴露8081端口，因为上面的代码的端口也是8081
EXPOSE 8081
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

wq保存退出

构建镜像

格式：docker build -t 镜像名:TAG .

注意要有后面的那个圆点

命令如下

docker build -t wzy_docker.jar:1.0 .
1

执行

[root@localhost java]# docker build -t wzy_docker.jar:1.0 .
[+] Building 21.5s (8/8) FINISHED                                       docker:default
 => [internal] load build definition from Dockerfile                              0.0s
 => => transferring dockerfile: 572B                                              0.0s
 => [internal] load metadata for docker.io/library/java:8                        15.5s
 => [internal] load .dockerignore                                                 0.0s
 => => transferring context: 2B                                                   0.0s
 => [internal] load build context                                                 1.5s
 => => transferring context: 52.09MB                                              1.4s
 => CACHED [1/3] FROM docker.io/library/java:8@sha256:c1ff613e8ba25833d2e1940da0  0.0s
 => [2/3] ADD KingdeeDemo-1.0-SNAPSHOT.jar wzy_docker.jar                         1.1s
 => [3/3] RUN bash -c 'touch /wzy_docker.jar'                                     2.9s
 => exporting to image                                                            0.2s
 => => exporting layers                                                           0.2s
 => => writing image sha256:8a2e8dd389bf95e223abd25ed043a1a618f2542de48426ec2a4b  0.0s
 => => naming to docker.io/library/wzy_docker.jar:1.0                             0.0s
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

docker images查看镜像

第一个wzy_docker.jar 就是

[root@localhost java]# docker images
REPOSITORY                                         TAG       IMAGE ID       CREATED         SIZE
wzy_docker.jar                                     1.0       8a2e8dd389bf   9 seconds ago   747MB
javacentos                                         1.5       bab2caaa8c22   4 days ago      982MB
0.0.0.0:5000/wzynewubt                             1.0       e0b810b1a75f   4 weeks ago     125MB
registry.cn-hangzhou.aliyuncs.com/bigworth/stock   1.0       67785ab85293   4 weeks ago     191MB
ubuntu                                             latest    efb62633a173   4 weeks ago     72.8MB
tomcat                                             latest    fb5657adc892   2 years ago     680MB
redis                                              6.2.6     7614ae9453d1   2 years ago     113MB
redis                                              latest    7614ae9453d1   2 years ago     113MB
mysql                                              latest    3218b38490ce   2 years ago     516MB
registry                                           latest    b8604a3fe854   2 years ago     26.2MB
centos                                             latest    5d0da3dc9764   2 years ago     231MB
[root@localhost java]#
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行容器

因为java项目一般都要后台运行，然后做端口映射，所以使用如下命令

docker run -d -p 8081:8081 8a2e8dd389bf
1

执行

[root@localhost java]# docker run -d -p 8081:8081 8a2e8dd389bf
a5030ed9e5b5ee8ad4529b6f92ba982cfbce7c024af0f9cd569ed324426a8024
[root@localhost java]# 
1
2
3

如果有防火墙则开放端口

开放端口：firewall-cmd --zone=public --add-port=8081/tcp --permanent
重启防火墙：firewall-cmd --reload
查看防火墙状态：firewall-cmd --list-all
1
2
3

如果http拒绝连接，执行下面命令安装httpd

yum install httpd
systemctl enable httpd
systemctl start httpd
1
2
3

然后访问项目

虚拟机访问

http://localhost:8081/my/cte
1

宿主机访问，192.168.0.101是我的虚拟机ip：

http://192.168.0.101:8081/my/cte
1

如果运行容器访问出现问题，还可以通过如下命令查看日志，根据报错信息查找原因

docker logs -t -f 容器实例id

查看运行日志：

docker logs -t -f 8a2e8dd389bf
1

dockerHub地址

https://hub.docker.com/
1