Sentinel同步流控规则到Nacos（Apollo、zookeeper同理）

已于 2022-02-18 16:52:12 修改
阅读量1.5k 收藏
点赞数 2
分类专栏： 微服务 文章标签： zookeeper java 云原生
于 2022-02-17 20:30:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23021275/article/details/122990857
版权

1.必看！！！(右边有目录导航)

  • 已集成Nacos、Sentinel并且Sentinel dashboard可正常显示Nacos持久化的流控规则
    Sentinel
  • 下载sentinel源码：https://github.com/alibaba/Sentinel/archive/refs/tags/1.8.3.zip
  • sentinel-dashboard工程添加lombok依赖、修改Nacos scope
  • 新建或修改package、class、enum不再赘婿，详见class和enum的package路径！！
  • 已确认无误，复制粘贴当伸手党即可。
<!-- for Nacos rule publisher sample -->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-datasource-nacos</artifactId>
    <!--<scope>test</scope>-->
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <!--请自行在父pom中管理依赖-->
    <version>1.18.16</version>
</dependency>

2.项目目录（下述代码全部在sentinel-dashboard工程）

项目目录

3.修改文件：sidebar.html

  • 文件目录：
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LfzAjtP9-1645099256107)(img_3.png)]

  • 替换内容：

        <!--启用Sentinel同步Nacos,2022年2月17日 14点11分-->
    <!--<li ui-sref-active="active" ng-if="!entry.isGateway">
        <a ui-sref="dashboard.flowV1({app: entry.app})">
        <i class="glyphicon glyphicon-filter"></i>&nbsp;&nbsp;流控规则</a>
    </li>-->

    <li ui-sref-active="active" ng-if="!entry.isGateway">
        <a ui-sref="dashboard.flow({app: entry.app})">
            <i class="glyphicon glyphicon-filter"></i>&nbsp;&nbsp;服务流控规则
        </a>
    </li>

  • 修改identity.js为（目的：簇点链路添加流控规则调用API改为V2）
    在这里插入图片描述

  • 产生影响：

    将流控规则时保存调用的API由V1改为V2(/v2/flow/rules)

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dlU6xk8t-1645099256111)(img_4.png)]

4. 新增配置

在这里插入图片描述

#在resources/application.properties中添加Sentinel -> Nacos的连接信息
#Nacos -> Sentinel：Nacos -> 服务 -> Sentinel dashboard
sentinel.nacos.serverAddr=192.168.1.135:8847
sentinel.nacos.groupId=SENTINEL_GROUP
sentinel.nacos.namespace=95c0ce18-50e0-4e1b-917e-6429d0c54c5e
#dataId未使用
sentinel.nacos.dataId=

5. 添加/修改同步代码（有问题看标题1）

  • 添加完后目录：

在这里插入图片描述

  • 实现思路借鉴test/com.alibaba.csp.sentinel.dashboard.rule.nacos

在这里插入图片描述

5.2 NacosPropertiesConfiguration

package com.alibaba.csp.sentinel.dashboard.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
@Data
@ConfigurationProperties(prefix="sentinel.nacos")
public class NacosPropertiesConfiguration{
    private String serverAddr;
    private String groupId = "DEFAULT_GROUP";
    private String namespace;
    private String dataId;
}

5.3 NacosPropertiesConfiguration

package com.alibaba.csp.sentinel.dashboard.config;

import lombok.AllArgsConstructor;
import lombok.Getter;

@Getter
@AllArgsConstructor
public enum RuleTypeEnum {
    FLOW("-flow-rules"),
    DEGRADE("-degrade-rules"),
    SYSTEM("-system-rules"),
    AUTHORITY("-authority-rules"),
    PARAM_FLOW("-param-flow-rules");

    private String ruleTypePostfix;
}

5.1 nacos包

  • flow/degrade，system/authority/param-flow参考degrade实现
  • NacosConfig
package com.alibaba.csp.sentinel.dashboard.rule.nacos;

import com.alibaba.csp.sentinel.dashboard.config.NacosPropertiesConfiguration;
import com.alibaba.csp.sentinel.dashboard.datasource.entity.rule.*;
import com.alibaba.csp.sentinel.datasource.Converter;
import com.alibaba.fastjson.JSON;
import com.alibaba.nacos.api.PropertyKeyConst;
import com.alibaba.nacos.api.config.ConfigFactory;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.exception.NacosException;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.List;
import java.util.Properties;

/**
 * @author Eric Zhao
 * @since 1.4.0
 */
@EnableConfigurationProperties(NacosPropertiesConfiguration.class)
@Configuration
public class NacosConfig {

    @Bean
    public Converter<List<FlowRuleEntity>,String> flowRuleEntityEncoder(){
        return JSON::toJSONString;
    }

    @Bean
    public Converter<String,List<FlowRuleEntity>> flowRuleDecoder(){
        return s->JSON.parseArray(s,FlowRuleEntity.class);
    }
    @Bean
    public Converter<String,List<DegradeRuleEntity>> degradeRuleDecoder(){
        return s->JSON.parseArray(s,DegradeRuleEntity.class);
    }
    @Bean
    public Converter<String,List<SystemRuleEntity>> systemRuleDecoder(){
        return s->JSON.parseArray(s,SystemRuleEntity.class);
    }
    @Bean
    public Converter<String,List<AuthorityRuleEntity>> authorityRuleDecoder(){
        return s->JSON.parseArray(s,AuthorityRuleEntity.class);
    }
    @Bean
    public Converter<String,List<ParamFlowRuleEntity>> paramFlowRuleDecoder(){
        return s->JSON.parseArray(s,ParamFlowRuleEntity.class);
    }
    @Bean
    public ConfigService nacosConfigService(NacosPropertiesConfiguration nacosPropertiesConfiguration) throws NacosException {
        Properties properties = new Properties();
        properties.put(PropertyKeyConst.NAMESPACE,nacosPropertiesConfiguration.getNamespace());
        properties.put(PropertyKeyConst.SERVER_ADDR,nacosPropertiesConfiguration.getServerAddr());
        return ConfigFactory.createConfigService(properties);
    }
}
  • NacosRuleApiProvider
package com.alibaba.csp.sentinel.dashboard.rule.nacos;

public interface NacosRuleApiProvider<T>  {
    T getRules(String app) throws Exception;
}
  • NacosRuleApiPublisher
package com.alibaba.csp.sentinel.dashboard.rule.nacos;

public interface NacosRuleApiPublisher<T>  {
    void publish(String app, T rules) throws Exception;
}
  • DegradeRuleNacosApiProvider
package com.alibaba.csp.sentinel.dashboard.rule.nacos.degrade;

import com.alibaba.csp.sentinel.dashboard.config.NacosPropertiesConfiguration;
import com.alibaba.csp.sentinel.dashboard.config.RuleTypeEnum;
import com.alibaba.csp.sentinel.dashboard.datasource.entity.rule.DegradeRuleEntity;
import com.alibaba.csp.sentinel.dashboard.rule.nacos.NacosRuleApiProvider;
import com.alibaba.csp.sentinel.datasource.Converter;
import com.alibaba.nacos.api.config.ConfigService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

@Slf4j
@Component("degradeProvider")
public class DegradeRuleNacosApiProvider implements NacosRuleApiProvider<List<DegradeRuleEntity>> {
    @Autowired
    private ConfigService configService;
    @Autowired
    private Converter<String, List<DegradeRuleEntity>> converter;
    @Autowired
    private NacosPropertiesConfiguration nacosPropertiesConfiguration;

    @Override
    public List<DegradeRuleEntity> getRules(String app) throws Exception {
        String dataId = new StringBuilder(app).append(RuleTypeEnum.DEGRADE.getRuleTypePostfix()).toString();
        String rules = configService.getConfig(dataId, nacosPropertiesConfiguration.getGroupId(), 3000);
        log.info("从Nacos配置中心获取{}规则:{}", RuleTypeEnum.DEGRADE.name(), rules);
        if (StringUtils.isEmpty(rules)) {
            return new ArrayList<>();
        }
        return converter.convert(rules);
    }


}
  • DegradeRuleNacosPublisher
/*
 * Copyright 1999-2018 Alibaba Group Holding Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.alibaba.csp.sentinel.dashboard.rule.nacos.degrade;

import com.alibaba.csp.sentinel.dashboard.config.NacosPropertiesConfiguration;
import com.alibaba.csp.sentinel.dashboard.config.RuleTypeEnum;
import com.alibaba.csp.sentinel.dashboard.datasource.entity.rule.FlowRuleEntity;
import com.alibaba.csp.sentinel.dashboard.rule.nacos.NacosRuleApiPublisher;
import com.alibaba.csp.sentinel.datasource.Converter;
import com.alibaba.csp.sentinel.util.AssertUtil;
import com.alibaba.nacos.api.config.ConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * @author Eric Zhao
 * @since 1.4.0
 */
@Slf4j
@Component("degradePublisher")
public class DegradeRuleNacosPublisher implements NacosRuleApiPublisher<List<FlowRuleEntity>> {

    @Autowired
    private ConfigService configService;
    @Autowired
    private Converter<List<FlowRuleEntity>, String> converter;
    @Autowired
    private NacosPropertiesConfiguration nacosPropertiesConfiguration;

    @Override
    public void publish(String app, List<FlowRuleEntity> rules) throws Exception {
        AssertUtil.notEmpty(app, "appName 不能为空");
        if (rules == null) {
            return;
        }
        String dataId = new StringBuilder(app).append(RuleTypeEnum.DEGRADE.getRuleTypePostfix()).toString();
        configService.publishConfig(dataId, nacosPropertiesConfiguration.getGroupId(), converter.convert(rules));
        log.info("推送{}到Nacos配置中心,DataId:{},规则:{}", RuleTypeEnum.DEGRADE.name(), dataId, rules);
    }
}
  • FlowRuleNacosApiProvider
package com.alibaba.csp.sentinel.dashboard.rule.nacos.flow;

import com.alibaba.csp.sentinel.dashboard.config.NacosPropertiesConfiguration;
import com.alibaba.csp.sentinel.dashboard.config.RuleTypeEnum;
import com.alibaba.csp.sentinel.dashboard.datasource.entity.rule.FlowRuleEntity;
import com.alibaba.csp.sentinel.dashboard.rule.nacos.NacosRuleApiProvider;
import com.alibaba.csp.sentinel.datasource.Converter;
import com.alibaba.nacos.api.config.ConfigService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

@Slf4j
@Component("flowProvider")
public class FlowRuleNacosApiProvider implements NacosRuleApiProvider<List<FlowRuleEntity>> {
    @Autowired
    private ConfigService configService;
    @Autowired
    private Converter<String, List<FlowRuleEntity>> converter;
    @Autowired
    private NacosPropertiesConfiguration nacosPropertiesConfiguration;

    @Override
    public List<FlowRuleEntity> getRules(String app) throws Exception {
        String dataId = new StringBuilder(app).append(RuleTypeEnum.FLOW.getRuleTypePostfix()).toString();
        String rules = configService.getConfig(dataId, nacosPropertiesConfiguration.getGroupId(), 3000);
        log.info("从Nacos配置中心获取{}规则:{}", RuleTypeEnum.FLOW.name(), rules);
        if (StringUtils.isEmpty(rules)) {
            return new ArrayList<>();
        }
        return converter.convert(rules);
    }


}
  • FlowRuleNacosPublisher
/*
 * Copyright 1999-2018 Alibaba Group Holding Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.alibaba.csp.sentinel.dashboard.rule.nacos.flow;

import com.alibaba.csp.sentinel.dashboard.config.NacosPropertiesConfiguration;
import com.alibaba.csp.sentinel.dashboard.config.RuleTypeEnum;
import com.alibaba.csp.sentinel.dashboard.datasource.entity.rule.FlowRuleEntity;
import com.alibaba.csp.sentinel.dashboard.rule.nacos.NacosRuleApiPublisher;
import com.alibaba.csp.sentinel.datasource.Converter;
import com.alibaba.csp.sentinel.util.AssertUtil;
import com.alibaba.nacos.api.config.ConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * @author Eric Zhao
 * @since 1.4.0
 */
@Slf4j
@Component("flowPublisher")
public class FlowRuleNacosPublisher implements NacosRuleApiPublisher<List<FlowRuleEntity>> {

    @Autowired
    private ConfigService configService;
    @Autowired
    private Converter<List<FlowRuleEntity>, String> converter;
    @Autowired
    private NacosPropertiesConfiguration nacosPropertiesConfiguration;

    @Override
    public void publish(String app, List<FlowRuleEntity> rules) throws Exception {
        AssertUtil.notEmpty(app, "appName 不能为空");
        if (rules == null) {
            return;
        }
        String dataId = new StringBuilder(app).append(RuleTypeEnum.FLOW.getRuleTypePostfix()).toString();
        configService.publishConfig(dataId, nacosPropertiesConfiguration.getGroupId(), converter.convert(rules));
        log.info("推送{}到Nacos配置中心,DataId:{},规则:{}", RuleTypeEnum.FLOW.name(), dataId, rules);
    }
}

5.4 FlowControllerV2

//改动：指定依赖注入类型
@Autowired
@Qualifier("flowProvider")
private NacosRuleApiProvider<List<FlowRuleEntity>> ruleProvider;

@Autowired
@Qualifier("flowPublisher")
private NacosRuleApiPublisher<List<FlowRuleEntity>> rulePublisher;

5.5 DegradeController

在这里插入图片描述

/*
 * Copyright 1999-2018 Alibaba Group Holding Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.alibaba.csp.sentinel.dashboard.controller;

import com.alibaba.csp.sentinel.dashboard.auth.AuthAction;
import com.alibaba.csp.sentinel.dashboard.auth.AuthService.PrivilegeType;
import com.alibaba.csp.sentinel.dashboard.client.SentinelApiClient;
import com.alibaba.csp.sentinel.dashboard.datasource.entity.rule.DegradeRuleEntity;
import com.alibaba.csp.sentinel.dashboard.discovery.MachineInfo;
import com.alibaba.csp.sentinel.dashboard.domain.Result;
import com.alibaba.csp.sentinel.dashboard.repository.rule.RuleRepository;
import com.alibaba.csp.sentinel.dashboard.rule.nacos.NacosRuleApiPublisher;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.degrade.circuitbreaker.CircuitBreakerStrategy;
import com.alibaba.csp.sentinel.util.StringUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.*;

import java.util.Date;
import java.util.List;

/**
 * Controller regarding APIs of degrade rules. Refactored since 1.8.0.
 *
 * @author Carpenter Lee
 * @author Eric Zhao
 */
@RestController
@RequestMapping("/degrade")
public class DegradeController {

    private final Logger logger = LoggerFactory.getLogger(DegradeController.class);

    @Autowired
    private RuleRepository<DegradeRuleEntity, Long> repository;
    @Autowired
    private SentinelApiClient sentinelApiClient;
    @Autowired
    @Qualifier("degradePublisher")
    NacosRuleApiPublisher publisher;

    @GetMapping("/rules.json")
    @AuthAction(PrivilegeType.READ_RULE)
    public Result<List<DegradeRuleEntity>> apiQueryMachineRules(String app, String ip, Integer port) {
        if (StringUtil.isEmpty(app)) {
            return Result.ofFail(-1, "app can't be null or empty");
        }
        if (StringUtil.isEmpty(ip)) {
            return Result.ofFail(-1, "ip can't be null or empty");
        }
        if (port == null) {
            return Result.ofFail(-1, "port can't be null");
        }
        try {
            List<DegradeRuleEntity> rules = sentinelApiClient.fetchDegradeRuleOfMachine(app, ip, port);
            rules = repository.saveAll(rules);
            return Result.ofSuccess(rules);
        } catch (Throwable throwable) {
            logger.error("queryApps error:", throwable);
            return Result.ofThrowable(-1, throwable);
        }

    }

    @PostMapping("/rule")
    @AuthAction(PrivilegeType.WRITE_RULE)
    public Result<DegradeRuleEntity> apiAddRule(@RequestBody DegradeRuleEntity entity) {
        Result<DegradeRuleEntity> checkResult = checkEntityInternal(entity);
        if (checkResult != null) {
            return checkResult;
        }
        Date date = new Date();
        entity.setGmtCreate(date);
        entity.setGmtModified(date);
        try {
            entity = repository.save(entity);
            publishRules(entity.getApp());
        } catch (Throwable t) {
            logger.error("Failed to add new degrade rule, app={}, ip={}", entity.getApp(), entity.getIp(), t);
            return Result.ofThrowable(-1, t);
        }
        if (!publishRules(entity.getApp(), entity.getIp(), entity.getPort())) {
            logger.warn("Publish degrade rules failed, app={}", entity.getApp());
        }
        return Result.ofSuccess(entity);
    }

    @PutMapping("/rule/{id}")
    @AuthAction(PrivilegeType.WRITE_RULE)
    public Result<DegradeRuleEntity> apiUpdateRule(@PathVariable("id") Long id,
                                                   @RequestBody DegradeRuleEntity entity) {
        if (id == null || id <= 0) {
            return Result.ofFail(-1, "id can't be null or negative");
        }
        DegradeRuleEntity oldEntity = repository.findById(id);
        if (oldEntity == null) {
            return Result.ofFail(-1, "Degrade rule does not exist, id=" + id);
        }
        entity.setApp(oldEntity.getApp());
        entity.setIp(oldEntity.getIp());
        entity.setPort(oldEntity.getPort());
        entity.setId(oldEntity.getId());
        Result<DegradeRuleEntity> checkResult = checkEntityInternal(entity);
        if (checkResult != null) {
            return checkResult;
        }

        entity.setGmtCreate(oldEntity.getGmtCreate());
        entity.setGmtModified(new Date());
        try {
            entity = repository.save(entity);
            publishRules(entity.getApp());
        } catch (Throwable t) {
            logger.error("Failed to save degrade rule, id={}, rule={}", id, entity, t);
            return Result.ofThrowable(-1, t);
        }
        if (!publishRules(entity.getApp(), entity.getIp(), entity.getPort())) {
            logger.warn("Publish degrade rules failed, app={}", entity.getApp());
        }
        return Result.ofSuccess(entity);
    }

    @DeleteMapping("/rule/{id}")
    @AuthAction(PrivilegeType.DELETE_RULE)
    public Result<Long> delete(@PathVariable("id") Long id) {
        if (id == null) {
            return Result.ofFail(-1, "id can't be null");
        }

        DegradeRuleEntity oldEntity = repository.findById(id);
        if (oldEntity == null) {
            return Result.ofSuccess(null);
        }

        try {
            repository.delete(id);
            publishRules(oldEntity.getApp());
        } catch (Throwable throwable) {
            logger.error("Failed to delete degrade rule, id={}", id, throwable);
            return Result.ofThrowable(-1, throwable);
        }
        if (!publishRules(oldEntity.getApp(), oldEntity.getIp(), oldEntity.getPort())) {
            logger.warn("Publish degrade rules failed, app={}", oldEntity.getApp());
        }
        return Result.ofSuccess(id);
    }

    private boolean publishRules(String app, String ip, Integer port) {
        List<DegradeRuleEntity> rules = repository.findAllByMachine(MachineInfo.of(app, ip, port));
        return sentinelApiClient.setDegradeRuleOfMachine(app, ip, port, rules);
    }

    private <R> Result<R> checkEntityInternal(DegradeRuleEntity entity) {
        if (StringUtil.isBlank(entity.getApp())) {
            return Result.ofFail(-1, "app can't be blank");
        }
        if (StringUtil.isBlank(entity.getIp())) {
            return Result.ofFail(-1, "ip can't be null or empty");
        }
        if (entity.getPort() == null || entity.getPort() <= 0) {
            return Result.ofFail(-1, "invalid port: " + entity.getPort());
        }
        if (StringUtil.isBlank(entity.getLimitApp())) {
            return Result.ofFail(-1, "limitApp can't be null or empty");
        }
        if (StringUtil.isBlank(entity.getResource())) {
            return Result.ofFail(-1, "resource can't be null or empty");
        }
        Double threshold = entity.getCount();
        if (threshold == null || threshold < 0) {
            return Result.ofFail(-1, "invalid threshold: " + threshold);
        }
        Integer recoveryTimeoutSec = entity.getTimeWindow();
        if (recoveryTimeoutSec == null || recoveryTimeoutSec <= 0) {
            return Result.ofFail(-1, "recoveryTimeout should be positive");
        }
        Integer strategy = entity.getGrade();
        if (strategy == null) {
            return Result.ofFail(-1, "circuit breaker strategy cannot be null");
        }
        if (strategy < CircuitBreakerStrategy.SLOW_REQUEST_RATIO.getType()
                || strategy > RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT) {
            return Result.ofFail(-1, "Invalid circuit breaker strategy: " + strategy);
        }
        if (entity.getMinRequestAmount() == null || entity.getMinRequestAmount() <= 0) {
            return Result.ofFail(-1, "Invalid minRequestAmount");
        }
        if (entity.getStatIntervalMs() == null || entity.getStatIntervalMs() <= 0) {
            return Result.ofFail(-1, "Invalid statInterval");
        }
        if (strategy == RuleConstant.DEGRADE_GRADE_RT) {
            Double slowRatio = entity.getSlowRatioThreshold();
            if (slowRatio == null) {
                return Result.ofFail(-1, "SlowRatioThreshold is required for slow request ratio strategy");
            } else if (slowRatio < 0 || slowRatio > 1) {
                return Result.ofFail(-1, "SlowRatioThreshold should be in range: [0.0, 1.0]");
            }
        } else if (strategy == RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO) {
            if (threshold > 1) {
                return Result.ofFail(-1, "Ratio threshold should be in range: [0.0, 1.0]");
            }
        }
        return null;
    }

    private void publishRules(/*@NonNull*/ String app) throws Exception {
        List<DegradeRuleEntity> rules = repository.findAllByApp(app);
        publisher.publish(app, rules);
    }
}

6. 构建启动DashboardApplication

7.效果展示

  • 同步前：
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

  • 同步后（服务本地配置与控制面板、Nacos配置）：

    • 控制面板
      在这里插入图片描述
    • 服务本地在这里插入图片描述
    • Nacos持久化
      在这里插入图片描述
子木倾然
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Sentinel动态推拉数据持久化同步到Nacos
程序员劝退师的博客
05-07 1074
前言 在我们使用Sentinel做熔断限流等操作时，一些设置好的配置默认是存放在当前服的内存中的，那么也就意味着每次重启服务，这些配置好的配置就会消失。在我们搭建微服务架构做测试的时候不是很友好。大家都知道Sentinel提供了一些持久化方式，如持久化到Nacos、本地JSON文件。这种方式虽然能解决持久化的操作，但是不能自动同步更新，也就是持久化配置写成什么样就是什么样，在程序启动后，无法动态更新到持久化存储中！当然能做到持久化Nacos或者本地JSON已经很不错了！如果作用做到这一步那么请见Sentin
Sentinel规则持久化到Nacos教程
小薯条的博客
11-28 3486
如何将Sentinel规则持久化到Nacos
springCloud-Alibaba——改造sentinel控制台数据规则推送持久化到nacos
LSY_CSDN_的博客
03-26 2081
目录 A、核心思路： B、自己修改—注释流控规则内存页： C、自己修改—注释流控规则回到单机页面按钮： D、自己修改—簇点链路中流控存到nacos： E、自己修改—增加可配置nacos地址： F、微服务接入控制台增加配置信息： G、启动测试： F、个人修改后安装包下载地址： 本文采用的是生产环境使用的Push模式将sentinel规则持久化到nacos： 官方说明： http...
sentinel实现gateway网关限流规则持久化
bright的博客
09-30 2524
sentinel实现gateway网关限流规则持久化 上一篇文件介绍了怎么实现网关怎么限流 1.网关限流持久化 1.1maven依赖 <dependencies> <<!--sentinel限流熔断 --> <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cl
sentinel配置自定义更新到nacos解决方案
qq_41190902的博客
10-12 1346
网上很多改造dashboard源码直接和nacos同步，然后sentinel再和nacos同步的方案但是总觉得有如下问题：此功能既然已经再test代码了，也就是以后也必定会发布，此时固定版本改造，等发布了新版，如果还没发布此功能，又得重新找一个对应得自定义改造得版本实在是麻烦，何不制作一个小代价的更新版本，既合适新版升级，又代价不太大的。
Java学习-Sentinel 1.8.4 规则持久化到Nacos
最新发布
05-31
在 Sentinel 1.8.4 版本中，支持将规则持久化到 Nacos，这是一种非常实用的功能，使得配置的规则可以在服务重启后依然生效，增强了系统的容错性和可维护性。 首先，我们要理解 Sentinel 的核心概念。Sentinel 提供...
sentinel 1.8.3持久化到nacos
04-28
5. **监控和调整**：使用 Sentinel Dashboard 可以实时查看应用的流量控制、熔断和降级效果，根据业务需求调整规则，所有的变更都会同步到 Nacos 中。 6. **扩展性**：Nacos 支持多种数据结构，这意味着 Sentinel ...
改造 Sentinel Dashboard 将规则持久化到Nacos
12-21
簇点链路 的流控的改造了一下
Sentinel-dashboard 1.8.5 流控规则持久化到ncos版
09-17
1. 限流规则 自动持久化到 nacos 2. 熔断规则 自动持久化到 nacos 3. 系统规则 自动持久化到 nacos 启动命令 java -Dnacos.serverAddr=192.168.31.100:8848 -Dnacos.namespace=TEST -Dnacos.groupId=DEFAULT_...
sentinel-dashboard.rar(修改使规则同步至nacos源码)
12-09
本文将详细讲解如何修改 Sentinel Dashboard 的源码，使其能够将规则同步到 Nacos。 1. **Sentinel Dashboard 与 Nacos 集成** Sentinel Dashboard 默认并不直接支持规则同步到 Nacos，但可以通过扩展其 API 来...
Sentinel配置规则持久化至Nacos
weixin_42270645的博客
03-10 6924
文中使用的nacos版本1.4.2、sentinel版本1.8.3 问题 当集成了Sentinel的客户端应用重启之后，在控制台配置的规则全部都没有了，如果需要上生产环境需要将规则配置进行持久化。下面就来实现Sentinel规则配置持久化。 添加Maven依赖 需要持久化至nacos就需要添加相关Maven依赖 <!-- Sentinel Datasource 依赖 --> <dependency> <groupId>com.alibaba.cloud<.
Sentinel系列之集成Nacos实现规则同步持久化
qq_38377525的博客
02-26 2527
Sentinel系列之集成Nacos实现规则同步持久化
Sentinel控制台改造：规则同步到Nacos
dsh153的博客
04-26 3482
Sentinel生产环境改造控制台使规则同步到Nacos首先下载Sentinel控制台的源码修改pom.xml文件修改sidebar.html创建Nacos配置类拉取Nacos配置推送配置给Nacos修改注入的Bean 官方给出的文档：在生产环境中使用-Sentinel 我们要实现push 模式，推送规则为Sentinel 控制台 → Nacos配置中心 → Sentinel 数据源 → Sent...
sentinel安装以及同步限流规则持久化到nacos
qq_28358461的博客
03-19 447
【代码】sentinel安装以及同步限流规则持久化到nacos。
Sentinel 基于Nacos规则持久化-推模式
Gblfy_Blog
07-25 1312
文章目录一、推模式架构图二、原理简述三、Sentinel控制台改造3.1. 下载源码3.2. 修改pom3.3. 重要文件复制3.4. 注册地址修改3.5. 请求实例需改3.6. 菜单新增四、编译 & 启动4.1. 先启动nacos4.2. 编译打包4.3. 创建微服务 && 启动4.4. 刷新sentinel4.5. 登录nacos4.6. sentinel 规则删除4.7. nacos规则查看4.8. 规则扩展 一、推模式架构图 图片引用自 https://github
限流神器Sentinel与nacos数据双向同步
fcclzydouble的博客
03-31 1206
在seintinel-dashboard要获取nacos配置中的配置数据，就是实现：DynamicRuleProvider接口，最后最重要的步骤是在你自已的应用里bootstrap.yaml中sentinel配置：下面是我的配置，主要是看。注意在你的应用pom中增加依赖库，
SpringClouldAlibaba 之 Sentinel流控规则同步到nacos（并重新生成镜像）
JHIII的博客
08-08 399
毕竟在nacos中维护这个流控规则不太友好，毕竟sentinel为我们提供了可视化界面，我们只需要修改修改 sentinel-dashboard这个工程然后重新制作一个镜像（docker）就可以了。为什么改它而不是v2 呢因为我们在添加流控规则时打开f12 看到走的方法是v1的。//配置nacos的地址。因为是在github上网不好下载有点慢这里我放一个 gitee上的地址。我们把这几个配置类复制到上面同目录下去（这个nacos 是我创建的包）我们需要去 /etc/sysctl.conf。...
Sentinel推送配置到nacos
weixin_42942786的博客
09-19 1697
Sentinel推送配置到nacos*Sentinel推送配置到nacossentinel是如何加载到目标服务的ip和端口？ Sentinel推送配置到nacos 一、首先下载sentinel的源码 https://github.com/alibaba/Sentinel 二、修改sentinel的jar包 注释scope ，不然无法在主程序中使用 <dependency> <groupId>com.alibaba.csp</groupId> <
sentinel规则持久化到Nacos后，修改sentinel规则会不会同步到nacos
05-21
Sentinel规则持久化到Nacos后，修改Sentinel规则不会自动同步到Nacos。需要手动更新Nacos中的规则。 在Sentinel中，规则和配置是分开的，规则是实时生效的，而配置则需要重启Sentinel才能生效。如果您想修改规则并...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值