分布式框架灰度发布实现

我的上一篇博客介绍了什么是灰度发布　灰度发布

本文将介绍分布式框架如何做到灰度发布。

在介绍具体实现步骤前，让我们先看下分布式框架下实现灰度发布的实现结构图：

一、灰度策略及规则定义

1. 通常灰度策略

1.支持根据服务名(serviceName)，方法名(methodName)，版本号(versionName) 进行路由。
2.支持上述服务名，方法名模糊匹配(正则) 进行路由
3.根据 callIp 匹配指定 ip 规则进行路由
4.根据callId。整数范围，整数取模进行路由
5.可以路由不匹配模式～
6.可以左边使用otherwise 全部匹配并路由到指定 ip
7.ip匹配支持掩码规则和正常精确匹配（不带掩码）

2. 整体规则定义

express1 ; express2 => ip-express

左边为匹配规则，以分号区分多个匹配规则，需要全部满足，才能匹配成功

express

method match "getFoo" ,"setFoo" 每一个子表达式形式如上，可以通过逗号（,）匹配多个条件，这里条件只要满足其一即可

=>

=> 是 Then表达式，划分左边和右边，如果左边匹配成功，将指向右边的 ip 表达式

right ip表达式

ip"192.168.1.12" 表示如果匹配成功，请求将路由到192.168.1.12的ip的服务节点上
ip支持掩码的匹配形式。 如 ip"192.168.1.0/24" 可以路由到 “192.168.1.0”的一个范围。

二、具体例子和功能

1.匹配字符串模式的变量

- method match "getSkuById" => ip"192.168.12.12"

作用：将方法为getSkuById的请求路由到

2.正则表达形式

可以通过正则的形式进行匹配，如下，可以将以get开头的请求路由到12的机器上，将set开头的请求路由到13的机器上。

method match r"get.*" => ip"192.168.12.12"
method match r"set.*" => ip"192.168.12.13"

3.匹配请求ip地址，可以应用到黑名单

- calleeIp match ip'192.168.1.101' => ip"192.168.2.105/30"

表示，请求ip为'192.168.1.101'的请求将会路由到 192.168.2.105/30及其掩码的ip的服务实例中

- calleeIp match ip'192.168.1.101' => ip"0.0.0.0"

表示将请求为101的ip路由到无效的ip上，实现黑名单的功能

4.可以根据请求用户的id进行路由

整数范围路由

- userId match 10..1000 => ip"192.168.12.1"

表示将请求用户id为10 到 1000 的用户路由到 ip为192.168.12.1的服务实例

取模路由

- userId match %“1024n+6” => ip"192.168.12.1"

表示将请求用户id与1024取模结果为6时，路由到 ip为192.168.12.1的服务实例 userId match %“1024n+3..5” => ip"192.168.12.1" 表示将请求用户id与1024取模结果为3到5之间时，路由到 ip为192.168.12.1的服务实例

5.不匹配模式

method match r"set.*" => ~ip"192.168.12.14"

表示以set开头的方法将不会路由到 ip 为 192.168.12.14 的服务实例

6.otherwise 模式

otherwise => ip"192.168.12.12"

表示左侧所有都匹配，一般作为路由规则的最后一条执行，表示前面所有路由规则都不满足时，最后执行的路由规则

7.多条件模式

method match r"set.*" ; version match "1.0.0" => ip'192.168.1.103'

同时满足上述两个条件的请求，才会路由到右侧Ip的实例上

8.多条件模式（情形二）

method match r"set.*",r"insert.*" => ip"192.123.12.11"

这种情形是，当请求的方法名为 set开头或者 insert开头时都可以匹配成功，路由到右侧Ip

9.路由多个Ip模式

serviceName match "com.today.service.MemberService" => ip"192.168.12.1",ip"192.168.12.2"

上述情形表示符合左边的条件，可以路由到上述右侧两个ip上

10.多路由表达式

method match "setFoo" => ip"192.168.10.12/24"
method match "getFoo" => ip"192.168.12.14"
otherwise => ip"192.168.12.18"

上述情形为多个路由表达式写法，每个路由表达式 换行分隔

我们会从最上面一条路由表达式开始进行匹配，当匹配到时即停止，不在继续向下匹配。如果没有匹配到，将继续向下进行解析。如上，当前两条都不符合时，即可路由到第三条，otherwise表示所有都符合的规则，这样最终将会路由到"192.168.12.18"的ip上

三、分布式架构灰度路由实现

以下我们以登录用户(即userId)进行灰度发布来讲实现步骤。

1.灰度表达式配置

定义灰度发布规则

userId match 19767 , 16852 , 16695 => ip"10.100.226.227" 
otherwise => ip"10.100.45.116"

以上规则表明：当登录用户ID为19767或16852是，访问IP地址为10.100.226.227的服务器服务，否则其他用户都访问IP地址为10.100.45.116的服务器服务

２.将灰度表达式动态发布到zookeeper

    /**
     * 根据host连接zk
     *
     * @param host
     * @return
     * @throws Exception
     */
    public static ZooKeeper createZkByHost(String host) throws Exception {
        CountDownLatch semaphore = new CountDownLatch(1);
        ZooKeeper zkClient = null;
        try {
            /*
             * ZooKeeper客户端和服务器会话的建立是一个异步的过程
             * 构造函数在处理完客户端的初始化工作后立即返回，在大多数情况下，并没有真正地建立好会话
             * 当会话真正创建完毕后，Zookeeper服务器会向客户端发送一个事件通知
             */
            zkClient = new ZooKeeper(host, 500, (event) -> {
                LOGGER.info("waiting  连接 Zk ....");
                if (event.getState() == Watcher.Event.KeeperState.SyncConnected) {
                    semaphore.countDown();
                }
            });
            LOGGER.info("build zk connect state1[{}]...", zkClient.getState());
            //semaphore.await();
            semaphore.await(1000, TimeUnit.MILLISECONDS);
            LOGGER.info("build zk connect state2[{}]...", zkClient.getState());
            LOGGER.info("build zk connect on [{}]...", host);
        } catch (Exception e) {
            LOGGER.info(e.getMessage(), e);
        }
        if (Objects.nonNull(zkClient) && zkClient.getState() == CONNECTED) {
            return zkClient;
        } else {
            if (zkClient != null) {
                zkClient.close();
            }
            LOGGER.info("ZK build connect on [{}] failed ...", host);
            throw new Exception("ZK build connect on [" + host + "] failed ...");
        }
    }

/**
     * 执行发布（服务）
     *
     * @param cid
     * @throws Exception
     */
    private void processPublish(String host, ConfigInfoDto cid) throws Exception {
        ZooKeeper zk = createZkByHost(host);
        String service = cid.getServiceName();

        String routerConfig = "userId match 19767 , 16852 , 16695 => ip\"10.100.226.227\" \n" +
        "otherwise => ip\"10.100.45.116\"";

        // 路由 
        ZkUtil.createData(zk, "/soa/config/routes/" + service,routerConfig);

        ZkUtil.closeZk(zk); 
    }

２.调用接口时将userId设置到分布式框架上下文

所有微服务接口提供统一网关

import com.github.dapeng.core.InvocationContext;
import com.github.dapeng.core.InvocationContextImpl;
import com.github.dapeng.core.SoaException;
import com.github.dapeng.core.helper.DapengUtil;
import com.github.dapeng.core.helper.SoaSystemEnvProperties;
import com.github.dapeng.openapi.utils.PostUtil;
import com.today.api.admin.enums.StaffManagerEnum;
import com.today.domain.LoginUser;
import com.today.domain.ResponseData;
import com.today.enums.ResponseStatus;
import com.today.soa.idgen.IDServiceClient;
import com.today.soa.idgen.domain.GenIDRequest;
import com.today.util.JSONUtil;
import com.today.util.UserSessionHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.stream.Collectors;

/**
 * @author ever
 * @date 2018-01-29
 */
@RestController
@RequestMapping("api")
public class OpenApiController {
    private Logger logger = LoggerFactory.getLogger(OpenApiController.class);
    private IDServiceClient idServiceClient = new IDServiceClient();
    private final static String BARCODE = "sku_barcode";

    @PostMapping(value = "{service}/{version}/{method}")
    @ResponseBody
    public String rest(@PathVariable(value = "service") String service,
                       @PathVariable(value = "version") String version,
                       @PathVariable(value = "method") String method,
                       @RequestParam(value = "parameter") String parameter,
                       HttpServletRequest req) {
        try {
            InvocationContext invocationContext = InvocationContextImpl.Factory.currentInstance();
            String sessionTid = invocationContext.sessionTid().map(DapengUtil::longToHexStr).orElse("0");
            MDC.put(SoaSystemEnvProperties.KEY_LOGGER_SESSION_TID, sessionTid);
            //接口鉴权
            LoginUser loginUser = UserSessionHelper.getCurrentLoginUser();

            if(loginUser.getManager() == StaffManagerEnum.SUPPER_MANAGER){ //超级管理员 不鉴权
                return PostUtil.post(service, version, method, parameter, req);
            }else{
                String serviceCode = service.substring(service.lastIndexOf(".")+1);
                logger.info("检测权限code"+serviceCode+"."+method + "===="+loginUser.getPermissionList().size());
                boolean bool = loginUser.getPermissionList().stream().
                        filter(item -> (serviceCode+"."+method).equals(item.code)).collect(Collectors.toList()).isEmpty();
                if(!bool){
                    return PostUtil.post(service, version, method, parameter, req);
                }else{
                    ResponseData responseData = new ResponseData();
                    responseData.setStatus(ResponseStatus.NO_PERMISSION);
                    responseData.setResponseMsg("["+serviceCode+"."+method+"]权限不足");
                    return JSONUtil.toJson(responseData);
                }
            }
        } finally {
            MDC.remove(SoaSystemEnvProperties.KEY_LOGGER_SESSION_TID);
        }
    }
}

其中PostUtil.post()会根据服务名，版本号，方法名及参数发起RPC请求对应微服务，这个方法会根据页面传入的参数获取userId并设置到分布式框架的上下文供路由匹配选择

如下：

public static String post(String service, String version, String method, String parameter, HttpServletRequest req, boolean clearInvocationContext) {
        InvocationContextImpl invocationCtx = (InvocationContextImpl)createInvocationCtx(service, version, method, req);
        OptimizedService bizService = ServiceCache.getService(service, version);
        if (bizService == null) {
            LOGGER.error("bizService not found[service:" + service + ", version:" + version + "]");
            return String.format("{\"responseCode\":\"%s\", \"responseMsg\":\"%s\", \"success\":\"%s\", \"status\":0}", SoaCode.NoMatchedService.getCode(), SoaCode.NoMatchedService.getMsg(), "{}");
        } else {
            Set<String> parameters = req.getParameterMap().keySet();
            if (parameters.contains("userId")) {
                invocationCtx.userId(Long.valueOf(req.getParameter("userId")));
            }
            InvocationContextProxy invocationCtxProxy = Factory.getInvocationContextProxy();
            invocationCtx.cookies(invocationCtxProxy.cookies());
            
            JsonPost jsonPost = new JsonPost(service, version, method, true);

            String var10;
            try {
                String var9 = jsonPost.callServiceMethod(parameter, bizService);
                return var9;
            } catch (SoaException var15) {
                LOGGER.error(var15.getMsg(), var15);
                var10 = String.format("{\"responseCode\":\"%s\", \"responseMsg\":\"%s\", \"success\":\"%s\", \"status\":0}", var15.getCode(), var15.getMsg(), "{}");
            } catch (Exception var16) {
                LOGGER.error(var16.getMessage(), var16);
                var10 = String.format("{\"responseCode\":\"%s\", \"responseMsg\":\"%s\", \"success\":\"%s\", \"status\":0}", "9999", "系统繁忙，请稍后再试[9999]！", "{}");
                return var10;
            } finally {
                if (clearInvocationContext) {
                    Factory.removeCurrentInstance();
                }

            }

            return var10;
        }
    }

现在有个问题，为了从HttpServletRequest中通过getParameter("userId")获取当前登录用户ID，我们如果前台传入，前端每个调用接口都要传入userId参数，这样就会大大增加前端的工作量。所以决定在服务端在session中获取当前用户ID设置到HttpServletRequest。但问题是HttpServletRequest为了防止页面传入参数被篡改，并没有提供setParameter()方法，所以通过过滤器及继承HttpServletRequestWrapper来实现。如下：

web.xml添加过滤器：

    <filter>
        <filter-name>addUserIdFilter</filter-name>
        <filter-class>com.today.filter.AddUserIdFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>addUserIdFilter</filter-name>
        <url-pattern>/api/*</url-pattern>
        <dispatcher>REQUEST</dispatcher>
        <dispatcher>FORWARD</dispatcher>
    </filter-mapping>

实现AddUserIdFilter：

import com.today.domain.LoginUser;
import com.today.util.UserSessionHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

/**
 * 类功能描述：添加用户ID过滤链
 *
 * @author WangXueXing create at 19-5-22 上午8:38
 * @version 1.0.0
 */
public class AddUserIdFilter implements Filter {
    private static final Logger logger = LoggerFactory.getLogger(AddUserIdFilter.class);
    /**
     * 通过过滤器添加当前登录用户ID, 为了后续通过用户ID进行灰度
     * @param request
     * @param response
     * @param chain
     * @throws IOException
     * @throws ServletException
     */
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        ModifyRequestParameterWrapper requestWrapper = new ModifyRequestParameterWrapper((HttpServletRequest)request);
        try{
            LoginUser loginUser = UserSessionHelper.getCurrentLoginUser();
            if(loginUser != null){
                requestWrapper.addParameter("userId", loginUser.getStaffId());
            }
        } catch (Exception e) {
            logger.error("添加userId报错", e);
        } finally {
            chain.doFilter(requestWrapper, response);
        }
    }

    @Override
    public void destroy() {}

    @Override
    public void init(FilterConfig fConfig) {}
}

实现ModifyRequestParameterWrapper：

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.util.HashMap;
import java.util.Map;

/**
 * 类功能描述：HttpServletRequest修改参数
 *
 * @author WangXueXing create at 19-5-22 上午8:26
 * @version 1.0.0
 */
public class ModifyRequestParameterWrapper extends HttpServletRequestWrapper {
    private Map<String, String[]> params = new HashMap<String, String[]>();

    public ModifyRequestParameterWrapper(HttpServletRequest request) {
        // 将request交给父类，以便于调用对应方法的时候，将其输出，其实父亲类的实现方式和第一种new的方式类似
        super(request);
        //将参数表，赋予给当前的Map以便于持有request中的参数
        this.params.putAll(request.getParameterMap());
    }

    //重载一个构造方法
    public ModifyRequestParameterWrapper(HttpServletRequest request, Map<String, Object> extendParams) {
        this(request);
        addAllParameters(extendParams);//这里将扩展参数写入参数表
    }

    @Override
    public String getParameter(String name) {//重写getParameter，代表参数从当前类中的map获取
        String[] values = params.get(name);
        if (values == null || values.length == 0) {
            return null;
        }
        return values[0];
    }

    public String[] getParameterValues(String name) {//同上
        return params.get(name);
    }

    public void addAllParameters(Map<String, Object> otherParams) {//增加多个参数
        for (Map.Entry<String, Object> entry : otherParams.entrySet()) {
            addParameter(entry.getKey(), entry.getValue());
        }
    }

    public void addParameter(String name, Object value) {//增加参数
        if (value != null) {
            if (value instanceof String[]) {
                params.put(name, (String[]) value);
            } else if (value instanceof String) {
                params.put(name, new String[]{(String) value});
            } else {
                params.put(name, new String[]{String.valueOf(value)});
            }
        }
    }
}

以上就会在接口调用时将当前userId信息注册到分布式框架上下文。

３.分布式灰度路由规则实现

请参考大鹏开源实现代码：灰度路由规则定义

灰度路由规则定义请参考编译原理词法分析实现

4. 分布式框架实现路由匹配