AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

初探灰度发布系列--AB Test以及栗子

2022-06-20 531
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
网络型负载均衡 NLB，每月750个小时 15LCU
传统型负载均衡 CLB，每月750个小时 15LCU
应用型负载均衡 ALB，每月750个小时 15LCU
简介： 灰度发布分几种：蓝绿、ABTest以及金丝雀灰度作用：为了减少灰度版本对生产环境的影响

灰度发布

灰度发布分几种：蓝绿、ABTest以及金丝雀
灰度作用：为了减少灰度版本对生产环境的影响

灰度策略 内容 缺点
蓝绿 会有两套环境，灰度发布之后，流量从绿切到蓝，然后进行验证 环境比较浪费，而且生产直接路由到灰度版本
ABTest 在网关层对不同用户进行路由，只有特定用户切流量到灰度版本，这样的话不会影响生产用户 相对流量权重比较复杂，需要对用户进行区分对待
金丝雀 将部分流量切换过去，然后进行验证灰度的准确性，如果没有问题则流量全部切换 还是那个生产用户直接测试灰度版本

AB Test实践

逻辑架构图

在这里插入图片描述
这是第一版本，我们实现一个自定义loadBalance，filter拿到对应header头，或者说被动打标，通过不同的域名，来进行路由
流量路由的时候，基于nacos注册服务里面metaData标识，来决定路由到哪台服务
灰度测试完之后滚动更新生产pod

这个是外部访问内部，内部怎么访问外部？

fegin或者http请求，灰度版本服务通过域名来访问
dubbo请求，本身也有负载均衡器，需要拿到对应的标识，比如说版本号来负载

进阶第二版
在第一版我们自定义了loadBalance，以及路由标识，比如说网关配置lb:xxx，为啥是lb开头，大家可以看下ReactiveLoadBalancerClientFilter源码，我们其实是需要定义另一种标识
那么问题来了，当灰度测试完之后，负载怎么换成正常的lb？

这个涉及到网关route动态配置，publushEvent即可（这个不在本章介绍）

实现demo

参照另一篇文章

GrayGatewayReactiveLoadBalancerClientAutoConfiguration

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.cloud.client.loadbalancer.LoadBalancerProperties;
import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author javachen
 * @description GrayGatewayReactiveLoadBalancerClientAutoConfiguration
 */
@Configuration
public class GrayGatewayReactiveLoadBalancerClientAutoConfiguration {

    public GrayGatewayReactiveLoadBalancerClientAutoConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean({GrayReactiveLoadBalancerClientFilter.class})
    public GrayReactiveLoadBalancerClientFilter grayReactiveLoadBalancerClientFilter(LoadBalancerClientFactory clientFactory, LoadBalancerProperties properties) {
        return new GrayReactiveLoadBalancerClientFilter(clientFactory, properties);
    }

}

GrayLoadBalancer

import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.DefaultResponse;
import org.springframework.cloud.client.loadbalancer.EmptyResponse;
import org.springframework.cloud.client.loadbalancer.Request;
import org.springframework.cloud.client.loadbalancer.Response;
import org.springframework.cloud.loadbalancer.core.NoopServiceInstanceListSupplier;
import org.springframework.cloud.loadbalancer.core.ReactorServiceInstanceLoadBalancer;
import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
import org.springframework.http.HttpHeaders;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.util.*;

/**
 * @author javachen
 * @description GrayReactiveLoadBalancerClientFilter
 */
public class GrayLoadBalancer implements ReactorServiceInstanceLoadBalancer {

    private static final Log log = LogFactory.getLog(GrayLoadBalancer.class);
    private ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;
    private  String serviceId;

    public GrayLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider, String serviceId) {
        this.serviceId = serviceId;
        this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;
    }

    @Override
    public Mono<Response<ServiceInstance>> choose(Request request) {
        HttpHeaders headers = (HttpHeaders) request.getContext();
        if (this.serviceInstanceListSupplierProvider != null) {
            ServiceInstanceListSupplier supplier = (ServiceInstanceListSupplier)this.serviceInstanceListSupplierProvider.getIfAvailable(NoopServiceInstanceListSupplier::new);
            return ((Flux)supplier.get()).next().map(list->getInstanceResponse((List<ServiceInstance>)list,headers));
        }

        return null;
    }

    private Response<ServiceInstance> getInstanceResponse(List<ServiceInstance> instances, HttpHeaders headers) {
        if (instances.isEmpty()) {
            return getServiceInstanceEmptyResponse();
        } else {
            return getServiceInstanceResponseWithWeight(instances);
        }
    }

    /**
     * 根据版本进行分发
     * @param instances
     * @param headers
     * @return
     */
    private Response<ServiceInstance> getServiceInstanceResponseByVersion(List<ServiceInstance> instances, HttpHeaders headers) {
        String versionNo = headers.getFirst("version");
        //System.out.println(versionNo);
        Map<String,String> versionMap = new HashMap<>();
        versionMap.put("version",versionNo);
        final Set<Map.Entry<String,String>> attributes =
                Collections.unmodifiableSet(versionMap.entrySet());
        ServiceInstance serviceInstance = null;
        for (ServiceInstance instance : instances) {
            Map<String,String> metadata = instance.getMetadata();
            if(metadata.entrySet().containsAll(attributes)){
                serviceInstance = instance;
                break;
            }
        }

        if(ObjectUtils.isEmpty(serviceInstance)){
            return getServiceInstanceEmptyResponse();
        }
        return new DefaultResponse(serviceInstance);
    }

    /**
     *
     * 根据在nacos中配置的权重值，进行分发
     * @param instances
     *
     * @return
     */
    private Response<ServiceInstance> getServiceInstanceResponseWithWeight(List<ServiceInstance> instances) {
        Map<ServiceInstance,Integer> weightMap = new HashMap<>();
        for (ServiceInstance instance : instances) {
            Map<String,String> metadata = instance.getMetadata();
            //System.out.println(metadata.get("version")+"-->weight:"+metadata.get("weight"));
            if(metadata.containsKey("gray")){
                weightMap.put(instance,1000);
            }else {
                weightMap.put(instance,1);
            }
        }
        WeightMeta<ServiceInstance> weightMeta = WeightRandomUtils.buildWeightMeta(weightMap);
        if(ObjectUtils.isEmpty(weightMeta)){
            return getServiceInstanceEmptyResponse();
        }
        ServiceInstance serviceInstance = weightMeta.random();
        if(ObjectUtils.isEmpty(serviceInstance)){
            return getServiceInstanceEmptyResponse();
        }
        return new DefaultResponse(serviceInstance);
    }

    private Response<ServiceInstance> getServiceInstanceEmptyResponse() {
        log.warn("No servers available for service: " + this.serviceId);
        return new EmptyResponse();
    }
}

GrayReactiveLoadBalancerClientFilter

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.*;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.cloud.gateway.filter.ReactiveLoadBalancerClientFilter;
import org.springframework.cloud.gateway.support.DelegatingServiceInstance;
import org.springframework.cloud.gateway.support.NotFoundException;
import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;
import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
import org.springframework.core.Ordered;
import org.springframework.http.HttpHeaders;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import javax.servlet.http.HttpServletRequest;
import java.net.URI;

/**
 * @author javachen
 * @description GrayReactiveLoadBalancerClientFilter
 */
public class GrayReactiveLoadBalancerClientFilter implements GlobalFilter, Ordered {

    private static final Log log = LogFactory.getLog(ReactiveLoadBalancerClientFilter.class);
    private static final int LOAD_BALANCER_CLIENT_FILTER_ORDER = 10150;
    private final LoadBalancerClientFactory clientFactory;
    private LoadBalancerProperties properties;

    public GrayReactiveLoadBalancerClientFilter(LoadBalancerClientFactory clientFactory, LoadBalancerProperties properties) {
        this.clientFactory = clientFactory;
        this.properties = properties;
    }

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

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

        URI url = (URI)exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);
        String schemePrefix = (String)exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_SCHEME_PREFIX_ATTR);
        if (url != null && ("grayLb".equals(url.getScheme()) || "grayLb".equals(schemePrefix))) {
            ServerWebExchangeUtils.addOriginalRequestUrl(exchange, url);
            if (log.isTraceEnabled()) {
                log.trace(ReactiveLoadBalancerClientFilter.class.getSimpleName() + " url before: " + url);
            }

            return this.choose(exchange).doOnNext((response) -> {
                if (!response.hasServer()) {
                    throw NotFoundException.create(true, "Unable to find instance for " + url.getHost());
                } else {
                    URI uri = exchange.getRequest().getURI();
                    String overrideScheme = null;
                    if (schemePrefix != null) {
                        overrideScheme = url.getScheme();
                    }

                    DelegatingServiceInstance serviceInstance = new DelegatingServiceInstance((ServiceInstance)response.getServer(), overrideScheme);
                    URI requestUrl = this.reconstructURI(serviceInstance, uri);
                    if (log.isTraceEnabled()) {
                        log.trace("LoadBalancerClientFilter url chosen: " + requestUrl);
                    }

                    exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR, requestUrl);
                }
            }).then(chain.filter(exchange));
        } else {
            return chain.filter(exchange);
        }
    }

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

    private Mono<Response<ServiceInstance>> choose(ServerWebExchange exchange) {
        URI uri = (URI)exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);
        GrayLoadBalancer loadBalancer = new GrayLoadBalancer(clientFactory.getLazyProvider(uri.getHost(), ServiceInstanceListSupplier.class), uri.getHost());
        if (loadBalancer == null) {
            throw new NotFoundException("No loadbalancer available for " + uri.getHost());
        } else {
            return loadBalancer.choose(this.createRequest(exchange));
        }
    }

    private Request createRequest(ServerWebExchange exchange) {
        HttpHeaders headers = exchange.getRequest().getHeaders();
        Request<HttpHeaders> request = new DefaultRequest<>(headers);
        return request;
    }

}

WeightMeta

import java.util.Arrays;
import java.util.Random;

/**
 * @author javachen
 * @description 权重元数据对象
 */
public class WeightMeta<T> {
    private final Random ran = new Random();
    private final T[] nodes;
    private final int[] weights;
    private final int maxW;

    public WeightMeta(T[] nodes, int[] weights) {
        this.nodes = nodes;
        this.weights = weights;
        this.maxW = weights[weights.length - 1];
    }

    /**
     * 该方法返回权重随机对象
     * @return
     */
    public T random() {
        int index = Arrays.binarySearch(weights, ran.nextInt(maxW) + 1);
        if (index < 0) {
            index = -1 - index;
        }
        return nodes[index];
    }

    public T random(int ranInt) {
        if (ranInt > maxW) {
            ranInt = maxW;
        } else if(ranInt < 0){
            ranInt = 1;
        } else {
            ranInt ++;
        }
        int index = Arrays.binarySearch(weights, ranInt);
        if (index < 0) {
            index = -1 - index;
        }
        return nodes[index];
    }

    @Override
    public String toString() {
        StringBuilder l1 = new StringBuilder();
        StringBuilder l2 = new StringBuilder("[random]\t");
        StringBuilder l3 = new StringBuilder("[node]\t\t");
        l1.append(this.getClass().getName()).append(":").append(this.hashCode()).append(":\n").append("[index]\t\t");
        for (int i = 0; i < weights.length; i++) {
            l1.append(i).append("\t");
            l2.append(weights[i]).append("\t");
            l3.append(nodes[i]).append("\t");
        }
        l1.append("\n");
        l2.append("\n");
        l3.append("\n");
        return l1.append(l2).append(l3).toString();
    }
}

WeightRandomUtils

import java.util.HashMap;
import java.util.Map;

/**
 * 　权重算法取自：@see https://www.ctolib.com/topics-61571.html
 *
 * 随机工具类
 *
 * 使用权重的集合Map构建随机元数据对象
 *
 * 比如：
 * 我们有3个url地址，他们的权重分别为1,2,3现在我们利用RandomUtil来根据权重随机获取url：
 *
 * <p><blockquote><pre>
 *
 * map.put(url1, 1);
 * map.put(url2, 2);
 * map.put(url3, 3);
 * RandomMeta<String, Integer> md = WeightRandomUtils.buildWeightMeta(map);
 * String weightRandomUrl = md.random();
 *
 * </pre></blockquote><p>
 *
 *
 */
public class WeightRandomUtils {
    public static <T> WeightMeta<T> buildWeightMeta(final Map<T, Integer> weightMap) {
        if(weightMap.isEmpty()){
            return null;
        }
        final int size = weightMap.size();
        Object[] nodes = new Object[size];
        int[] weights = new int[size];
        int index = 0;
        int weightAdder = 0;
        for (Map.Entry<T, Integer> each : weightMap.entrySet()) {
            nodes[index] = each.getKey();
            weights[index++] = (weightAdder = weightAdder + each.getValue());
        }
        return new WeightMeta<T>((T[]) nodes, weights);
    }

    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();
        map.put("v1",1);
        map.put("v2",2);
        WeightMeta<String> nodes = WeightRandomUtils.buildWeightMeta(map);
        for(int i = 0; i < 10; i++){
            new Thread(()->{
                System.out.println(nodes.random());
            }).start();
        }

    }
}

解析

可以参照ReactiveLoadBalancerClientFilter，RoundRobinLoadBalancer
就是里面会调用choose方法来进行负载

关键修改点

GrayLoadBalancer
在这里插入图片描述
启动这个，根据用户header以及访问host域名来触发

实践

nacos 两个实例，不同版本，元数据
在这里插入图片描述
postman带上特定标识，调接口的时候会发现进入了灰度版本

优化点

灰度测试后，不改负载也可以，最好是可以改回正常的负载

所以进行网关路由的动态配置，有很多实现方法

ReactiveLoadBalancerClientFilter源码

  1. GlobalFilter, Ordered ReactiveLoadBalancerClientFilter实现这两个类，搞过网关（网关是谁）的都知道，这两就是过滤器+排序
  2. 为啥网关配置是按lb开头？

在这里插入图片描述

  1. 关键点，是在choose方法，ReactorLoadBalancer负载算法，决定要路由到哪台机器

在这里插入图片描述

  1. ReactorLoadBalancer源码 （RoundRobinLoadBalancer实现类）

在这里插入图片描述

  1. 路由算法（这就是为啥前面我们会实现GrayLoadBalancer，WeightRandomUtils，就是仿造之前的RoundRobinLoadBalancer）

在这里插入图片描述

文章标签：
负载均衡
Perl
测试技术
应用服务中间件
数据处理
Dubbo
Nacos
算法
相关实践学习
SLB负载均衡实践
本场景通过使用阿里云负载均衡 SLB 以及对负载均衡 SLB 后端服务器 ECS 的权重进行修改，快速解决服务器响应速度慢的问题
负载均衡入门与产品使用指南
负载均衡（Server Load Balancer）是对多台云服务器进行流量分发的负载均衡服务，可以通过流量分发扩展应用系统对外的服务能力，通过消除单点故障提升应用系统的可用性。 本课程主要介绍负载均衡的相关技术以及阿里云负载均衡产品的使用方法。
大鸡腿同学
目录
相关文章
爱你三千遍斯塔克
|
6月前
rm用于文件和文件夹的删除，rm里可以接收参数1，-r表示可以删除目录，-f表示强制删除,通配符*匹配任意内容，test*以test开头,*test以test结尾，*test*匹配任何包含test内容
rm用于文件和文件夹的删除，rm里可以接收参数1，-r表示可以删除目录，-f表示强制删除,通配符*匹配任意内容，test*以test开头,*test以test结尾，*test*匹配任何包含test内容
爱你三千遍斯塔克
37 0
一只大鸽子
|
7月前
1043 输出PATest （20 分）
1043 输出PATest （20 分）
一只大鸽子
24 0
龙腾九州
|
8月前
|
机器学习/深度学习 Shell 开发工具
利用 test命令的测试功能
【1月更文挑战第4天】利用 test命令的测试功能。
龙腾九州
90 4
天眼数聚
|
机器学习/深度学习 数据采集 算法
AB Test如何应用于风控场景？
AB Test是一个很好的导航系统和说理工具，策略分析师在各个场景使用这种分析方法，可以形成一个完整的闭环;本文作者分享了关于AB Test如何应用于风控场景，我们一起来看一下。
天眼数聚
848 0
游客jxtcv3on3n4ym
|
存储 Java 索引
--测试 集合==文章====测试
一些关于集合的基本概念
游客jxtcv3on3n4ym
74 0
KookNut39
|
C++ 容器
set以及使用举例--C++基础
set以及使用举例--C++基础
KookNut39
153 0
set以及使用举例--C++基础
mia26jtrojklq
|
C语言 C++
1043 输出PATest (20 分)
给定一个长度不超过 104 的、仅由英文字母构成的字符串。请将字符重新调整顺序，按 PATestPATest.... 这样的顺序输出，并忽略其它字符。当然，六种字符的个数不一定是一样多的，若某种字符已经输出完，则余下的字符仍按 PATest 的顺序打印，直到所有字符都被输出。
mia26jtrojklq
99 0
kollpdcgpqxpi
|
DataWorks 搜索推荐 测试技术
召奴的大哉问系列：B2B 是否要做AB Test
AB Testing在软体工程领域是一个耳熟能详的词，大家都知道AB Test的重要性。当产品经理提出的需求不合里（太难做）时，程序员们心理总是os，你怎么知道客户到底要什么，不也是拍脑袋想的吗，这时候我们可能会提出另一种作法，并要求他（她）去做一个AB Test来验证哪一个作法更好。 但是，大家可能不知道，要做一个成功的AB Test实验，它背后的成本是非常巨大的。首先，你必须做许多的分析，了
kollpdcgpqxpi
1038 0
召奴的大哉问系列：B2B 是否要做AB Test
技术小胖子
|
测试技术 API C#
测试：VS2010的Coded UI Test参考内容列表
技术小胖子
1510 0
橘子红了呐
|
测试技术 C# Windows
CodeUI Test：创建第一个CodeUI Test
橘子红了呐
1135 0

热门文章

最新文章

  • 1
    为什么说流处理即未来？
  • 2
    【实战】锐捷AC+AP配置WLAN基本服务系列
  • 3
    Mac：安装Python3并配置环境变量（本地多个Python版本选择配置）
  • 4
    丰富、连接、待集成—MaxCompute 生态再出发
  • 5
    Tomcat 7.0 64位免安装解压版 安装及配置
  • 6
    securecrt克隆会话与sshd 的 MaxSessions
  • 7
    C语言结构体的使用！简易学生成绩统计程序发布！
  • 8
    《VMware Virtual SAN权威指南》一2.2　VSAN的要求
  • 9
    webstorm9.0.3 注册码
  • 10
    数据文件offline后unusable索引造成的问题
  • 1
    LangGraph：构建多代理动态工作流的开源框架，支持人工干预、循环、持久性等复杂工作流自动化
    27
  • 2
    Eliza：TypeScript 版开源 AI Agent 开发框架，快速搭建智能、个性的 Agents 系统
    25
  • 3
    AI Dev Gallery：微软开源 Windows AI 模型本地运行工具包和示例库，助理开发者快速集成 AI 功能
    33
  • 4
    「Mac畅玩鸿蒙与硬件51」UI互动应用篇28 - 模拟记账应用
    100
  • 5
    我的博客年度之旅：感恩、成长与展望
    87
  • 6
    《构建高效K近邻算法：降低计算复杂度的策略与实践》
    24
  • 7
    《提升支持向量机泛化能力：核函数改进策略大揭秘》
    16
  • 8
    《智能算法设计与开发的全解析：从理念到实践》
    20
  • 9
    《深度学习梯度消失问题：原因与解决之道》
    21
  • 10
    《docker基础篇：8.Docker常规安装简介》包括：docker常规安装总体步骤、安装tomcat、安装mysql、安装redis
    17

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月