全自动灰度服务搭建和发布实战 | SpringCloudGateway + Nacos + GitlabRunner

柔情只为你懂 2024-03-27 02:19 96阅读 0赞

## 1 | **业务场景说明** ##

要实现的业务场景：

1.  可以根据单个用户id或者批量用户id，判断是否需要灰度该用户/批量用户
2.  可以根据请求头字段（可动态设定的任意kv），判断是否需要走灰度服务

## 2 | **具体实现方案** ##

这里采用 SpringCloudGateway（SCG） + Nacos + GitlabRunner 来实现整个自动化的灰度发布。

*  **SCG**：统一的流量入口 + 正常/灰度服务选择分发逻辑处理
 *  **Nacos**：loadbalancer 提供方，通过 metadata 维护灰度服务
 *  **GitlabRunner**：灰度服务部署的自动化 CICD Pipeline 处理

下面分别从以上这三个组件来搭建。

### 2.1 | **SCG** ###

直接上代码，通过注释讲解。

*  **GrayLoadBalancerClientFilter**: 自定义灰度服务负载均衡过滤器

/**
     * 通过GrayLoadBalancer过滤实例
     */
    @Component
    @Slf4j
    public class GrayLoadBalancerClientFilter implements GlobalFilter, Ordered {
    
        @Resource
        private LoadBalancerClientFactory clientFactory;
        @Resource
        private CustomProperty customProperty;
    
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
            URI url = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);
    
            ServerWebExchangeUtils.addOriginalRequestUrl(exchange, url);
            if (url == null || BizConstant.HTTP.equalsIgnoreCase(url.getScheme())) {
                return chain.filter(exchange);
            }
            return doFilter(exchange, chain, url);
        }
    
        private Mono<Void> doFilter(ServerWebExchange exchange, GatewayFilterChain chain, URI url) {
            return this.choose(exchange).doOnNext(res -> {
                if (!res.hasServer()) {
                    throw NotFoundException.create(true, "Unable to find instance for ".concat(url.getHost()));
                }
                URI uri = exchange.getRequest().getURI();
                String overrideScheme = null;
                DelegatingServiceInstance delegatingServiceInstance = new DelegatingServiceInstance(res.getServer(), overrideScheme);
                URI reqUrl = this.reconstructURI(delegatingServiceInstance, uri);
                if (log.isDebugEnabled()) {
                    log.debug("GrayLoadBalancerClientFilter url chosen: {}", reqUrl.toString());
                }
                exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR, reqUrl);
            }).then(chain.filter(exchange));
        }
    
        private URI reconstructURI(DelegatingServiceInstance delegatingServiceInstance, URI originalUri) {
            return LoadBalancerUriTools.reconstructURI(delegatingServiceInstance, originalUri);
        }
    
        private Mono<Response<ServiceInstance>> choose(ServerWebExchange exchange) {
            URI uri = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);
            if (uri == null) {
                throw new MMException("{} is null", ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);
            }
            GrayLoadBalancer loadBalancer = new GrayLoadBalancer(clientFactory.getLazyProvider(uri.getHost(), ServiceInstanceListSupplier.class), uri.getHost(), customProperty);
            return loadBalancer.choose(this.createRequest(exchange));
        }
    
        private Request createRequest(ServerWebExchange exchange) {
            return new DefaultRequest(exchange.getRequest().getHeaders());
        }
    
    
        @Override
        public int getOrder() {
            return FILTER_ORDER_GRAY;
        }
    }
    复制代码

> **NOTE**
> 
> FILTER\_ORDER\_GRAY 是一个 int 常量，其值不能随意定义(如-1,0,1,2之类)。从下表可以看到，SCG 的 **LoadBalancerClientFilter** 执行顺序是 10100，那么 **GrayLoadBalancerClientFilter** 的执行顺序必须 > 10100 （否则自定义的 Filter 里就会有变量未被赋值）, 这里假定 FILTER\_ORDER\_GRAY = 10110
> 
> ![2f4b77ae32e2df443b133dbbf8f8d7d8.png][]

*  **GrayLoadBalancer**: 灰度发布负载均衡策略

/**
     * 灰度发布负载均衡策略
     */
    
    @Slf4j
    public class GrayLoadBalancer implements ReactorServiceInstanceLoadBalancer {
    
        private ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;
        private String serviceId;
        private CustomProperty customProperty;
    
    
        public GrayLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider, String serviceId, CustomProperty customProperty) {
            this.serviceId = serviceId;
            this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;
            this.customProperty = customProperty;
        }
    
        @Override
        public Mono<Response<ServiceInstance>> choose(Request request) {
            HttpHeaders headers = (HttpHeaders) request.getContext();
    
            if (this.serviceInstanceListSupplierProvider != null) {
                ServiceInstanceListSupplier supplier = this.serviceInstanceListSupplierProvider.getIfAvailable(NoopServiceInstanceListSupplier::new);
                return supplier.get().next().map(item -> getInstanceResponse(item, headers));
            }
            return null;
        }
    
        private Response<ServiceInstance> getInstanceResponse(List<ServiceInstance> instances, HttpHeaders headers) {
            if (instances.isEmpty()) {
                return getServiceInstanceEmptyResponse();
            }
            return getServiceInstanceResponseByUidsOrGrayTag(instances, headers);
        }
    
        /**
         * 从nacos获取服务实例列表，并根据策略返回灰度服务的实例还是正常服务的实例
         */
        private Response<ServiceInstance> getServiceInstanceResponseByUidsOrGrayTag(List<ServiceInstance> instances, HttpHeaders headers) {
            List<ServiceInstance> grayInstances = new ArrayList<>();
            List<ServiceInstance> normalInstances = new ArrayList<>();
    
            for (ServiceInstance instance : instances) {
                Map<String, String> metadata = instance.getMetadata();
                // nacos元数据包含“gray-tag”的key值,且value="true"，则判定为灰度实例
                String isGrayInstance = metadata.get(BizConstant.GRAY_TAG);
                if (BizConstant.TRUE.equals(isGrayInstance)) {
                    grayInstances.add(instance);
                } else {
                    normalInstances.add(instance);
                }
            }
            //没有灰度服务，直接返回
            if (grayInstances.isEmpty()) {
                return new DefaultResponse(chooseOneInstance(normalInstances));
            }
            //有灰度服务，判断是否需要灰度
            if (checkIfNeedGray(headers)) {
                log.info("gray service of {} will be called", this.serviceId);
                return new DefaultResponse(chooseOneInstance(grayInstances));
            }
            return new DefaultResponse(chooseOneInstance(normalInstances));
        }
    
        /**
         * 从实例列表中获取其中一个实例的策略实现，这里采用的是随机挑选
         * pick strategy 可以根据业务需要，在这个方法里改写
         */
        private ServiceInstance chooseOneInstance(List<ServiceInstance> serviceInstances) {
    
            // strategy 1：可用的里面随机选择一个
            int size = serviceInstances.size();
            if (size == 1) {
                return serviceInstances.get(0);
            }
            Random rand = new Random();
            int random = rand.nextInt(size);
            return serviceInstances.get(random);
        }
    
        /**
         * 灰度判断逻辑：
         * 1. 判断请求header里是否用灰度标识的 kv，有则走灰度服务
         * 2. 如果 1 不满足，则判断请求的用户 id 是否在灰度用户池中，有则走灰度服务
         * 3. 1 和 2 都不满足，走正常服务
         */
        private boolean checkIfNeedGray(HttpHeaders headers) {
            String grayTag = headers.getFirst(BizConstant.GRAY_TAG);
            if (grayTag != null) {
                if (BizConstant.TRUE.equalsIgnoreCase(grayTag)) {
                    // todo 可扩展点：目前是只判断header里是否有BizConstant.GRAY_TAG的kv不为空且v="true"，后面v可以改为版本号
                    return true;
                }
            }
            String uid = headers.getFirst(BizConstant.UID);
            if (uid != null && customProperty.getGraySetting().getGrayUids().contains(uid)) {
                return true;
            }
            return false;
        }
    
        private Response<ServiceInstance> getServiceInstanceEmptyResponse() {
            log.warn("No servers available for service: " + this.serviceId);
            return new EmptyResponse();
        }
    }
    复制代码

*  **Https2HttpFilter**：将进入网关的 https 请求转换为 http 请求

/**
     * https scheme to http
     */
    
    @Component
    @Slf4j
    public class Https2HttpFilter implements GlobalFilter, Ordered {
    
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
            ServerHttpRequest request = exchange.getRequest();
            URI originalUri = request.getURI();
            ServerHttpRequest.Builder mutate = request.mutate();
            String forwardUri = request.getURI().toString();
    
            if (forwardUri != null && forwardUri.startsWith(BizConstant.HTTPS)) {
                try {
                    URI mutatedUri = new URI(BizConstant.HTTP,
                            originalUri.getUserInfo(),
                            originalUri.getHost(),
                            originalUri.getPort(),
                            originalUri.getPath(),
                            originalUri.getQuery(),
                            originalUri.getFragment());
                    mutate.uri(mutatedUri);
                } catch (Exception e) {
                    log.error(e.getMessage());
                    throw new MMException("Https related error");
                }
            }
            ServerHttpRequest build = mutate.build();
            return chain.filter(exchange.mutate().request(build).build());
        }
    
        @Override
        public int getOrder() {
            return FILTER_ORDER_HTTPS_2_HTTP;
        }
    }
    复制代码

> **NOTE**
> 
> FILTER\_ORDER\_HTTPS\_2\_HTTP 是一个 int 常量，需要满足 **LoadBalancerClientFilter** 的执行顺序(10100) < FILTER\_ORDER\_HTTPS\_2\_HTTP < FILTER\_ORDER\_GRAY (10110)。这里可以假定 FILTER\_ORDER\_HTTPS\_2\_HTTP = 10105。之所以需要加一个**Https2HttpFilter** 过滤器，是因为如果 https 请求直接进入到 **GrayLoadBalancerClientFilter** 会报 *NotSslRecordException* 证书错误。

### 2.2 | **Nacos** ###

Nacos 主要做一件事情：通过 metadata 维护灰度服务。

![d156bf5cb96c972a65cb824cd7a97f7a.png][]

从上图可以看出，metadata 里 gray-tag=true 的实例即为灰度服务的实例。

通过 webUI 的编辑按钮可以实时的新增修改 metadata。

那么，如何在代码侧配置呢？

可以直接在**bootstrap.yml**添加以下字段：

spring:
      cloud:
        nacos:
          discovery:
            metadata:
              # 如果${gray}变量不存在，则gray-tag=false
              gray-tag: ${gray:false} 
    复制代码

### 2.3 | **GitlabRunner** ###

gitlab-runner 主要是 **kube\_deploy.yml** 和 **.gitlab-ci.yml** 的一个联动配置

*  **kube\_deploy.yml**添加以下环境变量：

apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: ccc-deploy
      namespace: ccc
    spec:
      template:
        spec:
          containers: 
          - env:
              - name: gray
                value: "gray-tag" # 这里的gray-tag值 将会在在.gitlab-ci.yml的脚本中被替换
    复制代码

*  **.gitlab-ci.yml** 灰度服务部署 gitlab-runner 脚本关键部分：

...
    stages:
      - k8s-deploy
    k8s-deploy-gray-service:
      stage: k8s-deploy
      script:
        - echo "=============== 开始 k8s 部署任务 ==============="
        - sed -i "s/gray-tag/true/g" kube_deploy.yml # 这
        - kubectl apply -f kube_deploy.yml
      only:
        - /^tag_gray_.*$/
    k8s-deploy-normal-service:
      stage: k8s-deploy
      script:
        - echo "=============== 开始 k8s 部署任务 ==============="
        - sed -i "s/gray-tag/false/g" kube_deploy.yml # 这里替换 gray-tag 为 false
        - kubectl apply -f kube_deploy.yml
      only:
        - /^tag_normal_.*$/
     ...
    复制代码

此时，当打了一个以 `tag_gray_` 开头的 tag 之后，**kube\_deploy.yml**里的**gray-tag**就会被替换成 true，那么，nacos 的元数据上就会有一个**gray-tag=true**的标签，就会走灰度服务的发布流程。同理，以 `tag_normal_` 开头的 tag，就会走正常服务的发布流程。

把这段脚本嵌入到 pipeline 之后，就可以通过 tag 的方式，自动化部署灰度/正常服务了。

## 3 | **后续 TODO** ##

目前实现的是后端服务的灰度发布，一个完整的灰度，还包含了前端应用的灰度，后续会就前端的灰度发布再做一次整理。

## 4 | **使用版本说明** ##

**实战依赖版本**

<table> 
 <thead> 
  <tr> 
   <th>Group</th> 
   <th>Spring Cloud</th> 
   <th>Spring Cloud</th> 
   <th>Spring Cloud</th> 
   <th>Spring Cloud Alibaba Nacos</th> 
   <th>Spring Cloud Alibaba Nacos</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Component</td> 
   <td>Hoxton.SR3</td> 
   <td>Gateway</td> 
   <td>LoadBalancer</td> 
   <td>Config</td> 
   <td>Discovery</td> 
  </tr> 
  <tr> 
   <td>Version</td> 
   <td>-</td> 
   <td>2.2.2.RELEASE</td> 
   <td>2.2.2.RELEASE</td> 
   <td>2.2.5.RELEASE</td> 
   <td>2.2.5.RELEASE</td> 
  </tr> 
 </tbody> 
</table>

**需要注意的**

在 Spring Cloud 全家桶中，最初的网关使用的是 Netflix 的 Zuul 1x 版本，但是由于其性能问题，Spring Cloud 在苦等 Zuul 2x 版本未果的情况下，推出了自家的网关产品，取名叫 Spring Cloud Gateway （以下简称 SCG)，基于Webflux，通过底层封装Netty，实现异步IO，大大地提示了性能。

**Zuul 1x 版本**

本质上就是一个同步Servlet，采用多线程阻塞模型进行请求转发。简单讲，每来一个请求，Servlet容器要为该请求分配一个线程专门负责处理这个请求，直到响应返回客户端这个线程才会被释放返回容器线程池。如果后台服务调用比较耗时，那么这个线程就会被阻塞，阻塞期间线程资源被占用，不能干其它事情。我们知道Servlet容器线程池的大小是有限制的，当前端请求量大，而后台慢服务比较多时，很容易耗尽容器线程池内的线程，造成容器无法接受新的请求。且不支持任何长连接，如websocket

> **NOTE** 由于两个网关的底层架构不一致，负载均衡的逻辑也完全不一致，本文只探讨 Spring Cloud Gateway 配合 Nacos 来实现灰度发布（ Spring Cloud Zuul 网关的灰度发布不展开）。

至此，结合 **SpringCloudGateway + Nacos + GitlabRunner** 的全自动灰度服务搭建和发布实战全部完成。

作者：烂笔头  
链接：https://juejin.cn/post/7198126784763281466

[2f4b77ae32e2df443b133dbbf8f8d7d8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/5e3167730b39485894b5427cf4037291.png
[d156bf5cb96c972a65cb824cd7a97f7a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/1913684a71e54be3b19adf4dfe10b57f.png