一、灰度发布

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

灰度发布开始到结束期间的这一段时间，称为灰度期。灰度发布能及早获得用户的意见反馈，完善产品功能，提升产品质量，让用户参与产品测试，加强与用户互动，降低产品升级所影响的用户范围。

下面基于 GateWay 和 Nacos 实现微服务架构灰度发布方案，首先对生产的服务和灰度环境的服务统一注册到 Nacos 中，但是版本不同，比如生产环境版本为 1.0 ，灰度环境版本为 2.0 ，请求经过网关后，判断携带的用户是否为灰度用户，如果是将请求转发至 2.0 的服务中，否则转发到 1.0 的服务中。

二、开始实施

首先搭建两个web服务模拟生产和灰度环境，分别注册到nacos 中，注意这里服务ID 要一致：

生产环境配置：

spring:
  application:
    name: web
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
        metadata:
          version: 1.0 # 指定版本号

灰度环境配置：

spring:
  application:
    name: web
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
        metadata:
          version: 2.0 # 指定版本号

启动两个服务后，可以在nacos 中查看详情：

下面为了模拟两个服务的差异性，创建相同的接口，不同的返回：

@RestController
public class TestController {

    @GetMapping("/getTest")
    public String getTest(){
        return "当前处于-生产环境！";
    }
}

@RestController
public class TestController {

    @GetMapping("/getTest")
    public String getTest(){
        return "当前处于-灰度环境！";
    }
}

下面开始搭建 GateWay 网关，同样需要注册到 nacos 中，但是和以前不同的是，这里我们要实现一个负载均衡器，在负载均衡器中判断是否使用哪个版本的服务，这里为了演示效果，在nacos 中新建一个配置文件，将灰度用户配置在这个配置文件中，在项目中应该从 db 或 noSQL 中进行获取。

Data ID： env-config.yaml
Group: DEFAULT_GROUP

env:
  gray:
    version: 2.0
    users: abc,ii,ss,kk,bb,pp
  pro:
    version: 1.0

再增加一个 GateWay 路由的配置：

Data ID：gateway.yaml
Group: DEFAULT_GROUP

spring:
  cloud:
    gateway:
      httpclient:
        connect-timeout: 2000
        response-timeout: 10s
      routes:
        - id: web
          uri: lb://web/
          order: 0
          predicates:
            - Path=/web/**
          filters:
            - StripPrefix=1 # 去除请求地址中的前缀

下面搭建 gateway 网关服务，注册到 nacos 中，并加载上面创建的配置文件：

spring:
  application:
    name: gateway
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
      config:
        server-addr: 127.0.0.1:8848
        file-extension: yaml
        refresh-enabled: true
        extension-configs[0]:
          data-id: env-config.yaml
          group: DEFAULT_GROUP
          refresh: true

启动后，查看下是否已经注册到 nacos 中了：

测试下是否可以负载转发：

已经实现了负载效果，但是还没有达到我们想要的效果，下面开始对 gateway 网关进行修改。

首先我们新建一个 EnvProperties 来接收 env-config.yaml 中的配置，注意一定要加 @RefreshScope 注解，这样才能修改配置后通知到相应的服务：

@Data
@Configuration
@RefreshScope
public class EnvProperties {
    @Value("${env.pro.version}")
    private String proVersion;

    @Value("${env.gray.users}")
    private List<String> grayUsers;

    @Value("${env.gray.version}")
    private String grayVersion;
}

在创建一个 ThreadLocal ，存储当前的版本信息，这里先记下来，后面就知道什么作用了：

public class GrayscaleThreadLocalEnvironment {
    private static ThreadLocal<String> threadLocal = new ThreadLocal<String>();
    
    public static void setCurrentEnvironment(String currentEnvironmentVsersion) {
        threadLocal.set(currentEnvironmentVsersion);
    }
    
    public static String getCurrentEnvironment() {
        return threadLocal.get();
    }
}

下面创建 过滤器 对请求进行拦截，然后获取到用户的信息，这里就默认用户ID 在 header 中，key 为 userId，取到之后判断是否在 灰度用户列表中，如果存在就把当前的 ThreadLocal（就是上面声明的ThreadLocal ） 中存储灰度的版本号，，否则就为生产的版本号：

@Component
@RefreshScope
public class GrayscaleGlobalFilter implements GlobalFilter, Ordered {

    @Autowired
    EnvProperties envProperties;

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();
        HttpHeaders header = response.getHeaders();
        header.add("Content-Type", "application/json; charset=UTF-8");

        List<String> list = request.getHeaders().get("userId");
        if (Objects.isNull(list) || list.isEmpty()) {
            return resultErrorMsg(response," 缺少userId！");
        }
        String userId = list.get(0);
        if (StringUtils.isBlank(userId)) {
            return resultErrorMsg(response," 缺少userId！");
        }
        if (envProperties.getGrayUsers().contains(userId)) {
            //指定灰度版本
            GrayscaleThreadLocalEnvironment.setCurrentEnvironment(envProperties.getGrayVersion());
        } else {
            //指定生产版本
            GrayscaleThreadLocalEnvironment.setCurrentEnvironment(envProperties.getProVersion());
        }
        return chain.filter(exchange.mutate().request(request).build());
    }

    public int getOrder() {
        return -1;
    }

    private Mono<Void> resultErrorMsg(ServerHttpResponse response, String msg) {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("code", "403");
        jsonObject.put("message", msg);
        DataBuffer buffer = response.bufferFactory().wrap(jsonObject.toJSONString().getBytes());
        return response.writeWith(Mono.just(buffer));
    }
}

上面的过滤器已经标识出当前请求属于灰度还是生产，下面就需要我们重写Ribbon 负载均衡器，这里重写的 RoundRobinRule ，在 choose 方法中，根据当前 ThreadLocal 中的版本，便利服务中版本与之相等的服务，作为转发服务，为了防止服务获取失败，这里曾加了重试策略，重试 10 次还是失败，即放弃重试：

@Component
@Slf4j
public class EnvRoundRobinRule extends RoundRobinRule {

    private AtomicInteger nextServerCyclicCounter;

    public EnvRoundRobinRule() {
        nextServerCyclicCounter = new AtomicInteger(0);
    }

    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            log.warn("no load balancer");
            return null;
        }
        Server server = null;
        int count = 0;
        // 如果失败，重试 10 次
        while (Objects.isNull(server) && count++ < 10) {
            List<Server> reachableServers = lb.getReachableServers();
            List<Server> allServers = lb.getAllServers();
            int upCount = reachableServers.size();
            int serverCount = allServers.size();

            if ((upCount == 0) || (serverCount == 0)) {
                log.warn("No up servers available from load balancer: " + lb);
                return null;
            }
            List<NacosServer> filterServers = new ArrayList<>();
            String currentEnvironmentVersion = GrayscaleThreadLocalEnvironment.getCurrentEnvironment();

            for (Server serverInfo : reachableServers) {
                NacosServer nacosServer = (NacosServer) serverInfo;
                String version = nacosServer.getMetadata().get("version");
                if (version.equals(currentEnvironmentVersion)) {
                    filterServers.add(nacosServer);
                }
            }

            int filterServerCount = filterServers.size();
            int nextServerIndex = incrementAndGetModulo(filterServerCount);
            server = filterServers.get(nextServerIndex);

            if (server == null) {
                Thread.yield();
                continue;
            }
            if (server.isAlive() && (server.isReadyToServe())) {
                return (server);
            }
            server = null;
        }

        if (count >= 10) {
            log.warn("No available alive servers after 10 tries from load balancer: "
                    + lb);
        }
        return server;
    }

    private int incrementAndGetModulo(int modulo) {
        for (; ; ) {
            int current = nextServerCyclicCounter.get();
            int next = (current + 1) % modulo;
            if (nextServerCyclicCounter.compareAndSet(current, next))
                return next;
        }
    }
}

到这 流程基本就已经结束了，下面在header 中增加 userId 为 abc，然后多访问几次，可以看到都被转发到了 灰度环境：

下面在header 中增加 userId 为 110，然后多访问几次，可以看到都被转发到了 生产环境：

三、服务中互相调用问题

上面可以通过 userId 来控制是否转发到灰度环境，但是随之而来还有一个问题就是，服务都注册到了同一个 nacos 中，那服务间互相调用的时候不还是没有控制环境，生产的服务通过 feign 客户端调用，通过轮训就会调用到灰度环境的服务，对此就需要对每个服务的 Ribbon 负载规则进行上面的配置，我们再使用feign 客户端的时候，将 userId 放入请求的 header 中，然后每个服务在请求拦截器中从header 中获取 userId，然后放入当前的 ThreadLoad 中。

这里补充下 feign 在 header 中传递数据有几种实现方式，可以通过 @RequestHeader 注解进行添加，也可以在请求拦截器中添加。

@RequestHeader 中添加：

@Component
@FeignClient(value = "PROVIDER",contextId = "ProviderFeignService",path = "/test")
public interface ProviderFeignService {
    @GetMapping("/getData")
    JSONObject getData(@RequestParam(name = "data") String data, @RequestHeader(name = "userId") String userId);

    @PostMapping("/postData")
    JSONObject postData(@RequestBody Map<String, Object> data);
}

本文的场景需要都所有的 feign 调用都要添加请球头，因此下面在拦截器中添加比较合适：

@Configuration
public class FeignConfiguration implements RequestInterceptor {
    @Override
    public void apply(RequestTemplate requestTemplate) {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        requestTemplate.header("userId", request.getHeader("userId"));
    }
}

在 feign 接口中指定配制：

@Component
@FeignClient(value = "PROVIDER",contextId = "ProviderFeignService",path = "/test",configuration = FeignConfiguration.class)
public interface ProviderFeignService {
    @GetMapping("/getData")
    JSONObject getData(@RequestParam(name = "data") String data);

    @PostMapping("/postData")
    JSONObject postData(@RequestBody Map<String, Object> data);
}