Docker 容器化部署完全指南：從安裝到生產環境最佳實踐

一、概述

1.1 背景介紹

Docker 解決的核心問題就一個："在我機器上能跑，到你那就不行了"。通過將應用及其依賴打包成鏡像，保證開發、測試、生產環境完全一致。容器秒級啟動（實測冷啟動 0.5-2 秒），鏡像分層復用節省存儲和傳輸成本——一個 200MB 的基礎鏡像被 50 個應用共享，每個應用只需額外存儲自己的差異層。

我們團隊從 2019 年開始全面容器化，目前線上跑著 800+ 個容器，覆蓋 Java、Go、Node.js、Python 四種技術棧。這篇文章把從安裝到生產環境踩過的坑全部整理出來。

1.2 技術特點

環境一致性：鏡像即環境，開發用的鏡像和生產用的完全一樣，徹底消除環境差異導致的問題

秒級啟動：容器不需要啟動完整操作系統，直接運行應用進程，啟動速度比虛擬機快 10-100 倍

分層存儲：鏡像由多層只讀層組成，相同的層在多個鏡像間共享，節省磁盤空間和網絡傳輸

資源隔離：基于 Linux cgroup 和 namespace 實現 CPU、內存、網絡、文件系統隔離，互不干擾

聲明式編排：通過 Dockerfile 和 docker-compose.yml 聲明式定義應用環境，版本可控、可復現

1.3 適用場景

應用容器化部署：將傳統應用打包成容器，統一部署和管理方式，降低運維復雜度

微服務架構：每個微服務獨立容器化，獨立部署、獨立擴縮容，服務間通過網絡通信

CI/CD 流水線：構建環境容器化，保證每次構建環境一致；測試環境秒級創建和銷毀

開發測試環境標準化：新人入職docker compose up一條命令拉起整套開發環境，不用花半天裝依賴

1.4 環境要求

組件	版本要求	說明
操作系統	CentOS 7+ / Ubuntu 20.04+	推薦 Ubuntu 22.04 LTS，內核 5.15+ 對 overlay2 和 cgroup v2 支持更好
Linux 內核	4.x+（推薦 5.x+）	內核 5.x 的 overlay2 性能更好，cgroup v2 支持更完善
Docker CE	24.0+（推薦 27.x）	24.0 開始默認使用 BuildKit，27.x 是當前最新穩定版
Docker Compose	V2（docker compose）	V1（docker-compose）已停止維護，V2 作為 Docker CLI 插件集成
硬件配置	2C4G 起步	跑 10 個以內容器 2C4G 夠用，20+ 容器建議 4C8G 起步
存儲	SSD 推薦	overlay2 存儲驅動在 SSD 上性能明顯優于 HDD

二、詳細步驟

2.1 準備工作

2.1.1 系統檢查

# 檢查系統版本
cat /etc/os-release

# 檢查內核版本（建議 5.x+）
uname -r

# 檢查是否支持 overlay2（生產環境必須用 overlay2）
cat /proc/filesystems | grep overlay

# 檢查可用磁盤空間（Docker 鏡像和容器數據會占用大量空間）
df -h

# 檢查是否已安裝舊版本 Docker
docker --version 2>/dev/null &&echo"Docker 已安裝"||echo"Docker 未安裝"

2.1.2 卸載舊版本

舊版本的包名可能是docker、docker.io、docker-engine，必須先卸載干凈：

# Ubuntu/Debian
sudo apt remove -y docker docker-engine docker.io containerd runc 2>/dev/null
sudo apt autoremove -y

# CentOS/Rocky Linux
sudo yum remove -y docker docker-client docker-client-latest 
  docker-common docker-latest docker-latest-logrotate 
  docker-logrotate docker-engine 2>/dev/null

注意：卸載舊版本不會刪除/var/lib/docker/下的鏡像、容器和卷數據。如果要全新安裝，手動刪除：

# 這個操作會刪除所有鏡像和容器數據，執行前確認不需要保留
sudo rm -rf /var/lib/docker
sudo rm -rf /var/lib/containerd

2.2 安裝 Docker CE

2.2.1 Ubuntu/Debian 安裝

# 安裝必要工具
sudo apt update
sudo apt install -y ca-certificates curl gnupg lsb-release

# 添加 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
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# 添加 Docker 官方源
echo
"deb [arch=$(dpkg --print-architecture)signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu 
$(. /etc/os-release && echo "$VERSION_CODENAME")stable"| 
 sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 安裝 Docker CE + CLI + containerd + Compose 插件 + BuildKit
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io 
  docker-buildx-plugin docker-compose-plugin

# 驗證安裝
docker --version
docker compose version

2.2.2 CentOS/Rocky Linux 安裝

# 安裝 yum-utils（提供 yum-config-manager）
sudo yum install -y yum-utils

# 添加 Docker 官方源
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

# 安裝
sudo yum install -y docker-ce docker-ce-cli containerd.io 
  docker-buildx-plugin docker-compose-plugin

# 啟動并設置開機自啟
sudo systemctl start docker
sudo systemctlenabledocker

# 驗證
docker --version
docker compose version

2.2.3 配置非 root 用戶運行 Docker

生產環境不建議用 root 跑 Docker 命令，把用戶加到 docker 組即可：

# 創建 docker 組（安裝時通常已自動創建）
sudo groupadd docker 2>/dev/null

# 將當前用戶加入 docker 組
sudo usermod -aG docker$USER

# 重新登錄使組權限生效（或執行以下命令臨時生效）
newgrp docker

# 驗證非 root 用戶可以運行 docker
docker run hello-world

注意：docker 組的用戶等同于擁有 root 權限（可以掛載宿主機任意目錄），只把可信用戶加入該組。

2.3 daemon.json 生產環境配置

這是我們線上所有 Docker 主機統一使用的 daemon.json，每個參數都有明確的理由：

{
"storage-driver":"overlay2",
"log-driver":"json-file",
"log-opts": {
 "max-size":"100m",
 "max-file":"3"
 },
"registry-mirrors": [
 "https://mirror.ccs.tencentyun.com",
 "https://docker.mirrors.ustc.edu.cn"
 ],
"insecure-registries": [
 "harbor.internal.example.com:5000"
 ],
"live-restore":true,
"default-ulimits": {
 "nofile": {
  "Name":"nofile",
  "Hard":65535,
  "Soft":65535
  }
 },
"bip":"172.17.0.1/16",
"default-address-pools": [
  {
  "base":"172.18.0.0/16",
  "size":24
  }
 ],
"max-concurrent-downloads":10,
"max-concurrent-uploads":5,
"features": {
 "buildkit":true
 }
}

參數說明：

storage-driver: overlay2：生產環境唯一推薦的存儲驅動，性能和穩定性最好。舊版本的 aufs/devicemapper 已廢棄

log-driver: json-file+max-size/max-file：限制每個容器日志最大 100MB，保留 3 個文件。這個必須配，否則日志會撐爆磁盤。線上出過好幾次磁盤 100% 的事故，都是沒限制日志大小導致的

registry-mirrors：鏡像加速器，國內拉 Docker Hub 鏡像很慢，配了加速器后拉取速度從幾十 KB/s 提升到幾 MB/s

insecure-registries：內網 Harbor 私有倉庫如果沒配 HTTPS，必須加到這里，否則 push/pull 會報證書錯誤

live-restore: true：Docker daemon 重啟時不殺容器。升級 Docker 版本或重啟 dockerd 時，正在運行的容器不受影響。生產環境必開

bip：自定義 docker0 網橋的網段。默認 172.17.0.0/16 可能和公司內網沖突，提前規劃好

default-address-pools：自定義容器網絡的地址池，避免docker network create時分配到已被占用的網段

max-concurrent-downloads: 10：并行拉取鏡像層數，默認 3 太少，設為 10 加快拉取速度

# 寫入配置后重啟 Docker
sudo mkdir -p /etc/docker
sudo vim /etc/docker/daemon.json # 寫入上面的配置
sudo systemctl daemon-reload
sudo systemctl restart docker

# 驗證配置生效
docker info | grep -E"Storage Driver|Logging Driver|Registry Mirrors|Live Restore"

2.4 Dockerfile 最佳實踐

2.4.1 多階段構建

多階段構建是減小鏡像體積最有效的手段。編譯階段用完整的 SDK 鏡像，運行階段只用最小的 runtime 鏡像。

Go 應用示例（從 1.2GB 壓縮到 15MB）：

# 文件名：Dockerfile
# 階段一：編譯
FROMgolang:1.22-alpine AS builder

WORKDIR/app

# 先復制 go.mod/go.sum，利用緩存（依賴不變時不重新下載）
COPYgo.mod go.sum ./
RUNgo mod download

# 再復制源碼
COPY. .

# 編譯為靜態二進制（CGO_ENABLED=0 不依賴 C 庫）
RUNCGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w"-o /app/server ./cmd/server

# 階段二：運行
FROMalpine:3.19

# 安裝必要的 CA 證書（HTTPS 請求需要）和時區數據
RUNapk --no-cache add ca-certificates tzdata

# 非 root 用戶運行
RUNaddgroup -S appgroup && adduser -S appuser -G appgroup

WORKDIR/app
COPY--from=builder /app/server .
COPY--from=builder /app/configs ./configs

# 設置時區
ENVTZ=Asia/Shanghai

USERappuser

EXPOSE8080

HEALTHCHECK--interval=30s --timeout=3s --start-period=5s --retries=3 
  CMD wget -qO- http://localhost:8080/health ||exit1

ENTRYPOINT["./server"]

實測結果：

不用多階段構建：golang:1.22 基礎鏡像 1.2GB + 應用 = 約 1.3GB

多階段構建用 alpine：15MB

Java Spring Boot 應用示例：

# 文件名：Dockerfile
# 階段一：構建
FROMmaven:3.9-eclipse-temurin-21AS builder

WORKDIR/app
COPYpom.xml .
# 先下載依賴（利用緩存層）
RUNmvn dependency:go-offline -B

COPYsrc ./src
RUNmvn package -DskipTests -B

# 解壓 Spring Boot fat jar（分層優化）
RUNjava -Djarmode=layertools -jar target/*.jar extract --destination /extracted

# 階段二：運行
FROMeclipse-temurin:21-jre-alpine

RUNaddgroup -S appgroup && adduser -S appuser -G appgroup

WORKDIR/app

# 按變化頻率從低到高復制（充分利用緩存）
COPY--from=builder /extracted/dependencies/ ./
COPY--from=builder /extracted/spring-boot-loader/ ./
COPY--from=builder /extracted/snapshot-dependencies/ ./
COPY--from=builder /extracted/application/ ./

ENVTZ=Asia/Shanghai
ENVJAVA_OPTS="-Xms512m -Xmx512m -XX:+UseG1GC"

USERappuser

EXPOSE8080

HEALTHCHECK--interval=30s --timeout=5s --start-period=30s --retries=3 
  CMD wget -qO- http://localhost:8080/actuator/health ||exit1

ENTRYPOINT["sh","-c","java$JAVA_OPTSorg.springframework.boot.loader.launch.JarLauncher"]

實測結果：

不用多階段構建：maven 基礎鏡像 800MB + 應用 = 約 900MB

多階段構建用 JRE alpine：約 180MB

2.4.2 .dockerignore 文件

構建上下文會把當前目錄所有文件發送給 Docker daemon，不配 .dockerignore 會把 node_modules、.git 等無關文件也發過去，構建慢且鏡像臃腫。

# 文件名：.dockerignore
.git
.gitignore
.dockerignore
Dockerfile
docker-compose*.yml
README.md
LICENSE
docs/

# Node.js
node_modules
npm-debug.log

# Go
vendor/

# Java
target/
*.jar
*.class

# Python
__pycache__
*.pyc
.venv
venv

# IDE
.idea
.vscode
*.swp
*.swo

# 環境變量文件（絕對不能打進鏡像）
.env
.env.*

這個文件必須有，特別是.env文件絕對不能打進鏡像，里面有數據庫密碼等敏感信息。

2.4.3 Dockerfile 編寫要點

COPY vs ADD：優先用 COPY，語義明確。ADD 會自動解壓 tar 包和支持 URL 下載，容易產生意外行為

RUN 合并減少層數：每條 RUN 指令生成一層，合并可以減小鏡像體積

# 錯誤寫法：3 層，且第一層的 apt cache 無法被清理掉
RUNapt update
RUNapt install -y curl wget
RUNrm -rf /var/lib/apt/lists/*

# 正確寫法：1 層，安裝完立即清理緩存
RUNapt update && apt install -y --no-install-recommends curl wget 
  && rm -rf /var/lib/apt/lists/*

非 root USER：容器默認以 root 運行，安全風險大。生產環境必須創建專用用戶

HEALTHCHECK：定義健康檢查，Docker 和編排工具（Compose/Swarm/K8s）據此判斷容器是否正常

ARG vs ENV：ARG 只在構建階段可用（如版本號），ENV 在運行時也可用（如配置參數）

2.5 Docker Compose 編排

2.5.1 完整的多服務編排示例

以下是一個典型的 Web 應用編排：Nginx 反向代理 + Node.js API + MySQL + Redis，包含健康檢查、啟動順序控制、資源限制。

# 文件名：docker-compose.yml

services:
# Nginx 反向代理
nginx:
 image:nginx:1.24-alpine
 container_name:app-nginx
 ports:
  -"80:80"
  -"443:443"
 volumes:
  -./nginx/conf.d:/etc/nginx/conf.d:ro
  -./nginx/ssl:/etc/nginx/ssl:ro
  -./frontend/dist:/var/www/html:ro
  -nginx-logs:/var/log/nginx
 depends_on:
  api:
   condition:service_healthy
 restart:unless-stopped
 deploy:
  resources:
   limits:
    cpus:'1.0'
    memory:256M
 networks:
  -frontend

# Node.js API 服務
api:
 build:
  context:./api
  dockerfile:Dockerfile
 container_name:app-api
 env_file:
  -.env
 environment:
  -NODE_ENV=production
  -DB_HOST=mysql
  -DB_PORT=3306
  -REDIS_HOST=redis
  -REDIS_PORT=6379
 depends_on:
  mysql:
   condition:service_healthy
  redis:
   condition:service_healthy
 healthcheck:
  test:["CMD","wget","-qO-","http://localhost:3000/health"]
  interval:15s
  timeout:5s
  retries:3
  start_period:10s
 restart:unless-stopped
 deploy:
  resources:
   limits:
    cpus:'2.0'
    memory:1G
   reservations:
    cpus:'0.5'
    memory:256M
 networks:
  -frontend
  -backend

# MySQL 數據庫
mysql:
 image:mysql:8.0
 container_name:app-mysql
 environment:
  MYSQL_ROOT_PASSWORD:${MYSQL_ROOT_PASSWORD}
  MYSQL_DATABASE:${MYSQL_DATABASE}
  MYSQL_USER:${MYSQL_USER}
  MYSQL_PASSWORD:${MYSQL_PASSWORD}
 volumes:
  -mysql-data:/var/lib/mysql
  -./mysql/conf.d:/etc/mysql/conf.d:ro
  -./mysql/init:/docker-entrypoint-initdb.d:ro
 healthcheck:
  test:["CMD","mysqladmin","ping","-h","localhost","-u","root","-p${MYSQL_ROOT_PASSWORD}"]
  interval:10s
  timeout:5s
  retries:5
  start_period:30s
 restart:unless-stopped
 deploy:
  resources:
   limits:
    cpus:'2.0'
    memory:2G
 command:>
   --character-set-server=utf8mb4
   --collation-server=utf8mb4_unicode_ci
   --max-connections=500
   --innodb-buffer-pool-size=1G
 networks:
  -backend

# Redis 緩存
redis:
 image:redis:7-alpine
 container_name:app-redis
 command:>
   redis-server
   --requirepass ${REDIS_PASSWORD}
   --maxmemory 512mb
   --maxmemory-policy allkeys-lru
   --appendonly yes
 volumes:
  -redis-data:/data
 healthcheck:
  test:["CMD","redis-cli","-a","${REDIS_PASSWORD}","ping"]
  interval:10s
  timeout:3s
  retries:3
 restart:unless-stopped
 deploy:
  resources:
   limits:
    cpus:'1.0'
    memory:768M
 networks:
  -backend

networks:
frontend:
 driver:bridge
backend:
 driver:bridge
 internal:true # 后端網絡不暴露到外部

volumes:
mysql-data:
redis-data:
nginx-logs:

配套 .env 文件：

# 文件名：.env（不要提交到 Git）
MYSQL_ROOT_PASSWORD=your_root_password_here
MYSQL_DATABASE=app_production
MYSQL_USER=app_user
MYSQL_PASSWORD=your_app_password_here
REDIS_PASSWORD=your_redis_password_here

常用操作命令：

# 啟動所有服務（后臺運行）
docker compose up -d

# 查看服務狀態
docker compose ps

# 查看某個服務的日志
docker compose logs -f api

# 重新構建并啟動
docker compose up -d --build

# 停止所有服務（保留數據卷）
docker compose down

# 停止并刪除數據卷（慎用，會丟數據）
docker compose down -v

2.6 網絡模式

2.6.1 網絡模式對比

模式	說明	適用場景
bridge	默認模式，容器通過虛擬網橋通信	大部分場景
host	容器直接使用宿主機網絡棧	對網絡性能要求極高的場景（如監控采集）
none	無網絡，完全隔離	安全敏感的離線計算任務
overlay	跨主機容器通信（Swarm 模式）	Docker Swarm 集群
macvlan	容器擁有獨立 MAC 地址，直接接入物理網絡	需要容器有獨立 IP 的傳統網絡環境

2.6.2 自定義網絡

生產環境不要用默認的 bridge 網絡，自定義網絡有 DNS 解析功能（容器間可以用容器名互相訪問）：

# 創建自定義網絡（指定網段，避免和內網沖突）
docker network create 
  --driver bridge 
  --subnet 172.20.0.0/24 
  --gateway 172.20.0.1 
  app-network

# 查看網絡詳情
docker network inspect app-network

# 將已運行的容器接入網絡
docker network connect app-network my-container

# 斷開網絡
docker network disconnect app-network my-container

注意：默認 bridge 網絡（docker0）不支持容器名 DNS 解析，只有自定義網絡才支持。這是很多人踩的坑——在默認網絡里用容器名訪問另一個容器，永遠連不上。

2.7 存儲卷

2.7.1 三種掛載方式對比

類型	命令示例	數據位置	適用場景
Named Volume	-v mydata:/data	Docker 管理（/var/lib/docker/volumes/）	數據庫、持久化數據
Bind Mount	-v /host/path:/container/path	宿主機指定目錄	配置文件、代碼熱更新
tmpfs	--tmpfs /tmp	內存	臨時文件、敏感數據（不落盤）

2.7.2 Named Volume 數據持久化

# 創建命名卷
docker volume create mysql-data

# 查看卷詳情
docker volume inspect mysql-data

# 使用命名卷啟動 MySQL
docker run -d 
  --name mysql 
  -v mysql-data:/var/lib/mysql 
  -e MYSQL_ROOT_PASSWORD=secret 
  mysql:8.0

# 備份卷數據
docker run --rm 
  -v mysql-data:/source:ro 
  -v $(pwd):/backup 
  alpine tar czf /backup/mysql-data-backup.tar.gz -C /source.

# 恢復卷數據
docker run --rm 
  -v mysql-data:/target 
  -v $(pwd):/backup 
  alpine tar xzf /backup/mysql-data-backup.tar.gz -C /target

注意：docker compose down -v會刪除所有命名卷，數據庫數據會丟失。生產環境執行前務必確認，或者養成習慣只用docker compose down（不加 -v）。

三、示例代碼和配置

3.1 完整配置示例

3.1.1 daemon.json 生產環境完整配置（帶注釋版）

// 文件路徑：/etc/docker/daemon.json
// 注意：實際 JSON 文件不支持注釋，這里僅作說明
{
 // 存儲驅動，生產環境只用 overlay2
 "storage-driver": "overlay2",

 // 日志驅動和限制（防止日志撐爆磁盤）
 "log-driver": "json-file",
 "log-opts": {
  "max-size": "100m",
  "max-file": "3"
 },

 // 鏡像加速器（按需配置）
 "registry-mirrors": [
  "https://mirror.ccs.tencentyun.com"
 ],

 // 內網私有倉庫（HTTP 協議）
 "insecure-registries": [
  "harbor.internal.example.com:5000"
 ],

 // Docker daemon 重啟時保持容器運行
 "live-restore": true,

 // 容器默認 ulimit
 "default-ulimits": {
  "nofile": { "Name": "nofile", "Hard": 65535, "Soft": 65535 },
  "nproc": { "Name": "nproc", "Hard": 65535, "Soft": 65535 }
 },

 // 自定義 docker0 網橋網段
 "bip": "172.17.0.1/16",

 // 自定義容器網絡地址池
 "default-address-pools": [
  { "base": "172.18.0.0/16", "size": 24 }
 ],

 // 并行下載/上傳層數
 "max-concurrent-downloads": 10,
 "max-concurrent-uploads": 5,

 // 啟用 BuildKit（構建速度更快，支持緩存掛載）
 "features": { "buildkit": true },

 // 數據根目錄（默認 /var/lib/docker，磁盤不夠時可改到大盤）
 "data-root": "/var/lib/docker",

 // DNS 配置（容器內 DNS 解析）
 "dns": ["8.8.8.8", "114.114.114.114"]
}

3.1.2 Makefile 封裝常用 Docker 操作

團隊協作時，用 Makefile 封裝常用命令，新人不用記一堆 docker 參數：

# 文件名：Makefile

APP_NAME := myapp
VERSION :=$(shellgit describe --tags --always --dirty 2>/dev/null || echo "dev")
REGISTRY := harbor.internal.example.com:5000
IMAGE  :=$(REGISTRY)/$(APP_NAME):$(VERSION)

.PHONY: build push run stop logs clean

# 構建鏡像
build:
docker build -t$(IMAGE)-t$(REGISTRY)/$(APP_NAME):latest .

# 推送到私有倉庫
push: build
docker push$(IMAGE)
docker push$(REGISTRY)/$(APP_NAME):latest

# 本地運行
run:
docker compose up -d

# 停止服務
stop:
docker compose down

# 查看日志
logs:
docker compose logs -f --tail=100

# 清理懸空鏡像和停止的容器
clean:
docker system prune -f
docker image prune -f

# 進入容器 shell
shell:
docker compose exec api sh

# 數據庫備份
db-backup:
docker compose exec mysql mysqldump -u root -p$(MYSQL_ROOT_PASSWORD)$(MYSQL_DATABASE)> backup_$(shelldate +%Y%m%d_%H%M%S).sql

# 查看資源使用
stats:
docker stats --no-stream

3.2 實際應用案例

案例一：Node.js 應用容器化部署

場景描述：將一個 Express.js API 服務容器化，配合 PM2 進程管理，實現生產級部署。

Dockerfile：

FROMnode:20-alpine AS builder

WORKDIR/app
COPYpackage*.json ./
RUNnpm ci --only=production && npm cache clean --force

FROMnode:20-alpine

RUNapk --no-cache add tini
RUNaddgroup -S appgroup && adduser -S appuser -G appgroup

WORKDIR/app
COPY--from=builder /app/node_modules ./node_modules
COPY. .

ENVNODE_ENV=production
USERappuser
EXPOSE3000

HEALTHCHECK--interval=30s --timeout=3s --retries=3 
  CMD wget -qO- http://localhost:3000/health ||exit1

# 用 tini 作為 PID 1（正確處理信號，避免僵尸進程）
ENTRYPOINT["/sbin/tini","--"]
CMD["node","src/index.js"]

運行結果：

$ docker build -t myapi:1.0 .
$ docker images myapi
REPOSITORY  TAG  IMAGE ID    SIZE
myapi    1.0  a1b2c3d4e5f6  95MB

# 對比不用多階段構建：約 350MB

案例二：零停機滾動更新

場景描述：生產環境更新應用版本，不中斷服務。通過 docker compose 配合 Nginx upstream 實現。

實現步驟：

構建新版本鏡像并推送到倉庫

拉取新鏡像，啟動新容器

健康檢查通過后，切換 Nginx 流量到新容器

停止舊容器

#!/bin/bash
# 文件名：rolling-update.sh
# 零停機滾動更新腳本

set-e

APP_NAME="app-api"
NEW_IMAGE="$1"

if[ -z"$NEW_IMAGE"];then
 echo"用法:$0"
 exit1
fi

echo"[1/5] 拉取新鏡像:$NEW_IMAGE"
docker pull"$NEW_IMAGE"

echo"[2/5] 啟動新容器"
docker compose up -d --no-deps --scale api=2 api

echo"[3/5] 等待新容器健康檢查通過..."
sleep 10
NEW_CONTAINER=$(docker compose ps -q api | tail -1)
foriin$(seq 1 30);do
  STATUS=$(docker inspect --format='{{.State.Health.Status}}'"$NEW_CONTAINER"2>/dev/null)
 if["$STATUS"="healthy"];then
   echo"新容器健康檢查通過"
   break
 fi
 echo"等待中... ($i/30)"
  sleep 2
done

echo"[4/5] 縮容，移除舊容器"
docker compose up -d --no-deps --scale api=1 api

echo"[5/5] 清理舊鏡像"
docker image prune -f

echo"更新完成!"

四、最佳實踐和注意事項

4.1 最佳實踐

4.1.1 鏡像瘦身

選擇合適的基礎鏡像：

基礎鏡像	大小	適用場景
ubuntu:22.04	77MB	需要完整包管理器的場景
debian:bookworm-slim	74MB	需要 glibc 但不需要完整 Debian
alpine:3.19	7MB	Go/Rust 等靜態編譯語言，體積最小
distroless	2-20MB	安全要求最高的場景，無 shell 無包管理器
scratch	0MB	純靜態二進制，如 Go 應用

我們團隊的做法：Go 應用用 alpine，Java 應用用 eclipse-temurin JRE alpine，Node.js 用 node alpine。

用 dive 分析鏡像層：

# 安裝 dive
wget https://github.com/wagoodman/dive/releases/download/v0.12.0/dive_0.12.0_linux_amd64.tar.gz
tar -zxvf dive_0.12.0_linux_amd64.tar.gz
sudo mv dive /usr/local/bin/

# 分析鏡像每一層的內容和大小
dive myapp:latest

dive 會顯示每一層新增了哪些文件、占了多少空間，能快速定位鏡像臃腫的原因。實測用 dive 分析后，我們把一個 Java 鏡像從 600MB 優化到 180MB。

4.1.2 安全加固

非 root 運行：容器默認以 root 運行，一旦容器逃逸攻擊者就是宿主機 root。Dockerfile 中必須創建專用用戶：

RUNaddgroup -S appgroup && adduser -S appuser -G appgroup
USERappuser

只讀文件系統：容器運行時文件系統設為只讀，防止惡意寫入：

docker run --read-only --tmpfs /tmp --tmpfs /var/run myapp:latest

需要寫入的目錄用 tmpfs 或 volume 掛載。

Drop 不需要的 Linux Capabilities：

# 移除所有 capabilities，只保留需要的
docker run --cap-drop ALL --cap-add NET_BIND_SERVICE myapp:latest

默認容器有 14 個 capabilities，大部分應用只需要 1-2 個。全部 drop 再按需 add 是最安全的做法。

鏡像安全掃描：

# 用 Trivy 掃描鏡像漏洞（推薦，速度快、數據庫全）
trivy image myapp:latest

# 只顯示高危和嚴重漏洞
trivy image --severity HIGH,CRITICAL myapp:latest

# 集成到 CI/CD：發現高危漏洞時構建失敗
trivy image --exit-code 1 --severity HIGH,CRITICAL myapp:latest

我們團隊在 CI 流水線中強制掃描，HIGH 以上漏洞必須修復才能上線。

4.1.3 日志管理

json-file 驅動限制大小（daemon.json 中已配置）：

{
"log-driver":"json-file",
"log-opts": {
 "max-size":"100m",
 "max-file":"3"
 }
}

每個容器最多 3 個日志文件，每個 100MB，總共 300MB 上限。不配這個，跑幾天日志就能把磁盤撐爆。

單個容器覆蓋全局日志配置：

# docker-compose.yml 中
services:
api:
 logging:
  driver:json-file
  options:
   max-size:"200m"
   max-file:"5"

集中日志收集方案：

# 用 fluentd 驅動將日志發送到集中式日志平臺
services:
api:
 logging:
  driver:fluentd
  options:
   fluentd-address:"10.0.0.50:24224"
   tag:"docker.{{.Name}}"
   fluentd-async:"true"

4.1.4 資源限制

容器不限制資源的話，一個容器內存泄漏就能把整臺宿主機拖垮。生產環境必須設資源限制。

# 命令行方式限制資源
docker run -d 
  --name myapp 
  --memory 1g 
  --memory-swap 1g 
  --cpus 2.0 
  --pids-limit 200 
  --oom-score-adj 500 
  myapp:latest

參數說明：

--memory 1g：內存上限 1GB，超過會觸發 OOM Killer

--memory-swap 1g：設為和 memory 相同值表示禁用 swap（生產環境建議禁用，swap 會導致性能急劇下降）

--cpus 2.0：最多使用 2 個 CPU 核心

--pids-limit 200：限制容器內最大進程數，防止 fork 炸彈

--oom-score-adj 500：OOM 優先級，值越大越容易被 kill（保護宿主機上更重要的進程）

4.1.5 CI/CD 集成

BuildKit 緩存加速構建：

# 啟用 BuildKit（daemon.json 中已配置，也可以通過環境變量臨時啟用）
exportDOCKER_BUILDKIT=1

# 使用緩存掛載加速依賴下載（Go 示例）
# Dockerfile 中：
# RUN --mount=type=cache,target=/go/pkg/mod go mod download
# RUN --mount=type=cache,target=/root/.cache/go-build go build -o /app/server

# 使用內聯緩存（CI/CD 跨構建復用緩存）
docker build 
  --build-arg BUILDKIT_INLINE_CACHE=1 
  --cache-from harbor.example.com/myapp:latest 
  -t harbor.example.com/myapp:v1.2.3 
  .

多平臺構建（buildx）：

# 創建多平臺構建器
docker buildx create --name multiarch --use

# 同時構建 amd64 和 arm64 鏡像并推送
docker buildx build 
  --platform linux/amd64,linux/arm64 
  -t harbor.example.com/myapp:v1.2.3 
  --push 
  .

ARM 服務器（如 AWS Graviton）越來越多，提前做好多平臺支持能省不少麻煩。

Harbor 私有倉庫：

# 登錄私有倉庫
docker login harbor.internal.example.com:5000

# 打標簽并推送
docker tag myapp:v1.2.3 harbor.internal.example.com:5000/project/myapp:v1.2.3
docker push harbor.internal.example.com:5000/project/myapp:v1.2.3

4.2 注意事項

4.2.1 配置注意事項

daemon.json 改錯了會導致 Docker 無法啟動，改之前先備份。

修改 daemon.json 后必須systemctl daemon-reload && systemctl restart docker

live-restore: true時重啟 dockerd 不會殺容器，但升級大版本（如 24.x 到 27.x）時可能不兼容，建議先在測試環境驗證

bip網段規劃要提前和網絡團隊確認，避免和公司內網、VPN 網段沖突。我們踩過的坑：默認 172.17.0.0/16 和辦公網 VPN 沖突，導致開發機連不上容器

4.2.2 常見錯誤

錯誤現象	原因分析	解決方案
Cannot connect to the Docker daemon	dockerd 未啟動或權限不足	systemctl start docker 或將用戶加入 docker 組
no space left on device	磁盤被鏡像/容器/日志占滿	docker system prune -a 清理；配置日志大小限制
OCI runtime create failed	內核版本太低或 seccomp 配置問題	升級內核到 5.x+；檢查 seccomp profile
port is already allocated	端口被其他進程占用	ss -tlnp | grep 找到占用進程并處理
network has active endpoints	刪除網絡時還有容器在用	先停止并刪除使用該網絡的容器
image pull timeout	DNS 解析失敗或網絡不通	檢查 DNS 配置；配置鏡像加速器

4.2.3 兼容性問題

cgroup v1 vs v2：Ubuntu 22.04 默認用 cgroup v2，部分老版本應用（如 Java 8u191 以下）不識別 cgroup v2 的內存限制，會導致 JVM 看到的是宿主機全部內存而非容器限制。解決辦法：升級 JDK 版本或在 GRUB 中加systemd.unified_cgroup_hierarchy=0回退到 v1

Alpine 與 glibc：Alpine 用 musl libc 而非 glibc，部分依賴 glibc 的應用（如某些 Python C 擴展、Oracle JDK）在 Alpine 上會報錯。解決辦法：換用 debian-slim 基礎鏡像，或安裝 gcompat 兼容層

Docker Compose V1 vs V2：V1（docker-compose，Python 實現）已停止維護，V2（docker compose，Go 實現）是 Docker CLI 插件。兩者配置文件基本兼容，但部分邊緣行為有差異。新項目直接用 V2

五、故障排查和監控

5.1 故障排查

5.1.1 日志查看

# 查看容器日志（最近 100 行，實時跟蹤）
docker logs --tail 100 -f 

# 查看指定時間段的日志
docker logs --since"2026-02-07T0000"--until"2026-02-07T1200"

# 查看 Docker daemon 日志
sudo journalctl -u docker -f

# 查看容器內進程
docker top 

# 查看容器詳細信息（啟動參數、網絡、掛載等）
docker inspect 

# 查看容器事件流（啟動、停止、OOM 等事件）
docker events --since"1h"

5.1.2 常見問題排查

問題一：容器啟動后立即退出

# 查看退出碼
docker inspect --format='{{.State.ExitCode}}'

# 常見退出碼含義：
# 0  - 正常退出（CMD/ENTRYPOINT 執行完畢）
# 1  - 應用錯誤
# 137 - 被 SIGKILL 殺死（通常是 OOM）
# 139 - 段錯誤（Segmentation Fault）
# 143 - 被 SIGTERM 正常終止

# 查看最后的日志
docker logs --tail 50 

解決方案：

退出碼 0：CMD 命令執行完就退出了，需要一個前臺進程保持運行。常見錯誤是用了CMD service nginx start（后臺啟動后進程退出），應該用CMD ["nginx", "-g", "daemon off;"]

退出碼 137：容器被 OOM Killer 殺了，增大內存限制或優化應用內存使用

退出碼 1：應用報錯，看日志找具體原因

問題二：容器網絡不通

# 檢查容器網絡配置
docker inspect --format='{{json .NetworkSettings.Networks}}' | jq

# 進入容器排查
dockerexec-it  sh

# 容器內檢查 DNS
cat /etc/resolv.conf
nslookup mysql

# 容器內檢查連通性
ping 
wget -qO- http://:/health

# 宿主機檢查 iptables 規則（Docker 通過 iptables 實現端口映射和網絡隔離）
sudo iptables -t nat -L -n | grep 
sudo iptables -L DOCKER -n

解決方案：

容器間互通但用容器名訪問不了：檢查是否在同一個自定義網絡中，默認 bridge 網絡不支持 DNS

容器訪問外網不通：檢查宿主機的 IP 轉發sysctl net.ipv4.ip_forward，值必須為 1

端口映射不生效：檢查宿主機防火墻規則，Docker 的 iptables 規則可能被其他防火墻工具覆蓋

問題三：存儲空間耗盡

# 查看 Docker 磁盤使用情況
docker system df

# 詳細查看每個鏡像/容器/卷的占用
docker system df -v

# 查看 overlay2 存儲占用
du -sh /var/lib/docker/overlay2/* | sort -rh | head -20

解決方案：

# 清理已停止的容器、未使用的網絡、懸空鏡像和構建緩存
docker system prune -f

# 更激進的清理：同時刪除未被任何容器使用的鏡像
docker system prune -a -f

# 只清理超過 24 小時的資源
docker system prune -a -f --filter"until=24h"

# 清理未使用的卷（數據庫卷要小心）
docker volume prune -f

預防措施：定期清理 + 日志大小限制 + 監控磁盤使用率告警

問題四：容器內存 OOM

# 查看容器資源使用情況
docker stats --no-stream 

# 查看容器內存限制
docker inspect --format='{{.HostConfig.Memory}}'

# 查看是否發生過 OOM
docker inspect --format='{{.State.OOMKilled}}'

# 查看系統 OOM 日志
dmesg | grep -i"oom|killed"

解決方案：

確認內存限制是否合理：docker stats觀察實際內存使用峰值，限制值設為峰值的 1.5 倍

Java 應用特別注意：JVM 堆內存（-Xmx）+ 非堆內存（Metaspace、線程棧、NIO Buffer）總和不能超過容器內存限制。經驗公式：容器內存 = Xmx * 1.5

禁用 swap：--memory-swap設為和--memory相同值

5.2 性能監控

5.2.1 docker stats 實時監控

# 查看所有容器資源使用（實時刷新）
docker stats

# 查看指定容器（不刷新，輸出一次）
docker stats --no-stream app-api app-mysql app-redis

# 輸出示例：
# CONTAINER ID  NAME    CPU %  MEM USAGE / LIMIT  MEM %  NET I/O     BLOCK I/O    PIDS
# a1b2c3d4e5f6  app-api   2.35%  256MiB / 1GiB    25.00% 1.2GB / 800MB  50MB / 10MB   35
# b2c3d4e5f6a1  app-mysql  5.12%  1.1GiB / 2GiB    55.00% 500MB / 1.5GB  2GB / 500MB   42
# c3d4e5f6a1b2  app-redis  0.50%  50MiB / 768MiB   6.51%  200MB / 300MB  1MB / 5MB    5

5.2.2 cAdvisor + Prometheus + Grafana 監控方案

生產環境推薦用 cAdvisor 采集容器指標，Prometheus 存儲，Grafana 展示。

# 文件名：docker-compose.monitoring.yml

services:
cadvisor:
 image:gcr.io/cadvisor/cadvisor:v0.49.1
 container_name:cadvisor
 ports:
  -"8080:8080"
 volumes:
  -/:/rootfs:ro
  -/var/run:/var/run:ro
  -/sys:/sys:ro
  -/var/lib/docker/:/var/lib/docker:ro
  -/dev/disk/:/dev/disk:ro
 privileged:true
 restart:unless-stopped

prometheus:
 image:prom/prometheus:v2.51.0
 container_name:prometheus
 ports:
  -"9090:9090"
 volumes:
  -./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
  -prometheus-data:/prometheus
 command:
  -'--config.file=/etc/prometheus/prometheus.yml'
  -'--storage.tsdb.retention.time=30d'
 restart:unless-stopped

grafana:
 image:grafana/grafana:10.4.0
 container_name:grafana
 ports:
  -"3000:3000"
 volumes:
  -grafana-data:/var/lib/grafana
 environment:
  -GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD:-admin}
 restart:unless-stopped

volumes:
prometheus-data:
grafana-data:

Prometheus 采集配置：

# 文件路徑：prometheus/prometheus.yml
global:
scrape_interval:15s

scrape_configs:
-job_name:'cadvisor'
 static_configs:
  -targets:['cadvisor:8080']

5.2.3 監控指標說明

指標名稱	正常范圍	告警閾值	說明
容器 CPU 使用率	< 70% of limit	> 85%	持續高于 85% 需要擴容或優化
容器內存使用率	< 80% of limit	> 90%	接近限制值會觸發 OOM
容器重啟次數	0	> 3 次/小時	頻繁重啟說明應用有問題
磁盤使用率	< 70%	> 85%	Docker 數據目錄磁盤使用率
容器網絡錯誤	0	> 0	網絡丟包或錯誤需要排查

5.3 備份與恢復

5.3.1 備份策略

#!/bin/bash
# 文件名：docker-backup.sh
# Docker 數據備份腳本

BACKUP_DIR="/data/backups/docker"
DATE=$(date +%Y%m%d_%H%M%S)
RETENTION_DAYS=7

mkdir -p"$BACKUP_DIR"

echo"=== Docker 數據備份開始:$DATE==="

# 備份所有命名卷
forvolin$(docker volume ls -q);do
 echo"備份卷:$vol"
  docker run --rm 
    -v"$vol":/source:ro 
    -v"$BACKUP_DIR":/backup 
    alpine tar czf"/backup/${vol}_${DATE}.tar.gz"-C /source.
done

# 備份 docker-compose 配置
echo"備份 Compose 配置..."
tar czf"$BACKUP_DIR/compose_configs_${DATE}.tar.gz"
  /opt/apps/*/docker-compose.yml 
  /opt/apps/*/.env 2>/dev/null

# 清理過期備份
find"$BACKUP_DIR"-name"*.tar.gz"-mtime +$RETENTION_DAYS-delete

echo"=== 備份完成 ==="

5.3.2 恢復流程

停止服務：docker compose down

恢復卷數據：

docker run --rm 
  -v mysql-data:/target 
  -v /data/backups/docker:/backup 
  alpine tar xzf /backup/mysql-data_20260207_030000.tar.gz -C /target

驗證完整性：docker compose up -d && docker compose ps

檢查數據：連接數據庫確認數據完整

六、總結

6.1 技術要點回顧

安裝與配置：daemon.json 是 Docker 生產環境的核心配置，日志大小限制、live-restore、網段規劃這三項必須配置，否則遲早出事故

Dockerfile 編寫：多階段構建是鏡像瘦身的關鍵手段，Go 應用從 1.3GB 壓縮到 15MB，Java 應用從 900MB 壓縮到 180MB。.dockerignore 必須有，防止敏感文件打進鏡像

Compose 編排：healthcheck + depends_on condition 控制啟動順序，deploy.resources 限制資源，networks 隔離前后端流量

安全加固：非 root 運行、只讀文件系統、drop capabilities、Trivy 鏡像掃描，四道防線缺一不可

監控與運維：docker stats 日常巡檢，cAdvisor + Prometheus + Grafana 長期監控，定期 docker system prune 清理空間

6.2 進階學習方向

Kubernetes 容器編排：Docker 解決了單機容器化問題，K8s 解決多機編排問題。掌握 Docker 后學 K8s 是自然的進階路徑

學習資源：Kubernetes 官方文檔

實踐建議：先用 kind 或 minikube 搭建本地集群練手，再上生產

鏡像構建優化：深入 BuildKit 緩存機制、多平臺構建、鏡像簽名和供應鏈安全

學習資源：BuildKit 官方文檔

實踐建議：在 CI/CD 中實踐 BuildKit 緩存掛載，構建速度能提升 50% 以上

容器運行時：了解 containerd、CRI-O 等底層運行時，理解 Docker 只是容器生態的上層工具

6.3 參考資料

Docker 官方文檔- 最權威的 Docker 使用參考

Dockerfile 最佳實踐- 官方推薦的 Dockerfile 編寫規范

Docker Compose 規范- Compose 文件格式完整參考

Docker 安全基準- CIS Docker Benchmark，安全加固檢查清單

Awesome Docker- Docker 生態工具和資源匯總

附錄

A. Docker 命令速查表

# 鏡像操作
docker images               # 列出本地鏡像
docker pull :         # 拉取鏡像
docker build -t : .      # 構建鏡像
docker push :         # 推送鏡像
docker rmi             # 刪除鏡像
docker image prune -f           # 清理懸空鏡像
docker save -o backup.tar      # 導出鏡像為 tar
docker load -i backup.tar         # 從 tar 導入鏡像
docker tag         # 給鏡像打標簽
dockerhistory          # 查看鏡像構建歷史

# 容器操作
docker run -d --name      # 后臺運行容器
docker ps                 # 查看運行中的容器
docker ps -a               # 查看所有容器（含已停止）
docker stop           # 停止容器
docker start          # 啟動已停止的容器
docker restart         # 重啟容器
docker rm            # 刪除容器
docker rm -f          # 強制刪除運行中的容器
dockerexec-it  sh      # 進入容器 shell
docker logs --tail 100 -f    # 查看容器日志
docker inspect         # 查看容器詳細信息
docker cp :/path /host/path  # 從容器復制文件到宿主機
docker stats               # 查看容器資源使用
docker top           # 查看容器內進程