Sentinel 基本认识

• Sentinel 核心库：Sentinel 的核心库不依赖任何框架或库，能够运行于 Java 8 及以上的版本的运行时环境中，同时对 Spring Cloud、Dubbo 等微服务框架提供了很好的支持。
• Sentinel 控制台（Dashboard）：Sentinel 提供的一个轻量级的开源控制台，它为用户提供了机器自发现、簇点链路自发现、监控、规则配置等功能。

Sentinel 核心库不依赖 Sentinel Dashboard，但两者结合使用可以有效的提高效率，让 Sentinel 发挥它最大的作用。

• 查看机器列表以及健康情况：Sentinel 控制台能够收集 Sentinel 客户端发送的心跳包，判断机器是否在线。
• 监控（单机和集群聚合）：Sentinel 控制台通过 Sentinel 客户端暴露的监控 API，可以实现秒级的实时监控。
• 规则管理和推送：通过 Sentinel 控制台，我们还能够针对资源定义和推送规则。
• 鉴权：从 Sentinel 1.6.0 起，Sentinel 控制台引入基本的登录功能，默认用户名和密码都是 sentinel。

安装 Sentinel Dashboard

1. 下载Sentinel Dashboard <font style="color:rgb(68, 68, 68);">jar</font> 地址入口Releases · alibaba/Sentinel

1. 打开命令行窗口，跳转 Sentinel Dashboard jar 包所在的目录，执行以下命令，启动 Sentinel Dashboard

java -jar sentinel-dashboard-1.8.5.jar

1. 访问 http://localhost:8080/ 默认账号/密码：sentinel/sentinel

Sentinel 使用步骤方法

1. 新建 Module spring-cloud-alibaba-sentinel-8501

1. 导入 Sentinel依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!--父工程-->
    <parent>
        <groupId>com.chen</groupId>
        <artifactId>spring-cloud-alibaba-demo</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <groupId>com.chen</groupId>
    <artifactId>spring-cloud-alibaba-sentinel-8501</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-cloud-alibaba-sentinel-8501</name>
    <description>spring-cloud-alibaba-sentinel-8501</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--SpringCloud ailibaba nacos -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!--SpringCloud ailibaba sentinel -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.3.8</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

1. yaml 配置

server:
  port: 8501

spring:
  application:
    name: chen-sentinel-service
  cloud:
    nacos:
      discovery:
        #Nacos服务注册中心地址
        server-addr: 127.0.0.1:8848
    sentinel:
      transport:
        #配置Sentinel dashboard地址
        dashboard: 127.0.0.1:8080
        #默认8719端口，假如被占用会自动从8719开始依次+1扫描,直至找到未被占用的端口
        port: 8917

management:
  endpoints:
    web:
      exposure:
        include: '*'

1. 主启动类添加 <font style="color:#9e880d;">@EnableDiscoveryClient</font>

package com.chen.springcloudalibabasentinel8501;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class SpringCloudAlibabaSentinel8501Application {

    public static void main(String[] args) {
        SpringApplication.run(SpringCloudAlibabaSentinel8501Application.class, args);
    }

}

1. 业务类

package com.chen.springcloudalibabasentinel8501.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class FlowLimitController {

    @Value("${server.port}")
    private String serverPort;


    @GetMapping("/testA")
    public String testA() {
        return "serverPort:[" + serverPort + "],testA……";
    }

    @GetMapping("/testB")
    public String testB() {
        return "serverPort:[" + serverPort + "],testB……";
    }
}

1. Sentinel采用懒加载机制。所以请求 http://localhost:8501/testB后，Sentinel 控制台 首页 下方新增了一个 chen-sentinel-service 的菜单，而这正是 spring-cloud-alibaba-sentinel-8501 的服务名（spring.application.name），说明 Sentinel 已经监控到这个服务，如下图。

实时监控

可以实时监测我们的服务请求次数，我们多次刷新请求页面，这里都可以记录下来

定义资源

• 适配主流框架自动定义资源
• 通过 SphU 手动定义资源
• 通过 SphO 手动定义资源
• 注解方式定义资源

适配主流框架自动定义资源

通过 SphU 手动定义资源

Sentinel 提供了一个名为 SphU 的类，它包含的 try-catch 风格的 API ，可以帮助我们手动定义资源。使用步骤如下：

1. 在SentinelFlowLimitController 中新增一个 <font style="color:#00627a;">testCbySphU</font>()方法定义一个名为 <font style="color:#00627a;">testCbySphU</font>的资源，代码如下

@GetMapping("/testC")
public String testC() {
    return testCbySphU();
}

/**
 * 通过 SphU 手动定义资源
 */
public String testCbySphU() {
    Entry entry = null;
    try {
        entry = SphU.entry("testAbySphU");
        String str = "testCbySphU端口[" + serverPort + "]请求成功";
        System.out.println(str);
        return str;
    } catch (BlockException e) {
        String str = "testCbySphU端口[" + serverPort + "]请求被限流";
        System.out.println(str);
        return str;
    } finally {
        if (entry != null) {
            entry.exit();
        }
    }
}

1. 重启项目，浏览器访问 http://localhost:8501/testC

通过 SphO 手动定义资源

1. 在SentinelFlowLimitController 中新增一个 <font style="color:#00627a;">testDbySphO</font>()方法定义一个名为 testDbySphO的资源，代码如下

@GetMapping("/testD")
public String testD() {
    return testDbySphO();
}

/**
 * 通过 SphO 手动定义资源
 */
public String testDbySphO() {
    if (SphO.entry("testDbySphO")) {
        // 务必保证finally会被执行
        try {
            String str = "testDbySphU端口[" + serverPort + "]请求成功";
            return str;
        } finally {
            SphO.exit();
        }
    } else {
        // 资源访问阻止，被限流或被降级
        //流控逻辑处理 - 开始
        String str = "testDbySphU端口[" + serverPort + "]请求被限流";
        return str;
        //流控逻辑处理 - 结束
    }
}

1. 重启项目，浏览器访问 http://localhost:8501/testD

注解方式定义资源（推荐）

1. 在SentinelFlowLimitController 中新增一个 <font style="color:#00627a;">testEbyAnnotation</font>()方法定义一个名为 testEbyAnnotation的资源，代码如下

@GetMapping("/testE")
@SentinelResource("testEbyAnnotation")
public String testE() {
    return testEbyAnnotation();
}

public String testEbyAnnotation(){
    String str = "testEbySphU端口[" + serverPort + "]请求成功";
    return str;
}

1. 重启项目，浏览器访问 http://localhost:8501/testE

Sentinel 流量控制

• QPS（每秒钟的请求数量）：当调用该api的QPS达到阈值的时候，进行限流。线程数：当调用该api的线程数达到阈值的时候，进行限流

• 直接：api达到限流条件时，直接限流
• 关联：当关联的资源达到阈值时，就限流自己
• 链路：只记录指定链路上的流量（指定资源从入口资源进来的流量，如果达到阈值，就进行限流）【api级别的针对来源】

• 快速失败：直接失败，抛异常
• Warm Up：根据codeFactor（冷加载因子，默认3）的值，从阈值／codeFactor，经过预热时长，才达到设 置的QPS阈值
• 排队等待：匀速排队，让请求以匀速的速度通过，阈值类型必须设置为QPS，否则无效

流量控制简单使用

QPS 表示并发请求数，即每秒钟最多通过的请求数。

Sentinel 控制台定义流控规则

1. SentinelFlowLimitController 中新增一个名为 testF 的服务方法如下：

@GetMapping("/testF")
public String testF() {
    return "serverPort:[" + serverPort + "],testF……";
}

1. 重启服务，访问 http://localhost:8501/testF

1. 到控制台对资源设置规则

1. 快速连续（频率大于每秒钟 2 次）访问 http://localhost:8501/testF，结果如下

• blockHandler 函数访问范围需要是 public；
• 返回类型需要与原方法相匹配；
• 参数类型需要和原方法相匹配并且最后加一个额外的参数，类型为 BlockException；
• blockHandler 函数默认需要和原方法在同一个类中，若希望使用其他类的函数，则可以指定 blockHandler 为对应的类的 Class 对象，注意对应的函数必需为 static 函数，否则无法解析。
• 请务必添加 blockHandler 属性来指定自定义的限流处理方法，若不指定，则会跳转到错误页（用户体验不好）。

1. 在Sentinel 控制台主页，点击 sentinel-sevice 下的 簇点链路，点击资源<font style="color:rgb(68, 68, 68);">testD-resource</font>右侧的 +流控 按钮，并在弹出的“新增流控规则”窗口中为这个资源定义流控规则，流控规则内容为 ：QPS 的阈值为 2
2. 快速连续（频率大于每秒钟 2 次）访问 http://localhost:8501/testF 结果如下：

通过代码定义流量控制规则

https://www.yuque.com/chenlaohan/xnax4v/akgnzc?inner=eMoQ1

1. 定义一个 <font style="color:rgb(68, 68, 68);">initFlowRules() </font>方法，为名为 <font style="color:rgb(68, 68, 68);">testD-resource</font> 的资源定义流控规则：每秒最多只能通过 2 个请求，即 QPS 的阈值为 2。在 testF() 方法中调用 initFlowRules() 方法，初始化流控规则

@GetMapping("/testF")
@SentinelResource(value = "testF-resource",blockHandler = "blockHandlerTestF")
public String testF() {
    initFlowQpsRule();
    return "serverPort:[" + serverPort + "],testF……";
}

public String blockHandlerTestF(BlockException exception){
    String str = Thread.currentThread().getName() + "端口[" + serverPort + "]请求被限流，请稍后重试";
    return str;
}

private static void initFlowQpsRule() {
    List<FlowRule> rules = new ArrayList<>();
    //定义一个限流规则对象
    FlowRule rule1 = new FlowRule();
    //资源名称
    rule1.setResource("testF-resource");
    //设置QPS的阈值为2
    rule1.setCount(2);
    //限流阈值的类型
    rule1.setGrade(RuleConstant.FLOW_GRADE_QPS);
    rule1.setLimitApp("default");
    rules.add(rule1);
    FlowRuleManager.loadRules(rules);
}

1. 浏览器访问 http://localhost:8501/testF，每秒访问超过2次

流控模式

流控模式有一下三种情况

• 直接：api达到限流条件时，直接限流
• 关联：当关联的资源达到阈值时，就限流自己
• 链路：只记录指定链路上的流量（指定资源从入口资源进来的流量，如果达到阈值，就进行限流）【api级别的针对来源】

直接（默认）+ 快速失败（默认）

QPS直接快速失败

QPS：query per second，每秒钟的请求数量，当调用该api的QPS达到阈值时，进行限流。

下面设置表示每秒请求两次或以内是OK，若QPS>2，就直接-快速失败，报默认错误

线程数直接失败

当调用该api的线程数达到阈值的时候，进行限流和QPS类似。

与QPS直接快速失败不同的是，QPS情况下限制的是流量，比如银行的人流量只能是1人/s，也就是说每次只能一个人进入银行办理业务；而线程数就好比银行只有一个窗口开放，一群人都可以进入银行，但是每次只能处理一个人的业务。

在请求中给线程休眠 0.9秒

@GetMapping("/testG")
public String testG() {
    try {
        Thread.sleep(9000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "serverPort:[" + serverPort + "],testG……";
}

多次请求，创建多个线程。这里直接报错

关联

当关联的资源达到阈值时，就限流自己。比如当与A关联的资源B达到阈值后，就限流A自己。使用如下：

创建两个请求资源

@GetMapping("/testG")
public String testG() {
    return "serverPort:[" + serverPort + "],testG……";
}

@GetMapping("/testH")
public String testH() {
    return "serverPort:[" + serverPort + "],testH……";
}

添加流控规则。当请求 资源/testH超过阈值时，限流资源 /testG资源请求

Postman模拟并发密集访问testG。先创建一个集合，名字自己随便取。

新建一个组，创建一个请求，请求我们的 http://localhost:8501/testH。选中组创建并发请求

请求过程中会发现在请求 http://localhost:8501/testG 就限流了

链路

作用：只针对从指定链路访问到本资源的请求做统计，判断是否超过阈值。

• 关联 ：假设A规则关联B，那么A资源是受限制的
• 链路 ：假设A规则绑定了一个链路 关联B，那么受限制的是B

:::

流控效果

快速失败

默认的流控效果，直接失败，抛出异常。可以参考上方所写过的：https://www.yuque.com/chenlaohan/xnax4v/akgnzc#j8UNT

Warm Up

刚开始把 阈值调低，不要让过多的请求访问服务器，导致冲垮服务器，先让服务器一点一点处理，再慢慢加量

预热公式：阈值 除以 coldFactor(默认值为3),经过预热时长后才会达到阈值

默认coldFactor为3，即请求QPS从(threshold / 3)开始，经多少预热时长才逐渐升至设定的QPS阈值。

如下案例，阀值为10，预热时长设置5秒。

系统初始化的阀值为10 / 3约等于3，即阀值刚开始为3，然后经过 5秒后阀值才慢慢升高恢复到10。这样做的目的就是防止瞬间高并发导致系统奔溃

排队等待

2022-08-24 15:01:09.324  INFO 10980 --- [nio-8501-exec-7] c.c.s.controller.FlowLimitController     : http-nio-8501-exec-7：testH
2022-08-24 15:01:10.324  INFO 10980 --- [nio-8501-exec-6] c.c.s.controller.FlowLimitController     : http-nio-8501-exec-6：testH
2022-08-24 15:01:11.325  INFO 10980 --- [nio-8501-exec-8] c.c.s.controller.FlowLimitController     : http-nio-8501-exec-8：testH
2022-08-24 15:01:12.325  INFO 10980 --- [nio-8501-exec-5] c.c.s.controller.FlowLimitController     : http-nio-8501-exec-5：testH
2022-08-24 15:01:13.325  INFO 10980 --- [nio-8501-exec-9] c.c.s.controller.FlowLimitController     : http-nio-8501-exec-9：testH
2022-08-24 15:01:14.324  INFO 10980 --- [io-8501-exec-10] c.c.s.controller.FlowLimitController     : http-nio-8501-exec-10：testH
2022-08-24 15:01:15.324  INFO 10980 --- [nio-8501-exec-2] c.c.s.controller.FlowLimitController     : http-nio-8501-exec-2：testH
2022-08-24 15:01:16.324  INFO 10980 --- [nio-8501-exec-1] c.c.s.controller.FlowLimitController     : http-nio-8501-exec-1：testH
2022-08-24 15:01:17.325  INFO 10980 --- [nio-8501-exec-4] c.c.s.controller.FlowLimitController     : http-nio-8501-exec-4：testH
2022-08-24 15:01:18.325  INFO 10980 --- [nio-8501-exec-3] c.c.s.controller.FlowLimitController     : http-nio-8501-exec-3：testH

熔断降级规则

官网参考：circuit-breaking

Sentinel 熔断策略

Sentinel 熔断降级配置规则

熔断降级规则（DegradeRule）包含下面几个重要的属性：

Sentinel 熔断状态

Sentinel 1.8.0版本对熔断降级做了大的调整，可自定义任意时长的熔断时间，引入了半开启恢复支持。熔断状态有三种状态，非别为<font style="color:rgb(77, 77, 77);">OPEN、HALF_OPEN、CLOSED</font>

慢调用比例

1. 编写业务测试方法

@GetMapping("/testI")
public String testI() {
    String str =  "serverPort:[" + serverPort + "],testI，测试慢调用比例RT";
    try {
        //暂停1秒
        TimeUnit.MILLISECONDS.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    log.info(str);
    return str;
}

1. 配置给资源熔断规则

此配置代表 在1000ms统计时长内，总请求数超过5次请求有80%的最大RT超过200ms的就进行熔断2s

1. Jmeter压力测试

使用Jmeter模拟 1s请求10个线程（大于最小请求数5个的设置）调用/testI

第一步：添加线程组，设置线程数和下方时间。下方表示1s请求10次	第二步：添加一个请求
第三步：发送请求

应为程序中设置了休眠 1000s，从实时监控可以看出只是第一个线程请求是OK的，后续9个线程请求都被限流了。

异常比例

1000ms统计时长内，大于5次的请求中超过80%的请求出现异常，则熔断2s

@GetMapping("/testI")
public String testI() {
    String str =  "serverPort:[" + serverPort + "],testI，测试慢调用比例RT";
    try {
        //暂停1秒
        TimeUnit.MILLISECONDS.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    log.info(str);
    int i = 10 / 0; //并发测试这里模拟异常
    return str;
}

Jmeter 单独访问一次，必然来一次报错一次(int age = 10/0)，调一次错一次；开启jmeter后，直接高并发发送请求，多次调用达到我们的配置条件了。断路器开启(保险丝跳闸)，微服务不可用了，不再报错error而是服务降级了。

异常数

统计时长1000ms内，超过5个请求中有3个请求异常的熔断2s

浏览器频繁访问 ，会发现次数达到后进行熔断

热点参数限流

何为热点：热点即经常访问的数据，有时候我们希望统计或者限制某个热点数据中访问频次最高的数据，并对其访问进行限流。使用如下：

案例使用

1. 定义业务方法

@GetMapping("/testHotKey")
@SentinelResource(value = "testHotKey", blockHandler = "blockExceptionTestHotKey")
public String testHotkey(@RequestParam(value = "p1", required = false) String p1,
                         @RequestParam(value = "p2", required = false) String p2) {
    return "serverPort:[" + serverPort + "],testHotkey...";
}

//这里是我们自定义的兜底方法，BlockException不要打成了BlockedException
public String blockExceptionTestHotKey(String p1, String p2, BlockException e) {
    return "testHotkey自定义限流提示：blockExceptionTestHotKey╰(*°▽°*)╯...";
}

1. 定义热点限制规则

热点规则共有资源名、限流模式（只支持QPS模式）、参数索引、单机阈值、统计窗口时长、是否集群6种参数，还有一些高级选项，用到时会详细介绍。这里会用到注解中的value作为资源名，兜底方法会在后面详细介绍

资源名**：**唯一路径，默认为请求路径。此处必须是 @SentinelResource 注解的 value 属性值，配置@GetMapping 的请求路径无效）

配置热点规则：

绑定testHotKey资源，把testHotKey对应的第一个参数作为热点key进行监控。设定热点限流规则：当该资源的访问QPS超过1次/s的时候，产生限流并执行自定义的blockExceptionTestHotKey兜底方法。

简而言之：方法testHotKey里面第一个参数只要QPS超过每秒1次，马上降级处理。

1. 测试

• 访问 http://localhost:8501/testHotKey?h1=a&h2=b

1次/s正常显示，迅速点击两次，触发热点限流，执行自定义兜底方法：

• 仅传入参数p2没有任何影响 http://localhost:8501/testHotKey?h2=b

参数例外项

上述案例演示了第一个参数h1，当QPS超过1秒1次点击后马上被限流

特例情况：我们期望h1参数当它是某个特殊值时，它的限流值和平时不一样，比如当h1的值等于5时，它的阈值可以达到10。

测试

• 访问 http://localhost:8501/testHotKey?h1=3&h2=b

持久化规则

前面我们微服务新增的限流规则后，微服务关闭重启后就会丢失，当时配置的限流规则都是临时的。 如何进行持久化呢，可以将限流配置规则持久化进Nacos保存，只要刷新服务某个rest地址，sentinel控制台的流控规则 就能看到。只要nacos里面的配置不删除，针对8501上的sentinel上的流控规则就持续存在。 （也可以持久化到文件，redis，数据库等）

1. 导入持久化需要的依赖，编写业务方法啊

<!--SpringCloud ailibaba sentinel-datasource-nacos 持久化-->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-datasource-nacos</artifactId>
</dependency>

@GetMapping("/rateLimit/byUrl")
@SentinelResource(value = "byUrl")
public String byUrl() {
    return "持久化配置限流测试";
}

1. 修改yaml

server:
  port: 8501

spring:
  application:
    name: chen-sentinel-service
  cloud:
    nacos:
      discovery:
        #Nacos服务注册中心地址
        server-addr: 127.0.0.1:8848
    sentinel:
      transport:
        #配置Sentinel dashboard地址
        dashboard: 127.0.0.1:8080
        #默认8719端口，假如被占用会自动从8719开始依次+1扫描,直至找到未被占用的端口
        port: 8917
      web-context-unify: false
      #持久化配置
      datasource:
        ds1:
          nacos:
            server-addr: 127.0.0.1:8848
            dataId: chen-sentinel-service
            groupId: DEFAULT_GROUP
            data-type: json
            rule-type: flow
management:
  endpoints:
    web:
      exposure:
        include: '*'

1. nacos添加配置规则

我们将sentinel的流控配置保存在nacos中，因为我们可以把nacos的配置持久化在了数据库中。

[
    {
        "resource": "/rateLimit/byUrl",
        "limitApp": "default",
        "grade": 1,
        "count": 1,
        "strategy": 0,
        "controlBehavior": 0,
        "clusterMode": false
    }
]

resource：资源名称；

limitApp：来源应用；

grade：阈值类型，0表示线程数，1表示QPS；

count：单机阈值；

strategy：流控模式，0表示直接，1表示关联，2表示链路；

controlBehavior：流控效果，0表示快速失败，1表示Warm Up，2表示排队等待；

clusterMode：是否集群。

1. 测试

启动服务访问接口，刷新Sentinel。可以看到Sentinel中加载了通过nacos持久化的规则配置文件。