Sentinel入门

前行@

已于 2023-11-17 21:19:07 修改

阅读量74

点赞数

文章标签： sentinel

于 2023-11-16 21:22:31 首次发布

本文链接：https://blog.csdn.net/m0_64371502/article/details/134444980

版权

官方网站

https://github.com/alibaba/Sentinel/wiki/%E4%BB%8B%E7%BB%8Dhttps://github.com/alibaba/Sentinel/wiki/%E4%BB%8B%E7%BB%8D

简介

Sentinel (分布式系统的流量防卫兵) 是阿里开源的一套用于服务容错的综合性解决方案。它以流量为切入点, 从流量控制、熔断降级、系统负载保护等多个维度来保护服务的稳定性。

特征:

丰富的应用场景：Sentinel 承接了阿里巴巴近 10 年的双十一大促流量的核心场景, 例如秒杀（即突发流量控制在系统容量可以承受的范围）、消息削峰填谷、集群流量控制、实时熔断下游不可用应用等。

完备的实时监控：Sentinel 提供了实时的监控功能。通过控制台可以看到接入应用的单台机器秒级数据, 甚至 500 台以下规模的集群的汇总运行情况。

广泛的开源生态：Sentinel 提供开箱即用的与其它开源框架/库的整合模块, 例如与 Spring Cloud、Dubbo、gRPC 的整合。只需要引入相应的依赖并进行简单的配置即可快速地接入 Sentinel。

完善的 SPI 扩展点：Sentinel 提供简单易用、完善的 SPI 扩展接口。您可以通过实现扩展接口快

速地定制逻辑。例如定制规则管理、适配动态数据源等

Sentinel 分为两个部分:

核心库（Java 客户端）不依赖任何框架/库,能够运行于所有 Java 运行时环境，同时对 Dubbo /Spring Cloud 等框架也有较好的支持。

控制台（Dashboard）基于 Spring Boot 开发，打包后可以直接运行，不需要额外的 Tomcat 等应用容器。

微服务集成Sentinel

为微服务集成Sentinel非常简单, 只需要加入Sentinel的依赖即可

在pom.xml中加入下面依赖

<!--熔断器-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

编写消费者controller并调用

测试一下

安装Sentinel控制台

Sentinel 提供一个轻量级的控制台, 它提供机器发现、单机资源实时监控以及规则管理等功能

sentinel的版本一定要和组件的版本对应一致，否则出现会在一定程序出现不可预知的错误，当前的环境需要1.8.1版本的sentinel

1 下载jar包

Release v1.8.1 · alibaba/Sentinel · GitHubA powerful flow control component enabling reliability, resilience and monitoring for microservices. (面向云原生微服务的高可用流控防护组件) - Release v1.8.1 · alibaba/Sentinelhttps://github.com/alibaba/Sentinel/releases/tag/1.8.1

2 启动控制台

# 直接使用jar命令启动项目(控制台本身是一个SpringBoot项目)

java -Dserver.port=8888 -Dcsp.sentinel.dashboard.server=localhost:8888 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.8.1.jar

3 修改 product ,在里面加入有关控制台的配置

spring.cloud.sentinel.transport.port=9999

# 该端口号为sentinal于服务之间的交互随便写只要不被占用

spring.cloud.sentinel.transport.dashboard=localhost:8888

#sentinal服务所在的地址和端口号

4 通过浏览器访问

输入localhost:8888 进入控制台 ( 默认用户名密码是 sentinel/sentinel )

刷新刚才创建的controller,多刷新几次

就来到了控制台

里面都是我们访问的详细信息

5.Sentinel规则

sentinel共有三种流控模式，分别是：

l 直接（默认）：接口达到限流条件时，开启限流

l 关联：当关联的资源达到限流条件时，开启限流 [适合做应用让步]

l 链路：当从某个接口过来的资源达到限流条件时，开启限流

流控规则

直接流控模式

直接流控模式是最简单的模式，当指定的接口达到限流条件时开启限流

资源名没有特殊处理的时候就是controller层的名字单机阈值就是每秒访问的次数

QPS:就是每秒请求数量当达到阈值时会进行限流

线程数:但调用该接口的线程数到达阈值的时候,进行限流

但你再次访问时如果每秒访问数超过1就会报错就是被限制了

关联流控模式

关联流控模式指的是，当指定接口关联的接口达到限流条件时，开启对指定接口开启限流。

当别人访问msg2阈值到达1的时候你访问msg1就会被限制

链路流控模式

链路流控模式指的是，当从某个接口过来的资源达到限流条件时，开启限流。

注解：@SentinelResource

我们可以对某一个方法进行限流控制，无论是谁在何处调用了它，这里需要使用到@SentinelResource，一旦方法被标注，那么就会进行监控@SentinelResource，一旦方法被标注，那么就会进行监控。

访问

被限流了

6.异常统一处理

BlockException异常统一处理

package com.example.exception;

import com.alibaba.csp.sentinel.adapter.spring.webmvc.callback.BlockExceptionHandler;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
import com.example.util.Result;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class MyExceptionHandler implements BlockExceptionHandler {
    
    @Resource
    private ObjectMapper objectMapper;
    @Override
    public void handle(HttpServletRequest httpServletRequest, HttpServletResponse response, BlockException e) throws Exception {

        Result r = null;
        if (e instanceof FlowException) {
            r = new Result(100, "限流了", "");
        }


        //返回json数据
        response.setStatus(500);
        response.setCharacterEncoding("utf-8");
        response.setContentType(MediaType.APPLICATION_JSON_VALUE);
        objectMapper.writeValue(response.getWriter(), r);
    }
}

还要写规范

把ObjectMapper弄成一个bean注入到我们的容器里面

重启

需要再重新添加流控规则

自定义规则:

7.服务熔断

8.配置流控效果

l 快速失败（默认）: 直接失败，抛出异常，不做任何额外的处理，是最简单的效果

l Warm Up：它从开始阈值到最大QPS阈值会有一个缓冲阶段，一开始的阈值是最大QPS阈值的1/3，然后慢慢.增长，直到最大阈值，适用于将突然增大的流量转换为缓步增长的场景。

设置阈值为 10，预热时间是 5 秒，逐渐增加到阈值上限，所以会有一个初始阈值

初始阈值 = 阈值上限 / coldFactor， coldFactor 是冷加载因子，默认为3

上面这个配置的效果就是：在 5 秒内最大阈值是 3（10/codeFactor），超过5秒，最大阈值为10

l 排队等待：让请求以均匀的速度通过，单机阈值为每秒通过数量，其余的排队等待；它还会让设置一个超时时间，当请求超过超时间时间还未处理，则会被丢弃。

排队等待方式会严格控制请求通过的间隔时间，也即是让请求以均匀的速度通过，对应的是漏桶算法。

注意:匀速排队，让请求以匀速通过，阈值类型必须设置为QPS，否则无效,匀速排队模式暂时不支持 QPS > 1000 的场景

当阈值设为 2 的时候，则代表一秒匀速的通过 2 个请求，也就是每个请求平均间隔恒定为 1000 / 2 = 500 ms，每一个请求的最长等待时间（maxQueueingTimeMs）为 1s 。

9.降级规则

慢调用的比例

规定每个请求最大的时间是50ms超过这个时间就认为是慢调用

慢调用的比例>=0.5（最小的请求时2 慢调用/总调用）的时候熔断时长 1s

异常比例

10.热点规则

@RequestMapping("/test3")

@SentinelResource(value = "test3")

//注意这里必须使用这个注解标识,热点规则不生效

public String message3(String name, Integer age){return name + age; }

热点规则一定要添加注解@SentinelResource不然不生效

11.授权规则

全局异常返回

@ControllerAdvice // 全局异常

public class GlobalException {

@ResponseBody // 以json

// 抛出的异常{} 代表的就是一个集合

@ExceptionHandler({UndeclaredThrowableException.class})

public Result test(){

return new Result("没有授权！！！");

}

}

12.Sentinel规则持久化

通过前面的讲解，我们已经知道，可以通过Dashboard来为每个Sentinel客户端设置各种各样的规则，但是这里有一个问题，就是这些规则默认是存放在内存中，极不稳定，所以需要将其持久化。

方法1：添加到nacos里面

1)在配置文件application中添加以下内容

spring.cloud.sentinel.datasource.ds1.nacos.data-id=${spring.application.name}

spring.cloud.sentinel.datasource.ds1.nacos.data-type=json

spring.cloud.sentinel.datasource.ds1.nacos.server-addr=localhost:8848

spring.cloud.sentinel.datasource.ds1.nacos.group-id=DEFAULT_GROUP

spring.cloud.sentinel.datasource.ds1.nacos.rule-type=flow

2）在nacos中为cloudalibaba-sentinel-service(可以在配置文件自定义)服务添加对应配置。

[

{

"resource": "/rateLimit/customerBlockHandler",#/rateLimit/customerBlockHandler

"limitApp": "default",

"grade": 1,

"count": 1,

"strategy": 0,

"controlBehavior": 0,

"clusterMode": false

}

]

resource: 资源名称;

imitApp: 来源应用;

grade: 阈值类型，0表示线程数，1表示QPS;

count: 单机阈值；

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

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

clusterMode: 是否集群。

方法2: 使用文件

package com.pro.config;


import com.alibaba.csp.sentinel.command.handler.ModifyParamFlowRulesCommandHandler;
import com.alibaba.csp.sentinel.datasource.*;
import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRule;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRuleManager;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRuleManager;
import com.alibaba.csp.sentinel.slots.system.SystemRule;
import com.alibaba.csp.sentinel.slots.system.SystemRuleManager;
import com.alibaba.csp.sentinel.transport.util.WritableDataSourceRegistry;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import org.springframework.beans.factory.annotation.Value;
import java.io.File;
import java.io.IOException;
import java.util.List;
public class FilePersistence implements InitFunc {
    @Value("${spring.application.name}")
    private String appcationName;
    @Override
    public void init() throws Exception {
        String ruleDir = System.getProperty("user.home") + "/sentinel-rules/" + appcationName;
        String flowRulePath = ruleDir + "/flow-rule.json";
        String degradeRulePath = ruleDir + "/degrade-rule.json";
        String systemRulePath = ruleDir + "/system-rule.json";
        String authorityRulePath = ruleDir + "/authority-rule.json";
        String paramFlowRulePath = ruleDir + "/param-flow-rule.json";
        this.mkdirIfNotExits(ruleDir);
        this.createFileIfNotExits(flowRulePath);
        this.createFileIfNotExits(degradeRulePath);
        this.createFileIfNotExits(systemRulePath);
        this.createFileIfNotExits(authorityRulePath);
        this.createFileIfNotExits(paramFlowRulePath);
        // 流控规则
        ReadableDataSource<String, List<FlowRule>> flowRuleRDS = new FileRefreshableDataSource<>(
                flowRulePath,
                flowRuleListParser
        );
        FlowRuleManager.register2Property(flowRuleRDS.getProperty());
        WritableDataSource<List<FlowRule>> flowRuleWDS = new FileWritableDataSource<>(
                flowRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerFlowDataSource(flowRuleWDS);
        // 降级规则
        ReadableDataSource<String, List<DegradeRule>> degradeRuleRDS = new FileRefreshableDataSource<>(
                degradeRulePath,
                degradeRuleListParser
        );
        DegradeRuleManager.register2Property(degradeRuleRDS.getProperty());
        WritableDataSource<List<DegradeRule>> degradeRuleWDS = new FileWritableDataSource<>(
                degradeRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerDegradeDataSource(degradeRuleWDS);
        // 系统规则
        ReadableDataSource<String, List<SystemRule>> systemRuleRDS = new FileRefreshableDataSource<>(
                systemRulePath,
                systemRuleListParser
        );
        SystemRuleManager.register2Property(systemRuleRDS.getProperty());
        WritableDataSource<List<SystemRule>> systemRuleWDS = new FileWritableDataSource<>(
                systemRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerSystemDataSource(systemRuleWDS);
        // 授权规则
        ReadableDataSource<String, List<AuthorityRule>> authorityRuleRDS = new FileRefreshableDataSource<>(
                authorityRulePath,
                authorityRuleListParser
        );
        AuthorityRuleManager.register2Property(authorityRuleRDS.getProperty());
        WritableDataSource<List<AuthorityRule>> authorityRuleWDS = new FileWritableDataSource<>(
                authorityRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerAuthorityDataSource(authorityRuleWDS);
        // 热点参数规则
        ReadableDataSource<String, List<ParamFlowRule>> paramFlowRuleRDS = new FileRefreshableDataSource<>(
                paramFlowRulePath,
                paramFlowRuleListParser
        );
        ParamFlowRuleManager.register2Property(paramFlowRuleRDS.getProperty());
        WritableDataSource<List<ParamFlowRule>> paramFlowRuleWDS = new FileWritableDataSource<>(
                paramFlowRulePath,
                this::encodeJson
        );
        ModifyParamFlowRulesCommandHandler.setWritableDataSource(paramFlowRuleWDS);
    }
    private Converter<String, List<FlowRule>> flowRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<FlowRule>>() {
            }
    );
    private Converter<String, List<DegradeRule>> degradeRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<DegradeRule>>() {
            }
    );
    private Converter<String, List<SystemRule>> systemRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<SystemRule>>() {
            }
    );
    private Converter<String, List<AuthorityRule>> authorityRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<AuthorityRule>>() {
            }
    );

    private Converter<String, List<ParamFlowRule>> paramFlowRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<ParamFlowRule>>() {
            }
    );

    private void mkdirIfNotExits(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            file.mkdirs();
        }
    }
    private void createFileIfNotExits(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            file.createNewFile();
        }
    }
    private <T> String encodeJson(T t) {
        return JSON.toJSONString(t);
    }
}

将这个配置文件使用

在对应的微服务下面的resources里面创建两个目录

META-INF/services

并在目录下面写一个文件

com.alibaba.csp.sentinel.init.InitFunc

文件里面写的是刚才的配置类的包名加类名：com.pro.config.FilePersistence