开发者

SpringCloudGateway Nacos GitlabRunner全自动灰度服务搭建发布

目录
  • 1 | 业务场景说明
  • 2 | 具体实现方案
    • 2.1 | SCG
    • 2.2 | Nacos
    • 2.3 | GitlabRunner
  • 3 | 后续 TODO
    • 4 | 使用版本说明

      1 | 业务场景说明

      要实现的业务场景:

      • 可以根据单个用户id或者批量用户id,判断是否需要灰度该用户/批量用户
      • 可以根据请求头字段(可动态设定的任意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;
          }
      python}
      

      NOTE

      FILTER_ORDER_GRAY 是一个 int 常量,其值不能随意定义(如-1,0,1,2之类)。从下表可以看到,SCG 的 LoadBalancerClientFilter 执行顺序是 10100,那么 GrayLoadBalancerClientFilter 的执行顺序必须 > 10100 (否则自定义的 Filter 里就会有变量未被赋值), 这里假定 FILTER_ORDER_GRAY = 10110

      SpringCloudGateway Nacos GitlabRunner全自动灰度服务搭建发布

      • 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编程客栈获取服务实例列表,并根据策略返回灰度服务的实例还是正常服务的实例
           */
          p开发者_JAVA入门rivate Response<ServiceInstance> getServiceInstanceResponseByUidsOrGrayTag(List<ServiceInstance> instances, HttpHeaders headers) {
              List<ServiceInstance> grayInstances = new ArrayList<>();
              List<ServiceInstance> normalInstances = new ArrayList<>();
              for (ServiceInstance instance : instances) {
            php      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 errorwww.devze.com");
                  }
              }
              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 维护灰度服务。

      SpringCloudGateway Nacos GitlabRunner全自动灰度服务搭建发布

      从上图可以看出,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 | 使用版本说明

      实战依赖版本

      GroupSpring CloudSpring CloudSpring CloudSpring Cloud Alibaba NacosSpring Cloud Alibaba Nacos
      ComponentHoxton.SR3GatewayLoadBalancerConfigDiscovery
      Version-2.2.2.RELEASE2.2.2.RELEASE2.2.5.RELEASE2.2.5.RELEASE

      需要注意的

      在 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 的全自动灰度服务搭建和发布实战全部完成。

      以上就是SpringCloudGateway Nacos GitlabRunner的详细内容,更多关于SpringCloudGateway Nacos GitlabRunner的资料请关注我们其它相关文章!

      0

      上一篇:

      下一篇:

      精彩评论

      暂无评论...
      验证码 换一张
      取 消

      最新开发

      开发排行榜