《Docker极简教程》--Docker镜像--Docker镜像的创建和使用

一、Docker 镜像的创建

1.1 基于 Dockerfile 创建镜像

当你基于 Dockerfile 创建镜像时，你需要编写一个描述镜像构建步骤的文本文件，该文件称为 Dockerfile。下面是一个简单的示例 Dockerfile 和相应的说明：

# 使用指定的基础镜像
FROM ubuntu:latest

# 维护者信息
MAINTAINER Your Name <your.email@example.com>

# 运行更新并安装必要的软件包
RUN apt-get update && apt-get install -y \
    nginx \
    && rm -rf /var/lib/apt/lists/*

# 将本地文件复制到容器中的指定位置
COPY nginx.conf /etc/nginx/nginx.conf
COPY index.html /var/www/html/index.html

# 暴露容器监听的端口
EXPOSE 80

# 定义容器启动时执行的命令
CMD ["nginx", "-g", "daemon off;"]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

说明：

• FROM 指令指定了基础镜像，这里使用了最新版的 Ubuntu 镜像。
• MAINTAINER 指令提供了镜像的维护者信息。
• RUN 指令用于在镜像中执行命令，这里更新了软件包列表并安装了 nginx。
• COPY 指令将本地文件复制到容器中的指定位置，这里将 nginx.conf 和 index.html 复制到了对应的目录下。
• EXPOSE 指令声明了容器需要监听的端口，这里暴露了 80 端口。
• CMD 指令定义了容器启动时执行的命令，这里启动了 nginx 服务并以前台模式运行。

要构建该镜像，你可以在包含 Dockerfile 的目录下运行以下命令：

docker build -t my-nginx-image .
1

该命令会在当前目录下查找名为 Dockerfile 的文件，并构建一个名为 my-nginx-image 的镜像。
这个例子中的 Dockerfile 创建了一个包含 nginx 服务器的镜像，并将自定义的配置文件和网页内容复制到容器中。

1.2 从现有镜像修改创建新镜像

要从现有镜像修改并创建新镜像，你可以通过在容器中执行修改操作，然后将容器保存为新的镜像。下面是一个简单的示例：
假设你有一个名为 ubuntu:latest 的基础镜像，你希望在该镜像中安装一个额外的软件包，然后保存为新的镜像。
首先，启动一个临时容器并在其中进行修改：

docker run -it --name temp-ubuntu ubuntu:latest /bin/bash
1

这个命令会在 ubuntu:latest 镜像上启动一个交互式的终端，并将容器命名为 temp-ubuntu。
在容器内执行你的修改操作，例如安装 vim 软件包：

apt-get update
apt-get install -y vim
1
2

完成修改后，退出容器，并保存为新的镜像：

docker commit temp-ubuntu my-modified-ubuntu
1

这个命令会将 temp-ubuntu 容器保存为名为 my-modified-ubuntu 的新镜像。

现在，你就可以使用 my-modified-ubuntu 这个新镜像来创建新的容器，并包含了你所做的修改。

二、Docker 镜像的使用

2.1 从 Docker Hub 拉取镜像

从Docker Hub拉取镜像非常简单。只需使用 docker pull 命令，后跟要拉取的镜像名称和标签（如果有的话）即可。以下是一个示例：

docker pull ubuntu:latest
1

这个命令将会拉取 Docker Hub 上的 ubuntu 镜像，并选择最新版本（latest 标签）。
如果要拉取特定版本的镜像，可以在镜像名称后添加版本标签：

docker pull ubuntu:20.04
1

这个命令将拉取 Ubuntu 20.04 版本的镜像。
拉取完成后，你就可以通过 docker images 命令查看本地已拉取的镜像列表。

docker images
1

这将列出所有本地镜像，包括你刚刚拉取的那些。

2.2 运行镜像作为容器

要运行一个镜像作为容器，你可以使用 docker run 命令。以下是一个基本的示例：

docker run -d --name my_container ubuntu:latest
1

这个命令将以后台模式（-d 参数）运行一个基于 ubuntu:latest 镜像的容器，并将容器命名为 my_container。
如果你希望在容器内执行某些命令，你可以将这些命令放在镜像名称后面。例如，要在 Ubuntu 容器内启动一个交互式终端：

docker run -it --name my_container ubuntu:latest /bin/bash
1

这个命令会以交互模式（-i）和终端连接模式（-t）运行容器，并执行 /bin/bash 命令。这样，你就可以在容器内部与其进行交互了。
此外，你可以通过 docker run 命令的一系列选项来自定义容器的行为，如挂载卷、设置环境变量、映射端口等。可以使用 docker run --help 命令查看所有可用选项的完整列表和说明。

2.3 管理镜像和容器

1. 查看本地镜像列表
   要查看本地系统上已经下载的 Docker 镜像列表，你可以使用 docker images 命令。这个命令将列出本地镜像的信息，包括镜像名称、标签、镜像 ID、创建时间、大小等。
   示例：

docker images
1

这个命令将输出类似以下的信息：

在这个示例中，列出了两个镜像：ubuntu 和 nginx，以及它们各自的标签、镜像 ID、创建时间和大小信息。

2. 查看运行中的容器
   要查看正在运行的容器列表，你可以使用 docker ps 命令。这个命令将列出正在运行的容器的相关信息，如容器 ID、镜像名称、创建时间、状态等。

docker ps
1

如果你想查看所有容器（包括已经停止的），可以使用 -a 选项：

docker ps -a
1

这将列出所有容器的信息，包括正在运行的和已经停止的。
另外，如果你只想查看容器 ID，可以使用 -q 选项：

docker ps -q
1

这将只输出容器 ID，一行一个。

3. 停止和删除容器
   要停止容器，你可以使用 docker stop 命令，后跟容器的名称或 ID。

docker stop container_name_or_id
1

如果你想停止所有正在运行的容器，可以使用以下命令：

docker stop $(docker ps -q)
1

这将停止所有正在运行的容器。
要删除容器，你可以使用 docker rm 命令，后跟容器的名称或 ID。

docker rm container_name_or_id
1

如果你要删除所有已停止的容器，可以使用以下命令：

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

这将删除所有已停止的容器。

Tip：删除容器将删除与容器关联的任何数据，包括日志、文件等。确保在删除之前备份必要的数据。

4. 删除镜像
   要删除镜像，你可以使用 docker rmi 命令，后跟要删除的镜像的名称或 ID。

docker rmi image_name_or_id
1

如果你要删除多个镜像，可以将它们的名称或 ID 一起列出：

docker rmi image1_name_or_id image2_name_or_id
1

如果你要删除所有未使用的镜像，可以使用以下命令：

docker image prune
1

这个命令将删除所有没有关联容器的镜像。
如果你要删除所有镜像，包括那些有关联容器的镜像，可以使用以下命令：

docker rmi $(docker images -q)
1

这个命令将删除所有本地镜像，包括那些正在运行的容器所使用的镜像。请注意，这可能会导致正在运行的容器失去所需的镜像而停止运行。

三、Docker 镜像的发布与分享

3.1 将镜像推送至 Docker Hub 或其他镜像仓库

要将镜像推送到 Docker Hub 或其他 Docker 镜像仓库，你需要先登录到该仓库，并为要推送的镜像添加正确的标签。然后，使用 docker push 命令将镜像推送到仓库。以下是一些基本步骤：

1. 登录到 Docker Hub 或其他镜像仓库：

docker login
1

这将提示你输入用户名和密码以登录到 Docker Hub 或其他镜像仓库。
2. 给要推送的镜像添加标签：

docker tag local_image:tag username/repository:tag
1

例如，要将名为 my_image 的本地镜像标记为 username/my_image 并具有标签 latest，你可以运行：

docker tag my_image:latest username/my_image:latest
1

3. 推送镜像到仓库：

docker push username/repository:tag
1

例如，要将标记为 username/my_image:latest 的镜像推送到 Docker Hub：

docker push username/my_image:latest
1

请确保你有权限将镜像推送到所选镜像仓库。通常，你需要在仓库的网站上创建一个与你 Docker Hub 账户相关联的仓库，并将其命名为 username/repository，然后才能将镜像推送到该仓库。

3.2 分享镜像链接或访问权限

要分享 Docker 镜像链接或访问权限，你可以直接提供镜像的完整名称和标签。其他用户可以使用该名称和标签来拉取镜像。另外，如果你将镜像推送到 Docker Hub 或其他镜像仓库，你可以通过将仓库 URL 与镜像名称和标签结合，提供一个可访问的链接。以下是一些示例：

1. 分享 Docker 镜像名称和标签：

镜像名称: username/repository:tag
1

例如：

username/my_image:latest
1

其他用户可以使用该名称和标签来拉取镜像：

docker pull username/my_image:latest
1

2. 如果你将镜像推送到 Docker Hub，你可以分享该镜像在 Docker Hub 上的链接：

https://hub.docker.com/r/username/repository
1

用户可以访问此链接以查看镜像的详细信息，并查找推送的镜像。

3. 如果你将镜像推送到其他私有镜像仓库，可以提供相应的访问链接和凭据（如果需要）。
   请确保在分享镜像链接或访问权限时，考虑到镜像的安全性和隐私性。

3.3 版本控制和管理

镜像版本控制和管理对于确保应用程序的可靠性和可重复性至关重要。以下是一些关于镜像版本控制和管理的最佳实践：

1. 语义化版本控制（Semantic Versioning）： 使用语义化版本控制规范（SemVer）来管理镜像版本。这包括指定主版本号、次版本号和修订号，以及可选的预发布版本号和构建元数据。这样做可以让用户清楚地了解每个版本的含义和变化。
2. 版本标签： 为每个镜像版本添加清晰的标签，例如 v1.0、v2.0-beta 等。标签应该反映镜像的版本号或特定的发布状态。
3. 文档化： 在镜像仓库中记录每个版本的变更日志和重要信息。这有助于团队成员了解每个版本的变化和影响。
4. 版本锁定： 在部署应用程序时，使用确切的镜像版本来确保环境的一致性和可重复性。避免使用不明确的标签（如 latest），因为它们可能会在不同时间指向不同的镜像版本。
5. 分支管理： 如果需要维护多个并行版本的镜像，考虑使用分支管理策略。每个主要版本可能对应一个分支，以便随时跟踪和更新每个版本的镜像。
6. 自动化构建和发布： 利用 CI/CD 工具自动化构建和发布镜像。这样可以减少人为错误，并确保每个版本的构建过程都是一致和可靠的。
7. 镜像审查： 定期审查镜像，检查其中包含的软件包是否存在安全漏洞，并及时更新镜像以纠正这些问题。
8. 回退策略： 定义镜像回退策略，以便在出现问题时能够快速回退到之前的稳定版本。
9. 访问控制： 限制对镜像仓库的访问权限，确保只有授权的人员可以发布新版本或修改现有版本。

以上这些实践有助于确保镜像的版本控制和管理是可靠、可重复和安全的。通过遵循这些最佳实践，团队可以更好地管理和维护他们的镜像库。

四、Docker 镜像的最佳实践

4.1 最小化镜像大小

最小化 Docker 镜像大小是 Docker 最佳实践中的一个重要方面，它可以带来许多好处，包括更快的构建和部署速度、减少网络传输和存储成本，以及提高安全性。以下是一些最佳实践来最小化 Docker 镜像大小：

1. 选择合适的基础镜像： 使用轻量级的基础镜像作为起点。例如，Alpine Linux 是一个小巧的 Linux 发行版，通常被用作基础镜像，因为它非常小，并且包含了必要的功能。
2. 最小化层数： 将镜像的层数（layers）尽量减少。每个 Dockerfile 中的指令都会创建一个新的层，因此尽量将多个指令合并为一个来减少层数。
3. 合理使用 .dockerignore 文件： 使用 .dockerignore 文件来排除不必要的文件和目录，以避免将它们添加到镜像中。这样可以减少构建上下文的大小，从而减少镜像大小。
4. 使用多阶段构建： 使用多阶段构建来减少最终镜像中的不必要的依赖和文件。多阶段构建允许你在一个 Dockerfile 中使用多个 FROM 指令，并且在不同的阶段构建和导出所需的文件，最终只将必要的文件复制到最终镜像中。
5. 精简安装和清理： 在安装软件包时，尽量只安装必要的组件和依赖项。安装完成后，清理临时文件和缓存以减少镜像大小。例如，使用 apt-get clean 或 yum clean all 来清理软件包管理器的缓存。
6. 避免不必要的工具和依赖： 避免在镜像中包含不必要的工具、库和依赖项。只包含应用程序运行所需的最小化组件。
7. 压缩文件和数据： 在将文件复制到镜像中之前，将其压缩为尽可能小的尺寸。可以使用 tar 命令将文件打包为 tarball，并使用 gzip 或其他压缩工具对其进行压缩。
8. 优化镜像构建过程： 优化 Dockerfile 中的指令顺序和构建过程，以尽可能地减少镜像大小。这可能包括将频繁更改的指令放在后面，以最大程度地利用 Docker 的缓存机制。

通过采取这些最佳实践，可以显著减小 Docker 镜像的大小，并提高应用程序的构建效率和性能。

4.2 定期更新镜像

定期更新镜像是确保应用程序安全性和稳定性的重要实践。以下是一些关于定期更新镜像的最佳实践：

1. 监控漏洞和更新： 定期监控容器镜像中的漏洞和安全更新。可以使用漏洞扫描工具或订阅安全通知来获取及时的更新信息。
2. 自动化更新流程： 配置自动化流程来定期检查和更新镜像。这可以通过 CI/CD 工具或自定义脚本来实现。自动化更新可以帮助确保及时应用安全补丁并减少人为错误。
3. 镜像版本管理： 使用版本控制系统管理镜像版本。每次更新镜像时，确保更新版本号，并记录更新内容和日期。
4. 测试更新： 在将更新的镜像部署到生产环境之前，务必在测试环境中进行测试。确保更新不会影响应用程序的稳定性和功能。
5. 回滚策略： 定义镜像更新的回滚策略。如果更新导致问题或异常行为，需要快速回滚到之前的稳定版本。
6. 通知和沟通： 在进行镜像更新时，及时通知团队成员和相关利益相关者。确保他们了解更新的内容、计划和可能的影响。
7. 周期性审查： 定期审查和优化镜像更新流程。根据经验教训和反馈，调整更新策略和流程，以提高效率和可靠性。
8. 记录和文档化： 记录每次镜像更新的详细信息，包括更新内容、操作人员、日期和时间等。这有助于追溯和排查问题，同时也有助于遵循合规要求。

通过采取这些最佳实践，可以确保镜像始终保持最新和安全，并降低由于过时镜像导致的安全风险和应用程序中断的可能性。

4.3 安全性考虑

在使用 Docker 镜像时，确保安全性是至关重要的。以下是一些在使用 Docker 镜像时需要考虑的安全性措施和最佳实践：

1. 使用官方镜像或受信任的来源： 尽可能使用官方镜像或受信任的第三方来源。官方镜像通常经过官方团队的审核和测试，因此更加可靠和安全。
2. 定期更新镜像： 定期更新镜像以获取最新的安全补丁和修复程序。使用自动化流程来确保更新及时进行，并及时测试更新是否会影响应用程序的稳定性。
3. 最小化容器特权： 在可能的情况下，尽量使用非特权用户运行容器。避免在容器内以 root 用户身份运行应用程序，以减少潜在的安全风险。
4. 使用容器资源限制： 使用 Docker 的资源限制功能，限制容器可以使用的 CPU、内存和其他资源。这有助于防止容器占用过多系统资源，并降低拒绝服务（DoS）攻击的风险。
5. 控制容器网络访问： 配置容器网络访问策略，限制容器可以访问的网络资源。使用 Docker 网络插件和安全组规则来实现网络隔离和访问控制。
6. 安全地共享数据： 避免在容器内部存储敏感信息。如果必须共享数据，确保使用安全的方法，如加密数据、使用安全密钥管理等。
7. 监控容器安全性： 定期监控容器的安全性，包括容器运行时和镜像构建过程中的漏洞扫描。使用容器安全扫描工具来识别和修复潜在的安全漏洞。
8. 审查和验证镜像： 审查和验证从外部来源获取的镜像，确保其来自受信任的来源，并且不包含恶意代码或后门程序。
9. 实施多层防御： 使用多层防御策略来保护容器环境。包括防火墙、入侵检测系统（IDS）、安全监控和日志记录等安全措施。
10. 教育和培训： 对团队成员进行安全培训和教育，提高他们对容器安全性的意识，并确保他们知道如何识别和应对安全威胁。

通过遵循这些安全性措施和最佳实践，可以更好地保护 Docker 容器环境免受潜在的安全威胁，并确保应用程序的安全性和稳定性。

4.4 优化镜像构建过程

优化 Docker 镜像构建过程是提高开发效率和减少资源消耗的关键步骤。以下是一些优化镜像构建过程的最佳实践：

1. 合理使用 Dockerfile 指令： 在 Dockerfile 中合理地组织指令，尽量将经常变化的指令放在后面，以利用 Docker 的缓存机制。例如，将稳定的依赖安装放在前面，将频繁更改的文件复制放在后面。
2. 多阶段构建： 使用多阶段构建来减少最终镜像的大小。通过在一个 Dockerfile 中使用多个 FROM 指令，在不同的阶段构建和导出所需的文件，然后将必要的文件复制到最终镜像中。
3. 精简构建上下文： 在构建镜像时，只复制所需的文件和目录到构建上下文中，通过 .dockerignore 文件排除不必要的文件和目录。这有助于减少构建上下文的大小，提高构建速度。
4. 利用缓存： 在 Dockerfile 中合理地利用缓存机制。确保经常变化的步骤放在后面，并使用合适的缓存无效化技术，以最大程度地减少不必要的镜像重建。
5. 并行构建： 如果有多个 Dockerfile 或多个构建任务，可以使用并行构建来提高构建效率。使用构建工具或 CI/CD 工具并行构建多个镜像，以减少构建时间。
6. 优化依赖安装： 在安装依赖时，尽量使用镜像内置的软件包管理器或官方软件源。避免在构建时下载软件包或依赖项，以减少网络传输时间和镜像大小。
7. 缓存下载的依赖项： 如果不确定依赖项是否会经常变化，可以将它们提前下载并缓存起来。这样可以避免在每次构建时都重新下载相同的依赖项，提高构建速度。
8. 优化镜像大小： 尽量减小镜像的大小，以减少网络传输时间和存储成本。删除不必要的文件、清理缓存、压缩文件等都是减小镜像大小的有效方法。
9. 定期审查和优化： 定期审查和优化 Dockerfile 和构建过程。根据经验教训和反馈，调整构建过程以提高效率和可靠性。

通过采取这些优化措施，可以显著提高 Docker 镜像的构建速度和效率，同时减少资源消耗和成本。

五、Docker 镜像的扩展应用

5.1 使用多阶段构建

多阶段构建是 Docker 镜像构建过程中的一种高级技术，它允许在单个 Dockerfile 中定义多个构建阶段，从而可以将构建过程分解为多个步骤，最终生成一个更小、更精简的最终镜像。以下是一些扩展应用多阶段构建的示例：

1. 编译和运行环境分离： 在开发和构建应用程序时，通常需要使用编译环境和运行环境。使用多阶段构建，可以在第一阶段构建编译环境，包括编译器、依赖项和构建工具，然后在第二阶段将编译生成的可执行文件复制到最终的运行环境中。这样可以将最终镜像中不必要的构建工具和依赖项移除，减小镜像大小。
2. 多语言应用程序构建： 对于多语言应用程序，可能需要使用不同的构建工具和依赖项来构建不同的部分。使用多阶段构建，可以为每种语言使用不同的构建阶段，以便根据需要定制每个阶段的构建环境。
3. 减小依赖项： 在多阶段构建中，可以在第一阶段安装所有的构建依赖项，并在第二阶段复制最终的构建结果。这样可以确保最终镜像只包含运行时所需的最小依赖项，减小镜像大小并提高安全性。
4. 代码打包和部署： 在多阶段构建中，可以将代码打包为一个可执行文件或静态资源，并将其复制到最终的镜像中。这样可以简化部署过程，使部署更加一致和可靠。
5. 多阶段测试： 在多阶段构建中，可以在每个阶段添加测试步骤，以确保每个阶段生成的结果都是正确的。这样可以提高构建质量和可靠性。

通过使用多阶段构建，可以更好地组织和管理 Docker 镜像构建过程，减小最终镜像的大小，提高应用程序的性能和安全性，并简化部署和维护过程。

5.2 组合多个镜像

组合多个镜像是一种常见的做法，通常用于构建复杂的应用程序或服务，其中每个镜像负责一个特定的组件或功能。以下是一些常见的组合多个镜像的方法：

1. Docker Compose： Docker Compose 是一个用于定义和运行多容器 Docker 应用程序的工具。你可以使用 Docker Compose 文件（通常命名为 docker-compose.yml）来定义多个服务和它们之间的关系，然后使用 docker-compose up 命令一键启动整个应用程序。这使得组合和管理多个镜像变得非常简单。
2. 多容器部署： 对于复杂的应用程序，可能需要在不同的容器中运行多个服务或组件。你可以使用 Docker CLI 或编排工具（如 Kubernetes）手动部署和管理多个容器，并使用容器网络和服务发现来管理它们之间的通信。
3. 镜像继承和扩展： 可以创建一个基础镜像，其中包含通用的应用程序或服务功能，然后创建其他镜像来继承和扩展该基础镜像。这种方法可以确保每个镜像都遵循相同的标准和配置，并且易于管理和更新。
4. 微服务架构： 微服务架构将应用程序拆分为多个小型服务，每个服务都运行在自己的容器中，并且可以独立地进行开发、部署和扩展。这种方法可以提高应用程序的灵活性、可伸缩性和可维护性。
5. 适配器模式： 有时候需要将不同的应用程序或服务连接起来，以构建更大型的系统。你可以使用适配器模式来创建专门的容器或镜像，用于连接不同的服务，并在它们之间进行数据交换和通信。

无论你选择哪种方法，组合多个镜像都需要考虑到每个镜像的配置和依赖关系，以确保它们能够正确地协同工作，并且能够满足应用程序的需求。

5.3 构建自定义镜像集群

构建自定义镜像集群通常涉及以下步骤：

1. 定义镜像集群结构： 首先，你需要确定你的镜像集群将包含哪些组件和服务，并定义它们之间的关系和依赖关系。考虑使用微服务架构来拆分应用程序为多个独立的服务，每个服务运行在自己的容器中。
2. 创建 Dockerfile： 为每个服务编写 Dockerfile，定义该服务的构建过程和环境配置。确保 Dockerfile 中包含了所需的依赖项、环境变量、启动命令等信息，并且符合最佳实践。
3. 构建镜像： 使用 Docker CLI 或 CI/CD 工具构建每个服务的镜像。确保你的构建过程是自动化的，并且可以在持续集成环境中进行。
4. 组合镜像： 使用 Docker Compose 或编排工具（如 Kubernetes）定义和组合你的镜像集群。在 Docker Compose 文件或 Kubernetes 配置文件中指定每个服务的镜像名称、端口映射、环境变量等配置信息。
5. 测试和验证： 在本地或测试环境中测试和验证你的镜像集群。确保每个服务都能够正确启动和运行，并且能够相互通信和协作。
6. 部署到生产环境： 一旦你的镜像集群通过了测试，就可以将其部署到生产环境中。根据需要使用 Docker Swarm、Kubernetes 或其他容器编排工具进行部署，并确保你的部署过程是可靠和自动化的。
7. 监控和维护： 部署后，定期监控你的镜像集群的运行状态，并进行必要的维护和更新。使用日志记录、指标监控和警报系统来及时发现和解决问题。
8. 持续改进： 不断改进和优化你的镜像集群，以提高性能、可靠性和安全性。定期审查和优化 Dockerfile、配置文件和部署过程，以适应不断变化的需求和环境。

构建自定义镜像集群是一个复杂的过程，需要仔细计划和管理。确保你的镜像集群能够满足应用程序的需求，并且能够在生产环境中稳定运行和扩展。

六、总结

Docker 镜像的创建和使用是容器化应用程序开发和部署的基础。通过 Dockerfile 定义镜像的构建过程，可以灵活地配置环境和依赖项，并最小化镜像大小。使用 Docker Hub 或私有镜像仓库管理和分享镜像，可以方便地共享和部署应用程序。在创建镜像时，应遵循最佳实践，包括最小化镜像大小、定期更新和监控镜像安全性。最后，通过 Docker Compose 或容器编排工具部署和管理镜像集群，实现应用程序的自动化部署和运维。通过深入理解 Docker 镜像的创建和使用，可以提高开发效率、简化部署流程，并确保应用程序的可靠性和安全性。