Docker - 快速指南

---

---

Docker - 概述

Docker 是一种容器管理服务。Docker 的关键词是 **开发、交付** 和 **运行** 在任何地方。Docker 的核心思想是让开发者能够轻松开发应用程序，并将它们打包到容器中，然后可以在任何地方部署。

Docker 的首次发布是在 2013 年 3 月，从那时起，它就成为了现代世界开发的热门词汇，尤其是在基于敏捷的项目中。

Docker 的特性

• Docker 通过提供更小的操作系统占用空间（通过容器）来降低开发规模。

• 通过容器，不同部门的团队（例如开发、QA 和运维）可以更轻松地在应用程序之间无缝协作。

• 您可以在任何地方部署 Docker 容器，包括任何物理机和虚拟机，甚至云环境。

• 由于 Docker 容器非常轻量级，因此非常易于扩展。

Docker 的组件

Docker 包含以下组件

• Docker for Mac - 它允许在 Mac OS 上运行 Docker 容器。

• Docker for Linux - 它允许在 Linux OS 上运行 Docker 容器。

• Docker for Windows - 它允许在 Windows OS 上运行 Docker 容器。

• Docker Engine - 用于构建 Docker 镜像和创建 Docker 容器。

• Docker Hub - 这是用于托管各种 Docker 镜像的注册表。

• Docker Compose - 用于使用多个 Docker 容器定义应用程序。

我们将在后续章节中详细讨论所有这些组件。

Docker 的官方网站是 https://www.docker.com/ 该网站包含有关 Docker 软件的所有信息和文档。它还提供了各种操作系统的下载链接。

在 Linux 上安装 Docker

要开始安装 Docker，我们将使用一个 Ubuntu 实例。如果您还没有，可以使用 Oracle Virtual Box 设置一个虚拟 Linux 实例。

以下屏幕截图显示了一个简单的 Ubuntu 服务器，它已安装在 Oracle Virtual Box 上。系统上定义了一个名为 **demo** 的 OS 用户，该用户拥有对服务器的完全 root 访问权限。

要安装 Docker，我们需要按照以下步骤操作。

步骤 1 - 在安装 Docker 之前，您首先需要确保正在运行正确的 Linux 内核版本。Docker 仅设计为在 Linux 内核版本 3.8 及更高版本上运行。我们可以通过运行以下命令来执行此操作。

uname

此方法返回有关 Linux 系统的系统信息。

语法

uname -a

选项

a - 用于确保返回系统信息。

返回值

此方法在 Linux 系统上返回以下信息 -

• 内核名称
• 节点名称
• 内核版本
• 内核版本号
• 机器
• 处理器
• 硬件平台
• 操作系统

示例

uname –a

输出

当我们运行上述命令时，我们将获得以下结果 -

从输出中，我们可以看到 Linux 内核版本为 4.2.0-27，高于版本 3.8，因此我们可以继续。

步骤 2 - 您需要使用以下命令更新操作系统以获取最新的软件包 -

apt-get

此方法将从 Internet 上安装软件包到 Linux 系统。

语法

sudo apt-get update

选项

• sudo - sudo 命令用于确保命令以 root 权限运行。

• update - update 选项用于确保 Linux 系统上的所有软件包都已更新。

返回值

无

示例

sudo apt-get update

输出

当我们运行上述命令时，我们将获得以下结果 -

此命令将连接到 Internet 并下载 Ubuntu 的最新系统软件包。

步骤 3 - 下一步是安装以后与 Docker 站点一起使用以下载必要的 Docker 软件包所需的必要证书。可以使用以下命令完成。

sudo apt-get install apt-transport-https ca-certificates

步骤 4 - 下一步是添加新的 GPG 密钥。此密钥用于确保在下载 Docker 的必要软件包时所有数据都已加密。

以下命令将从 **密钥服务器** hkp://ha.pool.sks-keyservers.net:80 下载 ID 为 58118E89F3A912897C070ADBF76221572C52609D 的密钥，并将其添加到 **adv** 密钥环。请注意，此特定密钥是下载必要的 Docker 软件包所必需的。

步骤 5 - 接下来，根据您使用的 Ubuntu 版本，您需要将相关站点添加到 **docker.list**（用于 **apt 软件包管理器**），以便它能够从 Docker 站点检测 Docker 软件包并相应地下载它们。

• Precise 12.04 (LTS) ─ deb https://apt.dockerproject.org/repoubuntu-precise main

• Trusty 14.04 (LTS) ─ deb https://apt.dockerproject.org/repo/ ubuntu-trusty main

• Wily 15.10 ─ deb https://apt.dockerproject.org/repo ubuntu-wily main

• Xenial 16.04 (LTS) - https://apt.dockerproject.org/repo ubuntu-xenial main

由于我们的操作系统是 Ubuntu 14.04，因此我们将使用存储库名称“deb https://apt.dockerproject.org/repoubuntu-trusty main”。

然后，我们需要将此存储库添加到上面提到的 **docker.list** 中。

echo "deb https://apt.dockerproject.org/repo ubuntu-trusty main” 
   | sudo tee /etc/apt/sources.list.d/docker.list

步骤 6 - 接下来，我们发出 **apt-get update 命令** 来更新 Ubuntu 系统上的软件包。

步骤 7 - 如果您想验证软件包管理器是否指向正确的存储库，可以通过发出 **apt-cache 命令** 来执行此操作。

apt-cache policy docker-engine

在输出中，您将获得指向 https://apt.dockerproject.org/repo/ 的链接

步骤 8 - 发出 **apt-get update 命令** 以确保本地系统上的所有软件包都已更新。

步骤 9 - 对于 Ubuntu Trusty、Wily 和 Xenial，我们必须安装 linux-image-extra-* 内核软件包，这允许使用 **aufs 存储驱动程序**。此驱动程序由较新版本的 Docker 使用。

可以使用以下命令完成。

sudo apt-get install linux-image-extra-$(uname -r) 
   linux-image-extra-virtual

步骤 10 - 最后一步是安装 Docker，我们可以使用以下命令来完成 -

sudo apt-get install –y docker-engine

这里，**apt-get** 使用 install 选项从 Docker 网站下载 Docker-engine 镜像并安装 Docker。

Docker-engine 是 Docker 公司为基于 Ubuntu 的系统提供的官方软件包。

在下一节中，我们将了解如何检查已安装的 Docker 版本。

Docker 版本

要查看正在运行的 Docker 版本，您可以发出以下命令 -

语法

docker version 

选项

• version - 用于确保 Docker 命令返回已安装的 Docker 版本。

返回值

输出将提供有关系统上安装的 Docker 版本的各种详细信息。

示例

sudo docker version 

输出

当我们运行上述程序时，我们将获得以下结果 -

Docker 信息

要查看有关系统上运行的 Docker 的更多信息，您可以发出以下命令 -

语法

docker info

选项

• info - 用于确保 Docker 命令返回有关已安装的 Docker 服务的详细信息。

返回值

输出将提供有关系统上安装的 Docker 的各种详细信息，例如 -

• 容器数量
• 镜像数量
• Docker 使用的存储驱动程序
• Docker 使用的根目录
• Docker 使用的执行驱动程序

示例

sudo docker info

输出

当我们运行上述命令时，我们将获得以下结果 -

Docker for Windows

Docker 对 Windows 具有开箱即用的支持，但您需要具有以下配置才能安装 Docker for Windows。

系统要求

您可以从以下位置下载 Docker for Windows - https://docs.container.net.cn/docker-for-windows/

Docker 工具箱

Docker 工具箱专为旧版 Windows（如 Windows 8.1 和 Windows 7）设计。您需要具有以下配置才能安装 Docker for Windows。

系统要求

您可以从以下位置下载 Docker 工具箱 - https://www.docker.com/products/docker-toolbox

Docker - 安装

让我们了解每个产品的安装过程。

Docker for Windows

下载安装程序后，双击它以启动安装程序，然后按照以下步骤操作。

步骤 1 - 单击“协议条款”，然后单击“安装”按钮以继续安装。

步骤 2 - 完成后，单击“完成”按钮以完成安装。

Docker 工具箱

下载安装程序后，双击它以启动安装程序，然后按照以下步骤操作。

步骤 1 - 在开始屏幕上单击“下一步”按钮。

步骤 2 - 在下一个屏幕上保留默认位置，然后单击“下一步”按钮。

步骤 3 - 保留默认组件，然后单击“下一步”按钮继续。

步骤 4 − 保持其他任务不变，然后单击“下一步”按钮。

步骤 5 − 在最终屏幕上，单击“安装”按钮。

使用 Docker Toolbox

现在让我们看看如何使用 Docker Toolbox 在 Windows 上使用 Docker 容器。第一步是启动 Docker Toolbox 应用程序，在安装 Docker Toolbox 时会在桌面上创建该应用程序的快捷方式。

接下来，您将在启动 Docker Toolbox 时看到配置正在进行。

完成后，您将看到 Docker 已配置并启动。您将获得 Docker 的交互式 Shell。

为了测试 Docker 是否正常运行，我们可以使用 Docker 的run 命令下载并运行一个简单的HelloWorld Docker 容器。

Docker run 命令的工作原理如下所示：

docker run 

此命令用于在 Docker 容器中运行命令。

语法

docker run image

选项

• 镜像 − 这是用于运行容器的镜像名称。

返回值

输出将在所需的容器中运行命令。

示例

sudo docker run hello-world

此命令将下载hello-world镜像（如果尚未存在），并以容器的形式运行hello-world。

输出

当我们运行上述命令时，我们将获得以下结果 -

如果要在 Windows 上运行 Ubuntu 操作系统，可以使用以下命令下载 Ubuntu 镜像：

Docker run –it ubuntu bash

在这里，您告诉 Docker 通过–it选项以交互模式运行该命令。

在输出中，您可以看到 Ubuntu 镜像已下载并运行，然后您将以 root 用户身份登录到 Ubuntu 容器中。

Docker - Hub

Docker Hub 是一个云上的注册表服务，允许您下载其他社区构建的 Docker 镜像。您还可以将自己构建的 Docker 镜像上传到 Docker Hub。在本章中，我们将了解如何从 Docker Hub 下载并使用 Jenkins Docker 镜像。

Docker Hub 的官方网站为：https://www.docker.com/community-edition#/add_ons

步骤 1 − 首先，您需要在 Docker Hub 上进行简单的注册。

步骤 2 − 注册完成后，您将登录到 Docker Hub。

步骤 3 − 接下来，让我们浏览并找到 Jenkins 镜像。

步骤 4 − 如果向下滚动同一页面，您可以看到 Docker 的pull命令。这将用于将 Jenkins 镜像下载到本地 Ubuntu 服务器上。

步骤 5 − 现在，转到 Ubuntu 服务器并运行以下命令：

sudo docker pull jenkins 

要运行 Jenkins，您需要运行以下命令：

sudo docker run -p 8080:8080 -p 50000:50000 jenkins 

请注意上述sudo命令的以下几点：

• 我们使用sudo命令确保它以 root 权限运行。

• 这里，jenkins是我们想要从 Docker Hub 下载并在我们的 Ubuntu 机器上安装的镜像名称。

• -p用于将内部 Docker 镜像的端口号映射到我们的主 Ubuntu 服务器，以便我们可以相应地访问容器。

然后，您将成功地在 Ubuntu 机器上以容器形式运行 Jenkins。

Docker - 镜像

在 Docker 中，一切都是基于镜像的。镜像是文件系统和参数的组合。让我们以 Docker 中的以下命令为例。

docker run hello-world 

• Docker 命令是特定的，它告诉操作系统上的 Docker 程序需要执行某些操作。

• run命令用于表示我们想要创建镜像的实例，然后该实例被称为容器。

• 最后，“hello-world”表示创建容器的镜像。

现在让我们看看如何使用 Docker Hub 中提供的 CentOS 镜像在 Ubuntu 机器上运行 CentOS。我们可以通过在 Ubuntu 机器上执行以下命令来实现：

sudo docker run centos –it /bin/bash

请注意上述sudo命令的以下几点：

• 我们使用sudo命令确保它以root权限运行。

• 这里，centos是我们想要从 Docker Hub 下载并在我们的 Ubuntu 机器上安装的镜像名称。

• ─it用于表示我们想要以交互模式运行。

• /bin/bash用于在 CentOS 启动并运行后运行 bash shell。

显示 Docker 镜像

要查看系统上的 Docker 镜像列表，您可以发出以下命令。

docker images

此命令用于显示当前安装在系统上的所有镜像。

语法

docker images 

选项

无

返回值

输出将提供系统上的镜像列表。

示例

sudo docker images

输出

当我们运行上述命令时，它将产生以下结果：

从上述输出中，您可以看到服务器上有三个镜像：centos、newcentos和jenkins。每个镜像都具有以下属性：

• TAG − 用于对镜像进行逻辑标记。

• 镜像 ID − 用于唯一标识镜像。

• 创建时间 − 镜像创建至今的天数。

• 虚拟大小 − 镜像的大小。

下载 Docker 镜像

可以使用 Docker 的run命令从 Docker Hub 下载镜像。让我们详细了解如何做到这一点。

语法

以下语法用于在 Docker 容器中运行命令。

docker run image 

选项

• 镜像 − 这是用于运行容器的镜像名称。

返回值

输出将在所需的容器中运行命令。

示例

sudo docker run centos

此命令将下载centos镜像（如果尚未存在），并以容器的形式运行操作系统。

输出

当我们运行上述命令时，我们将获得以下结果 -

您现在将看到 CentOS Docker 镜像已下载。现在，如果我们运行 Docker 的images命令以查看系统上的镜像列表，我们应该能够看到centos镜像。

删除 Docker 镜像

可以使用docker rmi命令删除系统上的 Docker 镜像。让我们更详细地了解此命令。

docker rmi

此命令用于删除 Docker 镜像。

语法

docker rmi ImageID

选项

• 镜像 ID − 需要删除的镜像的 ID。

返回值

输出将提供已删除镜像的镜像 ID。

示例

sudo docker rmi 7a86f8ffcb25 

这里，7a86f8ffcb25是newcentos镜像的镜像 ID。

输出

当我们运行上述命令时，它将产生以下结果：

让我们再看看一些关于镜像的 Docker 命令。

docker images -q

此命令用于仅返回镜像的镜像 ID。

语法

docker images 

选项

• q − 它告诉 Docker 命令仅返回镜像 ID。

返回值

输出将仅显示 Docker 主机上镜像的镜像 ID。

示例

sudo docker images -q 

输出

当我们运行上述命令时，它将产生以下结果：

docker inspect

此命令用于查看镜像或容器的详细信息。

语法

docker inspect Repository 

选项

• 仓库 − 这是镜像的名称。

返回值

输出将显示镜像的详细信息。

示例

sudo docker inspect jenkins 

输出

当我们运行上述命令时，它将产生以下结果：

Docker - 容器

容器是 Docker 镜像的实例，可以使用 Docker run 命令运行。Docker 的基本目的是运行容器。让我们讨论如何使用容器。

运行容器

容器的运行由 Docker 的run命令管理。要在交互模式下运行容器，首先启动 Docker 容器。

sudo docker run –it centos /bin/bash 

然后按 Crtl+p，您将返回到操作系统 Shell。

然后，您将在 Ubuntu 服务器上的 CentOS 系统实例中运行。

列出容器

可以通过docker ps命令列出机器上的所有容器。此命令用于返回当前正在运行的容器。

docker ps

语法

docker ps 

选项

无

返回值

输出将显示当前正在运行的容器。

示例

sudo docker ps

输出

当我们运行上述命令时，它将产生以下结果：

让我们看看docker ps命令的一些其他变体。

docker ps -a

此命令用于列出系统上的所有容器

语法

docker ps -a 

选项

• ─a − 它告诉docker ps命令列出系统上的所有容器。

返回值

输出将显示所有容器。

示例

sudo docker ps -a 

输出

当我们运行上述命令时，它将产生以下结果：

docker history

使用此命令，您可以查看通过容器对镜像运行的所有命令。

语法

docker history ImageID 

选项

• 镜像 ID − 这是您想要查看其所有运行命令的镜像 ID。

返回值

输出将显示针对该镜像运行的所有命令。

示例

sudo docker history centos

上述命令将显示针对centos镜像运行的所有命令。

输出

当我们运行上述命令时，它将产生以下结果：

Docker - 使用容器

在本章中，我们将详细探讨可以使用容器执行的操作。

docker top

使用此命令，您可以查看容器内的顶级进程。

语法

docker top ContainerID 

选项

• 容器 ID − 这是您想要查看其顶级进程的容器 ID。

返回值

输出将显示容器内的顶级进程。

示例

sudo docker top 9f215ed0b0d3 

上述命令将显示容器内的顶级进程。

输出

当我们运行上述命令时，它将产生以下结果：

docker stop

此命令用于停止正在运行的容器。

语法

docker stop ContainerID 

选项

• 容器 ID − 需要停止的容器 ID。

返回值

输出将给出已停止容器的 ID。

示例

sudo docker stop 9f215ed0b0d3 

上述命令将停止 Docker 容器9f215ed0b0d3。

输出

当我们运行上述命令时，它将产生以下结果：

docker rm

此命令用于删除容器。

语法

docker rm ContainerID 

选项

• 容器 ID − 需要删除的容器 ID。

返回值

输出将给出已删除容器的 ID。

示例

sudo docker rm 9f215ed0b0d3 

上述命令将删除 Docker 容器9f215ed0b0d3。

输出

当我们运行上述命令时，它将产生以下结果：

docker stats

此命令用于提供正在运行的容器的统计信息。

语法

docker stats ContainerID 

选项

• 容器 ID − 需要提供统计信息的容器 ID。

返回值

输出将显示容器的 CPU 和内存使用情况。

示例

sudo docker stats 9f215ed0b0d3 

上述命令将提供容器9f215ed0b0d3的 CPU 和内存使用情况。

输出

当我们运行上述命令时，它将产生以下结果：

docker attach

此命令用于附加到正在运行的容器。

语法

docker attach ContainerID 

选项

• 容器 ID − 需要附加到的容器 ID。

返回值

无

示例

sudo docker attach 07b0b6f434fe 

上述命令将附加到 Docker 容器07b0b6f434fe。

输出

当我们运行上述命令时，它将产生以下结果：

附加到 Docker 容器后，您可以运行上述命令以查看该 Docker 容器中的进程使用情况。

docker pause

此命令用于暂停正在运行的容器中的进程。

语法

docker pause ContainerID 

选项

• 容器 ID − 需要暂停容器中进程的容器 ID。

返回值

已暂停容器的容器 ID。

示例

sudo docker pause 07b0b6f434fe 

上述命令将暂停正在运行的容器07b0b6f434fe中的进程。

输出

当我们运行上述命令时，它将产生以下结果：

docker unpause

此命令用于恢复正在运行的容器中的进程。

语法

docker unpause ContainerID

选项

• 容器 ID − 需要恢复容器中进程的容器 ID。

返回值

正在运行的容器的容器 ID。

示例

sudo docker unpause 07b0b6f434fe 

上述命令将恢复正在运行的容器07b0b6f434fe中的进程。

输出

当我们运行上述命令时，它将产生以下结果：

docker kill

此命令用于杀死正在运行的容器中的进程。

语法

docker kill ContainerID

选项

• 容器 ID − 需要杀死容器中进程的容器 ID。

返回值

正在运行的容器的容器 ID。

示例

sudo docker kill 07b0b6f434fe 

上述命令将杀死正在运行的容器07b0b6f434fe中的进程。

输出

当我们运行上述命令时，它将产生以下结果：

Docker – 容器生命周期

下图说明了 Docker 容器的整个生命周期。

• 最初，Docker 容器将处于已创建状态。

• 然后，当使用 Docker 的run命令时，Docker 容器将进入运行状态。

• Docker 的kill命令用于杀死现有的 Docker 容器。

• Docker 的pause命令用于暂停现有的 Docker 容器。

• Docker 的stop命令用于暂停现有的 Docker 容器。

• Docker 的 **run** 命令用于将容器从 **停止** 状态恢复到 **运行** 状态。

Docker - 架构

下图显示了 **虚拟化** 的标准架构和传统架构。

• 服务器是用于托管多个虚拟机的物理服务器。

• 主机操作系统是基础机器，例如 Linux 或 Windows。

• 管理程序可以是 VMWare 或 Windows Hyper V，用于托管虚拟机。

• 然后，您可以在现有的管理程序之上安装多个操作系统作为虚拟机，作为访客操作系统。

• 然后，您将在每个访客操作系统上托管您的应用程序。

下图显示了通过 Docker 实现的新一代虚拟化。让我们看一下各个层。

• 服务器是用于托管多个虚拟机的物理服务器。因此，此层保持不变。

• 主机操作系统是基础机器，例如 Linux 或 Windows。因此，此层保持不变。

• 现在出现了新一代技术，即 Docker 引擎。它用于运行操作系统，而以前是将虚拟机作为 Docker 容器运行。

• 所有应用程序现在都作为 Docker 容器运行。

这种架构的明显优势在于，您不需要为访客操作系统配备额外的硬件。一切都可以作为 Docker 容器运行。

Docker - 容器和主机

Docker 引擎的一大优点是它设计为可以在各种操作系统上运行。我们已经看到了在 Windows 上的安装，以及在 Linux 系统上所有 Docker 命令的使用。现在让我们看看在 Windows 操作系统上的各种 Docker 命令。

Docker 镜像

让我们在 Windows 主机上运行 Docker **images** 命令。

从这里我们可以看到，我们有两个镜像 - **ubuntu** 和 **hello-world**。

运行容器

现在让我们在 Windows Docker 主机上运行一个容器。

我们可以看到，通过运行容器，我们现在可以在 Windows 主机上运行 Ubuntu 容器。

列出所有容器

让我们列出 Windows 主机上的所有容器。

停止容器

现在让我们停止 Windows 主机上正在运行的容器。

因此，您可以看到 Docker 引擎在不同的 Docker 主机上非常一致，它在 Windows 上的工作方式与在 Linux 上相同。

Docker - 配置

在本章中，我们将了解配置 Docker 的不同选项。

service docker stop

此命令用于停止 Docker **守护进程**。

语法

service docker stop 

选项

无

返回值

显示 Docker 进程已停止的消息。

示例

sudo service docker stop 

输出

当我们运行上述命令时，它将产生以下结果：

service docker start

此命令用于启动 Docker 守护进程。

语法

service docker start 

选项

无

返回值

显示 Docker 进程已启动的消息。

示例

sudo service docker start

输出

当我们运行上述命令时，它将产生以下结果：

Docker - 容器和 Shell

默认情况下，当您启动容器时，您还将在启动容器时使用 **shell 命令**，如下所示。这正是我们在前面章节中处理容器时所看到的。

在上面的屏幕截图中，您可以看到我们发出了以下命令：

sudo docker run –it centos /bin/bash 

我们使用此命令创建了一个新容器，然后使用 Ctrl+P+Q 命令退出容器。它确保即使我们在退出容器后，容器仍然存在。

我们可以使用 Docker **ps** 命令验证容器是否仍然存在。如果我们直接退出容器，则容器本身将被销毁。

现在有一种更简单的方法可以连接到容器并干净地退出，而无需销毁它们。实现此目的的一种方法是使用 **nsenter** 命令。

在运行 **nsenter** 命令之前，您需要先安装 **nsenter** 镜像。可以使用以下命令完成：

docker run --rm -v /usr/local/bin:/target jpetazzo/nsenter

在使用 **nsenter** 命令之前，我们需要获取容器的进程 ID，因为 **nsenter** 命令需要此 ID。我们可以通过 Docker **inspect 命令**获取进程 ID，并通过 **Pid** 进行过滤。

如上图所示，我们首先使用了 **docker ps** 命令查看正在运行的容器。我们可以看到有一个正在运行的容器，其 ID 为 ef42a4c5e663。

然后，我们使用 Docker **inspect** 命令检查此容器的配置，然后使用 **grep** 命令仅过滤进程 ID。从输出中，我们可以看到进程 ID 为 2978。

现在我们有了进程 ID，就可以继续使用 **nsenter** 命令连接到 Docker 容器。

nsenter

此方法允许用户连接到容器而无需退出容器。

语法

nsenter –m –u –n –p –i –t containerID command

选项

• **-u** 用于指定 **Uts 命名空间**

• **-m** 用于指定 **挂载命名空间**

• **-n** 用于指定 **网络命名空间**

• **-p** 用于指定 **进程命名空间**

• **-i** 用于使容器以交互模式运行。

• **-t** 用于将容器的 I/O 流连接到主机操作系统。

• **containerID** - 这是容器的 ID。

• **Command** - 这是要在容器内运行的命令。

返回值

无

示例

sudo nsenter –m –u –n –p –i –t 2978 /bin/bash

输出

从输出中，我们可以观察到以下几点：

• 当我们发出 **nsenter** 命令时，提示符会直接更改为 **bash shell**。

• 然后我们发出 **exit** 命令。现在，通常情况下，如果您没有使用 **nsenter** 命令，则容器将被销毁。但是您会注意到，当我们运行 **nsenter** 命令时，容器仍在运行。

Docker - 文件

在前面的章节中，我们已经看到了各种镜像文件，例如从 **Docker Hub** 下载的 Centos，您可以从中启动容器。下面再次显示了一个示例。

如果我们使用 Docker **images** 命令，我们可以看到系统中现有的镜像。从上面的屏幕截图中，我们可以看到有两个镜像：**centos** 和 **nsenter**。

但是 Docker 还使您能够创建自己的 Docker 镜像，这可以通过 **Docker 文件** 来完成。Docker 文件是一个简单的文本文件，其中包含有关如何构建镜像的说明。

以下步骤说明了您应该如何创建 Docker 文件。

**步骤 1** - 创建一个名为 **Docker 文件** 的文件，并使用 **vim** 进行编辑。请注意，文件名必须为“Dockerfile”，其中“D”为大写。

**步骤 2** - 使用以下说明构建 Docker 文件。

#This is a sample Image 
FROM ubuntu 
MAINTAINER demousr@gmail.com 

RUN apt-get update 
RUN apt-get install –y nginx 
CMD [“echo”,”Image created”] 

关于上述文件，需要注意以下几点：

• 第一行“#This is a sample Image”是注释。您可以使用 **#** 命令在 Docker 文件中添加注释

• 下一行必须以 **FROM** 关键字开头。它告诉 Docker，您要从哪个基础镜像构建您的镜像。在我们的示例中，我们正在从 **ubuntu** 镜像创建镜像。

• 下一个命令是将要维护此镜像的人员。在此处，您指定 **MAINTAINER** 关键字并仅提及电子邮件 ID。

• **RUN** 命令用于对镜像运行指令。在我们的例子中，我们首先更新 Ubuntu 系统，然后在我们的 **ubuntu** 镜像上安装 nginx 服务器。

• 最后一个命令用于向用户显示消息。

**步骤 3** - 保存文件。在下一章中，我们将讨论如何构建镜像。

Docker - 构建文件

我们在上一章创建了 Docker 文件。现在是时候构建 Docker 文件了。Docker 文件可以使用以下命令构建：

docker build 

让我们进一步了解此命令。

docker build

此方法允许用户构建自己的 Docker 镜像。

语法

docker build  -t ImageName:TagName dir

选项

• **-t** - 用于为镜像指定标签

• **ImageName** - 这是您要给镜像起的名称。

• **TagName** - 这是您要给镜像起的标签。

• **Dir** - Docker 文件所在的目录。

返回值

无

示例

sudo docker build –t myimage:0.1. 

这里，**myimage** 是我们给镜像起的名称，**0.1** 是我们给镜像起的标签号。

由于 Docker 文件位于当前工作目录中，因此我们在命令末尾使用了“.”来表示当前工作目录。

输出

从输出中，您首先会看到 Ubuntu 镜像将从 Docker Hub 下载，因为机器上本地没有可用的镜像。

最后，当构建完成时，所有必要的命令都将在镜像上运行。

然后您将看到成功构建的消息和新镜像的 ID。当您运行 Docker **images 命令**时，您将能够看到您的新镜像。

您现在可以从您的新镜像构建容器。

Docker - 公共仓库

公共存储库可用于托管 Docker 镜像，其他人可以使用这些镜像。例如，Docker Hub 上可用的镜像。大多数镜像，例如 Centos、Ubuntu 和 Jenkins，都对所有人公开可用。我们还可以通过将其发布到 Docker Hub 上的公共存储库来使我们的镜像可用。

对于我们的示例，我们将使用在“构建 Docker 文件”一章中构建的 **myimage** 存储库并将该镜像上传到 Docker Hub。让我们首先查看 Docker 主机上的镜像，以了解我们可以推送到 Docker 注册表的内容。

这里，我们有我们的 **myimage:0.1** 镜像，它是作为“构建 Docker 文件”一章的一部分创建的。让我们使用它上传到 Docker 公共存储库。

以下步骤说明了如何将镜像上传到公共存储库。

**步骤 1** - 登录 Docker Hub 并创建您的存储库。这是存储镜像的存储库。转到 https://hub.docker.com/ 并使用您的凭据登录。

**步骤 2** - 单击上述屏幕上的“创建存储库”按钮，并创建一个名为 **demorep** 的存储库。确保存储库的可见性为公开。

创建存储库后，请记下附加到存储库的 **pull** 命令。

将在我们的存储库中使用的 **pull** 命令如下：

docker pull demousr/demorep

**步骤 3** - 现在返回到 Docker 主机。在这里，我们需要将我们的 **myimage** 标记到 Docker Hub 中创建的新存储库。我们可以通过 Docker **tag 命令**来完成此操作。

我们将在本章后面进一步了解此 **tag 命令**。

**步骤 4** - 发出 Docker login 命令，从命令提示符登录到 Docker Hub 存储库。Docker login 命令将提示您输入 Docker Hub 存储库的用户名和密码。

**步骤 5** - 标记镜像后，现在是时候将镜像推送到 Docker Hub 存储库了。我们可以通过 Docker **push** 命令来完成此操作。我们将在本章后面进一步了解此命令。

docker tag

此方法允许用户将镜像标记到相关的存储库。

语法

docker tag imageID Repositoryname 

选项

• imageID − 需要标记到存储库的 ImageID。

• Repositoryname − 需要将 ImageID 标记到的存储库名称。

返回值

无

示例

sudo docker tag ab0c1d3744dd demousr/demorep:1.0

输出

下面给出了上述示例的输出示例。

docker push

此方法允许将镜像推送到 Docker Hub。

语法

docker push Repositoryname 

选项

• Repositoryname − 需要推送到 Docker Hub 的存储库名称。

返回值

推送到 Docker Hub 的存储库的长 ID。

示例

sudo docker push demousr/demorep:1.0 

输出

如果您返回到 Docker Hub 页面并转到您的存储库，您将在存储库中看到标签名称。

现在让我们尝试将我们上传到 Docker 主机的存储库拉取到本地。首先，让我们从本地 Docker 主机删除镜像 myimage:0.1 和 demousr/demorep:1.0。让我们使用 Docker 的 pull 命令从 Docker Hub 拉取存储库。

从上面的屏幕截图中，您可以看到 Docker 的 pull 命令已从 Docker Hub 获取我们的新存储库并将其放置在我们的机器上。

Docker - 管理端口

在 Docker 中，容器本身可以在端口上运行应用程序。当您运行容器时，如果要通过端口号访问容器中的应用程序，则需要将容器的端口号映射到 Docker 主机的端口号。让我们来看一个如何实现此目的的示例。

在我们的示例中，我们将从 Docker Hub 下载 Jenkins 容器。然后，我们将 Jenkins 端口号映射到 Docker 主机上的端口号。

步骤 1 − 首先，您需要在 Docker Hub 上进行简单的注册。

步骤 2 − 注册完成后，您将登录到 Docker Hub。

步骤 3 − 接下来，让我们浏览并找到 Jenkins 镜像。

步骤 4 − 如果您向下滚动到同一页面，您将看到 Docker 的 pull 命令。这将用于将 Jenkins 镜像下载到本地 Ubuntu 服务器上。

步骤 5 − 现在转到 Ubuntu 服务器并运行以下命令 −

sudo docker pull jenkins 

步骤 6 − 要了解容器公开了哪些端口，您应该使用 Docker 的 inspect 命令检查镜像。

现在让我们进一步了解此 inspect 命令。

docker inspect

此方法允许返回有关容器或镜像的低级信息。

语法

docker inspect Container/Image 

选项

• Container/Image − 要检查的容器或镜像

返回值

镜像或容器的低级信息，以 JSON 格式呈现。

示例

sudo docker inspect jenkins 

输出

inspect 命令的输出将以 JSON 格式显示。如果我们观察输出，我们可以看到有一个“ExposedPorts”部分，并且看到提到了两个端口。一个是 8080 的数据端口，另一个是 50000 的控制端口。

要运行 Jenkins 并映射端口，您需要更改 Docker 的 run 命令并添加“p”选项，该选项指定端口映射。因此，您需要运行以下命令 −

sudo docker run -p 8080:8080 -p 50000:50000 jenkins 

端口号映射的左侧是 Docker 主机要映射到的端口，右侧是 Docker 容器的端口号。

当您打开浏览器并导航到端口 8080 上的 Docker 主机时，您将看到 Jenkins 正在运行。

Docker - 私有注册表

您可能需要拥有自己的私有存储库。您可能不想在 Docker Hub 上托管存储库。为此，Docker 本身提供了一个存储库容器。让我们看看如何下载和使用用于注册表的容器。

步骤 1 − 使用 Docker 的 run 命令下载私有注册表。这可以通过以下命令完成。

sudo docker run –d –p 5000:5000 –-name registry registry:2

关于上述命令，需要注意以下几点 −

• Registry 是 Docker 管理的容器，可用于托管私有存储库。

• 容器公开的端口号为 5000。因此，使用 –p 命令，我们将相同的端口号映射到本地主机的 5000 端口号。

• 我们只是将注册表容器标记为“2”，以便在 Docker 主机上进行区分。

• –d 选项用于在分离模式下运行容器。这样容器就可以在后台运行。

步骤 2 − 让我们执行 docker ps 以查看注册表容器是否确实正在运行。

我们现在已确认注册表容器确实正在运行。

步骤 3 − 现在让我们标记我们现有的镜像之一，以便我们可以将其推送到我们的本地存储库。在我们的示例中，由于我们本地有 centos 镜像，我们将将其标记到我们的私有存储库并添加一个名为 centos 的标签。

sudo docker tag 67591570dd29 localhost:5000/centos 

关于上述命令，需要注意以下几点 −

• 67591570dd29 指的是 centos 镜像的镜像 ID。

• localhost:5000 是我们私有存储库的位置。

• 我们在私有存储库中将存储库名称标记为 centos。

步骤 4 − 现在让我们使用 Docker 的 push 命令将存储库推送到我们的私有存储库。

sudo docker push localhost:5000/centos 

在这里，我们将 centos 镜像推送到托管在 localhost:5000 上的私有存储库。

步骤 5 − 现在让我们使用 docker rmi 命令删除我们为 centos 拥有的本地镜像。然后，我们可以从我们的私有存储库下载所需的 centos 镜像。

sudo docker rmi centos:latest 
sudo docker rmi 67591570dd29

步骤 6 − 现在我们的本地机器上没有任何 centos 镜像，我们可以使用以下 Docker 的 pull 命令从我们的私有存储库拉取 centos 镜像。

sudo docker pull localhost:5000/centos

在这里，我们正在将 centos 镜像拉取到托管在 localhost:5000 上的私有存储库。

如果您现在查看系统上的镜像，您也将看到 centos 镜像。

Docker - 构建 Web 服务器 Dockerfile

我们已经了解了如何使用 Dockerfile 构建我们自己的自定义镜像。现在让我们看看如何构建一个可用于构建容器的 Web 服务器镜像。

在我们的示例中，我们将使用 Ubuntu 上的 Apache Web 服务器来构建我们的镜像。让我们按照下面给出的步骤构建我们的 Web 服务器 Dockerfile。

步骤 1 − 第一步是构建我们的 Dockerfile。让我们使用 vim 并创建一个包含以下信息的 Dockerfile。

FROM ubuntu 
RUN apt-get update 
RUN apt-get install –y apache2 
RUN apt-get install –y apache2-utils 
RUN apt-get clean 
EXPOSE 80 CMD [“apache2ctl”, “-D”, “FOREGROUND”]

关于上述语句，需要注意以下几点 −

• 我们首先从 Ubuntu 基础镜像创建我们的镜像。

• 接下来，我们将使用 RUN 命令更新 Ubuntu 系统上的所有软件包。

• 接下来，我们使用 RUN 命令在我们的镜像上安装 apache2。

• 接下来，我们使用 RUN 命令在我们的镜像上安装必要的实用程序 apache2 软件包。

• 接下来，我们使用 RUN 命令清理系统中任何不必要的文件。

• EXPOSE 命令用于将容器中 Apache 的 80 端口公开到 Docker 主机。

• 最后，CMD 命令用于在后台运行 apache2。

现在文件详细信息已输入，只需保存文件即可。

步骤 2 − 运行 Docker 的 build 命令来构建 Dockerfile。这可以通过以下命令完成 −

sudo docker build –t=”mywebserver” . 

我们将镜像标记为 mywebserver。构建镜像后，您将收到一条成功消息，表明文件已构建。

步骤 3 − 现在 Web 服务器文件已构建，现在是时候从镜像创建容器了。我们可以使用 Docker 的 run 命令来实现。

sudo docker run –d –p 80:80 mywebserver 

关于上述命令，需要注意以下几点 −

• 容器公开的端口号为 80。因此，使用 –p 命令，我们将相同的端口号映射到本地主机的 80 端口号。

• –d 选项用于在分离模式下运行容器。这样容器就可以在后台运行。

如果您在 Web 浏览器中转到 Docker 主机上的 80 端口，您现在将看到 Apache 正在运行。

Docker - 指令命令

Docker 有一系列指令命令。这些是放在 Dockerfile 中的命令。让我们看看有哪些可用的命令。

CMD 指令

此命令用于在运行时执行容器执行时的命令。

语法

CMD command param1 

选项

• command − 这是在启动容器时要运行的命令。

• param1 − 这是输入到命令的参数。

返回值

命令将相应地执行。

示例

在我们的示例中，我们将在 Dockerfile 中输入一个简单的 Hello World 回显，并创建一个镜像并从中启动一个容器。

步骤 1 − 使用以下命令构建 Dockerfile −

FROM ubuntu 
MAINTAINER demousr@gmail.com 
CMD [“echo” , “hello world”] 

这里，CMD 只是用于打印 hello world。

步骤 2 − 使用 Docker 的 build 命令构建镜像。

步骤 3 − 从镜像运行一个容器。

ENTRYPOINT

此命令也可用于在运行时为容器执行命令。但是我们可以通过 ENTRYPOINT 命令获得更大的灵活性。

语法

ENTRYPOINT command param1 

选项

• command − 这是在启动容器时要运行的命令。

• param1 − 这是输入到命令的参数。

返回值

命令将相应地执行。

示例

让我们来看一个示例以进一步了解 ENTRYPOINT。在我们的示例中，我们将在 Dockerfile 中输入一个简单的 echo 命令，并创建一个镜像并从中启动一个容器。

步骤 1 − 使用以下命令构建 Dockerfile −

FROM ubuntu 
MAINTAINER demousr@gmail.com 
ENTRYPOINT [“echo”]

步骤 2 − 使用 Docker 的 build 命令构建镜像。

步骤 3 − 从镜像运行一个容器。

ENV

此命令用于在容器中设置环境变量。

语法

ENV key value 

选项

• Key − 这是环境变量的键。

• value − 这是环境变量的值。

返回值

命令将相应地执行。

示例

在我们的示例中，我们将在 Dockerfile 中输入一个简单的 echo 命令，并创建一个镜像并从中启动一个容器。

步骤 1 − 使用以下命令构建 Dockerfile −

FROM ubuntu 
MAINTAINER demousr@gmail.com 
ENV var1=Tutorial var2=point 

步骤 2 − 使用 Docker 的 build 命令构建镜像。

步骤 3 − 从镜像运行一个容器。

步骤 4 − 最后，执行 env 命令以查看环境变量。

WORKDIR

此命令用于设置容器的工作目录。

语法

WORKDIR dirname 

选项

• dirname − 新的工作目录。如果目录不存在，它将被添加。

返回值

命令将相应地执行。

示例

在我们的示例中，我们将在 Dockerfile 中输入一个简单的 echo 命令，并创建一个镜像并从中启动一个容器。

步骤 1 − 使用以下命令构建 Dockerfile −

FROM ubuntu 
MAINTAINER demousr@gmail.com 
WORKDIR /newtemp 
CMD pwd

步骤 2 − 使用 Docker 的 build 命令构建镜像。

步骤 3 − 从镜像运行一个容器。

Docker - 容器链接

容器链接允许多个容器相互链接。它是比公开端口更好的选择。让我们一步一步地学习它是如何工作的。

步骤 1 − 如果 Jenkins 镜像不存在，请使用 Jenkins 的 pull 命令下载它。

步骤 2 − 镜像可用后，运行容器，但这次您可以使用 –-name 选项为容器指定一个名称。这将是我们的 源容器。

步骤 3 − 接下来，是时候启动目标容器了，但这次我们将它与我们的源容器链接起来。对于我们的目标容器，我们将使用标准的 Ubuntu 镜像。

当您执行 docker ps 时，您将看到两个容器都在运行。

步骤 4 − 现在，连接到接收容器。

然后运行 env 命令。您将注意到与源容器链接的新变量。

Docker - 存储

存储驱动程序

Docker 具有多个存储驱动程序，允许用户与底层存储设备交互。下表显示了不同的存储驱动程序及其使用的技术。

现在让我们讨论一些您将使用各种存储驱动程序的情况 −

AUFS

• 这是一个稳定的驱动程序；可用于生产就绪型应用程序。

• 它具有良好的内存使用率，并且有助于确保容器拥有流畅的 Docker 体验。

• 此驱动程序与高写入活动相关联，应予以考虑。

• 它适用于平台即服务类型的系统。

Devicemapper

• 这是一个稳定的驱动程序；确保流畅的 Docker 体验。

• 此驱动程序适用于在实验室中测试应用程序。

• 此驱动程序与主 Linux 内核功能一致。

Btrfs

• 此驱动程序与主 Linux 内核功能一致。

• 此驱动程序与高写入活动相关联，应予以考虑。

• 此驱动程序适用于您维护多个构建池的实例。

Overlay

• 这是一个稳定的驱动程序，并且与主 Linux 内核功能一致。

• 它具有良好的内存使用率。

• 此驱动程序适用于在实验室中测试应用程序。

ZFS

• 这是一个稳定的驱动程序，并且适用于在实验室中测试应用程序。

• 它适用于平台即服务类型的系统。

要查看正在使用的存储驱动程序，请发出docker info命令。

语法

docker info 

选项

无

返回值

该命令将提供有关安装在 Docker 主机上的 Docker 组件的所有相关信息。

示例

sudo docker info 

输出

以下输出显示正在使用的主要驱动程序是aufs驱动程序，并且根目录存储在/var/lib/docker/aufs中。

数据卷

在 Docker 中，您有一个可以跨容器共享的单独卷。这些被称为数据卷。数据卷的一些功能包括：

• 它们在创建容器时初始化。
• 它们可以在许多容器之间共享和重用。
• 可以直接对卷本身进行任何更改。
• 即使容器被删除后，它们也仍然存在。

让我们看看我们的 Jenkins 容器。让我们执行一个docker inspect来查看此镜像的详细信息。我们可以发出以下命令将docker inspect命令的输出写入文本文件，然后相应地查看该文件。

sudo docker inspect Jenkins > tmp.txt

当您使用more 命令查看文本文件时，您将看到一个名为JENKINS_HOME=/var/Jenkins_home的条目。

这是通过 Jenkins 镜像在容器内完成的映射。

现在假设您想将容器中的卷映射到本地卷，那么您需要在启动容器时指定–v选项。下面显示了一个示例：

sudo docker run –d –v /home/demo:/var/jenkins_home –p 8080:8080 –p 50000:50000 jenkins 

–v选项用于将容器中的卷/var/jenkins_home映射到 Docker 主机上的位置/home/demo。

现在，如果您在启动容器后转到 Docker 主机上的/home/demo位置，您将看到所有容器文件都存在那里。

更改容器的存储驱动程序

如果您想更改用于容器的存储驱动程序，您可以在启动容器时执行此操作。这可以通过在使用docker run命令时使用–volume-driver参数来完成。下面给出了一个示例：

sudo docker run –d --volume-driver=flocker 
   –v /home/demo:/var/jenkins_home –p 8080:8080 –p 50000:50000 jenkins

–volume-driver选项用于为容器指定另一个存储驱动程序。

要确认驱动程序已更改，首先让我们使用docker ps命令查看正在运行的容器并获取容器 ID。因此，首先发出以下命令：

sudo docker ps

然后针对容器发出docker inspect并使用该命令将输出放入文本文件。

sudo docker inspect 9bffb1bfebee > temp.txt 

如果您浏览文本文件并转到显示VolumeDriver的行，您将看到驱动程序名称已更改。

创建卷

可以使用docker命令预先创建卷。让我们进一步了解此命令。

语法

docker volume create –-name=volumename –-opt options

选项

• name - 这是需要创建的卷的名称。

• opt - 这些是您在创建卷时可以提供的选项。

返回值

该命令将输出创建的卷的名称。

示例

sudo docker volume create –-name = demo –opt o = size = 100m 

在上面的命令中，我们正在创建一个大小为 100MB 且名称为 demo 的卷。

输出

上面命令的输出如下所示：

列出所有卷

您还可以列出docker 主机上的所有docker 卷。下面提供了有关此命令的更多详细信息：

语法

docker volume ls 

选项

无

返回值

该命令将输出docker 主机上的所有卷。

示例

sudo docker volume ls

输出

上面命令的输出如下所示：

Docker - 网络

Docker 负责网络方面，以便容器可以与其他容器以及 Docker 主机通信。如果您在 Docker 主机上执行ifconfig，您将看到 Docker 以太网适配器。此适配器是在 Docker 安装在 Docker 主机上时创建的。

这是 Docker 主机和 Linux 主机之间的桥梁。现在让我们看看与 Docker 中的网络相关的一些命令。

列出所有 Docker 网络

此命令可用于列出主机上与 Docker 关联的所有网络。

语法

docker network ls 

选项

无

返回值

该命令将输出 Docker 主机上的所有网络。

示例

sudo docker network ls

输出

上面命令的输出如下所示

检查 Docker 网络

如果您想查看有关与 Docker 关联的网络的更多详细信息，可以使用 Docker network inspect命令。

语法

docker network inspect networkname 

选项

• networkname - 这是您需要检查的网络的名称。

返回值

该命令将输出有关网络的所有详细信息。

示例

sudo docker network inspect bridge 

输出

上面命令的输出如下所示：

现在让我们运行一个容器，看看我们再次检查网络时会发生什么。让我们使用以下命令启动一个 Ubuntu 容器：

sudo docker run –it ubuntu:latest /bin/bash 

现在，如果我们通过以下命令检查网络名称，您将看到该容器已连接到桥接。

sudo docker network inspect bridge

创建您自己的新网络

在启动容器之前，可以在 Docker 中创建网络。这可以通过以下命令完成：

语法

docker network create –-driver drivername name 

选项

• drivername - 这是用于网络驱动程序的名称。

• name - 这是赋予网络的名称。

返回值

该命令将输出新网络的长 ID。

示例

sudo docker network create –-driver bridge new_nw 

输出

上面命令的输出如下所示：

您现在可以在启动容器时附加新网络。因此，让我们使用以下命令启动一个 Ubuntu 容器：

sudo docker run –it –network=new_nw ubuntu:latest /bin/bash

现在，当您通过以下命令检查网络时，您将看到该容器已连接到网络。

sudo docker network inspect new_nw 

Docker - 设置 Node.js

Node.js 是一个用于开发服务器端应用程序的 JavaScript 框架。它是一个开源框架，开发用于在各种操作系统上运行。由于 Node.js 是一个流行的开发框架，因此 Docker 也确保它支持 Node.js 应用程序。

我们现在将了解启动并运行 Node.js 的 Docker 容器的各种步骤。

步骤 1 - 第一步是从 Docker Hub 拉取镜像。当您登录 Docker Hub 时，您将能够搜索并查看 Node.js 的镜像，如下所示。只需在搜索框中键入 Node，然后单击搜索结果中出现的 node（官方）链接。

步骤 2 - 您将在 Docker Hub 中存储库的详细信息中看到 Node 的 Docker pull命令。

步骤 3 - 在 Docker 主机上，使用上面显示的 Docker pull命令从 Docker Hub 下载最新的 node 镜像。

pull完成后，我们可以继续下一步。

步骤 4 - 在 Docker 主机上，让我们使用vim编辑器并创建一个 Node.js 示例文件。在此文件中，我们将添加一个简单的命令以将“HelloWorld”显示到命令提示符。

在 Node.js 文件中，让我们添加以下语句：

Console.log(‘Hello World’);

当我们通过 Node.js 运行它时，这将输出“Hello World”短语。

确保保存文件，然后继续下一步。

步骤 5 - 要使用 Node Docker 容器运行我们的 Node.js 脚本，我们需要执行以下语句：

sudo docker run –it –rm –name = HelloWorld –v “$PWD”:/usr/src/app 
   –w /usr/src/app node node HelloWorld.js

关于上述命令，需要注意以下几点 −

• –rm选项用于在容器运行后将其删除。

• 我们为容器指定了一个名为“HelloWorld”的名称。

• 我们提到要将容器中的卷/usr/src/app映射到我们当前的工作目录。这样做是为了让 node 容器获取我们工作目录中 Docker 主机上的 HelloWorld.js 脚本。

• –w选项用于指定 Node.js 使用的工作目录。

• 第一个 node 选项用于指定运行 node 镜像。

• 第二个 node 选项用于指定在 node 容器中运行 node 命令。

• 最后，我们提到脚本的名称。

然后我们将获得以下输出。从输出中，我们可以清楚地看到 Node 容器作为容器运行并执行了 HelloWorld.js 脚本。

Docker - 设置 MongoDB

MongoDB 是一个著名的面向文档的数据库，许多现代 Web 应用程序都使用它。由于 MongoDB 是一个流行的开发数据库，因此 Docker 也确保它支持 MongoDB。

我们现在将了解启动并运行 MongoDB 的 Docker 容器的各种步骤。

步骤 1 - 第一步是从 Docker Hub 拉取镜像。当您登录 Docker Hub 时，您将能够搜索并查看 Mongo 的镜像，如下所示。只需在搜索框中键入 Mongo，然后单击搜索结果中出现的 Mongo（官方）链接。

步骤 2 - 您将在 Docker Hub 中存储库的详细信息中看到 Mongo 的 Docker pull命令。

步骤 3 - 在 Docker 主机上，使用上面显示的 Docker pull命令从 Docker Hub 下载最新的 Mongo 镜像。

步骤 4 - 现在我们有了 Mongo 的镜像，让我们首先运行一个 MongoDB 容器，它将成为我们的 MongoDB 实例。为此，我们将发出以下命令：

sudo docker run -it -d mongo

关于上述命令，需要注意以下几点：

• –it选项用于以交互模式运行容器。

• –d选项用于作为守护进程运行容器。

• 最后，我们正在从 Mongo 镜像创建容器。

然后，您可以发出docker ps命令以查看正在运行的容器：

请注意以下几点：

• 容器的名称是tender_poitras。此名称将有所不同，因为当您启动容器时，容器的名称会不断变化。但只需记下您已启动的容器即可。

• 接下来，还要注意它正在运行的端口号。它在 TCP 端口 27017 上侦听。

步骤 5 - 现在让我们启动另一个容器，它将充当我们的客户端，用于连接到 MongoDB 数据库。为此，我们将发出以下命令：

sudo docker run –it –link=tender_poitras:mongo mongo /bin/bash 

关于上述命令，需要注意以下几点：

• –it选项用于以交互模式运行容器。

• 我们现在将新容器链接到已启动的 MongoDB 服务器容器。在这里，您需要提及已启动容器的名称。

• 然后我们指定要启动 Mongo 容器作为我们的客户端，然后在新容器中运行bin/bashshell。

您现在将在新容器中。

步骤 6 - 在新容器中运行env命令以查看有关如何连接到 MongoDB 服务器容器的详细信息。

步骤 6 - 现在是时候从客户端容器连接到 MongoDB 服务器了。我们可以通过以下命令执行此操作：

mongo 172.17.0.2:27017 

关于上述命令，需要注意以下几点

• mongo命令是用于连接到 MongoDB 数据库的客户端mongo命令。

• IP 和端口号是在使用env命令时获得的。

运行该命令后，您将连接到 MongoDB 数据库。

然后，您可以在命令提示符下运行任何 MongoDB 命令。在我们的示例中，我们正在运行以下命令：

use demo

此命令是一个 MongoDB 命令，用于切换到数据库名称demo。如果数据库不可用，则将创建它。

现在您已成功创建了客户端和服务器 MongoDB 容器。

Docker - 设置 NGINX

NGINX 是一款流行的轻量级 Web 应用程序，用于开发服务器端应用程序。它是一个开源的 Web 服务器，可以运行在各种操作系统上。由于nginx 是一个流行的开发 Web 服务器，因此 Docker 确保了对nginx 的支持。

现在我们将了解启动并运行nginx 的 Docker 容器的各个步骤。

步骤 1 - 第一步是从 Docker Hub 拉取镜像。登录 Docker Hub 后，您将能够搜索并查看nginx 的镜像，如下所示。只需在搜索框中输入 nginx，然后点击搜索结果中出现的nginx（官方）链接。

步骤 2 - 您将在 Docker Hub 中存储库详细信息中看到nginx 的 Docker pull 命令。

步骤 3 - 在 Docker 主机上，使用上面显示的 Docker pull 命令从 Docker Hub 下载最新的 nginx 镜像。

步骤 4 - 现在让我们通过以下命令运行nginx 容器。

sudo docker run –p 8080:80 –d nginx

我们将nginx 服务器上的端口 80 暴露到 Docker 主机上的端口 8080。

运行该命令后，如果您浏览 URL http://dockerhost:8080，您将获得以下输出。这表明nginx 容器已启动并正在运行。

步骤 5 - 让我们来看另一个示例，我们可以在ngnix 容器中托管一个简单的网页。在我们的示例中，我们将创建一个简单的HelloWorld.html 文件并在我们的nginx 容器中托管它。

首先让我们创建一个名为HelloWorld.html 的 HTML 文件。

让我们在 HTML 文件中添加一行简单的 Hello World。

然后让我们运行以下 Docker 命令。

sudo docker run –p 8080:80 –v 
   “$PWD”:/usr/share/nginx/html:ro –d nginx 

关于上述命令，需要注意以下几点 −

• 我们将nginx 服务器上的端口 80 暴露到 Docker 主机上的端口 8080。

• 接下来，我们将容器上的卷/usr/share/nginx/html 附加到我们的当前工作目录。这是我们的 HelloWorld.html 文件存储的位置。

现在，如果我们浏览 URL http://dockerhost:8080/HelloWorld.html，我们将获得以下预期输出 -

Docker - 工具箱

在介绍性章节中，我们已经了解了在 Windows 上安装 Docker 工具箱。Docker 工具箱的开发是为了让 Docker 容器可以在 Windows 和 MacOS 上运行。Windows 上工具箱的网站是 https://docs.container.net.cn/docker-for-windows/

对于 Windows，您需要拥有 Windows 10 或 Windows Server 2016 并且启用了 Hyper-V。

工具箱包含以下组件 -

• Docker Engine - 用作运行 Docker 容器的基础引擎或 Docker 守护程序。

• Docker Machine - 用于运行 Docker machine 命令。

• Docker Compose - 用于运行 Docker compose 命令。

• Kitematic - 这是为 Windows 和 Mac OS 构建的 Docker GUI。

• Oracle VirtualBox

现在让我们讨论使用 Docker 工具箱可以执行的不同类型的活动。

在 PowerShell 中运行

使用 Windows 10 上的 Docker 工具箱，您现在可以从powershell 运行 Docker 命令。如果您在 Windows 上打开 powershell 并输入 Docker 版本命令，您将获得有关已安装的 Docker 版本的所有必要详细信息。

拉取镜像和运行容器

您现在也可以从 Docker Hub 拉取镜像并在 powershell 中运行容器，就像在 Linux 中一样。以下示例将简要说明下载 Ubuntu 镜像并在该镜像上运行容器。

第一步是使用 Docker pull 命令从 Docker Hub 拉取 Ubuntu 镜像。

下一步是使用以下run 命令运行 Docker 镜像 -

docker run –it ubuntu /bin/bash 

您会注意到该命令与 Linux 中的相同。

Kitematic

这是 Windows 上 Docker 的 GUI 等效项。要打开此 GUI，请转到任务栏，在 Docker 图标上右键单击，然后选择打开 Kitematic。

它将提示您下载 Kitematic GUI。下载完成后，只需解压缩内容。将有一个名为Kitematic.exe 的文件。双击此 exe 文件以打开 GUI 界面。

然后将要求您登录 Docker Hub，通过 GUI 登录。只需输入所需的用户名和密码，然后点击登录按钮。

登录后，您将能够在界面左侧看到系统上下载的所有镜像。

在右侧，您将找到 Docker Hub 上可用的所有镜像。

让我们以一个示例来了解如何使用 Kitematic 从 Docker Hub 下载 Node 镜像。

步骤 1 - 在搜索条件中输入节点关键字。

步骤 2 - 点击官方 Node 镜像上的创建按钮。然后您将看到镜像正在下载。

镜像下载完成后，它将开始运行 Node 容器。

步骤 3 - 如果您转到设置选项卡，您可以深入了解更多设置选项，如下所示。

• 常规设置 - 在此选项卡中，您可以命名容器、更改路径设置和删除容器。

• 端口 - 在这里您可以看到不同的端口映射。如果需要，您可以创建自己的端口映射。

• 卷 - 在这里您可以看到不同的卷映射。

• 高级 - 它包含容器的高级设置。

Docker - 设置 ASP.Net

ASP.Net 是 Microsoft 提供的标准 Web 开发框架，用于开发服务器端应用程序。由于 ASP.Net 在开发中已经存在很长时间，因此 Docker 确保了对 ASP.Net 的支持。

在本章中，我们将了解启动并运行 ASP.Net 的 Docker 容器的各个步骤。

先决条件

首先需要执行以下步骤才能运行 ASP.Net。

步骤 1 - 由于这只能在 Windows 系统上运行，因此您首先需要确保您拥有 Windows 10 或 Window Server 2016。

步骤 2 - 接下来，确保 Hyper-V 和容器已安装在 Windows 系统上。要安装 Hyper-V 和容器，您可以转到“启用或关闭 Windows 功能”。然后确保选中 Hyper-V 选项和容器，然后点击“确定”按钮。

此操作后，系统可能需要重新启动。

步骤 3 - 接下来，您需要使用以下 PowerShell 命令安装 Docker 的1.13.0rc4 版本。以下命令将下载此版本并将其存储在临时位置。

Invoke-WebRequest "https://test.docker.com/builds/Windows/x86_64/docker-1.13.0-
   rc4.zip" -OutFile "$env:TEMP\docker-1.13.0-rc4.zip" –UseBasicParsing 

步骤 4 - 接下来，您需要使用以下powershell 命令展开存档。

Expand-Archive -Path "$env:TEMP\docker-1.13.0-rc4.zip" -DestinationPath $env:ProgramFiles

步骤 5 - 接下来，您需要使用以下powershell 命令将 Docker 文件添加到环境变量。

$env:path += ";$env:ProgramFiles\Docker" 

步骤 6 - 接下来，您需要使用以下powershell 命令注册 Docker 守护程序服务。

dockerd --register-service 

步骤 7 - 最后，您可以使用以下命令启动docker 守护程序。

Start-Service Docker

在powershell 中使用docker version 命令验证docker 守护程序是否正在工作。

安装 ASP.Net 容器

让我们看看如何安装 ASP.Net 容器。

步骤 1 - 第一步是从 Docker Hub 拉取镜像。登录 Docker Hub 后，您将能够搜索并查看Microsoft/aspnet 的镜像，如下所示。只需在搜索框中输入asp，然后点击搜索结果中出现的 Microsoft/aspnet 链接。

步骤 2 - 您将在 Docker Hub 中存储库详细信息中看到 ASP.Net 的 Docker pull 命令。

步骤 3 - 转到 Docker 主机并运行 microsoft/aspnet 镜像的 Docker pull 命令。请注意，该镜像非常大，大约 4.2 GB。

步骤 4 - 现在转到以下位置 https://github.com/Microsoft/aspnet-docker 并下载整个 Git 存储库。

步骤 5 - 在您的 C 驱动器中创建一个名为App 的文件夹。然后将4.6.2/sample 文件夹中的内容复制到您的 C 驱动器。转到示例目录中的 Docker 文件并发出以下命令 -

docker build –t aspnet-site-new –build-arg site_root=/ 

关于上述命令，需要注意以下几点 −

• 它从 Docker 文件构建一个名为aspnet-site-new 的新镜像。
• 根路径设置为本地路径文件夹。

步骤 6 - 现在是时候运行容器了。可以使用以下命令完成：-

docker run –d –p 8000:80 –name my-running-site-new aspnet-site-new 

步骤 7 - 现在您将在 Docker 容器中运行 IIS。要查找 Docker 容器的 IP 地址，您可以发出如下所示的 Docker inspect 命令。

Docker - 云

Docker Cloud 是 Docker 提供的一项服务，您可以在其中执行以下操作 -

• 节点 - 您可以将 Docker Cloud 连接到您现有的云提供商（如 Azure 和 AWS），以在这些环境中启动容器。

• 云存储库 - 提供一个存储您自己的存储库的位置。

• 持续集成 - 连接Github 并构建持续集成管道。

• 应用程序部署 - 部署和扩展基础设施和容器。

• 持续部署 - 可以自动化部署。

入门

您可以访问以下链接以开始使用 Docker Cloud - https://cloud.docker.com/

登录后，您将获得以下基本界面 -

连接到云提供商

第一步是连接到现有的云提供商。以下步骤将向您展示如何连接到 Amazon Cloud 提供商。

步骤 1 - 第一步是确保您拥有正确的 AWS 密钥。这可以从aws 控制台获取。使用以下链接登录您的aws 帐户 - https://aws.amazon.com/console/

步骤 2 - 登录后，转到安全凭证部分。记下将从 Docker Hub 使用的访问密钥。

步骤 3 − 接下来，您需要在aws中创建一个策略，允许 Docker 查看 EC2 实例。转到aws中的配置文件部分。点击创建策略按钮。

步骤 4 − 点击“创建自己的策略”，并将策略名称命名为dockercloudpolicy，策略定义如下所示。

{ 
   "Version": "2012-10-17", 
   "Statement": [ { 
      "Action": [ 
         "ec2:*", 
         "iam:ListInstanceProfiles" 
      ], 
      "Effect": "Allow", 
      "Resource": "*" 
   } ] 
}

接下来，点击创建策略按钮。

步骤 5 − 接下来，您需要创建一个角色，Docker 将使用该角色在 AWS 上启动节点。为此，请转到 AWS 中的角色部分，然后点击创建新角色选项。

步骤 6 − 为角色命名为dockercloud-role。

步骤 7 − 在下一个屏幕上，转到“跨账户访问的角色”，然后选择“在您的账户和第三方 AWS 账户之间提供访问权限”。

步骤 8 − 在下一个屏幕上，输入以下详细信息 -

• 在账户 ID 字段中，输入 Docker Cloud 服务的 ID：689684103426。
• 在外部 ID 字段中，输入您的 Docker Cloud 用户名。

步骤 9 − 然后，点击下一步按钮，在下一个屏幕上，附加在前面步骤中创建的策略。

步骤 10 − 最后，在创建角色的最后一个屏幕上，确保复制创建的arn角色。

arn:aws:iam::085363624145:role/dockercloud-role

步骤 11 − 现在返回Docker Cloud，选择云提供商，然后点击 Amazon Web Services 旁边的插头符号。

输入arn角色并点击保存按钮。

保存后，与 AWS 的集成将完成。

设置节点

与 AWS 集成完成后，下一步是设置节点。转到 Docker Cloud 中的节点部分。请注意，节点的设置将自动首先设置节点集群。

步骤 1 − 转到 Docker Cloud 中的节点部分。

步骤 2 − 接下来，您可以提供将在 AWS 中设置的节点的详细信息。

然后，您可以点击屏幕底部显示的启动节点集群。节点部署后，您将在节点集群屏幕中收到通知。

部署服务

部署节点后的下一步是部署服务。为此，我们需要执行以下步骤。

步骤 1 − 转到 Docker Cloud 中的服务部分。点击创建按钮。

步骤 2 − 选择所需的 Service。在我们的例子中，让我们选择mongo。

步骤 3 − 在下一个屏幕上，选择创建和部署选项。这将开始在您的节点集群上部署Mongo容器。

部署后，您将能够看到容器处于运行状态。

Docker - 日志

Docker 具有现成的日志记录机制，可用于在问题发生时进行调试。在守护进程级别和容器级别都有日志记录。让我们看看不同级别的日志记录。

守护进程日志记录

在守护进程日志记录级别，有四个级别的日志记录可用 -

• 调试 − 它详细说明了守护进程处理的所有可能信息。

• 信息 − 它详细说明了守护进程处理的所有错误 + 信息。

• 错误 − 它详细说明了守护进程处理的所有错误。

• 致命 − 它仅详细说明了守护进程处理的所有致命错误。

请按照以下步骤了解如何启用日志记录。

步骤 1 − 首先，我们需要停止docker 守护进程，如果它已经在运行。可以使用以下命令完成 -

sudo service docker stop 

步骤 2 − 现在我们需要启动docker 守护进程。但是这次，我们需要附加–l参数来指定日志记录选项。因此，在启动docker 守护进程时，让我们发出以下命令。

sudo dockerd –l debug &

关于上述命令，需要注意以下几点 −

• dockerd是docker 守护进程的可执行文件。

• –l选项用于指定日志记录级别。在我们的例子中，我们将其设置为调试。

• &用于在启用日志记录后返回命令提示符。

启用日志记录后启动 Docker 进程后，您现在还将看到调试日志发送到控制台。

现在，如果您执行任何 Docker 命令，例如docker images，调试信息也将发送到控制台。

容器日志记录

在容器级别也可以使用日志记录。因此，在我们的示例中，让我们首先启动一个 Ubuntu 容器。我们可以使用以下命令来完成。

sudo docker run –it ubuntu /bin/bash 

现在，我们可以使用docker log 命令查看容器的日志。

语法

Docker logs containerID 

参数

• containerID − 这是您需要查看其日志的容器的 ID。

示例

在我们的 Docker 主机上，让我们发出以下命令。在此之前，您可以在容器中发出一些命令。

sudo docker logs 6bfb1271fcdd 

输出

从输出中，您可以看到在容器中执行的命令显示在日志中。

Docker - Compose

Docker Compose用于将多个容器作为单个服务运行。例如，假设您有一个需要 NGNIX 和 MySQL 的应用程序，您可以创建一个文件，该文件将这两个容器作为服务启动，而无需单独启动每个容器。

在本章中，我们将了解如何开始使用 Docker Compose。然后，我们将了解如何使用 Docker Compose 启动并运行一个带有 MySQL 和 NGNIX 的简单服务。

Docker Compose ─ 安装

要启动并运行 Docker Compose，需要遵循以下步骤。

步骤 1 − 使用以下命令从github下载必要的文件 -

curl -L "https://github.com/docker/compose/releases/download/1.10.0-rc2/dockercompose
   -$(uname -s) -$(uname -m)" -o /home/demo/docker-compose

上述命令将下载 Docker Compose 的最新版本，在撰写本文时为1.10.0-rc2。然后将其存储在/home/demo/目录中。

步骤 2 − 接下来，我们需要使用以下命令为下载的 Docker Compose 文件提供执行权限 -

chmod +x /home/demo/docker-compose

然后，我们可以使用以下命令查看compose版本。

语法

docker-compose version 

参数

• version − 这用于指定我们想要Docker Compose版本详细信息。

输出

将显示 Docker Compose 的版本详细信息。

示例

以下示例显示了如何获取docker-compose版本。

sudo ./docker-compose -version 

输出

然后您将获得以下输出 -

创建您的第一个 Docker-Compose 文件

现在让我们继续创建我们的第一个 Docker Compose 文件。所有 Docker Compose 文件都是 YAML 文件。您可以使用 vim 编辑器创建一个。因此，执行以下命令以创建compose文件 -

sudo vim docker-compose.yml 

让我们仔细看看此文件的各种详细信息 -

• database和web关键字用于定义两个独立的服务。一个将运行我们的mysql数据库，另一个将是我们的nginx Web 服务器。

• image关键字用于为我们的mysql和nginx容器指定来自dockerhub的镜像。

• 对于数据库，我们使用 ports 关键字来提及需要为mysql公开的端口。

• 然后，我们还为mysql指定了运行mysql所需的环境变量。

现在让我们使用以下命令运行我们的 Docker Compose 文件 -

sudo ./docker-compose up 

此命令将获取您本地目录中的docker-compose.yml文件并开始构建容器。

执行后，所有镜像将开始下载，容器将自动启动。

当您执行docker ps时，您可以看到容器确实已启动并正在运行。

Docker - 持续集成

Docker 与许多持续集成工具集成，其中还包括流行的 CI 工具Jenkins。在 Jenkins 中，您可以使用可用于处理容器的插件。因此，让我们快速了解一下 Jenkins 工具可用的 Docker 插件。

让我们一步一步地看看 Jenkins 中为 Docker 容器提供了什么。

步骤 1 − 转到您的 Jenkins 仪表板并点击管理 Jenkins。

步骤 2 − 转到管理插件。

步骤 3 − 搜索 Docker 插件。选择 Docker 插件并点击无需重启即可安装按钮。

步骤 4 − 安装完成后，转到 Jenkins 仪表板中的作业。在我们的示例中，我们有一个名为Demo的作业。

步骤 5 − 在作业中，当您转到构建步骤时，您现在可以看到启动和停止容器的选项。

步骤 6 − 作为一个简单的示例，您可以选择在构建完成后停止容器的进一步选项。然后，点击保存按钮。

现在，只需在 Jenkins 中运行您的作业即可。在控制台输出中，您现在将能够看到已运行停止所有容器的命令。

Docker - Kubernetes 架构

Kubernetes 是一个用于 Docker 容器的编排框架，它有助于将容器作为服务公开给外部世界。例如，您可以有两个服务 - 一个服务包含nginx和mongoDB，另一个服务包含nginx和redis。每个服务都可以有一个 IP 或服务点，其他应用程序可以通过该服务点连接。然后使用 Kubernetes 来管理这些服务。

下图以简化的格式显示了 Kubernetes 从架构角度的工作原理。

minion是所有服务运行的节点。您可以同时运行许多 minion。每个 minion 将承载一个或多个 POD。每个POD都像托管一个服务一样。然后，每个 POD 包含 Docker 容器。每个 POD 可以托管一组不同的 Docker 容器。然后使用代理来控制将这些服务公开给外部世界。

Kubernetes 的架构中包含多个组件。下面解释了每个组件的作用 &mius;

• etcd − 此组件是一个高可用的键值存储，用于存储共享配置和服务发现。在这里，各种应用程序将能够通过发现服务连接到服务。

• Flannel − 这是容器所需的后台网络。

• kube-apiserver − 这是一个 API，可用于编排 Docker 容器。

• kube-controller-manager − 用于控制Kubernetes 服务。

• kube-scheduler − 用于在主机上调度容器。

• Kubelet − 用于通过清单文件控制容器的启动。

• kube-proxy − 用于向外部世界提供网络代理服务。

Docker - Kubernetes 的工作原理

在本章中，我们将了解如何通过kubeadm安装Kubenetes。这是一个有助于安装 Kubernetes 的工具。让我们一步一步地学习如何安装 Kubernetes。

步骤 1 − 确保您正在使用的Ubuntu 服务器版本为16.04。

步骤 2 − 确保您生成了一个可用于ssh登录的ssh密钥。您可以使用以下命令执行此操作。

ssh-keygen 

这将在您的主文件夹中生成一个密钥，如下所示。

步骤 3 − 接下来，根据您拥有的 Ubuntu 版本，您需要将相关站点添加到docker.list（用于apt 包管理器），以便它能够从kubernetes站点检测Kubernetes 包并相应地下载它们。

我们可以使用以下命令来完成。

curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -  
echo "deb http://apt.kubernetes.io/ kubernetes-xenial main” | sudo tee /etc/apt/sources.list.d/docker.list

步骤 4 − 然后，我们发出一个 apt-get update 以确保所有包都下载到 Ubuntu 服务器上。

步骤 5 − 按照前面章节的详细说明安装 Docker 软件包。

步骤 6 − 现在是时候安装Kubernetes了，安装以下软件包 −

apt-get install –y kubelet kubeadm kubectl kubernetes-cni

步骤 7 − 所有Kubernetes软件包下载完成后，可以使用以下命令启动 Kubernetes 控制器 −

kubeadm init 

完成后，您将收到一条成功消息，表明主节点已启动并运行，节点现在可以加入集群。