规则1： 同一个层级可以附加一个或多个子系统。

规则2：一个子系统可以附加到多个层级，当且仅当目标层级只有唯一一个子系统时。

规则3：系统每次新建一个层级时，该系统上的所有任务默认加入这个新建层级的初始化cggroup，这个cgroup也被称为root cgroup。对于创建的每个层级，任务只能存在于其中一个cgroup中，即一个任务不能存在于同一个层级的不同cgroup中，但一个任务可以存在于不同层级中的多个cgroup中。如果操作时把一个任务添加到同一个层级中的另一个cgroup中，则会将它从第一个cgroup中移除。

规则4： 任务在for/clone自身时创建的子任务默认与原任务在同一个cgroup中，但是子任务允许被移动到不同的cgroup中，即fork/clone完成后，父子任务间在cgroup方面是互不影响的。

bikio  # 可以为块设备设定输入/输出限制，比如物理驱动设备（包括磁盘、固态硬盘、USB等）
cpu   # 使用调度程序控制任务对CPU的使用
cpuacct  # 自动生成cgroup中任务对CPU资源使用情况的报告。
cpuset  # 可以为cgroup中的任务分配独立的CPU（此处针对多处理器系统）和内存。
devices  # 可以开启或关闭cgroup中任务对设备的访问
freezer  # 可以挂起或恢复cgroup中的任务
memory  # 可以设定cgroup中任务对内存使用量的设定，并且自动生成这些任务对内存资源使用情况的报告。
perf_event  # 使用后使cgroup中的任务可以进行统一的性能测试。
*net_cls  # Docker没有直接使用它，它通过使用等级标识符（classid）标识网络数据包，从而允许Linux流量控制程序（Traffic Controller,TC）识别从具体cgroup中生成的数据包。

根据config中的registry address，得到有效的index配置信息

由返回的Index配置信息解析获得一个registry endpoint.

重置config中的registry address为上一步返回的endpoint.

执行Login函数登入该registry endpoint。

# docker search centos --filter=stars=5000      # 显示评价为5000星以上的镜像
NAME                DESCRIPTION                     STARS               OFFICIAL            AUTOMATED
centos              The official build of CentOS.   5556                [OK]

    自动创建功能对于需要经常升级镜像内程序来说十分方便，自动创建功能使得用户通过Docker Hub指定跟踪一个目标网站（目前支持GitHub或BitBucket）上的项目，一旦项目发现新的提交，则会自动执行创建。要配置自动创建，包括如下的步骤：
        1）. 创建并登录Docker Hub,以及目标网站；*在目标网站中连接账户到Docker Hub。
        2）. 在Docker Hub中配置一个自动创建。
        3）.选取一个目标网站中的项目（需要含Dockerfile）和分支
        4）.指定Dockerfile的位置，并提交创建。
        之后可以再Docker Hub的“自动创建”页面跟踪每次创建的状态

    Docker的server端收到用户发起的pull请求后，需要做的主要工作如下：

        1、根据用户命令行参数解析出其希望拉取的repository信息

        2、通过TagStore设置锁，保证Docker daemon在一个时刻对一个repository只能进行一个拉取操作；拉取镜像完毕之后该锁释放。

        3、获取endpoint信息，并向该endpoint指定的registry发起会话

        4、如果待拉取repository为official版本或者endpoint的API版本为V2,同时用户没有配置Docker-Mirrors,Docker就直接向V2 registry拉取镜像。（如果向V2 registry拉取镜像失败，则尝试从V1 registry拉取。）

        5、获取V2 registry的endpoint。

        6、由endpoint和待拉取镜像名称获取拉取指定镜像的认证信息。

        7、如果tag值为空，即没有指定标签，则获取V2 registry中repository的tag list，然后对于tag list中的每一个标签，都执行一次pullV2Tag方法。该方法的功能分为两大部分，一是验证用户请求，二是当且仅当某一层不在本地时进行拉取这一层文件到本地。如果tag值不为空，则只对指定标签的镜像进行上述工作

    docker commit命令只提交容器镜像发生变更了的部分，即修改后的容器镜像与当前仓库中对应镜像之间的差异部分，这使得该操作实际需要提交的文件往往并不多。Docker server接收到对应的HTTP请求后，需要执行下面的步骤：

        根据用户输入pause函数的设置确定是否暂停该Docker容器的运行。

        寻找该容器文件系统再graphdriver上的路径。

        返回该容器与其父镜像的差异并将这部分文件和目录打成压缩包，即待commit容器的可读写层的差异（diff）。

        graphdriver根据返回的差异创建一个新的镜像，记录其元数据。

        将上述镜像文件及目录上传至repository。

    Docker client端通过Dockerfile完成相关信息的设置之后，Docker client向Docker server发送“POST/build”的HTTP请求，包含了所需的context信息（文件或目录）。

        Docker server端接受到相应的HTTP请求后，需要做的工作如下：

        创建一个临时目录。并将context制定的文件系统解压到该目录下。

        读取并解析Dockerfile

        根据解析出的DOckerfile遍历其中的所有指令，并分发到不同的模块去执行。Dockerfile每条指令的格式均为INSTRUCION arguments，INSTRUCION是一些特定的关键词，包括FROM、RUN、USER等，都会映射到不同的parser进行处理。

        parser为上述每一个指令创建一个对应的临时容器，然后通过commit使用此容器生成一层镜像。

        Dockerfile中偶的指令对应的层的集合，就是此次build后的结果。其中最后一次commit生成的层镜像ID就会作为最终的镜像ID返回。

    当用户制作了自己的镜像后，希望将它上传至仓库，此时可以通过docker push命令完成该操作。而在Docker server接收到用户的push请求后的关键步骤如下：

    解析出repository信息，通过TagStore设置锁。

    通过ping操作检查指定的registry是否可用，返回一个registry endpoint，然后发起同registry的会话.

    如果推送的镜像为Official镜像或者endpoint对应版本为V2 registry，则调用pushV2 Repository方法。这个方法会首先验证用户指定标签的镜像在本地是否存在，以及被推repository的访问权限。接下来，对于不同标签的待推送镜像，该方法会从顶向下逐个检验layer其checksum，标记被推送repository中不存在的layer和更改过的读写层内容。将这些标记后的镜像内容上传完毕后，再讲一份描述文件manifest上传到repository。

    如果镜像不属于上述情况，则Docker会调用push Repository方法来推送镜像到V1 registry，并根据待推送的repository和tag信息保证当且仅当某layer在endpoint上不存在时，才上传该layer。

docker.io ,docker ,docker-engine 两个docker发行版本。
Docker的版本：
    Docker-CE：Docker Commutication Enterprise
    Docker-EE：企业版本
Docker分为CE和EE版本。CE为社区版(免费，支持周期7个月)，EE为企业版，强调安全，付费使用，支持周期24个月。
    CE分位stable，test和nightly三个更新频道。

Docker安装的基本要求：
    1、Docker只支持64位CPU架构的计算机，目前不支持32位CPU.
    2、建议系统的Linux内核版本为3.10及以上。
    3、Linux内核需开启cgroups和namespace功能。
    4、对于非Linux内核的平台，如Microsoft Windows和OS X，需要安装使用Boot2Docker工具。

[root@localhost ~]# yum remove docker \
docker-client \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-selinux \
docker-engine-selinux \
docker-engine

(1)docker用户加入docker用户组
# groupadd docker

(2)将用户加入到docker组
# usermod -aG docker USERNAME

curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun

#!/bin/sh

SYSTEMDDIR=/usr/lib/systemd/system
SERVICEFILE=docker.service
SERVICENAME=docker
DOCKERDIR=/usr/bin
DOCKERBIN=docker
SOCKETFILE=docker.socket
CONTAINERDFILE=containerd.service

Usage(){
  echo "Usage: $0 ./FILE_NAME_DOCKER_CE_TAR_GZ"
  echo "       $0 ./docker-23.0.6.tgz"
  echo "Get docker-ce binary from: https://download.docker.com/linux/static/stable/x86_64/"
  echo "eg: wget -c https://download.docker.com/linux/static/stable/x86_64/docker-23.0.6.tgz"
  echo "eg: curl -O --progress https://download.docker.com/linux/static/stable/x86_64/docker-23.0.6.tgz"
  echo ""
}

#传入的参数不等于1就退出
if [ $# -ne 1 ]; then
  Usage
  exit 1
else
  FILETARGZ="$1"
fi

if [ ! -f ${FILETARGZ} ]; then
  echo "Docker binary tgz files does not exist, please check it"
  echo "Get docker-ce binary from: https://download.docker.com/linux/static/stable/x86_64/"
  echo "eg: wget https://download.docker.com/linux/static/stable/x86_64/docker-23.0.6.tgz"
  echo "eg: curl -O --progress https://download.docker.com/linux/static/stable/x86_64/docker-23.0.6.tgz"
  exit 1
fi

# 判断 docker 命令是否存在
if command -v docker >/dev/null 2>&1; then
    echo "Docker is installed."
    exit 3
else
    echo "Docker is not installed."
fi

echo "##EXTRACT : tar xvpf ./${FILETARGZ} --strip-components=1"
tar xvf ./${FILETARGZ} -C ${DOCKERDIR} -o --touch --strip-components=1 --no-same-owner --owner=root --group=root
which ${DOCKERBIN}
echo

#create docker group
echo "##create docker group"
getent group docker &> /dev/null
test $? -eq 0 || groupadd docker

echo "##systemd service: ${SERVICEFILE}"
echo "##docker.service: create docker systemd file"
cat >${SYSTEMDDIR}/${SERVICEFILE} << EOF
[Unit]
Description=Docker Application Container Engine
Documentation=https://docs.docker.com
#After=network-online.target docker.socket firewalld.service containerd.service
After=network-online.target docker.socket containerd.service
Wants=network-online.target
Requires=docker.socket containerd.service

[Service]
Type=notify
# the default is not to use systemd for cgroups because the delegate issues still
# exists and systemd currently does not support the cgroup feature set required
# for containers run by docker
ExecStart=${DOCKERDIR}/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
ExecReload=/bin/kill -s HUP \$MAINPID
TimeoutSec=0
RestartSec=2
Restart=always

# Note that StartLimit* options were moved from "Service" to "Unit" in systemd 229.
# Both the old, and new location are accepted by systemd 229 and up, so using the old location
# to make them work for either version of systemd.
StartLimitBurst=3

# Note that StartLimitInterval was renamed to StartLimitIntervalSec in systemd 230.
# Both the old, and new name are accepted by systemd 230 and up, so using the old name to make
# this option work for either version of systemd.
StartLimitInterval=60s

# Having non-zero Limit*s causes performance problems due to accounting overhead
# in the kernel. We recommend using cgroups to do container-local accounting.
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity

# Comment TasksMax if your systemd version does not support it.
# Only systemd 226 and above support this option.
TasksMax=infinity

# set delegate yes so that systemd does not reset the cgroups of docker containers
Delegate=yes

# kill only the docker process, not all processes in the cgroup
KillMode=process
OOMScoreAdjust=-500

[Install]
WantedBy=multi-user.target
EOF


echo "##systemd service: ${SOCKETFILE}"
echo "##docker.socket: create socket systemd file"
cat >${SYSTEMDDIR}/${SOCKETFILE} << EOF
[Unit]
Description=Docker Socket for the API

[Socket]
ListenStream=/var/run/docker.sock
SocketMode=0660
SocketUser=root
SocketGroup=docker

[Install]
WantedBy=sockets.target
EOF

echo "##systemd service: ${CONTAINERDFILE}"
echo "##containerd.service: create containerd systemd file"
cat >${SYSTEMDDIR}/${CONTAINERDFILE} << EOF
# Copyright The containerd Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

[Unit]
Description=containerd container runtime
Documentation=https://containerd.io
After=network.target local-fs.target

[Service]
ExecStartPre=-/sbin/modprobe overlay
ExecStart=${DOCKERDIR}/containerd

Type=notify
Delegate=yes
KillMode=process
Restart=always
RestartSec=5
# Having non-zero Limit*s causes performance problems due to accounting overhead
# in the kernel. We recommend using cgroups to do container-local accounting.
LimitNPROC=infinity
LimitCORE=infinity
LimitNOFILE=infinity
# Comment TasksMax if your systemd version does not supports it.
# Only systemd 226 and above support this version.
TasksMax=infinity
OOMScoreAdjust=-999

[Install]
WantedBy=multi-user.target
EOF
echo ""

echo "##create daemon.json file"
test -d /etc/docker || mkdir /etc/docker
cat > /etc/docker/daemon.json << EOF
{
    "oom-score-adjust": -1000,
    "log-driver": "json-file",
    "log-opts": {
        "max-size": "10m",
        "max-file": "3"
    },
    "max-concurrent-downloads": 10,
    "max-concurrent-uploads": 10,
    "bip": "172.17.0.1/16",
    "registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"],
    "storage-driver": "overlay2",
    "live-restore": true
}
EOF

systemctl daemon-reload
echo "##Service restart: ${SERVICENAME}"
systemctl restart ${SERVICENAME}
echo "##Service status: ${SERVICENAME}"
systemctl status ${SERVICENAME}
# 检查 Docker 服务状态并获取状态值
docker_status=$(systemctl is-active docker.service)
# 判断 Docker 服务是否处于运行状态
if [ "$docker_status" == "active" ]; then
    echo "Docker is running."
    echo "##Service enabled: ${SERVICENAME}"
    systemctl enable ${SERVICENAME}
    echo "## docker version"
    docker version
else
    echo "Docker is not running."
fi

install-docker.sh docker-23.0.6.tgz

# step 1: 安装必要的一些系统工具
sudo yum install -y yum-utils device-mapper-persistent-data lvm2

# Step 2: 添加软件源信息
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

docker安装版本查看：
# yum list docker-ce --showduplicates | sort -r

# Step 3: 更新并安装 Docker-CE，（最好安装18.09，因为k8s1.14配合18.09比较好）
sudo yum makecache fast && sudo yum -y install docker-ce-18.09.9 docker-ce-cli-18.09.9 

# Step 4: 开启Docker服务并设置为开机自动启动
systemctl start docker.service && systemctl enable docker.service

#查看docker软件包
# rpm -qa docker*
docker-ce-18.09.9-3.el7.x86_64      #docker服务端
docker-ce-cli-18.09.9-3.el7.x86_64  #docker客户端

# yum -y install https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/centos/7/x86_64/stable/Packages/docker-ce-selinux-17.03.3.ce-1.el7.noarch.rpm

# yum -y install docker-ce

Error: Package: containerd.io-1.2.6-3.3.el7.x86_64 (docker-ce-stable)
Requires: container-selinux >= 2:2.74
Error: Package: 3:docker-ce-19.03.2-3.el7.x86_64 (docker-ce-stable)
           Requires: container-selinux >= 2:2.74
 You could try using --skip-broken to work around the problem
 You could try running: rpm -Va --nofiles --nodigest

[root@falcon-agent-01 ~]# rpm -ivh docker-ce
error: open of docker-ce failed: No such file or directory

# yum -y install http://mirror.centos.org/centos/7/extras/x86_64/Packages/container-selinux-2.107-3.el7.noarch.rpm
# 再次安装docker 成功：
# yum -y install docker-ce-18.09.9 docker-ce-cli-18.09.9

# docker version
Client:                     # 客户端信息
 Version:           18.09.5         # docker版本信息
 API version:       1.39            # API接口信息
 Go version:        go1.10.8        # go语言版本信息
 Git commit:        e8ff056
 Built:             Thu Apr 11 04:43:34 2019
 OS/Arch:           linux/amd64     # 操作系统
 Experimental:      false

Server: Docker Engine - Community   # 服务端信息
 Engine:
  Version:          18.09.5         # 引擎版本
  API version:      1.39 (minimum version 1.12)
  Go version:       go1.10.8
  Git commit:       e8ff056
  Built:            Thu Apr 11 04:13:40 2019
  OS/Arch:          linux/amd64
  Experimental:     false

# docker info
Client:
 Debug Mode: false
Server:
 Containers: 0              #容器个数
  Running: 0                #正在运行的
  Paused: 0                 #暂停的
  Stopped: 0                #停止的
 Images: 0                  #镜像个数
 Server Version: 19.03.5    #docker版本
 Storage Driver: overlay2   #镜像文件存储类型
  Backing Filesystem: xfs
  Supports d_type: true
  Native Overlay Diff: false
 Logging Driver: json-file
 Cgroup Driver: cgroupfs
 Plugins:
  Volume: local
  Network: bridge host ipvlan macvlan null overlay
  Log: awslogs fluentd gcplogs gelf journald json-file local logentries splunk syslog
 Swarm: inactive
 Runtimes: runc
 Default Runtime: runc
 Init Binary: docker-init
 containerd version: b34a5c8af56e510852c35414db4c1f4fa6172339
 runc version: 3e425f80a8c931f88e6d94a8c831b9d5aa481657
 init version: fec3683
 Security Options:
  seccomp
   Profile: default
 Kernel Version: 3.10.0-514.el7.x86_64      #操作系统内核
 Operating System: CentOS Linux 7 (Core)    #操作系统版本
 OSType: linux                              #操作类型
 Architecture: x86_64                       #架构
 CPUs: 4                                    #CPU
 Total Memory: 15.38GiB                     #内存
 Name: master                               #操作系统主机名
 ID: 7QIJ:DWSP:VGLZ:LMV6:LYPV:BJRJ:MC64:RYNH:23DX:ZH6V:I3U4:FMI3
 Docker Root Dir: /var/lib/docker           #存储docker平台中相关信息
 Debug Mode: false
 Registry: https://index.docker.io/v1/      #加速器
 Labels:
 Experimental: false
 Insecure Registries:
  127.0.0.0/8
 Live Restore Enabled: false

yum install -y bash-completion

source /usr/share/bash-completion/completions/docker

WARNING: bridge-nf-call-iptables is disabled
WARNING: bridge-nf-call-ip6tables is disabled

$ sudo tee -a /etc/sysctl.conf <<-EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-arptables = 1
EOF

cat >> /etc/sysctl.conf << EOF
# iptables透明网桥的实现；
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-arptables = 1
EOF

# 然后重新加载 sysctl.conf 即可
$ sudo sysctl -p

# 应用 sysctl 参数而不重新启动
sudo sysctl --system

$ sysctl net.ipv4.ip_forward
net.ipv4.ip_forward = 1

$ sysctl -w net.ipv4.ip_forward=1

# 手动开启:
# vim /etc/sysctl.conf  #插入以下内容
net.ipv4.ip_forward = 1
# sysctl -p   #生效
net.ipv4.ip_forward = 1

# 查看
# cat /proc/sys/net/ipv4/ip_forward
1

# 设定iptables，防止Docker将iptables的FORWARD修改为DROP
# sed -i '/^ExecStart.*/aExecStartPost=/usr/sbin/iptables -P FORWARD ACCEPT' /usr/lib/systemd/system/docker.service
# 将Docker的网络端口开启，因为这台主要是来给我们build镜像的，因为测试需要，所以开启TCP地址，正常情况下应该做好安全防护
# sed -ri 's@(^ExecStart\>.*)@\1 -H tcp://0.0.0.0:2375@g' /usr/lib/systemd/system/docker.service
# 每次修改System风格程序的管理脚本都得重载配置
# systemctl daemon-reload
# 重启下Docker，让我们的配置生效；
# systemctl restart docker

{
    "registry-mirrors": [
        "https://registry.docker-cn.com"                        
    ]
}

systemctl daemon-reload
systemctl restart docker

# vim /etc/docker/daemon.json
{
    "registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"]
}

[root@Docker ~]# docker pull centos
Using default tag: latest
Trying to pull repository docker.io/library/centos ... 
latest: Pulling from docker.io/library/centosGet https://registry-1.docker.io/v2/library/centos/manifests/sha256:822de5245dc5b659df56dd32795b08ae42db4cc901f3462fc509e91e97132dc0: net/http: TLS handshake timeout

# vim  /etc/docker/daemon.json   #添加以下内容
{
  "registry-mirrors": ["https://qss6jjtw.mirror.aliyuncs.com"]
}

# 有多个的情况下，用逗号隔开：
# vim  /etc/docker/daemon.json   #添加以下内容
{
  "registry-mirrors": ["https://qss6jjtw.mirror.aliyuncs.com","https://qss7jjtw.mirror.aliyuncs.com"]
}

# systemctl daemon-reload
# systemctl restart docker

curl -sSL https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://f1361db2.m.daocloud.io

[root@learn ~]# cat /etc/docker/daemon.json
{
  "registry-mirrors": ["http://f1361db2.m.daocloud.io"]
}

# 重启docker
systemctl restart docker

docker run hello-world

{
    "authorization-plugins": [],
    "data-root": "", #Docker运行时使用的根路径,根路径下的内容稍后介绍，默认/var/lib/docker
    "dns": [],   #设定容器DNS的地址，在容器的 /etc/resolv.conf文件中可查看
    "dns-opts": [], #容器 /etc/resolv.conf 文件，其他设置
    "dns-search": [],  #设定容器的搜索域，当设定搜索域为 .example.com 时，在搜索一个名为 host 的 主机时，DNS不仅搜索host，还会搜索host.example.com。注意：如果不设置，Docker 会默认用主机上的 /etc/resolv.conf来配置容器。
    "oom-score-adjust": -1000, # 防止 docker 服务 OOM
    "storage-driver": "overlay2",  # docker存储驱动
    "storage-opts": [
        "overlay2.override_kernel_check=true"
    ],
    "exec-opts": ["native.cgroupdriver=systemd"], # 启动时的额外参数, https://www.cnblogs.com/architectforest/p/12988488.html docker默认的Cgroup Driver是cgroupfs,cgroupfs是cgroup为给用户提供的操作接口而开发的虚拟文件系统类型，它和sysfs，proc类似，可以向用户展示cgroup的hierarchy，通知kernel用户对cgroup改动，对cgroup的查询和修改只能通过cgroupfs文件系统来进行
    # 3,为什么要修改为使用systemd?
    # Kubernetes 推荐使用 systemd 来代替 cgroupfs,为什么呢？
    #   因为systemd是Kubernetes自带的cgroup管理器, 负责为每个进程分配cgroups,但docker的cgroup driver默认是cgroupfs,这样就同时运行有两个cgroup控制管理器, 当资源有压力的情况时,有可能出现不稳定的情况
    "exec-root": "",
    "experimental": false, #启用实验功能
    "features": {},
    "storage-driver": "overlay2",#表示使用OverlayFS的overlay2存储驱动
    "storage-opts": ["overlay2.override_kernel_check=true"],
    "labels": [],  #docker主机的标签，很实用的功能,例如定义：–label nodeName=host-121
    "live-restore": true,
    "log-driver": "",
    "log-opts": {},
    "log-level": "", # 容器日志等级
    "mtu": 0,
    "pidfile": "", #Docker守护进程的PID文件
    "cluster-store": "",
    "cluster-store-opts": {},
    "cluster-advertise": "",
    "max-concurrent-downloads": 3,
    "max-concurrent-uploads": 5,
    "default-shm-size": "64M",
    "shutdown-timeout": 15,
    "debug": true, #启用debug的模式，启用后，可以看到很多的启动信息。默认false
    "hosts": [],  #设置容器hosts
    "tls": true,   #默认 false, 启动TLS认证开关
    "tlscacert": "",  #默认 ~/.docker/ca.pem，通过CA认证过的的certificate文件路径
    "tlscert": "",  #默认 ~/.docker/cert.pem ，TLS的certificate文件路径
    "tlskey": "", #默认~/.docker/key.pem，TLS的key文件路径
    "tlsverify": true, #默认false，使用TLS并做后台进程与客户端通讯的验证
    "tls": true,
    "tlsverify": true,
    "tlscacert": "",
    "tlscert": "",
    "tlskey": "",
    "swarm-default-advertise-addr": "",
    "api-cors-header": "",
    "selinux-enabled": false,  # 默认 false，启用selinux支持
    "userns-remap": "",
    "group": "", # Unix套接字的属组,仅指/var/run/docker.sock
    "cgroup-parent": "",
    "default-ulimits": {
        "nofile": {
            "Name": "nofile",
            "Hard": 64000,
            "Soft": 64000
        }
    },
    "init": false,
    "init-path": "/usr/libexec/docker-init",
    "ipv6": false,
    "iptables": false,
    "ip-forward": false, # 默认true, 启用 net.ipv4.ip_forward ,进入容器后使用sysctl -a|grepnet.ipv4.ip_forward查看
    "ip-masq": false,
    "userland-proxy": false,
    "userland-proxy-path": "/usr/libexec/docker-proxy",
    "ip": "0.0.0.0",
    "bridge": "",
    "bip": "",          # 指定docker运行的网段
    "fixed-cidr": "",
    "fixed-cidr-v6": "",
    "default-gateway": "",
    "default-gateway-v6": "",
    "icc": false,
    "raw-logs": false,
    "allow-nondistributable-artifacts": [],
    "registry-mirrors": [],  # 镜像加速的地址，增加后在 docker info中可查看。
    "insecure-registries": [], # 配置docker的私库地址
    "seccomp-profile": "",
    "no-new-privileges": false,
    "default-runtime": "runc",
    "oom-score-adjust": -500,
    "node-generic-resources": ["NVIDIA-GPU=UUID1", "NVIDIA-GPU=UUID2"],
    "runtimes": { # 配置容器运行时
        "cc-runtime": {
            "path": "/usr/bin/cc-runtime"
        },
        "custom": {
            "path": "/usr/local/bin/my-runc-replacement",
            "runtimeArgs": [
                "--debug"
            ]
        }
    },
    "default-address-pools":[{"base":"172.80.0.0/16","size":24},
    {"base":"172.90.0.0/16","size":24}]
}

# 查看参数：
docker info | grep -i storage

$ sudo vim /etc/docker/daemon.yaml
{
  "live-restore": true
}

# 在docker守护进程停机期间保持容器存活,就是即使docker进程停止了,之前运行的容器不会停止
$ sudo dockerd --live-restore

# 只能使用reload重载
# 相当于发送SIGHUP信号量给dockerd守护进程
$ sudo systemctl reload docker

# 但是对应网络的设置需要restart才能生效
$ sudo systemctl restart docker

[root@learn ~]# cat /etc/docker/daemon.json
{
    "oom-score-adjust": -1000,
    "exec-opts": ["native.cgroupdriver=systemd"],
    "log-driver": "json-file",
    "log-opts": {
        "max-size": "10m",
        "max-file": "3"
    },
    "max-concurrent-downloads": 10,
    "max-concurrent-uploads": 10,
    "bip": "172.17.0.1/16",
    "registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"],
    "storage-driver": "overlay2",
    "storage-opts": [
        "overlay2.override_kernel_check=true"
    ],
    "live-restore": true
}


# docker-24.0.7 以下参数不生效了
    "exec-opts": ["native.cgroupdriver=systemd"],
    "storage-opts": [
        "overlay2.override_kernel_check=true"
    ],

# 重启docker
systemctl restart docker

1.查看docker镜像存放目录空间大小
du -sh /var/lib/docker/

2.停止docker服务。
systemctl stop docker

3.查看磁盘容量大的空间，且在上面创建新的docker目录。
df -h
mkdir -p /data/docker/lib

4.迁移/var/lib/docker目录下的文件到新创建的目录/data/docker/lib（注意第一个路径后面一定不要到 “/”，否则是同步的/var/lib/docker/目录里面的内容，不会把docker目录同步过去）
rsync -avz /var/lib/docker /data/docker/lib/

5.编辑 /etc/docker/daemon.json 添加如下参数。在docker 19.xx 版本以后使用data-root来代替graph
{
  "data-root": "/data/docker/lib/docker"
}

6.重新加载docker，并重启docker服务。
systemctl daemon-reload && systemctl start docker

7.检查docker是否变更为新目录/data/docker/lib/docker
[root@localhost ~]# docker info
...
Docker Root Dir: /data/docker/lib/docker

Debug Mode (client): false

Debug Mode (server): false

Registry: https://index.docker.io/v1/
...

8.重启服务器
reboot

9.删掉docker旧目录
rm -rf /var/lib/docker

Usage:  docker [OPTIONS] COMMAND

A self-sufficient runtime for containers

Options:
--config=~/.docker       #客户端配置文件的位置
-D, --debug              #启动调试模式
-H, --host=[]            #守护进程套接字（s）连接到
-h, --help               #打印帮助
-l, --log-level string #Set the logging level ("debug"|"info"|"warn"|"error"|"fatal") (default "info")
--tls                    #使用TLS;implied by --tlsverify
--tlscacert=~/.docker/ca.pem     #仅由此CA签署的信任证书
--tlscert=~/.docker/cert.pem     #TLS证书文件的路径
--tlskey=~/.docker/key.pem       #TLS密钥文件的路径
--tlsverify                      #使用TLS并验证远程
-v, --version                    #打印版本信息并退出
Management Commands:
  builder     Manage builds
  config      Manage Docker configs
  container   Manage containers
  engine      Manage the docker engine
  image       Manage images
  network     Manage networks
  node        Manage Swarm nodes
  plugin      Manage plugins
  secret      Manage Docker secrets
  service     Manage services
  stack       Manage Docker stacks
  swarm       Manage Swarm
  system      Manage Docker
  trust       Manage trust on Docker images
  volume      Manage volumes

Commands:
attach       #进入到正在运行的容器
build        #从Dockerfile构建一个镜像
commit       #从容器的更改中创建一个新的镜像
cp          #在本地文件系统与容器中互相复制 文件/文件夹
create      #创建一个新的容器
diff        #检查容器文件系统上的更改
events      #从服务器获取实时事件
exec        #进入正在运行的容器中运行命令
export      #将容器的文件系统导出为tar存档
history     #显示镜像每一层的大小
images      #镜像列表
import      #从tarball中导入内容以创建文件系统映像
info        #显示系统环境信息
inspect     #检查返回容器，镜像或任务的低级信息
kill        #杀死一个或多个正在运行的容器
load        #从tar归档或STDIN加载镜像
login       #登录到Docker镜像库。
logout      #从Docker镜像库中注销。
logs        #获取容器的日志。默认/var/lib/docker/containers/容器ID/容器ID-json.log
network     #管理Docker网络
node        #管理Docker Swarm节点
pause       #暂停一个或多个容器内的所有进程
port        #列出端口映射或容器的特定映射
ps          #容器列表
pull        #从镜像库中拉出镜像或存储库
push        #推送镜像或存储库到镜像库
rename      #重命名一个容器
restart     #重启一个容器
rm          #删除一个或多个容器
rmi         #rmi删除一个或多个镜像
run         #在新容器中运行命令
save        #将一个或多个镜像保存到tar归档文件（默认流式传输到STDOUT）
search      #在Docker Hub中搜索镜像
service     #管理Docker服务
start       #启动一个或多个停止的容器
stats      #信息显示容器资源使用的实时统计信息
stop      #停止一个或多个运行容器
swarm     #管理Docker Swarm
tag       #将镜像标记到存储库中
top       #显示容器的运行过程
unpause   #暂停取消暂停一个或多个容器内的所有进程
update    #更新一个或多个容器的配置
version   #显示Docker版本信息
volume    #管理Docker卷
wait      #阻塞直到容器停止，然后打印其退出代码

#对单个子命令执行help可以查看此子命令的详细用法，如下面对rm执行查看：
# docker rm --help
Usage:  docker rm [OPTIONS] CONTAINER [CONTAINER...]
Remove one or more containers
Options:
  -f, --force     Force the removal of a running container (uses SIGKILL)
      --help      Print usage
  -l, --link      Remove the specified link
  -v, --volumes   Remove the volumes associated with the container

run  运行容器
--name 指定容器的名字
-h 指定容器主机名
-i   以交互模式运行容器，通常与 -t 同时使用；
-t  为容器重新分配一个伪输入终端，通常与 -i 同时使用->-it；打算进入bash执行一些命令并查看返回结果，因此需要交互式终端
-d  后台运行容器，并返回容器ID；
-c  后面跟待完成的命令,docker exec xxx /bin/sh -c "aaa --version" # xxx表示容器名,aaa表示可执行文件
-p（小写字母p）映射指定端口，-p 宿主机端口:容器端口【-p 20022:22】 
-P (大写字母P) 映射随机端口
-w /myapp  指定容器的/myapp目录为工作目录
-v 绑定存储卷 -> -v 宿主机目录:容器里面的目录[:ro/rw];只能创建bind mount,实例中的rw为读写，ro为只读
-e 设置环境变量，如：-e mysql_user=root  ->就可以在容器里面或Dockfile里面引用这个变量
--rm 停止容器后，自动删除该容器；如果有挂载卷也会一并删除，建议只在测试时使用
--network 指定网络 [none、host、bridge]
--volumes-from
--dns dns配置
/bin/bash：放在镜像名后是命令，这里是希望是交互式，因此用/bin/bash。需要看容器里的基础镜像支持什么shell
/bin/sh：放在镜像名后是命令，这里是希望是交互式，因此用/bin/sh
pull 拉取（下载）镜像

Usage: docker run [OPTIONS] IMAGE [COMMAND] [ARG...]   

-d, --detach=false         指定容器运行于前台还是后台，默认为false    
-i, --interactive=false    打开STDIN，用于控制台交互   
-t, --tty=false            分配tty设备，该可以支持终端登录，默认为false   
-u, --user=""              指定容器的用户，覆盖容器中内置的账号   
-a, --attach=[]            登录容器（必须是以docker run -d启动的容器） 
-w, --workdir=""           指定容器的工作目录  
-c, --cpu-shares=0         设置容器CPU权重，在CPU共享场景使用   
-e, --env=[]               指定环境变量，容器中可以使用该环境变量   
-m, --memory=""            指定容器的内存上限   
-P, --publish-all=false    指定容器暴露的端口   
-p, --publish=[]           指定容器暴露的端口  
-h, --hostname=""          指定容器的主机名
--add-host list             Add a custom host-to-IP mapping (host:ip) (在多机可以使用--bridge模式部署rabbitmq集群,https://blog.csdn.net/sanduo112/article/details/120074642)  
-v, --volume=[]            给容器挂载存储卷，挂载到容器的某个目录   
--volumes-from=[]          给容器挂载其他容器上的卷，挂载到容器的某个目录 
--cap-add=[]               添加权限，权限清单详见：http://linux.die.net/man/7/capabilities   
--cap-drop=[]              删除权限，权限清单详见：http://linux.die.net/man/7/capabilities   
--cidfile=""               运行容器后，在指定文件中写入容器PID值，一种典型的监控系统用法   
--cpuset=""                设置容器可以使用哪些CPU，此参数可以用来容器独占CPU   
--device=[]                添加主机设备给容器，相当于设备直通   
--dns=[]                   指定容器的dns服务器   
--dns-search=[]            指定容器的dns搜索域名，写入到容器的/etc/resolv.conf文件   
--entrypoint=""            覆盖image的入口点   
--env-file=[]              指定环境变量文件，文件格式为每行一个环境变量   
--expose=[]                指定容器暴露的端口，即修改镜像的暴露端口   
--link=[]       指定容器间的关联，使用其他容器的IP、env等信息   
--lxc-conf=[]   指定容器的配置文件，只有在指定--exec-driver=lxc时使用   
--name=""    指定容器名字，后续可以通过名字进行容器管理，links特性需要使用名字   
--network="bridge"             容器网络设置: 
    bridge 使用docker daemon指定的网桥      
    host    //容器使用主机的网络   
    container:NAME_or_ID  >//使用其他容器的网路，共享IP和PORT等网络资源   
    none 容器使用自己的网络（类似--net=bridge），但是不进行配置  
--privileged=false  指定容器是否为特权容器，特权容器拥有所有的capabilities   
--restart="no"     指定容器停止后的重启策略（ default "no"）
                no：容器退出时不重启   
                on-failure：容器故障退出（返回值非零）时重启  
                always：容器退出时总是重启   
--rm=false    指定容器停止后自动删除容器(不支持以`docker run -d`启动的容器)   
--sig-proxy=true    设置由代理接受并处理信号，但是SIGCHLD、SIGSTOP和SIGKILL不能被代理
--mount mount                    将文件系统挂载到容器上,参数--mount默认情况下用来挂载volume，但也可以用来创建bind mount和tmpfs。如果不指定type选项，则默认为挂载volume，volume是一种更为灵活的数据管理方式，volume可以通过docker volume命令集被管理

docker run --name $CONTAINER_NAME -it \
--mount type=bind,source=$PWD/$CONTAINER_NAME/app,destination=/app \
--mount source=${CONTAINER_NAME}-data,destination=/data,readonly \
avocado-cloud:latest /bin/bash

docker image prune ：删除无用的镜像。
docker container prune ：删除无用的容器。
docker volume prune ：删除无用的卷。
docker network prune ：删除无用的网络。
docker system df ：类似于Linux上的df命令,查看Docker 磁盘使用情况
docker system df -v：查看Docker 磁盘使用情况详情
docker system prune ：可以用于清理磁盘，删除关闭的容器、无用的数据卷和网络，以及dangling镜像(即无tag的镜像)

# docker system prune
WARNING! This will remove:
  - all stopped containers      #删除关闭的容器
  - all networks not used by at least one container     #无用的数据卷和网络
  - all dangling images  #无tag的镜像
  - all dangling build cache     #cache清理

Are you sure you want to continue? [y/N] y


要强制删除可加上 -f 参数

docker system prune -a  (慎用)清理得更加彻底，可以将没有容器使用Docker镜像都删掉。注意，这两个命令会把你暂时关闭的容器，以及暂时没有用到的Docker镜像都删掉了…所以使用之前一定要想清楚.。我没用过，因为会清理没有开启的 Docker镜像

# cat pushimages.sh
#!/bin/bash
RepositoryAddr='dockerhub.koal.com:5000/idaas/'
NewRepositoryAddr='registry.cn-shanghai.aliyuncs.com/mefor/xwarm64'
ImageName=$1
Tag=$2

##set color##
echoRed() { echo $'\e[0;31m'"$1"$'\e[0m'; }
echoGreen() { echo $'\e[0;32m'"$1"$'\e[0m'; }
echoYellow() { echo $'\e[0;33m'"$1"$'\e[0m'; }

function Usage(){
  echoYellow "Usage:"
  echoGreen "  /bin/bash $0 [app/id/gw/sso/pdp/web/all] [version]"
  echoYellow "  for example : $0 app 2.0.0"
  return 0
}

if [[ "$#"q != "2"q ]]
then
  echoRed "input error …………"
  Usage
  exit 6  
fi

#Changing the image name
if [ "${ImageName}"x = 'app'x ] || [[ "${ImageName}"x = 'app-platform-integration'x ]]; then
    ImageName='app-platform-integration'
    NewTagPrefix='app-'
elif [ "$1"x = 'id'x  -o "$1"x = 'id-integration'x ]; then
    ImageName='id-integration'
    NewTagPrefix='id-'
elif [ "$1"x = 'gw'x -o "$1"x = 'gateway'x ]; then
    ImageName='gateway'
    NewTagPrefix='gw-'
elif [ "$1"x = 'sso'x -o "$1"x = 'authn-integration'x ]; then
    ImageName='authn-integration'
    NewTagPrefix='sso-'
elif [ "$1"x = 'pdp'x -o "$1"x = 'policy-services'x ]; then
    ImageName='policy-services'
    NewTagPrefix='pdp-'
elif [ "$1"x = 'web'x -o "$1"x = 'idaas-admin-integration'x ]; then
    ImageName='idaas-admin-integration'
    NewTagPrefix='web-'
elif [ "$1"x = 'all'x ]; then
    AImageName=("app-platform-integration" "id-integration" "gateway" "authn-integration" "policy-services" "idaas-admin-integration")
    #ANewTagPrefix=("app-" "id-" "gw-" "sso-" "pdp-" "web-")
else
    echoRed "Input ImageName Error"
    echoRed "Exit immediately"  && exit 3
fi 

function GoGo() {
    echoYellow "update ${ImageName} images"
    echoYellow "modify tag"
    echoYellow "${RepositoryAddr}${ImageName}:${Tag} ${NewRepositoryAddr}:${NewTagPrefix}${Tag}"
    docker tag ${RepositoryAddr}${ImageName}:${Tag} ${NewRepositoryAddr}:${NewTagPrefix}${Tag} && echoGreen "Succeeded in modifying the tag" || { echoRed "Failed to modify tag" && echoRed "Exit immediately"  && exit 2 
    }
    echoYellow "Push a new image to a new repository"
    echoYellow "${NewRepositoryAddr}:${NewTagPrefix}${Tag}"
    docker push ${NewRepositoryAddr}:${NewTagPrefix}${Tag}
    echoYellow "Delete the mirror of the new tag"
    docker rmi ${NewRepositoryAddr}:${NewTagPrefix}${Tag}
}
case "$ImageName" in 
app|app-platform-integration|id|id-integration|gw|gateway|sso|authn-integration|pdp|policy-services|web|idaas-admin-integration)
    GoGo 2>&1 | tee ./GoGoLog.txt
    ;;
all)
    {
    echoYellow "update all images"
    #echo ${AImageName[*]}
    #echo ${ANewTagPrefix[@]}
    #echo ${!ANewTagPrefix[@]}
    for ImageName in ${AImageName[*]};do
        if [[ "${ImageName}"x = 'app-platform-integration'x ]]; then
            ImageName='app-platform-integration'
            echo "ImageName=$ImageName"
            NewTagPrefix='app-'
            echo "NewTagPrefix=$NewTagPrefix"
            GoGo
        elif [[ "${ImageName}"x = 'id-integration'x ]]; then
            ImageName='id-integration'
            echo "ImageName=$ImageName"
            NewTagPrefix='id-'
            echo "NewTagPrefix=$NewTagPrefix"
            GoGo
        elif [[ "${ImageName}"x = 'gateway'x ]]; then
            ImageName='gateway'
            echo "ImageName=$ImageName"
            NewTagPrefix='gw-'
            echo "NewTagPrefix=$NewTagPrefix"
            GoGo
        elif [[ "${ImageName}"x = 'authn-integration'x ]]; then
            ImageName='authn-integration'
            echo "ImageName=$ImageName"
            NewTagPrefix='sso-'
            echo "NewTagPrefix=$NewTagPrefix"
            GoGo
        elif [[ "${ImageName}"x = 'policy-services'x ]]; then
            ImageName='policy-services'
            echo "ImageName=$ImageName"
            NewTagPrefix='pdp-'
            echo "NewTagPrefix=$NewTagPrefix"
            GoGo
        elif [[ "${ImageName}"x = 'idaas-admin-integration'x ]]; then
            ImageName='idaas-admin-integration'
            echo "ImageName=$ImageName"
            NewTagPrefix='web-'
            echo "NewTagPrefix=$NewTagPrefix"
            GoGo
        else
            echoRed "Error defining mirror name"
            echoRed "Exit immediately"  && exit 3 
        fi
    done
    } 2>&1 | tee ./GoGoLog.txt
    ;;
*)
    echoRed "input error …………"
    Usage
    ;; 
esac

Usage:  docker search [OPTIONS] TERM
从docker hub上搜索符合条件的images

# docker search --help

用法：docker search [OPTIONS] TERM
选项：
-f, --filter value    #根据提供的条件过滤输出（默认[]）
--limit int          #搜索结果的最大数目（默认为25）
--no-index         #不要截断输出
--no-trunc         #不要截断输出
# docker search mysql  #搜索带mysql关键字的镜像

解释：
NAME：image名字
DESCRIPTION：image描述                             
STARS：受欢迎受欢迎程度 
OFFICIAL：是否官方提供，如果OFFICIAL 为[ok] ，说明可以放心使用。

# docker search mysql --filter=stars=5  #仅显示评价为5星以上的镜像
# docker search mysql -f=stars=5
# docker search mysql -f stars=5

语法：docker pull [选项] [Docker Registry 地址[:端口号]/]仓库名[:标签]

具体选项通过docker pull --help命令可以查看。
用法：docker pull [OPTIONS] NAME[:TAG|@DIGEST]
选项：
-a, --all-tags   #下载存储库中的所有标记的镜像
--disable-content-trust  #跳过镜像验证（默认为true）
--help         #打印帮助

      Usage:    docker pull [OPTIONS] NAME[:TAG|@DIGEST]
或者： Usage:  docker image pull [OPTIONS] NAME[:TAG|@DIGEST]

eg：
[root@Docker ~]# docker pull centos #如果报错了，因为网络的问题，那么配置镜像加速,再下载，就可以了。

# docker pull ubuntu   # 下载最新版的ubuntu镜像

把docker.io-centos.tar  镜像上传到linux上
参数：  -i " docker.io-centos.tar  " 指定载入的镜像归档。
[root@haha ~]# docker load -i  /root/docker.io-centos.tar   

[root@haha ~]# docker pull hub.c.163.com/library/tomcat:latest
[root@haha ~]# docker images 
REPOSITORY                     TAG           IMAGE ID            CREATED             SIZE
hub.c.163.com/library/tomcat   latest         72d2be374029        4 months ago        292.4 MB

使用`docker images`命令可以列出本地主机上已有的镜像。
      Usage:  docker image COMMAND
或者： Usage:  docker images [OPTIONS] [REPOSITORY[:TAG]]

# docker images --help
用法：docker images [OPTIONS] [REPOSITORY[:TAG]]
选项：
-a, --all   # 显示所有的镜像，默认只列出最顶层的镜像
    --digests  # 显示摘要
-f, --filter value   # 根据提供的条件过滤输出（默认[]）
    --format string  # 漂亮的打印镜像使用Go模板
    --help           # 打印帮助
    --no-trunc      # 不要截断输出
-q, --quiet        # 只显示镜像ID

eg：
# docker images  # 列出主机上面已有的镜像

eg：
[root@Docker ~]#docker image ls  #列出本地可用镜像。其中 [name] 对镜像名称进行关键词查询。

[root@Docker ~]#docker image ls -a #列出本地所有镜像。包括<none>的镜像

eg：
# docker run -it --rm ubuntu:18.04 bash

[root@Docker ~]#docker system df
TYPE             TOTAL               ACTIVE              SIZE                RECLAIMABLE
Images            6                   3                   620.1MB             449.8MB (72%)
Containers          4                   0                   201.5MB             201.5MB (100%)
Local Volumes       0                   0                   0B                  0B
Build Cache         0                   0                   0B                  0B

[root@Docker ~]#docker image ls -f dangling=true
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
<none>              <none>              03966321a4eb        19 hours ago        318MB

[root@Docker ~]#docker image prune      # 删除无用的镜像
WARNING! This will remove all dangling images.
Are you sure you want to continue? [y/N] y
Total reclaimed space: 0B

[root@localhost ~]# docker image ls -a

[root@localhost ~]# docker image ls ubuntu

[root@localhost ~]# docker image ls ubuntu:18.04

[root@localhost ~]# docker image ls -f since=ubuntu:18.04

[root@localhost ~]# docker image ls -q

[root@localhost ~]# docker image ls -q nginx

[root@localhost ~]# docker image ls --format "{{.ID}}:{{.Repository}}"

[root@localhost ~]# docker image ls --format "table {{.ID}}\t{{.Repository}}\t{{.Tag}}"

语法：docker inspect [OPTIONS] NAME|ID [NAME|ID...]
[root@localhost ~]# docker inspect fb2  <==查看镜像

docker inspect 命令可以查看镜像和容器的详细信息，默认会列出全部信息

# docker inspect --help
用法：docker inspect [OPTIONS] CONTAINER|IMAGE|TASK [CONTAINER|IMAGE|TASK...]
-f, --format  # 可以通过此参数指定输出的模板格式，以便输出特定信息。
-s, --size    # 如果类型是容器，则显示总文件大小
--type        # 回指定类型的JSON（例如镜像，容器或任务）

# docker inspect a2a    #获取ID号镜像的详细信息
[
    {
        "Id": "sha256:a2a15febcdf362f6115e801d37b5e60d6faaeedcb9896155e5fe9d754025be12",
        "RepoTags": [
            "ubuntu:17",
            "ubuntu:latest"
        ],
# 上面是JSON输出信息，内容比较多，只粘贴了部分内容。
# docker inspect -f {{".Architecture"}}  a2a  #可以指定{{".key"}}的形式只显示指定的值
# docker inspect -f {{".Architecture"}}  a2    #当然也可以只截取ID的前一部分

Usage:  docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]
语法：docker tag 原名称:[标签] 新名称:[新标签]
或者：docker tag 原镜像的IMAGE ID 新名称:[新标签]

eg：
[root@localhost ~]# docker image ls

[root@localhost ~]# docker tag centos:latest centos:6
[root@localhost ~]# docker image ls

eg:
# docker tag a2a ubuntu:17  # 指定镜像然后给打个新的标签是ubuntu:17
# docker images

# docker rmi  镜像ID      # 会尝试删除所有指向该镜像的标签，然后删除该镜像文件本身。

# docker rmi ubuntu:17      # 删除掉ubuntu:17的镜像
Untagged: ubuntu:17

# 删除所有镜像：
# docker images -aq | sed 's#\(.*\)#docker image rm \1  --force#g' | bash

docker image rm [选项] <镜像1> [<镜像2> ...]
ps：<镜像> 可以是 镜像短 ID 、 镜像长 ID 、 镜像名 或者 镜像摘要
eg：利用IMAGE ID删除（前提是ID唯一）
[root@haha ~]#docker image rm 9f38484d220f

[root@haha ~]#docker image rm centos:latest

可以使用docker image rm命令
语法：docker image rm [选项] <镜像1> [<镜像2> ……]
其中<镜像>可以是长ID或者短ID、镜像名或者镜像摘要。

[root@localhost ~]# docker image ls

[root@localhost ~]# docker image rm c8e

[root@localhost ~]# docker image ls --digests

[root@localhost ~]# docker image rm $(docker image ls -q redis)

[root@localhost ~]# docker image ls

[root@localhost ~]# docker image rm $(docker image ls -q -f before=redis:latest)

保存 Image 到 tar 包
语法：docker save -o 导出的镜像名.tar  本地镜像名：镜像标签

eg：
# docker save -o /opt/hello-world.tar hello-world:latest  #将镜像存储到本地的/opt目录下名称为hello-world.tar

# ll -h /opt/hello-world.tar
-rw-------. 1 root root 13K Sep 12 14:44 /opt/hello-world.tar

# docker save > /opt/hello-world.tar hello-world:latest     #当然这种方式也是可以的

# docker rmi -f hello-world:latest          #先删除本地镜像，然后进行导入

# docker load -i /opt/hello-world.tar   #载入镜像，-i, --input后面跟要载入的镜像tar包

# docker load < /opt/hello-world.tar   #当然这种方式也是可以的

# docker tag test:latest user/test:latest # 必须先添加新的标签

# docker push user/test:latest

方法1：Push Image To Docker Hub  发布到Docker Hub
1、Signup on docker hub & create repo    注册一个帐号
https://hub.docker.com/
2、Login to docker hub 
Usage:  docker login [OPTIONS] [SERVER]
# docker login -u userabc -p abc123 -e userab@gmail.com     # 登录docker hub
3、Push image to docker hub   # 上传镜像
# docker push centos:httpd
4、Pull image from docker hub   # 下载镜像
# docker pull userabc/centos:httpd     #  用户名/镜像名

[root@localhost ~]# docker tag ubuntu:latest 1014068504/ubuntu:zx 
[root@localhost ~]# docker login

[root@localhost ~]# docker push 1014068504/ubuntu:zx

# docker commit --help  #使用方法如下

用法：docker commit [OPTIONS] CONTAINER_ID [REPOSITORY[:TAG]]
选项：
-a, --author string   #作者的信息，（例如“John Hannibal Smith <hannibal@a-team.com>”）
-c, --change value    #将Dockerfile指令应用于创建的映像（默认[]）
-m, --message string  #提交信息
-p, --pause           #在提交期间暂停容器（默认为true）
#提交保存时，只能选用正在运行的容器（即可以通过docker ps查看到的容器）来制作新的镜像。在指定特定镜像时，直接使用commit命令只是一个临时性的辅助命令，不推荐使用。官网建议通过docker build命令结合Dockerfile创建和管理镜像。


eg：
# docker run ubuntu echo 'hello!I am here!'  #先利用ubuntu镜像创建一个新的容器

# docker ps -a

# docker commit -m "Added a new file" -a "liks docktest" 43347239c263 test # 根据容器的ID提交一个新的镜像，镜像名称为test
sha256:fda92003d38176113e19b32a1710bca3732ba161c575eaa6bc1c765d2272707b

# docker images   # 查看一下现在有点镜像

eg：创建一个安装好apache工具的容器镜像
[root@Docker ~]# docker run -it centos:latest /bin/bash
[root@d632bc7716c1 /]# yum install httpd -y   #在 container 中安装 apache 软件包
[root@d632bc7716c1 /]# exit
exit 


查看 images 列表
[root@Docker ~]# docker images
REPOSITORY                TAG                 IMAGE ID            CREATED             SIZE
centos                    latest              9f38484d220f        6 weeks ago         202MB
注：当前只有一个image centos

根据容器当前状态做一个image镜像：创建一个安装了apache工具的centos镜像
语法： docker commit <container的ID>或<image_name>
例：
查看容器ID：
[root@Docker ~]# docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED              STATUS                          PORTS               NAMES
d632bc7716c1        centos:latest       "/bin/bash"         5 minutes ago        Exited (0) 2 minutes ago                            kind_vaughan

[root@Docker ~]# docker commit d632bc7716c1 centos:Apache
sha256:03966321a4eb63aae5992742427cf945119f3ba2c3f6dcf115b293c1b95dbaff

[root@Docker ~]# docker images 
REPOSITORY                TAG                 IMAGE ID            CREATED             SIZE
centos                    Apache              03966321a4eb        55 seconds ago      318MB
centos                    latest              9f38484d220f        6 weeks ago         202MB

使用新创建的centos:Apache镜像，生成一台容器实例：
镜像，生成一台容器实例：
[root@Docker ~]# docker run -it centos:apache /bin/bash
[root@8b1afc920454 /]# rpm -qa httpd    #查看，已经安装好apache命令
httpd-2.4.6-88.el7.centos.x86_64

[root@Docker ~]# wget https://download.openvz.org/template/precreated/ubuntu-14.04-x86.tar.gz
--2019-05-06 10:01:46--  https://download.openvz.org/template/precreated/ubuntu-14.04-x86.tar.gz
Resolving download.openvz.org (download.openvz.org)... 185.231.241.69
Connecting to download.openvz.org (download.openvz.org)|185.231.241.69|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 151788867 (145M) [application/x-gzip]
Saving to: ‘ubuntu-14.04-x86.tar.gz’

100%[=================================================================>] 151,788,867 2.41MB/s   in 76s

2019-05-06 10:03:08 (1.89 MB/s) - ‘ubuntu-14.04-x86.tar.gz’ saved [151788867/151788867]

[root@Docker ~]# ls
anaconda-ks.cfg  original-ks.cfg  ubuntu-14.04-x86.tar.gz
[root@Docker ~]# cat ubuntu-14.04-x86.tar.gz | docker
docker        dockerd       dockerd-ce    docker-init   docker-proxy
[root@Docker ~]# cat ubuntu-14.04-x86.tar.gz | docker import - test:ubuntu-14.04      #必须有这个横杠
sha256:7da8a58a99a17ae7d752bb7dee8e683460b9a459c2f10bea8c44732e18c273cd

导入操作完成后，会返回生成镜像的ID信息。
 [root@Docker ~]# docker images | grep ubunt
test                      ubuntu-14.04        7da8a58a99a1        3 minutes ago       405MB

# docker build --help
用法：Usage:  docker build [OPTIONS] PATH | URL | -
选项：
    --build-arg value   #设置构建时间变量（默认[]）
    --cgroup-parent string   #容器的可选父cgroup
    --cpu-period int       #限制CPU CFS（完全公平调度程序）周期
    --cpu-quota int      #限制CPU CFS（完全公平调度程序）配额
-c, --cpu-shares int      #CPU份额（相对权重）
    --cpuset-cpus string  #在其中允许执行的CPU（0-3,0,1）
    --cpuset-mems string  #允许执行的MEM（0-3,0,1）
    --disable-content-trust   #跳过镜像验证（默认为true）
 -f, --file string     #指定Dockerfile的名称（默认是'PATH/Dockerfile'） 
     --force-rm       #始终删除中间容器
     --help     #打印用法
     --isolation string   #容器隔离技术
     --label value   #设置镜像的元数据（默认[]）
 -m, --memory string      #内存限制
     --memory-swap string  #交换限制等于内存加交换：'-1'以启用无限交换
     --network string     #将容器连接到网络（默认“默认”）
     --no-cache     #构建镜像时不要使用缓存
     --pull  #始终尝试拉取图像的较新版本
 -q, --quiet     #取消构建输出并成功打印镜像ID
     --rm     #成功构建后移除中间容器（默认为true）
     --shm-size string   #/dev/shm的大小，默认值是64MB
 -t, --tag value     #以“名称:标记”格式命名（可选）标记（默认为[]）
     --ulimit value   #Ulimit选项（默认[]）
 -v, --volume value     #设置构建时绑定挂载（默认[]）

eg:
docker build -t 仓库名/镜像名:镜像tag ./

# docker pull centos:7.2.1511
# docker images centos   # 上面pull完毕之后，查看一下本地的镜像，可以看到多有镜像

# cat /docker/dockerfile/base/Dockerfile        #编写Dockerfile文件
FROM centos:7.2.1511
MAINTAINER The Base CentOS7.2 Project <test.com>
RUN curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo \
    && yum install -y net-tools gcc gcc-c++ wget \
    && yum install -y lrzsz openssh-server openssh-clients \
    && wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
CMD /bin/bash

# 创建一个basecentos的镜像，tag是7.2，然后去/docker/dockerfile/base/目录下找Dockerfile
# docker build -t basecentos:7.2  /docker/dockerfile/base/   

# docker images  basecentos

[root@Docker ~]# docker run --rm -it basecentos:7.2 /bin/bash
[root@b1a579927fbc /]# rpm -qa openssh-server

FROM [--platform=<platform>] <image> [AS <name>]
FROM [--platform=<platform>] <image>[:<tag>] [AS <name>]
FROM [--platform=<platform>] <image>[@<digest>] [AS <name>]

Syntax
LABEL <key>=<value> <key>=<value> <key>=<value> ...

一个Dockerfile种可以有多个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"

shell 格式： RUN <命令> ，就像直接在命令行中输入的命令一样。刚才写的 Dockerfile 中的 RUN 指令就是这种格式。RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html
exec 格式： RUN ["可执行文件", "参数1", "参数2"]，这更像是函数调用中的格式。

FROM debian:jessie
RUN apt-get update
RUN apt-get install -y gcc libc6-dev make
RUN wget -O redis.tar.gz "http://download.redis.io/releases/redis-3.2.5.tar.gz"
RUN mkdir -p /usr/src/redis
RUN tar -xzf redis.tar.gz -C /usr/src/redis --strip-components=1
RUN make -C /usr/src/redis
RUN make -C /usr/src/redis install

FROM debian:jessie
RUN buildDeps='gcc libc6-dev make' \
    && apt-get update \
    && apt-get install -y $buildDeps \
    && wget -O redis.tar.gz "http://download.redis.io/releases/redis-3.2.5.tar.gz" \
    && mkdir -p /usr/src/redis \
    && tar -xzf redis.tar.gz -C /usr/src/redis --strip-components=1 \
    && make -C /usr/src/redis \
    && make -C /usr/src/redis install \
    && rm -rf /var/lib/apt/lists/* \
    && rm redis.tar.gz \
    && rm -r /usr/src/redis \
    && apt-get purge -y --auto-remove $buildDeps

  格式为 EXPOSE <端口1> [<端口2>...]。

HTTP_PROXY
http_proxy
HTTPS_PROXY
https_proxy
FTP_PROXY
ftp_proxy
NO_PROXY
no_proxy

ARG 指令有生效范围
1、如果在 FROM 指令之前指定，那么只能用于 FROM 指令中
ARG DOCKER_USERNAME=library
FROM ${DOCKER_USERNAME}/alpine
RUN set -x ; echo ${DOCKER_USERNAME}



2、使用上述 Dockerfile 会发现无法输出 ${DOCKER_USERNAME} 变量的值
要想正常输出，必须在 FROM 之后再次指定 ARG
# 只在 FROM 中生效
ARG DOCKER_USERNAME=library
FROM ${DOCKER_USERNAME}/alpine

# 要想在 FROM 之后使用，必须再次指定
ARG DOCKER_USERNAME=library
RUN set -x ; echo ${DOCKER_USERNAME}

多阶段构建的时候，ARG 定义的变量，每个 FROM 都能用
# 这个变量在每个 FROM 中都生效
ARG DOCKER_USERNAME=library
FROM ${DOCKER_USERNAME}/alpine
RUN set -x ; echo 1
FROM ${DOCKER_USERNAME}/alpine
RUN set -x ; echo 2

格式有两种：
ENV <key> <value>
ENV <key1>=<value1> <key2>=<value2>...
  这个指令很简单，就是设置环境变量而已，无论是后面的其它指令，如 RUN ，还是运行时的应用，都可以直接使用这里定义的环境变量。

ENV VERSION=1.0 DEBUG=on \
    NAME="Happy Feet"

[root@a7cf709f3923 ~]# env

格式：
COPY <源路径>... <目标路径>
COPY ["<源路径1>",... "<目标路径>"]
  和 RUN 指令一样，也有两种格式，一种类似于命令行，一种类似于函数调用。COPY 指令将从构建上下文目录中 <源路径> 的文件/目录复制到新的一层的镜像内的 <目标路径> 位置。比如：

COPY package.json /usr/src/app/
  <源路径> 可以是多个，甚至可以是通配符，其通配符规则要满足 Go 的 filepath.Match 规则，如：

COPY hom* /mydir/
COPY hom?.txt /mydir/

FROM scratch
ADD ubuntu-xenial-core-cloudimg-amd64-root.tar.gz /

格式为 WORKDIR <工作目录路径> 

RUN cd /app
RUN echo "hello" > world.txt

  格式为：
VOLUME ["<路径1>", "<路径2>"...]
VOLUME <路径>

VOLUME /data

docker run -d -v mydata:/data xxxx

  格式： USER <用户名>

RUN groupadd -r redis && useradd -r -g redis redis
USER redis
RUN [ "redis-server" ]

# 建立 redis 用户，并使用 gosu 换另一个用户执行命令
RUN groupadd -r redis && useradd -r -g redis redis
# 下载 gosu
RUN wget -O /usr/local/bin/gosu "https://github.com/tianon/gosu/releases/download/1.7/
gosu-amd64" \
    && chmod +x /usr/local/bin/gosu \
    && gosu nobody true
# 设置 CMD，并以另外的用户执行
CMD [ "exec", "gosu", "redis", "redis-server" ]

  格式：
HEALTHCHECK [选项] CMD <命令> ：设置检查容器健康状况的命令
HEALTHCHECK NONE ：如果基础镜像有健康检查指令，使用这行可以屏蔽掉其健康检查指令
HEALTHCHECK 支持下列选项：
interval=<间隔> ：两次健康检查的间隔，默认为 30 秒；
timeout=<时长> ：健康检查命令运行超时时间，如果超过这个时间，本次健康检查就被视为失败，默认 30 秒；
retries=<次数> ：当连续失败指定次数后，则将容器状态视为 unhealthy ，默认 3 次。

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

CMD后边的命令的返回值决定了本次健康检查是否成功，具体的返回值如下：
0: success - 表示容器是健康的

1: unhealthy - 表示容器已经不能工作了

2: reserved - 保留值

FROM nginx
RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*
HEALTHCHECK --interval=5s --timeout=3s \
    CMD curl -fs http://localhost/ || exit 1

  格式： ONBUILD <其它指令>

CMD 指令的格式和 RUN 相似，也是两种格式：
shell 格式： CMD <命令>
exec 格式： CMD ["可执行文件", "参数1", "参数2"...]

参数列表格式： CMD ["参数1", "参数2"...] 。如果在指定了 ENTRYPOINT 指令后，那么CMD 指定内容将作为参数传入给容器。

  在指令格式上，一般推荐使用 exec 格式，这类格式在解析时会被解析为 JSON 数组，因此一定要使用双引号 " ，而不要使用单引号。

如果使用 shell 格式的话，实际的命令会被包装为 sh -c 的参数的形式进行执行。比如：
CMD echo $HOME
  在实际执行中，会将其变更为：
CMD [ "sh", "-c", "echo $HOME" ]