简单学docker

基础：Docker 容器使用 | 菜鸟教程

Docker 的核心骨架 ------镜像（Image）是 "模板"，容器（Container）是基于模板跑起来的 "实例"，就像用模具（镜像）做出具体的成品（容器）。

用「通俗语言 + 实操命令」，已有的认知扩展开，从 "只会拉、启动" 到能完整管理容器生命周期，都是最常用的核心操作：

一、先理清核心关系（帮你巩固基础）

概念	通俗理解	关键特点
镜像（Image）	软件安装包 / 模具	只读、可复用、跨平台
容器（Container）	跑起来的软件实例 / 成品	可启动 / 停止 / 删除、独立环境

你知道的 "拉镜像"= 下载模具；"启动容器"= 用模具做出成品并开机；接下来补充 "怎么看、怎么管、怎么删" 等必备操作。

二、Docker 核心操作速查（从基础到常用）

所有命令都在终端执行，先确保 Docker 服务已启动（systemctl start docker，Linux 下）。

1. 基础：拉取镜像

# 格式：docker pull 镜像名:版本号（不加版本号默认拉最新版latest）
docker pull nginx:latest  # 拉取nginx最新镜像（常用示例）
docker pull mysql:8.0     # 拉取mysql 8.0版本（指定版本更稳定）

2. 查看本地镜像（知道自己有哪些 "模具"）

docker images  # 列出所有本地镜像（名称、版本、大小、ID）
# 示例输出：
# REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
# nginx        latest    abc123456789   2 hours ago    187MB

3. 启动容器

知道 "启动容器"，但 Docker 里 docker run 才是「创建 + 启动」的核心命令

（首次运行镜像时，会自动创建容器并启动），这是最常用的操作：

# 最简格式（前台运行，关闭终端容器就停）
docker run nginx  

# 实用格式（后台运行+端口映射，必学！）
docker run -d -p 8080:80 --name my-nginx nginx
# 拆解参数（新手必记）：
# -d：后台运行容器（不会占终端）
# -p 8080:80：端口映射（把主机的8080端口，映射到容器内的80端口，外部能访问）
# --name my-nginx：给容器起个自定义名字（方便管理，否则Docker会随机起名）

比如上面的命令执行后，在浏览器访问 http://主机IP:8080，就能看到 nginx 的默认页面（容器跑起来了）。

4. 查看容器（知道自己跑了哪些 "成品"）

docker ps          # 查看正在运行的容器
docker ps -a       # 查看所有容器（包括已停止的）
# 示例输出：
# CONTAINER ID   NAMES      STATUS         PORTS                  NAMES
# 1234567890ab   my-nginx   Up 5 minutes   0.0.0.0:8080->80/tcp   my-nginx

5. 停止 / 重启容器（管理运行状态）

# 格式：docker stop 容器名/容器ID
docker stop my-nginx  # 停止名为my-nginx的容器
docker stop 1234567890ab  # 也可以用容器ID（输前几位就行）

# 重启容器
docker restart my-nginx

6. 进入容器内部（调试 / 操作容器里的内容）

比如想看看 nginx 容器里的配置文件，需要进入容器终端：

# 格式：docker exec -it 容器名/ID /bin/bash
docker exec -it my-nginx /bin/bash
# 执行后会进入容器内部，命令行提示符变成类似「root@1234567890ab:/#」
# 可以执行ls、cat等命令，比如查看nginx配置：cat /etc/nginx/nginx.conf
# 退出容器：输入exit回车

7. 查看容器日志（排错必备）

比如容器启动失败，看日志找原因：

# 格式：docker logs 容器名/ID
docker logs my-nginx  # 查看my-nginx的运行日志
docker logs -f my-nginx  # 实时跟踪日志（类似tail -f）

8. 删除容器 / 镜像（清理不用的）

# 先停止容器，再删除（运行中的容器删不了）
docker stop my-nginx
docker rm my-nginx  # 删除容器

# 删除镜像（要先删基于这个镜像的所有容器）
docker rmi nginx:latest  # 删除nginx最新版镜像
docker rmi 1234567890ab  # 用镜像ID删除

三、新手实操示例

以最常用的 nginx 为例，从拉取到删除完整操作：

# 1. 拉取nginx镜像
docker pull nginx

# 2. 后台启动容器，映射8080端口，命名my-nginx
docker run -d -p 8080:80 --name my-nginx nginx

# 3. 查看运行状态
docker ps  # 能看到my-nginx状态是Up

# 4. 访问验证（浏览器输http://本机IP:8080）

# 5. 停止容器
docker stop my-nginx

# 6. 删除容器
docker rm my-nginx

# 7. 删除镜像（可选）
docker rmi nginx

新手必知小提醒

1. 容器是 "临时的"：容器里的修改（比如改了 nginx 配置），删除容器后就没了（想保存修改需要做「镜像打包」，新手先不用急）；
2. 端口映射必加：如果启动容器不加 -p，外部（比如本机浏览器）访问不到容器里的服务；
3. 后台运行 -d：不加的话终端会被容器占用，关闭终端容器就停了，日常用都加 -d。

会用" 到 "能用好" 的关键 ------ 解决「数据丢了」「做自己的镜像」「多容器配合」这 3 个核心问题，全是实操导向，跟着敲命令就能会。

核心痛点解决：容器数据持久化（再也不怕删容器丢数据）

之前可能没注意：容器是 "临时的"，比如在 nginx 容器里改了首页内容，一旦删除容器，修改就全没了。

数据持久化就是把容器里的重要数据（配置、文件、数据库数据）绑定到主机上，容器删了数据还在。

1. 两种持久化方式（新手先掌握这 2 种）

方式	通俗理解	适用场景
数据卷（Volume）	Docker 帮你管理的 "专用数据文件夹"	数据库、应用配置（推荐）
主机目录挂载（Bind）	直接绑到主机的任意文件夹	自定义配置、静态文件

2. 实操 1：用「主机挂载」修改 nginx 首页（最直观）

目标：把主机的/tmp/nginx-html文件夹，绑定到 nginx 容器的首页目录，改主机文件 = 改容器首页。

# 1. 主机创建文件夹和首页文件
mkdir -p /tmp/nginx-html  # 创建文件夹
echo "<h1>我的自定义Nginx首页</h1>" > /tmp/nginx-html/index.html  # 写内容

# 2. 启动容器，挂载目录（关键是 -v 参数）
docker run -d -p 8080:80 --name my-nginx -v /tmp/nginx-html:/usr/share/nginx/html nginx
# 拆解 -v 参数：主机目录:容器内目录
# /tmp/nginx-html（主机） ↔ /usr/share/nginx/html（容器nginx首页目录）

# 3. 验证：浏览器访问 http://主机IP:8080，能看到"我的自定义Nginx首页"
# 4. 修改主机文件，容器内容实时变
echo "<h1>修改后的首页</h1>" > /tmp/nginx-html/index.html
# 刷新浏览器，内容直接变，不用重启容器！

# 5. 即使删除容器，/tmp/nginx-html里的文件还在，重建容器挂载后数据恢复
docker stop my-nginx && docker rm my-nginx
# 重新启动容器（挂载同一个目录）
docker run -d -p 8080:80 --name my-nginx -v /tmp/nginx-html:/usr/share/nginx/html nginx
# 访问还是修改后的内容，数据没丢！

3. 实操 2：用「数据卷」保存 MySQL 数据（数据库专用）

数据卷是 Docker 官方推荐的方式，Docker 会把数据存在/var/lib/docker/volumes/（不用记路径，Docker 管理），比手动挂载更安全。

# 1. 创建自定义数据卷（给mysql用）
docker volume create mysql-data

# 2. 启动MySQL容器，挂载数据卷（设置密码为123456）
docker run -d -p 3306:3306 --name my-mysql -v mysql-data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 mysql:8.0
# -v mysql-data:/var/lib/mysql：把数据卷绑到mysql的数据目录
# -e：设置环境变量（mysql必须设root密码）

# 3. 验证：进入mysql创建数据库，删容器后重建，数据还在
docker exec -it my-mysql mysql -uroot -p123456
# 进入mysql后执行：CREATE DATABASE test_db; （创建测试库）
# 退出mysql：exit

# 4. 删除容器
docker stop my-mysql && docker rm my-mysql

# 5. 重新启动mysql，挂载同一个数据卷
docker run -d -p 3306:3306 --name my-mysql -v mysql-data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 mysql:8.0

# 6. 再次进入mysql，能看到test_db还在！
docker exec -it my-mysql mysql -uroot -p123456
show databases;  # 能看到test_db，数据没丢！

进阶核心：自定义镜像（Dockerfile）------ 做自己的镜像

基础镜像（nginx、mysql）是别人做的，实际开发中需要把自己的应用 打包成镜像（比如 Python 脚本、Java 程序），这就要用Dockerfile（文本文件，定义镜像构建规则）。

1. Dockerfile 核心指令（新手先记这 5 个）

指令	作用	示例
FROM	指定基础镜像（必须第一行）	FROM python:3.9-alpine（轻量版）
WORKDIR	设置容器工作目录	WORKDIR /app
COPY	把主机文件复制到镜像里	COPY ./app.py /app/
RUN	构建镜像时执行的命令	RUN pip install flask
CMD/ENTRYPOINT	容器启动时执行的命令	CMD ["python", "/app/app.py"]

2. 实操：打包一个 Python Web 脚本为镜像

步骤：写一个简单的 Python Flask 脚本 → 写 Dockerfile → 构建镜像 → 运行容器。

第一步：准备文件（主机上操作）

# 1. 创建文件夹，进入
mkdir -p /tmp/my-python-app && cd /tmp/my-python-app

# 2. 写Python脚本（app.py）
cat > app.py << EOF
from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello():
    return "Hello Docker! 这是我的自定义镜像"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)
EOF

# 3. 写Dockerfile（文件名必须是Dockerfile，无后缀）
cat > Dockerfile << EOF
# 基础镜像：Python 3.9轻量版
FROM python:3.9-alpine

# 设置工作目录
WORKDIR /app

# 复制主机的app.py到镜像的/app目录
COPY app.py /app/

# 安装flask依赖
RUN pip install flask -i https://pypi.tuna.tsinghua.edu.cn/simple

# 容器启动时执行的命令
CMD ["python", "app.py"]
EOF

第二步：构建自定义镜像

# 格式：docker build -t 镜像名:版本号 构建上下文（. 表示当前目录）
docker build -t my-python-app:v1 .
# 执行后会看到镜像构建过程（Step 1/5 → Step 5/5），最后提示Successfully built xxx

# 查看构建好的镜像
docker images  # 能看到my-python-app:v1

第三步：运行自定义镜像的容器

docker run -d -p 5000:5000 --name my-app my-python-app:v1

# 验证：浏览器访问 http://主机IP:5000，能看到"Hello Docker! 这是我的自定义镜像"

三、效率神器：Docker Compose（管理多容器应用）

实际项目中，一个应用往往需要多个容器配合（比如 Web 容器 + 数据库容器 + 缓存容器），手动一个个启动太麻烦，Docker Compose可以用一个docker-compose.yml文件定义所有容器，一键启动 / 停止。

1. docker-compose.yml 基础结构

核心是services（定义每个容器）、volumes（数据卷）、ports（端口映射）、environment（环境变量）。

2. 实操：用 Compose 启动「Web 容器 + MySQL 容器」

目标：启动一个 Python Web 容器（连 MySQL）+ MySQL 容器，一键管理。

第一步：写 docker-compose.yml（主机 /tmp/my-compose 目录下）

mkdir -p /tmp/my-compose && cd /tmp/my-compose

cat > docker-compose.yml << EOF
version: '3.8'  # Compose版本（选3.8即可）

# 定义所有容器
services:
  # 第一个容器：mysql
  mysql:
    image: mysql:8.0
    ports:
      - "3306:3306"
    environment:
      - MYSQL_ROOT_PASSWORD=123456
      - MYSQL_DATABASE=test_db  # 自动创建test_db数据库
    volumes:
      - mysql-data:/var/lib/mysql  # 数据卷持久化
    restart: always  # 容器挂了自动重启

  # 第二个容器：自定义的Python Web（依赖mysql）
  web:
    build: .  # 从当前目录的Dockerfile构建镜像
    ports:
      - "5000:5000"
    depends_on:
      - mysql  # 先启动mysql，再启动web
    restart: always

# 定义数据卷（和上面mysql的volumes对应）
volumes:
  mysql-data:
EOF

# 同时把之前的app.py和Dockerfile复制到当前目录（Web容器需要）
cp /tmp/my-python-app/app.py ./
cp /tmp/my-python-app/Dockerfile ./

第二步：一键启动所有容器

# 启动（后台运行）：docker-compose up -d
docker-compose up -d

# 查看状态：docker-compose ps
# 能看到mysql和web两个容器都是Up状态

# 停止所有容器：docker-compose down
# 停止并删除数据卷：docker-compose down -v

四、补充：容器网络基础（新手够用版）

Docker 默认会给容器分配网络，同一台主机的容器之间可以通过「容器名 / 容器 IP」通信，不用端口映射。

比如上面 Compose 里的 web 容器，要连接 mysql 容器，不用写127.0.0.1，直接写mysql（容器名）即可，因为 Compose 会自动创建一个网络，把两个容器加入，互相能访问。

示例：修改 app.py 让 Web 连接 MySQL（仅演示，需安装 pymysql）：

# 新增依赖：RUN pip install flask pymysql -i 清华源
import pymysql
# 连接mysql：host写容器名mysql，不是127.0.0.1
conn = pymysql.connect(host='mysql', user='root', password='123456', db='test_db')

1. 先吃透「数据持久化」（Volume / 挂载）：解决数据丢失问题，是生产环境的基础；
2. 掌握「Dockerfile」：能打包自己的应用，从 "用别人的镜像" 到 "做自己的镜像"；
3. 学会「Docker Compose」：管理多容器，提升效率；
4. 后续可拓展：镜像仓库（Harbor/Docker Hub）、Docker Swarm（集群）、镜像优化（减小体积）。

可以挑一个你感兴趣的场景（比如打包 Java 程序、部署 Vue 前端）。

Docker 容器性能优化指南（实操导向）

容器性能优化核心是减少资源浪费、消除性能瓶颈，从「资源限制、镜像瘦身、运行时调优、存储 / 网络优化、监控排查」5 个维度入手，每个点都配实操命令和示例，新手也能落地。

基础优化：限制容器资源（防止抢占主机资源）

Docker 容器默认无资源限制，可能导致单个容器占满主机 CPU / 内存，拖垮所有服务。

核心是通过启动参数限制资源，这是最易落地的优化。

1. CPU 优化

优化手段	命令参数	实操示例（启动 nginx）	说明
限制 CPU 核心数	--cpus=<核心数>	docker run -d --cpus=1.5 --name nginx-cpu nginx	容器最多用 1.5 个 CPU 核心（比如主机 8 核，避免占满）
限制 CPU 优先级	--cpu-shares=<权重>	docker run -d --cpu-shares=512 nginx	权重越高（默认 1024），资源竞争时优先获得 CPU（仅当主机 CPU 满负载时生效）
绑定 CPU 核心	--cpuset-cpus=<核心列表>	docker run -d --cpuset-cpus=0,2 nginx	容器仅使用主机第 0、2 号 CPU 核心（适合对延迟敏感的场景）

2. 内存优化

优化手段	命令参数	实操示例	说明
限制内存上限	--memory=<大小>	docker run -d --memory=512m nginx	容器最多用 512MB 内存，超出则 OOM（内存溢出）
限制交换分区	--memory-swap=<大小>	docker run -d --memory=512m --memory-swap=1g nginx	内存 + 交换分区总计 1GB（设为 - 1 则无限制，不推荐）
预留内存（避免 OOM）	--memory-reservation=<大小>	docker run -d --memory=1g --memory-reservation=512m nginx	容器 "软限制" 512MB，主机资源充足时可用到 1GB，不足时优先回收至 512MB

3. 示例：给 MySQL 容器做资源限制（生产常用）

docker run -d \
  --name mysql-optimize \
  --cpus=2 \          # 限制2核CPU
  --cpuset-cpus=1,3 \ # 绑定1、3号核心
  --memory=2g \       # 限制2GB内存
  --memory-reservation=1g \ # 软限制1GB
  -e MYSQL_ROOT_PASSWORD=123456 \
  mysql:8.0

二、核心优化：镜像瘦身（加快启动 / 拉取，减少磁盘占用）

镜像体积越大，拉取 / 启动越慢，容器运行时也会占用更多磁盘和内存。优化 Dockerfile 是关键，核心思路：用轻量基础镜像、减少构建层、清理无用文件。

1. 优化手段（Dockerfile 示例对比）

反例（臃肿镜像）：

dockerfile

FROM python:3.9  # 完整镜像，体积~900MB
WORKDIR /app
COPY . /app
RUN pip install flask  # 安装依赖，无缓存清理
CMD ["python", "app.py"]

优化后（轻量镜像，体积～50MB）：

dockerfile

# 1. 用轻量基础镜像（alpine版，基于musl libc，体积极小）
FROM python:3.9-alpine  

# 2. 设置国内源，加快依赖安装
RUN sed -i 's/dl-cdn.alpinelinux.org/mirrors.aliyun.com/g' /etc/apk/repositories

# 3. 多阶段构建（仅复制必要文件，删除构建依赖）
WORKDIR /app
COPY requirements.txt .  # 仅复制依赖清单（避免代码变动触发依赖重装）
RUN pip install flask -i https://pypi.tuna.tsinghua.edu.cn/simple \
    && rm -rf /root/.cache/pip  # 清理pip缓存（关键！减少体积）
COPY app.py .

# 4. 非root用户运行（安全+减少资源权限）
RUN adduser -D appuser
USER appuser

CMD ["python", "app.py"]

2. 镜像优化核心原则

原则	作用
优先用alpine/slim基础镜像	比如nginx:alpine（~20MB） vs nginx:latest（~180MB）
合并 RUN 命令（减少镜像层）	用&&串联命令，避免每层都留无用文件
清理缓存 / 无用依赖	rm -rf /var/cache/apk/*（alpine）、rm -rf /root/.cache/pip（pip）
多阶段构建（分离构建 / 运行环境）	比如编译 Java 程序时，用 maven 镜像构建，再复制 jar 包到 jdk-alpine 镜像

3. 工具：查看镜像层 / 体积

docker images --format "{{.Repository}}:{{.Tag}} \t {{.Size}}"  # 看体积
docker history nginx:alpine  # 看镜像每层的大小，定位臃肿层

三、运行时优化：减少容器内资源消耗

1. 禁止不必要的服务 / 进程

• 容器遵循 "单进程原则"：一个容器只跑一个核心进程（比如 nginx 只跑 nginx，不跑 sshd、crond 等），避免后台进程消耗资源。
• 示例：Dockerfile 中避免启动无关服务，比如RUN systemctl start sshd（容器内无 systemd，还会浪费资源）。

2. 优化容器进程（避免 PID 1 问题）

Docker 容器默认以启动命令为 PID 1，但普通程序（如 Python 脚本）不处理信号，会导致容器退出不优雅、僵尸进程堆积。解决 ：用tini作为 PID 1（Docker 1.13 + 已内置，加--init参数即可）：

docker run -d --init --name app-optimize my-python-app:v1  # 自动管理进程，清理僵尸进程

3. 关闭无用日志 / 打印

容器日志刷屏会占用磁盘 IO 和 CPU，非调试场景限制日志大小：

# 启动容器时限制日志大小（json-file驱动）
docker run -d \
  --log-opt max-size=10m \  # 单个日志文件最大10MB
  --log-opt max-file=3 \    # 最多保留3个日志文件
  --name nginx-log nginx

4. 容器复用（减少启动开销）

频繁创建 / 删除容器会消耗主机资源，对临时任务（如 CI/CD），可复用容器而非每次新建：

# 复用容器执行命令，而非新建
docker exec -it my-nginx nginx -s reload  # 重载配置，不用重启容器

四、存储优化：提升 IO 性能

容器默认的存储层是可写层，IO 性能差，且写操作会生成新层，越用越卡。核心优化：减少容器层写入，用高效存储驱动。

1. 用 tmpfs 挂载临时目录（内存级 IO，无磁盘写入）

对临时文件（如缓存、临时日志），挂载到 tmpfs（内存），提升 IO 速度，容器销毁后自动清理：

# 启动nginx，把临时目录挂载到tmpfs
docker run -d \
  --name nginx-tmpfs \
  --tmpfs /var/cache/nginx:size=100m \  # 临时目录挂载到内存，限制100MB
  nginx

2. 选择高效存储驱动

Docker 默认存储驱动优先选overlay2（Linux 4.0 + 支持），性能远优于devicemapper/aufs。检查 / 设置：

# 查看当前存储驱动
docker info | grep "Storage Driver"

# 永久设置overlay2（修改daemon.json，需重启Docker）
cat > /etc/docker/daemon.json << EOF
{
  "storage-driver": "overlay2"
}
EOF
systemctl restart docker

3. 用数据卷（Volume）替代绑定挂载

数据卷由 Docker 管理，IO 性能优于主机目录绑定（Bind Mount），且支持跨主机（集群场景）：

# 优先用--mount（比-v更清晰）
docker run -d \
  --mount type=volume,source=nginx-data,target=/usr/share/nginx/html \
  --name nginx-volume nginx

五、网络优化：降低延迟 / 提升吞吐量

1. 选择合适的网络模式

网络模式	参数	适用场景	性能特点
桥接模式（默认）	无	多容器通信	通用，有轻微网络转发开销
主机网络	--net=host	高并发服务（如 API、数据库）	无网络转发，性能接近物理机（但端口冲突风险高）
容器网络	--net=container:<容器名>	多容器共享网络（如 Sidecar）	无网络隔离，通信延迟最低

示例（高并发 API 用主机网络）：

docker run -d --net=host --name api-optimize my-api-app:v1

2. 关闭 IPv6（减少资源占用）

容器默认开启 IPv6，若不用则关闭，减少网络栈开销：

# 修改daemon.json禁用IPv6
cat >> /etc/docker/daemon.json << EOF
{
  "ipv6": false,
  "fixed-cidr-v6": ""
}
EOF
systemctl restart docker

3. 优化 DNS 解析（减少网络延迟）

容器 DNS 解析慢会导致服务调用超时，手动指定高效 DNS 服务器：

# 启动容器时设置DNS
docker run -d \
  --dns=223.5.5.5 \  # 阿里云DNS
  --dns=8.8.8.8 \    # Google DNS
  --name app-dns my-python-app:v1

六、性能监控与瓶颈排查（找到优化点）

优化前先定位瓶颈（CPU / 内存 / IO / 网络），再针对性优化，避免盲目调参。

1. 基础监控命令

命令	作用	示例
docker stats	实时查看容器 CPU / 内存 / 网络 / IO 使用率	docker stats nginx（监控单个容器）
docker top <容器名>	查看容器内进程（定位耗资源进程）	docker top mysql
docker inspect <容器名>	查看容器详细配置（资源限制、存储、网络）	docker inspect nginx
docker logs --tail=100 <容器名>	查看日志（排查 IO/CPU 高是否因日志刷屏）	docker logs --tail=100 nginx

2. 进阶工具（可视化监控）

• cAdvisor：谷歌开源，轻量容器监控工具，一键启动：

  docker run -d \
    --volume=/:/rootfs:ro \
    --volume=/var/run:/var/run:ro \
    --volume=/sys:/sys:ro \
    --volume=/var/lib/docker/:/var/lib/docker:ro \
    --publish=8080:8080 \
    --name=cadvisor \
    gcr.io/cadvisor/cadvisor:latest

  访问http://主机IP:8080，可查看容器 CPU / 内存 / IO / 网络的详细曲线，定位瓶颈。

• Prometheus + Grafana：适合生产环境，可长期监控、告警（新手先掌握 cAdvisor 即可）。

七、优化优先级（新手落地顺序）

1. 先做「资源限制」：防止容器抢占主机资源，避免服务雪崩（最易操作，效果立竿见影）；
2. 再做「镜像瘦身」：减少拉取 / 启动时间，降低磁盘占用；
3. 然后优化「存储 / 网络」：针对 IO / 网络密集型服务（如数据库、文件服务）；
4. 最后用「监控工具」排查剩余瓶颈，微调参数。

总结

容器性能优化不是 "一刀切"，核心是：

• 对 CPU 密集型服务（如计算、编译）：限制 CPU 核心、绑定核心、优化进程；
• 对内存密集型服务（如数据库、缓存）：限制内存、关闭交换分区；
• 对 IO 密集型服务（如日志、文件服务）：用 tmpfs、overlay2、限制日志大小；
• 对网络密集型服务（如 API、网关）：用主机网络、优化 DNS。