深度剖析微服务电商项目的 CI/CD 体系：从业务到代码的落地实践

Asthenian
177 阅读13分钟

深度剖析微服务电商项目的 CI/CD 体系：从业务到代码的落地实践

一、引言：为什么 CI/CD 对电商项目至关重要？

在电商领域，快速迭代和高可用性是核心竞争力。想象一个场景：双十一促销活动即将来袭，订单服务需要新增优惠券功能，支付服务要支持新的支付渠道，而产品服务得优化搜索性能。如果没有 CI/CD，开发团队可能陷入手动构建、测试和部署的泥潭，导致功能上线延迟，甚至因配置错误引发生产事故。

持续集成（CI）和持续部署/交付（CD）通过自动化流程解决这些痛点。本文将围绕一个微服务电商项目，深入探讨 CI/CD 的设计与实现，从业务场景到代码层面，提供可落地的实践指南。我们将聚焦以下问题：

  • CI/CD 如何提升订单、支付等服务的开发效率？
  • 没有 CI/CD，微服务项目会面临哪些具体风险？
  • 如何为 Redis、MongoDB 等中间件和微服务设计 Docker 环境？
  • 架构师、程序员和实习生在 CI/CD 中如何分工协作？

二、CI/CD 的核心价值与风险规避

2.1 CI/CD 的业务价值

在我们的电商项目中，CI/CD 不仅仅是技术工具，更是业务成功的基石。以下是其核心价值，结合具体场景说明：

  1. 加速功能上线：

    • 场景：订单服务需要支持“满减优惠”功能，涉及订单金额计算和优惠券校验。CI/CD 确保开发人员提交代码后，自动运行单元测试、构建 Docker 镜像并部署到测试环境，半天内完成验证。
    • 价值：相比手动部署的数天周期，CI/CD 将上线时间缩短至小时级，抓住促销窗口。

  2. 保障代码质量：

    • 场景：支付服务新增微信支付接口，开发人员可能忘记处理支付回调的幂等性。CI 流水线通过单元测试和代码扫描（SonarQube）发现问题，强制修复。
    • 价值：避免生产环境中因代码缺陷导致的支付失败或重复扣款。

  3. 简化微服务协作：

    • 场景：产品服务更新了商品库存接口，订单服务需要同步调整调用逻辑。CI/CD 提供统一的构建和部署流程，确保两个服务的版本兼容。
    • 价值：降低跨团队协作的沟通成本，保持服务间的一致性。

  4. 支持高并发场景：

    • 场景：双十一期间，订单服务每秒处理数千个请求。CD 流水线支持蓝绿部署，平滑切换新版本，避免服务中断。
    • 价值：保证系统高可用性，防止促销活动中的流量高峰引发宕机。

2.2 没有 CI/CD 的风险

假设我们的电商项目没有 CI/CD，会面临以下具体问题：

  1. 集成问题：

    • 场景：订单服务和支付服务分别由两个团队开发，合并代码时发现接口不兼容（如订单服务期望 JSON 格式，支付服务返回 XML）。手动测试可能漏掉问题，直到生产环境才暴露。
    • 后果：修复成本高昂，可能导致促销活动延迟。

  2. 部署事故：

    • 场景：开发人员手动部署产品服务，忘记更新 Elasticsearch 的索引配置，导致商品搜索功能失效。
    • 后果：用户无法搜索商品，直接影响销售额。

  3. 测试不足：

    • 场景：支付服务未进行充分的单元测试，生产环境中发现分布式事务（Seata）配置错误，导致订单和支付数据不一致。
    • 后果：用户支付成功但订单未生成，引发投诉。

  4. 交付延迟：

    • 场景：网关服务需要支持新的限流规则，手动构建和部署耗费两天，错过市场竞争的先机。
    • 后果：竞争对手率先上线类似功能，抢占用户。

  5. 团队混乱：

    • 场景：实习生不知道最新版本的订单服务是否部署到测试环境，重复部署导致环境不稳定。
    • 后果：开发效率降低，团队信任受损。

这些问题在微服务架构中尤为严重，因为服务数量多、依赖复杂。CI/CD 通过自动化和标准化流程，将这些风险降到最低。

三、项目背景：微服务电商系统

3.1 业务场景

我们的电商平台支持以下核心功能：

  • 商品管理：用户可搜索商品、查看详情，系统支持高并发查询和库存更新。
  • 订单处理：用户下单后，系统生成订单、扣减库存并触发支付。
  • 支付流程：支持微信、支付宝等多种支付方式，需保证事务一致性。
  • 促销活动：支持满减、优惠券等活动，需快速上线新规则。

3.2 技术栈

  • 中间件：

    • Redis：缓存商品信息、用户会话。
    • MongoDB：存储订单、商品详情等非结构化数据。
    • RocketMQ：异步处理订单创建、支付通知。
    • Elasticsearch：支持商品搜索和推荐。
    • Nacos：服务注册、配置管理。
    • Seata：分布式事务，确保订单和支付一致性。
    • Canal：同步 MySQL 数据到 Elasticsearch。
    • Minio：存储商品图片。

  • 基础设施：

    • Docker：容器化服务和中间件。
    • GitLab：代码托管。
    • Jenkins：CI/CD 流水线。
    • Maven：项目构建。

3.3 微服务架构

项目包含以下服务：

  1. 网关服务（gateway-service） ：基于 Spring Cloud Gateway，负责路由、认证和限流。
  2. 分布式 ID 生成器（id-generator-service） ：基于雪花算法生成全局唯一 ID。
  3. 订单服务（order-service） ：管理订单创建、状态更新。
  4. 产品服务（product-service） ：管理商品信息、库存和搜索。
  5. 支付服务（payment-service） ：处理支付请求。

每个服务是独立的 Spring Boot 应用，使用 Java 开发，部署在 Docker 容器中。

四、CI/CD 流程设计

我们的 CI/CD 流程分为以下阶段：

  1. 代码提交：开发人员推送代码到 GitLab。
  2. 构建与测试：Jenkins 运行 Maven 构建，执行单元测试和代码质量检查。
  3. 容器化：构建 Docker 镜像，推送至私有 Harbor 仓库。
  4. 部署：使用 Docker Compose 部署到测试环境，支持蓝绿部署到生产环境。
  5. 监控与回滚：集成 Prometheus 和 Grafana，监控服务状态，支持快速回滚。

以下是具体实现。

五、Docker Compose 配置

Docker Compose 用于本地开发和测试环境，管理所有服务和中间件。以下是 docker-compose.yml，包含详细注释，明确启动顺序和依赖关系。

version: '3.8'

# 定义共享网络，所有容器加入此网络以便通信
networks:
  app-network:
    driver: bridge

# 定义持久化存储卷
volumes:
  redis-data:
  mongo-data:
  es-data:
  minio-data:
  mysql-data:
  nacos-data:

services:
  # Nacos：服务注册与配置中心，优先启动，因为所有微服务依赖它
  nacos:
    image: nacos/nacos-server:2.0.4
    ports:
      - "8848:8848" # 管理界面端口
      - "9848:9848" # gRPC 端口
    environment:
      - MODE=standalone # 单机模式，适合开发/测试
      - JVM_XMS=512m
      - JVM_XMX=512m
    volumes:
      - nacos-data:/home/nacos/data
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8848/nacos/actuator/health"]
      interval: 10s
      timeout: 5s
      retries: 3

  # Redis：缓存服务，订单和产品服务依赖
  redis:
    image: redis:6.2
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 3
    depends_on:
      nacos:
        condition: service_healthy # 等待 Nacos 健康

  # MongoDB：存储订单和商品数据
  mongodb:
    image: mongo:5.0
    ports:
      - "27017:27017"
    volumes:
      - mongo-data:/data/db
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "mongo", "--eval", "db.adminCommand('ping')"]
      interval: 10s
      timeout: 5s
      retries: 3
    depends_on:
      nacos:
        condition: service_healthy

  # RocketMQ NameServer：消息队列，订单和支付服务依赖
  rocketmq:
    image: apache/rocketmq:4.9.4
    ports:
      - "9876:9876"
    environment:
      - JAVA_OPT_EXT="-server -Xms512m -Xmx512m"
    networks:
      - app-network
    depends_on:
      nacos:
        condition: service_healthy

  # Elasticsearch：商品搜索，产品服务依赖
  elasticsearch:
    image: elasticsearch:7.17.0
    ports:
      - "9200:9200"
      - "9300:9300"
    environment:
      - discovery.type=single-node
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    volumes:
      - es-data:/usr/share/elasticsearch/data
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9200/_cluster/health"]
      interval: 10s
      timeout: 5s
      retries: 3
    depends_on:
      nacos:
        condition: service_healthy

  # Seata：分布式事务，订单和支付服务依赖
  seata:
    image: seataio/seata-server:1.5.2
    ports:
      - "8091:8091"
    environment:
      - SEATA_CONFIG_NAME=file:/root/seata-config/registry
    volumes:
      - ./seata-config:/root/seata-config
    networks:
      - app-network
    depends_on:
      nacos:
        condition: service_healthy

  # MySQL：供 Canal 同步数据
  mysql:
    image: mysql:8.0
    ports:
      - "3306:3306"
    environment:
      - MYSQL_ROOT_PASSWORD=root
      - MYSQL_USER=canal
      - MYSQL_PASSWORD=canal
      - MYSQL_DATABASE=example
    volumes:
      - mysql-data:/var/lib/mysql
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 3
    depends_on:
      nacos:
        condition: service_healthy

  # Canal：同步 MySQL 数据到 Elasticsearch
  canal:
    image: canal/canal-server:v1.1.5
    ports:
      - "11111:11111"
    environment:
      - canal.destinations=example
      - canal.instance.master.address=mysql:3306
      - canal.instance.dbUsername=canal
      - canal.instance.dbPassword=canal
    networks:
      - app-network
    depends_on:
      mysql:
        condition: service_healthy
      elasticsearch:
        condition: service_healthy

  # Minio：对象存储，产品服务依赖
  minio:
    image: minio/minio:RELEASE.2023-03-20T20-16-18Z
    ports:
      - "9000:9000"
      - "9001:9001"
    environment:
      - MINIO_ROOT_USER=admin
      - MINIO_ROOT_PASSWORD=password
    volumes:
      - minio-data:/data
    command: server /data --console-address ":9001"
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 10s
      timeout: 5s
      retries: 3
    depends_on:
      nacos:
        condition: service_healthy

  # 网关服务：依赖 Nacos 进行服务发现
  gateway-service:
    build:
      context: ./gateway-service
      dockerfile: Dockerfile
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=dev
      - NACOS_SERVER_ADDR=nacos:8848
    networks:
      - app-network
    depends_on:
      nacos:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
      interval: 10s
      timeout: 5s
      retries: 3

  # 分布式 ID 生成器
  id-generator-service:
    build:
      context: ./id-generator-service
      dockerfile: Dockerfile
    ports:
      - "8081:8081"
    environment:
      - SPRING_PROFILES_ACTIVE=dev
      - NACOS_SERVER_ADDR=nacos:8848
    networks:
      - app-network
    depends_on:
      nacos:
        condition: service_healthy

  # 订单服务：依赖多个中间件
  order-service:
    build:
      context: ./order-service
      dockerfile: Dockerfile
    ports:
      - "8082:8082"
    environment:
      - SPRING_PROFILES_ACTIVE=dev
      - NACOS_SERVER_ADDR=nacos:8848
      - REDIS_HOST=redis
      - MONGO_HOST=mongodb
      - ROCKETMQ_NAME_SERVER=rocketmq:9876
      - SEATA_SERVER_ADDR=seata:8091
    networks:
      - app-network
    depends_on:
      redis:
        condition: service_healthy
      mongodb:
        condition: service_healthy
      rocketmq:
        condition: service_started
      seata:
        condition: service_started
      nacos:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8082/actuator/health"]
      interval: 10s
      timeout: 5s
      retries: 3

  # 产品服务
  product-service:
    build:
      context: ./product-service
      dockerfile: Dockerfile
    ports:
      - "8083:8083"
    environment:
      - SPRING_PROFILES_ACTIVE=dev
      - NACOS_SERVER_ADDR=nacos:8848
      - REDIS_HOST=redis
      - ELASTICSEARCH_HOST=elasticsearch
      - MINIO_HOST=minio
    networks:
      - app-network
    depends_on:
      redis:
        condition: service_healthy
      elasticsearch:
        condition: service_healthy
      minio:
        condition: service_healthy
      nacos:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8083/actuator/health"]
      interval: 10s
      timeout: 5s
      retries: 3

  # 支付服务
  payment-service:
    build:
      context: ./payment-service
      dockerfile: Dockerfile
    ports:
      - "8084:8084"
    environment:
      - SPRING_PROFILES_ACTIVE=dev
      - NACOS_SERVER_ADDR=nacos:8848
      - ROCKETMQ_NAME_SERVER=rocketmq:9876
      - SEATA_SERVER_ADDR=seata:8091
    networks:
      - app-network
    depends_on:
      rocketmq:
        condition: service_started
      seata:
        condition: service_started
      nacos:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8084/actuator/health"]
      interval: 10s
      timeout: 5s
      retries: 3

注释说明：

  • 网络：所有服务加入 app-network，确保容器间通信。

  • 启动顺序：

    • Nacos 优先启动，所有微服务依赖其服务注册和配置管理。
    • Redis、MongoDB、RocketMQ、Elasticsearch、Seata、Minio、MySQL 次之，微服务依赖这些中间件。
    • Canal 依赖 MySQL 和 Elasticsearch，用于数据同步。
    • 微服务（网关、订单等）最后启动，依赖中间件。

  • 健康检查：通过 healthcheck 确保服务正常运行，例如 Nacos 和 Redis 使用 HTTP 或命令检查。

  • 依赖关系：

    • 使用 depends_on 和 condition: service_healthy 确保关键中间件健康后再启动服务。
    • RocketMQ 和 Seata 使用 service_started，因为它们无需健康检查。

  • 持久化：通过 volumes 确保数据（如 MongoDB、Elasticsearch）不丢失。

启动顺序总结：

  1. Nacos（服务注册中心）
  2. Redis, MongoDB, RocketMQ, Elasticsearch, Seata, MySQL, Minio（中间件）
  3. Canal（数据同步）
  4. 微服务（网关、订单、产品、支付、ID 生成器）

六、Dockerfile 编写

每个微服务需要一个 Dockerfile。以下以订单服务为例，其他服务类似。

# 使用 OpenJDK 17 作为基础镜像，支持最新的 Spring Boot
FROM openjdk:17-jre-slim

# 设置工作目录
WORKDIR /app

# 复制 Maven 打包的 JAR 文件
COPY target/order-service.jar /app/order-service.jar

# 设置 JVM 参数，优化性能
ENV JAVA_OPTS="-Xms256m -Xmx512m -XX:+UseG1GC"

# 暴露端口
EXPOSE 8082

# 运行应用
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar /app/order-service.jar"]

要点：

  • 使用 openjdk:17-jre-slim 减少镜像体积。
  • 通过 JAVA_OPTS 设置 JVM 参数，优化内存和垃圾回收。
  • 其他服务的 Dockerfile 类似，替换 JAR 文件名和端口（如支付服务用 8084）。

七、业务代码与单元测试

7.1 订单服务：订单创建与消息队列

订单服务是电商系统的核心，负责订单创建并通过 RocketMQ 异步通知支付服务。以下是代码示例。

订单服务核心代码：

package com.example.order.service;

import com.example.order.entity.Order;
import com.example.order.repository.OrderRepository;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import io.seata.spring.annotation.GlobalTransactional;

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    @GlobalTransactional
    public Order createOrder(String userId, String productId, int quantity, double price) {
        // 创建订单
        Order order = new Order();
        order.setUserId(userId);
        order.setProductId(productId);
        order.setQuantity(quantity);
        order.setTotalPrice(price * quantity);
        order.setStatus("PENDING");
        order = orderRepository.save(order);

        // 发送消息到 RocketMQ，通知支付服务
        rocketMQTemplate.convertAndSend("order-topic", order);

        return order;
    }
}

要点：

  • 使用 @GlobalTransactional 确保分布式事务（Seata），订单和支付一致。
  • 通过 RocketMQTemplate 发送订单消息，异步触发支付流程。

单元测试：

package com.example.order.service;

import com.example.order.entity.Order;
import com.example.order.repository.OrderRepository;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

@ExtendWith(MockitoExtension.class)
public class OrderServiceTest {

    @Mock
    private OrderRepository orderRepository;

    @Mock
    private RocketMQTemplate rocketMQTemplate;

    @InjectMocks
    private OrderService orderService;

    @Test
    public void testCreateOrder() {
        // 准备数据
        String userId = "user123";
        String productId = "prod456";
        int quantity = 2;
        double price = 100.0;

        // 模拟 repository
        Order savedOrder = new Order();
        savedOrder.setUserId(userId);
        savedOrder.setProductId(productId);
        savedOrder.setQuantity(quantity);
        savedOrder.setTotalPrice(price * quantity);
        savedOrder.setStatus("PENDING");

        when(orderRepository.save(any(Order.class))).thenReturn(savedOrder);

        // 调用服务
        Order result = orderService.createOrder(userId, productId, quantity, price);

        // 验证
        assertNotNull(result);
        assertEquals(userId, result.getUserId());
        assertEquals(price * quantity, result.getTotalPrice());
        assertEquals("PENDING", result.getStatus());

        // 验证 RocketMQ 消息发送
        verify(rocketMQTemplate, times(1)).convertAndSend(eq("order-topic"), any(Order.class));
        verify(orderRepository, times(1)).save(any(Order.class));
    }
}

要点：

  • 模拟 OrderRepository 和 RocketMQTemplate，测试订单创建和消息发送逻辑。
  • 验证订单状态和总价计算正确。

7.2 支付服务：分布式事务

支付服务处理订单支付，使用 Seata 保证事务一致性。

支付服务核心代码：

package com.example.payment.service;

import io.seata.spring.annotation.GlobalTransactional;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
@RocketMQMessageListener(topic = "order-topic", consumerGroup = "payment-group")
public class PaymentService {

    @Autowired
    private PaymentRepository paymentRepository;

    @GlobalTransactional
    public void processPayment(Order order) {
        // 创建支付记录
        Payment payment = new Payment();
        payment.setOrderId(order.getId());
        payment.setAmount(order.getTotalPrice());
        payment.setStatus("SUCCESS");
        paymentRepository.save(payment);

        // 更新订单状态（通过远程调用或消息）
        // 假设这里调用订单服务
    }
}

单元测试：类似订单服务，测试支付记录创建和事务逻辑。

八、Maven 打包

以下是订单服务的 pom.xml：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>order-service</artifactId>
    <version>1.0.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.0</version>
    </parent>

    <dependencies>
        <!-- Spring Boot -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>
        <!-- Nacos -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            <version>2022.0.0.0</version>
        </dependency>
        <!-- Seata -->
        <dependency>
            <groupId>io.seata</groupId>
            <artifactId>seata-spring-boot-starter</artifactId>
            <version>1.5.2</version>
        </dependency>
        <!-- RocketMQ -->
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-spring-boot-starter</artifactId>
            <version>2.2.3</version>
        </dependency>
        <!-- Redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- 测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-core</artifactId>
            <version>5.3.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.0.0-M7</version>
            </plugin>
            <plugin>
                <groupId>org.sonarsource.scanner.maven</groupId>
                <artifactId>sonar-maven-plugin</artifactId>
                <version>3.9.1.2184</version>
            </plugin>
        </plugins>
    </build>
</project>

打包流程：

  • 运行 mvn clean package：编译代码、运行测试、生成 order-service.jar。
  • 代码质量检查：运行 mvn sonar:sonar 集成 SonarQube。

九、GitLab 与 Jenkins 配置

9.1 GitLab 配置

  1. 仓库结构：

    • 每个服务一个仓库：order-service, payment-service, 等。
    • 根目录仓库 infrastructure 包含 docker-compose.yml 和共享配置。

  2. Webhook：

    • 在 GitLab 设置 Webhook，URL 为 http://jenkins:8080/gitlab-webhook/，触发事件为 Push events。

9.2 Jenkins 配置

Jenkinsfile（订单服务）：

pipeline {
    agent any
    environment {
        DOCKER_REGISTRY = 'harbor.example.com'
        DOCKER_CREDENTIALS_ID = 'harbor-credentials'
        IMAGE_NAME = "${DOCKER_REGISTRY}/ecommerce/order-service"
        IMAGE_TAG = "${env.BUILD_ID}"
        SONAR_TOKEN = credentials('sonar-token')
    }
    stages {
        stage('Checkout') {
            steps {
                git branch: 'develop', url: 'https://gitlab.com/ecommerce/order-service.git'
            }
        }
        stage('Build') {
            steps {
                sh 'mvn clean package -DskipTests'
            }
        }
        stage('Test') {
            steps {
                sh 'mvn test'
            }
        }
        stage('Code Quality') {
            steps {
                sh 'mvn sonar:sonar -Dsonar.login=$SONAR_TOKEN'
            }
        }
        stage('Docker Build & Push') {
            steps {
                script {
                    dockerImage = docker.build("${IMAGE_NAME}:${IMAGE_TAG}")
                    docker.withRegistry("https://${DOCKER_REGISTRY}", DOCKER_CREDENTIALS_ID) {
                        dockerImage.push("${IMAGE_TAG}")
                        dockerImage.push("latest")
                    }
                }
            }
        }
        stage('Deploy to Test') {
            steps {
                sh 'docker-compose -f docker-compose.yml up -d order-service'
            }
        }
        stage('Blue-Green Deploy to Prod') {
            when {
                branch 'master'
            }
            steps {
                script {
                    // 蓝绿部署逻辑（简化示例）
                    sh 'docker-compose -f docker-compose-prod.yml up -d --scale order-service=2'
                    sh 'sleep 30' // 等待新版本稳定
                    sh 'docker-compose -f docker-compose-prod.yml up -d --scale order-service=1'
                }
            }
        }
    }
    post {
        always {
            cleanWs()
        }
        failure {
            slackSend channel: '#ci-cd', message: "Build failed: ${env.JOB_NAME} #${env.BUILD_NUMBER}"
        }
    }
}

要点：

  • Code Quality：集成 SonarQube 检查代码质量。
  • Blue-Green Deploy：生产环境使用蓝绿部署，降低风险。
  • 通知：失败时通过 Slack 通知团队。

十、角色视角：代码与业务的结合

10.1 架构师的视角

职责：设计系统架构，优化 CI/CD 流程。

场景：订单服务需支持高并发促销活动。

操作：

  1. 架构设计：

    • 设计订单服务使用 Redis 缓存热门订单，降低 MongoDB 压力。
    • 使用 RocketMQ 削峰，异步处理订单创建。
    • 配置 Seata 确保分布式事务。
    // 订单服务配置 Redis 缓存
@Service
public class OrderCacheService {
    @Autowired
    private RedisTemplate<String, Order> redisTemplate;

    public void cacheOrder(Order order) {
        redisTemplate.opsForValue().set("order:" + order.getId(), order, 1, TimeUnit.HOURS);
    }
}

  2. CI/CD 优化：

    • 在 Jenkinsfile 中添加性能测试阶段，使用 JMeter 模拟高并发。
    • 配置蓝绿部署，确保促销期间零宕机。

  3. 监控：

    • 部署 Prometheus 监控 RocketMQ 消息积压，Grafana 展示订单服务 QPS。

视野：架构师从全局出发，关注系统性能、稳定性和 CI/CD 的可扩展性。

10.2 普通程序员的视角

职责：实现业务功能，参与 CI/CD。

场景：开发订单服务的优惠券功能。

操作：

  1. 代码实现：

    public Order applyCoupon(String userId, String productId, int quantity, String couponId) {
    // 验证优惠券
    Coupon coupon = couponService.getCoupon(couponId);
    if (coupon == null || !coupon.isValid()) {
        throw new IllegalArgumentException("Invalid coupon");
    }

    Order order = new Order();
    order.setUserId(userId);
    order.setProductId(productId);
    order.setQuantity(quantity);
    double price = productService.getPrice(productId);
    order.setTotalPrice(price * quantity * coupon.getDiscount());
    order.setStatus("PENDING");
    return orderRepository.save(order);
}

  2. 单元测试：

    @Test
public void testApplyCoupon() {
    when(couponService.getCoupon("coupon123")).thenReturn(new Coupon("coupon123", 0.8, true));
    when(productService.getPrice("prod456")).thenReturn(100.0);

    Order order = orderService.applyCoupon("user123", "prod456", 2, "coupon123");

    assertEquals(160.0, order.getTotalPrice()); // 100 * 2 * 0.8
}

  3. CI/CD 参与：

    • 推送代码到 GitLab，检查 Jenkins 构建日志。
    • 发现测试失败，修复 Redis 连接配置。

视野：程序员聚焦代码实现和调试，关注 CI/CD 流水线的执行结果。

10.3 实习生的视角

职责：辅助开发，学习技术。

场景：为产品服务添加商品图片上传功能。

操作：

  1. 代码实现：

    @Service
public class ProductService {
    @Autowired
    private MinioClient minioClient;

    public String uploadImage(String productId, MultipartFile file) {
        String bucket = "products";
        String objectName = productId + "-" + file.getOriginalFilename();
        minioClient.putObject(PutObjectArgs.builder()
            .bucket(bucket)
            .object(objectName)
            .stream(file.getInputStream(), file.getSize(), -1)
            .build());
        return "http://minio:9000/" + bucket + "/" + objectName;
    }
}

  2. 学习 CI/CD：

    • 导师指导实习生运行 docker-compose up 启动 Minio。
    • 提交代码到 GitLab，观察 Jenkins 流水线。

  3. 问题排查：

    • 发现 Minio 上传失败，检查 docker-compose.yml，发现端口配置错误。

视野：实习生通过简单任务学习技术，逐步理解 CI/CD 和微服务。

十一、总结

本文通过一个微服务电商项目，深入剖析了 CI/CD 的设计与实现：

  • 业务驱动：CI/CD 加速促销功能上线，保证支付和订单的高可用性。
  • 技术落地：通过 Docker Compose、Dockerfile、单元测试和 Jenkins 构建完整流程。
  • 角色协作：架构师优化架构，程序员实现功能，实习生学习成长。

未来，我们可以引入 Kubernetes 实现生产环境自动化，集成 Chaos Engineering 测试系统稳定性。希望这篇博客为您提供实操参考！

avatar
文章
阅读
粉丝