Sentinel整合Dubbo限流实战（二）

限流的基本认识

场景分析

一个互联网产品，打算搞一次大促来增加销量以及曝光。公司的架构师基于往期的流量情况做了一个活动流量的预估，然后整个公司的各个技术团队开始按照这个目标进行设计和优化，最终在大家不懈的努力之下，达到了链路压测的目标流量峰值。到了活动开始那天，大家都在盯着监控面板，看着流量像洪水一样涌进来。由于前期的宣传工作做得很好，使得这个流量远远超过预估的峰值，后端服务开始不稳定，CPU、内存各种爆表。部分服务开始出现无响应的情况。最后，整个系统开始崩溃，用户无法正常访问服务。

引入限流

在10.1黄金周，各大旅游景点都是人满为患。所有有些景点为了避免出现踩踏事故，会采取限流措施。
那在架构场景中，是不是也能这么做呢？针对这个场景，能不能够设置一个最大的流量限制，如果超过这个流量，我们就拒绝提供服务，从而使得我们的服务不会挂掉。当然，限流虽然能够保护系统不被压垮，但是对于被限流的用户，就会很不开心。所以限流其实是一种有损的解决方案。但是相比于全部不可用，有损服务是最好的一种解决办法。

限流的作用

除了前面说的限流使用场景之外，限流的设计还能防止恶意请求流量、恶意攻击。
所以，限流的基本原理是通过对并发访问/请求进行限速或者一个时间窗口内的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务（定向到错误页或者告知资源没有了）、排队或等待(秒杀、下单)、降级（返回兜底数据或默认数据，如商品详情页库存默认有货）。
一般互联网企业常见的限流有：限制总并发数（如数据库连接池、线程池）、限制瞬时并发数（nginx的limit_conn模块，用来限制瞬时并发连接数）、限制时间窗口内的平均速率（如Guava的RateLimiter、nginx的limit_req模块，限制每秒的平均速率）；其他的还有限制远程接口调用速率、限制MQ的消费速率。另外还可以根据网络连接数、网络流量、CPU或内存负载等来限流。
有了限流，就意味着在处理高并发的时候多了一种保护机制，不用担心瞬间流量导致系统挂掉或雪崩，最终做到有损服务而不是不服务。

常见的限流算法

滑动窗口
发送和接受方都会维护一个数据帧的序列，这个序列被称作窗口。目的在于控制发送速度，以免接受方的缓存不够大，而导致溢出，同时控制流量也可以避免网络拥塞。如下图所示：

微信图片_20200512190054.png

图中的4,5,6号数据帧已经被发送出去，但是未收到关联的ACK，7,8,9帧则是等待发送。可以看出发送端的窗口大小为6，这是由接受端告知的。此时如果发送端收到4号ACK，则窗口的左边缘向右收缩，窗口的右边缘则向右扩展，此时窗口就向前“滑动了”，即数据帧10也可以被发送。演示地址
漏桶（控制传输速率Leaky bucket）
漏桶算法思路是，不断的往桶里面注水，无论注水的速度是大还是小，水都是按固定的速率往外漏水；如果桶满了，水会溢出；
桶本身具有一个恒定的速率往下漏水，而上方时快时慢的会有水进入桶内。当桶还未满时，上方的水可以加入。一旦水满，上方的水就无法加入。桶满正是算法中的一个关键的触发条件（即流量异常判断成立的条件）。而此条件下如何处理上方流下来的水，有两种方式，在桶满水之后，常见的两种处理方式为：
1）暂时拦截住上方水的向下流动，等待桶中的一部分水漏走后，再放行上方水。
2）溢出的上方水直接抛弃。
特点：

• 1、漏水的速率是固定的。
• 2、即使存在突然注水量变大的情况，楼岁的速率也是固定的。
  *令牌桶（能够处理突发的流量）
  令牌桶算法是网络流量整形（Traffic Shaping）和速率限制（Rate Limiting）中最常使用的一种算法。典型情况下，令牌桶算法用来控制发送到网络上的数据的数目，并允许突发数据的发送。

• 令牌流和令牌桶
  系统会以一定的速度生成令牌，并将其放置到令牌桶中，可以将令牌桶想象成一个缓冲区（可以用队列这种数据结构来实现），当缓冲区填满的时候，新生成的令牌会被扔掉。这里有两个变量很重要：
  第一个是生成令牌的速度，一般称为 rate 。比如，我们设定 rate = 2 ，即每秒钟生成 2 个令牌，也就是每 1/2 秒生成一个令牌；
  第二个是令牌桶的大小，一般称为 burst 。比如，我们设定 burst = 10 ，即令牌桶最大只能容纳 10 个令牌。
  有三种情况可能发生：

• 数据流的速率=令牌流点的速率：这种情况下,每个到来的数据包或者请求都能对应一个令牌,然后无延迟地通过队列；
• 数据流的速率<令牌流的速率：通过队列的数据包或者请求只消耗了一部分令牌，剩下的令牌会在令牌桶里积累下来，直到桶被装满。剩下的令牌可以在突发请求的时候消耗掉。
• 数据流的速率>令牌流的速率：桶里的令牌很快就会被耗尽。导致服务中断一段时间，如果数据包或者请求持续到来,将发生丢包或者拒绝响应。

Sentinel整合Dubbo

限流的方式：
Semaphore，RateLimiter ->令牌桶/漏桶；
Redisson（RRateLimiter）；
Alibaba Sentinel
限流只是一个最基本的服务治理/服务质量体系要求

• 流量的切换
• 能不能够针对不同的渠道设置不同的限流策略
• 流量的监控
• 熔断
• 动态限流
• 集群限流

本文主要讲讲Sentinel怎么用

• 初始化限流规则
• 根据限流规则进行限流

Sentinel限流的思考

• 限流用了什么算法来实现（滑动窗口）
• 他是怎么实现的（责任链）
• SPI的扩展

创建provider项目

微信图片_20200512193542.png

添加jar依赖

<dependency>
            <groupId>com.tc.sentinel</groupId>
            <version>1.1-SNAPSHOT</version>
            <artifactId>sentinel-api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.7.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>2.12.0</version>
        </dependency>

SentinelService api

public interface SentinelService { String sayHello(String name); }

SentinelServiceImpl

/**把当前服务发布成dubbo服务*/
@Service
public class SentinelServiceImpl implements SentinelService {
    @Override
    public String sayHelloWorld(String txt) {
        System.out.println("begin execute sayHello:" + txt);
        return "Hello World :" + LocalDateTime.now();
    }
}

DubboConfig

@Configuration
@DubboComponentScan("com.tc.sentinel")
public class DubboConfig {

    @Bean
    public ApplicationConfig applicationConfig(){
        ApplicationConfig applicationConfig=new ApplicationConfig();
        applicationConfig.setName("sentinel-provider");
        applicationConfig.setOwner("Tc");
        return applicationConfig;
    }
    @Bean
    public RegistryConfig registryConfig(){
        RegistryConfig registryConfig=new RegistryConfig();
        registryConfig.setAddress("zookeeper://120.**.**.***:2181");
        return registryConfig;
    }
    @Bean
    public ProtocolConfig protocolConfig(){
        ProtocolConfig protocolConfig=new ProtocolConfig();
        protocolConfig.setName("dubbo");
        protocolConfig.setPort(20880);
        return protocolConfig;
    }
}

创建SpringBoot的Consumer项目

添加jar依赖

<dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.7.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>2.12.0</version>
        </dependency>
        <dependency>
            <groupId>com.tc.sentinel</groupId>
            <artifactId>sentinel-api</artifactId>
            <version>1.1-SNAPSHOT</version>
        </dependency>

SentinelDubboController

@RestController
public class SentinelController {
    @Reference
    SentinelService sentinelService;
    @GetMapping("/say")
    public String sayHello(){
        RpcContext.getContext().setAttachment("dubboApplication","sentinel-web");
        return sentinelService.sayHelloWorld("test-sentinel");
    }
    @GetMapping("/say2")
    public String sayHello2(){
        return sentinelService.sayHelloWorld("test-default");
    }
}

application.properties

dubbo.registry.address=zookeeper://120.**.**.***:2181
dubbo.scan.base-packages=com.tc.sentinel.sentinelweb
dubbo.application.name=sentinel-web
server.port=8090

在provider添加sentinel限流支持

添加jar包依赖

<dependency>
            <groupId>com.alibaba.csp</groupId>
            <artifactId>sentinel-dubbo-adapter</artifactId>
            <version>1.6.3</version>
</dependency>

设置限流的基准

Service Provider 用于向外界提供服务，处理各个消费者的调用请求。为了保护 Provider 不被激增的流量拖垮影响稳定性，可以给 Provider 配置 QPS 模式的限流，这样当每秒的请求量超过设定的阈值时会自动拒绝多的请求。
限流粒度可以是服务接口和服务方法两种粒度。若希望整个服务接口的 QPS 不超过一定数值，则可以为对应服务接口资源（resourceName 为接口全限定名）配置 QPS 阈值；若希望服务的某个方法的 QPS 不超过一定数值，则可以为对应服务方法资源（resourceName 为接口全限定名:方法签名）配置 QPS 阈值

@SpringBootApplication
public class SentinelProviderApplication {

    public static void main(String[] args) throws IOException {
        //表示当前的节点是集群客户端
//        ClusterStateManager.applyState(ClusterStateManager.CLUSTER_CLIENT);
        //初始化限流规则
        initFlowRole();
        SpringApplication.run(SentinelProviderApplication.class, args);
        System.in.read();
    }

    //限流规则
    private static void initFlowRole(){
        FlowRule flowRule = new FlowRule();
        //针对具体方法限流
        flowRule.setResource("com.tc.sentinel.SentinelService:sayHelloWorld(java.lang.String)");
        //限流阈值 qps=10
        flowRule.setCount(5);
        //限流阈值类型（QPS或者并发线程数）
        flowRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        //流控针对的调用来源，若为 default 则不区分调 用来源
        flowRule.setLimitApp("sentinel-web");
        //流量控制手段（直接拒绝、Warm Up、匀速排队）
        flowRule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
        FlowRuleManager.loadRules(Collections.singletonList(flowRule));
    }
}

启动时加入 JVM 参数 -Dcsp.sentinel.dashboard.server=localhost:8080 指定控制台地址和端口。

试用jemeter进行压测

参数解释

LimitApp*
很多场景下，根据调用方来限流也是非常重要的。比如有两个服务 A 和 B 都向 Service Provider 发起调用请求，我们希望只对来自服务 B 的请求进行限流，则可以设置限流规则的 limitApp 为服务 B 的名称。Sentinel Dubbo Adapter 会自动解析 Dubbo 消费者（调用方）的 application name 作为调用方名称（origin），在进行资源保护的时候都会带上调用方名称。若限流规则未配置调用方（default），则该限流规则对所有调用方生效。若限流规则配置了调用方则限流规则将仅对指定调用方生效。
注：Dubbo 默认通信不携带对端 application name 信息，因此需要开发者在调用端手动将 application name 置入 attachment 中，provider 端进行相应的解析。Sentinel Dubbo Adapter 实现了一个 Filter 用 于自动从 consumer 端向 provider 端透传 application name。若调用端未引入 Sentinel Dubbo Adapter，又希望根据调用端限流，可以在调用端手动将 application name 置入 attachment 中，key 为dubboApplication。

演示流程
1、修改provider中限流规则：flowRule.setLimitApp("sentinel-web");
2、在consumer工程中，做如下处理。其中一个通过attachment传递了一个消费者的application.name，另一个没有传，通过jemeter工具进行测试。

@GetMapping("/say")
    public String sayHello(){
        RpcContext.getContext().setAttachment("dubboApplication","sentinel-web");
        return sentinelService.sayHelloWorld("test-sentinel");
    }
    @GetMapping("/say2")
    public String sayHello2(){
        return sentinelService.sayHelloWorld("test-default");
    }

ControlBehavior

当 QPS 超过某个阈值的时候，则采取措施进行流量控制。流量控制的手段包括以下几种：直接拒绝、Warm Up、匀速排队。对应 FlowRule 中的 controlBehavior 字段。
直接拒绝（RuleConstant.CONTROL_BEHAVIOR_DEFAULT）方式是默认的流量控制方式，当QPS超过任意规则的阈值后，新的请求就会被立即拒绝，拒绝方式为抛出FlowException。这种方式适用于对系统处理能力确切已知的情况下，比如通过压测确定了系统的准确水位。
Warm Up（RuleConstant.CONTROL_BEHAVIOR_WARM_UP）方式，即预热/冷启动方式，当系统长期处于低并发的情况下，流量突然增加到qps的最高峰值，可能会造成系统的瞬间流量过大把系统压垮。所以warmup，相当于处理请求的数量是缓慢增加，经过一段时间以后，到达系统处理请求个数的最大值。
匀速排队（RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER）方式会严格控制请求通过的间隔时间，也即是让请求以均匀的速度通过，对应的是漏桶算法。
它的原理是，以固定的间隔时间让请求通过。当请求过来的时候，如果当前请求距离上个通过的请求通过的时间间隔不小于预设值，则让当前请求通过；否则，计算当前请求的预期通过时间，如果该请求的预期通过时间小于规则预设的 timeout 时间，则该请求会等待直到预设时间到来通过；反之，则马上抛出阻塞异常。
可以设置一个最长排队等待时间：

flowRule.setMaxQueueingTimeMs(5 * 1000);         // 最长排队等待时间：5s

这种方式主要用于处理间隔性突发的流量，例如消息队列。想象一下这样的场景，在某一秒有大量的请求到来，而接下来的几秒则处于空闲状态，我们希望系统能够在接下来的空闲期间逐渐处理这些请求，而不是在第一秒直接拒绝多余的请求。

如何是实现分布式限流
在前面的所有案例中，我们只是基于Sentinel的基本使用和单机限流的使用，假如有这样一个场景，我们现在把provider部署了10个集群，希望调用这个服务的api的总的qps是100，意味着每一台机器的qps是10，理想情况下总的qps就是100.但是实际上由于负载均衡策略的流量分发并不是非常均匀的，就会导致总的qps不足100时，就被限了。在这个场景中，仅仅依靠单机来实现总体流量的控制是有问
题的。所以最好是能实现集群限流。

架构图

要想使用集群流控功能，我们需要在应用端配置动态规则源，并通过 Sentinel 控制台实时进行推送。如下图所示：

微信图片_20200512202412.png

搭建token-server

jar包依赖

<dependency>
      <groupId>com.alibaba.csp</groupId>
      <artifactId>sentinel-cluster-server-default</artifactId>
      <version>1.6.3</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba.csp</groupId>
      <artifactId>sentinel-datasource-nacos</artifactId>
      <version>1.6.3</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.25</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba.csp</groupId>
      <artifactId>sentinel-transport-simple-http</artifactId>
      <version>1.6.3</version>
    </dependency>

ClusterServer

public class ClusterServer {

    public static void main(String[] args) throws Exception {
        ClusterTokenServer tokenServer = new SentinelDefaultTokenServer();
        ClusterServerConfigManager.loadGlobalTransportConfig(
                new ServerTransportConfig().setIdleSeconds(600).setPort(9999));
ClusterServerConfigManager.loadServerNamespaceSet(Collections.singleton("App-Tc"));
        tokenServer.start();
    }
}

/**
 * 从nacos上去获得动态的限流规则
 */
public class NacosDataSourceInitFunc implements InitFunc {
    /**nacos 配置中心的服务host*/
    private final String remoteAddress="192.168.12.101";
    /**nacos groupId*/
    private final String groupId="SENTINEL_GROUP";
    /**dataid（names + postfix） namespace不同，限流规则也不同*/
    private final String FLOW_POSTFIX="-flow-rules";
    /**意味着当前的token-server会从nacos上获得限流的规则*/
    @Override
    public void init() throws Exception {
        ClusterFlowRuleManager.setPropertySupplier(namespeces->{
            ReadableDataSource<String, List<FlowRule>> rds =
                    new NacosDataSource<>(remoteAddress, groupId, namespeces + FLOW_POSTFIX,
                            source -> JSON.parseObject(source, new TypeReference<List<FlowRule>>() {
                            }));
            return rds.getProperty();
        });
    }
}

在resource目录添加扩展点
/META-INF/services/com.alibaba.csp.sentinel.init.InitFunc = 自定义扩展点
启动Sentinel dashboard
启动nacos以及增加配置
配置内容：

  [
          {
             "resource":"com.gupao.sentinel.sentinelService:sayHello(java.lang.String)",
             "grade":1,       限流模式：1-qps
              "count":10,      限流阈值
              "clusterMode":true,     是否集群模式
             "clusterConfig":{
                  "flowId":111222,        全局唯一id
                  "thresholdType":1,            阈值模式：1-全局
                  "fallbackToLocalWhenFail":true        client通信失败  是否使用本地
              }
          }
      ]

配置JVM参数：
配置如下jvm启动参数，连接到sentinel dashboard
-Dproject.name=App-Tc -Dcsp.sentinel.dashboard.server=192.168.12.101:8080 -Dcsp.sentinel.log.use.pid=true

Dubbo接入分布式限流

jar包依赖

<dependency>
            <groupId>com.alibaba.csp</groupId>
            <artifactId>sentinel-cluster-client-default</artifactId>
            <version>1.6.3</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.csp</groupId>
            <artifactId>sentinel-datasource-nacos</artifactId>
            <version>1.6.3</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.csp</groupId>
            <artifactId>sentinel-transport-simple-http</artifactId>
            <version>1.6.3</version>
        </dependency>

增加扩展点

扩展点需要在resources/META-INF/services/增加扩展的配置
com.alibaba.csp.sentinel.init.initFunc=自定义扩展点

/**
 * 从nacos上去获得动态的限流规则
 */
public class NacosDataSourceInitFunc implements InitFunc {

    //token-server的地址
    private static final String CLUSTER_SERVER_HOST="localhost";
    private static final int CLUSTER_SERVER_PORT=9999;
    //请求超时时间
    private static final int REQUEST_TIME_OUT=200000;

    //namespace
    private static final String APP_NAME = "App-Tc";

    /**nacos配置中心的服务host*/
    private static final String REMOTE_ADDRESS = "192.168.12.101";

    /**groupId*/
    private static final String  GROUP_ID = "SENTINEL_GROUP";

    /**dataid（names+postfix）*/
    private static final String FLOW_POSTFIX = "-flow-rules";

    /**意味着当前的token-server会从nacos上获得限流的规则*/
    @Override
    public void init() throws Exception {
         //加载集群-信息
        loadClusterClientConfig();
        registryClusterFlowRuleProperty();
    }

    /**通过硬编码的方式，配置连接到token-server的服务地址（实际使用过程中不建议，
     *可以基于动态配置改造 ）*/
    private static void loadClusterClientConfig() {
        ClusterClientAssignConfig assignConfig = new ClusterClientAssignConfig();
        assignConfig.setServerHost(CLUSTER_SERVER_HOST);
        assignConfig.setServerPort(CLUSTER_SERVER_PORT);
        ClusterClientConfigManager.applyNewAssignConfig(assignConfig);

        ClusterClientConfig clientConfig = new ClusterClientConfig();
        //token-client请求token-server获取令牌的超时时间
        clientConfig.setRequestTimeout(REQUEST_TIME_OUT);
        ClusterClientConfigManager.applyNewConfig(clientConfig);
    }

    /**注册动态数据源*/
    /**
     * [
     *     {
     *         "resource":"com.gupao.sentinel.sentinelService:sayHello(java.lang.String)",
     *         "grade":1,       限流模式：1-qps
     *         "count":10,      限流阈值
     *         "clusterMode":true,     是否集群模式
     *         "clusterConfig":{
     *             "flowId":111222,        全局唯一id
     *             "thresholdType":1,            阈值模式：1-全局
     *             "fallbackToLocalWhenFail":true        client通信失败  是否使用本地
     *         }
     *     }
     * ]
     */
/*** 注册动态规则Property 
* 当client与Server连接中断，退化为本地限流时需要用到的该规则 
* 该配置为必选项，客户端会从nacos上加载限流规则，请求tokenserver时，会戴上要check的规 则id 
* {这里的动态数据源，我们稍后会专门讲到}
 */
    private static void registryClusterFlowRuleProperty(){
// 使用 Nacos 数据源作为配置中心，需要在 REMOTE_ADDRESS 上启动一个 Nacos 的服务        
ReadableDataSource<String, List<FlowRule>> ds =
                new NacosDataSource<>(REMOTE_ADDRESS, GROUP_ID, APP_NAME + FLOW_POSTFIX,
                        source -> JSON.parseObject(source, new TypeReference<List<FlowRule>>() {
                        }));

        // 为集群客户端注册动态规则源
        FlowRuleManager.register2Property(ds.getProperty());
    }
}

配置jvm参数

这里的project-name要包含在token-server中配置的namespace中，token server 会根据客户端对应的 namespace（默认为 project.name 定义的应用名）下的连接数来计算总的阈值。
-Dproject.name=App-Tc
-Dcsp.sentinel.dashboard.server=192.168.12.101:8080
-Dcsp.sentinel.log.use.pid=true

演示集群限流

所谓集群限流，就是多个服务节点使用同一个限流规则。从而对多个节点的总流量进行限制，添加一个sentinel-server。同时运行两个程序。