Docker三剑客

在当今软件开发和运维领域，容器化技术正扮演着越来越重要的角色。Docker 作为容器化技术的先驱和领导者，极大地简化了应用程序的打包、分发和部署过程。而 Docker 生态系统中的 “三剑客”——Docker、Docker Compose 和 Docker Swarm，更是为开发者和运维人员提供了强大而便捷的工具，帮助他们高效地管理和扩展容器化应用。

二、Docker 基础

Docker简介

Docker 是一个开源的应用容器引擎，它允许开发者将应用及其依赖打包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 服务器，也可以实现虚拟化。通过 Docker，能够实现应用的封装、部署、运行的生命周期管理，让应用在不同环境中保持一致性，大大简化了软件交付过程。

Docker架构

整体架构概述

Docker 采用客户端 - 服务器（C/S）架构，主要由 Docker 客户端（Docker Client）、Docker 守护进程（Docker Daemon）、镜像（Images）、容器（Containers）和仓库（Registries）组成。客户端负责接收用户的命令并发送给守护进程，守护进程负责处理这些命令，管理镜像和容器的生命周期。

详细介绍

1. Docker 客户端（Docker Client）：Docker 客户端是用户与 Docker 交互的主要方式，用户可以通过命令行工具（如 docker 命令）向 Docker 守护进程发送各种操作请求，如创建容器、拉取镜像等。
2. Docker 守护进程（Docker Daemon）：Docker 守护进程是 Docker 架构的核心组件，它在后台运行，负责处理 Docker 客户端发送的请求。守护进程管理着镜像、容器的生命周期，包括创建、启动、停止、删除等操作，同时还负责与仓库进行交互，拉取和推送镜像。
3. 镜像（Image）：镜像类似于虚拟机的模板，是一个只读的文件系统，包含了运行应用程序所需的所有文件和配置。可以通过 Dockerfile 来定义和构建镜像。
4. 容器（Container）：容器是镜像的一个运行实例。它是一个独立的进程，与宿主机和其他容器相互隔离。可以通过 docker run 命令来创建和启动容器。
5. 仓库（Registry）：仓库是用于存储和分发镜像的地方。Docker Hub 是 Docker 官方提供的公共仓库，也可以搭建自己的私有仓库。

Docker基本操作示例

安装Docker

一键离线安装docker方案：cicd / easy-docker · GitLab

# 下载后执行以下命令，如遇系统不兼容请联系作者
sh install-docker.sh install

镜像操作

#!/bin/bash# 1. 查看本地镜像列表
# 使用 docker images 命令查看本地已有的 Docker 镜像
echo "查看本地镜像列表:"
docker images# 2. 拉取镜像
# 使用 docker pull 命令从 Docker Hub 拉取一个 nginx 镜像，版本为 latest，网络问题可替换为
swr.cn-southwest-2.myhuaweicloud.com/wd/nginx:1.27-alpine3.19echo "拉取 nginx:latest 镜像..."
docker pull swr.cn-southwest-2.myhuaweicloud.com/wd/nginx:1.27-alpine3.19# 3. 再次查看本地镜像列表，确认新镜像已拉取
echo "再次查看本地镜像列表:"
docker images# 4. 查看镜像详细信息
# 使用 docker inspect 命令查看 nginx:latest 镜像的详细信息
echo "查看 nginx:latest 镜像的详细信息:"
docker inspect nginx:latest# 5. 为镜像打标签
# 使用 docker tag 命令为 nginx:latest 镜像添加一个新标签 my-nginx:1.0
echo "为 nginx:latest 镜像打标签 my-nginx:1.0..."
docker tag nginx:latest my-nginx:1.0# 6. 查看本地镜像列表，确认新标签已添加
echo "查看本地镜像列表，确认新标签已添加:"
docker images# 7. 推送镜像到 Docker Hub（需提前登录）
# 这里假设已经登录 Docker Hub 账号
# 使用 docker push 命令将 my-nginx:1.0 镜像推送到 Docker Hub
# 注意：需要将 your-dockerhub-username 替换为你的 Docker Hub 用户名
echo "推送 my-nginx:1.0 镜像到 Docker Hub..."
docker push your-dockerhub-username/my-nginx:1.0# 8. 删除本地镜像
# 使用 docker rmi 命令删除本地的 my-nginx:1.0 镜像
echo "删除本地的 my-nginx:1.0 镜像..."
docker rmi my-nginx:1.0# 9. 最后一次查看本地镜像列表，确认镜像已删除
echo "最后一次查看本地镜像列表:"
docker imagesecho "脚本执行完毕。"

容器操作

#!/bin/bash# 1. 拉取一个用于测试的镜像
# 使用 docker pull 命令从 Docker Hub 拉取一个 Ubuntu 22.04 镜像
echo "拉取 ubuntu:22.04 镜像..."
docker pull ubuntu:22.04# 2. 创建并启动一个新容器
# 使用 docker run 命令基于 ubuntu:22.04 镜像创建并启动一个新容器
# -d 选项表示让容器在后台运行
# --name my_ubuntu_container 为容器指定名称为 my_ubuntu_container
# 最后执行 /bin/bash 作为容器的启动命令
echo "创建并启动一个名为 my_ubuntu_container 的容器..."
docker run -d --name my_ubuntu_container ubuntu:22.04 /bin/bash# 3. 查看正在运行的容器列表
# 使用 docker ps 命令查看当前正在运行的容器
echo "查看正在运行的容器列表:"
docker ps# 4. 查看所有容器（包括已停止的）
# 使用 docker ps -a 命令查看所有容器，无论其运行状态如何
echo "查看所有容器（包括已停止的）:"
docker ps -a# 5. 进入正在运行的容器
# 使用 docker exec 命令进入 my_ubuntu_container 容器
# -it 选项表示以交互模式和分配一个伪终端
# 最后执行 /bin/bash 进入容器的 Bash 终端
echo "进入 my_ubuntu_container 容器..."
docker exec -it my_ubuntu_container /bin/bash <<EOF
ls
exit
EOF# 6. 停止正在运行的容器
# 使用 docker stop 命令停止 my_ubuntu_container 容器
echo "停止 my_ubuntu_container 容器..."
docker stop my_ubuntu_container# 7. 再次查看所有容器，确认容器已停止
echo "再次查看所有容器，确认容器已停止:"
docker ps -a# 8. 启动已停止的容器
# 使用 docker start 命令启动已停止的 my_ubuntu_container 容器
echo "启动已停止的 my_ubuntu_container 容器..."
docker start my_ubuntu_container# 9. 查看容器的详细信息
# 使用 docker inspect 命令查看 my_ubuntu_container 容器的详细信息
echo "查看 my_ubuntu_container 容器的详细信息:"
docker inspect my_ubuntu_container# 10. 删除容器
# 先停止容器
docker stop my_ubuntu_container
# 使用 docker rm 命令删除 my_ubuntu_container 容器
echo "删除 my_ubuntu_container 容器..."
docker rm my_ubuntu_container# 11. 最后一次查看所有容器，确认容器已删除
echo "最后一次查看所有容器，确认容器已删除:"
docker ps -aecho "脚本执行完毕。"

存储操作

#!/bin/bash# 1. 创建数据卷
# 使用 docker volume create 命令创建一个名为 my_volume 的数据卷
echo "创建数据卷 my_volume..."
docker volume create my_volume# 2. 列出所有数据卷
# 使用 docker volume ls 命令查看当前所有的数据卷
echo "列出所有数据卷:"
docker volume ls# 3. 查看特定数据卷的详细信息
# 使用 docker volume inspect 命令查看 my_volume 数据卷的详细信息
echo "查看 my_volume 数据卷的详细信息:"
docker volume inspect my_volume# 4. 使用数据卷启动容器
# 使用 docker run 命令基于 nginx 镜像启动一个容器
# -d 表示容器在后台运行
# -p 8080:80 将容器的 80 端口映射到宿主机的 8080 端口
# -v my_volume:/usr/share/nginx/html 将 my_volume 数据卷挂载到容器的 /usr/share/nginx/html 目录
# --name my_nginx_container 为容器指定名称为 my_nginx_container
echo "使用数据卷启动 nginx 容器..."
docker run -d -p 8080:80 -v my_volume:/usr/share/nginx/html --name my_nginx_container nginx# 5. 查看容器挂载信息
# 使用 docker inspect 命令查看 my_nginx_container 容器的挂载信息
# 通过 grep 命令筛选出包含 Mounts 的行以及其后的 10 行信息
echo "查看 my_nginx_container 容器的挂载信息:"
docker inspect my_nginx_container | grep Mounts -A 10# 6. 查看 Docker 系统磁盘使用情况
# 使用 docker system df 命令查看 Docker 系统中镜像、容器、数据卷等占用的磁盘空间
echo "查看 Docker 系统磁盘使用情况:"
docker system df# 7. 停止并删除容器
# 使用 docker stop 命令停止 my_nginx_container 容器
# 使用 docker rm 命令删除已停止的 my_nginx_container 容器
echo "停止并删除 my_nginx_container 容器..."
docker stop my_nginx_container
docker rm my_nginx_container# 8. 删除数据卷
# 使用 docker volume rm 命令删除 my_volume 数据卷
echo "删除 my_volume 数据卷..."
docker volume rm my_volume# 9. 清理 Docker 系统
# 使用 docker system prune -f 命令清理 Docker 系统中未使用的容器、网络、悬空镜像等
# -f 参数表示不进行确认提示，直接执行清理操作
echo "清理 Docker 系统..."
docker system prune -fecho "脚本执行完毕。"# 知识扩展
-v 容器内路径 # 匿名挂载（不建议）
-v 卷名:容器内路径 # 具名挂载
-v 宿主机路径:容器内路径 # 指定路径挂载:ro # 只读
:ro # 可读可写

网络操作

#!/bin/bash# 1. 查看 Docker 网络列表
# 使用 docker network ls 命令列出所有 Docker 网络
echo "查看 Docker 网络列表:"
docker network ls# 2. 创建自定义网络
# 使用 docker network create 命令创建一个名为 my_custom_network 的桥接网络
echo "创建自定义桥接网络 my_custom_network..."
docker network create my_custom_network# 3. 再次查看 Docker 网络列表，确认新网络已创建
echo "再次查看 Docker 网络列表:"
docker network ls# 4. 查看自定义网络的详细信息
# 使用 docker network inspect 命令查看 my_custom_network 网络的详细信息
echo "查看 my_custom_network 网络的详细信息:"
docker network inspect my_custom_network# 5. 启动容器并连接到自定义网络
# 使用 docker run 命令基于 nginx 镜像启动一个名为 my_nginx_container 的容器
# --network my_custom_network 指定容器连接到 my_custom_network 网络
# -d 表示容器在后台运行
# -p 8080:80 将容器的 80 端口映射到宿主机的 8080 端口
echo "启动 nginx 容器并连接到 my_custom_network 网络..."
docker run -d --network my_custom_network --name my_nginx_container -p 8080:80 nginx# 6. 启动另一个容器并连接到同一网络
# 启动一个名为 my_busybox_container 的 busybox 容器，并连接到 my_custom_network 网络
# 容器启动后执行 sleep 3600 命令，使容器保持运行状态
echo "启动 busybox 容器并连接到 my_custom_network 网络..."
docker run -d --network my_custom_network --name my_busybox_container busybox sleep 3600# 7. 测试容器间的网络连通性
# 使用 docker exec 命令在 my_busybox_container 容器中执行 ping 命令，测试与 my_nginx_container 容器的连通性
echo "测试 my_busybox_container 到 my_nginx_container 的网络连通性..."
docker exec my_busybox_container ping -c 3 my_nginx_container# 8. 断开容器与网络的连接
# 使用 docker network disconnect 命令断开 my_nginx_container 容器与 my_custom_network 网络的连接
echo "断开 my_nginx_container 与 my_custom_network 网络的连接..."
docker network disconnect my_custom_network my_nginx_container# 9. 再次测试容器间的网络连通性，此时应该无法连通
echo "再次测试 my_busybox_container 到 my_nginx_container 的网络连通性（应无法连通）..."
docker exec my_busybox_container ping -c 3 my_nginx_container# 10. 停止并删除容器
# 使用 docker stop 命令停止 my_nginx_container 和 my_busybox_container 容器
# 使用 docker rm 命令删除已停止的容器
echo "停止并删除容器..."
docker stop my_nginx_container my_busybox_container
docker rm my_nginx_container my_busybox_container# 11. 删除自定义网络
# 使用 docker network rm 命令删除 my_custom_network 网络
echo "删除 my_custom_network 网络..."
docker network rm my_custom_network# 12. 最后一次查看 Docker 网络列表，确认自定义网络已删除
echo "最后一次查看 Docker 网络列表:"
docker network lsecho "脚本执行完毕。"# 知识扩展
veth pair 设备总是成对出现的，就像一条虚拟的网线，一端连接着容器内部的网络命名空间，另一端连接到 Docker 主机上的网桥（通常是 docker0 网桥）或者其他网络设备。通过这种方式，容器能够与主机以及其他容器进行通信。
ip link show type veth容器的内网IP会漂移，两个容器之间如何通信？

其他操作

#!/bin/bash# 1. 查看 Docker 系统磁盘使用情况
echo "查看 Docker 系统磁盘使用情况:"
docker system df# 2. 清理 Docker 系统中未使用的资源
# 此命令会删除停止的容器、未使用的网络、悬空镜像和未使用的数据卷
echo "清理 Docker 系统中未使用的资源:"
docker system prune -f# 3. 查看容器日志
# 假设存在一个名为 my_container 的容器，查看其日志
echo "查看 my_container 容器的日志:"
docker logs my_container# 4. 实时跟踪容器日志
# 使用 -f 选项实时跟踪 my_container 的日志输出
echo "实时跟踪 my_container 的日志输出（按 Ctrl+C 停止）:"
docker logs -f my_container &
# 等待 5 秒后停止跟踪日志
sleep 5
kill $!# 5. 查看容器内正在运行的进程
echo "查看 my_container 容器内正在运行的进程:"
docker top my_container# 6. 实时监控容器的资源使用情况
# 显示 my_container 的 CPU、内存、网络 I/O 和磁盘 I/O 等信息
echo "实时监控 my_container 的资源使用情况（按 Ctrl+C 停止）:"
docker stats my_container &
# 等待 5 秒后停止监控
sleep 5
kill $!# 7. 实时监控 Docker 守护进程的事件
# 监控容器的创建、启动、停止、删除等事件
echo "实时监控 Docker 守护进程的事件（按 Ctrl+C 停止）:"
docker events &
# 等待 5 秒后停止监控
sleep 5
kill $!# 8. 查看 Docker 客户端和守护进程的版本信息
echo "查看 Docker 客户端和守护进程的版本信息:"
docker version# 9. 搜索 Docker Hub 上的镜像
# 搜索包含 "redis" 关键字的镜像
echo "搜索 Docker Hub 上的 redis 镜像:"
docker search redis# 10. 根据 Dockerfile 构建镜像
# 假设当前目录有 Dockerfile，构建名为 my_image:1.0 的镜像
echo "根据当前目录的 Dockerfile 构建 my_image:1.0 镜像:"
docker build -t my_image:1.0 .echo "脚本执行完毕。"

​​​​​​​构建镜像

假设我们有一个简单的 Java 应用，以下是一个 Dockerfile 的示例：

# 基础镜像，使用 OpenJDK 17 作为基础
FROM openjdk:17# 设置工作目录
WORKDIR /app# 将打包好的 JAR 文件复制到容器的 /app 目录下
COPY target/demo-0.0.1-SNAPSHOT.jar app.jar# 暴露应用端口，这里假设 Spring Boot 应用默认端口是 8080
EXPOSE 8080# 定义容器启动时执行的命令
CMD ["java", "-jar", "app.jar"]    

使用以下命令构建镜像：

docker build -t my-app:latest  .

Docker的核心技术

资源隔离（命名空间）

命名空间（Namespaces）是 Linux 内核提供的一种机制，用于隔离不同进程的资源，使得每个进程（容器）都感觉自己拥有独立的系统资源。Docker 主要使用了以下几种命名空间：

1. PID 命名空间（Process ID）：用于隔离进程的 ID。在不同的 PID 命名空间中，进程可以有相同的 PID。这样，每个容器都有自己独立的进程树，容器内的进程不会影响到宿主机或其他容器内的进程。例如，在容器内部，进程的 PID 从 1 开始计数，就像在一个独立的操作系统中一样。
2. NET 命名空间（Network）：隔离网络资源。每个容器可以有自己独立的网络栈，包括网络接口、IP 地址、端口等。容器可以拥有自己的虚拟网卡，通过网络命名空间的配置，可以实现容器与宿主机、其他容器之间的网络通信。比如，一个容器可以监听自己内部的端口，而不会与宿主机或其他容器的端口冲突。
3. IPC 命名空间（Inter - Process Communication）：隔离进程间通信资源。不同容器内的进程无法直接通过共享内存、信号量等 IPC 机制进行通信，保证了容器间的独立性。
4. MNT 命名空间（Mount）：隔离文件系统挂载点。每个容器都有自己独立的文件系统视图，容器内的进程只能看到自己挂载的文件系统，无法访问宿主机或其他容器的文件系统，除非进行了显式的挂载操作。
5. UTS 命名空间（Unix Time - Sharing System）：隔离系统的主机名和域名。容器可以有自己独立的主机名和域名，使得容器内的应用程序感觉自己运行在一个独立的主机上。
6. USER 命名空间：隔离用户和用户组。允许容器内的进程以不同的用户和用户组 ID 运行，增强了容器的安全性和隔离性。

资源限制（控制组）

控制组（Control Groups，简称 cgroups）是 Linux 内核的另一个重要特性，用于限制和监控进程组所使用的系统资源，包括 CPU、内存、磁盘 I/O 等。Docker 使用 cgroups 来实现对容器资源的精确控制：

1. CPU 限制：可以通过设置 CPU 份额或 CPU 周期来限制容器使用 CPU 的资源。例如，通过设置 --cpu - shares 参数，可以为容器分配相对的 CPU 时间片，保证容器在多容器环境中合理使用 CPU 资源。
2. 内存限制：可以限制容器使用的内存总量，防止容器过度占用内存导致宿主机性能下降。通过设置 --memory 参数，可以指定容器可以使用的最大内存量。
3. 磁盘 I/O 限制：可以对容器的磁盘读写操作进行限制，控制容器对磁盘 I/O 资源的使用。例如，通过设置 --blkio - weight 参数，可以调整容器的磁盘 I/O 权重。

镜像原理（联合文件系统）

Docker 镜像是一个只读的模板，采用分层结构，由多个只读层组成。联合文件系统（Union File System）是实现这种分层结构的关键技术，它允许将多个不同的文件系统层合并成一个统一的文件系统视图：

1. 分层结构：每个镜像层都代表一个文件系统的更改，例如基础镜像层可能包含操作系统的基本文件，而后续的层可以添加应用程序代码、依赖库等。这种分层结构使得镜像的构建和共享更加高效，不同的镜像可以共享相同的基础层。
2. 写时复制（Copy - on - Write）：当创建一个容器时，Docker 会在镜像的最上层添加一个可写层。在容器运行过程中，如果需要对文件进行修改，Docker 会将需要修改的文件从只读层复制到可写层，然后在可写层进行修改，而不会影响到只读层。这样可以减少磁盘空间的使用，提高容器的启动速度。

容器运行时

容器运行时负责创建和管理容器的生命周期，Docker 支持多种容器运行时，如 runc、containerd 等：

1. runc：是一个轻量级的容器运行时，它是 Docker 容器运行的基础。runc 直接与 Linux 内核交互，使用命名空间和控制组来创建和隔离容器。它负责容器的创建、启动、停止、销毁等操作。
2. containerd：是一个更高级的容器运行时，它提供了更丰富的功能，如镜像管理、容器编排等。containerd 作为一个守护进程运行在宿主机上，与 Docker 守护进程进行通信，负责管理容器的生命周期和镜像的存储与分发。

网络通信原理

Docker 支持多种网络模式，如 bridge、host、none、overlay 等，不同的网络模式有不同的通信原理：

1. bridge 模式：这是 Docker 默认的网络模式。在 bridge 模式下，Docker 会创建一个虚拟网桥（通常名为 docker0），容器通过虚拟网卡连接到这个网桥上。容器可以通过虚拟网桥与宿主机和其他容器进行通信。宿主机上的 iptables 规则会对容器的网络流量进行转发和过滤。
2. host 模式：容器直接使用宿主机的网络接口，没有独立的网络命名空间。容器可以直接访问宿主机的网络资源，网络性能较高，但容器之间的网络隔离性较差。
3. none 模式：容器没有网络连接，只有本地回环接口。适用于不需要网络访问的容器。
4. overlay 模式：用于在多个 Docker 主机之间创建分布式网络，实现容器的跨主机通信。overlay 网络使用 VXLAN 等技术将多个 Docker 主机的网络连接起来，使得容器可以像在同一个局域网中一样进行通信。

存储管理原理

Docker 提供了多种存储管理方式，包括数据卷（Volumes）和绑定挂载（Bind Mounts）：

1. 数据卷（Volumes）：是 Docker 管理的一种存储方式，数据卷绕过了容器的文件系统，直接将宿主机的目录或文件挂载到容器中。数据卷可以在容器之间共享和重用，并且在容器删除后数据不会丢失。Docker 会在宿主机的特定目录（通常是 /var/lib/docker/volumes）中管理数据卷。
2. 绑定挂载（Bind Mounts）：允许用户将宿主机上的任意目录或文件挂载到容器中。与数据卷不同，绑定挂载的路径是由用户指定的，而不是由 Docker 管理的。绑定挂载可以将宿主机的配置文件、数据目录等挂载到容器中，方便容器访问宿主机的资源。

三、DockerCompose

DockerCompose 简介

在实际应用中，一个应用往往由多个服务组成，如一个 Web 应用可能包含 Web 服务器、数据库服务器等。Docker Compose 就是为了简化多容器应用的部署和管理而设计的工具。通过一个 YAML 文件，我们可以定义应用的所有服务、网络和卷，然后使用一个命令就可以启动和管理整个应用。

DockerCompose 文件示例

以下是一个简单的 Web 应用的 Docker Compose 文件示例：

version: '3'
services:
  app:
    ports:- "8080:8080"
    depends_on:- db
  db:
    image: mysql:5.7
    environment:MYSQL_ROOT_PASSWORD: exampleMYSQL_DATABASE: mydb
    volumes:- db-data:/var/lib/mysqlvolumes:
  db-data:

DockerCompose 基本操作

#!/bin/bash# 确保当前目录下存在有效的 docker-compose.yml 文件# 1. 查看 Docker Compose 版本
echo "查看 Docker Compose 版本"
docker-compose version# 2. 根据 docker-compose.yml 文件构建并启动服务，以守护进程模式运行
echo "构建并启动服务（后台运行）"
docker-compose up -d# 3. 查看正在运行的服务状态
echo "查看正在运行的服务状态"
docker-compose ps# 4. 查看服务的日志输出
echo "查看服务日志"
docker-compose logs# 5. 停止正在运行的服务
echo "停止正在运行的服务"
docker-compose stop# 6. 启动已停止的服务
echo "启动已停止的服务"
docker-compose start# 7. 重新构建并启动服务
echo "重新构建并启动服务（后台运行）"
docker-compose up -d --build# 8. 停止并移除服务相关的容器、网络
echo "停止并移除服务相关的容器、网络"
docker-compose down

四、DockerSwarm

DockerSwarm 简介

Docker Swarm 是 Docker 官方提供的集群管理和编排工具，它允许将多个 Docker 主机组成一个集群，并将应用程序部署到这个集群上。Docker Swarm 提供了服务发现、负载均衡、高可用性等功能，使得应用程序可以在集群中高效地运行和扩展。

DockerSwarm 集群搭建

初始化Swarm 集群

在一台 Docker 主机上执行以下命令来初始化 Swarm 集群：

docker swarm init

执行该命令后，会生成一个加入集群的命令，类似于：

docker swarm join --token SWMTKN-1-xxxxxx 192.168.1.100:2377

​​​​​​​加入Swarm 集群

在其他 Docker 主机上执行上述生成的加入命令，即可将这些主机加入到 Swarm 集群中。

DockerSwarm 服务部署

创建服务

docker service create --name my-web-service --replicas 3 -p 80:3000 my-node-app

扩展服务

docker service scale my-web-service=5

​​​​​​​更新服务

docker service update --image my-node-app:v2 my-web-service