Docker容器技术详解

前言

作为程序员，你一定听过这句话："这程序在我电脑上明明是好的，怎么到你那就不行了？"这背后的根本原因是环境不一致。Docker 就是为了解决这个问题而生的。本文将用最通俗的方式，带你理解 Docker 的核心概念和工作原理。

🏠个人主页：你的主页

---

文章目录

• Docker容器技术详解
  • 一、从一个比喻开始理解Docker
  • 二、Docker解决了什么问题
  • 三、Docker核心概念
  • 四、Docker架构原理
  • 五、Docker与虚拟机的区别
  • 六、Docker实战入门
  • 七、Docker Compose多容器编排
  • 八、Docker Swarm与K8s的关系
  • 九、总结

---

一、从一个比喻开始理解Docker

1.1 大豆的跨国运输问题

假设你是一个农产品贸易商，需要把美国的大豆运到中国。

最原始的方式：直接把大豆散装在船舱里。

问题来了：

• 大豆可能受潮发霉
• 和其他货物混在一起
• 装卸效率低下

改进方式：用麻袋装好再运。

还是有问题：

• 麻袋大小不一，堆放困难
• 不同货物需要不同包装
• 换船时要重新装卸

最终方案：使用集装箱。

把大豆装进标准化的集装箱里：

• 集装箱尺寸统一，方便堆放
• 密封防潮，保护货物
• 可以直接从船上吊装到卡车上
• 不管里面装的是大豆、手机还是药品，外面看起来都一样

1.2 集装箱思想与Docker

船 = 服务器
货物 = 应用程序
集装箱 = Docker 容器

物流领域	IT 领域
货物（大豆、手机、药品）	应用程序（博客、商城、数据库）
船舱	服务器/虚拟机
集装箱	Docker 容器
集装箱标准化	容器镜像标准化
货物+集装箱一起运输	应用+环境一起打包部署

Docker 的核心思想：把应用程序和它依赖的环境打包成一个标准化的"集装箱"（容器），这个"集装箱"可以在任何支持 Docker 的服务器上运行。

1.3 为什么不直接用船（虚拟机）

你可能会问：直接用船运不行吗？为什么要加集装箱？

直接用船（虚拟机）的问题：

假设你要运 100 箱大豆和 50 箱手机：

• 方案一：租两艘船，一艘运大豆，一艘运手机
• 问题：两艘船太贵了，而且每艘船都没装满

用集装箱（Docker）的好处：

• 一艘船可以装很多集装箱
• 每个集装箱相互隔离，互不影响
• 大豆不会把手机弄湿，手机不会把大豆压坏
• 装卸效率高，标准化操作

对应到 IT 领域：

方案	类比	资源消耗
每个应用一台虚拟机	每种货物一艘船	高（每个虚拟机都要完整操作系统）
多个容器共享一台服务器	多个集装箱共享一艘船	低（容器共享宿主机内核）

---

二、Docker解决了什么问题

2.1 环境不一致问题

场景：你在 Ubuntu 上开发了一个 Python 应用，要部署到 CentOS 服务器上。

没有 Docker：

# Ubuntu 上安装依赖
apt-get install python3 python3-pip libmysqlclient-dev

# CentOS 上安装依赖（命令不一样！）
yum install python3 python3-pip mysql-devel

# 可能还有版本差异、路径差异、配置差异...

有了 Docker：

# 不管什么系统，命令都一样
docker pull my-python-app
docker run my-python-app

2.2 依赖冲突问题

场景：服务器上要同时运行两个应用，一个需要 Python 2.7，一个需要 Python 3.9。

没有 Docker：

服务器
├── Python 2.7  ← 应用A需要
└── Python 3.9  ← 应用B需要
    ↑ 冲突！系统默认只能用一个版本

有了 Docker：

服务器
├── 容器A（内置 Python 2.7）← 应用A
└── 容器B（内置 Python 3.9）← 应用B
    ↑ 互不影响！

2.3 部署效率问题

场景：新来了 10 台服务器，要部署同一个应用。

没有 Docker：

登录服务器1 → 安装依赖 → 配置环境 → 部署应用
登录服务器2 → 安装依赖 → 配置环境 → 部署应用
...
登录服务器10 → 安装依赖 → 配置环境 → 部署应用

耗时：可能一整天

有了 Docker：

# 在所有服务器上执行同一条命令
docker pull my-app && docker run my-app

# 耗时：几分钟

2.4 资源利用率问题

场景：有 3 个小应用，每个只需要 1GB 内存。

用虚拟机：

物理服务器（16GB 内存）
├── 虚拟机1（4GB）→ 应用A（实际用 1GB）
├── 虚拟机2（4GB）→ 应用B（实际用 1GB）
└── 虚拟机3（4GB）→ 应用C（实际用 1GB）

浪费：12GB - 3GB = 9GB

用 Docker：

物理服务器（16GB 内存）
├── 容器A（限制 1.5GB）→ 应用A
├── 容器B（限制 1.5GB）→ 应用B
└── 容器C（限制 1.5GB）→ 应用C

剩余：16GB - 4.5GB = 11.5GB 可用于其他容器

---

三、Docker核心概念

3.1 镜像（Image）

镜像是什么：镜像就是一个"压缩包"，里面包含了应用程序和它运行所需的一切环境（操作系统文件、依赖库、配置文件等）。

打个比方：镜像就像是一个"模具"，你可以用这个模具生产出无数个一模一样的"产品"（容器）。

镜像的特点：

• 只读：镜像一旦创建就不能修改
• 分层：镜像由多层组成，可以复用
• 可分享：可以上传到镜像仓库供他人使用

3.2 容器（Container）

容器是什么：容器是镜像的"运行实例"，是一个独立运行的环境。

打个比方：

• 镜像 = 类（Class）
• 容器 = 对象（Object）

你可以从一个镜像创建多个容器，就像从一个类可以 new 多个对象。

镜像：nginx:latest
    ↓ docker run
容器1：nginx-web1（运行中）
容器2：nginx-web2（运行中）
容器3：nginx-web3（已停止）

3.3 Dockerfile

Dockerfile 是什么：Dockerfile 是一个"菜谱"，告诉 Docker 如何一步步构建镜像。

举个例子：

# 基础镜像：从 Python 3.9 开始
FROM python:3.9-slim

# 设置工作目录
WORKDIR /app

# 复制依赖文件
COPY requirements.txt .

# 安装依赖
RUN pip install -r requirements.txt

# 复制应用代码
COPY . .

# 暴露端口
EXPOSE 8000

# 启动命令
CMD ["python", "app.py"]

Dockerfile 就像做菜的步骤：

1. 准备一口锅（FROM：基础镜像）
2. 放入食材（COPY：复制文件）
3. 加调料翻炒（RUN：执行命令）
4. 装盘上桌（CMD：启动应用）

3.4 镜像仓库（Registry）

镜像仓库是什么：存放镜像的地方，类似于代码的 GitHub。

代码管理	镜像管理
GitHub	Docker Hub
git push	docker push
git pull	docker pull
代码仓库	镜像仓库

常见的镜像仓库：

• Docker Hub：官方公共仓库
• 阿里云容器镜像服务：国内访问快
• Harbor：企业私有仓库
• 公司内部仓库：存放公司私有镜像

3.5 概念关系图

┌─────────────────────────────────────────────────────────────┐
│                      Docker 核心概念                         │
└─────────────────────────────────────────────────────────────┘

Dockerfile（菜谱）
    │
    │ docker build
    ▼
Image（镜像/模具）
    │
    ├── docker push ──────► Registry（镜像仓库）
    │                            │
    │                            │ docker pull
    │                            ▼
    │                       Image（镜像）
    │                            │
    │ docker run                 │ docker run
    ▼                            ▼
Container（容器）           Container（容器）

---

四、Docker架构原理

4.1 整体架构

Docker 采用经典的 Client-Server 架构：

┌─────────────────────────────────────────────────────────────┐
│                      Docker 架构                             │
└─────────────────────────────────────────────────────────────┘

┌──────────────┐         ┌──────────────────────────────────┐
│              │         │         Docker Daemon            │
│   Docker     │  REST   │  ┌────────────────────────────┐  │
│   Client     │  API    │  │      Docker Server         │  │
│              │ ──────► │  │   (HTTP API 服务器)         │  │
│  docker run  │         │  └─────────────┬──────────────┘  │
│  docker pull │         │                │                 │
│  docker build│         │  ┌─────────────▼──────────────┐  │
│              │         │  │         Engine             │  │
└──────────────┘         │  │   (创建 Job 执行任务)       │  │
                         │  └─────────────┬──────────────┘  │
                         │                │                 │
                         │  ┌─────────────▼──────────────┐  │
                         │  │      containerd            │  │
                         │  │   (容器运行时管理)          │  │
                         │  └─────────────┬──────────────┘  │
                         │                │                 │
                         │  ┌─────────────▼──────────────┐  │
                         │  │         runc               │  │
                         │  │   (实际创建容器)            │  │
                         │  └────────────────────────────┘  │
                         └──────────────────────────────────┘

4.2 各组件职责

组件	职责
Docker Client	命令行工具，解析用户命令，调用 API
Docker Daemon	守护进程，接收请求，管理容器和镜像
Docker Server	HTTP 服务器，提供 RESTful API
Engine	核心引擎，创建 Job 执行具体任务
containerd	容器运行时，管理容器生命周期
runc	底层工具，实际创建和运行容器

4.3 不同命令的执行流程

docker build（构建镜像）：

docker build -t my-app .
        │
        ▼
Docker Client 解析命令
        │
        ▼
调用 Docker Daemon API
        │
        ▼
Engine 创建 Build Job
        │
        ▼
按 Dockerfile 一层层构建镜像
        │
        ▼
生成镜像文件，存储到本地

docker pull（拉取镜像）：

docker pull nginx:latest
        │
        ▼
Docker Client 解析命令
        │
        ▼
调用 Docker Daemon API
        │
        ▼
Engine 创建 Pull Job
        │
        ▼
连接 Docker Registry（镜像仓库）
        │
        ▼
下载镜像层，存储到本地

docker run（运行容器）：

docker run -d nginx
        │
        ▼
Docker Client 解析命令
        │
        ▼
调用 Docker Daemon API
        │
        ▼
Engine 创建 Run Job
        │
        ▼
调用 containerd
        │
        ▼
containerd 调用 runc
        │
        ▼
runc 创建容器进程
        │
        ▼
容器运行！

4.4 容器的底层原理

容器本质上是一个特殊的进程，它利用 Linux 内核的两个关键技术：

Namespace（命名空间）：实现隔离

┌─────────────────────────────────────────────────────────────┐
│                    宿主机操作系统                            │
├─────────────────────────────────────────────────────────────┤
│  ┌─────────────────┐  ┌─────────────────┐                  │
│  │    容器 A       │  │    容器 B       │                  │
│  │  ┌───────────┐  │  │  ┌───────────┐  │                  │
│  │  │ PID: 1    │  │  │  │ PID: 1    │  │  ← 各自认为自己  │
│  │  │ 网络: eth0│  │  │  │ 网络: eth0│  │    是独立系统    │
│  │  │ 文件系统  │  │  │  │ 文件系统  │  │                  │
│  │  └───────────┘  │  │  └───────────┘  │                  │
│  └─────────────────┘  └─────────────────┘                  │
│                                                             │
│  Namespace 让每个容器看起来像独立的操作系统                  │
└─────────────────────────────────────────────────────────────┘

Namespace 类型：

Namespace	隔离内容
PID	进程 ID
Network	网络设备、端口
Mount	文件系统挂载点
UTS	主机名
IPC	进程间通信
User	用户和用户组

Cgroups（控制组）：实现资源限制

# 限制容器最多使用 512MB 内存和 1 个 CPU
docker run -m 512m --cpus 1 nginx

Cgroups 可以限制：

• CPU 使用率
• 内存使用量
• 磁盘 I/O
• 网络带宽

---

五、Docker与虚拟机的区别

5.1 架构对比

虚拟机架构：

┌─────────────────────────────────────────────────────────────┐
│                      物理服务器                              │
├─────────────────────────────────────────────────────────────┤
│                    宿主机操作系统                            │
├─────────────────────────────────────────────────────────────┤
│                   Hypervisor（虚拟化层）                     │
├───────────────────┬───────────────────┬─────────────────────┤
│      虚拟机 A     │      虚拟机 B     │      虚拟机 C       │
│  ┌─────────────┐  │  ┌─────────────┐  │  ┌─────────────┐    │
│  │   应用 A    │  │  │   应用 B    │  │  │   应用 C    │    │
│  ├─────────────┤  │  ├─────────────┤  │  ├─────────────┤    │
│  │   依赖库    │  │  │   依赖库    │  │  │   依赖库    │    │
│  ├─────────────┤  │  ├─────────────┤  │  ├─────────────┤    │
│  │ 完整操作系统│  │  │ 完整操作系统│  │  │ 完整操作系统│    │
│  │  (几个GB)   │  │  │  (几个GB)   │  │  │  (几个GB)   │    │
│  └─────────────┘  │  └─────────────┘  │  └─────────────┘    │
└───────────────────┴───────────────────┴─────────────────────┘

Docker 架构：

┌─────────────────────────────────────────────────────────────┐
│                      物理服务器                              │
├─────────────────────────────────────────────────────────────┤
│                    宿主机操作系统                            │
├─────────────────────────────────────────────────────────────┤
│                    Docker Engine                            │
├───────────────────┬───────────────────┬─────────────────────┤
│     容器 A        │     容器 B        │     容器 C          │
│  ┌─────────────┐  │  ┌─────────────┐  │  ┌─────────────┐    │
│  │   应用 A    │  │  │   应用 B    │  │  │   应用 C    │    │
│  ├─────────────┤  │  ├─────────────┤  │  ├─────────────┤    │
│  │   依赖库    │  │  │   依赖库    │  │  │   依赖库    │    │
│  │  (几十MB)   │  │  │  (几十MB)   │  │  │  (几十MB)   │    │
│  └─────────────┘  │  └─────────────┘  │  └─────────────┘    │
│                   │                   │                     │
│        共享宿主机操作系统内核                                │
└───────────────────┴───────────────────┴─────────────────────┘

5.2 详细对比

特性	虚拟机	Docker 容器
启动时间	分钟级	秒级
磁盘占用	GB 级	MB 级
性能	有损耗（5-20%）	接近原生
隔离性	强（完全隔离）	较强（共享内核）
操作系统	每个虚拟机一个完整 OS	共享宿主机内核
单机容量	通常几十个	可达上千个
迁移性	较差	很好

5.3 什么时候用虚拟机，什么时候用 Docker

用虚拟机的场景：

• 需要运行不同操作系统（如在 Linux 上运行 Windows）
• 需要强隔离（如多租户环境）
• 遗留系统迁移

用 Docker 的场景：

• 微服务架构
• CI/CD 流水线
• 开发测试环境
• 快速部署和扩缩容

实际中常见的组合：

物理服务器
    └── 虚拟机（ECS）
            └── Docker 容器
                    └── 应用服务

---

六、Docker实战入门

6.1 安装 Docker

Ubuntu/Debian：

# 更新包索引
sudo apt-get update

# 安装依赖
sudo apt-get install ca-certificates curl gnupg

# 添加 Docker 官方 GPG 密钥
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# 设置仓库
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 安装 Docker
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io

# 验证安装
docker --version

CentOS：

# 安装依赖
sudo yum install -y yum-utils

# 设置仓库
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

# 安装 Docker
sudo yum install docker-ce docker-ce-cli containerd.io

# 启动 Docker
sudo systemctl start docker
sudo systemctl enable docker

# 验证安装
docker --version

6.2 常用命令

镜像相关：

# 搜索镜像
docker search nginx

# 拉取镜像
docker pull nginx:latest

# 查看本地镜像
docker images

# 删除镜像
docker rmi nginx:latest

# 构建镜像
docker build -t my-app:v1 .

容器相关：

# 运行容器
docker run -d --name my-nginx -p 80:80 nginx

# 查看运行中的容器
docker ps

# 查看所有容器（包括已停止的）
docker ps -a

# 停止容器
docker stop my-nginx

# 启动已停止的容器
docker start my-nginx

# 删除容器
docker rm my-nginx

# 进入容器内部
docker exec -it my-nginx /bin/bash

# 查看容器日志
docker logs my-nginx

# 查看容器资源使用
docker stats

6.3 实战：部署一个 Java 应用

步骤一：编写 Dockerfile

# 基础镜像
FROM openjdk:17-jdk-slim

# 维护者信息
LABEL maintainer="your-email@example.com"

# 设置工作目录
WORKDIR /app

# 复制 JAR 包
COPY target/my-app.jar app.jar

# 暴露端口
EXPOSE 8080

# JVM 参数
ENV JAVA_OPTS="-Xms256m -Xmx512m"

# 启动命令
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar app.jar"]

步骤二：构建镜像

# 先用 Maven 打包
mvn clean package -DskipTests

# 构建 Docker 镜像
docker build -t my-java-app:v1 .

步骤三：运行容器

# 运行容器
docker run -d \
  --name my-java-app \
  -p 8080:8080 \
  -e SPRING_PROFILES_ACTIVE=prod \
  -v /data/logs:/app/logs \
  my-java-app:v1

# 查看日志
docker logs -f my-java-app

6.4 数据持久化

容器删除后，里面的数据也会丢失。如果需要持久化数据，有两种方式：

方式一：Volume（数据卷）

# 创建数据卷
docker volume create my-data

# 使用数据卷
docker run -d \
  --name mysql \
  -v my-data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=123456 \
  mysql:8.0

方式二：Bind Mount（绑定挂载）

# 将宿主机目录挂载到容器
docker run -d \
  --name nginx \
  -v /home/user/html:/usr/share/nginx/html \
  nginx

---

七、Docker Compose多容器编排

7.1 为什么需要 Docker Compose

实际项目中，一个应用往往由多个服务组成：

博客系统
├── 前端服务（Nginx）
├── 后端服务（Java/Python）
├── 数据库（MySQL）
└── 缓存（Redis）

如果手动一个个启动：

docker run -d mysql ...
docker run -d redis ...
docker run -d backend ...
docker run -d nginx ...

问题：

• 命令太多，容易出错
• 启动顺序有要求（先数据库，后应用）
• 服务之间的网络配置复杂

7.2 Docker Compose 是什么

Docker Compose 是一个多容器编排工具，通过一个 YAML 文件定义所有服务，一条命令启动整个应用。

7.3 docker-compose.yml 示例

version: '3.8'

services:
  # MySQL 数据库
  mysql:
    image: mysql:8.0
    container_name: blog-mysql
    environment:
      MYSQL_ROOT_PASSWORD: root123
      MYSQL_DATABASE: blog
    volumes:
      - mysql-data:/var/lib/mysql
    ports:
      - "3306:3306"
    networks:
      - blog-network
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 3

  # Redis 缓存
  redis:
    image: redis:7-alpine
    container_name: blog-redis
    ports:
      - "6379:6379"
    networks:
      - blog-network

  # 后端服务
  backend:
    build: ./backend
    container_name: blog-backend
    ports:
      - "8080:8080"
    environment:
      SPRING_DATASOURCE_URL: jdbc:mysql://mysql:3306/blog
      SPRING_REDIS_HOST: redis
    depends_on:
      mysql:
        condition: service_healthy
      redis:
        condition: service_started
    networks:
      - blog-network

  # Nginx 前端
  nginx:
    image: nginx:alpine
    container_name: blog-nginx
    ports:
      - "80:80"
    volumes:
      - ./frontend/dist:/usr/share/nginx/html
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - backend
    networks:
      - blog-network

volumes:
  mysql-data:

networks:
  blog-network:
    driver: bridge

7.4 Docker Compose 常用命令

# 启动所有服务（后台运行）
docker-compose up -d

# 查看服务状态
docker-compose ps

# 查看日志
docker-compose logs -f

# 停止所有服务
docker-compose down

# 停止并删除数据卷
docker-compose down -v

# 重新构建并启动
docker-compose up -d --build

# 只启动某个服务
docker-compose up -d mysql

# 扩缩容（启动 3 个 backend 实例）
docker-compose up -d --scale backend=3

7.5 服务依赖与启动顺序

depends_on 可以控制启动顺序：

services:
  backend:
    depends_on:
      mysql:
        condition: service_healthy  # 等 MySQL 健康检查通过
      redis:
        condition: service_started  # 等 Redis 启动

---

八、Docker Swarm与K8s的关系

8.1 单机到集群的演进

┌─────────────────────────────────────────────────────────────┐
│                    容器编排演进路线                          │
└─────────────────────────────────────────────────────────────┘

Docker（单容器）
    │
    │ 需要管理多个容器
    ▼
Docker Compose（单机多容器）
    │
    │ 需要跨多台服务器部署
    ▼
Docker Swarm / Kubernetes（集群多容器）

8.2 Docker Swarm 是什么

Docker Swarm 是 Docker 官方的集群管理工具，可以将多台服务器组成一个集群，统一管理和调度容器。

核心概念：

概念	说明
Node	集群中的一台服务器
Manager	管理节点，负责调度
Worker	工作节点，运行容器
Service	服务定义（镜像、副本数等）
Task	具体的容器实例

8.3 Docker Swarm vs Kubernetes

Docker Swarm 和 Kubernetes 是竞争关系，都是容器编排工具。

特性	Docker Swarm	Kubernetes
学习曲线	简单	陡峭
功能丰富度	基础	非常丰富
社区生态	较小	非常庞大
适用规模	中小规模	大规模
与 Docker 集成	原生集成	需要额外配置

现状：Kubernetes 已经成为事实上的标准，大多数公司选择 K8s。

8.4 Docker 与 K8s 的关系

很多人搞不清 Docker 和 K8s 的关系，其实很简单：

┌─────────────────────────────────────────────────────────────┐
│                  Docker 与 K8s 的关系                        │
└─────────────────────────────────────────────────────────────┘

Docker 容器 ≈ K8s Pod 中的 Container
Docker Compose ≈ K8s Pod（多个容器组成一个单元）
Docker Swarm ≈ Kubernetes（集群编排）

┌─────────────────────────────────────────────────────────────┐
│                    Kubernetes 集群                          │
├─────────────────────────────────────────────────────────────┤
│  ┌─────────────────────────────────────────────────────┐   │
│  │                      Pod                            │   │
│  │  ┌─────────────┐  ┌─────────────┐                  │   │
│  │  │ Container A │  │ Container B │  ← 这就是 Docker │   │
│  │  │ (应用服务)  │  │ (日志收集)  │    容器          │   │
│  │  └─────────────┘  └─────────────┘                  │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘

一句话总结：Docker 负责打包和运行单个容器，K8s 负责管理和调度大量容器。

---

九、总结

9.1 核心概念速查

概念	说明
镜像（Image）	应用+环境的打包文件，只读
容器（Container）	镜像的运行实例，可读写
Dockerfile	构建镜像的"菜谱"
Registry	镜像仓库，存放和分发镜像
Docker Compose	单机多容器编排工具
Docker Swarm	多机集群编排工具

9.2 Docker 解决的问题

问题	Docker 的解决方案
环境不一致	应用+环境一起打包
依赖冲突	容器隔离，互不影响
部署效率低	一条命令部署
资源利用率低	容器轻量，共享内核

9.3 常用命令速查

# 镜像
docker pull <image>      # 拉取镜像
docker build -t <tag> .  # 构建镜像
docker images            # 查看镜像
docker rmi <image>       # 删除镜像

# 容器
docker run -d <image>    # 运行容器
docker ps                # 查看容器
docker stop <container>  # 停止容器
docker rm <container>    # 删除容器
docker logs <container>  # 查看日志
docker exec -it <container> /bin/bash  # 进入容器

# Compose
docker-compose up -d     # 启动服务
docker-compose down      # 停止服务
docker-compose logs -f   # 查看日志

9.4 下一步学习

掌握了 Docker 之后，建议继续学习：

1. Kubernetes：容器编排的事实标准
2. CI/CD：Jenkins、GitLab CI 与 Docker 集成
3. 容器安全：镜像扫描、运行时安全
4. 服务网格：Istio、Linkerd

---

热门专栏推荐

• 服务器部署
• Agent小册
• Java基础合集
• Python基础合集
• Go基础合集
• 大数据合集
• 前端小册
• 数据库合集
• Redis 合集
• Spring 全家桶
• 微服务全家桶
• 数据结构与算法合集
• 设计模式小册
• 消息队列合集

等等等还有许多优秀的合集在主页等着大家的光顾，感谢大家的支持

文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论😊
希望能和诸佬们一起努力，今后我们一起观看感谢您的阅读🙏
如果帮助到您不妨3连支持一下，创造不易您们的支持是我的动力🌟