Dockerfile使用

CSDN 2024-08-29 10:37:11 阅读 94

1.Dockerfile是什么

官网地址

<code>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}"code>

# 暴露端口

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 builddocker 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>"code>

上述指令使用 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 指令(如 RUNCMD 等)结合使用,以创建一个包含所需文件和目录的镜像。

请注意,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 中同时使用了 CMDENTRYPOINT 指令,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" myimagecode>

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

ONBUILD

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

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

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

ONBUILD 指令的语法如下:

ONBUILD <指令>

其中 <指令> 可以是任何有效的 Dockerfile 指令,例如 RUNCOPYCMD 等。

当一个镜像被用作基础镜像构建其他镜像时,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中

image-20240505161340791

编写Dockerfile

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

<code>[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的镜像

image-20240508191728970

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

查看虚悬镜像

docker image ls -f dangling=true

image-20240508191900830

删除虚悬镜像

docker image prune

image-20240508192026678

4.docker部署jar包

准备java项目代码

准备java项目代码,打jar包

cmdjava -jar验证jar包无问题后再使用

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

<build>

<plugins>

<plugin>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-maven-plugin</artifactId>

</plugin>

</plugins>

</build>

代码:

image-20240521212457775

访问:

<code>http://localhost:8081/my/cte

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

编写Dockerfile文件

如下,使用java8

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

image-20240509194530466

将如下内容粘贴进去

<code>#基础镜像使用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

image-20240509202625220

宿主机访问,192.168.0.101是我的虚拟机ip:

<code>http://192.168.0.101:8081/my/cte

image-20240509202754969

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

<code>docker logs -t -f 容器实例id

查看运行日志:

docker logs -t -f 8a2e8dd389bf

dockerHub地址

https://hub.docker.com/



声明

本文内容仅代表作者观点,或转载于其他网站,本站不以此文作为商业用途
如有涉及侵权,请联系本站进行删除
转载本站原创文章,请注明来源及作者。