[学习铺垫]

  • setinel指南
  • 吞吐量（TPS）、QPS、并发数、响应时间（RT）概念

    微服务带来的问题

    在微服务等分布式架构中，服务容错是老生常谈的问题了，我们都知道在微服务架构中会存在多个微服务，而绝大部分微服务之间都会存在调用关系，
    若由于某个底层服务不可用从而产生连锁反应，导致一系列的上层服务崩溃、故障，这种现象被称为雪崩效应或级联故障
    所以在微服务等分布式架构中，能够防御服务雪崩效应的容错方案是必不可少的，

    常见的容错方案

    1、超时限制：
    设置请求超时时间，让请求线程在等待超过一定的时间后就判定为请求失败从而释放请求线程，在某些场景下线程释放得够快的话，就不会因为不断创建线程而导致资源耗尽引起的服务崩溃。

2、接口限流：
例如，上图中的服务A只能承受1k左右的QPS，那么就设置一个最大请求数量阈值，当QPS达到1k时就拒绝在这之后的请求。就像是我只能吃一碗饭，就算给我三碗我也只吃一碗。

3、舱壁模式：
舱壁模式实际上就是借鉴于现实生活中的船舱结构而设计，一艘船想要不那么容易沉也需要具备有一定的”容错“能力，而早期的船由于设计上的欠缺，只要一个地方进水了，那么水就会逐渐漫进整个船舱，这种结构的船几乎没有“容错”能力，所以就比较容易沉。于是此时就有人想到将原本一体的船舱分隔成一个个独立的船舱，船舱之间都使用钢板焊死隔开，这些钢板就是所谓的舱壁了。采用这种设计后，就算当其中一个两个船舱进水了，也不会影响到其他船舱，这艘船依旧能够正常行驶。
在软件层面上借鉴这种思想，我们可以让每个服务都运行在自己独立的线程池中，线程池之间是互不干扰的，服务A的线程池资源耗尽也不会影响到服务B。此时线程池就像船舱的舱壁一样将不同的服务资源隔离开来，这样某个服务挂掉也不会影响其他服务的运行。

4、断路器模式：
断路器模式的思想实际上和家里的断路器一样，在软件层面大致就是对某个服务的API进行监控，若在一定时间内调用的失败率或失败次数达到指定的阈值就认为该API是不可用的从而触发“跳闸”，即此时断路器就处于打开状态。过了一段时间后断路器会处于一个半开状态，若在半开状态时尝试调用该API成功后就会关闭断路器，否则依旧认为不可用让断路器继续处于打开状态

1.Sentinel概述

[官方文档]
Sentinel 是什么，官方描述如下：
随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel 是面向分布式服务架构的轻量级流量控制、熔断降级框架，主要以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度来帮助您保护服务的稳定性。

Setinel特性是什么？

  • 丰富的应用场景：Sentinel 承接了阿里巴巴近 10 年的双十一大促流量的核心场景，例如秒杀（即突发流量控制在系统容量可以承受的范围）、消息削峰填谷、集群流量控制、实时熔断下游不可用应用等。
  • 完备的实时监控：Sentinel 同时提供实时的监控功能。您可以在控制台中看到接入应用的单台机器秒级数据，甚至 500 台以下规模的集群的汇总运行情况。
  • 广泛的开源生态：Sentinel 提供开箱即用的与其它开源框架/库的整合模块，例如与 Spring Cloud、Apache Dubbo、gRPC、Quarkus 的整合。您只需要引入相应的依赖并进行简单的配置即可快速地接入 Sentinel。同时 Sentinel 提供 Java/Go/C++ 等多语言的原生实现。
  • 完善的 SPI 扩展机制：Sentinel 提供简单易用、完善的 SPI 扩展接口。您可以通过实现扩展接口来快速地定制逻辑。例如定制规则管理、适配动态数据源等。

image.png

Sentinel 分为两个部分:

  • 核心库（Java 客户端）不依赖任何框架/库，能够运行于所有 Java 运行时环境，同时对 Dubbo / Spring Cloud 等框架也有较好的支持。
  • 控制台（Dashboard）基于 Spring Boot 开发，打包后可以直接运行，不需要额外的 Tomcat 等应用容器。

我们说的资源，可以是任何东西，服务，服务里的方法，甚至是一段代码。使用 Sentinel 来进行资源保护，主要分为几个步骤:

  1. 定义资源
  2. 定义规则
  3. 检验规则是否生效

先把可能需要保护的资源定义好（埋点），之后再配置规则。也可以理解为，只要有了资源，我们就可以在任何时候灵活地定义各种流量控制规则。在编码的时候，只需要考虑这个代码是否需要保护，如果需要保护，就将之定义为一个资源。
对于主流的框架，我们提供适配，只需要按照适配中的说明配置，Sentinel 就会默认定义提供的服务，方法等为资源。

2.Setinel规则种类

Sentinel 的所有规则都可以在内存态中动态地查询及修改，修改之后立即生效。同时 Sentinel 也提供相关 API，供您来定制自己的规则策略。
Sentinel 支持以下几种规则：流量控制规则、熔断降级规则、系统保护规则、来源访问控制规则 和 热点参数规则。

2.1 流量控制规则(FlowRule)

  • 同一个资源可以同时有多个限流规则，检查规则时会依次检查。
  • 我们可以通过调用 FlowRuleManager.loadRules() 方法来用硬编码的方式定义流量控制规则，比如： ```java /**
  • 限流规则： / private void initFlowRule() { List rules = new ArrayList<>(); FlowRule rule = new FlowRule(); //资源名，资源名是限流规则的作用对象 rule.setResource(RESOURCES_NAME); //限流阈值类型，QPS 模式（1）或并发线程数模式（0） rule.setGrade(RuleConstant.FLOW_GRADE_QPS); // Set limit QPS to 20. rule.setCount(2);//限流阈值 //流控针对的调用来源.默认default，代表不区分调用来源 rule.setLimitApp(“default”); //调用关系限流策略：0:直接 1:关联 2:链路.默认根据资源本身（直接） rule.setStrategy(RuleConstant.STRATEGY_DIRECT); //流控效果，不支持按调用关系限流.0. default(reject directly), 1. warm up 2. rate limiter 3. warm up + rate limiter rule.setControlBehavior(0); //是否集群限流。默认false rule.setClusterMode(false); rules.add(rule); FlowRuleManager.loadRules(rules); } ``` 更多详细内容可以参考 流量控制。

2.2 熔断降级规则(DegradeRule)

  • 同一个资源可以同时有多个降级规则。
  • 通过调用 DegradeRuleManager.loadRules() 方法来用硬编码的方式定义流量控制规则。
    1. private void initDegradeRule() {
    2.   List<DegradeRule> rules = new ArrayList<>();
    3.   DegradeRule rule = new DegradeRule();
    4.   rule.setResource(RESOURCES_NAME);//资源名，即规则的作用对象
    5.   rule.setGrade(RuleConstant.DEGRADE_GRADE_RT);//熔断策略，支持慢调用比例/异常比例/异常数策略.默认慢调用比例
    6.   // set threshold RT, 10 ms
    7.   rule.setCount(10);//慢调用比例模式下为慢调用临界 RT（超出该值计为慢调用）；异常比例/异常数模式下为对应的阈值
    8.   rule.setTimeWindow(10);//熔断时长，单位为 s
    9.   rule.setMinRequestAmount(5);//熔断触发的最小请求数，请求数小于该值时即使异常比率超出阈值也不会熔断（1.7.0 引入）.默认5
    10.   rule.setStatIntervalMs(1000);//统计时长（单位为 ms），如 60*1000 代表分钟级（1.8.0 引入）默认1000ms
    11.   rule.setSlowRatioThreshold(0.5);//慢调用比例阈值，仅慢调用比例模式有效（1.8.0 引入）
    12.   rules.add(rule);
    13.   DegradeRuleManager.loadRules(rules);
    14. }
    更多详情可以参考 熔断降级。

    2.3 系统保护规则 (SystemRule)

    Sentinel 系统自适应限流从整体维度对应用入口流量进行控制，结合应用的 Load、CPU 使用率、总体平均 RT、入口 QPS 和并发线程数等几个维度的监控指标，通过自适应的流控策略，让系统的入口流量和系统的负载达到一个平衡，让系统尽可能跑在最大吞吐量的同时保证系统整体的稳定性。
    系统规则包含下面几个重要的属性：
    1. private void initSystemRule() {
    2.   List<SystemRule> rules = new ArrayList<>();
    3.   SystemRule rule = new SystemRule();
    4.   rule.setHighestSystemLoad(10);//load1 触发值，用于触发自适应控制阶段.默认-1
    5.   rule.setAvgRt(-1);//所有入口流量的平均响应时间.默认-1不生效
    6.   rule.setMaxThread(-1);//入口流量的最大并发数.默认-1不生效
    7.   rule.setQps(-1);//所有入口资源的 QPS.-1 (不生效)
    8.   rule.setHighestCpuUsage(-1);//当前系统的 CPU 使用率（0.0-1.0） 默认-1不生效
    9.   rules.add(rule);
    10.   SystemRuleManager.loadRules(rules);
    11. }
    注意系统规则只针对入口资源（EntryType=IN）生效。更多详情可以参考 系统自适应保护文档

2.4 来源访问控制规则

很多时候，我们需要根据调用方来限制资源是否通过，这时候可以使用 Sentinel 的访问控制（黑白名单）的功能。黑白名单根据资源的请求来源（origin）限制资源是否通过，若配置白名单则只有请求来源位于白名单内时才可通过；若配置黑名单则请求来源位于黑名单时不通过，其余的请求通过。
授权规则，即黑白名单规则（AuthorityRule）非常简单，主要有以下配置项：

  • resource：资源名，即规则的作用对象
  • limitApp：对应的黑名单/白名单，不同 origin 用 , 分隔，如 appA,appB
  • strategy：限制模式，AUTHORITY_WHITE 为白名单模式，AUTHORITY_BLACK 为黑名单模式，默认为白名单模式
    1. private void initAuthorityRule(){
    2.   List<AuthorityRule> rules = new ArrayList<>();
    3.   AuthorityRule rule = new AuthorityRule();
    4.   //资源名，即规则的作用对象
    5.   rule.setResource("")；      
    6.   //限制模式，AUTHORITY_WHITE 为白名单模式，AUTHORITY_BLACK 为黑名单模式，默认为白名单模式
    7.   rule.setStrategy(RuleConstant.AUTHORITY_WHITE);   
    8.   //对应的黑名单/白名单，不同 origin 用 , 分隔，如 appA,appB
    9.   rule.setLimitApp("");
    10.   rules.add(rule);
    11.   AuthorityRuleManager.loadRules(rules);
    12. }
    更多详情可以参考 来源访问控制。

    2.5 热点参数规则

    详情可以参考 热点参数限流。

3.Setinel使用

现在我们来为项目整合Sentinel，有两种方式

  • 硬编码方式

  • 注解方式

    编码方式

    1. <dependency>
    2. <groupId>com.alibaba.csp</groupId>
    3. <artifactId>sentinel-core</artifactId>
    4. <version>1.8.4</version>
    5. </dependency>

    ```java @RestController public class SentinelController {

    @PostConstruct public void init() {

    1.   List<FlowRule> rules = new ArrayList<>();
    2.   FlowRule rule = new FlowRule();
    3.   rule.setResource("HelloWorld");
    4.   rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
    5.   // Set limit QPS to 20.
    6.   rule.setCount(2);
    7.   rules.add(rule);
    8.   FlowRuleManager.loadRules(rules);

    }

    @GetMapping(“/hello”) public String hello(@RequestParam String message) { 

    1.   Entry entry = null;
    2.   try {
    3.       entry = SphU.entry(message);
    4.       /*您的业务逻辑 - 开始*/
    5.       System.out.println("hello world");
    6.       return "hello :" + message;
    7.       /*您的业务逻辑 - 结束*/
    8.   } catch (BlockException e1) {
    9.       /*流控逻辑处理 - 开始*/
    10.       System.out.println("block!");
    11.       /*流控逻辑处理 - 结束*/
    12.       throw new RuntimeException("接口被流控");
    13.   } finally {
    14.       if (entry != null) {
    15.           entry.exit();
    16.       }
    17.   }

    } }

  1. <a name="YTEeu"></a>
  2. ## 注解方式
  3. [[官方文档](https://github.com/alibaba/Sentinel/wiki/%E6%B3%A8%E8%A7%A3%E6%94%AF%E6%8C%81)]<br />Sentinel 提供了 @SentinelResource 注解用于定义资源，并提供了 AspectJ 的扩展用于自动定义资源、处理 BlockException 等。使用 [Sentinel Annotation AspectJ Extension](https://github.com/alibaba/Sentinel/tree/master/sentinel-extension/sentinel-annotation-aspectj) 的时候需要引入以下依赖
  4. ```xml
  5. <dependency>
  6.   <groupId>com.alibaba.csp</groupId>
  7.   <artifactId>sentinel-annotation-aspectj</artifactId>
  8.   <version>x.y.z</version>
  9. </dependency>

上面都是针对硬编码的方式进行资源的定义，代码入侵严重，下面使用注解的方式进行定义资源。
Sentinel 支持通过 @SentinelResource 注解定义资源并配置 blockHandler 和 fallback 函数来进行限流之后的处理。示例

  1. // 原本的业务方法.
  2. @SentinelResource(blockHandler = "blockHandlerForGetUser")
  3. public User getUserById(String id) {
  4.     throw new RuntimeException("getUserById command failed");
  5. }
  7. // blockHandler 函数，原方法调用被限流/降级/系统保护的时候调用
  8. public User blockHandlerForGetUser(String id, BlockException ex) {
  9.     return new User("admin");
  10. }

配置
Spring Cloud Alibaba
若您是通过 Spring Cloud Alibaba 接入的 Sentinel，则无需额外进行配置即可使用 @SentinelResource 注解。
Spring AOP
若您的应用使用了 Spring AOP（无论是 Spring Boot 还是传统 Spring 应用），您需要通过配置的方式将 SentinelResourceAspect 注册为一个 Spring Bean：

  1. @Configuration
  2. public class SentinelAspectConfiguration {
  4.     @Bean
  5.     public SentinelResourceAspect sentinelResourceAspect() {
  6.         return new SentinelResourceAspect();
  7.     }
  8. }

4.Spring Cloud Alibaba Sentinel

[官方文档]
随着微服务的流行，服务和服务之间的稳定性变得越来越重要。 Sentinel 以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。

第一步添加如下依赖

  1. <dependency>
  2.     <groupId>com.alibaba.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
  4. </dependency>
  5. <!-- actuator，用于暴露监控端点 -->
  6. <dependency>
  7.     <groupId>org.springframework.boot</groupId>
  8.     <artifactId>spring-boot-starter-actuator</artifactId>
  9. </dependency>

第二步配置actuator

  1. # 暴露所有端点
  2. management:
  3.   endpoints:
  4.     web:
  5.       exposure:
  6.         include: '*'
  7.   endpoint:
  8.     health:
  9.       show-details: always

所以接着到项目中整合一下Sentinel Dashboard的请求地址，在配置文件中添加如下配置：

  1. spring:
  2.   cloud:
  3.     sentinel:
  4.       transport:
  5.         # 配置sentinel控制台的地址
  6.         dashboard: 127.0.0.1:8080

流控规则演示

  • 直接：当前资源的QPS达到设定的阈值，就触发限流
  • 关联：当关联的资源的QPS达到设定的阈值，就触发限流。例如，/shares/1关联了/query，那么/query达到阈值，就会对/shares/1限流

  • 链路：只记录指定链路上的流量，这种模式是针对接口级别的来源进行限流
    链路模式稍微有些抽象，这里举个简单的例子说明一下。下图中有两个调用链路，图中的/test-b和/test-a实际就是两个接口，它们都调用了同一个common资源，所以/test-b和/test-a就称为common的入口资源：

    • 调用示例: ```java @Slf4j @Api(value = “ConsumerController”, tags = “控制器作用”) @RestController public class ConsumerController {

    @Resource private MicroFeginClient microFeginClient; /**

    • fallback：失败调用，若本接口出现未知异常，则调用fallback指定的接口。
    • blockHandler：sentinel定义的失败调用或限制调用，若本次访问被限流或服务降级，则调用blockHandler指定的接口。 */ @SentinelResource(
      1.  value = "hello2",
      2.  blockHandler = "blockHandlerFunc",
      3.  fallback = "fallbackFunc",
      4.  blockHandlerClass = SetinelHandler.class
      ) @ApiOperation(value = “hello”, notes = “演示1”) @GetMapping(“/hello”) public ApiResultResponse fec() { String hello = microFeginClient.hello(); return ApiResultResponse
      1.      .builder()
      2.      .result(hello)
      3.      .success(true)
      4.      .build();
      } } ```

  • 处理限流降级方法 必须为static ```java @Slf4j public class SetinelHandler { public static ApiResultResponse blockHandlerFunc(String a, BlockException e) {

    1.   // 如果被保护的资源被限流或者降级了，就会抛出BlockException
    2.   log.warn("资源被限流.", e);
    3.   return ApiResultResponse
    4.           .builder()
    5.           .message("接口限流了")
    6.           .errorCode(100)
    7.           .build();

    } public static ApiResultResponse fallbackFunc(String a) {

    1.   log.warn("资源被降级了.");
    2.   return ApiResultResponse
    3.           .builder()
    4.           .message("资源被降级了")
    5.           .errorCode(100)
    6.           .build();

    } }

  2. - 全局处理误信息进行相应优化,将上面替换成下面<br />Sentinel默认在当前服务触发限流或降级时仅返回简单的异常信息,所以我们需要对错误信息进行相应优化，以便可以细致区分触发的是什么规则
  3. ```java
  4. @Slf4j
  5. @Api(value = "ConsumerController", tags = "控制器作用")
  6. @RestController
  7. public class ConsumerController {
  9.     @Resource
  10.     private MicroFeginClient microFeginClient;
  12.     @ApiOperation(value = "hello2", notes = "演示2")
  13.     @GetMapping("/hello2")
  14.     public ApiResultResponse fec(@RequestParam String name) {
  15.         Student student = microFeginClient.hello2(name);
  16.         return ApiResultResponse
  17.                 .builder()
  18.                 .result(student)
  19.                 .success(true)
  20.                 .build();
  21.     }
  22. }

实现BlockExceptionHandler重写handle

  1. /**
  2.  * 当前方式会进行具体的控制规则进行输出
  3.  */
  4. @Component
  5. public class MyUrlBlockHandler implements BlockExceptionHandler {
  8.     @Override
  9.     public void handle(HttpServletRequest request, HttpServletResponse response, BlockException e) throws Exception {
  10.         String method = request.getMethod();
  11.         StringBuffer url = request.getRequestURL();
  12.         if ("GET".equals(method) && StringUtils.isNotBlank(request.getQueryString())) {
  13.             url.append("?").append(request.getQueryString());
  14.         }
  15.         ApiResultResponse resp = null;
  16.         // 不同的异常返回不同的提示语
  17.         if (e instanceof FlowException) {
  18.             resp = ApiResultResponse
  19.                     .builder()
  20.                     .message("接口限流")
  21.                     .errorCode(100)
  22.                     .build();
  23.         } else if (e instanceof DegradeException) {
  24.             resp = ApiResultResponse
  25.                     .builder()
  26.                     .message("服务降级")
  27.                     .errorCode(100)
  28.                     .build();
  29.         } else if (e instanceof ParamFlowException) {
  30.             resp = ApiResultResponse
  31.                     .builder()
  32.                     .message("热点参数限流")
  33.                     .errorCode(100)
  34.                     .build();
  36.         } else if (e instanceof SystemBlockException) {
  37.             resp = ApiResultResponse
  38.                     .builder()
  39.                     .message("触发系统保护规则")
  40.                     .errorCode(100)
  41.                     .build();
  43.         } else if (e instanceof AuthorityException) {
  44.             resp = ApiResultResponse
  45.                     .builder()
  46.                     .message("授权规则不通过")
  47.                     .errorCode(100)
  48.                     .build();
  49.         }
  50.         response.setStatus(500);
  51.         response.setCharacterEncoding("utf-8");
  52.         response.setContentType("application/json;charset=UTF-8");
  53.         new ObjectMapper().writeValue(response.getWriter(), resp);
  54.     }
  55. }

5.Sentinel Dashboard控制台

Sentinel 控制台提供一个轻量级的控制台，它提供机器发现、单机资源实时监控、集群资源汇总，以及规则管理的功能。您只需要对应用进行简单的配置，就可以使用这些功能。
Sentinel 控制台包含如下功能:

注意：

  1. Sentinel 控制台目前仅支持单机部署。Sentinel 控制台项目提供 Sentinel 功能全集示例，不作为开箱即用的生产环境控制台，不提供安全可靠保障。若希望在生产环境使用请根据文档自行进行定制和改造。
  2. 集群资源汇总仅支持 500 台以下的应用集群，有大概 1 - 2 秒的延时。

    https://github.com/alibaba/Sentinel/releases

Clipboard_2021-02-05-23-54-19.png
下载完成后，然后打开cmd，通过命令运行该jar包。如下：

java -jar sentinel-dashboard-1.6.3.jar

默认端口8080 可以指定启动端口 java -jar sentinel-dashboard-1.6.3.jar —server.port=8081

启动后页面如下.控制台用户密码 sentinel/sentinel
Clipboard_2021-02-06-00-05-15.png

监控到client如下

image.png

6.Setinel规则持久化

[官方参考文档]
我们在使用setinel控制台的时候，如果关闭服务，所做的规则配置将全部丢失，这在生产环境中是无法容忍的，所以我们要考虑到将规则进行持久化。
Setinel的持久化分为三种模式：pull，push，以及原始模式。这里主要讲述push模式。生产环境建议使用push模式。

  1. 原始模式
  • API 将规则推送至客户端并直接更新到内存中，扩展写数据源
  • 简单，无任何依赖
  • 不保证一致性；规则保存在内存中，重启即消失。严重不建议用于生产环境
  1. pull模式
  • 扩展写数据源， 客户端主动向某个规则管理中心定期轮询拉取规则，这个规则中心可以是 RDBMS、文件等。
  • 简单，无任何依赖；规则持久化。
  • 不保证一致性；实时性不保证，拉取过于频繁也可能会有性能问题。
  1. push模式
  • 扩展读数据源ReadableDataSource，规则中心统一推送，客户端通过注册监听器的方式时刻监听变化，比如使用 Nacos、Zookeeper 等配置中心。这种方式有更好的实时性和一致性保证。生产环境下一般采用 push 模式的数据源。
  • 规则持久化；一致性；快速。
  • 引入第三方依赖。

Setinel push模式

生产环境建议使用push模式。通过控制台设置规则后将规则推送到统一的规则中心，客户端实现 ReadableDataSource 接口端监听规则中心实时获取变更，流程如下：
image.png
DataSource 扩展常见的实现方式有:

  • 拉模式：客户端主动向某个规则管理中心定期轮询拉取规则，这个规则中心可以是 RDBMS、文件，甚至是 VCS 等。这样做的方式是简单，缺点是无法及时获取变更；
  • 推模式：规则中心统一推送，客户端通过注册监听器的方式时刻监听变化，比如使用 Nacos、Zookeeper 等配置中心。这种方式有更好的实时性和一致性保证。

如何实现push模式

下载Setinel源码修改Dashboard 规则。
Dashboard 规则改造主要通过2个接口：

  1. com.alibaba.csp.sentinel.dashboard.rule.DynamicRuleProvider
  2. com.alibaba.csp.sentinel.dashboard.rule.DynamicRulePublisher
  • Download Sentinel Source Code
  • 修改原sentinel-dashboard项目下的POM文件
    1. <!-- for Nacos rule publisher sample -->
    2. <dependency>
    3. <groupId>com.alibaba.csp</groupId>
    4. <artifactId>sentinel-datasource-nacos</artifactId>
    5. <!--注释掉原文件中的scope，让其不仅在test的时候生效-->
    6. <!--<scope>test</scope>-->
    7. </dependency>
  1. 复制sentinel-dashboard项目下test下的nacos包src/test/java/com/alibaba/csp/sentinel/dashboard/rule/nacos到 src/main/java/com/alibaba/csp/sentinel/dashboard/rule下。
  2. 修改NacosConfig中的指向Nacos 的ip和端口。

image.png

  • 修改controller中的默认provider & publisher

    com.alibaba.csp.sentinel.dashboard.controller.v2.FlowControllerV2中

  1. @RestController
  2. @RequestMapping(value = "/v2/flow")
  3. public class FlowControllerV2 {
  5.     @Autowired
  6.     //@Qualifier("flowRuleDefaultProvider")
  7.     @Qualifier("flowRuleNacosProvider")
  8.     private DynamicRuleProvider<List<FlowRuleEntity>> ruleProvider;
  10.     @Autowired
  11.     //@Qualifier("flowRuleDefaultPublisher")
  12.     @Qualifier("flowRuleNacosPublisher")
  13.     private DynamicRulePublisher<List<FlowRuleEntity>> rulePublisher;
  15. }

image.png
打开 ·/Sentinel-1.6.2/sentinel-dashboard/src/main/webapp/resources/app/scripts/directives/sidebar/
sidebar.html·文件

  1. <!--<li ui-sref-active="active" ng-if="entry.appType==0">-->
  2.     <!--<a ui-sref="dashboard.flow({app: entry.app})">-->
  3.         <!--<i class="glyphicon glyphicon-filter"></i>&nbsp;&nbsp;流控规则 V1</a>-->
  4. <!--</li>-->
  6. ------------改为
  8. <li ui-sref-active="active" ng-if="entry.appType==0">
  9.     <a ui-sref="dashboard.flow({app: entry.app})">
  10.         <i class="glyphicon glyphicon-filter"></i>&nbsp;&nbsp;流控规则 Nacos</a>
  11. </li>

image.png
Dashboard中要修改的代码已经好了。
重新启动 Sentinel-dashboard mvn clean package -DskipTests

client使用

  1. <!-- actuator，用于暴露监控端点 -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-actuator</artifactId>
  5. </dependency>
  6. <dependency>
  7.     <groupId>com.alibaba.cloud</groupId>
  8.     <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
  9. </dependency>
  10. <dependency>
  11.     <groupId>com.alibaba.csp</groupId>
  12.     <artifactId>sentinel-datasource-nacos</artifactId>
  13. </dependency>

bootstrap.yml

  1. spring:
  2.   application:
  3.     name: springcloud-order
  4.   cloud:
  5.     nacos:
  6.       config:
  7.         server-addr: 127.0.0.1:8848
  8.         file-extension: yaml
  9.       discovery:
  10.         server-addr: 127.0.0.1:8848
  11.     sentinel:
  12.       transport:
  13.         dashboard: 127.0.0.1:8080
  14.       datasource:
  15.         yibo_flow:
  16.           nacos:
  17.             server-addr: 127.0.0.1:8848
  18.             dataId: ${spring.application.name}-flow-rules
  19.             groupId: SENTINEL_GROUP
  20.             rule_type: flow

application.yml

  1. server:
  2.   port: 7003
  3. logging:
  4.   level:
  5.     com.itmck.feign: debug
  7. # 暴露所有端点
  8. management:
  9.   endpoints:
  10.     web:
  11.       exposure:
  12.         include: '*'
  13.   endpoint:
  14.     health:
  15.       show-details: always

访问nacos并创建
image.png
发布之后在sentinel控制台可以看到规则
image.png
通过sentinel控制台修改流控规则在nacos配置中可以看到实时修改