容器生命周期管理
run - 创建并启动一个新的容器。
语法
docker run [OPTIONS] IMAGE [COMMAND] [ARG...] 常用参数说明
-d: 后台运行容器并返回容器 ID。
-it: 交互式运行容器，分配一个伪终端。
--name: 给容器指定一个名称。
-p: 端口映射，格式为 host_port:container_port。
-v: 挂载卷，格式为 host_dir:container_dir。
--rm: 容器停止后自动删除容器。
--env 或 -e: 设置环境变量。
--network: 指定容器的网络模式。
--restart: 容器的重启策略（如 no、on-failure、always、unless-stopped）。
-u: 指定用户。
实例
1.基本使用
docker run ubuntu
拉取 ubuntu 镜像并在前台启动一个容器。
2.后台运行容器
docker run -d ubuntu
在后台运行 ubuntu 容器并返回容器 ID。
3. 交互式运行并分配终端
docker run -it ubuntu /bin/bash
以交互模式运行 ubuntu 容器，并启动一个 Bash shell。
4.指定容器名称
docker run --name my_container ubuntu
运行一个 ubuntu 容器，并将其命名为 my_container。
5.端口映射
docker run -p 8080:80 nginx
将本地主机的 8080 端口映射到容器内的 80 端口，运行 nginx 容器。
6.挂载卷
docker run -v /host/data:/container/data ubuntu
将主机的 /host/data 目录挂载到容器内的 /container/data 目录。
7.设置环境变量
docker run -e MY_ENV_VAR=my_value ubuntu
设置环境变量 MY_ENV_VAR 的值为 my_value，运行 ubuntu 容器。
8.使用网络模式
docker run --network host nginx
使用主机的网络模式运行 nginx 容器。
9.指定重启策略
docker run --restart always nginx
设置容器的重启策略为 always，即使容器停止也会自动重启。
10.指定用户
docker run -u user123 ubuntu
以 user123 用户运行 ubuntu 容器。
11. 组合多个选项
docker run -d -p 8080:80 -v /host/data:/data --name webserver nginx
后台运行一个命名为 webserver 的 nginx 容器，将主机的 8080 端口映射到容器的 80 端口，并将主机的 /host/data 目录挂载到容器的 /data 目录。start/stop/restart - 这些命令主要用于启动、停止和重启容器。
docker start 命令
语法
docker start [OPTIONS] CONTAINER [CONTAINER...]
参数
-a: 附加到容器的标准输入输出流。
-i: 附加并保持标准输入打开。
实例
启动一个容器:
docker start my_container
启动名称为 my_container 的容器。
启动并附加到容器:
docker start -a my_container
启动容器并附加到它的标准输入输出流。
同时启动多个容器:
docker start container1 container2 container3
同时启动 container1、container2 和 container3 容器。
docker stop 命令
语法
docker stop [OPTIONS] CONTAINER [CONTAINER...]
参数
-t, --time: 停止容器之前等待的秒数，默认是 10 秒。
实例
停止一个容器:
docker stop my_container
停止名称为 my_container 的容器。
指定等待时间停止容器:
docker stop -t 30 my_container
等待 30 秒后停止容器。
同时停止多个容器:
docker stop container1 container2 container3
同时停止 container1、container2 和 container3 容器。
docker restart 命令
语法
docker restart [OPTIONS] CONTAINER [CONTAINER...]
参数
-t, --time: 重启容器之前等待的秒数，默认是 10 秒。
实例
重启一个容器:
docker restart my_container
重启名称为 my_container 的容器。
指定等待时间重启容器:
docker restart -t 15 my_container
等待 15 秒后重启容器。
同时重启多个容器:
docker restart container1 container2 container3
同时重启 container1、container2 和 container3 容器。kill - 立即终止一个或多个正在运行的容器
docker kill 命令用于立即终止一个或多个正在运行的容器。
与 docker stop 命令不同，docker kill 命令会直接发送 SIGKILL 信号给容器的主进程，
导致容器立即停止，而不会进行优雅的关闭。
语法
docker kill [OPTIONS] CONTAINER [CONTAINER...]
OPTIONS说明：
-s, --signal: 发送给容器的信号（默认为 SIGKILL）。
常用信号
SIGKILL: 强制终止进程（默认信号）。
SIGTERM: 请求进程终止。
SIGINT: 发送中断信号，通常表示用户请求终止。
SIGHUP: 挂起信号，通常表示终端断开。
实例
立即终止一个容器:
docker kill my_container
立即终止名称为 my_container 的容器。
发送自定义信号:
docker kill -s SIGTERM my_container
向名称为 my_container 的容器发送 SIGTERM 信号，而不是默认的 SIGKILL 信号。
同时终止多个容器:
docker kill container1 container2 container3
立即终止 container1、container2 和 container3 容器。
docker kill 命令用于立即终止一个或多个正在运行的容器，通过发送信号（默认 SIGKILL）给容器的主进程实现。
与 docker stop 不同，docker kill 不会等待容器优雅地停止，而是直接终止进程。该命令在需要快速停止容器时非常有用，但应谨慎使用以避免数据损失或不一致。rm - 于删除一个或多个已经停止的容器。
docker rm 命令用于删除一个或多个已经停止的容器。
docker rm 命令不会删除正在运行的容器，如果你需要先停止容器，可以使用 docker stop 命令。
语法
docker rm [OPTIONS] CONTAINER [CONTAINER...]
CONTAINER [CONTAINER...]: 一个或多个要删除的容器的名称或 ID。
OPTIONS说明：
-f, --force: 强制删除正在运行的容器（使用 SIGKILL 信号）。
-l, --link: 删除指定的连接，而不是容器本身。
-v, --volumes: 删除容器挂载的卷。
删除单个容器：
docker rm <container_id_or_name>
你可以一次性删除多个容器，只需将容器 ID 或名称用空格分隔：
docker rm <container_id_or_name1> <container_id_or_name2> ...
你可以使用以下命令来删除所有已停止的容器：
docker container prune
这个命令会提示你确认删除所有已停止的容器。
实例
假设你有以下两个容器：
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
abcd1234 nginx "nginx -g 'daemon…" 2 minutes ago Exited (0) 1 minute ago my_nginx
efgh5678 redis "redis-server" 3 minutes ago Exited (0) 2 minutes ago my_redis
你可以使用以下命令删除它们：
docker rm abcd1234 efgh5678
或者，你可以使用容器名称删除它们：
docker rm my_nginx my_redis
删除所有已经停止的容器：
docker rm $(docker ps -a -q)pause/unpause - 暂停和恢复容器中的所有进程。
docker pause 命令
docker pause 命令用于暂停一个或多个容器中的所有进程。
语法
docker pause CONTAINER [CONTAINER...]
实例
暂停一个容器：
docker pause my_container
暂停名称为 my_container 的容器中的所有进程。
暂停多个容器：
docker pause container1 container2
同时暂停 container1 和 container2 容器中的所有进程。
docker unpause 命令
docker unpause 命令用于恢复一个或多个已暂停容器中的所有进程。
语法
docker unpause CONTAINER [CONTAINER...]
实例
恢复一个容器：
docker unpause my_container
恢复名称为 my_container 的容器中的所有进程。
恢复多个容器：
docker unpause container1 container2
同时恢复 container1 和 container2 容器中的所有进程。
使用场景
临时暂停活动: 当需要临时暂停容器中的所有活动以进行系统维护或资源管理时，可以使用 docker pause。
资源管理: 在需要重新分配系统资源时，暂停不必要的容器以释放资源。
调试和故障排除: 在调试或故障排除过程中暂停容器以分析当前状态。
总结
docker pause: 用于暂停容器中的所有进程。暂停的容器仍然存在，但其进程将挂起，直到恢复。
docker unpause: 用于恢复已暂停容器中的所有进程，使其恢复正常运行。create - 创建一个新的容器，但不会启动它。
语法
docker create [OPTIONS] IMAGE [COMMAND] [ARG...]
常用参数
--name: 给容器指定一个名称。
-p, --publish: 端口映射，格式为 host_port:container_port。
-v, --volume: 挂载卷，格式为 host_dir:container_dir。
-e, --env: 设置环境变量。
--network: 指定容器的网络模式。
--restart: 容器的重启策略（如 no、on-failure、always、unless-stopped）。
-u, --user: 指定用户。
--entrypoint: 覆盖容器的默认入口点。
--detach: 在后台创建容器。
实例
创建一个容器：
docker create ubuntu
根据 ubuntu 镜像创建一个容器，但不会启动它。
创建并指定容器名称：
docker create --name my_container ubuntu
创建一个名为 my_container 的容器，但不会启动它。
创建并设置环境变量：
docker create -e MY_ENV_VAR=my_value ubuntu
创建一个容器，并设置环境变量 MY_ENV_VAR 的值为 my_value。
创建并挂载卷：
docker create -v /host/data:/container/data ubuntu
创建一个容器，并将主机的 /host/data 目录挂载到容器的 /container/data 目录。
创建并端口映射：
docker create -p 8080:80 nginx
创建一个容器，将本地主机的 8080 端口映射到容器的 80 端口，但不会启动它。
创建并指定重启策略：
docker create --restart always nginx
创建一个容器，并将重启策略设置为 always。
创建并指定用户：
docker create -u user123 ubuntu
创建一个容器，并以 user123 用户运行容器。
查看容器
在创建容器之后，可以使用 docker ps -a 命令查看所有容器，包括已创建但未启动的容器。
docker ps -a
启动已创建的容器
使用 docker start 命令来启动已创建但未启动的容器：
docker start my_container
总结
docker create: 用于创建一个新的容器实例但不启动它。可以通过各种参数设置容器的配置。
docker start: 启动已创建的容器，使其开始运行。
docker create 命令允许用户预先配置容器的设置，并在需要时手动启动容器，这对于自动化部署和测试场景特别有用。exec - 在运行中的容器内执行一个新的命令。
docker exec 命令用于在运行中的容器内执行一个新的命令。这对于调试、运行附加的进程或在容器内部进行管理操作非常有用。
语法
docker exec [OPTIONS] CONTAINER COMMAND [ARG...]
常用参数
-d, --detach: 在后台运行命令。
--detach-keys: 覆盖分离容器的键序列。
-e, --env: 设置环境变量。
--env-file: 从文件中读取环境变量。
-i, --interactive: 保持标准输入打开。
--privileged: 给这个命令额外的权限。
--user, -u: 以指定用户的身份运行命令。
--workdir, -w: 指定命令的工作目录。
-t, --tty: 分配一个伪终端。
实例
在容器内运行命令：
docker exec my_container ls /app
在运行中的 my_container 容器内执行 ls /app 命令，列出 /app 目录的内容。
以交互模式运行命令：
docker exec -it my_container /bin/bash
在运行中的 my_container 容器内启动一个交互式的 Bash shell。-i 保持标准输入打开，-t 分配一个伪终端。
在后台运行命令：
docker exec -d my_container touch /app/newfile.txt
在运行中的 my_container 容器内后台执行 touch /app/newfile.txt 命令，创建一个新文件。
设置环境变量：
docker exec -e MY_ENV_VAR=my_value my_container env
在运行中的 my_container 容器内执行 env 命令，并设置环境变量 MY_ENV_VAR 的值为 my_value。
以指定用户身份运行命令：
docker exec -u user123 my_container whoami
在运行中的 my_container 容器内以 user123 用户身份执行 whoami 命令。
指定工作目录：
docker exec -w /app my_container pwd
在运行中的 my_container 容器内以 /app 目录为工作目录执行 pwd 命令。
使用场景
调试容器: 进入容器内部进行调试和排查问题。
管理任务: 在容器内运行附加的管理任务或维护操作。
监控和检查: 在容器内执行监控和检查命令，获取运行状态和日志。
总结
docker exec 命令是 Docker 中非常强大的工具，允许用户在运行中的容器内执行额外的命令。这对于调试、管理和维护容器非常有用，能够帮助用户更灵活地控制和操作容器内部的环境。rename - 重命名容器。
docker rename 命令用于重命名已存在的容器。该命令允许你在不停止或删除容器的情况下，直接修改容器的名称。
语法
docker rename <当前容器名称或ID> <新容器名称>
常用参数说明：
当前容器名称或ID：需要修改名称的现有容器的名称或者 ID。
新容器名称：将容器重命名为指定的新名称。这个名称必须唯一，不能与其他正在运行的容器冲突。
实例
1、重命名容器
假设有一个正在运行的容器，名称为 my_old_container，并且需要将它重命名为 my_new_container：
docker rename my_old_container my_new_container
执行成功后，容器的名称将变为 my_new_container。你可以通过以下命令确认：
docker ps -a
2、使用容器 ID 重命名
如果你不知道容器的名称，但知道其 ID，可以使用容器的 ID 来重命名。例如：
docker rename 123abc456def my_new_container
同样，123abc456def 是容器的 ID，重命名后可以通过 docker ps -a 查看。
3、检查是否重名
如果你尝试重命名的名称已经被其他容器使用，Docker 会返回错误：
docker rename my_old_container existing_container_name
输出：
Error response from daemon: Conflict. The container name "/existing_container_name" is already in use by container "abc123". You have to remove (or rename) that container to be able to reuse that name.
此时需要先重命名或移除 existing_container_name 的容器，然后再进行操作。容器操作
ps - 列出 Docker 容器
docker ps 命令用于列出 Docker 容器。
默认情况下，docker ps 命令只显示运行中的容器，但也可以通过指定选项来显示所有容器，包括停止的容器。
语法
docker ps [OPTIONS]
OPTIONS说明：
-a, --all: 显示所有容器，包括停止的容器。
-q, --quiet: 只显示容器 ID。
-l, --latest: 显示最近创建的一个容器，包括所有状态。
-n: 显示最近创建的 n 个容器，包括所有状态。
--no-trunc: 不截断输出。
-s, --size: 显示容器的大小。
--filter, -f: 根据条件过滤显示的容器。
--format: 格式化输出。
实例
1、列出所有在运行的容器信息
默认情况下，docker ps 只显示正在运行的容器。
docker ps
CONTAINER ID IMAGE COMMAND ... PORTS NAMES
09b93464c2f7 nginx:latest "nginx -g 'daemon off" ... 80/tcp, 443/tcp myrunoob
96f7f14e99ab mysql:5.6 "docker-entrypoint.sh" ... 0.0.0.0:3306->3306/tcp mymysql
输出详情介绍：
CONTAINER ID: 容器 ID。
IMAGE: 使用的镜像。
COMMAND: 启动容器时运行的命令。
CREATED: 容器的创建时间。
STATUS: 容器状态。
状态有7种：
created（已创建）
restarting（重启中）
running（运行中）
removing（迁移中）
paused（暂停）
exited（停止）
dead（死亡）
PORTS: 容器的端口信息和使用的连接类型（tcp\udp）。
NAMES: 自动分配的容器名称。
2、列出所有容器，包括停止的容器
docker ps -a
显示所有容器，包括停止的容器。
3、只显示容器 ID
docker ps -q
只显示容器 ID。
4、显示最近创建的一个容器
docker ps -l
显示最近创建的一个容器，包括所有状态。
5、显示最近创建的 n 个容器
docker ps -n 3
显示最近创建的 3 个容器，包括所有状态。
6、显示容器的大小
docker ps -s
显示容器的大小。
7、根据条件过滤显示的容器
docker ps -f "status=exited"
显示状态为 exited 的容器。
docker ps -f "name=my_container"
显示名称包含 my_container 的容器。
8、格式化输出
docker ps --format "table {{.ID}}\t{{.Names}}\t{{.Status}}"
以表格形式显示容器的 ID、名称和状态。
常见过滤器
status: 容器状态（如 running、paused、exited）。
name: 容器名称。
id: 容器 ID。
label: 容器标签。
ancestor: 容器镜像。
使用场景
监控容器状态: 实时监控运行中的容器状态和资源使用情况。
调试和管理: 查看所有容器，包括停止的容器，以便进行调试和管理操作。
自动化脚本: 使用过滤器和格式化选项，便于在自动化脚本中获取特定容器信息。inspect - 获取 Docker 对象（容器、镜像、卷、网络等）的详细信息。
docker inspect 命令用于获取 Docker 对象（容器、镜像、卷、网络等）的详细信息。
docker inspect 命令返回 JSON 格式的详细信息，可以帮助用户了解对象的配置和状态。
语法
docker inspect [OPTIONS] NAME|ID [NAME|ID...]
OPTIONS 说明：
-f, --format: 使用 Go 模板语法格式化输出。
--type: 返回指定类型的对象信息（可选类型：container、image、network、volume）。
实例
1、检查容器
docker inspect my_container
返回 my_container 容器的详细信息。
2、检查镜像
docker inspect my_image
返回 my_image 镜像的详细信息。
3、检查卷
docker inspect my_volume
返回 my_volume 卷的详细信息。
4、检查网络
docker inspect my_network
返回 my_network 网络的详细信息。
5、格式化输出
docker inspect --format '{{ .State.Running }}' my_container
返回 my_container 容器的运行状态，格式化输出为布尔值。
6、检查多个对象
docker inspect my_container my_image
返回 my_container 容器和 my_image 镜像的详细信息。
实例输出
容器信息：
docker inspect my_container
输出：
[
{
"Id": "d2f5e3f19a6a",
"Created": "2024-07-23T00:00:00Z",
"Path": "bash",
"Args": [],
"State": {
"Status": "running",
"Running": true,
"Paused": false,
"Restarting": false,
"OOMKilled": false,
"Dead": false,
"Pid": 12345,
"ExitCode": 0,
"Error": "",
"StartedAt": "2024-07-23T00:00:00Z",
"FinishedAt": "0001-01-01T00:00:00Z"
},
"Image": "sha256:abc123",
"ResolvConfPath": "/var/lib/docker/containers/d2f5e3f19a6a/resolv.conf",
"HostnamePath": "/var/lib/docker/containers/d2f5e3f19a6a/hostname",
"HostsPath": "/var/lib/docker/containers/d2f5e3f19a6a/hosts",
"LogPath": "/var/lib/docker/containers/d2f5e3f19a6a/d2f5e3f19a6a-json.log",
"Name": "/my_container",
"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,
"CapAdd": null,
"CapDrop": null,
"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",
"ConsoleSize": [
0,
0
],
"Isolation": "",
"CpuShares": 0,
"Memory": 0,
"NanoCpus": 0,
"CgroupParent": "",
"BlkioWeight": 0,
"BlkioWeightDevice": null,
"BlkioDeviceReadBps": null,
"BlkioDeviceWriteBps": null,
"BlkioDeviceReadIOps": null,
"BlkioDeviceWriteIOps": null,
"CpuPeriod": 0,
"CpuQuota": 0,
"CpuRealtimePeriod": 0,
"CpuRealtimeRuntime": 0,
"CpusetCpus": "",
"CpusetMems": "",
"Devices": null,
"DiskQuota": 0,
"KernelMemory": 0,
"MemoryReservation": 0,
"MemorySwap": 0,
"MemorySwappiness": null,
"OomKillDisable": false,
"PidsLimit": null,
"Ulimits": null,
"CpuCount": 0,
"CpuPercent": 0,
"IOMaximumIOps": 0,
"IOMaximumBandwidth": 0,
"Mounts": [],
"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/l/abc123/diff",
"MergedDir": "/var/lib/docker/overlay2/merged",
"UpperDir": "/var/lib/docker/overlay2/upper",
"WorkDir": "/var/lib/docker/overlay2/work"
},
"Name": "overlay2"
},
"Mounts": [],
"Config": {
"Hostname": "d2f5e3f19a6a",
"Domainname": "",
"User": "",
"AttachStdin": false,
"AttachStdout": false,
"AttachStderr": false,
"ExposedPorts": {},
"Tty": false,
"OpenStdin": false,
"StdinOnce": false,
"Env": [
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
],
"Cmd": [
"bash"
],
"Image": "ubuntu",
"Volumes": null,
"WorkingDir": "",
"Entrypoint": null,
"OnBuild": null,
"Labels": {}
},
"NetworkSettings": {
"Bridge": "",
"SandboxID": "abc123",
"HairpinMode": false,
"LinkLocalIPv6Address": "",
"LinkLocalIPv6PrefixLen": 0,
"Ports": {},
"SandboxKey": "/var/run/docker/netns/abc123",
"SecondaryIPAddresses": null,
"SecondaryIPv6Addresses": null,
"EndpointID": "abc123",
"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": "abc123",
"EndpointID": "abc123",
"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
}
}
}
}
]
使用场景
调试容器: 获取容器的详细配置信息，以便进行调试和排查问题。
查看网络配置: 查看容器的网络配置信息，了解其网络连接状态。
监控资源: 获取容器的资源配置信息和使用情况，便于进行资源管理和监控。
脚本自动化: 在自动化脚本中使用 docker inspect 获取对象的详细信息，以进行后续操作。
docker inspect 命令是 Docker 中非常强大和实用的命令之一，允许用户获取容器、镜像、卷、网络等对象的详细信息。通过使用该命令，用户可以深入了解和管理 Docker 对象的配置和状态，满足各种调试、监控和管理需求。top - 显示指定容器中的正在运行的进程。
docker top 命令用于显示指定容器中的正在运行的进程。
docker top 命令类似于 Linux 中的 top 或 ps 命令，它帮助用户查看容器内的进程信息，便于监控和调试容器内的活动。
语法
docker top [OPTIONS] CONTAINER [ps OPTIONS]
查看容器内的进程:
docker top my_container
这将显示容器 my_container 中所有正在运行的进程。
使用自定义 ps 选项:
docker top my_container -o pid,comm
这将显示容器 my_container 中所有正在运行的进程，并只显示 pid 和 comm 列。
实例
查看容器内的进程：
docker top my_container
示例输出：
UID PID PPID C STIME TTY TIME CMD
root 1725 1708 0 14:02 ? 00:00:00 bash
root 1767 1725 0 14:03 ? 00:00:00 ps
自定义输出：
docker top my_container -o pid,comm
示例输出：
PID COMMAND
1725 bash
1767 ps
常用场景
监控容器内部活动: 通过查看容器内的进程，用户可以监控容器内部正在运行的应用程序和服务。
调试和排查问题: 当容器出现问题时，可以通过 docker top 命令查看容器内的进程，帮助排查问题。
资源管理: 了解容器内的进程和资源使用情况，便于进行资源管理和优化。
docker top 命令是一个有用的工具，帮助用户查看容器内正在运行的进程信息。通过该命令，用户可以监控、调试和管理容器内的活动，确保容器正常运行。attach - 允许用户附加到正在运行的容器并与其交互。
docker attach 命令用于附加到正在运行的 Docker 容器的标准输入、输出和错误输出（stdin、stdout、stderr）。允许用户直接与容器交互，就像与正在运行的进程交互一样。
语法
docker attach [OPTIONS] CONTAINER
常用选项
--detach-keys: 设置一个在容器中分离的键序列（例如，ctrl-c）。
--no-stdin: 不附加标准输入。
--sig-proxy: 当键盘中断时，将信号代理到容器（默认为 true）。
实例
附加到正在运行的容器：
docker attach my_container
附加到名为 my_container 的容器，用户可以直接与容器的标准输入、输出和错误输出交互。
附加到容器并禁用标准输入：
docker attach --no-stdin my_container
附加到 my_container 容器，但不附加标准输入。
设置分离键序列：
docker attach --detach-keys="ctrl-c" my_container
附加到 my_container 容器，并设置 ctrl-c 为分离键序列。
注意事项
如果附加到一个已经附加了其他会话的容器，所有会话将共享相同的标准输入、输出和错误输出。这意味着多个会话中的输出可能会混杂在一起。
使用 docker attach 进行交互时，需要注意正确设置分离键序列，以确保能够安全地分离而不停止容器。
常用场景
调试和故障排除: 直接附加到正在运行的容器进行调试和故障排除。
监控: 实时查看容器内的输出和日志。
交互操作: 需要与容器内的应用程序进行交互时使用。
docker attach 命令是 Docker 中一个有用的命令，允许用户附加到正在运行的容器并与其交互。通过此命令，用户可以实时查看容器的输出，进行调试和故障排除，以及执行其他交互操作。使用适当的选项和分离键序列，可以灵活地管理和控制与容器的交互。events - 获取 Docker 守护进程生成的事件。
docker events 命令用于实时获取 Docker 守护进程生成的事件。
docker events 命令允许用户监控 Docker 容器、镜像、网络和卷的各种操作事件，例如创建、启动、停止、删除等。
语法
docker events [OPTIONS]
OPTIONS说明：
-f, --filter: 根据提供的条件过滤输出。
--format: 使用 Go 模板格式化输出。
--since: 显示从指定时间开始的事件。
--until: 显示直到指定时间的事件。
实例
获取所有事件：
docker events
输出：
2023-07-22T15:04:05.123456789Z container create 123abc456def (image=ubuntu, name=my_container)
2023-07-22T15:04:06.123456789Z container start 123abc456def (image=ubuntu, name=my_container)
2023-07-22T15:04:10.123456789Z container stop 123abc456def (image=ubuntu, name=my_container)
2023-07-22T15:04:11.123456789Z container destroy 123abc456def (image=ubuntu, name=my_container)
过滤事件：
docker events --filter event=stop
以上命令只显示容器停止事件。
输出：
2023-07-22T15:04:10.123456789Z container stop 123abc456def (image=ubuntu, name=my_container)
格式化输出：
docker events --format '{{.Time}} - {{.Type}} - {{.Action}}'
以上命令使用指定格式显示事件。
输出：
2023-07-22T15:04:05.123456789Z - container - create
2023-07-22T15:04:06.123456789Z - container - start
2023-07-22T15:04:10.123456789Z - container - stop
2023-07-22T15:04:11.123456789Z - container - destroy
显示从指定时间开始的事件：
docker events --since "2023-07-22T15:04:05"
以上命令显示从 2023-07-22T15:04:05 开始的事件。
显示直到指定时间的事件：
docker events --until "2023-07-22T16:04:05"
以上命令显示直到 2023-07-22T16:04:05 的事件。logs - 获取和查看容器的日志输出。
docker logs 命令用于获取和查看容器的日志输出。
docker logs 命令非常有用，可以帮助用户调试和监控运行中的容器。
语法
docker logs [OPTIONS] CONTAINER
常用选项：
-f, --follow: 跟随日志输出（类似于 tail -f）。
--since: 从指定时间开始显示日志。
-t, --timestamps: 显示日志时间戳。
--tail: 仅显示日志的最后部分，例如 --tail 10 显示最后 10 行。
--details: 显示提供给日志的额外详细信息。
--until: 显示直到指定时间的日志。
实例
显示容器日志
docker logs my_container
显示名为 my_container 的容器的所有日志，输出内容：
hello world
hello world
hello world
...
跟随日志输出
docker logs -f my_container
持续显示 my_container 的日志输出，输出内容：
hello world
hello world
hello world
...
显示带时间戳的日志
docker logs -t my_container
显示包含时间戳的日志，输出内容：
2023-07-22T15:04:05.123456789Z hello world
2023-07-22T15:04:06.123456789Z hello world
2023-07-22T15:04:07.123456789Z hello world
...
从指定时间开始显示日志
docker logs --since="2023-07-22T15:00:00" my_container
显示 2023-07-22T15:00:00 之后的日志。
显示最后 10 行日志
docker logs --tail 10 my_container
显示 my_container 的最后 10 行日志。
显示额外详细信息的日志
docker logs --details my_container
显示 my_container 的日志，并包含额外详细信息。
显示直到指定时间的日志
docker logs --until="2023-07-22T16:00:00" my_container
显示 2023-07-22T16:00:00 之前的日志。wait - 允许用户等待容器停止并获取其退出代码。
docker wait 命令用于阻塞，直到指定的容器停止运行，然后返回容器的退出代码。
docker wait 命令对于自动化脚本非常有用，因为它可以等待容器完成某项任务，并根据容器的退出状态采取后续操作。
语法
docker wait [OPTIONS] CONTAINER [CONTAINER...]
等待一个容器停止并获取其退出代码:
docker wait my_container
等待多个容器停止并获取它们的退出代码:
docker wait container1 container2
实例
启动一个会立即退出的容器:
docker run --name test_container ubuntu bash -c "exit 5"
使用 docker wait 命令等待容器退出并获取退出代码:
docker wait test_container
输出：
5
此命令等待 test_container 退出，并返回退出代码 5。
启动多个会立即退出的容器:
docker run --name test_container1 ubuntu bash -c "exit 1"
docker run --name test_container2 ubuntu bash -c "exit 2"
使用 docker wait 命令等待多个容器退出并获取它们的退出代码:
docker wait test_container1 test_container2
输出：
1
2
此命令等待 test_container1 和 test_container2 退出，并返回它们的退出代码 1 和 2。
注意事项
docker wait 命令会阻塞直到容器停止，因此在长时间运行的容器上使用时需要注意。
该命令仅返回容器的退出代码，不提供其他关于容器的状态或输出的信息。
docker wait 命令是一个简单但非常有用的工具，允许用户等待容器停止并获取其退出代码。通过该命令，用户可以轻松地在脚本中实现任务同步和自动化操作。使用 docker wait 命令，可以确保在指定的容器完成其任务之前，不会进行任何后续操作。export - 将容器的文件系统导出为 tar 归档文件。
docker export 命令用于将 Docker 容器的文件系统导出为一个 tar 归档文件。
docker export 命令主要用于备份或迁移容器的文件系统，而不包括 Docker 镜像的所有层和元数据。
语法
docker export [OPTIONS] CONTAINER
OPTIONS说明：
-o, --output: 将输出保存到指定文件，而不是输出到标准输出。
导出容器文件系统:
docker export my_container
将名为 my_container 的容器的文件系统导出到标准输出。
将导出文件保存为 tar 文件:
docker export my_container > my_container_backup.tar
将容器 my_container 的文件系统导出并保存到 my_container_backup.tar 文件中。
使用 --output 选项保存导出文件:
sh
docker export -o my_container_backup.tar my_container
将容器 my_container 的文件系统导出并保存到 my_container_backup.tar 文件中。
实例
启动一个容器:
docker run -d --name my_container ubuntu bash -c "echo hello > /hello.txt && sleep 3600"
导出容器的文件系统:
docker export my_container > my_container_backup.tar
查看导出的 tar 文件内容:
tar -tf my_container_backup.tar
输出：
hello.txt
导入文件系统到新的容器:
cat my_container_backup.tar | docker import - my_new_image
注意事项
docker export 只导出容器的文件系统，不包括 Docker 镜像的层、元数据或运行时信息。
如果容器正在运行，导出的文件系统将是容器当前状态的快照。
导出的 tar 文件可能会很大，具体取决于容器的文件系统大小。
docker export 命令是一个有用的工具，用于将容器的文件系统导出为 tar 归档文件。这对于备份、迁移和分析容器的文件系统非常有用。通过使用 --output 选项，用户可以将导出内容保存为指定文件，方便管理和使用。port - 显示容器的端口映射信息。
docker port 命令用于显示容器的端口映射信息，即容器内部的端口如何映射到宿主机的端口。
docker port 命令对于了解容器如何与宿主机网络交互非常有用。
语法
docker port CONTAINER [PRIVATE_PORT[/PROTO]]
CONTAINER: 要查询端口映射的容器的名称或 ID。
PRIVATE_PORT (可选): 容器内部的端口号。
PROTO (可选): 协议类型（tcp 或 udp），默认是 tcp。
查看容器的所有端口映射:
docker port my_container
显示名为 my_container 的容器的所有端口映射信息。
查看特定端口的映射:
docker port my_container 80
显示名为 my_container 的容器内部的端口 80 映射到宿主机的哪个端口。
查看特定端口和协议的映射:
docker port my_container 80/tcp
显示名为 my_container 的容器内部的 TCP 端口 80 映射到宿主机的哪个端口。
实例
启动一个容器并映射端口:
docker run -d -p 8080:80 --name my_container nginx
此命令将 my_container 容器的端口 80 映射到宿主机的端口 8080。
查看容器的端口映射:
docker port my_container
输出：
80/tcp -> 0.0.0.0:8080
显示容器的端口 80 映射到宿主机的 8080 端口。
查看特定端口的映射:
docker port my_container 80
输出：
0.0.0.0:8080
注意事项
docker port 命令仅显示端口映射信息，不会显示容器内部运行的服务的状态或其他信息。
如果容器没有暴露任何端口，或者没有进行端口映射，docker port 命令将不会返回任何信息。
docker port 命令是一个用于查看容器端口映射的工具，帮助用户了解容器的端口如何映射到宿主机。通过使用这个命令，用户可以方便地检查和调试容器的网络配置。stats - 实时显示 Docker 容器的资源使用情况。
docker stats 命令用于实时显示 Docker 容器的资源使用情况，包括 CPU、内存、网络 I/O 和块 I/O。
docker stats 似于 Linux 系统中的 top 命令，但它专门针对 Docker 容器。通过 docker stats，用户可以监控容器的资源使用情况，帮助优化性能和进行故障排除。
语法
docker stats [OPTIONS] [CONTAINER...]
OPTIONS 说明：
--all , -a :显示所有的容器，包括未运行的。
--format :指定返回值的模板文件。
--no-stream :展示当前状态就直接退出了，不再实时更新。
--no-trunc :不截断输出。
显示所有运行的容器的资源使用情况:
docker stats
显示指定容器的资源使用情况:
docker stats my_container
显示所有容器（包括未运行的容器）的资源使用情况:
docker stats --all
只显示一次数据而不是持续刷新:
docker stats --no-stream
使用自定义格式输出:
docker stats --format "table {{.Container}}\t{{.CPUPerc}}\t{{.MemUsage}}"
实例
列出所有在运行的容器信息。
runoob@runoob:~$ docker stats
CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O PIDS
b95a83497c91 awesome_brattain 0.28% 5.629MiB / 1.952GiB 0.28% 916B / 0B 147kB / 0B 9
67b2525d8ad1 foobar 0.00% 1.727MiB / 1.952GiB 0.09% 2.48kB / 0B 4.11MB / 0B 2
e5c383697914 test-1951.1.kay7x1lh1twk9c0oig50sd5tr 0.00% 196KiB / 1.952GiB 0.01% 71.2kB / 0B 770kB / 0B 1
4bda148efbc0 random.1.vnc8on831idyr42slu578u3cr 0.00% 1.672MiB / 1.952GiB 0.08% 110kB / 0B 578kB / 0B 2
输出详情介绍：
CONTAINER ID 与 NAME: 容器 ID 与名称。
CPU % 与 MEM %: 容器使用的 CPU 和内存的百分比。
MEM USAGE / LIMIT: 容器正在使用的总内存，以及允许使用的内存总量。
NET I/O: 容器通过其网络接口发送和接收的数据量。
BLOCK I/O: 容器从主机上的块设备读取和写入的数据量。
PIDs: 容器创建的进程或线程数。
根据容器等 ID 或名称现实信息：
runoob@runoob:~$ docker stats awesome_brattain 67b2525d8ad1
CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O PIDS
b95a83497c91 awesome_brattain 0.28% 5.629MiB / 1.952GiB 0.28% 916B / 0B 147kB / 0B 9
67b2525d8ad1 foobar 0.00% 1.727MiB / 1.952GiB 0.09% 2.48kB / 0B 4.11MB / 0B 2
以 JSON 格式输出：
runoob@runoob:~$ docker stats nginx --no-stream --format "{{ json . }}"
{"BlockIO":"0B / 13.3kB","CPUPerc":"0.03%","Container":"nginx","ID":"ed37317fbf42","MemPerc":"0.24%","MemUsage":"2.352MiB / 982.5MiB","Name":"nginx","NetIO":"539kB / 606kB","PIDs":"2"}
输出指定的信息：
runoob@runoob:~$ docker stats --all --format "table {{.Container}}\t{{.CPUPerc}}\t{{.MemUsage}}" fervent_panini 5acfcb1b4fd1 drunk_visvesvaraya big_heisenberg
{"BlockIO":"0B / 13.3kB","CPUPerc":"0.03%","Container":"nginx","ID":"ed37317fbf42","MemPerc":"0.24%","MemUsage":"2.352MiB / 982.5MiB","Name":"nginx","NetIO":"539kB / 606kB","PIDs":"2"}
CONTAINER CPU % MEM USAGE / LIMIT
fervent_panini 0.00% 56KiB / 15.57GiB
5acfcb1b4fd1 0.07% 32.86MiB / 15.57GiB
drunk_visvesvaraya 0.00% 0B / 0B
big_heisenberg 0.00% 0B / 0B
常用场景
实时监控: 实时查看容器的资源使用情况，以便进行性能监控和优化。
故障排除: 在容器出现问题时，检查资源使用情况，帮助排查问题根源。
资源管理: 监控容器的资源使用情况，确保资源分配合理，避免资源浪费或瓶颈。
docker stats 命令是一个强大的工具，用于实时监控 Docker 容器的资源使用情况。通过该命令，用户可以获取容器的 CPU、内存、网络 I/O 和块 I/O 的详细信息，帮助进行性能优化、故障排除和资源管理。容器的root文件系统（rootfs）命令
commit - 允许用户将容器的当前状态保存为新的 Docker 镜像。
docker commit 命令用于将容器的当前状态保存为一个新的 Docker 镜像。
docker commit 命令通常用于创建镜像来保存容器的状态，以便在将来可以重用或分发该镜像。
语法
docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]
OPTIONS说明：
-a :提交的镜像作者。
-c :使用 Dockerfile 指令来创建镜像。
-m :提交时的说明文字。
-p :提交镜像前暂停容器（默认为 true）。
将容器保存为新镜像:
docker commit my_container my_new_image
将名为 my_container 的容器保存为一个名为 my_new_image 的新镜像。
指定标签:
docker commit my_container my_new_image:latest
将容器保存为带有 latest 标签的镜像。
添加作者信息和提交信息:
docker commit -a "John Doe" -m "Added new features" my_container my_new_image
将容器保存为新镜像，并添加作者信息和提交信息。
在不暂停容器的情况下提交镜像:
docker commit --pause=false my_container my_new_image
在不暂停容器的情况下，将其保存为新镜像。
实例
启动一个容器:
docker run -d -it --name my_container ubuntu bash
进行一些更改:
docker exec my_container apt-get update
docker exec my_container apt-get install -y nginx
提交容器为新镜像:
docker commit -a "Your Name" -m "Installed nginx" my_container my_new_image
查看新镜像:
docker images
常用场景
保存工作进度: 在开发或测试过程中，将容器的当前状态保存为镜像，以便稍后可以恢复。
创建基础镜像: 为特定应用程序或环境配置创建自定义基础镜像。
分发配置: 将特定配置或应用程序状态保存为镜像，以便分发给其他团队成员或在不同环境中使用。
docker commit 命令是一个强大的工具，允许用户将容器的当前状态保存为新的 Docker 镜像。通过使用该命令，用户可以创建自定义镜像，以便在将来重用或分发。添加适当的作者和提交信息，有助于跟踪镜像的历史和变化。cp - 用于在容器和宿主机之间复制文件或目录。
docker cp 命令用于在 Docker 容器和宿主机之间复制文件或目录。
docker cp 命令支持从容器到宿主机，或从宿主机到容器的文件复制操作。
语法
docker cp [OPTIONS] SRC_PATH CONTAINER:DEST_PATH
docker cp [OPTIONS] CONTAINER:SRC_PATH DEST_PATH
SRC_PATH: 源路径（可以是容器内的路径或宿主机的路径）。
CONTAINER: 容器的名称或 ID。
DEST_PATH: 目标路径（可以是容器内的路径或宿主机的路径）。
从容器复制文件到宿主机
docker cp my_container:/path/in/container /path/on/host
将容器 my_container 内的 /path/in/container 文件或目录复制到宿主机的 /path/on/host。
从宿主机复制文件到容器
docker cp /path/on/host my_container:/path/in/container
将宿主机上的 /path/on/host 文件或目录复制到容器 my_container 内的 /path/in/container。
从容器复制目录到宿主机
docker cp my_container:/path/in/container /path/on/host
将容器内的 /path/in/container 目录及其内容复制到宿主机的 /path/on/host。
从宿主机复制目录到容器
docker cp /path/on/host my_container:/path/in/container
将宿主机上的 /path/on/host 目录及其内容复制到容器 my_container 内的 /path/in/container。
实例
容器复制文件到宿主机
启动一个容器并创建一个文件:
docker run -d --name my_container ubuntu bash -c "echo 'Hello, Docker!' > /hello.txt"
从容器复制文件到宿主机:
docker cp my_container:/hello.txt ./hello.txt
将容器内的 /hello.txt 文件复制到当前宿主机目录下。
查看复制的文件内容:
cat hello.txt
输出：
Hello, Docker!
从宿主机复制文件到容器
复制一个文件到容器:
docker cp ./hello.txt my_container:/hello.txt
将宿主机上的 hello.txt 文件复制到容器内的 /hello.txt。
进入容器查看文件内容:
docker exec -it my_container cat /hello.txt
输出：
Hello, Docker!
注意事项
docker cp 命令不会修改源文件或目录，它仅进行复制操作。
目标路径必须是有效的路径，且宿主机或容器中应有足够的权限进行写入操作。
在处理大文件或大目录时，复制操作可能需要一些时间。
docker cp 命令是 Docker 提供的一个有用工具，用于在容器和宿主机之间复制文件或目录。这个命令适用于备份、配置更新、日志收集等操作，帮助用户方便地管理和操作容器中的文件。diff - 显示 Docker 容器文件系统的变更。
docker diff 命令用于显示 Docker 容器文件系统的变更。它显示自容器创建以来，文件系统中发生的所有修改，包括添加、删除和修改的文件或目录。
docker diff 命令对于调试和理解容器的文件系统变化非常有用。
语法
docker diff CONTAINER
CONTAINER: 容器的名称或 ID。
docker diff 命令的输出包含以下三种类型的变更：
A: 表示新增的文件或目录。
D: 表示删除的文件或目录。
C: 表示修改过的文件或目录。
查看容器的文件系统变更
docker diff my_container
显示名为 my_container 的容器的文件系统变更。
实例
启动一个容器并修改文件系统:
docker run -d --name my_container ubuntu bash -c "echo 'Hello, Docker!' > /hello.txt && sleep 3600"
查看容器的文件系统变更:
docker diff my_container
输出示例：
A /hello.txt
此输出表示 /hello.txt 文件在容器文件系统中被新增了。
删除容器中的文件:
docker exec my_container rm /hello.txt
再次查看容器的文件系统变更:
docker diff my_container
输出示例：
D /hello.txt
此输出表示 /hello.txt 文件在容器文件系统中被删除了。
注意事项
docker diff 命令仅显示容器的文件系统变化，不显示容器内的其他状态信息（如运行的进程）。
输出信息可能会因容器内文件系统的变化而不断变化，因此应在需要时及时查看。
docker diff 命令是一个强大的工具，用于显示 Docker 容器文件系统的变化。通过使用该命令，用户可以轻松查看和了解容器自创建以来所做的文件系统更改，有助于调试、审计和分析容器的行为。镜像仓库
login/logout - 管理 Docker 客户端与 Docker 注册表的身份验证。
docker login 和 docker logout 命令用于管理 Docker 客户端与 Docker 注册表的身份验证。通过 docker login 命令，用户可以登录到 Docker 注册表，访问和推送镜像；通过 docker logout 命令，用户可以退出登录。
docker login : 登陆到 一个Docker 镜像仓库，如果未指定镜像仓库地址，默认为官方仓库 Docker Hub
docker logout : 登出一个D ocker 镜像仓库，如果未指定镜像仓库地址，默认为官方仓库 Docker Hub
docker login
docker login 命令用于登录到 Docker 注册表。
默认情况下，它登录到 Docker Hub，但也可以登录到其他 Docker 注册表。
语法
docker login [OPTIONS] [SERVER]
SERVER: Docker 注册表的服务器地址（默认是 Docker Hub）。
-u, --username: 登录用户名。
-p, --password: 登录密码（不推荐在命令行使用）。
--password-stdin: 从标准输入读取密码。
使用示例
1、登录到 Docker Hub
docker login
提示输入 Docker Hub 用户名和密码。
2、登录到 Docker Hub（指定用户名）
docker login --username myusername
3、提示输入 Docker Hub 密码。
从标准输入读取密码：
echo "mypassword" | docker login --username myusername --password-stdin
从标准输入读取密码，避免在命令行明文输入密码。
4、登录到自定义注册表
docker login myregistry.com
提示输入自定义注册表的用户名和密码。
docker logout
docker logout 命令用于退出当前登录的 Docker 注册表。默认情况下，它退出 Docker Hub，但也可以指定其他注册表。
语法
docker logout [SERVER]
SERVER: Docker 注册表的服务器地址（默认是 Docker Hub）。
使用示例
1、退出 Docker Hub
docker logout
退出当前用户在 Docker Hub 的登录状态。
2、退出自定义注册表
docker logout myregistry.com
退出当前用户在 myregistry.com 的登录状态。
操作实例
1、登录 Docker Hub
docker login
输出：
Username: myusername
Password:
Login Succeeded
2、从标准输入读取密码登录 Docker Hub
echo "mypassword" | docker login --username myusername --password-stdin
输出：
Login Succeeded
3、登录自定义注册表
docker login myregistry.com
输出：
Username: myusername
Password:
Login Succeeded
4、退出 Docker Hub
docker logout
输出：
Removing login credentials for https://index.docker.io/v1/
5、退出自定义注册表
docker logout myregistry.com
输出：
Removing login credentials for myregistry.com
注意事项
不推荐在命令行直接使用 -p 选项输入密码，因为这样密码会以明文形式暴露在命令历史记录中。
使用 --password-stdin 可以避免密码明文暴露，增强安全性。
确保在公共或共享环境中执行 docker logout，以防止其他用户访问您的账户。pull - 从 Docker 注册表（例如 Docker Hub）中拉取（下载）镜像到本地。
docker pull 命令用于从 Docker 注册表（例如 Docker Hub）中拉取（下载）镜像到本地。
docker pull 命令允许用户获取所需的镜像以便在本地运行容器。
语法
docker pull [OPTIONS] NAME[:TAG|@DIGEST]
NAME: 镜像名称，通常包含注册表地址（如 docker.io/library/ubuntu）。
TAG（可选）: 镜像标签，默认为 latest。
DIGEST（可选）: 镜像的 SHA256 摘要。
常用选项：
--all-tags, -a: 下载指定镜像的所有标签。
--disable-content-trust: 跳过镜像签名验证。
1、拉取默认标签（latest）的镜像
docker pull ubuntu
这会从 Docker Hub 拉取名为 ubuntu 的镜像，标签默认为 latest。
2、拉取特定标签的镜像
docker pull ubuntu:20.04
这会从 Docker Hub 拉取名为 ubuntu 的镜像，标签为 20.04。
3、拉取特定摘要的镜像
docker pull ubuntu@sha256:12345abcdef...
这会拉取具有特定 SHA256 摘要的 ubuntu 镜像。
4、拉取所有标签的镜像
docker pull --all-tags ubuntu
这会拉取 ubuntu 镜像的所有可用标签。
5、从自定义注册表拉取镜像
docker pull myregistry.com/myrepo/myimage:mytag
这会从 myregistry.com 注册表中拉取 myrepo 仓库中的 myimage 镜像，标签为 mytag。
实例
1、拉取 Ubuntu 镜像：
docker pull ubuntu
输出示例：
Using default tag: latest
latest: Pulling from library/ubuntu
Digest: sha256:12345abcdef...
Status: Downloaded newer image for ubuntu:latest
docker.io/library/ubuntu:latest
2、拉取指定标签的 Ubuntu 镜像
docker pull ubuntu:20.04
输出示例：
20.04: Pulling from library/ubuntu
Digest: sha256:67890abcdef...
Status: Downloaded newer image for ubuntu:20.04
docker.io/library/ubuntu:20.04
注意事项
默认标签为 latest，但最好显式指定标签以避免拉取意外的版本。
确保有足够的磁盘空间来存储拉取的镜像。
在生产环境中，建议使用镜像的摘要（digest）以确保镜像的唯一性和一致性。
docker pull 命令是获取 Docker 镜像的基本工具，通过指定镜像名称、标签或摘要，可以从 Docker 注册表中下载所需的镜像。push - 将本地构建的 Docker 镜像推送（上传）到 Docker 注册表（如 Docker Hub 或私有注册表）。
docker push 命令用于将本地构建的 Docker 镜像推送（上传）到 Docker 注册表（如 Docker Hub 或私有注册表）。这使得镜像可以在其他系统或环境中共享和使用。
语法
docker push [OPTIONS] NAME[:TAG]
NAME: 镜像名称，通常包含注册表地址（如 docker.io/myrepo/myimage）。
TAG（可选）: 镜像标签，默认为 latest。
OPTIONS 说明：
--disable-content-trust :忽略镜像的校验,默认开启
1、推送默认标签（latest）的镜像
docker push myrepo/myimage
这会将本地的 myrepo/myimage:latest 镜像推送到 Docker Hub。
2、推送特定标签的镜像
docker push myrepo/myimage:1.0
这会将本地的 myrepo/myimage:1.0 镜像推送到 Docker Hub。
3、推送到自定义注册表
docker push myregistry.com/myrepo/myimage:mytag
这会将本地的 myrepo/myimage:mytag 镜像推送到 myregistry.com 注册表。
实例
推送镜像到 Docker Hub
1、登录到 Docker Hub
docker login
2、构建一个镜像
docker build -t myrepo/myimage:1.0 .
3、推送镜像到 Docker Hub
docker push myrepo/myimage:1.0
输出示例：
The push refers to repository [docker.io/myrepo/myimage]
d1e017099d17: Pushed
1.0: digest: sha256:12345abcdef... size: 1234
推送镜像到自定义注册表
1、登录到自定义注册表
docker login myregistry.com
2、构建一个镜像
docker build -t myregistry.com/myrepo/myimage:mytag .
3、推送镜像到自定义注册表
docker push myregistry.com/myrepo/myimage:mytag
输出示例：
The push refers to repository [myregistry.com/myrepo/myimage]
d1e017099d17: Pushed
mytag: digest: sha256:67890abcdef... size: 5678
注意事项
确保已登录到目标注册表（使用 docker login 命令）。
在推送镜像之前，确保镜像标签正确，并符合注册表的命名规范。
推送操作需要网络连接，镜像大小和网络速度会影响推送时间。
对于私有注册表，确保拥有相应的访问权限和配置信息。
docker push 命令是将本地 Docker 镜像推送到注册表的关键工具，通过使用这个命令，用户可以方便地共享、部署和管理 Docker 镜像。在使用时，确保正确登录和标签设置，以保证镜像能够正确推送到目标注册表。search - 用于在 Docker Hub 或其他注册表中搜索镜像。
docker search 命令用于在 Docker Hub 或其他注册表中搜索镜像。
docker search 命令帮助用户查找和获取所需的镜像，并提供了对搜索结果进行过滤和排序的功能。
语法
docker search [OPTIONS] TERM
TERM: 要搜索的关键字。
常用选项：
--automated :只列出 automated build类型的镜像；
--no-trunc :显示完整的镜像描述；
-f <过滤条件>:列出收藏数不小于指定值的镜像。
1、搜索镜像
docker search ubuntu
这会在 Docker Hub 中搜索包含关键字 ubuntu 的镜像。
2、限制返回的搜索结果数量
docker search --limit 5 ubuntu
这会在 Docker Hub 中搜索包含关键字 ubuntu 的镜像，并只返回前 5 个结果。
3、过滤搜索结果
docker search --filter stars=50 ubuntu
这会在 Docker Hub 中搜索包含关键字 ubuntu 的镜像，并只返回 stars 数不低于 50 的镜像。
4、不截断输出
docker search --no-trunc ubuntu
这会在 Docker Hub 中搜索包含关键字 ubuntu 的镜像，并显示完整的镜像描述。
5、自定义格式输出
docker search --format "{{.Name}}: {{.StarCount}} stars" ubuntu
这会在 Docker Hub 中搜索包含关键字 ubuntu 的镜像，并以指定格式显示镜像名称和 star 数。
实例
1、搜索 Ubuntu 镜像
docker search ubuntu
输出示例：
NAME DESCRIPTION STARS OFFICIAL AUTOMATED
ubuntu Ubuntu is a Debian-based Linux operating sys… 10000 [OK]
dorowu/ubuntu-desktop-lxde-vnc Ubuntu with openssh-server and NoVNC 4000 [OK]
rastasheep/ubuntu-sshd Dockerized SSH service, built on top of offi… 2000 [OK]
参数说明：
NAME: 镜像仓库源的名称
DESCRIPTION: 镜像的描述
OFFICIAL: 是否 docker 官方发布
stars: 类似 Github 里面的 star，表示点赞、喜欢的意思。
AUTOMATED: 自动构建。
2、限制返回结果数量
docker search --limit 3 ubuntu
输出示例：
NAME DESCRIPTION STARS OFFICIAL AUTOMATED
ubuntu Ubuntu is a Debian-based Linux operating sys… 10000 [OK]
dorowu/ubuntu-desktop-lxde-vnc Ubuntu with openssh-server and NoVNC 4000 [OK]
rastasheep/ubuntu-sshd Dockerized SSH service, built on top of offi… 2000 [OK]
3、过滤搜索结果
docker search --filter stars=1000 ubuntu
输出示例：
NAME DESCRIPTION STARS OFFICIAL AUTOMATED
ubuntu Ubuntu is a Debian-based Linux operating sys… 10000 [OK]
dorowu/ubuntu-desktop-lxde-vnc Ubuntu with openssh-server and NoVNC 4000 [OK]
rastasheep/ubuntu-sshd Dockerized SSH service, built on top of offi… 2000 [OK]
4、自定义格式输出
docker search --format "{{.Name}}: {{.StarCount}} stars" ubuntu
输出示例：
ubuntu: 10000 stars
dorowu/ubuntu-desktop-lxde-vnc: 4000 stars
rastasheep/ubuntu-sshd: 2000 stars
注意事项
搜索结果可能包含大量镜像，可以使用过滤和排序选项来精简结果。
确保使用准确的关键字以获取相关结果。
docker search 默认搜索 Docker Hub，若需要搜索其他注册表，需相应配置 Docker 客户端。
docker search 命令是查找 Docker 镜像的重要工具，通过指定关键字和选项，用户可以高效地在 Docker 注册表中搜索和获取所需的镜像。这个命令适用于各种场景，包括查找特定功能的镜像、获取高评分镜像以及自定义结果显示。本地镜像管理
images - 列出本地的 Docker 镜像。
docker images 命令用于列出本地的 Docker 镜像。
通过 docker images 命令，用户可以查看所有已下载或构建的 Docker 镜像的详细信息，如仓库名称、标签、镜像 ID、创建时间和大小。
语法
docker images [OPTIONS] [REPOSITORY[:TAG]]
OPTIONS 说明：
-a, --all: 显示所有镜像（包括中间层镜像）。
--digests: 显示镜像的摘要信息。
-f, --filter: 过滤输出，基于提供的条件。
--format: 使用 Go 模板格式化输出。
--no-trunc: 显示完整的镜像 ID。
-q, --quiet: 只显示镜像 ID。
列出所有本地镜像:
docker images
列出带有摘要信息的镜像:
docker images --digests
列出所有镜像（包括中间层镜像）:
docker images --all
使用过滤条件列出镜像:
docker images --filter "dangling=true"
只显示镜像 ID:
docker images --quiet
使用自定义格式输出:
docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.ID}}\t{{.Size}}"
实例
查看本地镜像列表:
runoob@runoob:~$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
mymysql v1 37af1236adef 5 minutes ago 329 MB
runoob/ubuntu v4 1c06aa18edee 2 days ago 142.1 MB
<none> <none> 5c6e1090e771 2 days ago 165.9 MB
httpd latest ed38aaffef30 11 days ago 195.1 MB
alpine latest 4e38e38c8ce0 2 weeks ago 4.799 MB
mongo 3.2 282fd552add6 3 weeks ago 336.1 MB
redis latest 4465e4bcad80 3 weeks ago 185.7 MB
php 5.6-fpm 025041cd3aa5 3 weeks ago 456.3 MB
python 3.5 045767ddf24a 3 weeks ago 684.1 MB
...
列出本地镜像中 REPOSITORY 为 ubuntu的 镜像列表:
root@runoob:~# docker images ubuntu
REPOSITORY TAG IMAGE ID CREATED SIZE
ubuntu 14.04 90d5884b1ee0 9 weeks ago 188 MB
ubuntu 15.10 4e3b13c8a266 3 months ago 136.3 MB
带有摘要信息的输出:
docker images --digests
输出：
REPOSITORY TAG DIGEST IMAGE ID CREATED SIZE
ubuntu latest sha256:8c53f09a9c6f1e85e10a8ffb649dd9de28b9be4994e792bd96fca152527bba03 2d13d07a40a3 2 weeks ago 72.9MB
nginx stable sha256:1c4f40db5d1c8e5e09d28e501ad167d7c2d91b8908f6f1d9c97d1c67c5f9a69b 5a34e9e5d33b 3 weeks ago 133MB
hello-world latest sha256:feda4427b0b5d9d84545dcb38e736a5226e5bb6228c61b0b6b28cb7483a14b68 feb5d9fea6a5 4 weeks ago 13.3kB
使用过滤条件输出:
docker images --filter "dangling=true"
示例输出：
REPOSITORY TAG IMAGE ID CREATED SIZE
<none> <none> 7db03500db4f 5 weeks ago 65.3MB
自定义格式输出:
docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.ID}}\t{{.Size}}"
输出：
REPOSITORY TAG IMAGE ID SIZE
ubuntu latest 2d13d07a40a3 72.9MB
nginx stable 5a34e9e5d33b 133MB
hello-world latest feb5d9fea6a5 13.3kB
常用场景
管理镜像: 列出本地镜像，了解当前可用的镜像。
过滤镜像: 使用过滤选项查找特定条件的镜像，如悬空镜像（未打标签的镜像）。
镜像 ID 管理: 只获取镜像 ID 以便于后续操作，如删除镜像。
docker images 命令是 Docker 镜像管理中非常基础且重要的命令。通过该命令，用户可以查看本地所有镜像的详细信息，进行镜像的管理和维护。使用各种选项和格式，可以灵活地过滤和格式化输出，以满足不同的管理需求。rmi - 删除不再需要的镜像。
docker rmi 命令用于删除一个或多个 Docker 镜像。
docker rmi 命令对于管理本地存储的镜像非常有用，帮助用户清理不再需要的镜像，释放存储空间。
语法
docker rmi [OPTIONS] IMAGE [IMAGE...]
参数说明：
IMAGE: 要删除的镜像的名称或 ID。可以是镜像名、镜像 ID 或镜像摘要。
OPTIONS: 可选参数，用来控制命令的行为。
常用选项：
-a, --all-tags: 指定仓库名称时，删除该仓库下的所有镜像。
-f, --force: 强制删除镜像，即使该镜像被容器使用。
--help: 打印帮助信息并退出。
--no-prune: 不删除悬空的父镜像。
-q, --quiet: 安静模式，不显示删除镜像的详细信息。
删除单个镜像
docker rmi ubuntu:latest
删除名为 ubuntu 的 latest 标签的镜像。
删除多个镜像
docker rmi ubuntu:latest nginx:latest
删除 ubuntu 和 nginx 的 latest 标签的镜像。
删除镜像的多个标签
docker rmi ubuntu:latest ubuntu:18.04
删除 ubuntu 镜像的 latest 和 18.04 标签。
删除所有标签的镜像
docker rmi -a ubuntu
删除 ubuntu 仓库下的所有镜像。
强制删除镜像
docker rmi -f ubuntu:latest
强制删除 ubuntu 的 latest 标签的镜像，即使它正在被使用。
删除悬空的镜像
docker rmi -d
删除所有没有标签的悬空镜像。
安静模式删除所有镜像
docker rmi -q $(docker images -q)
使用安静模式删除所有镜像，不显示删除的镜像信息。
删除指定仓库的所有镜像
docker rmi -a myrepo
删除 myrepo 仓库下的所有镜像。
删除镜像并保留其子镜像
docker rmi --no-prune ubuntu:latest
删除 ubuntu:latest 镜像，但保留其子镜像。
实例
查看现有镜像：
docker images
输出：
REPOSITORY TAG IMAGE ID CREATED SIZE
my_image latest d1e1b5a3a8a9 3 days ago 128MB
my_image1 latest c3a4f5a3a8b8 4 days ago 256MB
my_image2 latest a9e1d3a7c9b9 5 days ago 512MB
删除一个镜像：
docker rmi my_image
输出：
Untagged: my_image:latest
Deleted: sha256:d1e1b5a3a8a9...
删除多个镜像：
docker rmi my_image1 my_image2
输出：
Untagged: my_image1:latest
Deleted: sha256:c3a4f5a3a8b8...
Untagged: my_image2:latest
Deleted: sha256:a9e1d3a7c9b9...
常用场景
清理无用镜像: 删除不再需要的镜像，以释放存储空间。
镜像管理: 管理和维护本地镜像库，确保只保留需要的镜像。
强制删除: 在镜像被容器使用时，强制删除它们（谨慎使用）。
注意事项
强制删除镜像（使用 -f 选项）时，可能会导致依赖于该镜像的容器无法运行，因此应谨慎使用。
默认情况下，docker rmi 会删除未使用的父镜像，如果不希望这样做，可以使用 --no-prune 选项。
docker rmi 命令是 Docker 镜像管理中非常重要的工具。通过该命令，用户可以删除不再需要的镜像，释放存储空间，并保持本地镜像库的整洁。使用适当的选项，可以灵活地管理镜像的删除过程。tag - 创建本地镜像的别名（tag）。
docker tag 命令用于创建本地镜像的别名（tag），通过为镜像打标签，可以使用更容易记忆的名字或版本号来标识和管理镜像。
语法
docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]
SOURCE_IMAGE[:TAG]: 源镜像名称和标签，标签默认为 latest。
TARGET_IMAGE[:TAG]: 目标镜像名称和标签，标签默认为 latest。
1、为镜像打标签
docker tag myimage:1.0 myrepo/myimage:latest
这会将本地 myimage:1.0 镜像标记为 myrepo/myimage:latest。
2、为镜像打多个标签
docker tag myimage:1.0 myrepo/myimage:stable
docker tag myimage:1.0 myrepo/myimage:v1.0
这会将 myimage:1.0 分别标记为 myrepo/myimage:stable 和 myrepo/myimage:v1.0。
3、为镜像打标签以推送到 Docker Hub
docker tag myimage:1.0 myusername/myimage:1.0
docker push myusername/myimage:1.0
这会将 myimage:1.0 镜像标记为 myusername/myimage:1.0 并推送到 Docker Hub。
实例
为镜像打标签
1、列出本地镜像
docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
myimage 1.0 123456789abc 2 days ago 500MB
2、为镜像打标签
docker tag myimage:1.0 myrepo/myimage:latest
3、验证标签
docker images
输出示例：
REPOSITORY TAG IMAGE ID CREATED SIZE
myimage 1.0 123456789abc 2 days ago 500MB
myrepo/myimage latest 123456789abc 2 days ago 500MB
注意事项
标签只是镜像的别名，不会创建新的镜像层，因此不会占用额外的存储空间。
标签应该简洁且具有描述性，以便于识别和管理镜像版本。
在使用标签时，确保命名符合注册表的命名规范。
docker tag 命令是管理 Docker 镜像的重要工具，通过为镜像打标签，可以方便地标识、管理和发布不同版本的镜像。这个命令适用于各种场景，包括版本管理、镜像发布和镜像复制。在使用时，确保标签命名规范和描述性，以提高镜像管理的效率和可维护性。build - 从 Dockerfile 构建 Docker 镜像。
docker build 命令用于从 Dockerfile 构建 Docker 镜像。
docker build 命令通过读取 Dockerfile 中定义的指令，逐步构建镜像，并将最终结果保存到本地镜像库中。
语法
docker build [OPTIONS] PATH | URL | -
PATH: 包含 Dockerfile 的目录路径或 .（当前目录）。
URL: 指向包含 Dockerfile 的远程存储库地址（如 Git 仓库）。
-: 从标准输入读取 Dockerfile。
常用选项：
-t, --tag: 为构建的镜像指定名称和标签。
-f, --file: 指定 Dockerfile 的路径（默认是 PATH 下的 Dockerfile）。
--build-arg: 设置构建参数。
--no-cache: 不使用缓存层构建镜像。
--rm: 构建成功后删除中间容器（默认开启）。
--force-rm: 无论构建成功与否，一律删除中间容器。
--pull: 始终尝试从注册表拉取最新的基础镜像。
更多选项说明：
--build-arg=[]: 设置构建镜像时的变量。
--cpu-shares: 设置 CPU 使用权重。
--cpu-period: 限制 CPU CFS 周期。
--cpu-quota: 限制 CPU CFS 配额。
--cpuset-cpus: 指定可使用的 CPU ID。
--cpuset-mems: 指定可使用的内存节点 ID。
--disable-content-trust: 忽略内容信任验证（默认启用）。
-f: 指定 Dockerfile 的路径。
--force-rm: 强制在构建过程中删除中间容器。
--isolation: 使用指定的容器隔离技术。
--label=[]: 设置镜像的元数据。
-m: 设置内存的最大值。
--memory-swap: 设置交换空间的最大值（内存 + 交换空间），-1 表示不限制交换空间。
--no-cache: 构建镜像时不使用缓存。
--pull: 尝试拉取基础镜像的最新版本。
--quiet, -q: 安静模式，构建成功后只输出镜像 ID。
--rm: 构建成功后删除中间容器（默认启用）。
--shm-size: 设置 /dev/shm 的大小，默认值为 64M。
--ulimit: 设置 Ulimit 配置。
--squash: 将 Dockerfile 中所有步骤压缩为一层。
--tag, -t: 为镜像指定名称和标签，格式为 name:tag 或 name；可以在一次构建中为一个镜像设置多个标签。
--network: 在构建期间设置 RUN 指令的网络模式，默认值为 default。
1、构建镜像
docker build -t myimage:latest .
这会从当前目录读取 Dockerfile 并构建一个名为 myimage:latest 的镜像。
2、指定 Dockerfile 路径
docker build -f /path/to/Dockerfile -t myimage:latest .
这会从 /path/to/ 目录读取 Dockerfile 并构建一个名为 myimage:latest 的镜像。
3、设置构建参数
docker build --build-arg HTTP_PROXY=http://proxy.example.com -t myimage:latest .
这会在构建过程中使用 HTTP_PROXY 环境变量。
4、不使用缓存层构建镜像
docker build --no-cache -t myimage:latest .
这会在构建镜像时忽略所有缓存层，确保每一步都重新执行。
实例 - 使用 Dockerfile 构建镜像
1、创建 Dockerfile，内容如下：
# Dockerfile 示例
FROM ubuntu:20.04
LABEL maintainer="yourname@example.com"
RUN apt-get update && apt-get install -y nginx
COPY index.html /var/www/html/index.html
CMD ["nginx", "-g", "daemon off;"]
2、构建镜像
docker build -t mynginx:latest .
输出示例：
Sending build context to Docker daemon 3.072kB
Step 1/5 : FROM ubuntu:20.04
20.04: Pulling from library/ubuntu
...
Step 2/5 : LABEL maintainer="yourname@example.com"
...
Step 3/5 : RUN apt-get update && apt-get install -y nginx
...
Step 4/5 : COPY index.html /var/www/html/index.html
...
Step 5/5 : CMD ["nginx", "-g", "daemon off;"]
...
Successfully built 123456789abc
Successfully tagged mynginx:latest
3、验证镜像
docker images
输出示例：
注意事项
REPOSITORY TAG IMAGE ID CREATED SIZE
mynginx latest 123456789abc 10 minutes ago 200MB
确保 Dockerfile 语法正确，并按照顺序执行每一步。
使用 .dockerignore 文件排除不需要的文件和目录，以减少构建上下文的大小。
在生产环境中，尽量使用精简的基础镜像以减小镜像体积和提高安全性。
避免在 Dockerfile 中暴露敏感信息（如密码、密钥）。
docker build 命令是构建 Docker 镜像的核心工具，通过定义清晰的 Dockerfile，可以自动化地构建应用程序的运行环境和依赖。在使用时，确保合理设置选项和优化 Dockerfile，以提高构建效率和镜像质量。history - 查看指定镜像的历史层信息。
docker history 命令用于查看指定镜像的历史层信息，它显示了镜像创建过程中的每一层，包括创建时间、创建者、大小和注释等信息。
语法
docker history [OPTIONS] IMAGE
IMAGE: 要查看历史记录的镜像名称或 ID。
OPTIONS 说明：
-H, --human: 以人类可读的格式显示镜像大小（默认启用）。
--no-trunc: 显示完整的输出，不截断信息。
-q, --quiet: 仅显示镜像 ID。
实例
1、查看镜像历史
docker history myimage:latest
输出示例：
IMAGE CREATED CREATED BY SIZE COMMENT
sha256:123abc456def 2 days ago /bin/sh -c #(nop) CMD ["nginx" "-g" "daemon… 0B
sha256:789ghi012jkl 2 days ago /bin/sh -c #(nop) COPY file:abc123 in /var/… 1.5kB
sha256:345mno678pqr 2 days ago /bin/sh -c apt-get update && apt-get install… 45.3MB
sha256:678stu901vwx 2 days ago /bin/sh -c #(nop) LABEL maintainer=yourname… 0B
sha256:901yza234bcd 2 days ago /bin/sh -c #(nop) FROM ubuntu:20.04 72.9MB
2、显示完整输出
docker history --no-trunc myimage:latest
3、仅显示镜像 ID
docker history -q myimage:latest
输出示例：
sha256:123abc456def
sha256:789ghi012jkl
sha256:345mno678pqr
sha256:678stu901vwx
sha256:901yza234bcd
操作实例
构建一个简单的镜像
1、创建一个 Dockerfile：
# 使用 Ubuntu 作为基础镜像
FROM ubuntu:20.04
# 添加维护者信息
LABEL maintainer="yourname@example.com"
# 更新包列表并安装 Nginx
RUN apt-get update && apt-get install -y nginx
# 复制自定义网页到 Nginx 的默认网页目录
COPY index.html /var/www/html/
# 设置启动时的默认命令
CMD ["nginx", "-g", "daemon off;"]
2、构建镜像：
docker build -t mynginx:latest .
3、查看镜像历史
docker history mynginx:latest
输出示例：
IMAGE CREATED CREATED BY SIZE COMMENT
sha256:123abc456def 1 minute ago /bin/sh -c #(nop) CMD ["nginx" "-g" "daemon… 0B
sha256:789ghi012jkl 1 minute ago /bin/sh -c #(nop) COPY file:abc123 in /var/… 1.5kB
sha256:345mno678pqr 1 minute ago /bin/sh -c apt-get update && apt-get install… 45.3MB
sha256:678stu901vwx 1 minute ago /bin/sh -c #(nop) LABEL maintainer=yourname… 0B
sha256:901yza234bcd 1 minute ago /bin/sh -c #(nop) FROM ubuntu:20.04
注意事项
镜像历史信息包括每一层的创建指令和大小，有助于了解镜像的构建过程和内容。
使用 --no-trunc 选项可以查看完整的创建指令，避免信息截断。
在构建复杂镜像时，通过查看历史记录，可以帮助识别和优化 Dockerfile 中的冗余步骤。
docker history 命令是一个强大的工具，可以帮助开发者和运维人员了解镜像的构建历史和每一层的详细信息。通过查看镜像历史，可以更好地调试、优化和审计 Docker 镜像，确保镜像的高效和安全。save - 将一个或多个 Docker 镜像保存到一个 tar 归档文件中。
docker save 命令用于将一个或多个 Docker 镜像保存到一个 tar 归档文件中，以便在其他环境中分发或备份。
语法
docker save [OPTIONS] IMAGE [IMAGE...]
IMAGE: 要保存的一个或多个镜像名称或 ID。
OPTIONS 说明：
-o, --output: 指定输出文件的路径。
1、保存单个镜像到文件
docker save -o myimage.tar myimage:latest
这将 myimage:latest 镜像保存为 myimage.tar 文件。
2、保存多个镜像到同一个文件
docker save -o multiple_images.tar myimage:latest anotherimage:latest
这将 myimage:latest 和 anotherimage:latest 镜像保存到 multiple_images.tar 文件中。
实例
构建一个示例镜像
1、创建一个 Dockerfile：
# 使用 Ubuntu 作为基础镜像
FROM ubuntu:20.04
# 添加维护者信息
LABEL maintainer="yourname@example.com"
# 更新包列表并安装 Nginx
RUN apt-get update && apt-get install -y nginx
# 复制自定义网页到 Nginx 的默认网页目录
COPY index.html /var/www/html/
# 设置启动时的默认命令
CMD ["nginx", "-g", "daemon off;"]
构建镜像：
docker build -t mynginx:latest .
2、保存镜像到文件
docker save -o mynginx.tar mynginx:latest
这将 mynginx:latest 镜像保存为 mynginx.tar 文件。
3、验证保存的文件
ls -lh mynginx.tar
输出示例：
-rw-r--r-- 1 user user 200M Jul 24 14:00 mynginx.tar
4、加载保存的镜像
要将保存的镜像加载到另一个 Docker 环境中，可以使用 docker load 命令：
docker load -i mynginx.tar
注意事项
保存镜像时，会包含镜像的所有层，因此生成的 tar 文件可能会很大。
如果保存多个镜像到同一个文件中，使用 docker load 命令时会加载所有包含的镜像。
为了减少文件大小，可以在保存前使用 docker image prune 命令清理未使用的镜像和层。
docker save 命令是一个方便的工具，用于将 Docker 镜像保存为 tar 文件，以便于备份、分发和迁移。通过结合 docker load 命令，可以轻松地在不同环境中恢复和使用保存的镜像。load - 从由 docker save 命令生成的 tar 文件中加载 Docker 镜像。
docker load 命令用于从由 docker save 命令生成的 tar 文件中加载 Docker 镜像。它可以将存档中的镜像和所有层加载到 Docker 中，使其可以在新环境中使用。
语法
docker load [OPTIONS]
OPTIONS 说明：
-i, --input: 指定输入文件的路径。
-q, --quiet: 安静模式，减少输出信息。
1、从文件加载镜像
docker load -i myimage.tar
这将从 myimage.tar 文件中加载镜像。
2、从标准输入加载镜像
cat myimage.tar | docker load
这将通过管道从标准输入加载镜像。
实例
1、构建和保存镜像
首先，构建一个示例镜像并保存，创建 Dockerfile：
# 使用 Ubuntu 作为基础镜像
FROM ubuntu:20.04
# 添加维护者信息
LABEL maintainer="yourname@example.com"
# 更新包列表并安装 Nginx
RUN apt-get update && apt-get install -y nginx
# 复制自定义网页到 Nginx 的默认网页目录
COPY index.html /var/www/html/
# 设置启动时的默认命令
CMD ["nginx", "-g", "daemon off;"]
构建镜像：
docker build -t mynginx:latest .
保存镜像到文件：
docker save -o mynginx.tar mynginx:latest
2、加载镜像
从文件加载镜像：
docker load -i mynginx.tar
3、验证加载的镜像
docker images
输出示例：
REPOSITORY TAG IMAGE ID CREATED SIZE
mynginx latest 123abc456def 1 minute ago 200MB
注意事项
加载的镜像包括其所有层和元数据，与保存时的状态完全一致。
使用 docker load 时，所有包含在 tar 文件中的镜像都会被加载。
加载过程中可能需要较长时间，具体取决于镜像的大小和系统性能。
docker load 命令是从保存的 tar 文件中恢复 Docker 镜像的便捷方法。通过结合 docker save 和 docker load，用户可以轻松地在不同环境中备份、分发和迁移 Docker 镜像。import - 从一个 tar 文件或 URL 导入容器快照，从而创建一个新的 Docker 镜像。
docker import 命令用于从一个 tar 文件或 URL 导入容器快照，从而创建一个新的 Docker 镜像。
与 docker load 不同，docker import 可以从容器快照中创建新的镜像，而不需要保留镜像的历史和元数据。
语法
docker import [OPTIONS] file|URL|- [REPOSITORY[:TAG]]
file|URL|-: 输入文件的路径、本地文件或 URL，或者使用 - 从标准输入读取。
[REPOSITORY[:TAG]]: （可选）为导入的镜像指定仓库和标签。
OPTIONS 说明：
-c, --change: 在导入过程中应用 Dockerfile 指令，如 CMD、ENTRYPOINT、ENV 等。
-m, --message: 为导入的镜像添加注释。
1、从本地 tar 文件导入镜像
docker import mycontainer.tar mynewimage:latest
这将从 mycontainer.tar 文件导入镜像，并命名为 mynewimage:latest。
2、从 URL 导入镜像
docker import http://example.com/mycontainer.tar mynewimage:latest
这将从指定的 URL 导入镜像，并命名为 mynewimage:latest。
3、从标准输入导入镜像
cat mycontainer.tar | docker import - mynewimage:latest
这将通过管道从标准输入读取 tar 文件并导入镜像。
4、在导入过程中应用变更
docker import -c "ENV LANG=en_US.UTF-8" -c "CMD /bin/bash" mycontainer.tar mynewimage:latest
这将从 mycontainer.tar 导入镜像，并在过程中设置环境变量 LANG 和命令 CMD。
实例
1、导出容器快照
首先，创建并运行一个容器：
docker run -d --name mycontainer ubuntu:20.04 sleep 3600
导出容器快照：
docker export mycontainer -o mycontainer.tar
2、导入容器快照
从 tar 文件导入镜像：
docker import mycontainer.tar mynewimage:latest
3、验证导入的镜像
docker images
输出示例：
REPOSITORY TAG IMAGE ID CREATED SIZE
mynewimage latest 123abc456def 1 minute ago 72.9MB
4、运行导入的镜像
docker run -it mynewimage:latest /bin/bash
注意事项
docker import 创建的镜像不会保留原始镜像的历史和元数据。
使用 -c 选项可以在导入过程中应用 Dockerfile 指令，从而自定义新镜像的配置。
导入的 tar 文件必须是使用 docker export 创建的容器快照，或者是兼容的其他格式。
docker import 命令是一种从容器快照创建新镜像的灵活方法，适用于迁移、恢复和自定义 Docker 镜像的场景。通过使用 docker import，用户可以轻松地从容器快照生成新的镜像，并在导入过程中应用额外的配置。info|version
info - 显示 Docker 的系统级信息，包括当前的镜像和容器数量。
docker info 命令用于显示 Docker 系统的详细信息，包括 Docker 版本、存储驱动、镜像数量、容器数量以及其他重要的配置信息。
docker info 命令非常有用，可以帮助用户了解 Docker 环境的总体状态。
语法
docker info [OPTIONS]
实例
查看docker系统信息。
$ docker info
Client:
Context: default
Debug Mode: false
Plugins:
buildx: Docker Buildx (Docker Inc., 0.8.1)
compose: Docker Compose (Docker Inc., 2.3.3)
Server:
Containers: 3
Running: 1
Paused: 0
Stopped: 2
Images: 10
Server Version: 20.10.7
Storage Driver: overlay2
Backing Filesystem: extfs
Supports d_type: true
Native Overlay Diff: true
Logging Driver: json-file
Cgroup Driver: cgroupfs
Cgroup Version: 1
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: d71fcd7d8303cbf684402823e425e9dd2e99285d
runc version: b9ee9c6314599f1b4a7f497e1f1f856fe433d3b7
init version: de40ad0
Security Options:
seccomp
Profile: default
selinux
Kernel Version: 5.10.25-linuxkit
Operating System: Docker Desktop
OSType: linux
Architecture: x86_64
CPUs: 2
Total Memory: 1.942GiB
Name: docker-desktop
ID: 3WZ2:ZQ7K:6K4E:6ZCR:YITZ:GH2S:6NUB:HTB5:OS7K:AAUI:K7CC:JZL3
Docker Root Dir: /var/lib/docker
Debug Mode: true
File Descriptors: 45
Goroutines: 49
System Time: 2024-07-23T09:41:47.2527914Z
EventsListeners: 4
HTTP Proxy: http://proxy.example.com:80
HTTPS Proxy: https://proxy.example.com:443
No Proxy: localhost,127.0.0.1,docker-registry.example.com
Registry: https://index.docker.io/v1/
Labels:
Experimental: false
Insecure Registries:
127.0.0.0/8
Registry Mirrors:
Live Restore Enabled: false
WARNING: No swap limit support
输出解释
Client: Docker 客户端的相关信息。
Context: 当前 Docker 上下文。
Debug Mode: 客户端是否开启调试模式。
Plugins: 安装的客户端插件，如 buildx 和 compose。
Server: Docker 服务端（守护进程）的相关信息。
Containers: 容器的总数。
Running: 运行中的容器数量。
Paused: 暂停中的容器数量。
Stopped: 停止的容器数量。
Images: 镜像的总数。
Server Version: Docker 服务端的版本号。
Storage Driver: 使用的存储驱动（如 overlay2）。
Backing Filesystem: 后端文件系统类型。
Supports d_type: 是否支持 d_type。
Native Overlay Diff: 是否支持原生 Overlay 文件系统。
Logging Driver: 使用的日志驱动（如 json-file）。
Cgroup Driver: 使用的 Cgroup 驱动（如 cgroupfs）。
Cgroup Version: Cgroup 的版本（如 1）。
Plugins: 服务端插件列表，包括卷、网络和日志插件。
Swarm: Swarm 模式的状态（如 inactive）。
Runtimes: 支持的运行时（如 runc）。
Default Runtime: 默认运行时（如 runc）。
Init Binary: 初始化二进制文件（如 docker-init）。
containerd version: 使用的 containerd 版本。
runc version: 使用的 runc 版本。
init version: 使用的 init 版本。
Security Options: 启用的安全选项（如 seccomp 和 selinux）。
Kernel Version: 内核版本。
Operating System: 操作系统名称。
OSType: 操作系统类型（如 linux）。
Architecture: 系统架构（如 x86_64）。
CPUs: CPU 数量。
Total Memory: 总内存。
Name: Docker 主机名。
ID: Docker 实例 ID。
Docker Root Dir: Docker 根目录。
Debug Mode: 服务端是否开启调试模式。
File Descriptors: 文件描述符数量。
Goroutines: Goroutines 数量。
System Time: 系统时间。
EventsListeners: 事件监听器数量。
HTTP Proxy: 配置的 HTTP 代理。
HTTPS Proxy: 配置的 HTTPS 代理。
No Proxy: 不使用代理的地址列表。
Registry: 使用的注册表地址。
Labels: 配置的标签。
Experimental: 是否启用了实验性功能。
Insecure Registries: 配置的不安全注册表列表。
Registry Mirrors: 注册表镜像列表。
Live Restore Enabled: 是否启用了实时恢复功能。
WARNING: 警告信息（如没有启用 swap 限制支持）。version - 显示 Docker 客户端和服务端的版本信息。
docker version 命令用于显示 Docker 客户端和服务端的版本信息。
docker version 命令可以帮助你确认当前安装的 Docker 版本以及客户端和服务器的详细版本信息。
另外还有一个 docker --version 命令是用于显示 Docker 的版本信息。
语法
docker version [OPTIONS]
OPTIONS说明：
-f :指定返回值的模板文件。
实例
显示 Docker 版本信息。
$ docker version
Client: Docker Engine - Community
Version: 20.10.7
API version: 1.41
Go version: go1.13.15
Git commit: f0df350
Built: Wed Jun 2 11:57:37 2021
OS/Arch: linux/amd64
Context: default
Experimental: true
Server: Docker Engine - Community
Engine:
Version: 20.10.7
API version: 1.41 (minimum version 1.12)
Go version: go1.13.15
Git commit: b0f5bc3
Built: Wed Jun 2 11:55:47 2021
OS/Arch: linux/amd64
Experimental: false
containerd:
Version: 1.4.6
GitCommit: d71fcd7d8303cbf684402823e425e9dd2e99285d
runc:
Version: 1.0.0-rc95
GitCommit: b9ee9c6314599f1b4a7f497e1f1f856fe433d3b7
docker-init:
Version: 0.19.0
GitCommit: de40ad0
输出解释
Client: Docker 客户端的相关信息。
Version: 客户端的版本号。
API version: API 的版本号。
Go version: 编译 Docker 客户端所用的 Go 语言版本。
Git commit: 该版本对应的 Git 提交 ID。
Built: 构建日期。
OS/Arch: 操作系统和架构。
Context: 当前 Docker 上下文。
Experimental: 是否启用了实验性功能。
Server: Docker 服务端（守护进程）的相关信息。
Engine:
Version: 服务端的版本号。
API version: API 的版本号（以及支持的最低版本）。
Go version: 编译 Docker 服务端所用的 Go 语言版本。
Git commit: 该版本对应的 Git 提交 ID。
Built: 构建日期。
OS/Arch: 操作系统和架构。
Experimental: 是否启用了实验性功能。
containerd: Docker 使用的 containerd 版本和 Git 提交 ID。
runc: Docker 使用的 runc 版本和 Git 提交 ID。
docker-init: Docker 使用的 docker-init 版本和 Git 提交 ID。
<Docker Compose
docker compose run - 启动一个新容器并运行一个特定的应用程序。
docker compose run 命令用于启动一个新容器并运行一个特定的服务，而不启动整个 Compose 文件中定义的所有服务。
docker compose run 命令允许你在单个服务上执行任务，如运行一次性命令或调试。
与 docker compose up 的区别在于，run 命令只会运行指定的服务，不会启动依赖它的其他服务。
语法
docker compose run [OPTIONS] SERVICE [COMMAND] [ARGS...]
SERVICE：Compose 文件中定义的服务名称。
COMMAND 和 ARGS：可选参数，指定要在容器内运行的命令及其参数。
OPTIONS 选项：
--rm：运行后自动删除容器。
-d：以分离模式运行容器。
-T：禁用伪TTY。
实例
1、运行一个特定服务的命令
docker compose run web python manage.py migrate
这个命令将在 web 服务的容器中执行 python manage.py migrate 命令，而不启动其他服务。
2、自动删除容器
docker compose run --rm web bash
这个命令会运行 web 服务并启动一个 Bash 终端，任务完成后会删除容器。
docker compose run 非常适合用来在服务中执行一次性任务，而不影响其他服务的运行。docker compose rm - 启动一个新容器并删除一个特定的应用程序。
docker compose rm 命令用于删除已停止的服务容器。
docker compose rm 命令不会删除运行中的容器，主要用于清理已停止或不再需要的容器，以释放系统资源。
语法
docker compose rm [OPTIONS] [SERVICE...]
SERVICE（可选）：要删除的服务容器的名称。如果不指定服务名称，将删除所有已停止的服务容器。
OPTIONS 选项：
-f, --force：强制删除容器，而不提示用户确认。
-s, --stop：首先停止正在运行的容器，然后删除它们。
-v, --volumes：同时删除与容器关联的卷（volume）。
实例
1、删除所有已停止的服务容器
docker compose rm
会列出并提示是否删除所有停止的服务容器。
2、强制删除所有已停止的服务容器
docker compose rm -f
直接删除停止的容器，不会提示用户确认。
3、删除特定服务的已停止容器
docker compose rm web
仅删除 web 服务的已停止容器。
4、删除并清理相关卷
docker compose rm -v
删除已停止的容器并同时删除与之关联的卷。docker compose ps - 从 docker compose 检查 docker 容器状态。
docker compose ps 命令用于列出与 Docker Compose 项目相关的容器及其状态。
docker compose ps 能显示当前项目中所有服务容器的运行状态、端口映射等信息。
语法
docker compose ps [OPTIONS] [SERVICE...]
SERVICE（可选）：指定要查看状态的服务名称。如果不指定，将列出所有服务的容器状态。
OPTIONS 选项：
-a, --all：列出所有容器，包括已停止的容器。
-q, --quiet：仅显示容器 ID，不显示其他信息。
--services：仅列出服务名称，不显示容器的详细信息。
--filter：根据条件过滤输出结果。例如，可以按照状态过滤容器。
输出信息
Name：容器名称。
Command：容器中运行的命令。
State：容器的状态（如 Up、Exited）。
Ports：容器的端口映射。
实例
1、列出所有运行中的容器
docker compose ps
显示当前项目中正在运行的容器及其状态。
2、列出所有容器（包括已停止的容器）
docker compose ps -a
包括停止的容器在内，列出所有容器的状态。
3、仅显示容器 ID
docker compose ps -q
只返回容器的 ID，不包括其他详细信息。
4、列出所有服务的名称
docker compose ps --services
只显示服务名称，而不列出容器的详细信息。
5、根据状态过滤容器
docker compose ps --filter "status=running"
仅列出状态为"running"的容器。docker compose build - 构建 docker compose 文件。
docker compose build 命令用于根据 docker-compose.yml 文件中的定义，构建服务的镜像。
docker compose build 会从指定的 Dockerfile 或 build 上下文中构建镜像，并为所有服务准备好容器。
语法
docker compose build [OPTIONS] [SERVICE...]
SERVICE（可选）：指定要构建的服务名称。如果不指定，将为所有服务构建镜像。
OPTIONS 选项：
--no-cache：在构建过程中不使用缓存层，强制从头开始构建镜像。
--pull：始终尝试从注册表中拉取最新的基础镜像。
--build-arg：传递构建时的变量（类似于 Docker 的 --build-arg 选项）。
--progress：指定构建的进度样式（auto、plain、tty），影响显示的输出方式。
--parallel：并行构建多个服务镜像以提高速度。
--no-rm：构建失败时，保留中间容器（默认在成功或失败后都会删除中间容器）。
实例
1、为所有服务构建镜像
docker compose build
根据 docker-compose.yml 中的配置，为所有服务构建镜像。
2、构建特定服务的镜像
docker compose build web
仅为 web 服务构建镜像。
3、不使用缓存构建镜像
docker compose build --no-cache
强制 Docker 从头构建所有镜像，不使用之前构建的缓存层。
4、从最新基础镜像构建
docker compose build --pull
确保 Docker 拉取最新的基础镜像，而不是使用本地镜像。
5、传递构建变量
docker compose build --build-arg NODE_ENV=production
通过 --build-arg 传递构建时所需的变量，例如传递 NODE_ENV 环境变量。docker compose up - 运行 docker compose 文件。
docker compose up 命令用于启动 Docker Compose 项目中定义的所有服务容器，并确保它们按照 docker-compose.yml 文件中的配置运行。
docker compose up 命令不仅会启动服务，还会自动构建尚未构建的镜像（如有必要），创建网络和卷，并以容器的形式启动服务。
语法
docker compose up [OPTIONS] [SERVICE...]
SERVICE（可选）：可以指定一个或多个服务，仅启动这些服务。如果不指定，将启动所有服务。
OPTIONS 选项：
-d, --detach：以后台模式运行容器，类似于在 docker run 中使用 -d 选项。
--build：在启动之前强制重新构建镜像，即使镜像已存在。
--no-build：阻止在启动时构建镜像，即使镜像不存在也不构建。
--force-recreate：强制重新创建容器，即使它们已经存在且内容未发生变化。
--no-recreate：如果容器已经存在，则不重新创建它们（默认行为是如果配置文件变化则重新创建）。
--remove-orphans：移除不再在 Compose 文件中定义的孤立容器。
-V, --renew-anon-volumes：重新创建匿名卷（删除旧的卷并创建新的）。
实例
1、启动所有服务并附加到控制台
docker compose up
启动 Compose 文件中定义的所有服务，并将日志输出显示在当前终端中。
2、在后台模式运行服务
docker compose up -d
以后台（分离）模式运行所有服务，终端不会输出服务的日志。
3、仅启动指定服务
docker compose up web
只启动 web 服务，而不启动其他服务。
4、启动服务并强制重建镜像
docker compose up --build
在启动服务之前，强制重新构建服务镜像。
5、启动服务并强制重新创建容器
docker compose up --force-recreate
强制重新创建服务容器，即使之前的容器存在且未发生更改。
6、启动服务并移除不再存在于 Compose 文件中的孤立容器
docker compose up --remove-orphans
移除任何不再在当前 docker-compose.yml 文件中定义的容器。docker compose ls - 列出 docker compose 服务。
docker compose ls 命令用于列出当前系统中所有 Docker Compose 项目及其状态。
docker compose ls 命令可以帮助你快速查看有哪些 Compose 项目正在运行或处于其他状态。
语法
docker compose ls [OPTIONS]
OPTIONS 选项：
--all：显示所有项目，包括未启动的项目。
--filter：根据条件过滤输出结果。例如，可以按状态过滤。
--format：指定输出格式（如 table、json 等）。
--quiet：只显示项目名称，而不显示其他信息。
输出信息：
docker compose ls 的输出信息包括以下字段：
Name：项目名称。
Status：项目的状态（例如 running、exited 等）。
Config Files：与项目相关联的 docker-compose.yml 文件的路径。
实例
1、列出所有运行的 Docker Compose 项目
docker compose ls
显示当前正在运行的所有项目及其状态。
2、列出所有项目（包括未启动的）
docker compose ls --all
显示包括未启动的项目在内的所有 Compose 项目。
3、仅显示项目名称
docker compose ls --quiet
只返回项目名称，而不包括详细信息。
4、按状态过滤项目
docker compose ls --filter "status=running"
仅显示状态为 running 的项目。docker compose start - 启动 docker compose 文件创建的容器。
docker compose start 命令用于启动已存在但目前处于停止状态的 Docker Compose 服务容器。
与 docker compose up 不同，它不会创建新的容器或重新构建镜像，只会启动已经创建但停止的容器。
语法
docker compose start [SERVICE...]
SERVICE（可选）：指定要启动的服务名称。如果不指定，将启动所有已停止的服务容器。
实例
1、启动所有已停止的服务
docker compose start
这将启动所有当前处于停止状态的容器。
2、启动特定服务
docker compose start web
仅启动 web 服务的容器，而不影响其他服务。docker compose restart - 重启 docker compose 文件创建的容器。
docker compose restart 命令命令用于重启一个或多个服务。
与 docker compose restart 命令会停止正在运行的服务容器，然后重新启动它们。
如果你需要更新配置或者只是想简单地重启服务而不需要重建容器，那么 restart 是很有用的。
语法
docker compose restart [SERVICE...]
SERVICE（可选）：可以指定要重启的一个或多个服务名称。如果不指定服务名称，则会重启所有在 docker-compose.yml 文件中定义的服务。
实例
1、重启所有服务：
docker-compose restart
2、重启特定的服务（例如名为 web 和 db 的服务）：
docker-compose restart web db
确保你在包含 docker-compose.yml 文件的目录中执行这些命令，或者通过 -f 参数指定 docker-compose.yml 文件的位置。例如，如果你的 docker-compose.yml 文件不在当前目录下，你可以这样指定文件位置：
docker-compose -f /path/to/docker-compose.yml restart
这样做可以让你控制哪个 docker-compose.yml 文件被用来管理服务。网络命令
docker network ls: 列出所有网络。
[root@iZbp1dcnzq7pzpg9607m6pZ ~]# docker network ls
NETWORK ID NAME DRIVER SCOPE
07302702a48c bridge bridge local
49d8f7800546 host host local
8a8ac3a1f811 none null localdocker network create : 创建一个新的网络。
docker network rm : 删除指定的网络。
docker network connect : 连接容器到网络。
docker network disconnect : 断开容器与网络的连接。
详细内容查看：docker network 命令
卷命令
docker volume ls: 列出所有卷。
docker volume create : 创建一个新的卷。
docker volume rm : 删除指定的卷。
docker volume inspect : 显示卷的详细信息。
