Spring Cloud Alibaba之Sentinel实现熔断限流功能

微服务中为了防止某个服务出现问题，导致影响整个服务集群无法提供服务的情况，我们在系统访问量和业务量高起来了后非常有必要对服务进行熔断限流处理。 其中熔断即服务发生异常时能够更好的处理；限流是限制每个服务的资源（比如说访问量）。
spring-cloud中很多使用的是hystrix组件来进行限流的，现在我们这里使用阿里的sentinel来实现熔断限流功能。

sentinel简介

这个在阿里云有企业级的商用版本 应用高可用服务 ahas；现在有免费的入门级可以先体验下，之后再决定是否使用付费的专业版或者是自己搭建。

sentinel的github

sentinel功能概述

• 流量控制：将随机的请求调整为合适的形状。即限制请求数量；
• 熔断降级：当检测到调用链路中某个资源出现不稳定的表现，如请求响应时间长或者异常比例升高的时候，则对此资源的调用进行限制，让请求快速失败，避免影响到其它的资源而导致级联故障。 采用的手段：1.并发线程数的限制；2.通过响应时间进行降级
• 系统负载保护：sentinel提供系统维度的自适应保护能力。即在系统负载较高时，自动将流量转发到其它集群中的机器上去， 使系统的入口流量和系统的负载达到一个平衡，保护系统能力范围内处理最多的请求。

sentinel和hystrix的区别

• 两者的原则是一致的，都是当一个资源出现问题时，让其快速失败，不波及到其它服务。
• hystrix采用的是线程池隔离的方式，优点是做到了资源之间的隔离，缺点是增加了线程切换的成本
• sentinel采用的是通过并发线程的数量和响应时间来对资源限制。

sentinel规则

sentinel默认定义如下规则：

流控规则

通过qps或并发线程数来做限制，里面的针对来源可以对某个微服务做限制，默认是都限制。

• 流控模式：
• 直接：接口达到限流条件，开启限流；
• 关联：当关联的资源达到限流条件时，开启限流（适合做应用让步）
• 链路：当从某个接口过来的资源达到限流条件时，开启限流（限制更细致）

关于配置规则：可以直接使用url地址来配置，也可以通过自定义名称来配置（需要在方法上添加@sentinelresource("order")注解才能达到效果，可以重复）

链路限流不生效的问题：由于sentinel基于filter开发的拦截使用的链路收敛的模式，因此需要设置关闭链路收敛使链路收敛能够生效，

spring:
   cloud:
     sentinel:
       filter:
         # 关闭链路收敛使链路收敛能够生效
         enabled: false

降级规则

当满足设置的条件，对服务进行降级。

根据平均响应时间：当资源的平均响应时间超过阀值（以ms为单位）之后，资源进入准降级状态。
如果接下来1秒持续进入的n个请求的rt都持续超过这个阀值，则在接下来的时间窗口（单位s）之内就会使这个方法进行服务降级。

注意sentinel默认的最大时间为4900ms，超过这个时间将被默认设置为4900ms；可以通过启动配置 -dcsp.sentinel.statistic.max.rt=xxx来修改。

异常降级：通过设置异常数或者异常比例来进行服务降级。

热点规则

必须使用@sentinelresource("order")注解来做标记，将限流做到参数级别上去，并且可以配置排除参数值等于某个值时不做限流。

授权规则

通过配置黑白名单来设置是否允许通过。

自定义来源获取规则：

import com.alibaba.csp.sentinel.adapter.servlet.callback.requestoriginparser;
import org.apache.commons.lang3.stringutils;
import org.springframework.stereotype.component;

import javax.servlet.http.httpservletrequest;

/**
* <p> sentinel自定义授权来源获取规则 </p>
*/
@component
public class requestoriginparserdefinition implements requestoriginparser {

  /**
   * 定义区分来源的规则：本质上是通过获取request域中获取来源标识，然后交给流控应用来进行匹配处理
   *
   * @param request request域
   * @return 返回区分来源的值
   */
  @override
  public string parseorigin(httpservletrequest request) {
      string client = request.getheader("client");
      if(stringutils.isnotblank(client)){
          return "none";
      }
      return client;
  }
}

系统规则

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

• load（仅对 linux/unix-like 机器生效）：当系统 load1 超过阈值，且系统当前的并发线程数超过系统容量时才会触发系统保护。系统容量由系统的 maxqps * minrt 计算得出。设定参考值一般是 cpu cores * 2.5。
• rt：当单台机器上所有入口流量的平均 rt 达到阈值即触发系统保护，单位是毫秒。
• 线程数：当单台机器上所有入口流量的并发线程数达到阈值即触发系统保护。
• 入口 qps：当单台机器上所有入口流量的 qps 达到阈值即触发系统保护。
• cpu使用率：当单台机器上所有入口流量的 cpu使用率达到阈值即触发系统保护。

sentinel的使用

下面我们通过一些简单的示例来快速了解sentinel的使用。

安装控制台界面工具

在sentinel的github上下载安装包https://github.com/alibaba/sentinel/releases；就是一个jar包直接使用命令启动即可。

java -dserver.port=9080 -dcsp.sentinel.dashboard.server=localhost:9080 -dproject.name=sentinel-dashboard -jar sentinel-dashboard.jar

-dserver.port 是设置访问的端口号；
sentinel-dashboard.jar 就是刚刚下载的jar包名称；
为方便使用可以创建一个bat启动文件，在里面输入上面的命令行，后面启动直接点击这个bat文件即可。

从 sentinel 1.6.0 起，sentinel 控制台引入基本的登录功能，默认用户名和密码都是 sentinel；启动成功后浏览器输入 即可访问控制台。
注意这个控制台不是必须接入的，同时只有你的接口方法被访问过后控制台里面才会显示。

服务中使用

添加如下依赖包

<!--由于我们使用的spring-cloud,因此这里因此 sentinel的集成包来简化我们的配置 -->
<dependency>
    <groupid>com.alibaba.cloud</groupid>
    <artifactid>spring-cloud-starter-alibaba-sentinel</artifactid>
</dependency>
<!--sentinel 对dubbo的支持-->
<dependency>
    <groupid>com.alibaba.csp</groupid>
    <artifactid>sentinel-apache-dubbo-adapter</artifactid>
</dependency>

注意如果没有使用dubbo那么无需引入sentinel-apache-dubbo-adapter; 比如之前使用的是feign和hystrix搭配的，只需要将hystrix的相关配置和依赖去掉，然后加入sentinel的依赖即可。

代码中的使用示例1，如果我们只需对相关的http方法进行限流，直接引入依赖的包即可；下面是我们向对某个方法进行限流，因此使用使用@sentinelresource注解来配置。

@service
public class sentineldemoserviceimpl implements sentineldemoservice {

    /**
     * sentinel 熔断限流示例1
     */
    @sentinelresource(value = "sentineldemoservice#sentineldemo1", defaultfallback = "sentineldemo1fallback")
    @override
    public string sentineldemo1() {
        return "sentinel 示例1";
    }

    /**
     * 失败的时候会调用此方法
     */
    public string sentineldemo1fallback(throwable t) {
        if (blockexception.isblockexception(t)) {
            return "blocked by sentinel: " + t.getclass().getsimplename();
        }
        return "oops, failed: " + t.getclass().getcanonicalname();
    }

}

然后在控制台配置相关的策略规则即可。

自定义sentinel的异常返回

通过实现blockexceptionhandler接口来自定义异常返回；注意之前的urlblockhandler 视乎已经在新版中移除了。

@component
public class sentinelexceptionhandler implements blockexceptionhandler {

    /**
     * 异常处理
     *
     * @param request  请求
     * @param response 响应
     * @param e        blockexception异常接口，包含sentinel的五个异常
     *                 flowexception  限流异常
     *                 degradeexception  降级异常
     *                 paramflowexception  参数限流异常
     *                 authorityexception  授权异常
     *                 systemblockexception  系统负载异常
     * @throws ioexception io异常
     */
    @override
    public void handle(httpservletrequest request, httpservletresponse response, blockexception e) throws exception {
        jsonobject responsedata = new jsonobject();
        if (e instanceof flowexception) {
            responsedata.put("message", "限流异常");
            responsedata.put("code", "c5001");
        } else if (e instanceof degradeexception) {
            responsedata.put("message", "降级异常");
            responsedata.put("code", "c5002");
        } else if (e instanceof paramflowexception) {
            responsedata.put("message", "参数限流异常");
            responsedata.put("code", "c5003");
        } else if (e instanceof authorityexception) {
            responsedata.put("message", "授权异常");
            responsedata.put("code", "c5004");
        } else if (e instanceof systemblockexception) {
            responsedata.put("message", "系统负载异常");
            responsedata.put("code", "c5005");
        }
        response.setcontenttype("application/json;charset=utf-8");
        response.getwriter().write(responsedata.tojsonstring());
    }
}

基于文件实现sentinel规则的持久化

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

编写一个实现initfunc接口的类，在里面定义持久化的方式，这里使用文件

public class filepersistence implements initfunc {

  @value("spring.application.name")
  private string applicationname;

  @override
  public void init() throws exception {
      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.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；在文件中添加上面写的配置类的全路径top.vchar.order.config.filepersistence

使用nacos实现动态规则配置

动态规则扩展文档

添加如下依赖

<dependency>
    <groupid>com.alibaba.csp</groupid>
    <artifactid>sentinel-datasource-nacos</artifactid>
</dependency>

添加如下配置（具体可以参考sentinelproperties 配置类）：

spring:
  cloud:
    sentinel:
      datasource:
        flow:
          # 配置nacos的
          nacos:
            rule-type: flow
            server-addr: 127.0.0.1:8848
            namespace: public
            groupid: "default_group"
            dataid: dubbo-customer-demo-sentinel.rule
            username: nacos
            password: 123456

然后在nacos中创建一个配置文件 dubbo-customer-demo-sentinel.rule，类型为text; 具体配置参数见官网说明；下面是一个示例：

[
    {
        "resource": "sentineldemoservice#sentineldemo2",
        "count": 0,
        "grade": 1,
        "limitapp":"default",
        "strategy":0,
        "controlbehavior":0,
        "clustermode":false
    }
]

实际使用不建议这样做，还是建议使用控制台的方式；因为使用官方提供的集成方式时，nacos的时候会疯狂的拉取数据，同时只支持一个规则的配置；因此要么自己去基于nacos实现，要么使用控制台的方式；
且配置项很多，因此还是建议使用控制台的方式来实现，或者是对接其rest api接口，在实际操作中还是建议使用界面化的操作。

关于熔断降级是如何实现自动调用我们配置的fallback方法

sentinel使用了spring的aop切面编程功能拦截有@sentinelresource注解的类，具体查看com.alibaba.csp.sentinel.annotation.aspectj.sentinelresourceaspect类，在执行实际的方法时使用try-catch进行异常捕获，
如果异常是blockexception的时候会调用handleblockexception方法（注意我们也可以配置自己自定义的异常也走这个方法），通过反射执行配置的fallback方法。

到此这篇关于spring cloud alibaba之sentinel的文章就介绍到这了,更多相关spring cloud alibaba内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！