Docker中仓库、镜像和容器用法详解

1、仓库、镜像和容器之间的关系

2、Docker镜像

        当运行容器时，使用的镜像如果在本地中不存在，docker 就会自动从 docker 镜像仓库中下载，默认是从 Docker Hub 公共镜像源下载，如果不指定版本，默认下载最新的版本。也可以通过配置，使用自定义的镜像仓库。

2.1 查看镜像信息

2.1.1　使用images命令列出镜像

使用 docker images 或者 docker image ls来列出本地主机上的镜像：

docker images
docker image ls

选项说明：

1. REPOSITORY：表示镜像的仓库源
2. TAG：镜像的标签, 同一仓库源可以有多个 TAG，代表这个仓库源的不同个版本
3. IMAGE ID：镜像ID，它唯一的标识了镜像。在使用id时，可以使用该id的前若干个字符组成的可区分串来代替完整的ID。
4. CREATED：镜像创建时间，说明镜像的最后更新时间。
5. SIZE：镜像大小  

2.1.2 使用tag命令添加镜像标签

        使用docker tag命令为本地镜像任意添加新的标签。当TAG为时，直接为该镜像打上标签，若TAG不为时，此时操作相当于复制链接一份。

如：添加一个新的myubuntu:latest镜像：

docker tag ubuntu:18.04 myubuntu:latest

注意：可以注意到ID的相同的，docker tag命令添加的标签实际上起到了类似链接的作用。

如TAG为时：

docker tag d1165f221234 hello-world:old_image

注意：此时直接为该镜像打上了标签。

2.1.3 使用inspect命令查看详细信息

docker inspect ubuntu:18.04

执行结果：

[root@dgw-machine ~]# docker inspect ubuntu:18.04
[
    {
        "Id": "sha256:3941d3b032a8168d53508410a67baad120a563df67a7959565a30a1cb2114731",
        "RepoTags": [
            "myubuntu:latest",
            "ubuntu:18.04"
        ],
        "RepoDigests": [
            "ubuntu@sha256:8aa9c2798215f99544d1ce7439ea9c3a6dfd82de607da1cec3a8a2fae005931b"
        ],
        "Parent": "",
        "Comment": "",
        "Created": "2023-03-08T03:22:44.73196058Z",
        "Container": "ee3fcc8c88d3f3129f1236850de28a7eba0da7c548a7b23a6495905ebcf255ea",
        "ContainerConfig": {
            "Hostname": "ee3fcc8c88d3",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "/bin/sh",
                "-c",
                "#(nop) ",
                "CMD [\"/bin/bash\"]"
            ],
            "Image": "sha256:b64649bc9d1a48300ec5a929146aa3c5ca80046f74c33aa5de65a7046f5177a6",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
                "org.opencontainers.image.ref.name": "ubuntu",
                "org.opencontainers.image.version": "18.04"
            }
        },
        "DockerVersion": "20.10.12",
        "Author": "",
        "Config": {
            "Hostname": "",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "/bin/bash"
            ],
            "Image": "sha256:b64649bc9d1a48300ec5a929146aa3c5ca80046f74c33aa5de65a7046f5177a6",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
                "org.opencontainers.image.ref.name": "ubuntu",
                "org.opencontainers.image.version": "18.04"
            }
        },
        "Architecture": "amd64",
        "Os": "linux",
        "Size": 63146040,
        "VirtualSize": 63146040,
        "GraphDriver": {
            "Data": {
                "MergedDir": "/var/lib/docker/overlay2/16361f3b03baee1bac13d5476160ddb296b800caec61cebd427b24a32b758e42/merged",
                "UpperDir": "/var/lib/docker/overlay2/16361f3b03baee1bac13d5476160ddb296b800caec61cebd427b24a32b758e42/diff",
                "WorkDir": "/var/lib/docker/overlay2/16361f3b03baee1bac13d5476160ddb296b800caec61cebd427b24a32b758e42/work"
            },
            "Name": "overlay2"
        },
        "RootFS": {
            "Type": "layers",
            "Layers": [
                "sha256:b7e0fa7bfe7f9796f1268cca2e65a8bfb1e010277652cee9a9c9d077a83db3c4"
            ]
        },
        "Metadata": {
            "LastTagTime": "2023-05-14T11:50:51.28460608+08:00"
        }
    }
]

上述命令返回的是一个json格式的信息，如果只需要其中某条信息时，可以使用-f指定。

如获取镜像的RootFS：

docker inspect -f {{".RootFS"}} ubuntu:18.04
docker inspect -f {{".RootFS.Type"}} ubuntu:18.04

2.1.4 使用history命令查看镜像历史

docker history ubuntu:18.04

 过长的命令被自动截断了，可以添加--no-trunc命令：

2.2 查找镜像

以查找mysql为例：

2.2.1 通过Docker Hub 进行查找, 比如Docker Hub

2.2.2 使用 docker search 命令来搜索镜像

docker search mysql

参数介绍：

• NAME: 镜像仓库源的名称
• DESCRIPTION: 镜像的描述
• OFFICIAL: 是否 docker 官方发布
• STARS: 类似 Github 里面的 star，表示点赞、喜欢的意思。
• AUTOMATED: 自动构建

支持的命令主要包括：

1. -f，--filter  filter：过滤输出的内容
2. --format string：格式化输出内容
3. --limit int：限制输出的结果个数，默认为25个
4. --no-trunc：不截断输出结果

示例如下：

# 搜索官方提供的
docker search --filter=is-official=true mysql
docker search -f=is-official=true mysql
docker search -f is-official=true mysql

#搜索收藏数超过4的
docker search -f stars=100 mysql

2.3 拉取/获取镜像

使用如下命令：

docker [image] pull NAME[:TAG]

其中：NAME是镜像仓库名称，TAG是镜像的标签。

        对于docker镜像来说，如果不显示指定 TAG，则默认会选择latest标签，这样会下载仓库中最新版本的镜像。

2.3.1 获取mysql镜像

docker pull mysql

2.3.2 获取Ubuntu镜像

docker pull ubuntu:18.04

2.4 删除镜像

sudo docker image rm 镜像名或镜像ID
sudo docker image rm hello-world
sudo docker image rm fce289e99eb9

注意：删除的前提是：这个对象没有创建容器。镜像正在运行时是不能删除的。需要先把容器给stop、删除，然后再删除镜像。

2.4.1 使用标签删除镜像

        使用docker rmi或者docker image rm命令可以删除镜像。

支持的选项：

1. -f，-force：强制删除镜像，即使有容器依赖它
2. -no-prune：不要请理未带标签的父镜像

docker rmi myubuntu:latest

注意：当镜像只剩下一个标签的时候，docker rmi会彻底的删除镜像。

2.4.2 使用ID删除镜像

docker image rm fce289e99eb9

当使用docker rmi ID命令时，会先尝试删除该ID所有指向的镜像标签，然后再删除该镜像本身。

注意：通常不推荐使用-f参数来强制删除一个存在的容器依赖的镜像。正确的做法是先删除依赖该镜像的所有容器，再删除该镜像。

2.4.3 清理镜像

        使用docker 一段时间后，系统中可能会遗留一些临时的镜像文件，以及一些没有使用的镜像，可以通过docker image prune命令来进行清理。

支持的选项包括：

• -a，-all：删除所有无用的镜像，不光是临时镜像
• -filter filter：只清理符合给定过滤器的镜像
• -f，-force：强制删除镜像，而不进行提示确认

如下命令-f会自动清理临时的遗留镜像文件层，最后提示释放的存储空间。

docker image prune -f

docker image prune -a

2.5 更新镜像

        针对ubantu镜像，是否可以在里面安装一些软件，然后再生成一个新的镜像呢？这就需要重新commit出一个新的镜像。

以ubantu镜像为例：

首先run一个ubantu容器，同时在里面进行apt-get update更新操作：

docker run -it ubuntu:latest
apt-get update

2.6 创建镜像

创建镜像主要有三种方法：基于已有镜像的容器创建、基于本地模板导入、基于Dockerfile创建。

2.6.1 基于已有容器创建

命令格式：

docker [container] commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]

主要选项包括：

• -a，--author=""：作者信息
• -c，--change=[]：提交的时候执行Dockerfile指令，包括CMD | ENTRYPOINT|ENV | EXPOSE | LABEL | ONBUILD | USER | VOLUME | WORKDIR等
• -m，--message=""：提交信息
• -p，--pause=true：提交时暂停容器运行

实例操作：

首先下载一个镜像，以Ubuntu最新镜像为例：

然后启动镜像，并在其中进行修改操作：

docker run -it ubuntu:latest /bin/bash

记住容器的id：18db64bd342f，也可以通过下面命令查看：

使用docker commit命令提交一个镜像：

docker commit -m "Added a new file" -a "dgw" 18db64bd342f test:1.0

2.6.2 基于本地模板导入

        可以直接从一个操作系统模板文件中导入一个镜像。

 

注意：

2.6.3 基于Dockerfile创建

2.7 镜像的导出

        可以使用docker save命令将镜像导出到本地文件。

命令参数：

• -o，-output string：导出镜像到指定的文件中。
• >：同 -o 方法。

使用tag导出：

docker save -o ubuntu_18.04.tar ubuntu:latest
docker save > ubuntu_18.04_2.tar ubuntu:latest

使用id导出：

docker save > ubuntu_18.04_3.tar 6b7dfa7e8fdb

之后用户就可以复制.tar文件将镜像分享给别人。

2.8 镜像的导入

使用docker load命令将导出的tar文件再导入到本地镜像库。

支持的参数：

• -i，-input string：从指定文件中读入镜像内容。
• <：同 -i

docker load -i ubuntu_18.04.tar

        这将导入镜像和相关的元数据信息（包括标签等）。导入成功后，可以使用docker images命令进行查看，与原镜像一致。

2.9 上传镜像

        可以使用docker push 命令上传镜像到仓库，默认上传到Docker Hub官方仓库（需要登录）。

3、Docker容器

        在生产环境中，为了提高容器的高可用性和安全性，一方面要合理利用资源限制参数来管理容器的资源消耗；另一方面要指定合适的容器重启策略，来自动重启退出的容器。此外，还可以使用HAProxy等辅助工具来处理负载均衡，自动切换故障的应用容器。

3.1 创建容器

3.1.1 新建容器

        可以使用docker create命令新建一个容器。

docker create -it ubuntu:18.04

注意：使用docker create命令创建的容器处于停止状态，可以使用docker start命令来启动它。

3.1.2 启动容器

        可以使用docker start命令来启动一个已经创建的容器。

docker start id

3.1.3 新建并启动容器

可以使用docker run命令直接新建并启动容器。

docker run等价于先执行docker create命令，再执行docker start命令。

示例：（输出一个hello world，然后容器自动停止）

docker run ubuntu:18.04 /bin/echo "Hello world"

注意：如果镜像不指定版本号，默认是latest，若不存在的话会自动下载。

当利用docker run来创建并启动容器时，Docker在后台运行的标准操作包括：

启动一个bash终端，允许用户进行交互：

docker run -it ubuntu:18.04 /bin/bash

其中：

• -it 可以连写的，表示 -i -t
• -t  选项让Docker分配一个伪终端（pseudo-tty）并绑定到容器的标准输入上，
• -i  测让容器的标准输入保持打开。

在交互式模式下，用户可以通过创建的终端来输入命令：

可以使用Ctrl+d或输入exit命令来退出容器。 

        对于所创建的bash容器，当用户使用exit命令退出bash进程之后，容器也会自动退出。这是因为对于容器来说，当其中的应用退出后，容器的使命完成，也就没有继续运行的必要了。

        可以使用docker  container  wait CONTAINER[CONTAINER....]子命令来等待容器退出，并打印退出返回结果。

        某些时候，执行docker  [container]  run时候因为命令无法正常执行容器会出错直接退出，此时可以查看退出的错误代码。

默认情况下，常见错误代码包括:

• 125: Docker daemon执行出错，例如指定了不支持的Docker命令参数;
• 126:所指定命令无法执行，例如权限出错;
• 127:容器内命令无法找到。

3.1.4 容器重启

使用docker restart命令重启容器。

3.1.5 守护态运行

        大部分时候需要Docker容器以守护态在后台运行，可以添加 -d 来实现。

docker run -d ubuntu:18.04 /bin/bash -c "while true; do echo hello world; sleep 1; done"

3.1.6 查看容器输出

         要获取容器的输出信息，可以使用docker logs命令。

docker logs --help

docker logs -t dbef38912874

3.2 停止容器

3.2.1 暂停容器

        可以使用docker pause 命令来暂停一个运行中的容器。

示例：启动一个容器，然后将其暂停

docker run -d --name test_pause ubuntu:18.04 /bin/bash -c "while true; do echo hello world; sleep 1; done"
docker pause test_pause

处于pause状态的容器，可以使用docker unpause命令来恢复到运行状态：

docker unpause test_pause

3.2.2 终止容器

        使用docker  stop 命令来终止一个正在运行的容器。

        该命令会首先发送SIGTERM信号，等待一段超时时间后（默认是10s），再发送SIGKILL信号来终止容器。

docker stop id

3.2.3 强制停止容器

加上-f之后是可以强制停止容器的。

docker rm -f fcf727bda146

3.2.4 清理停止的容器

执行docker container prune命令，会自动清除掉所有处于停止状态的容器。

docker container prune

还可以使用docker kill 直接发送SIGKILL信号来强行终止容器。

可以使用docker ps -qa命令来查看所有容器的ID。

docker ps -qa

 

可以使用docker start命令启动处于停止状态的容器。

也可以使用docker restart命令重新启动容器。先将一个运行的容器终止，然后再重新启动。

docker restart 67b354e0d141

3.3 进入容器

3.3.1 attach命令

        attach命令是Docker官方自带的命令。

docker run -itd ubuntu:18.04
docker ps
docker attach intelligent_fermi

注意：当多个窗口同时attach到同一个容器的时候，所有窗口都会同步显示;当某个窗口因命令阻塞时，其他窗口也无法执行操作了。

注意：使用docker attach进入时，当使用exit退出时容器也跟着停止了。

3.3.2 exec命令

        可以在运行中容器内直接执行任意命令。

docker exec -it intelligent_fermi /bin/bash

通过指定 -it 参数来保持标准输入打开，并且分配一个伪终端。

注意：当退出容器时，不会导致容器的停止。

3.4 删除容器

        可以使用docker rm 命令来删除处于终止或者退出状态的容器。

        默认情况下，docker rm命令只能删除已经处于终止或退出状态的容器，并不能册删除还处于运行状态的容器。

docker rm practical_jemison

        如果要直接删除一个运行中的容器，可以添加-f参数。Docker会先发送SIGKILL信号给容器,终止其中的应用，之后强行删除。或者也可以先stop容器，然后再rm删除容器。

docker rm -f intelligent_fermi

3.5 导出容器

        可以导出一个已经创建的容器到一个文件中，不管此时这个容器是否处于运行状态。

docker export -o ubuntu_hello_world.tar 0e3f62f364a3
或者
docker export 0e3f62f364a3 > ubuntu_hello_world2.tar

其中，-o选项来指定导出的.tar文件名 ，也可以直接通过重定向来实现。

        之后，就可以将导出的.tar文件传输到别的机器上，然后通过导入命令到系统中，实现容器的迁移。

注意：导出容器的时候，容器无需关闭

3.6 导入容器

        导出的文件可以通过docker import 命令导入变成镜像。

docker import --help

        可以通过-c，--change=[ ]选项在导入的同时执行对容器进行修改的Dockerfile文件。

docker import ubuntu_hello_world.tar test/ubuntu:v1

        docker load命令和docker import命令类似。实际上，既可以使用docker load命令来导入镜像存储文件到本地镜像库，也可以使用docker import 命令来导入一个容器快照到本地镜像仓库。二者的区别：容器快照文件将丢弃所有的历史记录和元数据信息（即仅保留容器当时的快照状态），而镜像存储文件将保存完整记录，体积更大。此外，从容器快照文件导入时可以重新指定标签等元数据信息。

3.7 查看容器

3.7.1 查看启动的容器

• -a 表示all 所有的

# 查看正在运行的容器
sudo docker container ls
# 查看所有的容器
sudo docker container ls --all
docker ps

3.7.2 查看容器详情

        可以使用docker container inspect命令查询详情，会以json格式返回包括容器的id、创建时间、路径、状态、镜像、配置等在内的各项信息。

docker container inspect eloquent_robinson

[root@dgw-machine ~]# docker container inspect eloquent_robinson
[
    {
        "Id": "0e3f62f364a357fae84b577379c67ed78ff485c1a855fa9cee004f8fc0f30ff7",
        "Created": "2023-05-21T05:06:52.230375082Z",
        "Path": "/bin/bash",
        "Args": [
            "-c",
            "while true; do echo hello world; sleep 1; done"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 11785,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2023-05-21T05:06:52.554615834Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:e28a50f651f9eefbc8883ddc64704d609f3d95bf1ea9e41f873a8da68ea5ec98",
        "ResolvConfPath": "/var/lib/docker/containers/0e3f62f364a357fae84b577379c67ed78ff485c1a855fa9cee004f8fc0f30ff7/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/0e3f62f364a357fae84b577379c67ed78ff485c1a855fa9cee004f8fc0f30ff7/hostname",
        "HostsPath": "/var/lib/docker/containers/0e3f62f364a357fae84b577379c67ed78ff485c1a855fa9cee004f8fc0f30ff7/hosts",
        "LogPath": "/var/lib/docker/containers/0e3f62f364a357fae84b577379c67ed78ff485c1a855fa9cee004f8fc0f30ff7/0e3f62f364a357fae84b577379c67ed78ff485c1a855fa9cee004f8fc0f30ff7-json.log",
        "Name": "/eloquent_robinson",
        "RestartCount": 0,
        "Driver": "overlay2",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "",
        "ExecIDs": null,
        "HostConfig": {
            "Binds": null,
            "ContainerIDFile": "",
            "LogConfig": {
                "Type": "json-file",
                "Config": {}
            },
            "NetworkMode": "default",
            "PortBindings": {},
            "RestartPolicy": {
                "Name": "no",
                "MaximumRetryCount": 0
            },
            "AutoRemove": false,
            "VolumeDriver": "",
            "VolumesFrom": null,
            "ConsoleSize": [
                27,
                166
            ],
            "CapAdd": null,
            "CapDrop": null,
            "CgroupnsMode": "host",
            "Dns": [],
            "DnsOptions": [],
            "DnsSearch": [],
            "ExtraHosts": null,
            "GroupAdd": null,
            "IpcMode": "private",
            "Cgroup": "",
            "Links": null,
            "OomScoreAdj": 0,
            "PidMode": "",
            "Privileged": false,
            "PublishAllPorts": false,
            "ReadonlyRootfs": false,
            "SecurityOpt": null,
            "UTSMode": "",
            "UsernsMode": "",
            "ShmSize": 67108864,
            "Runtime": "runc",
            "Isolation": "",
            "CpuShares": 0,
            "Memory": 0,
            "NanoCpus": 0,
            "CgroupParent": "",
            "BlkioWeight": 0,
            "BlkioWeightDevice": [],
            "BlkioDeviceReadBps": [],
            "BlkioDeviceWriteBps": [],
            "BlkioDeviceReadIOps": [],
            "BlkioDeviceWriteIOps": [],
            "CpuPeriod": 0,
            "CpuQuota": 0,
            "CpuRealtimePeriod": 0,
            "CpuRealtimeRuntime": 0,
            "CpusetCpus": "",
            "CpusetMems": "",
            "Devices": [],
            "DeviceCgroupRules": null,
            "DeviceRequests": null,
            "MemoryReservation": 0,
            "MemorySwap": 0,
            "MemorySwappiness": null,
            "OomKillDisable": false,
            "PidsLimit": null,
            "Ulimits": null,
            "CpuCount": 0,
            "CpuPercent": 0,
            "IOMaximumIOps": 0,
            "IOMaximumBandwidth": 0,
            "MaskedPaths": [
                "/proc/asound",
                "/proc/acpi",
                "/proc/kcore",
                "/proc/keys",
                "/proc/latency_stats",
                "/proc/timer_list",
                "/proc/timer_stats",
                "/proc/sched_debug",
                "/proc/scsi",
                "/sys/firmware"
            ],
            "ReadonlyPaths": [
                "/proc/bus",
                "/proc/fs",
                "/proc/irq",
                "/proc/sys",
                "/proc/sysrq-trigger"
            ]
        },
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/255e8f6f55b45d7614bd012fcc0d2f8efdd1a44d3564d5ab0ab90da041867b2c-init/diff:/var/lib/docker/overlay2/d2db9613f837932d77d6dc5a11090e59704626d4358161a1ae364967bde28315/diff",
                "MergedDir": "/var/lib/docker/overlay2/255e8f6f55b45d7614bd012fcc0d2f8efdd1a44d3564d5ab0ab90da041867b2c/merged",
                "UpperDir": "/var/lib/docker/overlay2/255e8f6f55b45d7614bd012fcc0d2f8efdd1a44d3564d5ab0ab90da041867b2c/diff",
                "WorkDir": "/var/lib/docker/overlay2/255e8f6f55b45d7614bd012fcc0d2f8efdd1a44d3564d5ab0ab90da041867b2c/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "0e3f62f364a3",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "/bin/bash",
                "-c",
                "while true; do echo hello world; sleep 1; done"
            ],
            "Image": "ubuntu:18.04",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {}
        },
        "NetworkSettings": {
            "Bridge": "",
            "SandboxID": "11f5f2a64705ba6ef8419547bb0bbb3aacba5a68288de1b1ad2e092656484ca6",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/11f5f2a64705",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "2a6e6d63a0ff4d1cbfa4da9ad5353c7cc32acf7e5015a064f6b5d40c82472922",
            "Gateway": "172.17.0.1",
            "GlobalIPv6Address": "",
            "GlobalIPv6PrefixLen": 0,
            "IPAddress": "172.17.0.2",
            "IPPrefixLen": 16,
            "IPv6Gateway": "",
            "MacAddress": "02:42:ac:11:00:02",
            "Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "63bc5376b3ecf16d0d60b4952199d183cd553485dfebe9de3b65927f9e98b28c",
                    "EndpointID": "2a6e6d63a0ff4d1cbfa4da9ad5353c7cc32acf7e5015a064f6b5d40c82472922",
                    "Gateway": "172.17.0.1",
                    "IPAddress": "172.17.0.2",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:11:00:02",
                    "DriverOpts": null
                }
            }
        }
    }
]

3.7.3 查看容器内进程

        使用top方法查看容器内进程，类似于Linux系统中的top命令。会打印出容器内的进程信息，包括PID、用户、时间、命令等。

docker top eloquent_robinson

3.7.4 查看统计信息

        使用stats命令查看统计信息，会显示CPU、内存、存储、网络等使用情况的统计信息。

docker stats eloquent_robinson

3.8 复制文件

        container cp命令支持在容器和主机之间复制文件。

 将容器中数据复制到宿主机上：

docker cp eloquent_robinson:/tmp .

将宿主机上数据复制到容器中：

docker cp 111.txt eloquent_robinson:/tmp

3.9 查看容器变更

        docker diff查看容器内文件系统的变更。

docker container diff eloquent_robinson

3.10 查看容器端口映射

        docker port命令可以查看容器的端口映射情况。

docker container port objective_burnell

3.11 更新容器配置

        docker update命令可以更新容器中的一些运行时配置，主要是一些资源限制份额。

3.12 容器别名及操作

docker run -itd --name new_ubuntu new/ubuntu:v2.0.1 /bin/bash

3.13 容器错误日志

例：实时查看docker容器名为user-dgw的最后10行日志
docker logs -f -t --tail 10 user-dgw

例：查看指定时间后的日志，只显示最后100行：
docker logs -f -t --since="2018-02-08" --tail=100 user-dgw

例：查看最近30分钟的日志:
docker logs --since 30m user-dgw

例：查看某时间之后的日志：
docker logs -t --since="2018-02-08T13:23:37" user-dgw

例：查看某时间段日志：
docker logs -t --since="2018-02-08T13:23:37" --until "2018-02-09T12:23:37" user-dgw

例：将错误日志写入文件：
docker logs -f -t --since="2018-02-18" user-dgw | grep error >> logs_error.txt

4、Docker仓库

仓库（Repository）是集中存放镜像的地方。

• 可以采用共有的仓库，也可以自己搭建Docker Registry;
• 如果之前有自己的Artifactory或者Nexus，它们同样可以支持Docker Registry功能;
• 带界面的也可以使用Harbor等

4.1公共镜像Docker Hub

注册官方docker hub：Docker Hub

本人注册名称为：dgwdocker

4.1.1 登录：

        可以通过docker login命令输入用户名、密码和邮箱来完成注册和登录。注册成功后，本地用户目录下会自动创建.docker/config.json文件，保存用户的认证信息。

        登录成功后用户可以上传个人制作的镜像到Docker Hub。

4.1.2 镜像准备：

4.1.3 将镜像推送至Docke Hub服务器：

4.2 第三方镜像市场

4.2.1 查看镜像

如时速云：https://tenxcloud.com/

时速云官方仓库中的镜像会保持与DockerHub中官方镜像的同步。

4.2.2 下载镜像

下载镜像同样是使用docker pull命令，但是要在前面添加服务器的地址。

略

4.3 搭建本地私有仓库

4.3.1 使用registry镜像创建私有仓库

官方提供了registry镜像来简单搭建一套本地私有仓库环境。

docker run -d -p 5000:5000 registry:2

 这将自动下载并启动一个registry容器，创建本地的私有仓库服务。

此时，在本地启动了一个私有仓库服务，监听端口为5000。

4.3.2 管理私有仓库

略