从入门到精通Docker容器化迁移与升级实战详解企业应用容器化过程中的迁移策略升级技巧与最佳实践

1. 引言

在当今快速发展的IT环境中，企业应用的容器化已成为提高部署效率、增强可移植性和简化运维管理的重要手段。Docker作为容器化技术的领导者，为企业提供了一种轻量级、可移植的虚拟化解决方案。本文将深入探讨企业应用容器化过程中的迁移策略、升级技巧与最佳实践，帮助读者从入门到精通掌握Docker容器化迁移与升级的全过程。

2. Docker基础知识

2.1 容器化概念

容器化是一种将应用程序及其依赖项打包在一起的技术，使其能够在任何环境中一致地运行。与传统虚拟机相比，容器共享主机操作系统内核，更加轻量级，启动更快，资源利用率更高。

2.2 Docker架构和核心组件

Docker采用客户端-服务器架构，主要包括以下核心组件：

Docker Engine：Docker的核心组件，负责创建和运行容器。
Docker镜像：只读的模板，用于创建容器。
Docker容器：镜像的运行实例。
Dockerfile：用于构建Docker镜像的文本文件。
Docker Compose：用于定义和运行多容器Docker应用程序的工具。
Docker Registry：用于存储和分发Docker镜像的服务。

2.3 Docker基础命令

以下是一些常用的Docker命令：

# 搜索镜像 docker search nginx # 拉取镜像 docker pull nginx:latest # 查看本地镜像 docker images # 运行容器 docker run -d -p 8080:80 --name my-nginx nginx # 查看运行中的容器 docker ps # 停止容器 docker stop my-nginx # 启动容器 docker start my-nginx # 删除容器 docker rm my-nginx # 删除镜像 docker rmi nginx:latest # 构建镜像 docker build -t my-app:1.0 . # 进入容器 docker exec -it my-nginx bash

3. 容器化迁移策略

3.1 迁移前评估

在开始容器化迁移之前，需要进行全面的评估：

3.1.1 应用评估

应用复杂性分析：评估应用的架构、组件和依赖关系。
状态管理分析：确定应用是否是有状态的，以及如何处理状态数据。
兼容性分析：检查应用与容器环境的兼容性。

3.1.2 环境评估

基础设施评估：评估现有基础设施是否支持容器化。
网络配置评估：分析网络需求和现有网络架构。
存储需求评估：确定存储需求和现有存储解决方案。

3.1.3 团队评估

技能评估：评估团队对Docker和容器技术的了解程度。
培训需求：确定团队需要哪些培训来成功实施容器化。

3.2 迁移规划

3.2.1 迁移策略选择

根据应用特性和业务需求，可以选择以下迁移策略：

重新托管（Rehost）：直接将应用迁移到容器中，不做任何代码更改。

 # 示例：将传统Web应用重新托管到容器中 FROM ubuntu:20.04 RUN apt-get update && apt-get install -y apache2 php COPY . /var/www/html/ EXPOSE 80 CMD ["apache2ctl", "-D", "FOREGROUND"]

重构平台（Replatform）：对应用进行少量修改，以更好地利用容器特性。

 # 示例：修改应用以使用环境变量配置 FROM node:14 WORKDIR /app COPY package*.json ./ RUN npm install COPY . . # 使用环境变量而不是硬编码配置 ENV PORT=3000 ENV DB_HOST=localhost EXPOSE $PORT CMD ["node", "app.js"]

重构（Refactor）：对应用进行重大修改，采用云原生架构。

 # 示例：将单体应用重构为微服务 # 用户服务Dockerfile FROM node:14 WORKDIR /app COPY user-service/package*.json ./ RUN npm install COPY user-service/ . EXPOSE 3001 CMD ["node", "user-service.js"] # 订单服务Dockerfile FROM node:14 WORKDIR /app COPY order-service/package*.json ./ RUN npm install COPY order-service/ . EXPOSE 3002 CMD ["node", "order-service.js"]

3.2.2 迁移优先级确定

根据业务价值、技术复杂性和风险等因素，确定应用迁移的优先级：

高价值低复杂性：优先迁移
高价值高复杂性：分阶段迁移
低价值低复杂性：根据资源情况迁移
低价值高复杂性：最后迁移或考虑淘汰

3.2.3 迁移计划制定

制定详细的迁移计划，包括：

时间表：确定每个阶段的开始和结束时间。
资源分配：分配人力、物力和财力资源。
风险缓解：识别潜在风险并制定应对措施。
回滚计划：制定在出现问题时回滚到原始环境的计划。

3.3 迁移执行

3.3.1 环境准备

准备容器化环境，包括：

安装Docker：在所有目标服务器上安装Docker。

 # 在Ubuntu上安装Docker sudo apt-get update sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" sudo apt-get update sudo apt-get install -y docker-ce docker-ce-cli containerd.io

配置网络：配置容器网络，确保容器之间以及容器与外部网络之间的通信。

 # 创建自定义网络 docker network create --driver bridge my-network # 运行容器并连接到自定义网络 docker run -d --name my-app --network my-network my-app-image

设置存储：配置持久化存储解决方案。

 # 创建数据卷 docker volume create my-data # 运行容器并挂载数据卷 docker run -d --name my-app -v my-data:/app/data my-app-image

3.3.2 应用容器化

根据选择的迁移策略，将应用容器化：

创建Dockerfile：为应用创建Dockerfile。

 # 示例：Java应用的Dockerfile FROM openjdk:11-jre-slim WORKDIR /app COPY target/my-app.jar . EXPOSE 8080 CMD ["java", "-jar", "my-app.jar"]

构建镜像：使用Dockerfile构建镜像。

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

测试容器：在本地环境中测试容器。

 # 运行容器进行测试 docker run -d -p 8080:8080 --name my-app-test my-app:1.0 # 检查容器日志 docker logs my-app-test # 进入容器进行调试 docker exec -it my-app-test bash

3.3.3 数据迁移

如果应用有持久化数据，需要将数据迁移到容器环境中：

数据导出：从原始环境中导出数据。

 # 示例：从MySQL数据库导出数据 mysqldump -u username -p database_name > backup.sql

数据导入：将数据导入到容器化环境中。

 # 示例：将数据导入到MySQL容器 docker exec -i mysql-container mysql -u root -ppassword database_name < backup.sql

数据同步：设置数据同步机制，确保数据一致性。

 # 示例：使用rsync同步数据 rsync -avz /path/to/source/ user@remote:/path/to/destination/

3.4 迁移验证

3.4.1 功能验证

验证容器化应用的功能是否与原始应用一致：

功能测试：执行全面的功能测试，确保所有功能正常工作。

 # 示例：使用curl测试Web应用 curl -I http://localhost:8080 # 示例：使用Postman测试API # 可以编写自动化测试脚本或使用CI/CD工具集成测试

集成测试：验证应用与其他系统的集成是否正常。

 # 示例：使用Docker Compose进行集成测试 version: '3' services: web: build: . ports: - "8080:8080" depends_on: - db db: image: mysql:5.7 environment: MYSQL_ROOT_PASSWORD: password MYSQL_DATABASE: mydb

3.4.2 性能验证

验证容器化应用的性能是否满足要求：

负载测试：使用工具如JMeter、Gatling等进行负载测试。

 # 示例：使用Apache Bench进行简单负载测试 ab -n 1000 -c 100 http://localhost:8080/

资源使用监控：监控容器资源使用情况。

 # 查看容器资源使用情况 docker stats my-app # 示例：使用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 google/cadvisor:latest

3.4.3 安全验证

验证容器化应用的安全性：

漏洞扫描：使用工具如Clair、Trivy等扫描镜像漏洞。

 # 示例：使用Trivy扫描镜像漏洞 docker run -v /var/run/docker.sock:/var/run/docker.sock aquasec/trivy:latest image my-app:1.0

安全配置检查：检查容器安全配置。

 # 示例：使用Docker Bench for Security检查安全配置 docker run -it --net host --pid host --cap-add audit_control -v /var/lib:/var/lib -v /var/run/docker.sock:/var/run/docker.sock -v /usr/lib/systemd:/usr/lib/systemd -v /etc:/etc --label docker_bench_security docker/docker-bench-security

4. 容器化升级技巧

4.1 版本管理

4.1.1 镜像版本控制

使用语义化版本控制管理镜像版本：

# 标记镜像版本 docker tag my-app:1.0 my-registry/my-app:1.0.0 # 推送镜像到仓库 docker push my-registry/my-app:1.0.0 # 创建最新版本的标签 docker tag my-app:1.0 my-registry/my-app:latest docker push my-registry/my-app:latest

4.1.2 使用Docker Compose进行版本管理

使用Docker Compose管理多容器应用的版本：

version: '3.7' services: web: image: my-registry/my-app:1.0.0 ports: - "8080:8080" depends_on: - db db: image: mysql:5.7 environment: MYSQL_ROOT_PASSWORD: password MYSQL_DATABASE: mydb volumes: - db-data:/var/lib/mysql volumes: db-data:

升级时，只需更新镜像版本：

version: '3.7' services: web: # 更新镜像版本 image: my-registry/my-app:1.1.0 ports: - "8080:8080" depends_on: - db # 其他服务保持不变

4.2 兼容性处理

4.2.1 数据库兼容性

处理数据库升级时的兼容性问题：

-- 示例：MySQL数据库升级脚本 -- 检查版本 SELECT VERSION(); -- 添加新表或字段 ALTER TABLE users ADD COLUMN last_login TIMESTAMP; -- 处理数据迁移 UPDATE users SET last_login = NOW() WHERE last_login IS NULL;

4.2.2 API兼容性

处理API升级时的兼容性问题：

// 示例：Node.js API兼容性处理 app.get('/api/users', (req, res) => { // 检查版本参数 const version = req.query.version || '1.0'; if (version === '1.0') { // 旧版本API响应 res.json(users.map(user => ({ id: user.id, name: user.name }))); } else { // 新版本API响应 res.json(users); } });

4.2.3 配置兼容性

处理配置升级时的兼容性问题：

# 示例：使用环境变量处理配置兼容性 version: '3.7' services: app: image: my-app:2.0.0 environment: # 新配置 NEW_FEATURE_ENABLED: "true" # 兼容旧配置 LEGACY_MODE: "false" # 如果新配置不存在，使用默认值 command: sh -c "if [ -z $$NEW_FEATURE_ENABLED ]; then export NEW_FEATURE_ENABLED=false; fi && node app.js"

4.3 升级策略

4.3.1 蓝绿部署

蓝绿部署是一种减少停机时间的升级策略：

# 阶段1：运行蓝环境（当前版本） docker-compose -f docker-compose.blue.yml up -d # 阶段2：准备绿环境（新版本） docker-compose -f docker-compose.green.yml up -d # 阶段3：测试绿环境 curl http://green-environment:8080/health # 阶段4：切换流量到绿环境 # 更新负载均衡器配置或DNS记录 # 阶段5：停用蓝环境 docker-compose -f docker-compose.blue.yml down

4.3.2 滚动升级

滚动升级是一种逐步替换旧版本实例的升级策略：

# 使用Docker Swarm进行滚动升级 docker service create --name my-app --replicas 3 --publish 8080:8080 my-registry/my-app:1.0.0 # 升级到新版本 docker service update --image my-registry/my-app:1.1.0 my-app # 监控升级进度 docker service ps my-app

4.3.3 金丝雀发布

金丝雀发布是一种将新版本逐步推送给部分用户的升级策略：

# 使用Kubernetes进行金丝雀发布 # 部署稳定版本 kubectl apply -f stable-deployment.yaml # 部署金丝雀版本（少量实例） kubectl apply -f canary-deployment.yaml # 监控金丝雀版本性能 kubectl get pods -w # 如果一切正常，逐步增加金丝雀版本实例 kubectl scale deployment canary-deployment --replicas=2 kubectl scale deployment stable-deployment --replicas=8 # 最终完全替换 kubectl apply -f new-stable-deployment.yaml

4.4 回滚策略

4.4.1 快速回滚

准备快速回滚方案，以便在出现问题时迅速恢复：

# 使用Docker标签进行快速回滚 # 在升级前标记当前版本 docker tag my-registry/my-app:current my-registry/my-app:backup-$(date +%Y%m%d%H%M%S) # 升级到新版本 docker-compose pull docker-compose up -d # 如果出现问题，回滚到备份版本 docker-compose stop docker tag my-registry/my-app:backup-20230101120000 my-registry/my-app:current docker-compose up -d

4.4.2 数据库回滚

准备数据库回滚方案：

-- 示例：创建数据库备份 CREATE DATABASE mydb_backup_20230101120000; CREATE TABLE mydb_backup_20230101120000.users LIKE mydb.users; INSERT INTO mydb_backup_20230101120000.users SELECT * FROM mydb.users; -- 如果需要回滚 DROP TABLE mydb.users; RENAME TABLE mydb_backup_20230101120000.users TO mydb.users;

4.4.3 自动化回滚

设置自动化回滚机制，在检测到问题时自动触发回滚：

#!/bin/bash # 健康检查脚本 HEALTH_CHECK_URL="http://my-app:8080/health" MAX_RETRIES=5 RETRY_INTERVAL=10 # 检查应用健康状态 for i in $(seq 1 $MAX_RETRIES); do if curl -f $HEALTH_CHECK_URL; then echo "Application is healthy" exit 0 fi echo "Health check failed, retrying in $RETRY_INTERVAL seconds..." sleep $RETRY_INTERVAL done # 如果所有重试都失败，执行回滚 echo "Health check failed after $MAX_RETRIES attempts, rolling back..." docker-compose stop docker tag my-registry/my-app:backup-20230101120000 my-registry/my-app:current docker-compose up -d

5. 企业应用容器化最佳实践

5.1 安全性最佳实践

5.1.1 镜像安全

使用官方基础镜像：优先使用官方提供的基础镜像。

 # 推荐 FROM node:14 # 不推荐 FROM ubuntu:20.04 RUN apt-get update && apt-get install -y nodejs npm

定期更新基础镜像：定期更新基础镜像以获取安全补丁。

 # 拉取最新的基础镜像 docker pull node:14 # 重新构建应用镜像 docker build -t my-app:latest .

最小化镜像大小：使用多阶段构建和精简基础镜像。

 # 多阶段构建示例 # 构建阶段 FROM node:14 AS build WORKDIR /app COPY package*.json ./ RUN npm install COPY . . RUN npm run build # 生产阶段 FROM node:14-alpine WORKDIR /app COPY --from=build /app/dist ./dist COPY package*.json ./ RUN npm install --production EXPOSE 8080 CMD ["node", "dist/app.js"]

扫描镜像漏洞：定期扫描镜像中的安全漏洞。

 # 使用Trivy扫描镜像 docker run -v /var/run/docker.sock:/var/run/docker.sock aquasec/trivy:latest image my-app:1.0

5.1.2 容器运行时安全

以非root用户运行容器：避免以root用户运行容器。

 # 创建非root用户 RUN groupadd -r appuser && useradd -r -g appuser appuser USER appuser

限制容器能力：限制容器的能力，减少攻击面。

 # 运行容器时限制能力 docker run --cap-drop ALL --cap-add NET_BIND_SERVICE my-app

使用只读根文件系统：将容器的根文件系统设置为只读。

 # 运行容器时设置只读根文件系统 docker run --read-only my-app

隔离敏感数据：使用 secrets 或 volumes 管理敏感数据。

 # 使用Docker secrets管理敏感数据 echo "my_secret_password" | docker secret create db_password - docker service create --name db --secret db_password -e MYSQL_ROOT_PASSWORD_FILE="/run/secrets/db_password" mysql:5.7

5.2 性能优化最佳实践

5.2.1 镜像优化

使用.dockerignore文件：排除不必要的文件。

 # .dockerignore示例 node_modules npm-debug.log .git .vscode

优化缓存层：合理安排Dockerfile指令顺序，充分利用缓存。

 # 不好的示例 - 每次更改代码都会重新安装依赖 FROM node:14 WORKDIR /app COPY . . RUN npm install CMD ["node", "app.js"] # 好的示例 - 只有package.json变化时才重新安装依赖 FROM node:14 WORKDIR /app COPY package*.json ./ RUN npm install COPY . . CMD ["node", "app.js"]

合并RUN指令：减少镜像层数。

 # 不好的示例 - 多个RUN指令创建多个层 RUN apt-get update RUN apt-get install -y nginx RUN rm -rf /var/lib/apt/lists/* # 好的示例 - 合并RUN指令 RUN apt-get update && apt-get install -y nginx && rm -rf /var/lib/apt/lists/*

5.2.2 资源限制

设置CPU和内存限制：为容器设置资源限制，避免资源争用。

 # 限制容器CPU和内存使用 docker run -d --name my-app --cpus="1.5" --memory="1g" my-app:1.0

使用资源预留：为重要容器预留资源。

 # 使用Docker Compose设置资源限制和预留 version: '3.7' services: app: image: my-app:1.0 deploy: resources: limits: cpus: '1.5' memory: 1G reservations: cpus: '1.0' memory: 512M

5.2.3 存储优化

使用适当的存储驱动：根据应用需求选择合适的存储驱动。

 # 查看当前存储驱动 docker info | grep "Storage Driver" # 更改存储驱动（需要修改Docker配置） # 编辑 /etc/docker/daemon.json { "storage-driver": "overlay2" } # 重启Docker服务 systemctl restart docker

优化数据卷使用：合理使用数据卷提高I/O性能。

 # 使用绑定挂载提高性能 docker run -d --name my-app -v /host/path:/container/path my-app:1.0 # 使用数据卷持久化数据 docker run -d --name my-db -v db-data:/var/lib/mysql mysql:5.7

5.3 监控与日志最佳实践

5.3.1 容器监控

使用Prometheus和Grafana：建立容器监控系统。

 # docker-compose.yml示例 version: '3.7' services: prometheus: image: prom/prometheus:latest ports: - "9090:9090" volumes: - ./prometheus.yml:/etc/prometheus/prometheus.yml command: - '--config.file=/etc/prometheus/prometheus.yml' grafana: image: grafana/grafana:latest ports: - "3000:3000" environment: - GF_SECURITY_ADMIN_PASSWORD=admin depends_on: - prometheus cadvisor: image: google/cadvisor:latest ports: - "8080:8080" volumes: - /:/rootfs:ro - /var/run:/var/run:ro - /sys:/sys:ro - /var/lib/docker/:/var/lib/docker:ro

设置告警规则：配置告警规则，及时发现异常。

 # prometheus.yml示例 global: scrape_interval: 15s rule_files: - "alert_rules.yml" alerting: alertmanagers: - static_configs: - targets: - alertmanager:9093 scrape_configs: - job_name: 'cadvisor' static_configs: - targets: ['cadvisor:8080']

5.3.2 日志管理

配置日志驱动：选择合适的日志驱动。

 # 使用json-file日志驱动（默认） docker run -d --name my-app --log-driver=json-file --log-opt max-size=10m --log-opt max-file=3 my-app:1.0 # 使用syslog日志驱动 docker run -d --name my-app --log-driver=syslog --log-opt syslog-address=tcp://192.168.1.100:514 my-app:1.0

使用ELK Stack：建立集中式日志管理系统。

 # docker-compose.yml示例 version: '3.7' services: elasticsearch: image: docker.elastic.co/elasticsearch/elasticsearch:7.10.0 environment: - discovery.type=single-node ports: - "9200:9200" logstash: image: docker.elastic.co/logstash/logstash:7.10.0 volumes: - ./logstash.conf:/usr/share/logstash/pipeline/logstash.conf depends_on: - elasticsearch kibana: image: docker.elastic.co/kibana/kibana:7.10.0 ports: - "5601:5601" depends_on: - elasticsearch filebeat: image: docker.elastic.co/beats/filebeat:7.10.0 volumes: - /var/lib/docker/containers:/var/lib/docker/containers:ro - /var/run/docker.sock:/var/run/docker.sock:ro - ./filebeat.yml:/usr/share/filebeat/filebeat.yml depends_on: - logstash

应用日志最佳实践：在应用中实现结构化日志。

 // Node.js应用中使用winston记录结构化日志 const winston = require('winston'); const logger = winston.createLogger({ level: 'info', format: winston.format.json(), transports: [ new winston.transports.Console() ] }); // 记录日志 logger.info('User login', { userId: '12345', timestamp: new Date().toISOString(), ip: '192.168.1.100' });

6. 实战案例

6.1 传统Java Web应用容器化迁移

6.1.1 应用分析

假设我们有一个传统的Java Web应用，使用Spring框架，打包为WAR文件，部署在Tomcat服务器上，连接MySQL数据库。

6.1.2 迁移策略

采用重新托管（Rehost）策略，将应用迁移到容器中，不做代码更改。

6.1.3 实施步骤

创建Dockerfile：

 # 使用官方Tomcat镜像作为基础镜像 FROM tomcat:9-jre11 # 设置维护者信息 MAINTAINER DevOps Team <devops@example.com> # 删除默认应用 RUN rm -rf /usr/local/tomcat/webapps/* # 复制WAR文件到webapps目录 COPY target/my-webapp.war /usr/local/tomcat/webapps/ROOT.war # 暴露端口 EXPOSE 8080 # 启动Tomcat CMD ["catalina.sh", "run"]

创建docker-compose.yml：

 version: '3.7' services: webapp: build: . ports: - "8080:8080" depends_on: - db environment: - DB_HOST=db - DB_PORT=3306 - DB_NAME=myapp - DB_USER=myuser - DB_PASSWORD=mypassword networks: - app-network db: image: mysql:5.7 environment: - MYSQL_ROOT_PASSWORD=rootpassword - MYSQL_DATABASE=myapp - MYSQL_USER=myuser - MYSQL_PASSWORD=mypassword volumes: - db-data:/var/lib/mysql networks: - app-network ports: - "3306:3306" volumes: db-data: networks: app-network: driver: bridge

构建和运行：

 # 构建镜像 docker-compose build # 启动服务 docker-compose up -d # 查看日志 docker-compose logs -f

数据迁移：

 # 从原数据库导出数据 mysqldump -u root -p myapp > myapp_backup.sql # 将数据导入到容器化数据库 docker exec -i $(docker-compose ps -q db) mysql -u root -prootpassword myapp < myapp_backup.sql

验证：

 # 检查应用是否正常运行 curl -I http://localhost:8080 # 检查数据库连接 docker exec -it $(docker-compose ps -q db) mysql -u myuser -pmypassword myapp

6.1.4 升级策略

假设我们需要升级应用版本，采用滚动升级策略：

更新Dockerfile：

 # 更新基础镜像版本 FROM tomcat:9-jre11 # 其他内容保持不变

构建新版本镜像：

 # 构建新版本镜像 docker-compose build --no-cache

滚动升级：

 # 使用Docker Swarm进行滚动升级 docker swarm init # 部署服务 docker stack deploy -c docker-compose.yml myapp # 更新服务 docker service update --image myapp_webapp:latest myapp_webapp

6.2 微服务架构应用容器化迁移

6.2.1 应用分析

假设我们有一个微服务架构的应用，包含用户服务、订单服务和支付服务，使用Spring Boot开发，每个服务都是独立的JAR包。

6.2.2 迁移策略

采用重构平台（Replatform）策略，对应用进行少量修改，以更好地利用容器特性。

6.2.3 实施步骤

创建各服务的Dockerfile：

 # 用户服务Dockerfile FROM openjdk:11-jre-slim WORKDIR /app COPY target/user-service.jar . EXPOSE 8081 # 使用环境变量配置 ENV JAVA_OPTS="-Xmx512m" CMD ["sh", "-c", "java $JAVA_OPTS -jar user-service.jar"]

 # 订单服务Dockerfile FROM openjdk:11-jre-slim WORKDIR /app COPY target/order-service.jar . EXPOSE 8082 ENV JAVA_OPTS="-Xmx512m" CMD ["sh", "-c", "java $JAVA_OPTS -jar order-service.jar"]

 # 支付服务Dockerfile FROM openjdk:11-jre-slim WORKDIR /app COPY target/payment-service.jar . EXPOSE 8083 ENV JAVA_OPTS="-Xmx512m" CMD ["sh", "-c", "java $JAVA_OPTS -jar payment-service.jar"]

创建docker-compose.yml：

 version: '3.7' services: user-service: build: context: . dockerfile: Dockerfile-user ports: - "8081:8081" environment: - SPRING_PROFILES_ACTIVE=prod - DB_HOST=db - DB_PORT=3306 - DB_NAME=userdb - DB_USER=user - DB_PASSWORD=password depends_on: - db networks: - app-network order-service: build: context: . dockerfile: Dockerfile-order ports: - "8082:8082" environment: - SPRING_PROFILES_ACTIVE=prod - DB_HOST=db - DB_PORT=3306 - DB_NAME=orderdb - DB_USER=order - DB_PASSWORD=password - USER_SERVICE_URL=http://user-service:8081 depends_on: - db - user-service networks: - app-network payment-service: build: context: . dockerfile: Dockerfile-payment ports: - "8083:8083" environment: - SPRING_PROFILES_ACTIVE=prod - DB_HOST=db - DB_PORT=3306 - DB_NAME=paymentdb - DB_USER=payment - DB_PASSWORD=password - ORDER_SERVICE_URL=http://order-service:8082 depends_on: - db - order-service networks: - app-network api-gateway: image: nginx:alpine ports: - "80:80" volumes: - ./nginx.conf:/etc/nginx/nginx.conf depends_on: - user-service - order-service - payment-service networks: - app-network db: image: mysql:5.7 environment: - MYSQL_ROOT_PASSWORD=rootpassword volumes: - db-data:/var/lib/mysql - ./init.sql:/docker-entrypoint-initdb.d/init.sql networks: - app-network ports: - "3306:3306" volumes: db-data: networks: app-network: driver: bridge

创建API网关配置：

 # nginx.conf events { worker_connections 1024; } http { upstream user_service { server user-service:8081; } upstream order_service { server order-service:8082; } upstream payment_service { server payment-service:8083; } server { listen 80; location /api/users/ { proxy_pass http://user_service; } location /api/orders/ { proxy_pass http://order_service; } location /api/payments/ { proxy_pass http://payment_service; } } }

创建数据库初始化脚本：

 -- init.sql CREATE DATABASE IF NOT EXISTS userdb; CREATE DATABASE IF NOT EXISTS orderdb; CREATE DATABASE IF NOT EXISTS paymentdb; CREATE USER IF NOT EXISTS 'user'@'%' IDENTIFIED BY 'password'; GRANT ALL PRIVILEGES ON userdb.* TO 'user'@'%'; CREATE USER IF NOT EXISTS 'order'@'%' IDENTIFIED BY 'password'; GRANT ALL PRIVILEGES ON orderdb.* TO 'order'@'%'; CREATE USER IF NOT EXISTS 'payment'@'%' IDENTIFIED BY 'password'; GRANT ALL PRIVILEGES ON paymentdb.* TO 'payment'@'%'; FLUSH PRIVILEGES;

构建和运行：

 # 构建镜像 docker-compose build # 启动服务 docker-compose up -d # 查看日志 docker-compose logs -f

数据迁移：

 # 从原数据库导出数据 mysqldump -u root -p userdb > userdb_backup.sql mysqldump -u root -p orderdb > orderdb_backup.sql mysqldump -u root -p paymentdb > paymentdb_backup.sql # 将数据导入到容器化数据库 docker exec -i $(docker-compose ps -q db) mysql -u root -prootpassword userdb < userdb_backup.sql docker exec -i $(docker-compose ps -q db) mysql -u root -prootpassword orderdb < orderdb_backup.sql docker exec -i $(docker-compose ps -q db) mysql -u root -prootpassword paymentdb < paymentdb_backup.sql

验证：

 # 检查各服务是否正常运行 curl -I http://localhost/api/users/ curl -I http://localhost/api/orders/ curl -I http://localhost/api/payments/ # 检查数据库连接 docker exec -it $(docker-compose ps -q db) mysql -u user -ppassword userdb docker exec -it $(docker-compose ps -q db) mysql -u order -ppassword orderdb docker exec -it $(docker-compose ps -q db) mysql -u payment -ppassword paymentdb

6.2.4 升级策略

假设我们需要升级其中一个服务，采用金丝雀发布策略：

创建Kubernetes部署文件：

 # user-service-deployment.yaml apiVersion: apps/v1 kind: Deployment metadata: name: user-service spec: replicas: 3 selector: matchLabels: app: user-service template: metadata: labels: app: user-service spec: containers: - name: user-service image: my-registry/user-service:1.0.0 ports: - containerPort: 8081 env: - name: SPRING_PROFILES_ACTIVE value: "prod" - name: DB_HOST value: "db" - name: DB_PORT value: "3306" - name: DB_NAME value: "userdb" - name: DB_USER value: "user" - name: DB_PASSWORD value: "password" resources: limits: memory: "512Mi" cpu: "500m" requests: memory: "256Mi" cpu: "250m" --- apiVersion: v1 kind: Service metadata: name: user-service spec: selector: app: user-service ports: - protocol: TCP port: 8081 targetPort: 8081

部署稳定版本：

 # 部署稳定版本 kubectl apply -f user-service-deployment.yaml

创建金丝雀版本部署文件：

 # user-service-canary-deployment.yaml apiVersion: apps/v1 kind: Deployment metadata: name: user-service-canary spec: replicas: 1 selector: matchLabels: app: user-service version: canary template: metadata: labels: app: user-service version: canary spec: containers: - name: user-service image: my-registry/user-service:1.1.0 ports: - containerPort: 8081 env: - name: SPRING_PROFILES_ACTIVE value: "prod" - name: DB_HOST value: "db" - name: DB_PORT value: "3306" - name: DB_NAME value: "userdb" - name: DB_USER value: "user" - name: DB_PASSWORD value: "password" resources: limits: memory: "512Mi" cpu: "500m" requests: memory: "256Mi" cpu: "250m"

部署金丝雀版本：

 # 部署金丝雀版本 kubectl apply -f user-service-canary-deployment.yaml

监控金丝雀版本：

 # 查看Pod状态 kubectl get pods -l app=user-service # 查看金丝雀版本日志 kubectl logs -f deployment/user-service-canary

逐步增加金丝雀版本流量：

 # 增加金丝雀版本副本数 kubectl scale deployment user-service-canary --replicas=2 # 减少稳定版本副本数 kubectl scale deployment user-service --replicas=2

完全切换到新版本：

 # 更新稳定版本到新版本 kubectl set image deployment/user-service user-service=my-registry/user-service:1.1.0 # 删除金丝雀版本 kubectl delete deployment user-service-canary

7. 常见问题与解决方案

7.1 容器启动失败

7.1.1 问题描述

容器启动后立即退出，或者无法正常启动。

7.1.2 原因分析

应用程序本身有问题
环境变量配置错误
端口冲突
资源限制过严
依赖服务未就绪

7.1.3 解决方案

查看容器日志：

 # 查看容器日志 docker logs my-container # 查看最后N行日志 docker logs --tail 50 my-container # 实时查看日志 docker logs -f my-container

进入容器调试：

 # 进入容器 docker exec -it my-container bash # 如果容器已退出，可以使用以下命令启动并进入 docker run -it --entrypoint /bin/bash my-image

检查环境变量：

 # 查看容器环境变量 docker exec my-container env # 在docker-compose中设置环境变量 environment: - ENV_VAR=value

检查端口冲突：

 # 查看主机端口使用情况 netstat -tulpn | grep :8080 # 更改容器端口映射 docker run -p 8081:8080 my-image

调整资源限制：

 # 增加内存限制 docker run -m 1g my-image # 增加CPU限制 docker run --cpus 2 my-image

添加健康检查：

 # 在Dockerfile中添加健康检查 HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 CMD curl -f http://localhost:8080/health || exit 1

7.2 数据持久化问题

7.2.1 问题描述

容器重启后数据丢失，或者数据卷无法正常挂载。

7.2.2 原因分析

未正确配置数据卷
数据卷权限问题
数据卷路径错误
数据卷已满

7.2.3 解决方案

使用数据卷：

 # 创建命名数据卷 docker volume create my-data # 使用数据卷 docker run -d -v my-data:/app/data my-image

使用绑定挂载：

 # 使用绑定挂载 docker run -d -v /host/path:/container/path my-image

设置数据卷权限：

 # 在Dockerfile中设置数据目录权限 RUN mkdir -p /app/data && chown -R appuser:appgroup /app/data

检查数据卷空间：

 # 查看数据卷使用情况 docker system df # 查看数据卷详细信息 docker volume inspect my-data

备份和恢复数据卷：

 # 备份数据卷 docker run --rm -v my-data:/source -v $(pwd):/backup alpine tar czf /backup/my-data-backup.tar.gz -C /source . # 恢复数据卷 docker run --rm -v my-data-new:/target -v $(pwd):/backup alpine tar xzf /backup/my-data-backup.tar.gz -C /target

7.3 网络连接问题

7.3.1 问题描述

容器之间无法通信，或者容器无法访问外部网络。

7.3.2 原因分析

网络配置错误
防火墙阻止
DNS解析问题
端口未正确暴露

7.3.3 解决方案

检查容器网络配置：

 # 查看容器网络配置 docker inspect my-container | grep -A 20 "NetworkSettings" # 查看Docker网络列表 docker network ls # 查看网络详细信息 docker network inspect my-network

创建自定义网络：

 # 创建自定义网络 docker network create --driver bridge my-network # 将容器连接到自定义网络 docker run -d --name my-container --network my-network my-image

使用Docker Compose管理网络：

 # 在docker-compose.yml中定义网络 version: '3.7' services: web: build: . networks: - app-network db: image: mysql:5.7 networks: - app-network networks: app-network: driver: bridge

测试容器间连接：

 # 从一个容器ping另一个容器 docker exec -it container1 ping container2 # 使用curl测试HTTP连接 docker exec -it container1 curl http://container2:8080

检查DNS配置：

 # 查看容器DNS配置 docker exec my-container cat /etc/resolv.conf # 自定义DNS配置 docker run --dns 8.8.8.8 my-image

7.4 性能问题

7.4.1 问题描述

容器运行缓慢，或者资源使用率过高。

7.4.2 原因分析

资源限制不当
存储I/O瓶颈
网络延迟
应用程序性能问题

7.4.3 解决方案

监控容器资源使用：

 # 查看容器资源使用情况 docker stats my-container # 使用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 google/cadvisor:latest

调整资源限制：

 # 设置CPU和内存限制 docker run -d --name my-container --cpus=2 --memory=2g my-image

优化存储性能：

 # 使用绑定挂载提高性能 docker run -d --name my-container -v /host/path:/container/path my-image # 使用合适的存储驱动 # 编辑 /etc/docker/daemon.json { "storage-driver": "overlay2" }

优化网络性能：

 # 使用主机网络提高性能 docker run -d --name my-container --network host my-image # 调整网络参数 docker run -d --name my-container --sysctl net.core.somaxconn=1024 my-image

应用性能优化：

 # 使用多阶段构建减小镜像大小 FROM maven:3.6.3-jdk-11 AS build WORKDIR /app COPY pom.xml . RUN mvn dependency:go-offline COPY src ./src RUN mvn package -DskipTests FROM openjdk:11-jre-slim WORKDIR /app COPY --from=build /app/target/*.jar app.jar EXPOSE 8080 CMD ["java", "-jar", "app.jar"]