Dockerfile - 工作流程、构建镜像、文件语法

最新推荐文章于 2024-03-25 11:55:44 发布
最新推荐文章于 2024-03-25 11:55:44 发布
阅读量1.3k 收藏 19
点赞数 35
分类专栏： Docker 文章标签： linux 运维 服务器 Dockerfile
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CYK_byte/article/details/135249621
版权

目录

一、Dockerfile 

1.1、简介

1.2、Dockerfile 构建镜像的流程

1.3、Dockerfile 文件语法

1.3.1、注意事项

1.3.2、FROM

1.3.3、MAINTAINER（官方已废弃）

1.3.4、RUN

1.3.5、EXPOSE

1.3.6、WORKDIR

1.3.7、ADD 和 COPY

1.3.8、ENV

1.3.9、VOLUME

1.3.10、CMD 和 ENTRYPOINT

一、Dockerfile 

1.1、简介

a）Dockerfile 是什么？

        Dockerfile 就是镜像的描述文件.

b）Dockerfile 的作用？

        通过 Dockerfile 文件就可以构建一个属于自己的镜像.

c）为什么使用 Dockerfile 构建镜像？

        官方的镜像确实足够好了，适用于大多数应用场景，但是如果我们想要构建属于我们自己的业务镜像，就需要自定义镜像了.

例如，你写了一个 Spring 项目，还用到了，redis，tomcat...... 这些容器，那么你部署项目的时候，还需要先去启动 redis，tomcat ...... 这些容器，并且如果要部署到多台机器上，整个部署的过程就相当繁琐.  通过 Dockerfile 就可以提前将这些部署操作写好，我们只需要通过 build 指令构建镜像，最后运行镜像就完成了部署.

d）如何通过 Dockerfile 构建镜像？

        a. 在指定位置创建一个 Dockerfile 文件，进行编写.

        b. 通过以下命令构建镜像.

docker build -t 自定义镜像名:自定义版本 .(指定 Dockerfile 文件所在位置，"." 表示当前目录)

1.2、Dockerfile 构建镜像的流程

a）编写 Dockerfile 文件：例如在 /root 目录下创建一个 Dockerfile 文件进行编写，就称 /root（Dockerfile 文件所在目录）为 context（上下文）.

b）请求 DockerServer 构建：因为 Docker 也是一个客户端服务器程序，因此我们可以在客户端通过 build 命令来请求 DockerServer 进行构建镜像.

c）开始构建：DockerServer 会拿到 context（上下文）中的所有 Dockerfile 开始构建.  具体的，会对  Dockerfile 文件中的每一行指令都构建出一个 临时镜像，并保存到 cache 中（这样做是为了日后如果有修改 Dockerfile 文件，比如在原来的基础上增加了几条命令，那么之前命令构建好的镜像就直接从缓存里拿了，提升了构建速度），最后就构建出了一个最终的镜像.

Ps：Dockerfile 编写要求，一行只能存在一条完成的命令

d）特例1：如果 context 中存在 dockerIgnore 文件，那么本次构建则不会构建 dockerIgnore 文件中描述的文件.

e）特里2：如果我就想让 DockerServer 每次都把 Dockerfile 中的命令都加载一遍，就可以在 build 命令中加上 --no-cache 参数，这样就不会把每次生成的零时镜像保存到 cache 中.

1.3、Dockerfile 文件语法

1.3.1、注意事项

  1. 每条指令都必须大写，后面都至少需要一个参数.
  2. 指令按照从上到下，顺序执行.
  3. # 表示注释.
  4. 每条指令都会创建一个新的镜像层，并对镜像进行提交（临时镜像）.

1.3.2、FROM

a）表示当前镜像是基于哪一个镜像的. 

这个指令是非常有必要的，因为一个容器就是一个操作系统，我们写的 Dockerfile 总不可能每次都是从操作系统的层面写起.  例如你的运行的是一个 Java 项目，那么就需要 JDK 环境来支撑，总不能自己手写 JDK 吧~

FROM 基于哪个镜像

Ps：第一个指令必须是 FROM

b）例如，我们要构建一个镜像，是基于 centos 镜像的，那么就需要创建一个 Dockerfile 文件，编写内容如下

FROM centos:7

通过如下指令通过当前目录下的 Dockerfile 文件构建名为 mycentos 镜像

[root@VM-8-17-centos dockerfile]# docker build -t mycentos:1 .
[+] Building 0.1s (5/5) FINISHED                                                                                                                            docker:default
 => [internal] load build definition from Dockerfile                                                                                                                  0.0s
 => => transferring dockerfile: 56B                                                                                                                                   0.0s
 => [internal] load .dockerignore                                                                                                                                     0.0s
 => => transferring context: 2B                                                                                                                                       0.0s
 => [internal] load metadata for docker.io/library/centos:7                                                                                                      0.0s
 => [1/1] FROM docker.io/library/centos:latest                                                                                                                        0.0s
 => exporting to image                                                                                                                                                0.0s
 => => exporting layers                                                                                                                                               0.0s
 => => writing image sha256:22773018c04267669821153cd42ef21101902b10a8a16f340fbef85a77821d03                                                                          0.0s
 => => naming to docker.io/library/mycentos:1                                                                                                                         0.0s

这样，我们自己的镜像就构建好了

[root@VM-8-17-centos dockerfile]# docker images
REPOSITORY                  TAG              IMAGE ID       CREATED       SIZE
centos                      latest           5d0da3dc9764   2 years ago   231MB
mycentos                    1                22773018c042   2 years ago   231MB

1.3.3、MAINTAINER（官方已废弃）

镜像维护者的姓名和邮箱地址.

Ps：官方已废弃，这里就不讲了

1.3.4、RUN

a）构建镜像时需要运行的指令.

RUN 要运行的指令

b）例如要基于 centos 构建镜像，同时希望下载好 vim 编辑器，RUN 指令的写法就有以下两种方式

# 第一种写法
RUN yum install -y vim
# 第二种写法
RUN ["yum", "install", "-y", "vim"]

这里使用第一种方式来演示，那么 Dockerfile 文件如下

FROM centos:7
RUN yum install -y vim

构建镜像

[root@VM-8-17-centos dockerfile]# docker build -t mycentos:1 .
[+] Building 35.6s (6/6) FINISHED                                                                                                                           docker:default
 => [internal] load .dockerignore                                                                                                                                     0.0s
 => => transferring context: 2B                                                                                                                                       0.0s
 => [internal] load build definition from Dockerfile                                                                                                                  0.0s
 => => transferring dockerfile: 74B                                                                                                                                   0.0s
 => [internal] load metadata for docker.io/library/centos:7                                                                                                           0.0s
 => CACHED [1/2] FROM docker.io/library/centos:7                                                                                                                      0.0s
 => [2/2] RUN yum install -y vim                                                                                                                                     33.7s
 => exporting to image                                                                                                                                                1.9s 
 => => exporting layers                                                                                                                                               1.8s 
 => => writing image sha256:e30f98790cacacea34fce01e42b64b14dd5e489645e4df6f1b4f9e3ac31c12b6                                                                          0.0s 
 => => naming to docker.io/library/mycentos:1                                                                                                                         0.0s

运行容器，检查 vim 是否安装成功

[root@VM-8-17-centos dockerfile]# docker run -it mycentos:1
[root@795b36479fe7 /]# ll
total 64
-rw-r--r--   1 root root 12114 Nov 13  2020 anaconda-post.log
lrwxrwxrwx   1 root root     7 Nov 13  2020 bin -> usr/bin
drwxr-xr-x   5 root root   360 Dec 28 02:57 dev
drwxr-xr-x   1 root root  4096 Dec 28 02:57 etc
drwxr-xr-x   2 root root  4096 Apr 11  2018 home
lrwxrwxrwx   1 root root     7 Nov 13  2020 lib -> usr/lib
lrwxrwxrwx   1 root root     9 Nov 13  2020 lib64 -> usr/lib64
drwxr-xr-x   2 root root  4096 Apr 11  2018 media
drwxr-xr-x   2 root root  4096 Apr 11  2018 mnt
drwxr-xr-x   2 root root  4096 Apr 11  2018 opt
dr-xr-xr-x 115 root root     0 Dec 28 02:57 proc
dr-xr-x---   2 root root  4096 Nov 13  2020 root
drwxr-xr-x   1 root root  4096 Dec 28 02:56 run
lrwxrwxrwx   1 root root     8 Nov 13  2020 sbin -> usr/sbin
drwxr-xr-x   2 root root  4096 Apr 11  2018 srv
dr-xr-xr-x  13 root root     0 Dec 28 02:57 sys
drwxrwxrwt   1 root root  4096 Dec 28 02:56 tmp
drwxr-xr-x   1 root root  4096 Nov 13  2020 usr
drwxr-xr-x   1 root root  4096 Nov 13  2020 var
[root@795b36479fe7 /]# vim test   
[root@795b36479fe7 /]# cat test
hellow world

Ps：-it 参数表示运行容器后立即与容器进行交互，如果不加此参数，运行 centos 容器启动后会立即结束（centos 镜像中没有需要执行的任务）

1.3.5、EXPOSE

a）声明当前容器对外暴露的端口号.  此命令的作用只是声明，日后方便别人看的，因为端口号暴露是可以在 docker run 启动容器时通过 -p 参数指定的.

EXPOSE 端口号

b）例如，声明该容器暴露的端口号为 8080、15672、5672，那么 Dockerfile 文件编写如下

FROM centos:7
RUN yum install -y vim
# 这里只是声明容器中使用的端口号
EXPOSE 8080
EXPOSE 15672
EXPOSE 5672

1.3.6、WORKDIR

a）指定在创建容器后，终端默认进来的工作目录（一个落脚点）.  如果 WORKDIR 指定的目录不存在，就会自动创建目录结构并进入.

# 绝对路径
WORKDIR /apps/data
# 相对路径
WORKDIR a

# 注意：WORKDIR 指令可以在 Dockerfile 文件中多次使用.  以上连续使用就表示，
# 先进入 /apps/data 目录，然后在进入 /apps/data/a 目录

b）例如，先进入 /apps/data 目录，在进入 /apps/data/a 目录，那么 Dockerfile 文件如下

FROM centos:7
RUN yum install -y vim
# 这里只是声明容器中使用的端口号
EXPOSE 8080
EXPOSE 15672
EXPOSE 5672
WORKDIR /apps/data
WORKDIR a

构建好后进入镜像，检查当前所在目录

[root@VM-8-17-centos dockerfile]# docker build -t mycentos3 .
[+] Building 0.3s (8/8) FINISHED                                                                                                                            docker:default
 => [internal] load build definition from Dockerfile                                                                                                                  0.0s
 => => transferring dockerfile: 191B                                                                                                                                  0.0s
 => [internal] load .dockerignore                                                                                                                                     0.0s
 => => transferring context: 2B                                                                                                                                       0.0s
 => [internal] load metadata for docker.io/library/centos:7                                                                                                           0.0s
 => [1/4] FROM docker.io/library/centos:7                                                                                                                             0.0s
 => CACHED [2/4] RUN yum install -y vim                                                                                                                               0.0s
 => [3/4] WORKDIR /apps/data                                                                                                                                          0.1s
 => [4/4] WORKDIR a                                                                                                                                                   0.1s
 => exporting to image                                                                                                                                                0.1s
 => => exporting layers                                                                                                                                               0.1s
 => => writing image sha256:5661a00d5fe4468bb0f231d44e5c16e609d65f3e37ac8c24697c8a6e8220eab9                                                                          0.0s
 => => naming to docker.io/library/mycentos3                                                                                                                          0.0s
[root@VM-8-17-centos dockerfile]# 
[root@VM-8-17-centos dockerfile]# docker run -it mycentos3
[root@89c6748a1083 a]# pwd
/apps/data/a
[root@89c6748a1083 a]#

1.3.7、ADD 和 COPY

a）将宿主机目录下的文件拷贝到镜像.

ADD 宿主机目录或URL 容器内目录
COPY 构建上下文中的文件 容器内目录

b）ADD 和 COPY的区别：

相同点：

  1. ADD 和 COPY 都是用来拷贝宿主机上的文件到镜像中.

不同点：

  1. ADD 如果拷贝的是一个 tar 包，会自动解压.
  2. COPY 只能拷贝上下文中的文件到工作目录，ADD 可以将宿主机上任意目录下的文件拷贝到镜像.
  3. ADD 不仅可以拷贝宿主机文件，还可以通过指定 URL 来下载需要的文件.

c）例如，将当前目录下的 aa.txt 文件拷贝到容器的工作目录，Dockerfile 文件如下

FROM centos:7
RUN yum install -y vim
# 这里只是声明容器中使用的端口号
EXPOSE 8080
EXPOSE 15672
EXPOSE 5672
WORKDIR /apps/data
WORKDIR a
ADD aa.txt .

构建镜像后进入容器，检查文件

[root@VM-8-17-centos dockerfile]# docker build -t mycentos:1 .
[+] Building 0.2s (10/10) FINISHED                                                                                                                          docker:default
 => [internal] load build definition from Dockerfile                                                                                                                  0.0s
 => => transferring dockerfile: 204B                                                                                                                                  0.0s
 => [internal] load .dockerignore                                                                                                                                     0.0s
 => => transferring context: 2B                                                                                                                                       0.0s
 => [internal] load metadata for docker.io/library/centos:7                                                                                                           0.0s
 => [1/5] FROM docker.io/library/centos:7                                                                                                                             0.0s
 => [internal] load build context                                                                                                                                     0.0s
 => => transferring context: 45B                                                                                                                                      0.0s
 => CACHED [2/5] RUN yum install -y vim                                                                                                                               0.0s
 => CACHED [3/5] WORKDIR /apps/data                                                                                                                                   0.0s
 => CACHED [4/5] WORKDIR a                                                                                                                                            0.0s
 => [5/5] ADD aa.txt .                                                                                                                                                0.1s
 => exporting to image                                                                                                                                                0.0s
 => => exporting layers                                                                                                                                               0.0s
 => => writing image sha256:66e032475f19cd2dec85f8007cc5329b68eae84b876d5b0b180d588059d86c45                                                                          0.0s
 => => naming to docker.io/library/mycentos:1                                                                                                                         0.0s
[root@VM-8-17-centos dockerfile]# 
[root@VM-8-17-centos dockerfile]# docker run -it mycentos:1
[root@cac57774ec9d a]# ls
aa.txt
[root@cac57774ec9d a]# cat aa.txt
hello world
[root@cac57774ec9d a]# pwd
/apps/data/a

1.3.8、ENV

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

# 创建环境变量如下
ENV 自定义变量名=值

# 使用：通过 $自定义变量名 即可使用

b）例如，自定义变量名为 BASE_PATH，值为 /apps/data ，用来给 WORKDIR 进行配置.

FROM centos:7
RUN yum install -y vim
# 这里只是声明容器中使用的端口号
EXPOSE 8080
EXPOSE 15672
EXPOSE 5672
# 配置环境变量
ENV BASE_PATH=/apps/data
WORKDIR $BASE_PATH
ADD aa.txt .

构建后进入容器，检查当前目录

[root@VM-8-17-centos dockerfile]# docker build -t mycentos:2 .
[+] Building 0.2s (9/9) FINISHED                                                                                                                            docker:default
 => [internal] load .dockerignore                                                                                                                                     0.0s
 => => transferring context: 2B                                                                                                                                       0.0s
 => [internal] load build definition from Dockerfile                                                                                                                  0.0s
 => => transferring dockerfile: 239B                                                                                                                                  0.0s
 => [internal] load metadata for docker.io/library/centos:7                                                                                                           0.0s
 => [1/4] FROM docker.io/library/centos:7                                                                                                                             0.0s
 => [internal] load build context                                                                                                                                     0.0s
 => => transferring context: 27B                                                                                                                                      0.0s
 => CACHED [2/4] RUN yum install -y vim                                                                                                                               0.0s
 => CACHED [3/4] WORKDIR /apps/data                                                                                                                                   0.0s
 => [4/4] ADD aa.txt .                                                                                                                                                0.0s
 => exporting to image                                                                                                                                                0.0s
 => => exporting layers                                                                                                                                               0.0s
 => => writing image sha256:1ef398b6982b0ce29fb20c7aa1383150694791b3d898c1b6d19c12fdea994517                                                                          0.0s
 => => naming to docker.io/library/mycentos:2                                                                                                                         0.0s
[root@VM-8-17-centos dockerfile]# docker run -it mycentos:2
[root@500be777bf0a data]# pwd
/apps/data

1.3.9、VOLUME

a）容器数据卷，用来声明容器中的某个目录可以挂载到宿主机中.  这个命令和 EXPOSE 一样也仅仅只是声明，因为将来通过 docker run 启动容器时可以通过 -v 参数指定数据卷挂载.

VOLUME 目录

b）例如，声明容器中的 /apps/data 目录可以挂载到宿主机中，如下

VOLUME /apps/data

1.3.10、CMD 和 ENTRYPOINT

a）CMD & ENTRYPOINT 的作用

都是用来指定容器启动时默认执行的指令.

Ps：CMD 指令可以存在多个，但是存在多个只有最后一个生效.

b）使用语法

CMD 命令
ENTRYPOINT 命令

例如命令是 java -jar demo.jar ，这里实际上有两种方式书写：

  • 直接命令方式：java -jar demo.jar
  • 字符串数组方式（推荐）：["java", "-jar", "demo.jar"]

推荐原因：通过字符串数组的方式，在未来启动容器的时候，如果需要调整，可以覆盖数组中的参数（怎么覆盖，下文会讲）

c）区别

覆盖参数的方式不一样，例如启动 centos 命令原本要初始化的命令为 ls /apps/data，现在要覆盖成 ls /

1. cmd 配置后，启动容器时进行覆盖如下：

# 语法
docker run 镜像:版本号 覆盖自己定义的命令

# 当前场景的写法
docker run centos:7 ls /

2. entrypoint 配置后，启动容器时进行覆盖如下：

# 语法
docker run --entrypoint=覆盖指令 镜像:版本号 传递参数

# 当前场景写法
docker run --entrypoint=ls centos:7 /

Ps：使用的前提必须是字符串数组的方式 

d）如何使用

从上述区别中也可以看出，entrypoint 的覆盖方式比较麻烦，因此一个较为普遍的使用方式：

  • entrypoint 用来书写一个容器固定的指令.
  • cmd 用来给 entrypoint 传递参数.

例如，需要初始化的命令为 ls /apps/data ，那么 Dockerfile 文件如下

FROM centos:7
RUN yum install -y vim
# 这里只是声明容器中使用的端口号
EXPOSE 8080
EXPOSE 15672
EXPOSE 5672
# 命令 ls ，参数 /apps/data
ENTRYPOINT ["ls"]
CMD ["/apps/data"]

构建镜像并启动容器

[root@VM-8-17-centos dockerfile]# docker build -t mycentos:2 .
[+] Building 0.1s (9/9) FINISHED                                                                                                                            docker:default
 => [internal] load build definition from Dockerfile                                                                                                                  0.0s
 => => transferring dockerfile: 263B                                                                                                                                  0.0s
 => [internal] load .dockerignore                                                                                                                                     0.0s
 => => transferring context: 2B                                                                                                                                       0.0s
 => [internal] load metadata for docker.io/library/centos:7                                                                                                           0.0s
 => [1/4] FROM docker.io/library/centos:7                                                                                                                             0.0s
 => [internal] load build context                                                                                                                                     0.0s
 => => transferring context: 27B                                                                                                                                      0.0s
 => CACHED [2/4] RUN yum install -y vim                                                                                                                               0.0s
 => CACHED [3/4] WORKDIR /apps/data                                                                                                                                   0.0s
 => CACHED [4/4] ADD aa.txt .                                                                                                                                         0.0s
 => exporting to image                                                                                                                                                0.0s
 => => exporting layers                                                                                                                                               0.0s
 => => writing image sha256:148a9754a1fd4bff7e6c15a70db21cf594a7811378420057996207dc1ec0ffd1                                                                          0.0s
 => => naming to docker.io/library/mycentos:2                                                                                                                         0.0s
[root@VM-8-17-centos dockerfile]# 
[root@VM-8-17-centos dockerfile]# 
[root@VM-8-17-centos dockerfile]# docker run mycentos:2
aa.txt
[root@VM-8-17-centos dockerfile]# 
[root@VM-8-17-centos dockerfile]# docker run mycentos:2 /
anaconda-post.log
apps
bin
dev
etc
home
lib
lib64
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var

这样将来一旦要修改初始化参数，就可以直接在启动容器时进行修改.

陈亦康
关注
  • 35
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
DockerFile构建过程
m0_52091913的博客
08-31 3173
DockerFile构建过程，指令讲解，操作实列，脚本创建
如何将nodeclub构建成Docker镜像
02-26
摘要：本文从什么是Docker切入，详细分享了Dockerfile支持的语法命令，最后他介绍了怎么把nodeclub构建成Docker镜像。14年毕业后开始接触node，今天就想跟大家聊聊怎么把nodeclub项目源码构建成一个镜像。话说Docker...
Dockerfile命令详细介绍及springboot项目部署案例
爱意时刻减淡，玫瑰不再浪漫
08-19 3409
文章目录前言1.Dockerfile1.1 Dockerfile的架构图1.2 Dockerfile解析过程1.3 Dockerfile的保留命令1.3.1 FROM 命令1.3.2 MAINTAINER 命令1.3.3 RUN 命令1.3.4 EXPOSE 命令1.3.5 CMD 命令1.3.6 WORKDIR 命令1.3.7 ENV 命令1.3.8 ADD 命令1.3.9 COPY 命令1.3.10 VOLUME 命令1.3.11 ENTRYPOINT命令1.4 dockerfile命令实践，定制一个
dockerfile文件
最新发布
0
03-25 1107
Dockerfile 是一个文本文件，开发者使用它来定义如何构建一个Docker镜像。它是自动化构建Docker镜像的标准方法，包含了用于构建镜像的一系列指令，这些指令会被Docker引擎按顺序逐行解析并执行。。
Dockerfile
Technicistboy的博客
07-16 418
DockerfileDockerfile基本结构指令FROMMAINTAINERRUNCMDEXPOSEENVADDCOPYENTRYPOINTVOLUMEUSERWORKDIRONBUILD创建镜像 Dockerfile 基本结构 Dockerfile 是一个文本格式的配置文件，用户可以使用 Dockerfile 快速创建自定义镜像。 Dockerfile 由一行行命令语句组成，并且支持以 # 开头的注释行。 Docker分为四部分： 基础镜像信息 维护者信息 镜像操作指令 容器启动时默认要执行的指令
DockerFile文件详细解析
IT小辉同学
04-11 6794
从应用软件的角度而言，DockerFile，Docker镜像和Docker容器分别代表了软件的三个不同阶段DockerFile是软件的原材料Docker镜像是软件的交付品Docker容器则可以认为是软件镜像的运行状态，也是依照镜像运行的容器实例DockerFile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署和运维，三者缺一不可，合理充当Docker体系的基石！Dockerfile，需要定义一个Dockerfile，Dockerfile定义了进程需要的一切东西。
Dockerfile【超级详细】
热门推荐
danke的博客
02-08 2万+
Docker Hub 中 99% 镜像都是从这个基础镜像过来的 FROM scratch,然后配置需要的软件和配置来进行构建的。2、编写dockerfile文件 官方命名 Dockerfile ，build会自动寻找这个文件 就不需要 -f 指定了。CMD #指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代。ENTRYPOINT #指定这个容器启动的时候要运行的命令，可以追加命令。在/home/tomcat/test 下构建两个文件。
Dockerfile文件解释
Annlin_的博客
05-08 1万+
我们需要跟我们本地一样的python执行环境，所以我们要使用dockerfile来构建我们的镜像 Dockerfile 一、书写规则 1、Dockerfile文件名称必须这么写（Dockerfile） 2、第一行，如果基础镜像没有的话，会去远程去拉 FROM 基础镜像名称：版本号 3、第二行，维护的人的名字 LABEL annlin 4、第三行，设置镜像的工作空间（相当于设置登录容器之后默认进去的目录） 设置一个应用目录，创建镜像的时候会创建这个目录 WORKDIR /app.
Docker（七）—— 如何用Dockerfile制作自己的镜像
qq_44886213的博客
11-14 8304
自己写了一个小程序，如何带着环境打包成一个镜像，然后发布给别人run起来呢？以前程序员需要交付一个jar包或者war包，但是现在！
DockerFile文件详细解析.pdf
04-29
Dockerfile是一个文本文件，其中包含用于构建Docker镜像的指令。通过定义Dockerfile中的指令，可以自动化地构建和配置Docker容器所需的软件环境，从而简化了应用程序的部署过程。在Dockerfile中可以定义以下内容： ...
编写最佳的Dockerfile的方法
01-20
Dockerfile的语法非常简单，然而如何加快镜像构建速度，如何减少Docker镜像的大小却不是那么直观，需要积累实践经验。这篇博客可以帮助你快速掌握编写Dockerfile的技巧。 为了保证可读性，本文采用意译而非直译。...
Dockerfile基本梳理
01-20
Dockerfile常用语法和格式语法FROM（设置镜像创建基础）LABEL（设置镜像标签）RUN（运行命令并创建新的Image Layer）WORKDIR（设定当前工作目录）ADD 和 COPY（将本地文件添加到image里）ENV（设置常量）CMD（设置...
【Dockerfile】详细教程
WQH_Boss的博客
06-28 3069
本文介绍了Dockerfile是什么以及详细使用方法，包括模版案例
Docker基础系列之DockerFile
囚徒之困
03-06 1736
Dockerfile
Dockerfile文件详细介绍
zhoutao5688的专栏
07-24 248
Dockerfile文件介绍，
Dockerfile简介+使用
2301_77433582的博客
05-12 2844
Dockerfile是docker中镜像文件的的描述文件，说的直白点就是镜像文件到底是由什么东西一步步构成的。例如：你在淘宝上买了一个衣架，但是卖家并没有给你发一个完整的衣架，而是一些组件和一张图纸，你按照这个图纸一步一步将衣架组装起来，就成了你所需要的样子。那么Dockerfile 就是这张图纸，镜像文件就是你需要的这个衣架，Dockerfile 不建议随便命名，就用 Dockerfile。
【docker】dockerfile构建镜像
manyulanlanlu的博客
10-07 6073
docker run创建并启动容器，再通过docker exec/cp 等容器操作指令修改容器内容，然后再去用docker commit提交成新的镜像。
Dockerfile详解
氷的博客
09-13 515
然后使用docker history test:1.0和docker history test:2.0这两条命令查看它们每层的镜像ID，会发现test1.0和test:2.0的前五个镜像层的ID一模一样，这也说明了test:2.0的镜像在构建过程中复用了test:1.0的镜像层。Dockerfile 文件内容没有变化，但 RUN 命令的外部依赖发生了变化，例如本例中要安装的 vim 软件源发生了变更(版本变化、下载地址变化等)，那么从发生变化的这个指令层开始的所有镜像层 cache 全部失效。
dockerfile构建centos7镜像
08-31
要使用Dockerfile构建CentOS 7镜像，可以按照以下步骤进行操作： 1. 首先，确保已经在系统上安装了Docker环境。可以使用以下命令来检查和安装Docker服务： - 检查CentOS 7内核版本和存储驱动 - 卸载之前安装的Docker服务（如果有） - 安装Docker依赖包 - 安装最新版本的Docker核心服务 2. 创建一个名为Dockerfile的文件，用于定义构建镜像的指令和配置。Dockerfile是一个文本文件，可以使用编辑器创建。在Dockerfile中，可以使用一些常用的命令来定义构建过程，比如FROM、RUN、COPY等。具体的Dockerfile格式可以参考官方文档。 3. 在Dockerfile所在的目录下，执行以下命令来构建镜像： - 使用docker build命令，指定镜像名称和Dockerfile所在的目录路径。例如：`docker build -t mycentosimage .` 这将在当前目录下使用Dockerfile构建一个名为mycentosimage的镜像。 4. 构建完成后，可以使用docker images命令来查看已构建的镜像列表。例如：`docker images` 通过以上步骤，你就可以使用Dockerfile构建CentOS 7镜像了。请注意，在构建过程中要确保Dockerfile的语法正确，并按照需求进行配置和安装所需的软件包。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [CentoOS7系统下使用DockerFile构建镜像](https://blog.csdn.net/smxzsp/article/details/110537368)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

陈亦康

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值