Docker镜像
|
Docker基础
|
16
|
0

5343 字
|
1 小时
本文最后更新于112 天前，其中的信息可能已经过时，如有错误请发送邮件到big_fw@foxmail.com

镜像

镜像管理

  • 容器创建时需要指定镜像，每个镜像都由唯一的标示 Image ID ，和容器的 Container ID 一样，默认 128 位，可以使用前 16 为缩略形式，也可以使用镜像名与版本号两部分组合唯一标示，如果省略版本号，默认使用最新版本标签 ( latest,latest并不一定是最新版本,是由开发者自定义某个版本为latest版本,默认拉取的就是这个版本 )

  • 镜像的分层：Docker 的镜像通过联合文件系统 ( union filesystem ) 将各层文件系统叠加在一起
    生产环境中大量的文件被重复使用，所以分层是十分好用的

引导过程中需要的两种文件系统

  • bootfs：用于系统引导的文件系统，包括 bootloader 和 kernel，容器启动完成后会被卸载以节省内存资源

  • roofs：位于 bootfs 之上，表现为 Docker 容器的根文件系统

传统模式中，系统启动时，内核挂载 rootfs 时会首先将其挂载为“只读”模式，完整性自检完成后将其挂载为读写模式

在生产环境中，有可能遇到命令输出结果花屏，那是文件系统损坏，不用担心，无论是ext4还是xfs都是日志文件系统，包括NTFS，会将当前的修改文件操作记录到文件系统的日志，所以才可以修复，fat16.32不行

Docker 中，rootfs 由内核挂载为“只读”模式，而后通过 UFS 技术挂载一个“可写” 层

可写层

假如每层都有/aaa文件，上层优先级大于下级，如果要是把aaa删了，就没有，不光可写层没了，下层也都没了,所以Docker是分层的,下层是只读层,不可写.

  • 在Docker中，镜像是由多个只读层叠加而成的。每一层都包含了一些文件系统的更改，这些更改是在构建镜像的过程中产生的。当你在一个容器中运行一个镜像时，Docker会在这些只读层之上添加一个可写的容器层，所有的更改都会在这个容器层中进行。

  • 如果你在容器层中删除了一个文件，比如 /aaa，那么这个文件在容器中的可写层确实会被删除。但是，这并不意味着底层镜像层中的相同路径下的文件也被删除了。底层镜像层仍然是只读的，它们的文件不会因为容器层的操作而改变。

  • 所以，即使你在容器层中删除了 /aaa，底层镜像层中的 /aaa 文件依然存在。当你停止并删除容器后，再次从这个镜像启动一个新的容器时，你会发现 /aaa 文件又回来了，因为它存在于镜像的只读层中。

  • 然而，Docker使用了联合文件系统（UnionFS）技术，这是一种可以在多个目录树（即多个文件系统）上叠加内容的文件系统。在Docker中，这意味着当你在容器层中删除文件时，虽然底层镜像层中的文件实际上并没有被删除，但它们对容器的文件系统来说是不可见的。这种机制称为“写时复制”（Copy-on-Write），它通过隐藏底层的文件来模拟实际的删除效果。

总结一下：

  • 在容器层中删除文件只会影响容器层本身，不会影响底层的镜像层。
  • 底层镜像层中的文件在物理上并没有被删除，但它们在容器文件系统中变得不可见。
  • 当从同一镜像启动新容器时，之前删除的文件会再次出现，因为它们仍然存在于镜像的只读层中。

这种机制有助于节省存储空间，因为不需要为每个容器复制整个镜像，同时也保证了镜像的一致性和可重复性。

镜像制作过程：

最基础的镜像就是在最干净的环境上搭建一个我们需要的的服务，然后把根 / 打包。
但是缺点很了然，太大了，有太多的目录是开启自动生成的，比如proc目录，还有一些var下的log等等
而且基础镜像越大，在这个基础上创建的镜像更大
基础镜像是官方基础的镜像，尽可能简洁，啥也没有，只有增加，如果还能减少，那他就不够基础

目前有两种制作方法

  • 通过 tar 打包构建基础镜像
  • 通过 mkimage-yum.sh 脚本构建基础镜像
    两种方法比较，tar更原始，简单粗暴，脚本更干净

通过 tar 打包构建基础镜像

  • 卸载不必要的软件包
CentOS 6.9系统（虚拟机-1）：
    yum remove -y iwl* ql* xorg* ipw* *firmware* --exclude=kernel-firmware

    (iwl 开头的文件通常是与 Intel Wireless 网卡相关的固件文件。
    这些文件包含了网卡的硬件驱动程序和必要的配置信息，用于确保无线网卡能够正常工作。
    在 Linux 系统中，这些固件文件通常位于 /lib/firmware 目录下，并且在系统启动或网络管理器尝试连接到无线网络时被加载2。
    这条命令用来从系统中移除所有以 iwl 开头的软件包和所有 firmware 相关的软件包，同时排除 kernel-firmware 包，以防止其被意外移除)

CentOS 7.4.1708系统（虚拟机-2）：
    yum remove -y iwl* *firmware* --exclude=kernel-firmware
  • 清除 yum 缓存
- CentOS 6.9系统（虚拟机-1）：
    yum clean all
- CentOS 7.4.1708系统（虚拟机-2）：
    yum clean all
    rm -rf /var/cache/yum
  • 打包文件系统
- CentOS 6.9系统（虚拟机-1）：
    tar --numeric-owner --exclude=/proc --exclude=/sys --exclude=/mnt --exclude=/var/cache --exclude=/usr/share/{foomatic,backgrounds,perl5,fonts,cups,qt4,groff,kde4,icons,pixmaps,emacs,gnome-background-properties,sounds,gnome,games,desktop-directories} --exclude=/var/log -zcvf   /mnt/CentOS-6.9-BaseImage.tar.gz     /

- CentOS 7.4.1708系统（虚拟机-2）：
    tar --numeric-owner --exclude=/proc --exclude=/sys --exclude=/mnt --exclude=/var/cache --exclude=/usr/share/{foomatic,backgrounds,perl5,fonts,cups,qt4,groff,kde4,icons,pixmaps,emacs,gnome-background-properties,sounds,gnome,games,desktop-directories} --exclude=/var/log -zcvf   /mnt/CentOS-7.4-BaseImage.tar.gz     /
  • 安装和启动 Docker
# 安装EPEL源和REMI源
rpm -Uvh https://dl.fedoraproject.org/pub/epel/7/x86_64/e/epel-release-7-10.noarch.rpm
rpm -Uvh https://rpms.remirepo.net/enterprise/remi-release-7.rpm
​
# 安装Docker软件包
yum install -y docker-io
​
# 启动Docker服务
systemctl start docker.service
  • 导入镜像仓库
cat /mnt/CentOS-7.4-BaseImage.tar.gz | docker import - centos-tar:7.4.1708

docker import 命令用于将本地文件系统上的文件或目录导入为 Docker 镜像:
    docker import [OPTIONS] file/URL  [REPOSITORY[:TAG]]
  • 验证

通过 mkimage-yum.sh 脚本构建基础镜像

  • 安装第三方源
- CentOS 6.9系统（虚拟机-1）：

rpm -Uvh https://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm
rpm -Uvh https://rpms.remirepo.net/enterprise/remi-release-6.rpm

- CentOS 7.4.1708系统（虚拟机-2）：

rpm -Uvh https://dl.fedoraproject.org/pub/epel/7/x86_64/Packages/e/epel-release-7-13.noarch.rpm
rpm -Uvh
  • 安装和启动 Docker
yum install -y docker-io
systemctl start docker.service
  • 创建脚本文件
#mkimage-yum.sh脚本，这个文件就是 Docker 官方的创建镜像的脚本文件，URL 为:
https://github.com/moby/moby/blob/master/contrib/mkimage-yum.sh

脚本内容:
#!/usr/bin/env bash
#
# Create a base CentOS Docker image.
#
# This script is useful on systems with yum installed (e.g., building
# a CentOS image on CentOS).  See contrib/mkimage-rinse.sh for a way
# to build CentOS images on other systems.
​
set -e
​
usage() {
    cat << EOOPTS
$(basename $0) [OPTIONS] <name>
OPTIONS:
  -p "<packages>"  The list of packages to install in the container.
                   The default is blank. Can use multiple times.
  -g "<groups>"    The groups of packages to install in the container.
                   The default is "Core". Can use multiple times.
  -y <yumconf>     The path to the yum config to install packages from. The
                   default is /etc/yum.conf for Centos/RHEL and /etc/dnf/dnf.conf for Fedora
  -t <tag>         Specify Tag information.
                   default is reffered at /etc/{redhat,system}-release
EOOPTS
    exit 1
}
​
# option defaults
yum_config=/etc/yum.conf
if [ -f /etc/dnf/dnf.conf ] && command -v dnf &> /dev/null; then
    yum_config=/etc/dnf/dnf.conf
    alias yum=dnf
fi
# for names with spaces, use double quotes (") as install_groups=('Core' '"Compute Node"')
install_groups=()
install_packages=()
version=
while getopts ":y:p:g:t:h" opt; do
    case $opt in
        y)
            yum_config=$OPTARG
            ;;
        h)
            usage
            ;;
        p)
            install_packages+=("$OPTARG")
            ;;
        g)
            install_groups+=("$OPTARG")
            ;;
        t)
            version="$OPTARG"
            ;;
        \?)
            echo "Invalid option: -$OPTARG"
            usage
            ;;
    esac
done
shift $((OPTIND - 1))
name=$1
​
if [[ -z $name ]]; then
    usage
fi
​
# default to Core group if not specified otherwise
if [ ${#install_groups[*]} -eq 0 ]; then
    install_groups=('Core')
fi
​
target=$(mktemp -d --tmpdir $(basename $0).XXXXXX)
​
set -x
​
mkdir -m 755 "$target"/dev
mknod -m 600 "$target"/dev/console c 5 1
mknod -m 600 "$target"/dev/initctl p
mknod -m 666 "$target"/dev/full c 1 7
mknod -m 666 "$target"/dev/null c 1 3
mknod -m 666 "$target"/dev/ptmx c 5 2
mknod -m 666 "$target"/dev/random c 1 8
mknod -m 666 "$target"/dev/tty c 5 0
mknod -m 666 "$target"/dev/tty0 c 4 0
mknod -m 666 "$target"/dev/urandom c 1 9
mknod -m 666 "$target"/dev/zero c 1 5
​
# amazon linux yum will fail without vars set
if [ -d /etc/yum/vars ]; then
    mkdir -p -m 755 "$target"/etc/yum
    cp -a /etc/yum/vars "$target"/etc/yum/
fi
​
if [[ -n "$install_groups" ]]; then
    yum -c "$yum_config" --installroot="$target" --releasever=/ --setopt=tsflags=nodocs \
        --setopt=group_package_types=mandatory -y groupinstall "${install_groups[@]}"
fi
​
if [[ -n "$install_packages" ]]; then
    yum -c "$yum_config" --installroot="$target" --releasever=/ --setopt=tsflags=nodocs \
        --setopt=group_package_types=mandatory -y install "${install_packages[@]}"
fi
​
yum -c "$yum_config" --installroot="$target" -y clean all
​
cat > "$target"/etc/sysconfig/network << EOF
NETWORKING=yes
HOSTNAME=localhost.localdomain
EOF
​
# effectively: febootstrap-minimize --keep-zoneinfo --keep-rpmdb --keep-services "$target".
#  locales
rm -rf "$target"/usr/{{lib,share}/locale,{lib,lib64}/gconv,bin/localedef,sbin/build-locale-archive}
#  docs and man pages
rm -rf "$target"/usr/share/{man,doc,info,gnome/help}
#  cracklib
rm -rf "$target"/usr/share/cracklib
#  i18n
rm -rf "$target"/usr/share/i18n
#  yum cache
rm -rf "$target"/var/cache/yum
mkdir -p --mode=0755 "$target"/var/cache/yum
#  sln
rm -rf "$target"/sbin/sln
#  ldconfig
rm -rf "$target"/etc/ld.so.cache "$target"/var/cache/ldconfig
mkdir -p --mode=0755 "$target"/var/cache/ldconfig
​
if [ -z "$version" ]; then
    for file in "$target"/etc/{redhat,system}-release; do
        if [ -r "$file" ]; then
            version="$(sed 's/^[^0-9\]*\([0-9.]\+\).*$/\1/' "$file")"
            break
        fi
    done
fi
​
if [ -z "$version" ]; then
    echo >&2 "warning: cannot autodetect OS version, using '$name' as tag"
    version=$name
fi
​
tar --numeric-owner -c -C "$target" . | docker import - $name:$version
​
docker run -i -t --rm $name:$version /bin/bash -c 'echo success'
​
rm -rf "$target"
  • 导入镜像
chmod 755 mkimage-yum.sh
./mkimage-yum.sh centos-mkimage

两种方法比较

由上述可知，通过 tar 打包创建的基础镜像的体积大约是通过mkimage-yum.sh脚本创建的基础镜像的3倍左右。这是由于前者是基于最小化安装的 CentOS 系统而创建的，而后者是从 CentOS 官方源安装必要的软件包而创建的，前者比后者多安装了很多软件包，包括邮件工具、设备驱动程序，等等。这两种方法各有特点：

  • 通过 tar 打包创建：基础镜像体积较大，但可以按照需求自由定制，适用于各种版本的CentOS系统，灵活度较高
  • 通过 mkimage-yum.sh 脚本创建：基础镜像体积较小，但只能安装官方源支持的软件包，并且只适用于最新版本的 CentOS 系统

镜像的构成

准备文件

先找一个边角简单的镜像下载解压，准备好单独的目录，因为如果直接是centos的解压出来删不掉，bin，etc之类的会变成红黑色

docker pull zxs/nginx:v1
docker images
docker save -o nginx.tar zxs/nginx:v1
mkdir nginx
mv nginx.tar nginx
cd nginx/
ls
tar -xvf nginx.tar

镜像内容详解

file

一层一层看看

[root@localhost] ls 1e7a6af88d20204edbc8ffc4a474e6b17ffb95e4a4895d3129ef32cf3ab1ed28
json  layer.tar  VERSION

json

相关的元数据

[root@kube-master01 1e7a6af88d20204edbc8ffc4a474e6b17ffb95e4a4895d3129ef32cf3ab1ed28]# cat json |jq
{
  "id": "1e7a6af88d20204edbc8ffc4a474e6b17ffb95e4a4895d3129ef32cf3ab1ed28",
  "parent": "1990f205e35e95d03e96de11d73fa30916c9368841821afad456d484b586a99b",
  "created": "1970-01-01T08:00:00+08:00",
  "container_config": {
    "Hostname": "",
    "Domainname": "",
    "User": "",
    "AttachStdin": false,
    "AttachStdout": false,
    "AttachStderr": false,
    "Tty": false,
    "OpenStdin": false,
    "StdinOnce": false,
    "Env": null,
    "Cmd": null,
    "Image": "",
    "Volumes": null,
    "WorkingDir": "",
    "Entrypoint": null,
    "OnBuild": null,
    "Labels": null
  },
  "os": "linux"
}

version

[root@kube-master01 1e7a6af88d20204edbc8ffc4a474e6b17ffb95e4a4895d3129ef32cf3ab1ed28]# cat VERSION
1.0
  • 规范版本，因为docker是从1-1.5的，所以有很多服务和他的功能差不多，于是云原生容器基金会 CNCF制定了一些规范，所有的镜像必须按照规范来制作，不然一家公司一个规范，整个行业就乱套了。当然，为了感谢docker，docker的所有镜像都可以在其他服务中使用，也就是其他服务也最起码要符合docker的规范

layers

可以看到当前的layer解压出来的是nginx的网页缺省文件

[root@kube-master01 1e7a6af88d20204edbc8ffc4a474e6b17ffb95e4a4895d3129ef32cf3ab1ed28]# tar -xvf layer.tar
usr/
usr/local/usr/local/nginx/
usr/local/nginx/html/
usr/local/nginx/html/index.html

这里解压出来的是基础镜像，也就是根目录

file

这一层是nginx的源码包
file

这一层是nginx的编译安装，在编译的过程中对这些目录进行了改变
file

  • 所以层级是：基础镜像——源码包——编译安装——首页文件

这个是镜像ID的json文件，保存元数据，而且这是 所有层 的json的合并结果！是增量结果

file

manifest

是仓库的清单文件，!而且这里有组成镜像的顺序!

[rootalocalhost nginx]# cat manifest.jsonjdrootalocalhost
[
  {
    "Config":"465f4d61dd93783960186f9451d0b0cbccb645e33527dcab224605375433bd6f.ison",
    "RepoTags":[
        "zxs/nginx:v1"
    ].
    "Layers":[
        "34dfcb87035d49398a076e833d1ceb9fb216cd6647e391384528f4e124bb07f4/layer.tar".
        "3e03ad7c2743ca78f1ac11170463012b175a32bc6c00446716d93667b3b51d64/layer.tar",
        "a5aa60be4fd0837ef1d3c33a9fa3e56b998471ef869f7aaefed7f25afab19722/layer.tar",
        "1e7a6af88d20204edbc8ffc4a474e6b17ffb95e4a4895d3129ef32cf3ab1ed28/layer.tar'
        ]
    }
]
[rootalocalhost nginx]#

repositories

写了一点描述加上MD5

[rootalocalhost nginx]# cat repositories
{"zxs/nginx:v1": {"new1":"1e7a6af88d20204edbc8ffc4a474e6b17ffb95e4a4895d3129ef32cf3ab1ed28"}}

Dockerfile

Dockerfile相当于写一个剧本，之后所有的会按照你的剧本唱戏，一点一点搭起服务

目前镜像的制作有两种方式

  • 容器——保存为——镜像(前提是必须能启动起来)
  • dockerfile——build——镜像

dockerfile底层原理

  • 是把当前dockerfile所在的目录整个打包发给docker服务器(server端)，因为可以跨主机，所以必须是整个目录，不然服务器不知道去哪个目录找（不知道你的dockerfile在哪个文件）

  • 所以打包的目录文件会很大，最好的办法就是创建一个单独的目录放dockerfile

  • 在可写层执行一条指令，然后封装，在读取，再封装，也就是说最多只有128层，换句话说，dockerfile文件最多只有128行

  • dockerfile执行的时候原理是每一行都会去创建一个容器，在那个容器中进行文件的设置，并且在完成后自动删除，可以在标签中验证

    file

dockerfile语法

编辑好dockerfile文件后，用

docker build -t 指定镜像名 . (可选--no-cache)

[TOC]

FROM（指定基础 image）

构建指令，必须指定且需要在 Dockerfile 其他指令的前面。后续的指令都依赖于该指令指定的 image。FROM 指令指定的基础 image 可以是官方远程仓库中的，也可以位于本地仓库

FROM centos:7.2
FROM centos

MAINTAINER（用来指定镜像创建者信息）

构建指令，用于将 image 的制作者相关的信息写入到 image 中。当我们对该 image 执行 docker inspect 命令时，输出中有相应的字段记录该信息。

MAINTAINER  wangyang "wangyang@itxdl.cn"

​

LABEL（将元数据添加到镜像）

标签的定义
# 指令将元数据添加到镜像。`LABEL` 是键值对。要在 `LABEL` 值中包含空格，请像在命令行中一样使用引号和反斜杠
LABEL "com.example.vendor"="ACME Incorporated"
LABEL com.example.label-with-value="foo"
LABEL version="1.0"
LABEL description="This text illustrates \
that label-values can span multiple lines."

# 多行标签定义方式
LABEL multi.label1="value1" multi.label2="value2" other="value3"
LABEL multi.label1="value1" \
      multi.label2="value2" \
      other="value3"
标签的继承

基础或父镜像（FROM 行中的镜像）中包含的标签由您的镜像继承。如果标签已经存在但具有不同的值，则最近应用的值将覆盖任何先前设置的值

查看镜像标签
$ docker image inspect --format='' myimage
案例
# dockerfile
FROM busybox
LABEL author=wangyanglinux
CMD echo wangyanglinux

# 构建镜像
[root@k8s-master01 testd]# docker build -t wangyanglinux:0.0.1 . --no-cache

# 安装 jq
[root@k8s-master01 testd]# yum install epel-release
[root@k8s-master01 testd]# yum install jq

# 查看标签
[root@k8s-master01 testd]# docker image inspect wangyanglinux:0.0.1 --format "{{json .ContainerConfig.Labels}}" | jq
{
  "author": "wangyanglinux"
}

RUN（安装软件用）

构建指令，RUN 可以运行任何被基础 image 支持的命令。如基础 image 选择了 Centos，那么软件管理部分只能使用 Centos 的包管理命令

RUN cd /tmp && curl -L 'http://archive.apache.org/dist/tomcat/tomcat-7/v7.0.8/bin/apache-tomcat-7.0.8.tar.gz' | tar -xz 
RUN ["/bin/bash", "-c", "echo hello"]

由于每行指令都是新建一个容器执行，所以不能

file

可以写在一行，中间用&& 或者 ; ，这样还可以节省行数
但是如果需要安装的版本不一样，那就不如分开写

#比如:
RUN 编译安装nginx
RUN 编译安装php
RUN 编译安装mysql5.6
  • 所以我们习惯把一个软件的命令写在一行
    而且基础只要有一点点不一样，后续的都相同。那么都不能重用，那就需要把常用的一些指令放在前面，一直到不一样的地方再改

USER（设置container容器的用户）

设置指令，设置启动容器的用户，默认是 root 用户

USER daemon  =  ENTRYPOINT ["memcached", "-u", "daemon"]

EXPOSE（指定容器需要映射到宿主机器的端口）

设置指令，该指令会将容器中的端口映射成宿主机器中的某个端口。当你需要访问容器的时候，可以不是用容器的 IP 地址而是使用宿主机器的 IP 地址和映射后的端口。要完成整个操作需要两个步骤，首先在 Dockerfile 使用 EXPOSE 设置需要映射的容器端口，然后在运行容器的时候指定 -P 选项加上 EXPOSE 设置的端口，这样 EXPOSE 设置的端口号会被随机映射成宿主机器中的一个端口号。也可以指定需要映射到宿主机器的那个端口，这时要确保宿主机器上的端口号没有被使用。EXPOSE指令可以一次设置多个端口号，相应的运行容器的时候，可以配套的多次使用 -p 选项

# 映射多个端口  
EXPOSE port1 port2 port3  

# 随机暴露需要运行的端口
docker run -P image

# 相应的运行容器使用的命令  
docker run -p port1 -p port2 -p port3 image  

# 还可以指定需要映射到宿主机器上的某个端口号  
docker run -p host_port1:port1 -p host_port2:port2 -p host_port3:port3 image

ENV（用于设置环境变量）

构建指令，在 image 中设置一个环境变量。设置了后，后续的 RUN 命令都可以使用，container 启动后，可以通过 docker inspect 查看这个环境变量，也可以通过在 docker run --env key=value 时设置或修改环境变量。假如你安装了 JAVA 程序，需要设置 JAVA_HOME，那么可以在 Dockerfile 中这样写：

ENV JAVA_HOME /path/to/java/dirent

ARG（设置变量）

起作用的时机
  • arg 是在 build 的时候存在的, 可以在 Dockerfile 中当做变量来使用
  • env 是容器构建好之后的环境变量, 不能在 Dockerfile 中当参数使用
案例
# Dockerfile
FROM redis:3.2-alpine

LABEL maintainer="wangyanglinux@163.com"

ARG REDIS_SET_PASSWORD=developer
ENV REDIS_PASSWORD ${REDIS_SET_PASSWORD}

VOLUME /data

EXPOSE 6379

CMD ["sh", "-c", "exec redis-server --requirepass \"$REDIS_PASSWORD\""]
FROM nginx:1.13.1-alpine

LABEL maintainer="wangyanglinux@163.com"

RUN mkdir -p /etc/nginx/cert \
    && mkdir -p /etc/nginx/conf.d \
    && mkdir -p /etc/nginx/sites

COPY ./nginx.conf /etc/ngixn/nginx.conf
COPY ./conf.d/ /etc/nginx/conf.d/
COPY ./cert/ /etc/nginx/cert/

COPY ./sites /etc/nginx/sites/

ARG PHP_UPSTREAM_CONTAINER=php-fpm
ARG PHP_UPSTREAM_PORT=9000
RUN echo "upstream php-upstream { server ${PHP_UPSTREAM_CONTAINER}:${PHP_UPSTREAM_PORT}; }" > /etc/nginx/conf.d/upstream.conf

VOLUME ["/var/log/nginx", "/var/www"]

WORKDIR /usr/share/nginx/html

ADD（从 src 复制文件到 container 的 dest 路径）

ADD <src> <dest>  
        <src> 是相对被构建的源目录的相对路径，可以是文件或目录的路径，也可以是一个远程的文件 url;
        <dest> 是 container 中的绝对路径
  • src:原路径，也就是当前dockerfile所在的相对路径，而且可以写url，下载地址，并且只要是压缩包就会自动解压，解压好坏看情况，如果把一堆目录压缩之后，ADD会解压，反而不好
  • dest：就是容器内部的路径
  • COPY不能写URL，也不能解压

COPY （从 src 复制文件到 container 的 dest 路径）

COPY <src> <dest>

VOLUME（指定挂载点）

设置指令，使容器中的一个目录具有持久化存储数据的功能，该目录可以被容器本身使用，也可以共享给其他容器使用。我们知道容器使用的是 AUFS，这种文件系统不能持久化数据，当容器关闭后，所有的更改都会丢失。当容器中的应用有持久化数据的需求时可以在 Dockerfile中 使用该指令

FROM base  
VOLUME ["/tmp/data"]

WORKDIR（切换目录）

  • 设置指令，可以多次切换(相当于cd命令)，对RUN,CMD,ENTRYPOINT生效
  • 这是默认的登录路径，比如centos就在根下，wordpress就在/var/www/html/下
    而且可以和RUN配合，比如安装nginx，./configure的时候，如果有默认目录就不用写在一行了
WORKDIR /p1 WORKDIR p2 RUN vim a.txt

CMD（设置 container 启动时执行的操作）

  • 设置指令，用于 container 启动时指定的操作。该操作可以是执行自定义脚本，也可以是执行系统命令。该指令只能在文件中存在一次，如果有多个，则只执行最后一条
  • 默认启动命令，有两个使用机会，start和run的时候会被使用
CMD echo “Hello, World!”

ENTRYPOINT（设置container启动时执行的操作）

设置指令，指定容器启动时执行的命令，可以多次设置，但是只有最后一个有效。

ENTRYPOINT ls -l

该指令的使用分为两种情况，一种是独自使用，另一种和 CMD 指令配合使用。当独自使用时，如果你还使用了 CMD 命令且 CMD 是一个完整的可执行的命令，那么 CMD 指令和 ENTRYPOINT 会互相覆盖只有最后一个 CMD 或者 ENTRYPOINT 有效

CMD echo “Hello, World!” 
ENTRYPOINT ls -l
# CMD 指令将不会被执行，只有 ENTRYPOINT 指令被执行

另一种用法和 CMD 指令配合使用来指定 ENTRYPOINT 的默认参数，这时 CMD 指令不是一个完整的可执行命令，仅仅是参数部分；ENTRYPOINT 指令只能使用 JSON 方式指定执行命令，而不能指定参数
CMD中括号的是选项，ENTEYPOINT中括号内的是命令

FROM ubuntu  
CMD ["-l"]  
ENTRYPOINT ["/usr/bin/ls"]

CMD 与 ENTRYPOINT 的较量

官方释义：https://docs.docker.com/engine/reference/builder/#cmd

cmd 给出的是一个容器的默认的可执行体。也就是容器启动以后，默认的执行的命令

FROM centos
CMD echo "hello cmd!"

docker run xx 
==> hello cmd!

# 如果我们在 run 时指定了命令或者有entrypoint，那么 cmd 就会被覆盖。仍然是上面的 image。run 命令变了：
docker run xx echo glgl
==> glgl

cmd 是默认体系，entrypoint 是正统地用于定义容器启动以后的执行体

FROM centos 
CMD ["p in cmd"]
ENTRYPOINT ["echo"]

[root@k8s-master01 testd]# docker run --name test1  ent:v1
p in cmd
[root@k8s-master01 testd]# docker run --name test2 ent:v1  p in run
p in run

# ENTRYPOINT shell 模式任何 run 和 cmd 的参数都无法被传入到 entrypoint 里。官网推荐第一种用法
FROM centos
CMD ["p in cmd"]
ENTRYPOINT echo

  • CMD (Command)
    想象一下，你有一个玩具机器人，CMD就是告诉机器人它应该默认做什么动作。比如，你设定它默认跳一支舞。但如果有一天你想要机器人做别的事情，比如唱歌，你只需要告诉它“唱首歌”，它就会停止跳舞，转而唱歌。这就是CMD的作用，它设定了默认的动作（命令），但你可以随时改变它。

  • ENTRYPOINT (Entry Point)
    现在，想象你有一个遥控车，ENTRYPOINT就像是车的引擎。不管你想要车做什么，比如前进、转弯或者倒车，首先得有引擎让它动起来。所以，ENTRYPOINT设定了车必须要有的引擎，也就是主要的命令。然后，你可以通过遥控器（相当于docker run命令中的参数）来告诉车具体要做什么动作，比如前进或者转弯，但引擎（ENTRYPOINT）是一直在运行的。

  • 总结
    CMD就像是机器人的默认动作，可以被随时更改。
    ENTRYPOINT就像是遥控车的引擎，是必须的，而且它会一直运行。你可以通过遥控器给它不同的指令，但它始终是车的核心。

  • 在Docker的世界里，CMD通常用来提供默认的参数或者命令，而ENTRYPOINT则用来确保容器总是以特定的命令开始运行。你可以把CMD看作是可选的配件，而ENTRYPOINT则是必不可少的部件。

ONBUILD（在子镜像中执行）

ONBUILD 指定的命令在构建镜像时并不执行，而是在它的子镜像中执行
扩展：比如Tomcat中有一个webapp，里面那个root每次都要清空，就可以在调用下面写个ONBUILD

ONBUILD ADD . /app/src
ONBUILD RUN /usr/local/bin/python-build --dir /app/src

STOPSIGNAL signal

STOPSIGNAL 指令设置将发送到容器以退出的系统调用信号。这个信号可以是一个有效的无符号数字，与内核的syscall表中的位置相匹配，例如9，或者是SIGNAME格式的信号名，例如：SIGKILL

SIGHUP 1 A 终端挂起或者控制进程终止

SIGINT 2 A 键盘中断（如break键被按下）

SIGQUIT 3 C 键盘的退出键被按下

SIGILL 4 C 非法指令

SIGABRT 6 C 由abort(3)发出的退出指令

SIGFPE 8 C 浮点异常

SIGKILL 9 AEF Kill信号

SIGSEGV 11 C 无效的内存引用

SIGPIPE 13 A 管道破裂: 写一个没有读端口的管道

SIGALRM 14 A 由alarm(2)发出的信号

SIGTERM 15 A 终止信号

SIGUSR1 30,10,16 A 用户自定义信号1

SIGUSR2 31,12,17 A 用户自定义信号2

SIGCHLD 20,17,18 B 子进程结束信号

SIGCONT 19,18,25 进程继续（曾被停止的进程）

SIGSTOP 17,19,23 DEF 终止进程

SIGTSTP 18,20,24 D 控制终端（tty）上按下停止键

SIGTTIN 21,21,26 D 后台进程企图从控制终端读

SIGTTOU 22,22,27 D 后台进程企图从控制终端写

​

SHELL （覆盖命令的shell模式所使用的默认 shell）

Linux 的默认shell是 [“/bin/sh”, “-c”]，Windows 的是 [“cmd”, “/S”, “/C”]。SHELL 指令必须以 JSON 格式编写。SHELL 指令在有两个常用的且不太相同的本地 shell:cmd 和 powershell，以及可选的 sh 的 windows 上特别有用

HEALTHCHECK （容器健康状况检查命令）

HEALTHCHECK [OPTIONS] CMD command
    [OPTIONS] 的选项支持以下三中选项
        --interval=DURATION 两次检查默认的时间间隔为 30 秒
    --timeout=DURATION 健康检查命令运行超时时长，默认 30 秒
    --retries=N 当连续失败指定次数后，则容器被认为是不健康的，状态为 unhealthy，默认次数是3

    CMD后边的命令的返回值决定了本次健康检查是否成功，具体的返回值如下：
        0: success - 表示容器是健康的
        1: unhealthy - 表示容器已经不能工作了
        2: reserved - 保留值

HEALTHCHECK NONE

# 第一个的功能是在容器内部运行一个命令来检查容器的健康状况
# 第二个的功能是在基础镜像中取消健康检查命令
# 为了帮助调试失败的探测，command 写在 stdout 或 stderr 上的任何输出文本（UTF-8编码）都将存储在健康状态中，并且可以通过 docker inspect 进行查询。 这样的输出应该保持简短（目前只存储前4096个字节）
注意

HEALTHCHECK 命令只能出现一次，如果出现了多次，只有最后一个生效

模板
HEALTHCHECK --interval=5m --timeout=3s \
CMD curl -f http://localhost/ || exit 1
查看容器的健康状态
$ docker inspect –format ‘{{json .State.Health.Status}}’ cID

扩展

docker  history   镜像名   --no-trunc
可以看到制造镜像的全过程

file

男孩子都是香香软软的小猪
暂无评论

发送评论 编辑评论 


				

			

						

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
							
													

					

				

			

			
			

				

					
				

			

				

											

							
							
						

																

							
							
						

																

							
							
						

										
					
											
						

	

		
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
（╯‵□′）╯︵┴─┴
￣﹃￣
(/ω＼)
∠( ᐛ 」∠)＿
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ｀)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ(￣∇￣o)
ヾ(´･ ･｀｡)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò｡)
Σ(っ °Д °;)っ
( ,,´･ω･)ﾉ"(´っω･｀｡)
╮(╯▽╰)╭
o(*////▽////*)q
＞﹏＜
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
	

	

		
颜文字
Emoji
小恐龙
花!
	


									

			

			
			
		

	






上一篇
下一篇 

                    

                    
			        推荐文章
		            

		            

							
高级镜像制作

							
							

							
Docker网络原理

							
							

							
docker的容器持久化

							
							

							
Docker简介

							
							

							
Docker的基本操作

							
							

							
容器的资源限制