Sentinel的持久化

官网地址：https://github.com/alibaba/Sentinel/wiki/%E5%9C%A8%E7%94%9F%E4%BA%A7%E7%8E%AF%E5%A2%83%E4%B8%AD%E4%BD%BF%E7%94%A8-Sentinel

一、规则管理及推送

Sentinel-dashboard配置的规则是基于内存的，在微服务以及控制台重启的时候就清空了；

一般来说，规则的推送有下面三种模式：

 1、原始模式

如果不做任何修改，Dashboard 的推送规则方式是通过 API 将规则推送至客户端并直接更新到内存中；

优缺点：这种做法的好处是简单，无依赖；坏处是应用重启规则就会消失，仅用于简单测试，不能用于生产环境

2、Pull模式

　　pull 模式的数据源（如本地文件、RDBMS 等）一般是可写入的。使用时需要在客户端注册数据源：将对应的读数据源注册至对应的 RuleManager，将写数据源注册至 transport 的 WritableDataSourceRegistry 中。

 

 　　首先 Sentinel 控制台通过 API 将规则推送至客户端并更新到内存中，接着注册的写数据源会将新的规则保存到本地的文件中。使用 pull 模式的数据源时一般不需要对 Sentinel 控制台进行改造。

　　这种实现方法好处是简单，不引入新的依赖，坏处是无法保证监控数据的一致性。

（1）通过SPI扩展机制进行扩展，在resources目录下创建 META-INF/services/com.alibaba.csp.sentinel.init.InitFunc 文件；我们写一个拉模式的实现类  com.yufeng.persistence.PullModeByFileDataSource ，并将这个类的全类名写入到文件中。

 （2）实现的类  PullModeByFileDataSource 类，如下：

@Slf4j
public class PullModeByFileDataSource implements InitFunc {

    @Override
    public void init() {
        log.info("time:{}读取配置", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss")));

        // 1. 创建文件夹
        try {
            this.mkdirIfNotExits(PersistenceRuleConstant.storePath);
    
            // 2. 创建文件
            this.createFileIfNotExits(PersistenceRuleConstant.rulesMap);
    
            // 3.处理流控规则
            this.dealFlowRules();
    
            // 4.处理降级规则
            this.dealDegradeRules();
    
            // 5.处理系统规则
            this.dealSystemRules();
    
            // 6.处理热点参数规则
            this.dealParamFlowRules();
    
            // 7.处理授权规则
            this.dealAuthRules();
        } catch (IOException e) {
            log.error("错误原因:{}",e);
        }
    }

    /**
     * 处理流控规则
     */
    private void dealFlowRules() throws FileNotFoundException {
        String ruleFilePath = PersistenceRuleConstant.rulesMap.get(PersistenceRuleConstant.FLOW_RULE_PATH).toString();

        // 1. 创建流控规则的可读数据源
        ReadableDataSource<String, List<FlowRule>> flowRuleRds = new FileRefreshableDataSource<> (
                ruleFilePath, source -> JSON.parseObject(source, new TypeReference<List<FlowRule>>() {})
        );

        // 2. 将可读数据源注册至FlowRuleManager 这样当规则文件发生变化时，就会更新规则到内存
        FlowRuleManager.register2Property(flowRuleRds.getProperty());

        WritableDataSource<List<FlowRule>> flowRuleWds = new FileWritableDataSource<List<FlowRule>>(
                ruleFilePath, JSON::toJSONString);

        // 3. 将可写数据源注册至 transport 模块的 WritableDataSourceRegistry 中.
        // 这样收到控制台推送的规则时，Sentinel 会先更新到内存，然后将规则写入到文件中.
        WritableDataSourceRegistry.registerFlowDataSource(flowRuleWds);
    }

    /**
     * 降级规则
     */
    private void dealDegradeRules() throws FileNotFoundException {
        String degradeRuleFilePath = PersistenceRuleConstant.rulesMap.get(PersistenceRuleConstant.DEGRAGE_RULE_PATH).toString();

        // 1. 创建流控规则的可读数据源
        ReadableDataSource<String, List<DegradeRule>> degradeRuleRds = new FileRefreshableDataSource<>(
                degradeRuleFilePath, source -> JSON.parseObject(source, new TypeReference<List<DegradeRule>>() {})
        );

        // 2.将可读数据源注册至FlowRuleManager 这样当规则文件发生变化时，就会更新规则到内存
        DegradeRuleManager.register2Property(degradeRuleRds.getProperty());

        WritableDataSource<List<DegradeRule>> degradeRuleWds = new FileWritableDataSource<>(
                degradeRuleFilePath, JSON::toJSONString
        );

        // 3. 将可写数据源注册至 transport 模块的 WritableDataSourceRegistry 中.
        // 这样收到控制台推送的规则时，Sentinel 会先更新到内存，然后将规则写入到文件中.
        WritableDataSourceRegistry.registerDegradeDataSource(degradeRuleWds);
    }

    /**
     * 处理系统规则
     */
    private void dealSystemRules() throws FileNotFoundException {
        String systemRuleFilePath = PersistenceRuleConstant.rulesMap.get(PersistenceRuleConstant.SYSTEM_RULE_PATH).toString();

        // 1.创建流控规则的可读数据源
        ReadableDataSource<String, List<SystemRule>> systemRuleRDS = new FileRefreshableDataSource<>(
                systemRuleFilePath, source -> JSON.parseObject(source, new TypeReference<List<SystemRule>>() {})
        );

        // 2.将可读数据源注册至FlowRuleManager 这样当规则文件发生变化时，就会更新规则到内存
        SystemRuleManager.register2Property(systemRuleRDS.getProperty());

        WritableDataSource<List<SystemRule>> systemRuleWDS = new FileWritableDataSource<>(
                systemRuleFilePath, JSON::toJSONString
        );

        // 3.将可写数据源注册至 transport 模块的 WritableDataSourceRegistry 中.
        // 这样收到控制台推送的规则时，Sentinel 会先更新到内存，然后将规则写入到文件中.
        WritableDataSourceRegistry.registerSystemDataSource(systemRuleWDS);
    }

    /**
     * 热点参数规则
     */
    private void dealParamFlowRules() throws FileNotFoundException {
        String paramFlowRuleFilePath = PersistenceRuleConstant.rulesMap.get(PersistenceRuleConstant.HOT_PARAM_RULE).toString();

        // 1. 创建流控规则的可读数据源
        ReadableDataSource<String, List<ParamFlowRule>> paramFlowRuleRDS = new FileRefreshableDataSource<>(
                paramFlowRuleFilePath, source -> JSON.parseObject(source, new TypeReference<List<ParamFlowRule>>() {})
        );

        // 2. 将可读数据源注册至FlowRuleManager 这样当规则文件发生变化时，就会更新规则到内存
        ParamFlowRuleManager.register2Property(paramFlowRuleRDS.getProperty());

        WritableDataSource<List<ParamFlowRule>> paramFlowRuleWDS = new FileWritableDataSource<>(
                paramFlowRuleFilePath, JSON::toJSONString
        );

        // 3. 将可写数据源注册至 transport 模块的 WritableDataSourceRegistry 中.
        // 这样收到控制台推送的规则时，Sentinel 会先更新到内存，然后将规则写入到文件中.
        ModifyParamFlowRulesCommandHandler.setWritableDataSource(paramFlowRuleWDS);
    }

    /**
     * 方法实现说明:授权规则
     * @author:smlz
     * @return:
     * @exception:
     * @date:2019/11/29 13:56
     */
    private void dealAuthRules() throws FileNotFoundException {
        String authFilePath = PersistenceRuleConstant.rulesMap.get(PersistenceRuleConstant.AUTH_RULE_PATH).toString();

        // 1.创建流控规则的可读数据源
        ReadableDataSource<String, List<AuthorityRule>> authRuleRDS = new FileRefreshableDataSource<>(
                authFilePath, source -> JSON.parseObject(source, new TypeReference<List<AuthorityRule>>() {})
        );

        // 2.将可读数据源注册至FlowRuleManager 这样当规则文件发生变化时，就会更新规则到内存
        AuthorityRuleManager.register2Property(authRuleRDS.getProperty());

        WritableDataSource<List<AuthorityRule>> authRuleWDS = new FileWritableDataSource<>(
                authFilePath, JSON::toJSONString
        );

        // 3.将可写数据源注册至 transport 模块的 WritableDataSourceRegistry 中.
        // 这样收到控制台推送的规则时，Sentinel 会先更新到内存，然后将规则写入到文件中.
        WritableDataSourceRegistry.registerAuthorityDataSource(authRuleWDS);
    }

    /**
     * 创建文件目录
     */
    private void mkdirIfNotExits(String filePath) throws IOException {
        File file = new File(filePath);
        if(!file.exists()) {
            log.info("创建Sentinel规则目录:{}",filePath);
            file.mkdirs();
        }
    }

    /**
     * 创建规则文件
     */
    private void createFileIfNotExits(Map<String,String> ruleFileMap) throws IOException {
        for (Map.Entry entry : ruleFileMap.entrySet()) {
            String ruleFilePath  = PersistenceRuleConstant.rulesMap.get(entry.getKey()).toString();
            File ruleFile = new File(ruleFilePath);
            if(!ruleFile.exists()) {
                log.info("创建Sentinel 规则文件:{}",ruleFile);
                ruleFile.createNewFile();
            }
        }
    }
}

（3）常量类的定义

public class PersistenceRuleConstant {

    /**
     * 存储文件路径
     */
    public static final String storePath = System.getProperty("user.home")+"\sentinel\rules\";

    /**
     * 各种存储sentinel规则映射map
     */
    public static final Map rulesMap = new HashMap<String,String>();

    //流控规则文件
    public static final String FLOW_RULE_PATH = "flowRulePath";

    //降级规则文件
    public static final String DEGRAGE_RULE_PATH = "degradeRulePath";

    //授权规则文件
    public static final String AUTH_RULE_PATH = "authRulePath";

    //系统规则文件
    public static final String SYSTEM_RULE_PATH = "systemRulePath";

    //热点参数文件
    public static final String HOT_PARAM_RULE = "hotParamRulePath";

    static {
        rulesMap.put(FLOW_RULE_PATH,storePath + "flowRule.json");
        rulesMap.put(DEGRAGE_RULE_PATH,storePath + "degradeRule.json");
        rulesMap.put(SYSTEM_RULE_PATH,storePath + "systemRule.json");
        rulesMap.put(AUTH_RULE_PATH,storePath + "authRule.json");
        rulesMap.put(HOT_PARAM_RULE,storePath + "hotParamRule.json");
    }
}

 3、Push模式

　　生产环境下一般更常用的是 push 模式的数据源。对于 push 模式的数据源,如远程配置中心（ZooKeeper, Nacos, Apollo等等），推送的操作不应由 Sentinel 客户端进行，而应该经控制台统一进行管理，直接进行推送，数据源仅负责获取配置中心推送的配置并更新到本地。因此推送规则正确做法应该是 配置中心控制台/Sentinel 控制台 → 配置中心 → Sentinel 数据源 → Sentinel，而不是经 Sentinel 数据源推送至配置中心。这样的流程就非常清晰了：

 原理简述

（1）控制台推送规则：

•  将规则推送到Nacos或其他远程配置中心；
• Sentinel客户端链接Nacos，获取规则配置；并监听Nacos配置变化，如发生变化，就更新本地缓存（从而让本地缓存总是和Nacos一致）；

（2）控制台监听Nacos配置变化，如发生变化就更新本地缓存（从而让控制台本地缓存总是和Nacos一致）

改造方案