SpringCloud Alibaba学习笔记 ——（六、Sentinel 服务保护框架）

Gorit

发布于 2021-12-30 17:32:25

6310

发布于 2021-12-30 17:32:25

文章被收录于专栏：Gorit 带你学全栈系列Gorit 带你学全栈系列

SpriingCloudAlibaba —— Sentinel 服务保护框架

六、Sentinel 服务保护框架

Author: Gorit

Date：2021年1月

Refer：阿里云大学

2021年发表博文： 11/30

六、Sentinel 服务保护框架

具体介绍查阅官方文档，这里就不介绍了

6.1 Sentinel 的功能

服务限流
实现对服务接口的保护

QPS（每秒的请求量）

6.1.1 服务接口的保护方案

黑名单和白名单
对 IP 实现限流 / 熔断机制
服务降级
服务隔离机制。

6.1.2 名词解释

服务限流：（类比去景点玩，景点人员限流）

目的为了保护我们的服务，在高并发情况下，如果客户端的请求服务器端达到一定的极限（设置阈值），请求的数量超出我们设置的阈值，开启我们的自我保护机制，直接执行我们的服务降级的方法，不会去执行我们的业务逻辑，走本地的 fallback 方法

服务降级：（类比秒杀一件商品，当前排队人数过多，请稍后重试）

在高并发的情况下，为了防止用户一直等待，采用限流活熔断机制，保护我们的服务，不会执行我们的业务逻辑，走本地 fallback 方法，返回一个友好的提示给客户端

服务雪崩的效应：

默认的情况下，Tomcat/ Jetty 服务器只会有一个线程池处理所有的接口请求。这样的话，高并发情况下，如果客户端所有的请求都堆积到同一个接口上，那么会产生该服务器的所有线程都在处理该接口，可能会导致其他接口无法访问，短暂没有线程处理

**服务雪崩**解决方案：

服务的隔离机制：线程池隔离或者信号量隔离机制

线程池隔离：每个接口都由自己的独立的线程池维护我们的请求、每个线程池互不影响。缺点：占用服务器内存非常大
信号量隔离：设置最多允许我们某个接口有一定的阈值线程数量去处理接口，如果超出线程数量，拒绝访问

6.2 Sentinel 和 Hystrix 的区别

6.2.1 Sentinel 和 Hystrix 的区别

6.2.2 配置限流的方式

手动代码配置（纯代码，注解的形式）
Sentinel 控制台形式配置
默认情况下 Sentinel 不对数据持久化，需要自己持久化

实现的步骤：

创建我们流控、限流规则。然后在被映射的地址去引用。

6.3 Sentinel 实现服务限流

6.3.0 安装 Sentinel 控制台

在 6.3.3 小结中会用到

参考文档

下载 Jar 包 (sentinel-dashboard-1.8.0.jar)
运行

java -Dserver.port=8718 -Dcsp.sentinel.dashboard.server=localhost:8718 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.8.0.jar

默认登录 sentinel sentinel

6.3.1 使用 Java 代码实现服务限流

导入坐标依赖

        <dependency>
            <groupId>com.alibaba.cloudgroupId>
            <artifactId>spring-cloud-starter-alibaba-sentinelartifactId>
            <version>2.1.0.RELEASEversion>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>

编写 OrderContoller

@RestController
public class OrderService {

    // 定义的限流规则名称
    private static final String GETORDER_KEY = "orderToMenber";
    
    
    // 测试 Sentinel，对接口限流
    @RequestMapping("/orderToMenber")
    public String orderToMenber() {
        Entry entry = null;
        try {
            entry = SphU.entry(GETORDER_KEY);
            return "orderToMenber接口";
        } catch (Exception e) {
           // 限流的情况就会进入 Exception
            return "当前访问人数过多，请稍后重试！";
        } finally {
            if (entry != null) {
                entry.exit();
            }
        }
    }

    /**
     * 创建限流规则
     * @return
     */
    @RequestMapping("/initFlowQpsRule")
    public String initFlowQpsRule() {
        List<FlowRule> rules = new ArrayList<FlowRule>();
        FlowRule rule1 = new FlowRule();
        rule1.setResource(GETORDER_KEY); // 限流规则名称
        //qps 控制在 1 以内
        rule1.setCount(1);
        //qps 限流
        rule1.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule1.setLimitApp("default");
        rules.add(rule1);
        FlowRuleManager.loadRules(rules);
        return ".... 限流配置初始化成功";
    }
   
   
}

编写启动类 AppOrder
先访问 http://localhost:8080/initFlowQpsRule 实现初始化规则
再访问 http://localhost:8080/orderToMenber
然后看到刷新一遍，接口就会显示 Exception 的异常信息了

QPS：每秒接口的访问次数，设置为 1，每秒接口只能访问一次
必须先加载规则，规则才能生效。
如果 SpringBoot 重启，规则就会失效

SpringBoot 项目启动成功之后，加载我们的限流规则。

Sentinel 限流的规则默认情况下是没有持久化，如果需要持久化的话用 zk、nacos、携程阿波罗

解决方案

编写 SentinelApplicationRunner 配置类，并实现 ApplicationRunner 接口（这个接口是 SpringBoot 提供的启动加载的一个类

package cn.gorit.service.order.config;

import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.context.annotation.Configuration;

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

/**
 * @Classname SentinelApplicationRunner
 * @Description 我们将初始化的规则，放在这里加载，这是 Springboot 提供的一个启动加载接口
 * @Date 2021/1/30 14:31
 * @Created by CodingGorit
 * @Version 1.0
 */
@Configuration
public class SentinelApplicationRunner implements ApplicationRunner {
    // 定义的限流规则名称
    private static final String GETORDER_KEY = "orderToMenber";

    private Logger log = LoggerFactory.getLogger(SentinelApplicationRunner.class);

    @Override
    public void run(ApplicationArguments args) throws Exception {
        List<FlowRule> rules = new ArrayList<FlowRule>();
        FlowRule rule1 = new FlowRule();
        rule1.setResource(GETORDER_KEY); // 限流规则名称
        //qps 控制在 1 以内
        rule1.setCount(1);
        //qps 限流
        rule1.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule1.setLimitApp("default");
        rules.add(rule1);
        FlowRuleManager.loadRules(rules);
        log.info(">>> 限流配置加载成功");
    }
}

然后再次启动，就能直接访问 http://localhost:8080/orderToMenber 实现服务限流了

6.3.2 使用注解实现服务限流

    /**
     * @SentinelResource 参数主要如下
     * fallback 服务降级执行本地方法
     * blockHandler 限流/熔断 出现异常执行的方法
     * value 指定我们的资源名称
     * @return
     */
    @SentinelResource(value = GETORDER_KEY, blockHandler = "getOrderQpsException")
    @RequestMapping("/orderToMemberSentinelResource")
    public String orderToMemberSentinelResource() {
        return "orderToMemberSentinelResource";
    }

    /**
     * 被限流后返回的提示
     * @param e
     * @return
     */
    public String getOrderQpsException(BlockException e) {
        e.printStackTrace();
        return "该接口被限流了";
    }

6.3.3 Springboot 整合 Sentinel 仪表盘

先启动 Sentinel 控制台：

java -Dserver.port=8718 -Dcsp.sentinel.dashboard.server=localhost:8718 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.8.0.jar

登录的账号密码：sentinel sentinel
SpringBoot 配置整合 Sentinel 控制台

spring:
  application:
    name: gorit-order
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    sentinel:
      transport:
        dashboard: 127.0.0.1:8718
      eager: true

重新启动 SpringBoot

编写接口

   /**
     * 基于控制台实现流量规则限流
     * @return
     */
    @RequestMapping("/getOrderConsole")
    public String getOrderConsole () {
        return "getOrderConsole";
    }

    /**
     * 如果没有使用 @SentinelResource 注解，默认资源名称为接口路径 /getOrderConsole
     */

在控制台添加规则

被限流返回的结果

Blocked by Sentinel (flow limiting)

如果要实现和上述一样的返回效果，只需要加上 @SentinelResouce 注解即可

PS：如果配置了注解，就会和默认的资源名称冲突，所以要删除默认的资源名称

6.3.4 实现信号量隔离

限流规则设置线程数

    // 基于信号量， 在控制台设置规则的时候，配置为 线程数
    @SentinelResource(value = GETORDER_KEY, blockHandler = "getOrderQpsException")
    @RequestMapping("/getOrderSemaphore")
    public String getOrderSemaphore () {
        log.info(">>>" + Thread.currentThread().getName());
        return "getOrderSemaphore";
    }

阙值改为线程数

访问效果

如果看不到效果，可以在代码中加入 Thread.sleep(500) ，使线程阻塞即可

6.4 Sentinel 数据持久化 & 实现服务降级 & 服务熔断

Sentinel 持久化方案
网关整合 Sentinel 实现限流
如何对服务实现动态降级
降级的策略 RT、错误比例、次数

6.4.1 Sentinel 数据持久化的方式（基于 nacos 配置中心实现持久化）

Sentinel 支持数据规则持久化的，官方默认支持 5 种（sentinel-nacos 1.7.0 版本）

nacos 分布式配置中心
携程阿波罗
存放本地文件
Zookeeper
redis

一、在 nacos 中创建流控规则

gorit-order-sentinel

我们可以在 Nacos 编写 Sentinel 的资源配置，然后整合 sentinel-nacos 的配置

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

resource: 资源名，即限流规则的作用对象
limitApp：流控针对的调用来源，若为 default 则不区分调用来源
grade：限流阙值类型（QPS 或并发线程数）；0 代表根据并发数量来限流， 1 代表 QPS 来进行流量控制
count：限流阙值
strategy：调用关系限流策略

二、SpringBoot 客户端整合 nacos-sentinel

依赖配置

        <dependency>
            <groupId>com.alibaba.cloudgroupId>
            <artifactId>spring-cloud-starter-alibaba-sentinelartifactId>
            <version>2.1.0.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>com.alibaba.cspgroupId>
            <artifactId>sentinel-datasource-nacosartifactId>
            <version>1.7.0version>
        dependency>

PS：我用的 SpringBoot 版本是 2.3.4 RELEASE，之前用的 nacos-sentinel 的版本是 1.5.6，启动老是报错，好来改成 1.7.0 就出来了

配置文件（application.yml）

spring:
  application:
    name: gorit-order
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    sentinel:
      transport:
        dashboard: 127.0.0.1:8718 # 这个是控制台的地址，因为我启动时，指定了控制台启动的端口为 8718
      eager: true
      datasource:
        - nacos:
            server-addr: localhost:8848 # nacos 连接地址
            group-id: DEFAULT_GROUP # nacos 连接分组
            rule-type: flow # 路由存储规则  flow、degrade、param-flow、gw-flow
            data-id: ${spring.application.name}-sentinel # 读取配置文件的 data-id
            data-type: json # 读取配置文件累心为 JSON 和 XML

server:
  port: 8091

编写 getOrderSentinel 接口

    // 集成 nacos 实现 sentinel 流控规则的持久化
    @RequestMapping("/getOrderSentinel")
    public String getOrderSentinel() {
        return "OrderSentinel";
    }

启动项目

三、更新前面 Nacos 的配置

更新前

更新 nacos 配置

更改后

看，我们已经实现了通过 nacos 配置中心修改限流规则了

PS: 如果发现重启没有生效的话，是因为我们之前编写的 SentinelApplicationRunner 类会初始化我们的流控配置，所以将其注释掉，就可以解决 nacos 持久化被覆盖的问题

6.4.2 Gateway 整合 sentinel 实现服务限流

官方文档

Gateway 是采用 netty 启动的，不支持 Servlet-API。所以添加了 Springboot-web 的依赖就会报错

网关流控原理

当通过 GatewayRuleManager 加载网关流控规则（GatewayFlowRule）时，无论是否针对请求属性进行限流，Sentinel 底层都会将网关流控规则转化为热点参数规则（ParamFlowRule），存储在 GatewayRuleManager 中，与正常的热点参数规则相隔离。转换时 Sentinel 会根据请求属性配置，为网关流控规则设置参数索引（idx），并同步到生成的热点参数规则中。
外部请求进入 API Gateway 时会经过 Sentinel 实现的 filter，其中会依次进行 路由/API 分组匹配、请求属性解析和参数组装。Sentinel 会根据配置的网关流控规则来解析请求属性，并依照参数索引顺序组装参数数组，最终传入 SphU.entry(res, args) 中。Sentinel API Gateway Adapter Common 模块向 Slot Chain 中添加了一个 GatewayFlowSlot，专门用来做网关规则的检查。GatewayFlowSlot 会从 GatewayRuleManager 中提取生成的热点参数规则，根据传入的参数依次进行规则检查。若某条规则不针对请求属性，则会在参数最后一个位置置入预设的常量，达到普通流控的效果。

新建一个 module，并命名为 gorit-gateway
添加依赖

        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-gatewayartifactId>
            <version>2.2.4.RELEASEversion>
        dependency>
        <dependency>
            <groupId>com.alibaba.cspgroupId>
            <artifactId>sentinel-spring-cloud-gateway-adapterartifactId>
            <version>1.7.0version>
        dependency>

编写项目配置依赖 application.yml

spring:
  application:
    name: gorit-order-gateway-8080
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    gateway:
      routes:
        - id: my-member  # 这个用不到，是之前写过的，可以直接 copy 过来
          uri: lb://gorit-member
          # 匹配规则
          predicates:
            - Path=/gorit-member/**
        - id: gorit
          uri: https://www.gorit.cn/ # 转发到我的个人网站
          # 匹配规则
          predicates:
            - Path=/**
      enabled: true
server:
  port: 8080

注入对应的 SentinelGatewayFilter 实例以及 SentinelGatewayBlockExceptionHandler 实例即可

package cn.gorit.config;

import com.alibaba.csp.sentinel.adapter.gateway.sc.SentinelGatewayFilter;
import com.alibaba.csp.sentinel.adapter.gateway.sc.exception.SentinelGatewayBlockExceptionHandler;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.http.codec.ServerCodecConfigurer;
import org.springframework.web.reactive.result.view.ViewResolver;

import java.util.Collections;
import java.util.List;

/**
 * @Classname GatewayConfiguration
 * @Description TODO
 * @Date 2021/1/31 22:34
 * @Created by CodingGorit
 * @Version 1.0
 */
@Configuration
public class GatewayConfiguration {

    private final List<ViewResolver> viewResolvers;
    private final ServerCodecConfigurer serverCodecConfigurer;

    public GatewayConfiguration(ObjectProvider<List<ViewResolver>> viewResolversProvider,
                                ServerCodecConfigurer serverCodecConfigurer) {
        this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
        this.serverCodecConfigurer = serverCodecConfigurer;
    }

    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
        // Register the block exception handler for Spring Cloud Gateway.
        return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
    }

    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public GlobalFilter sentinelGatewayFilter() {
        return new SentinelGatewayFilter();
    }
}

配置限流的接口（对应上述第一段实现原理）

package cn.gorit.config;

import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayFlowRule;
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayRuleManager;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.context.annotation.Configuration;

import java.util.HashSet;
import java.util.Set;

/**
 * @Classname SentinelApplicationRunner
 * @Description TODO
 * @Date 2021/1/31 22:37
 * @Created by CodingGorit
 * @Version 1.0
 */
@Configuration
public class SentinelApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        initGatewayRules();
    }

    /**
     * 配置网关限流规则
     */
    private void initGatewayRules() {
        Set<GatewayFlowRule> rules = new HashSet<>();
        // 设置规则
        rules.add(new GatewayFlowRule("gorit")
                // 设置阙值
                .setCount(1)
                // 设置时间窗口，单位是秒，默认是 1 s
                .setIntervalSec(1));
        GatewayRuleManager.loadRules(rules);
    }
}

然后即可实现限流效果

PS：

如果要实现动态限流，并且持久化，将配置写入 nacos 配置中心即可
如果要实现自定义限流返回的信息，需要重写该方法：

public class SentinelGatewayBlockExceptionHandler implements WebExceptionHandler

然后注入我们重写的 handler 即可

 */
public class JsonSentinelGatewayBlockExceptionHandler implements WebExceptionHandler {
    public JsonSentinelGatewayBlockExceptionHandler(List<ViewResolver> viewResolvers) {
    }

    @Override
    public Mono<Void> handle(ServerWebExchange exchange, Throwable throwable) {
        ServerHttpResponse serverHttpResponse = exchange.getResponse();
        serverHttpResponse.getHeaders().add("Content-Type","application/json;charset=utf-8");
        byte[] datas = "{\"code\":403,\"msg\":\"API 接口被限流\"}".getBytes(StandardCharsets.UTF_8);
        DataBuffer buffer = serverHttpResponse.bufferFactory().wrap(datas);
        return serverHttpResponse.writeWith(Mono.just(buffer));
    }
}

6.4.3 实现服务动态降级

官方文档

服务出现异常时，会自动服务降级，禁止外来继续访问，不会执行真正的逻辑

Sentinel 支持服务的熔断降级

熔断类似于保险丝，如果超出了我们的阙值的情况下，在一定时间内不会执行我们的业务逻辑，直接执行我们的服务降级方法（fallback）返回一个友好的提示给客户端，不会真实的执行业务逻辑

    // 基于信号量， 在控制台设置规则的时候，配置为 线程数
    @SentinelResource(value = GETORDER_KEY, fallback = "",blockHandler = "getOrderQpsException")
    @RequestMapping("/getOrderSemaphore")
    public String getOrderSemaphore () {
        log.info(">>>" + Thread.currentThread().getName());
        return "getOrderSemaphore";
    }

服务降级策略

rt（平均响应时间）如果在 1s 内访问五次，平均响应时间超出了我们在平台设置的阙值的情况下，直接触发我们的熔断，执行我们的服务降级的方法。时间窗口：在规定的时间窗口内一直执行服务降级的方法，不执行业务逻辑
错误比例客户端，发出了连续 5 个请求，每个请求全部错误，这说明错误率百分之百每 s 秒发出 5个请求，如果请求异常占比超过我们设置的阈值占比的情况下，就会执行服务降级的方法，在规定时间窗口不执行业务逻辑
错误次数

官方的熔断策略

慢调用比例 (SLOW_REQUEST_RATIO)：选择以慢调用比例作为阈值，需要设置允许的慢调用 RT（即最大的响应时间），请求的响应时间大于该值则统计为慢调用。当单位统计时长（statIntervalMs）内请求数目大于设置的最小请求数目，并且慢调用的比例大于阈值，则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求响应时间小于设置的慢调用 RT 则结束熔断，若大于设置的慢调用 RT 则会再次被熔断。
异常比例 (ERROR_RATIO)：当单位统计时长（statIntervalMs）内请求数目大于设置的最小请求数目，并且异常的比例大于阈值，则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求成功完成（没有错误）则结束熔断，否则会再次被熔断。异常比率的阈值范围是 [0.0, 1.0]，代表 0% - 100%。
异常数 (ERROR_COUNT)：当单位统计时长内的异常数目超过阈值之后会自动进行熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求成功完成（没有错误）则结束熔断，否则会再次被熔断。

一、编写慢调用比例策略

接口

    /**
     * 基于我们的平均响应时间海鲜降级
     */
    @SentinelResource(value = "getOrderDowngradeRtType",fallback = "getOrderDowngradeRtTypeFallback")
    @RequestMapping("/getOrderDowngradeRtType")
    public String getOrderDowngradeRtType() {
        try {
            Thread.sleep(300);
        } catch (Exception e) {

        }
        return "order 业务逻辑正常执行";
    }

    public String getOrderDowngradeRtTypeFallback() {
        return "执行本地的服务降级的方法";
    }

sentinel 添加降级规则

测试相应即可

超出响应时间了，就会返回 fallback 的内容

二、异常比例熔断测试

接口（不带参数就会报错)

    /**
     * 基于异常比例 服务降级
     *
     */
    @SentinelResource(value = "getOrderDowngradeErrorType",fallback = "getOrderDowngradeErrorTypeFallback")
    @RequestMapping("/getOrderDowngradeErrorType")
    public String getOrderDowngradeErrorType(@RequestParam int age) {
        int i = 1/age;
        return "业务逻辑请求成功 i "+ i;
    }

    public String getOrderDowngradeErrorTypeFallback(int age) {
        return "错误率太高，请稍后重试访问该接口";
    }

配置

三、基于异常数实现服务降级

复用上面的接口

6.6 Sentinel 整合热词限流

热点参数限流

负载均衡专题

本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。

原始发表：2021-02-04 ，如有侵权请联系 cloudcommunity@tencent.com 删除

对象存储

spring

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！

对象存储

spring

登录后参与评论

0 条评论

热度