1.Dockerfile是什么
官网地址
https://docs.docker.com/reference/dockerfile/
概念
是什么
Dockerfile 是用于构建 Docker 镜像的文本文件,它包含一系列的指令(instructions)和参数,用于描述如何构建和配置镜像。
Dockerfile 是基于一种声明式语法,它允许您定义从基础镜像开始的一系列操作,包括安装软件包、复制文件、设置环境变量、暴露端口等。
以下是一个简单的 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
用于设置容器内部的工作目录
shell
#指定在创建容器后,终端默认登录进来的工作目录。
#比如如下命令,运行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 中创建新用户并设置为容器的默认用户:
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
指令设置环境变量并在容器中使用它:
dockerfile
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的目录下执行命令
shell
[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是否生成
shell
[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是版本标签,最后的.一定要带上
时间略长,完成后如下:
shell
[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
查看生成的镜像,第一个便是
shell
[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版本
shell
[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可能会出现找不到主类错误
xml
<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 .
执行
shell
[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 就是
shell
[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
执行
shell
[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/