Docker 容器

Docker 容器是 Docker 平台中的一个基本概念，它是 Docker 技术的核心组成部分。Docker 容器是一个独立、可执行的运行单元，它包含了应用程序及其所有依赖项，可以在任何支持 Docker 的环境中运行。下面是 Docker 容器的详细介绍：

1. 轻量和独立：
   Docker 容器是轻量级的，它们与宿主机共享操作系统的内核，并共享部分系统资源，因此容器的启动速度非常快。每个容器都是独立的，互相之间隔离，这意味着容器之间的应用程序和进程不会相互干扰。

2. 隔离性：
   Docker 容器利用 Linux 内核的特性（如 namespace 和 cgroups）实现隔离。这种隔离性使得容器可以在同一主机上运行多个容器，每个容器都拥有自己的文件系统、网络空间、进程空间和用户空间。这样，不同容器之间的文件系统和进程不会相互干扰，保障了应用程序的稳定性和安全性。

3. 可移植性：
   Docker 容器是在 Docker 平台中创建的，因此容器可以在任何支持 Docker 的环境中运行，无需担心环境配置的问题。Docker 提供了一个统一的容器格式，使得容器可以在不同的主机和云服务中迁移和部署，提高了应用程序的可移植性。

4. Docker 镜像：
   容器是基于 Docker 镜像创建的。Docker 镜像是一个只读的模板，包含了运行容器所需的文件系统、应用程序和依赖项。Docker 容器在运行时是镜像的一个可写实例。通过 Docker 镜像，你可以创建多个相同或不同配置的容器。

5. 易于管理：
   Docker 容器可以通过 Docker CLI 或者 Docker API 进行管理和控制。你可以使用命令来启动、停止、删除和查询容器的状态。此外，Docker 还提供了一些工具和管理平台，帮助你更方便地管理容器集群。

6. 应用程序隔离：
   Docker 容器允许你将应用程序及其所有依赖项打包在一个容器中。这种隔离性使得容器内的应用程序不会受到主机上其他应用程序或系统设置的影响，从而减少了应用程序之间的冲突和依赖问题。

总体而言，Docker 容器提供了一种轻量、灵活和可移植的应用程序部署和运行解决方案。它在开发、测试、生产等多个环境中都能发挥作用，并为应用程序的部署和管理带来了极大的便利性和效率提升。

容器运行背后

​ Docker 容器存在的意义就是为了运行容器中的应用，对外提供服务，所以启动容器的目的就是启动运行该容器中的应用。容器中的应用运行完毕后，容器就会自动终止。所以，如果不想让容器启动后立即终止运行，则就需要使容器应用不能立即结束。通常采用的方式有两种，使应用处于与用户交互的状态或等待状态。

启停命令

[root@docker ~]# docker ps -a
CONTAINER ID   IMAGE           COMMAND             CREATED        STATUS                        PORTS                                       NAMES
3a0125af56d6   tomcat:8.5.49   "catalina.sh run"   17 hours ago   Exited (255) 17 minutes ago   0.0.0.0:8082->8080/tcp, :::8082->8080/tcp   tomcat8082
8d4bb15b855e   fb5657adc892    "catalina.sh run"   17 hours ago   Exited (255) 17 minutes ago   0.0.0.0:8081->8080/tcp, :::8081->8080/tcp   tomcat8081
80eab7e4166d   ubuntu          "bash"              17 hours ago   Exited (255) 17 minutes ago                                               myubuntu
02923446e2a3   ubuntu          "bash"              17 hours ago   Exited (0) 17 hours ago                                                   sharp_swartz

启动容器

[root@docker ~]# docker start tomcat8082
tomcat8082
[root@docker ~]# docker ps -a
CONTAINER ID   IMAGE           COMMAND             CREATED        STATUS                        PORTS                                       NAMES
3a0125af56d6   tomcat:8.5.49   "catalina.sh run"   17 hours ago   Up 4 seconds                  0.0.0.0:8082->8080/tcp, :::8082->8080

docker start 3a0125af56d6 用id启动也是一样的

停止容器

[root@docker ~]# docker stop tomcat8082
tomcat8082
[root@docker ~]# docker ps -a
CONTAINER ID   IMAGE           COMMAND             CREATED        STATUS                        PORTS                                       NAMES
3a0125af56d6   tomcat:8.5.49   "catalina.sh run"   17 hours ago   Exited (143) 2 seconds ago                                                tomcat8082

docker skill tomcat8082 
#也是停止，这是强制停止，即使在运行的时候也会停止

docker stop$（docker ps -q） 停止所有启动的容器。

重启

docker restart tomcat8082

暂停

docker pause 命令可以暂停容器对外提供服务。

[root@docker ~]# docker ps -a
CONTAINER ID   IMAGE           COMMAND             CREATED        STATUS                        PORTS                                       NAMES
3a0125af56d6   tomcat:8.5.49   "catalina.sh run"   17 hours ago   Up 3 seconds                  0.0.0.0:8082->8080/tcp, :::8082->8080/tcp   tomcat8082

[root@docker ~]# docker ps -a
CONTAINER ID   IMAGE           COMMAND             CREATED        STATUS                        PORTS                                       NAMES
3a0125af56d6   tomcat:8.5.49   "catalina.sh run"   17 hours ago   Up 30 seconds (Paused)        0.0.0.0:8082->8080/tcp, :::8082->8080/tcp   tomcat8082

解除暂停

[root@docker ~]# docker unpause tomcat8082
tomcat8082

run

介绍

docker run 是 Docker 命令中最常用和最重要的命令之一。它用于在新的容器中运行一个镜像。docker run 命令的详细介绍如下：

语法：

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

参数说明：

• [OPTIONS]：用于指定一些选项和配置参数。常用的选项包括：

  • -d：以后台（detached）模式运行容器，容器将在后台持续运行。
  • -it：以交互（interactive）模式运行容器，进入容器的交互式终端。
  • --name：为容器指定一个自定义的名称。
  • --rm：容器退出时自动删除容器，适用于一次性任务。
  • -p：指定端口映射，将容器内部端口映射到宿主机上的端口。
  • -v：挂载数据卷，将宿主机的目录或文件挂载到容器中。

• IMAGE：要运行的镜像的名称或 ID。

• [COMMAND] [ARG...]：可选参数，用于覆盖镜像中指定的默认执行命令。可以在运行容器时指定要在容器中执行的命令。

示例用法：

1. 在后台运行一个镜像：

   docker run -d nginx
   

   这将在后台运行一个 nginx 镜像，并分配一个随机的容器名称。

2. 在交互模式下运行一个镜像，并指定容器名称：

   docker run -it --name my_container ubuntu /bin/bash
   

   这将在交互模式下运行一个 ubuntu 镜像，并进入容器的 Bash Shell。容器的名称为 “my_container”。

3. 映射容器内部端口到宿主机端口：

   docker run -p 8080:80 nginx
   

   这将运行一个 nginx 镜像，并将容器内部的 80 端口映射到宿主机的 8080 端口。

4. 挂载宿主机数据卷到容器中：

   docker run -v /host/data:/container/data nginx
   

   这将运行一个 nginx 镜像，并将宿主机的 /host/data 目录挂载到容器中的 /container/data 目录。

例子

运行一个叫mynginx的nginx的容器

[root@docker ~]# docker run --name mynginx nginx

[root@docker ~]# docker ps -a
CONTAINER ID   IMAGE         COMMAND                   CREATED              STATUS                      PORTS     NAMES
c5f3b62d603b   nginx         "/docker-entrypoint.…"   About a minute ago   Exited (0) 34 seconds ago             mynginx

–name 指定当前容器名称为 mynxing

以交互模式运行 tomcat

[root@docker ~]# docker run --name myubuntu -it ubuntu  /bin/bash
root@6f46c4097d84:/# ls
bin   dev  home  lib32  libx32  mnt  proc  run   srv  tmp  var
boot  etc  lib   lib64  media   opt  root  sbin  sys  usr

• –name 指定当前容器名称为 myubuntu
• -it 指定以交互模式运行容器，且为容器分配一个伪终端。
• 后面的/bin/bash 用于指定容器启动后需要运行的命令为/bin 下的 bash 命令，而该命令会启动一个 bash 终端。

[root@docker ~]# docker run --name tomcat8081 -it -p 8081:8080 tomcat:8.5.49

[root@docker ~]# docker ps -a
CONTAINER ID   IMAGE           COMMAND                   CREATED          STATUS                      PORTS                                       NAMES
e0d8d8ad3d65   tomcat:8.5.49   "catalina.sh run"         45 seconds ago   Up 44 seconds               0.0.0.0:8081->8080/tcp, :::8081->8080/tcp   tomcat8081
eb410e67f70b   nginx           "/docker-entrypoint.…"   8 minutes ago    Up 8 minutes                80/tcp                                      mynginx2

-p 用于指定端口映射，格式为 暴露给宿主机的端口:容器中应用的端口

回车后会发现 tomcat 已启动，且 tomcat 的日志输出占居了命令行

此时在 Window 的浏览器中通过 8081 端口可以访问到 tomcat。docker:8081

可以使用ctrl +p +q不结束容器退出

[root@docker ~]# docker run --name tomcat8081 -it -P tomcat:8.5.49

-P 会随机生成端口号匹配 tomcat的8080端口

以守护进程方式运行tomcat

[root@docker ~]# docker run --name tomcat8082 -d -p 8082:8080 tomcat:8.5.49
8df8e4a76b754a2fc7b989a94c469a94bc491b5569106524f467dddbacd501f2

[root@docker ~]# docker run --name ydhnginx -p 8080:80 -d --cpu-shares 10 --cpus 1 --cpuset-cpus 0 -m 10000000 nginx:latest

交互模式需不需要接/bin/bash

在 Docker 容器中使用交互模式，可以让你与容器的主进程进行交互，比如在容器中运行命令、查看输出等。交互模式的启动通常是通过在 docker run 命令中加入 -it 参数来实现。

接不接 /bin/bash 取决于你希望在容器中执行什么样的操作。/bin/bash 是 Linux 中的一个常见的命令解释器，如果你想要在容器中打开一个交互式的 Shell，可以在 docker run 命令中加入 /bin/bash 或 /bin/sh。例如：

docker run -it ubuntu /bin/bash

docker run -it ubuntu 	#这个命令和上面的命令是一样的，因为ubuntun默认用的bash

上面的命令会在一个 Ubuntu 镜像中启动一个容器，并进入交互模式的 Bash Shell。

[root@docker ~]# docker run --name tomcat8081 -it -P tomcat:8.5.49

如果不加 /bin/bash 或 /bin/sh，容器会启动，但不会自动进入交互模式。**这意味着容器会运行它的默认主进程，**一旦主进程退出，容器也会停止。这在某些情况下可能是你所期望的行为，比如运行后台服务。

这个时候需要去看服务的dockerfile对应的CMD是什么了,运行tomcat容器接 /bin/bash 反而会执行不成功

create

在 Docker 中，docker create 命令用于创建一个新的容器，但并不立即启动它。这个命令通常与 docker start 结合使用，可以分别实现创建容器和启动容器的操作。

docker create 命令的基本语法如下：

docker create [OPTIONS] IMAGE [COMMAND] [ARG...]

• OPTIONS：可以包含一些选项，用于配置容器的各种属性，例如设置环境变量、映射端口等。常见的选项包括：

  • -e, --env=[]：设置环境变量。
  • --name：为容器指定一个自定义名称。
  • -p, --publish=[]：映射容器端口到宿主机端口。
  • -v, --volume=[]：挂载数据卷。
  • -d, --detach：在后台运行容器。

• IMAGE：指定用于创建容器的镜像名称或镜像 ID。

• COMMAND 和 ARG...：可选，可以指定容器在启动时要执行的命令及其参数。

示例：创建一个名为 mycontainer 的容器，从 ubuntu 镜像构建，并执行 echo "Hello Docker" 命令。

docker create --name mycontainer ubuntu echo "Hello Docker"

创建容器后，你可以使用 docker start 命令来启动它：

docker start mycontainer

或者使用 docker run 命令来直接创建并启动容器：

docker run --name mycontainer ubuntu echo "Hello Docker"

需要注意的是，docker create 只是创建容器并返回容器 ID，不会直接启动容器。而 docker run 命令是 docker create 和 docker start 两个操作的结合。如果只需要创建容器而不启动它，可以使用 docker create；如果需要立即启动容器，可以使用 docker run。

exec

介绍

docker exec 是 Docker 命令行工具中的一个命令，用于在正在运行的容器内部执行命令。通过 docker exec 命令，你可以在已经创建并运行的容器中打开一个新的进程，并在容器内部执行特定的命令。这为在运行中的容器中执行额外的操作提供了便利性和灵活性。下面是 docker exec 的详细介绍：

语法：

docker exec [OPTIONS] CONTAINER COMMAND [ARG...]

参数说明：

• OPTIONS：可选参数，用于配置 docker exec 的行为，比如 -it 表示进入交互模式。
• CONTAINER：指定要执行命令的容器的名称或容器ID。
• COMMAND：要在容器内部执行的命令。
• ARG：命令的参数（可选）。

使用示例：

docker exec -it my_container_name /bin/bash

上述命令表示在名为 my_container_name 的容器中执行 /bin/bash 命令，进入交互模式的 Bash Shell。

工作原理：

1. docker exec 命令首先会找到指定的容器，确保该容器正在运行。
2. 然后，它会在容器内部启动一个新的进程，以执行指定的命令。
3. 执行的命令将在容器的上下文中运行，可以访问容器的文件系统、网络等资源。
4. 命令执行结束后，容器继续保持运行状态。

注意事项：

• 要使用 docker exec 命令，容器必须处于运行状态。如果容器处于停止状态，你需要先使用 docker start 命令启动容器，然后再使用 docker exec 命令执行命令。
• 使用 -it 参数来进入交互模式。这样可以在容器中与命令进行交互，比如在容器内部运行交互式 Shell。

docker exec 命令非常有用，它允许你在运行中的容器内部执行额外的操作，比如查看日志、调试应用程序、安装软件等。这为容器的管理和维护提供了更大的灵活性和便利性。

例子

[root@docker ~]# docker exec --help

Usage:  docker exec [OPTIONS] CONTAINER COMMAND [ARG...]

Execute a command in a running container

Aliases:
  docker container exec, docker exec

Options:
  -d, --detach               Detached mode: run command in the background #运行在后台
      --detach-keys string   Override the key sequence for detaching a container #运行ctrl +q +p 停止的容器
  -e, --env list             Set environment variables
      --env-file list        Read in a file of environment variables
  -i, --interactive          Keep STDIN open even if not attached
      --privileged           Give extended privileges to the command
  -t, --tty                  Allocate a pseudo-TTY
  -u, --user string          Username or UID (format: "<name|uid>[:<group|gid>]")
  -w, --workdir string       Working directory inside the container

可以使用ctrl +p +q退出但不终止当前进程

[root@docker ~]# docker ps -a
CONTAINER ID   IMAGE           COMMAND             CREATED         STATUS         PORTS                                       NAMES
e8bf0fd8d347   tomcat:8.5.49   "catalina.sh run"   2 minutes ago   Up 2 minutes   0.0.0.0:8082->8080/tcp, :::8082->8080/tcp   tomcat8082
[root@docker ~]# docker exec -w /root -it tomcat8082 /bin/bash
root@e8bf0fd8d347:~# 

root@e8bf0fd8d347:~# exit
exit
[root@docker ~]# docker ps -a
CONTAINER ID   IMAGE           COMMAND             CREATED         STATUS         PORTS                                       NAMES
e8bf0fd8d347   tomcat:8.5.49   "catalina.sh run"   6 minutes ago   Up 6 minutes   0.0.0.0:8082->8080/tcp, :::8082->8080/tcp   tomcat8082

用exit：退出并终止当前进程

外部操作容器 exec

[root@docker ~]# docker exec -it tomcat8082 pwd
/usr/local/tomcat

[root@docker ~]# docker exec -it tomcat8082 ls
BUILDING.txt	 NOTICE		RUNNING.txt  include  native-jni-lib  work
CONTRIBUTING.md  README.md	bin	     lib      temp
LICENSE		 RELEASE-NOTES	conf	     logs     webapps

attach

介绍

docker attach 命令用于附加到正在运行的 Docker 容器，将你的终端连接到容器的标准输入、输出和错误流，使你可以与容器的主进程进行交互。使用 docker attach，你可以像连接到本地终端一样，与容器内部的进程进行交互和执行命令。

语法：

docker attach [OPTIONS] CONTAINER

参数说明：

• [OPTIONS]：用于指定一些选项和配置参数。常用的选项包括：

  • --detach-keys：指定从容器中分离的键盘序列，通常是 Ctrl-P 和 Ctrl-Q 的组合。默认情况下，使用 Ctrl-C 将导致容器停止。

• CONTAINER：要附加的容器的名称或 ID。

注意事项：

• 使用 docker attach 命令前，确保容器已经在运行中。如果容器没有在运行状态，命令会报错。
• 在容器内部，通常使用 exit 命令或 Ctrl-D 来退出容器并分离控制台。

示例用法：

假设你有一个正在运行的容器 my_container，你想要附加到该容器，与其交互并执行一些命令：

1. 附加到容器并进入交互模式：

   docker attach my_container
   

   这将将你的终端连接到 my_container 容器，并进入容器的交互式终端。现在你可以在容器内执行命令。

2. 在容器内执行命令：

   docker attach my_container ls -l
   

   这将在容器内执行 ls -l 命令，并显示容器中的文件列表。执行完命令后，容器不会自动退出，你可以继续在容器内进行其他操作。

3. 使用 --detach-keys 参数来分离控制台：

   docker attach --detach-keys="ctrl-p,ctrl-q" my_container
   

   这将附加到容器，但使用 Ctrl-P 和 Ctrl-Q 来分离控制台，而不是默认的 Ctrl-C，从而使容器保持在后台运行。

例子

[root@docker ~]# docker attach --help

Usage:  docker attach [OPTIONS] CONTAINER

Attach local standard input, output, and error streams to a running container

Aliases:
  docker container attach, docker attach

Options:
      --detach-keys string   Override the key sequence for detaching a container
      --no-stdin             Do not attach STDIN#
      --sig-proxy            Proxy all received signals to the process (default
                             true)

使用attach连接ubuntu，然后退出，可以看到ubuntu一栏显示的是Exited

[root@docker ~]# docker ps -a
CONTAINER ID   IMAGE           COMMAND             CREATED          STATUS             
7dd956784e22   ubuntu          "bash"              3 minutes ago    Up 3 minutes       
aab4e131f2ef   tomcat:8.5.49   "catalina.sh run"   23 minutes ago   Up 23 minutes      
e8bf0fd8d347   tomcat:8.5.49   "catalina.sh run"   52 minutes ago   Exited (130) 31 min
[root@docker ~]# docker attach stupefied_euclid
root@7dd956784e22:/# exit 
exit
[root@docker ~]# docker ps -a
CONTAINER ID   IMAGE           COMMAND             CREATED          STATUS                        PORTS                                       NAMES
7dd956784e22   ubuntu          "bash"              4 minutes ago    Exited (0) 2 seconds ago                                                  stupefied_euclid
aab4e131f2ef   tomcat:8.5.49   "catalina.sh run"   23 minutes ago   Up 23 minutes                 0.0.0.0:8081->8080/tcp, :::8081->8080/tcp   tomcat8081
e8bf0fd8d347   tomcat:8.5.49   "catalina.sh run"   53 minutes ago   Exited (130) 32 minutes ago                                               tomcat8082

用attach连接tomcat服务，可以看到连接不成功。

[root@docker ~]# docker attach tomcat8081

• catalina.sh：这是 Tomcat 的启动脚本文件，在 Tomcat 安装目录下的 bin 文件夹中。
• run：这是 catalina.sh 脚本的一个参数，用于告诉 Tomcat 启动时执行的操作是 “run”，即启动 Tomcat 服务。

对于像 Tomcat 这样的 Web 服务器，它通常在后台运行，并且不会直接从标准输入接受交互式命令。因此，在 Tomcat 这样的容器上使用 docker attach 通常不会让你像进入一个交互式 Shell 那样与容器进行交互。

可以看到tomcat是用脚本运行的，在后台运行。而ubuntu的主程序是bash,是可以进行交互的，跟正常使用ubuntu一样。

ps

介绍

docker container ps 是 Docker 命令中用于列出当前正在运行的容器的命令。它显示当前正在活动状态的容器，可以用来查看容器的状态、标识符、名称、端口映射等信息。

语法：

docker container ps [OPTIONS]

参数说明：

• [OPTIONS]：用于指定一些选项和配置参数。常用的选项包括：
  • -a, --all：显示所有容器，包括已停止的容器。
  • -q, --quiet：仅显示容器的 ID，而不显示其他信息。
  • --no-trunc：不截断输出，显示完整的容器信息。
  • --filter：根据指定条件过滤容器的输出。
  • --format：指定输出的格式。

示例用法：

1. 列出正在运行的容器：

   docker container ps
   

   这将显示所有当前正在运行的容器的信息，包括容器的 ID、名称、状态、端口映射等。

2. 列出所有容器（包括已停止的）：

   docker container ps -a
   

   这将显示所有容器的信息，包括正在运行的容器和已停止的容器。

3. 仅显示容器的 ID：

   docker container ps -q
   

   这将仅显示容器的 ID，而不显示其他信息。

4. 显示完整的容器信息：

   docker container ps --no-trunc
   

   这将显示完整的容器信息，不会截断输出，可以看到更多容器的详细信息。

5. 根据条件过滤容器的输出：

   docker container ps --filter "status=exited"
   

   这将仅显示状态为 “exited”（已停止）的容器。

6. 自定义输出格式：

   docker container ps --format "ID: {{.ID}}, Name: {{.Names}}, Status: {{.Status}}"
   

   这将自定义输出容器信息的格式，仅显示容器的 ID、名称和状态。

总结来说，docker container ps 命令是用于列出当前正在运行的容器的主要命令。它提供了一种方便的方式来查看容器的状态和信息，帮助你进行容器的管理和监控。根据不同的选项和参数，你可以自定义输出的内容和格式，以满足特定的需求。

例子

[root@docker ~]# docker ps --help

Usage:  docker ps [OPTIONS]

List containers

Aliases:
  docker container ls, docker container list, docker container ps, docker ps

Options:
  -a, --all             Show all containers (default shows just running)
  -f, --filter filter   Filter output based on conditions provided
      --format string   Format output using a custom template:
                        'table':            Print output in table format with
                        column headers (default)
                        'table TEMPLATE':   Print output in table format using
                        the given Go template
                        'json':             Print in JSON format
                        'TEMPLATE':         Print output using the given Go
                        template.
                        Refer to https://docs.docker.com/go/formatting/ for
                        more information about formatting output with templates
  -n, --last int        Show n last created containers (includes all states)
                        (default -1)
  -l, --latest          Show the latest created container (includes all states)
      --no-trunc        Don't truncate output
  -q, --quiet           Only display container IDs
  -s, --size            Display total file sizes

查看所有正在运行的容器

docker ps 命令本身查看的是所有处于运行状态的容器信息。

docker ps

查看所有容器

docker ps –a 用于查看所有容器，无论是否处于运行状态。

docker ps -a

查看所有容器的 ID

docker ps –q 用于查看所有处于运行状态的容器的 ID。

docker ps -q

查看最后创建的容器

docker ps –l 用于查看最后创建的容器，无论该容器是否处于运行状态。

docker ps -l

查看最后创建的 n 个容器

docker ps –n 2用于查看最后创建的指定个数的容器，无论该容器是否处于运行状态。

docker ps -n 2

查看容器大小

docker ps -s 显示容器的大小

docker ps -s

top

介绍

docker top 是一个 Docker 命令，用于查看正在运行的容器内部的进程信息。使用 docker top 可以查看容器内部的进程列表及其资源使用情况，类似于 Linux 系统中的 top 命令。

语法：

docker top CONTAINER [ps OPTIONS]

参数说明：

• CONTAINER：要查看进程信息的容器的名称或 ID。

• [ps OPTIONS]：可选参数，用于指定 ps 命令的选项和参数。ps 命令是用于查看进程信息的命令。你可以使用 ps 命令的选项来定制输出的格式和内容。

示例用法：

1. 查看容器内部的所有进程：

   docker top my_container
   

   这将显示名为 my_container 的容器内部的所有进程的信息，包括进程 ID（PID）、用户、CPU 使用率、内存使用率等。

2. 查看指定容器内部的进程信息：

   docker top my_container -eo pid,ppid,user,cmd
   

   这将显示名为 my_container 的容器内部的进程信息，但只包括进程 ID（PID）、父进程 ID（PPID）、用户和命令。

docker top 命令允许你实时查看正在运行的容器内部的进程状态，这对于容器的监控和调试非常有用。你可以根据不同的选项和参数，自定义输出的格式和内容，以满足特定的需求。

例子

[root@docker ~]# docker top --help

Usage:  docker top CONTAINER [ps OPTIONS]   #跟ps的使用一样

Display the running processes of a container

Aliases:
  docker container top, docker top

[root@docker ~]# docker top tomcat8081
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                6497                6476                0                   17:16               ?                   00:00:06            /usr/local/openjdk-11/bin/java -Djava.util.logging.config.file=/usr/local/tomcat/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKeySize=2048 -Djava.protocol.handler.pkgs=org.apache.catalina.webresources -Dorg.apache.catalina.security.SecurityListener.UMASK=0027 -Dignore.endorsed.dirs= -classpath /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar -Dcatalina.base=/usr/local/tomcat -Dcatalina.home=/usr/local/tomcat -Djava.io.tmpdir=/usr/local/tomcat/temp org.apache.catalina.startup.Bootstrap start

top加上过滤(跟linux组合用法一样)

[root@docker ~]# docker top tomcat8082|grep PID
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
[root@docker ~]# 

对于 ubuntu 容器来说，这个日志是/bin/bash 的运行历史记录。

logs

介绍

Docker logs是Docker引擎提供的一种功能，用于查看运行在Docker容器中的应用程序的日志输出。它允许您从已运行的容器中实时获取日志，并且可以非常方便地用于监视和调试应用程序。

以下是Docker logs的详细介绍：

1. 获取容器日志: 使用docker logs命令可以获取容器的日志。语法如下：

   docker logs [OPTIONS] CONTAINER_ID/CONTAINER_NAME
   

   其中，CONTAINER_ID是容器的唯一标识符，也可以使用CONTAINER_NAME来指定容器名称。如果没有提供任何选项，默认会显示标准输出（STDOUT）和标准错误（STDERR）的日志。

2. 查看实时日志: 通过添加-f或--follow选项，可以实时地查看容器的日志输出。这样您可以像使用tail -f命令一样实时监视应用程序的日志：

   docker logs -f CONTAINER_ID/CONTAINER_NAME
   

3. 时间戳: 日志中默认不包含时间戳，但可以通过添加--timestamps选项来显示日志中的时间戳：

   docker logs --timestamps CONTAINER_ID/CONTAINER_NAME
   

4. 显示最新日志: 使用--tail选项可以只显示最近的几行日志，非常有用的调试选项。例如，只显示最后10行日志：

   docker logs --tail 10 CONTAINER_ID/CONTAINER_NAME
   

5. 清理日志: 如果您希望清空容器的日志，可以使用--since选项来指定时间戳。这将只显示指定时间之后的日志，相当于清理之前的日志记录。

   docker logs --since "2023-07-01T00:00:00" CONTAINER_ID/CONTAINER_NAME
   

6. 多容器日志收集: 在使用Docker Compose等工具时，您可能会运行多个容器。通过添加容器名称，可以获取指定容器的日志：

   docker logs CONTAINER_NAME
   

7. 日志驱动程序: Docker支持多种日志驱动程序（log drivers），可以根据需要将日志写入不同的目标。默认情况下，Docker使用json-file驱动程序，将日志写入容器的文件系统。但是，您也可以配置为使用syslog、journald等其他日志驱动程序。

请注意，Docker logs只能访问容器的标准输出和标准错误流。如果应用程序将日志写入其他文件或使用第三方日志记录工具，则需要使用特定的方法来查看这些日志。

[root@docker ~]# docker logs --help

Usage:  docker logs [OPTIONS] CONTAINER

Fetch the logs of a container

Aliases:
  docker container logs, docker logs

Options:
      --details        Show extra details provided to logs
  -f, --follow         Follow log output
      --since string   Show logs since timestamp (e.g. "2013-01-02T13:23:37Z") or relative (e.g. "42m" for 42 minutes)
  -n, --tail string    Number of lines to show from the end of the logs (default "all")
  -t, --timestamps     Show timestamps
      --until string   Show logs before a timestamp (e.g. "2013-01-02T13:23:37Z") or relative (e.g. "42m" for 42 minutes)

docker logs [容器]可以查看指定容器中应用的运行日志，无论该容器是运行还是停止状态

docker logs 查看的是容器中应用的运行日志。这个应用是根据容器创建时命令（docker run 或 docker create）中的[command]指定，或通过容器镜像的 Dockerfile 中的 CMD指令指定。

例子

查看tomcat8082的日志

[root@docker ~]# docker logs tomcat8082
19-Jul-2023 09:14:49.471 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log Server version name:   Apache Tomcat/8.5.49
19-Jul-2023 09:14:49.473 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log Server built:          Nov 17 2019 18:45:30 UTC
19-Jul-2023 09:14:49.474 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log Server version number: 8.5.49.0
19-Jul-2023 09:14:49.474 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log OS Name:               Linux
19-Jul-2023 09:14:49.474 INFO [main] org.apache.catalina.startup.VersionLoggerListener.log OS Version:            3.10.0-1160.el7.x86_64

查看ubuntu的日志

[root@docker ~]# docker ps -a
CONTAINER ID   IMAGE           COMMAND             CREATED        STATUS                        PORTS                           
...
02923446e2a3   ubuntu          "bash"              17 hours ago   Exited (0) 17 hours ago                                                   sharp_swartz

[root@docker ~]# docker logs sharp_swartz
root@02923446e2a3:/# exit
exit

查看指定时间内的日志

通过添加选项–since 可以指定要显示自从指定时间以来的日志。这个时间可以是一个绝对时间，也可以是一个相对时长。

下面使用的是绝对时间：显示自从 2023年 7 月 19 日后产生日志的最后 3 条

[root@docker ~]# docker logs --since="2023-07-19" --tail=3 tomcat8082
20-Jul-2023 02:01:04.393 INFO [main] org.apache.coyote.AbstractProtocol.start Starting ProtocolHandler ["http-nio-8080"]
20-Jul-2023 02:01:04.403 INFO [main] org.apache.coyote.AbstractProtocol.start Starting ProtocolHandler ["ajp-nio-8009"]
20-Jul-2023 02:01:04.407 INFO [main] org.apache.catalina.startup.Catalina.start Server startup in 551 ms

下面使用的是相对时长：显示自从 20 分钟之前产生日志中的最后 3 条。其中 m 表示分，可以使用 s 表示秒，h 表示小时。

[root@docker ~]# docker logs --since=20m --tail=3 tomcat8082
20-Jul-2023 02:01:04.393 INFO [main] org.apache.coyote.AbstractProtocol.start Starting ProtocolHandler ["http-nio-8080"]
20-Jul-2023 02:01:04.403 INFO [main] org.apache.coyote.AbstractProtocol.start Starting ProtocolHandler ["ajp-nio-8009"]
20-Jul-2023 02:01:04.407 INFO [main] org.apache.catalina.startup.Catalina.start Server startup in 551 ms

通过添加选项–until 可以指定要显示截止到指定时间之前的日志。这个时间可以是一个绝对时间，也可以是一个相对时长。下面使用的是绝对时间：显示截止到 2023 年7 月 21 日前产生日志的最后 3 条。

[root@docker ~]# docker logs --until="2023-07-21" --tail=3 tomcat8082
20-Jul-2023 02:25:11.011 INFO [Thread-5] org.apache.coyote.AbstractProtocol.stop Stopping ProtocolHandler ["ajp-nio-8009"]
20-Jul-2023 02:25:11.013 INFO [Thread-5] org.apache.coyote.AbstractProtocol.destroy Destroying ProtocolHandler ["http-nio-8080"]
20-Jul-2023 02:25:11.014 INFO [Thread-5] org.apache.coyote.AbstractProtocol.destroy Destroying ProtocolHandler ["ajp-nio-8009"]

下面使用的是相对时长：显示截止到 5 分钟之前产生日志中的最后 3 条。

20-Jul-2023 02:25:11.011 INFO [Thread-5] org.apache.coyote.AbstractProtocol.stop Stopping ProtocolHandler ["ajp-nio-8009"]
20-Jul-2023 02:25:11.013 INFO [Thread-5] org.apache.coyote.AbstractProtocol.destroy Destroying ProtocolHandler ["http-nio-8080"]
20-Jul-2023 02:25:11.014 INFO [Thread-5] org.apache.coyote.AbstractProtocol.destroy Destroying ProtocolHandler ["ajp-nio-8009"]

可以使用-t 选项查看某日志的详细时间戳。下面的命令查看的是最后 3 条日志的时间戳，并与不添加-t 的输出进行了对比。

选项-f 可以查看运行中容器的以上命令用于查看 mytomcat 的最后三条动态日志。其会占用命令行，一直等待日志的

输出**。**

[root@docker ~]# docker logs -f --tail=1 tomcat8082
20-Jul-2023 02:25:11.014 INFO [Thread-5] org.apache.coyote.AbstractProtocol.destroy Destroying ProtocolHandler ["ajp-nio-8009"]

实时查看tomcat8082的最后一条日志

cp

介绍

在 Docker 中，docker cp 是用于在主机和容器之间复制文件和目录的命令。它允许你将文件从主机复制到容器内，或者从容器复制到主机上。这在许多场景下非常有用，例如将配置文件、日志、数据文件等复制到或从容器中提取。

docker cp 命令的语法如下：

docker cp [OPTIONS] CONTAINER:SRC_PATH DEST_PATH
docker cp [OPTIONS] SRC_PATH CONTAINER:DEST_PATH

其中，CONTAINER 是容器的名称或 ID，SRC_PATH 是源文件或目录的路径，DEST_PATH 是目标路径。

下面是一些常用选项：

• --follow-link: 如果 SRC_PATH 是一个符号链接，则跟踪该链接并复制其目标。

• --archive | -a: 将文件保留为 tar 存档格式，以便在复制目录时保留权限和元数据。

• --from-container: 如果你使用的 Docker 版本支持多个容器复制功能，你可以使用此选项指定复制的来源容器。

• 将文件从主机复制到容器内

假设有一个名为 my_container 的容器，并且我们想将主机上的文件 host_file.txt 复制到容器内的路径 /container/path/。

docker cp host_file.txt my_container:/container/path/

• 从容器复制文件到主机

假设我们想从容器 my_container 中的路径 /container/path/ 复制文件 container_file.txt 到主机上的目录 host_directory/。

docker cp my_container:/container/path/container_file.txt host_directory/

• 复制目录并保留权限

假设我们想将主机上的整个目录 my_directory/ 复制到容器 my_container 中的路径 /container/path/，并且希望保留目录和文件的权限和元数据。

docker cp -a my_directory/ my_container:/container/path/

docker cp 命令不支持容器间的复制

请注意，使用 docker cp 命令时要确保容器处于运行状态，否则可能会遇到错误。这也是在容器内复制文件时要特别小心的原因，因为文件复制可能会覆盖容器中的现有文件。

[root@docker ~]# docker cp --help

Usage:  docker cp [OPTIONS] CONTAINER:SRC_PATH DEST_PATH|-
	docker cp [OPTIONS] SRC_PATH|- CONTAINER:DEST_PATH

Copy files/folders between a container and the local filesystem

Use '-' as the source to read a tar archive from stdin
and extract it to a directory destination in a container.
Use '-' as the destination to stream a tar archive of a
container source to stdout.

Aliases:
  docker container cp, docker cp

Options:
  -a, --archive       Archive mode (copy all uid/gid information)
  -L, --follow-link   Always follow symbol link in SRC_PATH
  -q, --quiet         Suppress progress output during copy. Progress output is
                      automatically suppressed if no terminal is attached

rm

在Docker中，docker rm命令用于删除一个或多个已经停止的容器。这允许您从系统中移除不再需要的容器，释放资源并清理环境。以下是docker rm命令的详细介绍：

语法

docker rm [OPTIONS] CONTAINER [CONTAINER...]

参数和选项

• CONTAINER: 要删除的一个或多个容器的ID或名称。
• OPTIONS:
  • --force, -f: 强制删除正在运行的容器。如果容器正在运行，您必须使用此选项强制删除。
  • --link: 删除容器的连接，而不删除容器本身。当容器之间有链接时使用。
  • --volumes, -v: 删除与容器关联的挂载卷。默认情况下，Docker在删除容器时会保留容器挂载的数据卷。如果要一并删除数据卷，需要使用此选项。
  • --help: 显示帮助信息并退出。

例子

• 删除一个已停止的容器：

  docker rm container_id_or_name
  

• 强制删除一个正在运行的容器：

  docker rm -f container_id_or_name
  

• 删除多个容器：

  docker rm container1 container2 container3
  

• 删除容器及其关联的挂载卷：

  docker rm -v container_id_or_name
  

• 删除容器的连接：

docker rm --link container_id_or_name

注意事项

• docker rm命令只能删除已经停止的容器。要删除正在运行的容器，您需要使用-f选项来强制删除。
• 删除容器时，如果它有关联的挂载卷，默认情况下Docker会保留挂载卷。如果希望连同挂载卷一起删除，需要使用-v选项。
• 请谨慎使用docker rm -f命令，因为它会直接终止正在运行的容器并删除它，可能导致数据丢失或不可恢复的状态。
• 在删除容器之前，最好先备份或确认容器内的重要数据已经保存。

例子

删除正在运行的容器

docker rm -f $(docker ps  -q)

删除所有的容器

docker rm -f $(docker ps -a -q)

commit

在Docker中，docker commit是一个命令，用于将容器的当前状态保存为一个新的镜像。它可以在容器中做出一些修改后，将这些修改保存为新的镜像，以便以后可以使用或分享这个镜像。

docker commit命令的基本语法如下：

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

其中，CONTAINER是指定要提交的容器的ID或名称。REPOSITORY是为新的镜像指定的名称，而TAG是镜像的版本标签（可选）。如果不指定REPOSITORY和TAG，则会生成一个无标签的镜像。

以下是一些docker commit命令的常用选项：

• -a, --author: 指定新镜像的作者信息。
• -c, --change: 为提交的镜像指定Dockerfile指令，例如增加环境变量或执行一些操作。
• -m, --message: 提交时的说明信息。
• -p, --pause: 在提交容器时暂停容器的运行。

注意事项：

1. 使用docker commit命令时要谨慎，因为它会将当前容器的状态保存为一个新的镜像，而不是基于Dockerfile构建。这可能会导致一些问题，例如生成过大、不一致或不可重复构建的镜像。

2. 推荐的做法是使用Dockerfile来描述镜像的构建过程，而不是直接使用docker commit命令。使用Dockerfile可以更好地跟踪镜像的构建历史，并确保镜像的可重复性和一致性。

3. 如果要频繁修改容器并保存为新镜像，可能需要重新考虑容器的设计和镜像的管理方式，以避免出现不必要的复杂性和问题。

[root@docker ~]# docker commit --help

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

Create a new image from a container's changes

Aliases:
  docker container commit, docker commit

Options:
  -a, --author string    Author (e.g., "John Hannibal Smith <hannibal@a-team.com>")
  -c, --change list      Apply Dockerfile instruction to the created image
  -m, --message string   Commit message
  -p, --pause            Pause container during commit (default true)

例子

将容器的当前状态保存为新的镜像名称为centos7 ，标签为net-tools

[root@docker ~]# docker commit -a "ydh" -m"Added net-tools" mycentos centos7:net-tools
sha256:5351ce6503e61d3a0bcc6b68073fa246be2fedeb3e106fd926afa38d3bdc2c2c
[root@docker ~]# docker images
REPOSITORY    TAG         IMAGE ID       CREATED          SIZE
centos7       net-tools   5351ce6503e6   19 seconds ago   418MB

不指定镜像名称和版本会生成玄虚镜像

[root@docker ~]# docker commit -a "ydh" -m"Added net-tools" mycentos 
sha256:c40dbe98af86182c29dfb2e4b23e121ca799f6ca26cbe3998f6c7dece6ea809d
[root@docker ~]# docker images
REPOSITORY    TAG         IMAGE ID       CREATED          SIZE
<none>        <none>      c40dbe98af86   1 second ago     418MB

export

[root@docker ~]# docker export --help

Usage:  docker export [OPTIONS] CONTAINER

Export a container's filesystem as a tar archive

Aliases:
  docker container export, docker export

Options:
  -o, --output string   Write to a file, instead of STDOUT

在Docker中，docker export是一个命令行工具，用于将Docker容器转储为一个tar归档文件。这个归档文件包含了容器的文件系统内容，但不包含容器的元数据（例如标签、容器配置等）。这意味着，使用docker export导出的内容不能被还原成一个Docker镜像或容器，只能用于文件系统的备份或迁移目的。

下面是docker export命令的详细介绍：

语法

docker export [OPTIONS] CONTAINER > output.tar

参数说明

• CONTAINER: 要导出的容器的名称或容器ID。
• output.tar: 将导出的容器文件系统保存到名为output.tar的tar归档文件。

选项

• -o, --output: 可选参数，用于指定导出文件的路径和名称。
• --help: 显示命令的帮助信息。

使用示例

1. 导出一个运行中的容器为output.tar文件：

docker export my_container > output.tar

2. 使用-o选项指定输出文件路径和名称：

docker export -o /path/to/output.tar my_container

注意事项

• 使用docker export导出的内容只包含容器的文件系统内容，不包括元数据和历史记录。这意味着不能将导出的内容还原成一个Docker镜像或容器。
• docker export适用于简单的文件系统备份和容器迁移场景，但在一些情况下可能并不是最佳选择。对于复杂的应用程序和容器，建议使用Docker镜像和容器的方式进行备份和迁移，以保留元数据和历史记录等信息。
• 要导出整个Docker镜像，而不仅仅是容器文件系统，请使用docker save命令。

例子

[root@docker ~]# docker export -o tom-export.tar tomcat1
[root@docker ~]# ll
总用量 498560
-rw-------. 1 root root      1244 7月  15 11:35 anaconda-ks.cfg
-rw-------  1 root root 510520320 7月  20 11:08 tom-export.tar

import

在 Docker 中，import 是一个用于将本地文件系统中的文件或目录导入到 Docker 镜像中的命令。这允许你在构建镜像时向镜像添加额外的文件或目录。import 命令可以很方便地将一些本地的配置文件、代码、数据等内容打包进镜像中，从而使得镜像更加完整和功能丰富。

import 命令的基本语法如下：

docker import [OPTIONS] file|URL|- [REPOSITORY[:TAG]]

其中，file|URL|- 指定要导入的文件或目录路径。可以是本地文件系统中的路径、远程 URL 地址，或者直接使用 - 表示从标准输入读取数据。REPOSITORY 和 TAG 是可选的，用于指定导入的镜像的名称和标签。

下面是一些常用的选项：

• --change=[]：可以使用该选项来在导入镜像时应用 Dockerfile 指令，例如添加作者信息、设置环境变量等。
• --message=""：添加导入镜像时的描述信息，方便标识和查看镜像的用途。

示例：将本地的一个目录导入为 Docker 镜像并标记为 myimage:latest：

docker import /path/to/local/directory myimage:latest

示例：从一个 URL 导入镜像并添加作者信息：

docker import --change "LABEL maintainer=john@example.com" http://example.com/myimage.tar.gz myimage:latest

请注意，import 命令与 docker build 命令有所区别。import 只是简单地将文件或目录打包为镜像，而 docker build 允许你基于 Dockerfile 创建更复杂和可定制的镜像。如果你需要更多控制和灵活性，通常会使用 docker build 来构建镜像。

[root@docker ~]# docker import --help

Usage:  docker import [OPTIONS] file|URL|- [REPOSITORY[:TAG]]

Import the contents from a tarball to create a filesystem image

Aliases:
  docker image import, docker import

Options:
  -c, --change list       Apply Dockerfile instruction to the created image
  -m, --message string    Set commit message for imported image
      --platform string   Set platform if server is multi-platform capable

例子

[root@docker ~]# docker import tom-export.tar tom:export
sha256:2e0bf29392a66fb2a5a77c5fff94e3572e5dcebc7bfbbedc3c66cf3bed40709b
[root@docker ~]# docker images
REPOSITORY    TAG         IMAGE ID       CREATED             SIZE
tom           export      2e0bf29392a6   9 seconds ago       499MB
<none>        <none>      c40dbe98af86   About an hour ago   418MB

不指定镜像和标签,成为玄虚镜像了

[root@docker ~]# docker import tom-export.tar
sha256:1d2a738961fa73f919baa4024304ece957701e0975fa36afb07a363b70b310a7
[root@docker ~]# docker images
REPOSITORY    TAG         IMAGE ID       CREATED          SIZE
<none>        <none>      1d2a738961fa   11 seconds ago   499MB
tom           export      2e0bf29392a6   3 hours ago      499MB

system

在 Docker 中，有许多用于管理容器和镜像的命令。然而，关于 systemt 命令，我无法确定它是否存在，因为在 Docker 中没有这个具体的命令。可能是由于误解或拼写错误导致的。

不过，我可以提供 Docker 中常见的一些管理系统和信息的命令，希望它们能够满足你的需求：

1. docker info：显示 Docker 系统信息，包括服务器的配置、镜像和容器数量等。
2. docker version：显示 Docker 版本信息，包括 Docker 客户端和服务器的版本号。
3. docker system df：显示 Docker 使用的磁盘空间信息，包括镜像、容器和卷的大小等。
4. docker system prune：清理未使用的资源，包括未使用的镜像、容器、网络和卷。
5. docker system events：显示 Docker 服务器的实时事件流，例如创建、启动、停止和删除容器的事件。

[root@docker ~]# docker system --help

Usage:  docker system COMMAND

Manage Docker

Commands:
  df          Show docker disk usage
  events      Get real time events from the server
  info        Display system-wide information
  prune       Remove unused data

对比

export、save

docker export 和 docker save 是两个不同的 Docker 命令，它们用于不同的场景和目的。下面是它们的详细对比：

1. docker export:

   • 功能：docker export 命令用于将容器的文件系统导出为一个 tar 归档文件。

   • 导出内容：只是对当前容器的文件系统快照进行导出，其会丢弃原镜像的所有历史记录与元数据信息。

   • 文件格式：导出的结果是一个 tar 归档文件，其中包含了容器的完整文件系统快照。

   • 用途：一般用于将容器的文件系统导出，可以用于备份容器或将容器的文件系统导入到另一个容器中。

   • 示例：

     docker export -o container_export.tar <container_id>
     

2. docker save:

   • 功能：docker save 命令用于将镜像保存为一个或多个 tar 归档文件，包含了镜像的元数据和所有图层信息。

   • 导出内容：它导出整个镜像，包含了镜像的元数据、层信息和配置信息。

   • 文件格式：导出的结果是一个或多个 tar 归档文件，其中包含了镜像的元数据和图层信息。

   • 用途：一般用于备份镜像、在不同的 Docker 宿主机之间传输镜像，或者将镜像导入到其他 Docker 环境中。

   • 示例：

     docker save -o image_export.tar <image_name>
     

综上所述，docker export 用于导出容器的文件系统，而 docker save 用于导出整个镜像，包含了镜像的元数据和图层信息。它们的使用场景和导出内容不同，需要根据具体的需求来选择使用哪个命令。

import、load

docker import 和 docker load 都是用于将文件或目录导入到 Docker 镜像中，但它们之间有一些重要的区别。

1. docker import:

   • 功能：docker import 用于将本地文件系统中的文件或目录导入为 Docker 镜像。

   • 适用对象：import 恢复为的镜像只包含当前镜像一层。适用于从文件或目录创建一个新的、空白的镜像，并且通常用于简单的镜像构建。它并不处理 Dockerfile 或构建上下文。

   • 输入来源：可以从本地文件路径、远程 URL 或标准输入导入数据。

   • 镜像名称和标签：可以选择指定导入的镜像的名称和标签。import 可以为导入的镜像指定与

   • 示例：

     # 从本地目录导入为镜像
     docker import /path/to/local/directory myimage:latest
     
     # 从 URL 导入为镜像
     docker import http://example.com/myimage.tar.gz myimage:latest
     

2. docker load:

   • 功能：docker load 用于从 Docker 存档文件中（通常是由 docker save 命令生成的）恢复镜像和容器的内容。

   • 适用对象：适用于将完整的镜像及其所有的历史信息导入到 Docker，并还原成完整的镜像。可以包含多个镜像和标签。

   • 输入来源：从本地文件系统中的 Docker 存档文件（.tar）导入数据。

   • 镜像名称和标签：存档文件中已经包含了镜像的名称和标签信息。load 加载的镜像不能指定与，与原镜像的相同

   • 示例：

     # 从 Docker 存档文件导入镜像
     docker load -i myimage.tar.gz
     

综上所述，docker import 适用于简单的文件或目录导入为镜像，而 docker load 用于从 Docker 存档文件中还原完整的镜像及其历史信息。选择使用哪个命令取决于你的需求，如果要创建新的镜像并手动添加额外的内容，可以使用 docker import；如果要还原包含多个镜像及其历史的存档文件，应该使用 docker load。

commit、export+import

• 相同点：docker export + docker import 会将一个容器变为一个镜像，docker commit 也可以将一个容器变一个镜像。
• 不同点：docker export + docker import 恢复的镜像仅包含原容器生成的一层分层，docker commit 生成的镜像中包含容器的原镜像的所有分层信息。