springcloud gateway实现灰度发布

已于 2023-03-31 09:05:06 修改
阅读量1.3k 收藏 2
点赞数
文章标签： spring cloud gateway spring
于 2023-03-29 21:18:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38937840/article/details/129844559
版权

灰度发布

灰度发布（又名金丝雀发布）是指在黑与白之间，能够平滑过渡的一种发布方式。在其上可以进行A/B testing，即让一部分用户继续用产品特性A，一部分用户开始用产品特性B，如果用户对B没有什么反对意见，那么逐步扩大范围，把所有用户都迁移到B上面来。灰度发布可以保证整体系统的稳定，在初始灰度的时候就可以发现、调整问题，以保证其影响度。
灰度期：灰度发布开始到结束期间的这一段时间，称为灰度期。

更多介绍可以参考百度百科灰度发布

今天我将利用Spring Gateway 结合Nacos实现灰度发布

由于代码过多，这里只展示了关键信息，源代码地址以防在文末

创建项目

项目结构

  • api-server 需要灰度的app应用
  • gateway-server gateway 网管
  • nacos 注册中心

项目版本

    <properties>
        <youhuo.version>0.1-SNAPSHOT</youhuo.version>
        <spring.boot.version>2.7.8</spring.boot.version>
        <spring.cloud.version>2021.0.5</spring.cloud.version>
        <spring.cloud.alibaba.version>2021.0.4.0</spring.cloud.alibaba.version>
    </properties>

Gateway Server

灰度配置文件

@Data
// 动态刷新
@RefreshScope
@Configuration
@ConfigurationProperties(prefix = "server.gray")
public class ServerGrayProperty {

    /**
     * 生产的版本
     */
    private String proVersion;
    /**
     * 需要灰度的人员列表
     */
    private List<String> grayUsers;

    /**
     * 灰度的版本
     */
    private String grayVersion;

    /**
     * 权重
     */
    private Double weight;

    /**
     * 是否开启{@link GrayEnvLoadBalancer} 的方式进行灰度发布
     */
    private Boolean enable = true;
}

示例

server:
  gray:
    proVersion: 1
    enable: true
    grayUsers:  abc,ii,ss,kk,bb,pp
    grayVersion:  2

GrayEnvLoadBalancer

通过自定义的配置实现获取不同的路由选择

@RequiredArgsConstructor
@Slf4j
public class GrayEnvLoadBalancer implements ReactorServiceInstanceLoadBalancer {

    private ServerGrayProperty serverGrayProperty;
    /**
     * 用于获取 serviceId 对应的服务实例的列表
     */
    private final ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;
    /**
     * 需要获取的服务实例名
     * <p>
     * 暂时用于打印 logger 日志
     */
    private final String serviceId;

    @Override
    public Mono<Response<ServiceInstance>> choose(Request request) {
        // 获得 HttpHeaders 属性，实现从 header 中获取 version
        HttpHeaders headers = ((RequestDataContext) request.getContext()).getClientRequest().getHeaders();
        // 选择实例
        ServiceInstanceListSupplier supplier = serviceInstanceListSupplierProvider.getIfAvailable(NoopServiceInstanceListSupplier::new);
        return supplier.get(request).next().map(list -> getInstanceResponse(list, headers));
    }

    private Response<ServiceInstance> getInstanceResponse(List<ServiceInstance> instances, HttpHeaders headers) {
        // 如果服务实例为空，则直接返回
        if (CollUtil.isEmpty(instances)) {
            log.warn("[getInstanceResponse][serviceId({}) 服务实例列表为空]", serviceId);
            return new EmptyResponse();
        }
        // todo 这里获取可以根据等候的信息获取
        String userId = Objects.requireNonNull(headers.get("userId")).stream().findFirst().orElse("");
        // 筛选满足 version 条件的实例列表
        String version = serverGrayProperty.getGrayVersion();
        // 筛选满足 灰度的用户实例列表
        List<String> grayUsers = serverGrayProperty.getGrayUsers();
        List<ServiceInstance> chooseInstances;
        if (StrUtil.isEmpty(version) && !grayUsers.contains(userId)) {
            chooseInstances = instances;
        } else {
            // 选择满足条件的实例
            chooseInstances = filterList(instances, instance -> version.equals(instance.getMetadata().get("version")) && grayUsers.contains(userId));
            if (CollUtil.isEmpty(chooseInstances)) {
                log.warn("[getInstanceResponse][serviceId({}) 没有满足版本({})的服务实例列表，直接使用所有服务实例列表]", serviceId, version);
                chooseInstances = instances;
            }
        }

        // 基于 tag 过滤实例列表
        chooseInstances = filterTagServiceInstances(chooseInstances, headers);

        // 随机 + 权重获取实例列表
        return new DefaultResponse(NacosBalancer.getHostByRandomWeight3(chooseInstances));
    }


    /**
     * 基于 tag 请求头，过滤匹配 tag 的服务实例列表
     * <p>
     * copy from EnvLoadBalancerClient
     *
     * @param instances 服务实例列表
     * @param headers   请求头
     * @return 服务实例列表
     */
    private List<ServiceInstance> filterTagServiceInstances(List<ServiceInstance> instances, HttpHeaders headers) {
        // 情况一，没有 tag 时，直接返回
        String tag = EnvUtils.getTag(headers);
        if (StrUtil.isEmpty(tag)) {
            return instances;
        }

        // 情况二，有 tag 时，使用 tag 匹配服务实例
        List<ServiceInstance> chooseInstances = filterList(instances, instance -> tag.equals(EnvUtils.getTag(instance)));
        if (CollUtil.isEmpty(chooseInstances)) {
            log.warn("[filterTagServiceInstances][serviceId({}) 没有满足 tag({}) 的服务实例列表，直接使用所有服务实例列表]", serviceId, tag);
            chooseInstances = instances;
        }
        return chooseInstances;
    }

    public static <T> List<T> filterList(Collection<T> from, Predicate<T> predicate) {
        if (CollUtil.isEmpty(from)) {
            return new ArrayList<>();
        }
        return from.stream().filter(predicate).collect(Collectors.toList());
    }


    public void setServerGrayProperty(ServerGrayProperty serverGrayProperty) {
        this.serverGrayProperty = serverGrayProperty;
    }
}

GrayReactiveLoadBalancerClientFilter

@Component
@AllArgsConstructor
@Slf4j
@SuppressWarnings({"JavadocReference", "rawtypes", "unchecked", "ConstantConditions"})
public class GrayReactiveLoadBalancerClientFilter implements GlobalFilter, Ordered {

    private final LoadBalancerClientFactory clientFactory;

    private final GatewayLoadBalancerProperties properties;

    private final ServerGrayProperty serverGrayProperty;

    @Override
    public int getOrder() {
        return ReactiveLoadBalancerClientFilter.LOAD_BALANCER_CLIENT_FILTER_ORDER;
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        URI url = exchange.getAttribute(GATEWAY_REQUEST_URL_ATTR);
        String schemePrefix = exchange.getAttribute(GATEWAY_SCHEME_PREFIX_ATTR);
        // 将 lb 替换成 grayLb，表示灰度负载均衡
        if (url == null || (!"grayLb".equals(url.getScheme()) && !"grayLb".equals(schemePrefix))) {
            return chain.filter(exchange);
        }
        // preserve the original url
        addOriginalRequestUrl(exchange, url);

        if (log.isTraceEnabled()) {
            log.trace(ReactiveLoadBalancerClientFilter.class.getSimpleName() + " url before: " + url);
        }

        URI requestUri = exchange.getAttribute(GATEWAY_REQUEST_URL_ATTR);
        String serviceId = requestUri.getHost();
        Set<LoadBalancerLifecycle> supportedLifecycleProcessors = LoadBalancerLifecycleValidator
                .getSupportedLifecycleProcessors(clientFactory.getInstances(serviceId, LoadBalancerLifecycle.class),
                        RequestDataContext.class, ResponseData.class, ServiceInstance.class);
        DefaultRequest<RequestDataContext> lbRequest = new DefaultRequest<>(
                new RequestDataContext(new RequestData(exchange.getRequest()), getHint(serviceId)));
        return choose(lbRequest, serviceId, supportedLifecycleProcessors).doOnNext(response -> {

            if (!response.hasServer()) {
                supportedLifecycleProcessors.forEach(lifecycle -> lifecycle
                        .onComplete(new CompletionContext<>(CompletionContext.Status.DISCARD, lbRequest, response)));
                throw NotFoundException.create(properties.isUse404(), "Unable to find instance for " + url.getHost());
            }

            ServiceInstance retrievedInstance = response.getServer();

            URI uri = exchange.getRequest().getURI();

            // if the `lb:<scheme>` mechanism was used, use `<scheme>` as the default,
            // if the loadbalancer doesn't provide one.
            String overrideScheme = retrievedInstance.isSecure() ? "https" : "http";
            if (schemePrefix != null) {
                overrideScheme = url.getScheme();
            }

            DelegatingServiceInstance serviceInstance = new DelegatingServiceInstance(retrievedInstance,
                    overrideScheme);

            URI requestUrl = reconstructURI(serviceInstance, uri);

            if (log.isTraceEnabled()) {
                log.trace("LoadBalancerClientFilter url chosen: " + requestUrl);
            }
            exchange.getAttributes().put(GATEWAY_REQUEST_URL_ATTR, requestUrl);
            exchange.getAttributes().put(GATEWAY_LOADBALANCER_RESPONSE_ATTR, response);
            supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onStartRequest(lbRequest, response));
        }).then(chain.filter(exchange))
                .doOnError(throwable -> supportedLifecycleProcessors.forEach(lifecycle -> lifecycle
                        .onComplete(new CompletionContext<ResponseData, ServiceInstance, RequestDataContext>(
                                CompletionContext.Status.FAILED, throwable, lbRequest,
                                exchange.getAttribute(GATEWAY_LOADBALANCER_RESPONSE_ATTR)))))
                .doOnSuccess(aVoid -> supportedLifecycleProcessors.forEach(lifecycle -> lifecycle
                        .onComplete(new CompletionContext<ResponseData, ServiceInstance, RequestDataContext>(
                                CompletionContext.Status.SUCCESS, lbRequest,
                                exchange.getAttribute(GATEWAY_LOADBALANCER_RESPONSE_ATTR),
                                new ResponseData(exchange.getResponse(), new RequestData(exchange.getRequest()))))));
    }

    protected URI reconstructURI(ServiceInstance serviceInstance, URI original) {
        return LoadBalancerUriTools.reconstructURI(serviceInstance, original);
    }

    private Mono<Response<ServiceInstance>> choose(Request<RequestDataContext> lbRequest, String serviceId,
                                                   Set<LoadBalancerLifecycle> supportedLifecycleProcessors) {
        if (serverGrayProperty.getEnable()) {
            // 直接创建 GrayEnvLoadBalancer 对象
            GrayEnvLoadBalancer loadBalancer = new GrayEnvLoadBalancer(
                    clientFactory.getLazyProvider(serviceId, ServiceInstanceListSupplier.class), serviceId);
            loadBalancer.setServerGrayProperty(serverGrayProperty);
            supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onStart(lbRequest));
            return loadBalancer.choose(lbRequest);
        } else {
            // 直接创建 GrayLoadBalancer 对象
            GrayLoadBalancer loadBalancer = new GrayLoadBalancer(
                    clientFactory.getLazyProvider(serviceId, ServiceInstanceListSupplier.class), serviceId);
            supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onStart(lbRequest));
            return loadBalancer.choose(lbRequest);
        }
    }

    private String getHint(String serviceId) {
        LoadBalancerProperties loadBalancerProperties = clientFactory.getProperties(serviceId);
        Map<String, String> hints = loadBalancerProperties.getHint();
        String defaultHint = hints.getOrDefault("default", "default");
        String hintPropertyValue = hints.get(serviceId);
        return hintPropertyValue != null ? hintPropertyValue : defaultHint;
    }

}

这里我们就可以根据ServerGrayProperty配置的映射进行不灰度策略的实现

Api Server

一个简单的Springboot 项目，每次请求返回自己服务的端口号

@RestController
@RequestMapping(value = "/system/api/")
public class GraLbController {

    @Value("${server.port}")
    private Integer port;

    @GetMapping(value = "test")
    public String test() {
        return String.format("port=%s", port);
    }
}

需要启动两个项目，设置不同的端口号即可
在这里插入图片描述

Nacos配置

确定我们的服务已经注册到Nacos
在这里插入图片描述
修改api的元数据
在这里插入图片描述

{
	"preserved.register.source": "SPRING_CLOUD",
	"version": "2",
	"nacos.weight":10,
	"nacos.healthy":true,
	"name":"gray-api-01"
}

效果展示

不在访问列表里的用户持续访问原有生产版本

GET http://localhost:9080/system/api/test
userId: abc2

返回效果如下：

HTTP/1.1 200 OK
Vary: Origin
Vary: Access-Control-Request-Method
Vary: Access-Control-Request-Headers
Content-Type: text/plain;charset=UTF-8
Content-Length: 9
Date: Wed, 29 Mar 2023 13:03:47 GMT

port=9081

当用户出现在访问列表后将灰度到升级版本中

GET http://localhost:9080/system/api/test
userId: abc

返回效果如下：

HTTP/1.1 200 OK
Vary: Origin
Vary: Access-Control-Request-Method
Vary: Access-Control-Request-Headers
Content-Type: text/plain;charset=UTF-8
Content-Length: 9
Date: Wed, 29 Mar 2023 13:05:28 GMT

port=8092

如果有任何疑问，可以联系小编 372787553，小遍
大家如果想进入程序交流群，可以直接备注进群即可

源代码地址 https://github.com/yanghaiji/grayscale-publishing-demo 如果对您有所帮助记得 star哦

小杨同学~
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
SpringCloud Alibaba微服务实战三十三 - 集成灰度发布
飘渺Jam的博客
06-09 2627
大家好，我是飘渺Jam，一名来自三流城市三流公司的三流程序员，这是我们的第157篇原创文章，如果你喜欢请记得给我一个点赞与转发。 系列教程将会在流量降低时转为付费位置，流量多时将不会，各位抓紧时间学习哟~ 前言 这篇文章来源于粉丝提出的一个问题：如何解决多环境统一注册中心服务实例乱窜？ 怎么理解呢？ 假设现在开发环境的AccountService已经在Nacos中注册了，现在小张需要对它进行修改升级，本地启动AccountService后也注册到了Nacos，但是在调试的时候请求通过网关后经常直接跳转到.
万字硬核解析:Spring Cloud Alibaba-全链路灰度设计
wdj_yyds的博客
06-25 707
​ 自定义Spring MVC拦截器的目的是下游服务收到请求，通过拦截器检查HttpHeader中是否有灰度标记，如果有灰度标记那么就将灰度标记保存到Holder中，之后如果有后续的RPC调用同样的将灰度标记传递下去java复制代码// 如果HttpHeader中灰度标记为true，则将灰度标记放到holder中，如果需要就传递下去 if (gray!} }​ 配置拦截器：java复制代码。
springcloud微服务项目，通过gateway+nacos实现灰度发布(系统不停机升级)
君临天下tjm的博客
03-28 1766
在微服务系统中，原有系统不下线，新版系统与原有系统同时在线，通过访问权重在线实时配置，可以让少量用户先应用新版本功能，如果用户反馈存在问题，则下线新系统；如果反馈良好，则逐步加大新系统的分流权重，同时降低老系统的访问权重，直到新系统替换老系统，实现一种平滑的系统升级效果。"- Weight=group1, 1" ：配置访问权重，group1相同的为一组，组内的不同机器根据权重系数"1"，计算分流权重，权重越大，被访问几率越大。
Spring Cloud Gateway实现灰度发布功能
热门推荐
sslulu520的博客
07-07 1万+
灰度发布又名金丝雀发布，在微服务中的表现为同一服务同时上线不同版本，让一部分用户使用新版本来验证新特性，如果验证没有问题，则将所有用户都迁移到新版本上。 在微服务架构中，网关负责请求的统一入口，主要功能之一是请求路由。而灰度发布实质就是让指定用户路由到指定版本的服务上。所以该功能可以在网关这一层实现。 今天就分享下Spring Cloud Gateway如何实现灰度发布。 1 Spring Cloud Gateway的路由逻辑 既然要让指定用户路由到指定服务版本，我们需要先了解Spring Cloud Ga
【java】基于springCloud的灰度发布
m0_73427585的博客
05-31 787
单体项目包含多个模块，任意模块的修改都需要对整个项目进行编译、打包和部署简单来说就是，发布比较简单，但是耦合性比较高，出现问题需要整体项目打包。
springclooud灰度路由
a435656923的博客
03-03 1363
springcloud灰度路由网关gateway和feign的使用方式
基于Spring Gateway路由判断器实现各种灰度发布场景
penngo的专栏
08-26 1038
基于Spring Gateway路由判断器实现各种灰度发布场景
基于springCloud的灰度发布源码文件
最新发布
05-31
Spring Cloud Gateway 基于服务发现路由定位 基于 Filter 链（定义过滤器对请求过滤）提供了网关基本的功能，例如：鉴权、流量控制、熔断、路径重写、日志监控等。 Spring Cloud Ribbon 基于http和tcp的客户端负载...
SpringCloud-grayRelease:整合nacos（Euraka）实现灰度发布
05-26
SpringCloud-grayRelease整合nacos（Euraka 类似）实现灰度发布在一般情况下，升级服务器端应用，需要将应用源码或程序包上传到服务器，然后停止掉老版本服务，再启动新版本。但是这种简单的发布方式存在两个问题，...
springboot整合nacos和spring cloud gateway
07-11
在现代微服务架构中，Spring Boot、Nacos和Spring Cloud Gateway是重要的...在实际项目中，还可以根据需求进一步定制Nacos的配置中心功能，比如实现动态配置、健康检查、灰度发布等功能，以满足复杂的企业级应用场景。
基于Nacos元数据实现灰度发布，可以按照最小粒度灰度发布
08-17
{"idDeptSign":"040101","ip":"192.168.1.2","springCloud":"register"} 前端请求头设置参数publicParam {"idDeptSign":"040101","ip":"192.168.1.2","idEmp":"12342134"} idDeptSign和ip值都相等，则会有灰度...
SpringCloud系列之API Gateway开发手册（Hoxton版本）.pdf
11-20
SpringCloud系列之API Gateway开发手册（Hoxton版本）.pdf，这是一份基于SpringBoot2.x版本，SpringCloud Hoxton版本的入门教程，适合做入门教程，仅供学习参考
springcloud灰度发布方案
11-22
springcloud灰度发布方案。包含网关、服务间调用灰度发布代码。详情请参考博客：https://blog.csdn.net/han949417140/article/details/121420529
SpringCloud Zuul网关功能实现解析
08-19
SpringCloud Zuul网关功能实现解析 SpringCloud Zuul网关功能实现解析是基于 SpringCloud 生态系统的微服务架构中的一种网关解决方案。 Zuul 是 Netflix 公司开源的一个基于 Java 的 API Gateway 项目，旨在提供一...
全自动灰度服务搭建和发布实战 | SpringCloudGateway + Nacos + GitlabRunner
BASK2311的博客
02-11 1353
在 Spring Cloud 全家桶中，最初的网关使用的是 Netflix 的 Zuul 1x 版本，但是由于其性能问题，Spring Cloud 在苦等 Zuul 2x 版本未果的情况下，推出了自家的网关产品，取名叫 Spring Cloud Gateway （以下简称 SCG)，基于Webflux，通过底层封装Netty，实现异步IO，大大地提示了性能。目前实现的是后端服务的灰度发布，一个完整的灰度，还包含了前端应用的灰度，后续会就前端的灰度发布再做一次整理。的标签，就会走灰度服务的发布流程。
Objects.requireNonNull( )方法说明
qq_43842093的博客
05-31 5391
Objects.requireNonNull( )方法在java.util.Objects中 作用就是判断一个对象是否为空 底层源码： /* @param obj 需要检测是否为空的对象 * @param <T> 对象类型 * @return 对象不为空则返回该对象 * @throws 对象为空则报NullPointerException异常 */ public static <T> T requireNonNull(T obj) {
关于SpringCloud中灰度路由的使用
ABestRookie的博客
11-25 2533
关于SpringCloud中灰度路由的使用1 灰度路由的简介2 灰度路由的使用案列基础服务父服务工具服务业务服务client服务consumer1服务consumer2服务provider1服务provider2服务验证测试1 启动本地nacos服务2 启动五个项目服务3 使用postman进行测试 在微服务中, 通常为了高可用, 同一个服务往往采用集群方式部署, 即同时存在几个相同的服务,而灰度的核心就 是路由, 通过我们特定的策略去调用目标服务线路 1 灰度路由的简介 灰度发布（又名金丝雀发布）是指
SpringCloudGateway实现灰度发布，结合nacos支持不同服务配置不同灰度版本及灰度权重（概率）
BruceChao5211的博客
04-24 2495
网上查看现有的一些实现gateway灰度发布的博客，一般都是使用过滤器、拦截器等，过于复杂，而且不够灵活，索性自己研究一下gateway，发现可以通过 AbstractLoadBalancerRule 实现，下面是我实现的一套灵活一些的灰度发布策略。 首先gateway的配置文件如下（可以配置到nacos中）： # 服务灰度发布配置 server: gray: config: # producer服务 producer: # 需要灰度发布的版本
Spring Cloud 全链路灰度发布方案
959
06-05 740
如果实际生产有需求变更的话, 不会立刻在线上服务修改, 而是会切成一小部分流量进行修改测试。经过测试后无问题则全面的上线。 文章目录1.什么是灰度发布2.什么是全链路灰度发布3.网关层的灰度路由转发4.openFeign透传灰度标记5.Nacos中服务如何做灰度标记6.总结 1.什么是灰度发布 灰度发布（又名金丝雀发布）是指在黑与白之间，能够平滑过渡的一种发布方式。在上面可以进行A/B测试, 即让一部分用户继续用产品特性A, 一部分用户使用产品特性B, 如果用户B没有反对意见的话, 那么会逐渐扩大范围, 把
SpringCloud中怎么配合nacos实现动态路由和灰度发布
07-12
在Spring Cloud中，可以使用Nacos作为服务发现和配置中心，并结合Spring Cloud Gateway来实现动态路由和灰度发布。 下面是一些步骤来配合Nacos实现动态路由和灰度发布： 1. 引入依赖：在项目的pom.xml文件中添加...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小杨同学~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值