• 【docker】dockerfile构建镜像


    一、Dockerfile概念

    Dockerfile 是一个文本文件,文件中包含了一条条的指令(instruction),用于构建镜像。每一条指定构建一层镜像,因此每一条指令的内容,就是描述该层镜像应当如何构建。

    • dockerfile是 自定义镜像 的一套规则
    • dockerfile由多条指令构成,dockerfile的每一条指令都会对应于docker镜像中的每一层。

    dockerfile的原理就是镜像分层

    • Dockerfile中的每一个指令都会创建一个新的镜像层(是一个临时的容器,执行完后将不再存在,再往后进行重新的创建与操作)
    • 镜像层将被缓存和复用(后续的镜像层将基于前面的每一层,每一层都会有下几层的缓存)
    • 当Dockerfile的指令修改了,复制的文件变化了,或构件镜像时指定的变量不同了,那么对应的镜像层缓存就会失效(因为后续的操作必然更改前面的镜像层)
    • 某一层的镜像缓存失效了之后,它之后的镜像层缓存就都会失效(第一层不成功,那么第二层也会失效)
    • 容器的修改并不会影响镜像,如果在某一层中添加一个文件,在下一层中删除它,镜像中依然会包含该文件。
      在这里插入图片描述

    二、Docker镜像的创建

    创建镜像有三种办法

    • 基于已有镜像创建
    • 基于本地模板创建
    • 基于Dockerfile创建

    1、基于已有镜像创建

    原理:将容器里面运行的程序及运行环境打包生成新的镜像

    docker commit 【选项】 【容器id】 仓库名:标签
    
    • 1

    常用选项

    选项描述
    -m说明信息
    -a作者信息
    -p生成过程中停止容器的运行

    基于已有镜像创建案例

    在这里插入图片描述

    2、基于本地模板创建

    原理:通过导入操作系统模板文件生成新的镜像

    wget http://download.openvz.org/template/precreated/debian-7.0-x86-minimal.tar.gz
    #使用wget命令导入为本地镜像
    
    docker import debian-7.0-x86-minimal.tar.gz -- debian:v1
    或
    cat debian-7.0-x86-minimal.tar.gz |docker import - debian:v1
    #生成镜像
    
    docker images
    #查看镜像
    
    docker run -itd debian:v1 bash
    #创建并启动容器
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    在这里插入图片描述

    在这里插入图片描述

    3、基于dockerfile创建

    • dockerfile是 一组指令 组成的文件
    • dockerfile每行支持一条指令,每条指定可携带多个参数,一条指令可以用&&方式,去写多条指令
    • dockerfile支持以“ # ”为开头的注释

    3.1 dockerfile结构

    • 基于镜像信息 (linux发行版:比如 centos 、ubuntu、suse、debian、alpine、redhat)
    • 维护者信息 (docker search 可查看)
    • 镜像操作指令 (tar yum make)
    • 容器启动时执行指令cmd [“/root/run/sh”]、entrypoint、都是系统启动时,第一个加载的程序/脚本/命令)

    3.2 构建镜像命令

    可以在构建镜像时指定资源限制

    在编写Dockerfile时,需要遵守严格的格式:

    • 第一行必须使用 FROM 指令指明所基于的镜像名称
    • 之后使用 MAINTAINER 指令说明维护该镜像的用户信息
    • 然后是镜像操作相关指令,如 RUN 指令。每一条指令,都会给基础镜像添加新的一层。
    • 最后使用 CMD 指令指定启动容器时,要运行的命令操作

    三 、镜像分层的原理

    #Docker 镜像结构的分层
    镜像不是一个单一的文件,而是有多层构成。容器其实是在镜像的最上面加了一层读写层,在运行容器里做的任何文件改动,都会写到这个读写层。如果删除了容器,也就删除了其最上面的读写层,文件改动也就丢失了。Docker使用存储驱动管理镜像每层内容及可读写层的容器层。

    (1)Dockerfile 中的每个指令都会创建一个新的镜像层;
    (2)镜像层将被缓存和复用;
    (3)当Dockerfile 的指令修改了,复制的文件变化了,或者构建镜像时指定的变量不同了,对应的镜像层缓存就会失效;
    (4)某一层的镜像缓存失效,它之后的镜像层缓存都会失效;
    (5)镜像层是不可变的,如果在某一层中添加一个文件,然后在下一层中删除它,则镜像中依然会包含该文件,只是这个文件在 Docker 容器中不可见了。

    1、docker镜像分层(基于AUFS构建)

    • docker镜像位于bootfs之上
    • 每一层镜像的下一层为父镜像
    • 第一层镜像称为base images(操作系统环境镜像)
    • 容器层(可读可写,为了给用户操作),在最顶层(writeable)
    • 容器层以下都是readonly

    在这里插入图片描述

    2、bootfs 内核空间

    主要包含bootloader(引导程序)和kernel(内核)。

    • bootloader主要引导加载kernel,linux刚启动时会加载bootfs文件系统,在Docker镜像的最底层是bootfs。
    • 这一层与我们典型的Linux/Unix系统时一样的,包含boot加载器和内核, 当boot加载完成之后整个内核就都在内存中了 ,此时内存的使用权由bootfs交给内核,此时系统也会卸载bootfs。
    • 在linux操作系统中,linux加载bootfs时会将rootfs设置为read-only,系统自检后会将只读改为读写,让我们可以在操作系统中进行操作。

    3、rootfs 内核空间

    • bootfs之上(base images,例如centos、ubuntu)
    • 包含的就是典型的linux系统中的/dev、/proc、/bin、/etc等标准目录和文件。
    • rootfs就是各种不同的操作系统发行版。

    4、AUFS 与overlay/overlay2

    AUFS是一种联合文件系统,它使用同一个linux host上的多个目录,逐个堆叠起来,对外呈现出一个统一的文件系统,AUFS使用该特性,实现了Docker镜像的分层。

    • 而docker 使用了overlay/overlay2存储驱动来支持分层结构。
    • overlayFS将单个linux主机上的两个目录合并成一个目录 ,这些目录被称为层,统一过程被称为联合挂载。

    4.1 overlay结构

    overlayfs在linux主机上只有两层,一个目录在下层,用来保存镜像,另一个目录在上层,用来存储容器信息。

    rootfs    #基础镜像
    lower     #下层信息(为镜像层,只读)
    upper     #上层目录(容器信息,可写)
    worker    #运行的工作目录(copy-on-write写时复制-->准备容器环境)
    mergod    #视图层(容器视图)
    
    #docker 镜像层次结构总结
    1、base images :基础镜像
    2、image :固化了一个标准运行环境,镜像本身的功能-封装一组功能性的文件,通过统一的方式,文件格式提供出来(只读)
    3、container :容器层(读写)
    4、docker-server 端
    5、呈现给docker-client(视图)
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    5、联合文件系统(UnionFS)

    UnionFS(联合文件系统) : Union文件系统(UnionFS)是一种分层、轻量级并且高性能的文件系统,它支持对文件系统的修改作为一次提交来一层层的叠加,同时可以将不同目录挂载到同一个虚拟文件系统下。AUFS、OberlayFS及Devicemapper都是一种UnionFS。

    Union文件系统是Docker镜像的基础。 镜像可以通过分层来进行继承,基于基础镜像(没有父镜像),可以制作各种具体的应用镜像。

    特性:
    一次同时加载多个文件系统,但从外面看起来,只能看到一个文件系统,联合加载会把各层文件系统叠加起来,这样最终的文件系统会包含所有底层的文件和目录。

    从仓库下载时, 我们下看到的一层层的就是联合文件系统

    6 、镜像加载原理

    • 在Docker镜像的最底层是bootfs,这一层与我们典型的Linux/Unix系统是一样的,包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中,此时内存的使用权已由bootfs转交给内核,此时系统也会卸载bootfs.

    • rootfs在bootfs之上。包含的就是典型Linux系统中的/dev,/proc,/bin,/etc等标准目录和文件。rootfs就是各种不同的操作系统发行版,比如Ubuntu,Centos等等。

    • 我们可以理解成一开始内核里什么都没有, 操作一个命令下载debian,这是就会在内核上面加一层基础镜像; 再安装一个emacs,会在基础镜像上叠加一层image;接着再安装一个apache,又会在images.上面叠加一层image。最后它们看起来就像一个文件系统即容器的rootfs。 在Docker的体系里把这些rootfs叫做Docker的镜像。 但是,此时的每一层rootfs都是read-only的,我们此时还不能对其进行操作。当我们创建一个容器,也就是将Docker镜像进行实例化,系统会在一层或是多层read-only的rootfs之上分配一层空的read-write的rootfs.

    四、dockerfile操作指令

    指令含义
    FROM指定新镜像所基于的镜像。 第一条指令必须为FROM指令,每创建一个镜像就需要一条FROM指令, 例如:centos 7
    from有两层含义: ①开启一个新的镜像,②必须写的一行指令
    MAINTAINER说明新镜像的维护人信息(可写可不写)
    RUN命令每一条RUN后面跟一条命令 ,在所基于的镜像上执行命令,并提交到新的镜像中, RUN必须大写。
    CMD [“要运行的程序”,“参数1”,“参数2”]指定启动容器时需要运行的命令或脚本, Dockerfile只能有一条CMD命令, 如果指定多条则只能执行最后一条,“/bin/bash”也是一条CMD,并且会覆盖images镜像里面的cmd
    ENTRYPOINT [“要运行的程序”,“参数1”,“参数2”]设定容器启动时第一个运行的命令及其参数。可以通过使用命令:docker run --entrypoint 来覆盖镜像中的ENTRYPOINT指令的内容
    EXPOSE [端口号]指定新镜像加载到Docker时要开启的端口 “暴露端口”,就是这个容器暴露出去的端口号。
    ENV [环境变量] [变量值]设置一个 “ 环境变量 ”的值,会被后面的RUN使用,容器可以根据自己的需求创建时传入环境变量,镜像不可以
    ADD [源文件/目录] [目标文件/目录]①将源文件复制到目标文件, 源文件要与Dockerfile位于相同目录中。 ②或者时一个URL。 ③若源文件时压缩包的则会将其解压。
    COPY [源文件/目录] [目标文件/目录]将本地主机上的文件/目录复制达到目标地点,源文件/目录要与Dockerfile在相同的目录中, copy只能用于复制,add复制的同时,还可以将对象解压, copy比add节省资源
    VOLUME [“目录”]在容器中创建一个挂载点,简单来说就是 -v,指定镜像的目录挂载到宿主机上。
    USER [用户名/UID]指定运行容器的用户
    WORKDIR [路径]为后续的RUN、CMD、ENTRYPOINT指定工作目录, 相当于一个临时的“CD ” ,否则需要使用绝对路径,例如 workdir /opt ,移动到opt目录下, 后续执行的指令都是在/opt下面操作
    ONBUILD [命令]指定所生成的镜像作为一个基础镜像时所要运行的命令 “(是一种优化)”
    HEALTHCHECK健康检查

    1、CMD和ENTRYPOINT介绍

    要想了解cmd和entrypoint的区别,首先必须了解到exec模式和shell模式的区别

    1.1 exec和shell模式的区别

    exec模式: 容器加载时使用的启动的第一个任务进程

    shell模式: 容器加载时第一个bash环境(/bin/bash、/bin/sh、/bin/init)

    1.1.1 exec模式下传入命令

    构建的镜像时传入CMD,启动容器时不传入CMD

    cd /opt
    mkdir test
    #创建Dockerfile的工作目录
    
    vim Dockerfile
    FROM centos:7
    CMD ["top"]
    #编写Dockerfile文件
    
    docker build -t centos:7 .
    #基于dockerfile构建镜像
    
    docker run -it --name test centos:7
    #基于构建好的镜像启动容器
    
    docker logs test
    #查看执行的命令
    
    docker exec test ps sux 
    #传入ps aux 命令执行,查看结果
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    启动时传入/bin/bash命令

    docker run -itd --name test01 test centos:7 /bin/bash
    #基于构建好的镜像启动容器,并且加上/bin/bash命令
    
    docker exec test01 ps aux
    #通过exec 传入命令查看执行效果
    
    • 1
    • 2
    • 3
    • 4
    • 5

    在这里插入图片描述

    1.1.2 使用exec模式无法输出环境变量
    cd /opt/test
    vim Dockerfile
    FROM centos:7
    CMD ["echo","$HOME"]
    #编写新的dockerfile文件
    
    echo $HOME
    #有shell环境下输出的变量值
    
    docker build -t centos:ydq .
    #构建dockerfile镜像
    
    docker images
    #查看镜像
    
    docker run -itd --name ydq centos:ydq 
    #基于构建好镜像的启动容器
    
    docker ps 
    #查看运行的容器
    
    docker logs ydq
    #查看执行结果
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    在这里插入图片描述
    在这里插入图片描述

    1.1.3 shell模式
    vim Dockerfile
    FROM centos:7
    CMD ["sh","-c","echo $HOME"]
    #编写一个dockerfile文件
    
    docker build -t centos:ydq2
    #基于文件编写centos:ydq2的镜像
    
    docker images
    #查看镜像
    
    docker run -itd --name ydq3 centos:ydq2
    #启动容器
    
    docker logs ydq3
    #查看输出日志
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    在这里插入图片描述
    在这里插入图片描述

    1.2 小结

    CMD和ENTRYPOINT的区别
    简单回答

    • 相同点: 都是容器环境启动时需要加载的命令
    • 不同点: CMD不能传参,ENTRYPOINT可以传参

    详细回答

    不同点

    • 如果ENTRYPOINT是使用shell模式,CMD指令会被忽略
    • **如果ENTRYPOINT是使用exec模式,**CMD也会是exec模式,CMD指令的内容作为参数追加到ENTRYPOINT

    五、案例实验

    1、构建apache服务

    mkdir /opt/apache
    cd /opt/apache
    
    vim Dockerfile
    
    FROM centos:7
    #基于的基础镜像
    
    MAINTAINER this is apacher iamge <ydq>
    #维护镜像的用户信息
    
    RUN yum -y update
    #在基于镜像(centos:7)上执行更新yum仓库
    
    RUN yum -y install httpd 
    #镜像操作指令安装apache软件
    
    EXPOSE 80
    #开启80端口
    
    ADD index.html /var/www/html/index.html
    #FUZHI Dockerfile所在目录下的index.html文件到容器中的/var/www/html目录下
    
    
    //方法一:需要些脚本
    ADD run.sh /run.sh
    #复制Dockerfile文件所在目录下的run.sh文件到容器中的根目录下
    RUN chmod +x /run.sh
    #在基于镜像上为根目录下的run.sh文件到容器中的根目录
    CMD ["/run.sh"]
    #启动容器时运行容器根目录下的run.sh文件
    
    //方法二:
    ENTRYPOINT ["/usr/sbin/apachectl"]
    CMD ["-D","FOREGROUND"]
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    在这里插入图片描述

    echo "this is ydq" > index.html
    #指定页面内容
    
    vim run.sh
    #!/bin/bash
    rm -rf /run/httpd/*   #删除原有的apache缓存
    exec /usr/sbin/apachectl -D FOREGROUND   #开启apache服务,并开启守护进程
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    在这里插入图片描述

    docker build -t httpd:centos7 .
    #在Dockerfile所在目录下构建新镜像 httpd:centos7
    
    docker images
    #查看镜像
    
    docker run -d -p 1234:80 httpd:centos7
    #后台运行容器,并暴露端口1234
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    在这里插入图片描述

    真机访问20.0.0.55:1234
    
    • 1

    在这里插入图片描述

    2、构建ssh镜像

    mkdir /sshd
    cd /sshd
    vim Dockerfile
    #编写dockerfile文件内容
    
    FROM centos:7
    #指定基础镜像
    
    MAINTAINER ydq
    #指定维护者信息
    
    RUN yum -y update
    RUN yum -y install openssh* net-tools lsof telnet passwd
    #下载所需软件
    
    RUN echo "123" |passwd --stdin root
    #修改root密码
    
    RUN sed -i 's/UsePAM yes/UsePAM no/g' /etc/ssh/sshd_config
    #关闭pam认证模块
    
    RUN ssh-keygen -t rsa -f /etc/ssh/ssh_host_rsa_key
    #创建秘钥对方式,-t 指定秘钥方式,-f 指定验证文件
    
    RUN sed -ir '/^session\s+required\s+pam_loginuid.so/ s/^/#/' /etc/pam.d/sshd
    #响应修改PAM认证模块
    
    RUN mkdir -p /root/.ssh && chown root.root /root && chmod 700 /root/.ssh
    #修改root目录的文件
    
    EXPOSE 22
    #开放22端口
    
    CMD ["/usr/sbin/sshd","-D"]
    #容器加载时启动shhd,并开启守护进程
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    在这里插入图片描述

    docker build -t sshd:new .
    
    docker images
    
    docker run -d -P sshd:new 
    
    docker ps -a
    
    ssh docker -p 【端口】 或ssh 20.0.0.55:【端口】 或 127.0.0.1:【端口】
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    存在的问题

    在这里插入图片描述

    3、升级ssh镜像,构建systemctl镜像

    根据上面登录到sshd中,无法使用systemctl命令,所以此次将在上次创建好的镜像中作为基础镜像,再次构建新的镜像。

    mkdir /systemctl 
    cd /systemctl
    vim Dockerfile
    #新建目录,再创建Dockerfile文件
    
    FROM sshd:new
    #以上次sshd:new镜像为基础镜像
    
    MAINTAINER ydq2
    #设置维护人信息
    
    ENV container docker
    #设置变量,container值为docker
    
    RUN (cd /lib/systemd/system/sysinit.target.wants/;for i in *;do [ $i == \systemd-temfiles-setup.service ] || rm -f $i;done ); \
    rm -f /lib/systemd/system/multi-user.target.wants/*; \
    rm -f /etc/systemd/system/*.wants/*; \
    rm -f /lib/systemd/system/local-fs.target.wants/*; \
    rm -f /lib/systemd/system/sockets.target.wants/*udev*; \
    rm -f /lib/systemd/system/sockets.target.wants/initctl*; \
    rm -f /lib/systemd/system/basic.target.wants/*; \
    rm -f /lib/systemd/system/anaconda.target.wants/*;
    #基础镜像上执行切换到/lib/systemd/system/sysinit.target.wants目录下,for循环遍历该目录下所有文件,如果文件名称不是systemd-tmpfiles-setup.service,则删除
    
    VOLUME [ "/sys/fs/cgroup" ]
    #创建一个数据卷,用于挂载宿主机的目录
    
    CMD ["/usr/sbin/init"]
    #启动容器时进行系统初始化
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    在这里插入图片描述

    docker build -t systemctl:sshd . 
    docker images
    
    docker run --privileged -it -v /sys/fs/cgroup:/sys/fs/cgroup:ro systemctl:sshd /sbin/init
    #--privileged : 使containner内的root拥有真正的root权限,不进行降权处理,否则containner内的用户只是外部的一个普通用户
    #-v :将宿主机和容器内的/sys/fs/cgroup共享
    #ro :表示这个目录在宿主机为只读,不能修改 
    
    -----以下再开个终端操作------------
    docker ps 
    
    docker exec -it 【容器ID/bin/bash
    systemctl status sshd
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    六、总结面试题

    1、为什么docker的centos镜像只有200M多?

    • 因为docker镜像只有rootfs和其它镜像层,共用宿主机的linux内核(bootfs),所以很小。
    • **bootfs + rootfs :**作用是 加载、引导内核程序 + 挂载使用linux操作系统 等等一些关键的目录文件
    • 就是说bootfs用内核的,rootfs用自己的。
    • 对于一个精简的os,rootfs可以很小,只需要包括最基本的命令,工具和程序库就可以了,因为底层直接用host的kernel,自己只需要提供rootfs就行了,所以对于不同的linux发行版,bootfs基本是一致的,rootfs会有差别,所以不同的发行版可以共用bootfs。

    总的来说:就是dcoker的centos镜像中,内核是使用host主机的,系统才是自己的。

    2、 LXC和容器是什么有关系?

    • LXC是内核中容器技术/驱动,功能是候将资源容器化, 完成资源容器虚拟化的过程。
    • 是早期docker的依赖组件,目前docker拥有自己的libcontainer库,可以实现容器虚拟的功能,对LXC依赖性大大降低。

    3、dockerfile镜像分层的原理

    用overlay2存储引擎的方式叠加上去,最上面的容器层是可读可写的,其它镜像是可读的,他们是共用的内核资源,共用的操作系统里所必须的引导程序,挂载,系统之间的文件,这些文件它和内核之间共享,所有它比实际的centos要小。

    4、容器之间的相互通信的方式

    docker 0 、 数据卷容器 、 --link 隧道 、 container 模式(直连接口,同一个network namespaces里,通过同一个网卡的方式,在同一个名称空间里 共有一个IP,通过localhost交互/自己的ip或端口交互)

    5、你用过哪些dockerfile命令?

    FROM: 指定系统

    MAINTAINER :指定维护人信息

    RUN :运行命令

    ENV :指定环境变量

    ADD :复制文件

    EXPOSE :指定端口

    CMD :执行命令

    USER : 运行容器的用户

    6、你用dockerfile怎么创建一个镜像出来?

    Dockerfile例主要包含信息有

    ①基础镜像

    ②镜像源信息

    ③镜像操作指令

    ④容器启动时执行的命令

    大概步骤

    先把所需要的安装包放在指定目录。

    然后在该目录下创建一个Dockerfile文件,进行添加指令,首先是FROM 指定基础镜像。然后MAINTAINER设置维护人信息,然后使用RUN执行相关命令。EXPOSE 指定端口,最后执行CMD命令运行服务或脚本,如果运行脚本,需要在指定路径写上脚本,

    最后执行docker build -t 进行构建镜像。

    7、ADD和copy的区别?

    Dockerfile中的copy指令和add指令都可以将主机上的资源复制或加入到容器镜像中,都是在构建镜像的过程中完成。

    • copy只能用于复制(节省资源)
    • ADD复制的同时,如果复制的对象是压缩包,ADD还可以解压(比较消耗资源)
    • COPY指令和ADD指令的唯一区别 在于是否支持远程URL获取资源,COPY指令只能从执行docker build所在的主机上读取资源并复制到镜像中,而ADD指令还支持通过URL从远程服务器赌球资源并复制到镜像中。
    • 满足同等功能的情况下,推荐使用COPY指令,ADD指定更擅长读取本地tar文件并解压缩。

    总结:①copy更节省资源,②ADD可以将压缩文件解压后复制,③COPY只支持本机复制到镜像,ADD支持URL复制到镜像。④ADD会自动创建目标目录

    8、CMD和ENTRYPOINT区别

    1、相同点

    都是容器启动时加载的命令,启动模式如下:

    • exec:容器加载时使用的启动的第一个任务进程

    • shell:容器加载时,使用的第一个bash(/bin/bash 、/bin/sh、/bin/init)

    2、不同点

    cmd是容器环境启动时默认加载的命令

    entrypoint是容器环境启动时第一个加载的命令程序/脚本程序init。

    • 如果entrypoint使用了shell模式,CMD指令会被忽略

    • 如果entrypoint使用了exec模式。CMD指定的内容被追加为entrypoint指定命令的参数

    • 如果entrypoint使用了exec模式,CMD也应该使用exec模式

    9、如果存在多个CMD或多个ENTRYPOINT,有哪些是生效的?

    • 如果存在多个CMD,只会有最后一个生效

    • 如果存在多个ENTRYPOINT,只会是第一个生效

  • 相关阅读:
    【GD32F427开发板试用】IAR 环境移植freertos
    C++精简实现2048游戏逻辑
    蓝城兄弟完成私有化交割:从纳斯达克退市 作价6000万美元
    CSS基础语法
    自动激光分板系统(自动PCB激光分板系统)市场现状分析
    定制qga(作业截图)
    记录vue配置跨域不起作用以及一些理解
    基于改进量子粒子群算法的电力系统经济调度(Matlab代码实现)
    杰理之SPP 连接和断开事件处理【篇】
    算法第六节
  • 原文地址:https://blog.csdn.net/m0_57515995/article/details/126894691