Dockerfile使用

1.Dockerfile是什么

官网地址

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

概念

是什么

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"]

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

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

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

docker build -t myimage:tag .

上述命令将在当前目录下的 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 .

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

docker run:

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

示例命令：

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

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

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

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

保留字指令

FROM

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

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

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

FROM 指令的语法如下：

FROM <基础镜像>

其中：

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

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

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

以下是一个示例：

FROM ubuntu:20.04

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

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

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

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

MAINTAINER

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

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

MAINTAINER 指令的语法如下：

MAINTAINER <维护者信息>

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

例如：

MAINTAINER John Doe <john@example.com>

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

以下是一个示例：

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

上述指令使用 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 <命令>

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

以下是一些示例：

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

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

RUN echo "Hello, Docker!"

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

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

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

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

EXPOSE

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

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

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

EXPOSE 指令的语法如下：

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

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

以下是一个示例：

EXPOSE 80

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

EXPOSE 8080 9000-9010

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

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

文档化：通过在 Dockerfile 中使用 EXPOSE 指令，可以清楚地记录容器在运行时需要监听的端口，使用户或开发人员了解容器的网络配置和使用要求。
与-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:/#

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

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

WORKDIR 指令的语法如下：

WORKDIR <工作目录路径>

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

以下是一个示例：

WORKDIR /app

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

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

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

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

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

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

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

USER

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

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

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

USER 指令的语法如下：

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

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

以下是一些示例：

USER myuser

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

USER 1000

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

USER myuser:mygroup

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

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

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

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

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

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

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

ENV

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

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

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

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

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

ENV 指令的语法如下：

ENV <变量名>=<值>

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

以下是一些示例：

ENV MY_VAR=my_value

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

ENV PORT=8080

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

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

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

ENV MY_VAR=my_value
ENV PORT=8080

RUN echo $MY_VAR

在上述示例中，通过 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 <源路径> <目标路径>

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

以下是一些示例：

ADD app.py /app/

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

ADD mydir /mydir/

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

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

上述指令将从远程 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 <源路径> <目标路径>

其中：

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

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

以下是一些示例：

COPY app.py /app/

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

COPY data/ /data/

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

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

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

VOLUME

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

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

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

VOLUME 指令的语法如下：

VOLUME <路径>

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

以下是一个示例：

VOLUME /data

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

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

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

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

通过这样的绑定，容器内的 /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"]

以下是一些示例：

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

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

CMD echo "Hello, Docker!"

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

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

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

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

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

docker run myimage python script.py

上述命令将覆盖镜像中的默认 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"]

以下是一些示例：

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

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

ENTRYPOINT echo "Hello, Docker!"

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

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

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

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

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

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

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

docker run myimage python script.py

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

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

ARG

用于定义构建参数

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

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

ARG 指令的语法如下：

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

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

以下是一个示例：

ARG VERSION=1.0

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

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

RUN echo "Version: ${VERSION}"

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

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

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

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

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

HEALTHCHECK

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

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

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

HEALTHCHECK 指令的语法如下：

HEALTHCHECK [选项] CMD <命令>

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

HEALTHCHECK 指令支持以下选项：

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

以下是一个示例：

HEALTHCHECK --interval=5s --timeout=3s CMD curl -f http://localhost/ || exit 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

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

ONBUILD

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

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

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

ONBUILD 指令的语法如下：

ONBUILD <指令>

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

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

以下是一个示例：

ONBUILD COPY . /app
ONBUILD RUN make /app

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

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

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

SHELL

用于设置默认的 Shell 环境

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

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

SHELL 指令的语法如下：

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

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

以下是一些示例：

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

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

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

上述指令将设置 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

然后去oracle官网下载一个jdk8

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

放到linux中

编写Dockerfile

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

[root@localhost wzy]# vim Dockerfile

将下面内容复制进去

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

然后查看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]#

执行构建

使用 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

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

[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]#

验证

运行新镜像的容器实例

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]#

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>

代码：

访问：

http://localhost:8081/my/cte

然后把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

wq保存退出

构建镜像

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

注意要有后面的那个圆点

命令如下

docker build -t wzy_docker.jar:1.0 .

执行

[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

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]#

运行容器

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

docker run -d -p 8081:8081 8a2e8dd389bf

执行

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

如果有防火墙则开放端口

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

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

yum install httpd
systemctl enable httpd
systemctl start httpd

然后访问项目

虚拟机访问

http://localhost:8081/my/cte

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

http://192.168.0.101:8081/my/cte

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

docker logs -t -f 容器实例id

查看运行日志：

docker logs -t -f 8a2e8dd389bf

dockerHub地址

https://hub.docker.com/