什么是灰度
有时候,产品说,我们这个新版本上线后,先切20%的流量看看转化率。
有时候,领导说,这个重构的系统我们还是需要在生产小规模验证一下。
有时候,产品说,转化率符合预期,流量扩大到80%吧。
有时候,领导说,生产炸了,快、快全部切回老系统。
相信上面的场景很多人都遇到过,那么常见的解决这些问题的方式是什么呢?
使用配置文件,劣势,改配置需要发布。
使用db存储,劣势,每一次请求都要访问一次DB,不太合适 使用配置中心,劣势,不能做复杂的规则,例如10%的流量,排除掉某些个用户。
实现一个通用的灰度框架需要考虑哪些
1、规则是可以通过配置完成的
2、规则配置后是实时生效的,支持热加载的
3、不同的团队有不同的技术栈,需要支持市场上主流的配置中心
4、复杂规则可以自定义扩展、数据源支持自定义扩展
5、规则的执行是可跟踪的,跟踪的数据是可查看的,数据的存储是可以自定义的。
设计-先搭骨架
1、规则是由许多细小的表达式组成,例如 在0-20之间,在[1,2,3,4,6,7]中,等于“jack”,先设计一个class来描述这样的规则 ,我们可以设计成一个规则(Rule 包含 多个 Feature,规则的执行结果等于所有的Feature的执行结果)
public class GrayRuleConfig
{
private List<Feature> features;
public static class Feature{
private String key;
private boolean enable;
private boolean unionAll;
private Map<String,String> metaData;
}
}
复制代码
2、规则行为定义和Feature的行为
public interface IRule {
String getKey();
boolean enable();
boolean check(Object value);
}
复制代码
public interface IFeature<F> {
F getFeature();
boolean check(Object targetValue);
}
复制代码
3、规则和Feature的公有行为抽象出来,并定义好执行骨架
public abstract class AbstractRule implements IRule {
private final ITraceRepository traceRepository;
public AbstractRule(ITraceRepository traceRepository) {
this.traceRepository = traceRepository;
}
public boolean check(Object value) {
boolean result = doCheck(value);
beforeGrayCheck(value);
try {
if (result) {
execResultPass();
} else {
execResultNoPass();
}
afterGrayCheck(value, result);
} catch (Exception ex) {
execGrayErrorAfter(ex, value);
}
return result;
}
protected void beforeGrayCheck(Object value) {
System.out.println(this.getClass() + ";beforeGrayCheck:" + value);
}
protected void afterGrayCheck(Object value, boolean result) {
System.out.println(this.getClass() + ";afterGrayCheck:" + value);
}
protected void execGrayErrorAfter(Exception ex, Object value) {
//todo log
System.out.println(this.getClass() + ";execGrayErrorAfter:" + value + "ex:" + ex);
}
private void execResultPass() {
traceRepository.pass(this.getKey());
}
private void execResultNoPass() {
traceRepository.noPass(this.getKey());
}
public abstract boolean doCheck(Object targetValue);
复制代码
public abstract class AbstractFeature<F> implements IFeature<F> {
private ITraceRepository traceRepository;
private F feature;
public void setTraceRepository(ITraceRepository traceRepository){
this.traceRepository=traceRepository;
}
public ITraceRepository getTraceRepository(){
return this.traceRepository;
}
protected IFeature buildFeature(String featureDesc){
return buildFeature(featureDesc,null);
}
protected IFeature buildFeature(String featureDesc,ITraceRepository traceRepository){
this.feature=parseFeature(featureDesc);
this.traceRepository=traceRepository;
return this;
}
public F getFeature() {
return this.feature;
}
public boolean check(Object targetValue) {
return doCheck(targetValue);
}
private F parseFeature(String featureDesc){
if (StringUtils.isEmpty(featureDesc)){
throw new GrayException("featureDesc can not be null");
}
return doParseFeature(featureDesc);
}
protected abstract F doParseFeature(String featureDesc);
protected abstract boolean doCheck(Object value);
复制代码
默认支持的规则实现
public class DefaultRule extends AbstractRule {
private String key;
private boolean enable;
public boolean isUnionAll() {
return unionAll;
}
public void setUnionAll(boolean unionAll) {
this.unionAll = unionAll;
}
private boolean unionAll;
public DefaultRule(ITraceRepository traceRepository) {
super(traceRepository);
}
public void setKey(String key){
this.key=key;
}
public void setEnable(boolean enable){
this.enable=enable;
}
public boolean enable() {
return this.enable;
}
public String getKey() {
return this.key;
}
private List<IFeature> features;
public void setFeatures(List<IFeature> features){
this.features=features;
}
public List<IFeature> getFeatures() {
return this.features;
}
public boolean doCheck(Object targetValue) {
boolean result=false;
for (IFeature feature:this.features){
result=feature.check(targetValue);
if (result&&!unionAll){
break;
}
if (!result&&unionAll){
break;
}
}
return result;
}
复制代码
规则部分,先写到这里,github有源码