sentinel

Author Avatar
丁起男 08月 22,2021
  • 在其它设备中阅读本文章

sentinel

基本概念

  • 资源:资源是sentinel的关键概念。它可以是java应用程序中的任何内容,可以是一个服务,也可以是一个方法,甚至可以是一段代码。总之就是sentinel要保护的东西
  • 规则:作用于资源之上,定义以什么样的方式保护资源,主要包括流量控制规则,熔断降级规则以及系统保护规则。也就是如何保护资源

主要功能

sentinel的主要功能就是容错,

  • 保证自己不被上游服务压垮:流量控制
  • 保证自己不被下游服务拖垮:熔断降级
  • 保证外界环境良好:系统负载保护

流控规则

流量控制,其原理是监控应用流量的qps(每秒查询率)或并发线程数等指标,当达到指定的阈值时对流量进行控制,以避免被瞬时的流量高峰冲垮,从而保障应用的高可用性

操作

控制台中:簇点链路->指定资源->添加流控

  • 资源名:唯一即可
  • 针对来源:指定对哪个微服务进行限流,默认指default,意思是不区分来源,全部限制
  • 阈值类型
    • qps:每秒请求数
    • 线程数:最大并发线程

流控模式

  • 直接:默认,接口达到限流条件时开启限流
  • 关联:当关联的资源达到限流条件时,开启限流
  • 链路:当从某个接口过来的资源达到限流条件时,开启限流

链路流控模式指的是,当从某个接口过来的资源达到限流条件时,开启限流。它的功能有点类似于针对来源配置项,区别在于:针对来源是针对上级微服务,而链路流控是针对上级接口,也就是说它的粒度更细

流控效果

  • 快速失败:默认,直接失败,抛出异常
  • warm up(预热):会有一个缓冲阶段,适用于将突然增大的流量转换为缓步增长的场景
  • 排队等待:让请求以均匀的速度通过,单机阈值为每秒通过数量,其余的排队等待

降级规则

降级规则就是设置当满足什么条件的时候,对服务进行降级处理

降级策略

  • rt:平均响应时间,单资源的平均响应时间超过阈值(单位ms)之后,资源进入准降级状态,如果接下来1s连续的5个请求,他们的rt全都超过阈值,接下来的时间窗口内,会进行降级

    rt最大4900,若要更多需要添加启动配置项

  • 异常比例:当资源的每秒异常总数占通过量的比值超过阈值后,接下来的时间窗口内,进入降级状态

  • 异常数:当资源近1分钟的异常数目超过阈值之后,记下来的时间窗口内,会进行服务降级

    由于系统统计时间窗口是分钟级别的,若时间窗口小于60s,则熔断结束后可能再次进入熔断状态

热点规则

热点参数流控规则是一种更细粒度的流控规则,它允许将规则具体到参数上。热点参数限流会统计参数中的热点参数,并根据配置的限流阈值与模式,对包含热点参数的资源调用生效
如果想使用热点规则,则需要再控制层的相关方法中使用@SentinelResource注解声明

参数

  • 参数索引:参数的下标

授权规则

很多时候需要根据调用来源来判断该次请求释放允许放行,这时候可以使用sentinel的来源访问控制的功能。来源访问控制根据资源的请求来源(origin)限制资源释放通过

  • 若配置白名单,则只有请求来源位于白名单内时才可通过
  • 若配置黑名单,则请求来源位于黑名单时不通过,其余的请求通过

流控应用

其实这个位置要填写的是来源标识,Sentinel提供了 RequestOriginParser 接口来处理来源

只要Sentinel保护的接口资源被访问,Sentinel就会调用 RequestOriginParser 的实现类去解析

访问来源

系统规则

系统保护规则是从应用级别的入口流量进行控制,从单台机器的总体load、rt、入口qps、cpu使用率和线程数五个维度进行监控应用数据,让系统尽可能抱在最大吞吐量的同时保证系统整体的稳定性

系统保护规则是应用整体维度的,而不是资源维度的,并且仅对入口流量(进入应用的流量)生效

自定义异常返回

/**
 * 异常处理
 */
@Component
public class ExceptionHandlerPage implements UrlBlockHandler {

    //BlockException 异常接口,包含Sentinel的五个异常
    // FlowException 限流异常
    // DegradeException 降级异常
    // ParamFlowException 参数限流异常
    // AuthorityException 授权异常
    // SystemBlockException 系统负载异常
    @Override
    public void blocked(HttpServletRequest request, HttpServletResponse response, BlockException e) throws IOException {
        response.setContentType("application/json;charset=utf-8"); 
        ResponseData data = null; 
        if (e instanceof FlowException) { 
            data = new ResponseData(-1, "接口被限流了..."); 
        } else if (e instanceof DegradeException) { 
            data = new ResponseData(-2, "接口被降级了..."); 
        }
        response.getWriter().write(JSON.toJSONString(data));
    }

    @Data
    @AllArgsConstructor//全参构造
    @NoArgsConstructor//无参构造
    class ResponseData {
        private int code;
        private String message;
    }
}

@SentinelResource

用于定义资源,并提供可选的异常处理和fallback配置项

属性作用
value资源名称
entryTypeentry类型,标记流量的方向,取值in/out,默认out
blockHandler处理BlockExcpetion(sentinel自身异常)的函数名称
blockHandlerClass存放blockHandler的类,对应的处理函数必须static修饰
fallback用于在抛出异常的时候提供fallback处理逻辑。fallback函数可以针对所有类型的异常进行处理
fallbackClass存放fallback的类。对应的处理函数必须static修饰
defaultFallback用于通用的fallback逻辑。默认fallback函数可以针对所有类型的异常进行处理。若同时配置了fallback和defaultFallback,以fallback为准
exceptionsToIgnore指定排除掉哪些异常。排除的异常不会计入异常统计,也不会进入fallback逻辑,而是原样抛出
exceptionsToTrace需要trace的异常

规则持久化

sentinel的规则默认是保持在内存中的,当微服务重启后,原本设置的规则将会丢失,这样是很麻烦的

sentinel规则持久化使用的是本地文件,本地文件数据源会定时轮询文件的变更,读取规则。这样我们既可以在应用本地直接修改文件来更新规则,也可以通过sentinel控制台推送规则

首先sentinel控制台通过api将规则推送至客户端并更新到内存中,接着注册的写数据源会将新的规则保持到本地的文件中

  1. 配置类

    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 applicationName;
    
        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>>() {
                }
        );
    
        @Override
        public void init() throws Exception {
            // TIPS: 如果你对这个路径不喜欢,可修改为你喜欢的路径
            String ruleDir = System.getProperty("user.home") + "/sentinel-rules/" + applicationName;
            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
            // 这样当规则文件发生变化时,就会更新规则到内存
            FlowRuleManager.register2Property(flowRuleRDS.getProperty());
            WritableDataSource<List<FlowRule>> flowRuleWDS = new FileWritableDataSource<>(
                    flowRulePath,
                    this::encodeJson
            );
    
            // 将可写数据源注册至transport模块的WritableDataSourceRegistry中
            // 这样收到控制台推送的规则时,Sentinel会先更新到内存,然后将规则写入到文件中
            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 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);
        }
    }
    
    
  2. 添加配置

    在resources下创建配置目录META-INF/services,然后添加文件com.alibaba.csp.sentinel.init.InitFunc

    在文件中添加配置类的全路径

feign整合sentinel

  1. 导入依赖

    		<dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
            </dependency>
    
  2. 配置文件中开启feign对sentinel的支持

    feign:
      sentinel:
        enabled: true
    
  3. 创建容错类:容错类要求必须实现被容错的接口,并为每个方法实现容错方案

  4. 为被容错的接口指定容错类

    @FeignClient(value = "被调用服务名",fallback = 容错类.class)
    

容错获取异常

在feign整合sentinel后,当调用失败时会执行容错类中的容错方案,但是这样就不不会抛出异常,也叫难以定位问题

  1. 创建容错工厂类:实现接口FallbackFactory接口的泛型是被容错接口

  2. 实现create方法,方法的参数就是发生的异常,可以自行进行处理;返回值是被容错接口,可用匿名内部类的形式返回容错类

  3. 为不被容错的接口指定容错类

    @FeignClient(value = "被调用服务名",fallbackFactory = 容错工厂类.class)
    

    fallback和fallbackFactory不可同时使用