springcloud 灰度发布

谁践踏了优雅 2022-12-23 14:23 145阅读 0赞

线上部署项目的时候，各个微服务不只部署一份，有时候，为了测试，可以进行灰度发布，先测试新的服务是否可用

1.微服务之间调用

微服务A 调用微服务B，灰度规则定义在数据库中或者元数据中

微服务A 中 定义灰度规则

ribbon 灰度发布 适合 各个微服务之间的调用

引入：

<dependency>
        <groupId>io.jmnarloch</groupId>
        <artifactId>ribbon-discovery-filter-spring-cloud-starter</artifactId>
        <version>2.1.0</version>
    </dependency>

import com.netflix.client.config.IClientConfig;
    import com.netflix.loadbalancer.AbstractLoadBalancerRule;
    import com.netflix.loadbalancer.ILoadBalancer;
    import com.netflix.loadbalancer.Server;
    import com.netflix.niws.loadbalancer.DiscoveryEnabledServer;
    
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    
    public class GrayRule extends AbstractLoadBalancerRule {
    
        /**
         * 根据用户选出一个服务
         * @param iClientConfig
         * @return
         */
        @Override
        public void initWithNiwsConfig(IClientConfig iClientConfig) {
    
    
        }
    
        @Override
        public Server choose(Object key) {
    
            return choose(getLoadBalancer(),key);
        }
    
        public Server choose(ILoadBalancer lb, Object key){
    
            System.out.println("灰度  rule");
            Server server = null;
            while (server == null){
                // 获取所有 可达的服务
                List<Server> reachableServers = lb.getReachableServers();
    
                // 获取 当前线程的参数 用户id verion=1
                Map<String,String> map = RibbonParameters.get();
                String version = "";
                if (map != null && map.containsKey("version")){
                    version = map.get("version");
                }
                System.out.println("当前rule version:"+version);
    
                // 根据用户选服务
                for (int i = 0; i < reachableServers.size(); i++) {
                    server = reachableServers.get(i);
                    // 用户的version我知道了，服务的自定义meta我不知道。
    
    
                    // eureka:
                    //  instance:
                    //    metadata-map:
                    //      version: v2
                    // 不能调另外 方法实现 当前 类 应该实现的功能，尽量不要乱尝试
    
                    Map<String, String> metadata = ((DiscoveryEnabledServer) server).getInstanceInfo().getMetadata();
    
                    String version1 = metadata.get("version");
    
                    // 服务的meta也有了，用户的version也有了。
                    if (version.trim().equals(version1)){
                        return server;
    
                    }
    
                }
    
            }
    
            // 怎么让server 取到合适的值。
            return server;
    
        }
    
    
    }

取得当前线程的参数（获取客户端 微服务A请求的参数）

import org.springframework.stereotype.Component;
    
    @Component
    public class RibbonParameters {
    
        private static final ThreadLocal local = new ThreadLocal();
    
        // get
        public static <T> T get(){
            return  (T)local.get();
        }
    
        // set
        public static <T> void set(T t){
            local.set(t);
        }
    }

定义灰度规则

import com.netflix.loadbalancer.IRule;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * 该类不应该在主应用程序的扫描之下，需要修改启动类的扫描配置。否则将被所有的Ribbon client共享，
     * 比如此例中：ribbonRule 对象 会共享。
     */
    //所以 该类不被@Configuration 注解
    public class GrayRibbonConfiguration {
    
        @Bean
        public IRule ribbonRule(){
            return new GrayRule();
        }
    
    }

定义切面,获取用户传递的参数

import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    import java.util.HashMap;
    import java.util.Map;
    
    
    @Aspect
    @Component
    public class RequestAspect {
    
        @Pointcut("execution(* com.wfy.apipassenger.controller..*Controller*.*(..))")
        private void anyMehtod(){
    
        }
    
        @Before(value = "anyMehtod()")
        public void before(JoinPoint joinPoint){
    
            HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();
            String version = request.getHeader("version");
    
            Map<String,String> map = new HashMap<>();
            map.put("version",version);
    
            RibbonParameters.set(map);
    
        }
    }

在启动类上添加注解

@RibbonClient(name = "微服务B",configuration = GrayRibbonConfiguration.class)

测试灰度发布是否成功：

微服务A中的类

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.client.RestTemplate;
    
    @RestController
    @RequestMapping("/test")
    public class TestCallServiceSmsController {
    
        @Autowired
        private RestTemplate restTemplate;
    
        @GetMapping("/call")
        public String testCall(){
    
            return restTemplate.getForObject("http://微服务B/test/testB",String.class);
        }
    
        
    }

微服务B中的类

import org.springframework.beans.factory.annotation.Value;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.servlet.http.HttpServletRequest;
    
    @RestController
    @RequestMapping("/test")
    public class ServiceSmsTestController {
    
        @Value("${server.port}")
        private String port;
    
        @GetMapping("/testB")
        public String test(){
    
            return "testB:"+port;
        }
    
    }

以上方式可以简化为：RibbonFilterContextHolder 可以用于网关和服务之间+服务和服务之间

import io.jmnarloch.spring.cloud.ribbon.support.RibbonFilterContextHolder;
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    import java.util.HashMap;
    import java.util.Map;
    
    
    @Aspect
    @Component
    public class RequestAspect {
    
        @Pointcut("execution(* com.wfy.apipassenger.controller..*Controller*.*(..))")
        private void anyMehtod(){
    
        }
    
        @Before(value = "anyMehtod()")
        public void before(JoinPoint joinPoint){
    
            HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();
            String version = request.getHeader("version");
    
            // 灰度规则 匹配的地方 查db，redis ==== 为v2
            if (version.trim().equals("v2")){
                RibbonFilterContextHolder.getCurrentContext().add("version","v2");
            }
    
        }
    }

2.网关 调用 微服务

引入

<dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
    </dependency>

在zuul服务中定义类实现ZuulFilter 接口 中的run方法

import com.netflix.zuul.ZuulFilter;
    import com.netflix.zuul.context.RequestContext;
    import com.netflix.zuul.exception.ZuulException;
    import io.jmnarloch.spring.cloud.ribbon.support.RibbonFilterContextHolder;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.netflix.zuul.filters.support.FilterConstants;
    import org.springframework.context.annotation.FilterType;
    import org.springframework.stereotype.Component;
    
    import javax.servlet.http.HttpServletRequest;
    
    @Component
    public class GrayFilter extends ZuulFilter {
    
    
        @Override
        public String filterType() {
            return FilterConstants.PRE_TYPE;
        }
    
        @Override
        public int filterOrder() {
            return 0;
        }
    
        @Override
        public boolean shouldFilter() {
            return false;
        }
    
        @Override
        public Object run() throws ZuulException {
    
    
            RequestContext currentContext = RequestContext.getCurrentContext();
            HttpServletRequest request = currentContext.getRequest();
    
            int userId = Integer.parseInt(request.getHeader("userId"));
            // 根据用户id 查 规则  查库 v1,meata
    
            // 金丝雀
            if (userId == 1){
                RibbonFilterContextHolder.getCurrentContext().add("version","v1");
            // 普通用户
            }else{
                RibbonFilterContextHolder.getCurrentContext().add("version","v2");
            }
    
    
    
            return null;
        }
    }

网关服务的启动类添加@EnableZuulProxy 注解 完成

灰度发布允许失败 允许适度浪费 内部竞争

灰度发布 修改规则，可以不重新发布服务，1。更改数据库 2.更改需要灰度的服务的元数据