Sentinel：万字详解微服务的哨兵机制，我跪了

标签：调用   架构   检验   down   inf   orm   with   不可用   签名   

随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel 以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。

Sentinel 具有以下特征：

• 丰富的应用场景：Sentinel 承接了阿里巴巴近10年的双十一大促流量的核心场景，例如秒杀、消息削峰填谷、集群流量控制、实时熔断下游不可用应用等。
• 完备的实时监控：Sentinel 同时提供实时的监控功能。你可以在控制台中看到接入应用的单台机器秒级数据，甚至 500 台以下规模的集群的汇总运行情况。
• 广泛的开源生态：Sentinel 提供开箱即用的与其它开源框架/库的整合模块，例如与 Spring Cloud、Dubbo、gRPC 的整合。只需要引入相应的依赖并进行简单的配置即可快速地接入 Sentinel。
• 完善的SPI扩展点：Sentinel 提供简单易用、完善的 SPI 扩展接口。您可以通过实现扩展接口来快速地定制逻辑。例如定制规则管理、适配动态数据源等。

Sentinel 的主要特性：

Sentinel 的开源生态：

Sentinel 分为两个部分：

• 核心库（Java 客户端）不依赖任何框架/库，能够运行于所有 Java 运行时环境，同时对 Dubbo / Spring Cloud 等框架也有较好的支持。
• 控制台（Dashboard）基于 Spring Boot 开发，打包后可以直接运行，不需要额外的 Tomcat 等应用容器。

2. Sentinel 快速开始

首先，引入 Sentinel 依赖

 <dependency>
     <groupId>com.alibaba.csp</groupId>
     <artifactId>sentinel-core</artifactId>
     <version>1.7.1</version>
 </dependency> 

接着，定义资源

资源?是 Sentinel 中的核心概念之一。最常用的资源是我们代码中的 Java 方法。 当然，您也可以更灵活的定义你的资源，例如，把需要控制流量的代码用 Sentinel API SphU.entry("HelloWorld") 和 entry.exit() 包围起来即可。在下面的例子中，我们将 System.out.println("hello world"); 作为资源（被保护的逻辑），用 API 包装起来。例如：

try (Entry entry = SphU.entry("HelloWorld")) {
     // Your business logic here.
     System.out.println("hello world");
 } catch (BlockException e) {
     // Handle rejected request.
     e.printStackTrace();
 }
 // try-with-resources auto exit 

还可以使用注解定义资源??https://github.com/alibaba/Sentinel/wiki/%E6%B3%A8%E8%A7%A3%E6%94%AF%E6%8C%81?

例如：

 @SentinelResource("HelloWorld")
 public void helloWorld() {
     // 资源中的逻辑
     System.out.println("hello world");
 } 

最后，定义规则

接下来，通过流控规则来指定允许该资源通过的请求次数，例如下面的代码定义了资源 HelloWorld 每秒最多只能通过 20 个请求。

 private static void initFlowRules(){
     List<FlowRule> rules = new ArrayList<>();
     FlowRule rule = new FlowRule();
     rule.setResource("HelloWorld");
     rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
     // Set limit QPS to 20.
     rule.setCount(20);
     rules.add(rule);
     FlowRuleManager.loadRules(rules);
 } 

完成！

完整的代码如下：

pom.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 4     <modelVersion>4.0.0</modelVersion>
 5     <parent>
 6         <groupId>org.springframework.boot</groupId>
 7         <artifactId>spring-boot-starter-parent</artifactId>
 8         <version>2.2.2.RELEASE</version>
 9         <relativePath/> <!-- lookup parent from repository -->
10     </parent>
11     <groupId>com.cjs.example</groupId>
12     <artifactId>sentinel-example</artifactId>
13     <version>0.0.1-SNAPSHOT</version>
14     <name>sentinel-example</name>
15 
16     <properties>
17         <java.version>1.8</java.version>
18         <spring-cloud.version>Greenwich.SR4</spring-cloud.version>
19         <spring-cloud-alibaba.version>2.1.0.RELEASE</spring-cloud-alibaba.version>
20     </properties>
21 
22     <dependencies>
23         <dependency>
24             <groupId>org.springframework.boot</groupId>
25             <artifactId>spring-boot-starter-actuator</artifactId>
26         </dependency>
27         <dependency>
28             <groupId>org.springframework.boot</groupId>
29             <artifactId>spring-boot-starter-web</artifactId>
30         </dependency>
31         <dependency>
32             <groupId>com.alibaba.cloud</groupId>
33             <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
34         </dependency>
35 
36     </dependencies>
37 
38     <dependencyManagement>
39         <dependencies>
40             <dependency>
41                 <groupId>org.springframework.cloud</groupId>
42                 <artifactId>spring-cloud-dependencies</artifactId>
43                 <version>${spring-cloud.version}</version>
44                 <type>pom</type>
45                 <scope>import</scope>
46             </dependency>
47 
48             <dependency>
49                 <groupId>com.alibaba.cloud</groupId>
50                 <artifactId>spring-cloud-alibaba-dependencies</artifactId>
51                 <version>${spring-cloud-alibaba.version}</version>
52                 <type>pom</type>
53                 <scope>import</scope>
54             </dependency>
55         </dependencies>
56     </dependencyManagement>
57 
58     <build>
59         <plugins>
60             <plugin>
61                 <groupId>org.springframework.boot</groupId>
62                 <artifactId>spring-boot-maven-plugin</artifactId>
63             </plugin>
64         </plugins>
65     </build>
66 
67 </project>

application.properties

 server.port=8084
 spring.application.name=sentinel-example
 spring.cloud.sentinel.transport.dashboard=127.0.0.1:8080

SentinelExampleApplication.java

 1 package com.cjs.example.sentinel;
 2 
 3 import com.alibaba.csp.sentinel.Entry;
 4 import com.alibaba.csp.sentinel.SphU;
 5 import com.alibaba.csp.sentinel.slots.block.BlockException;
 6 import com.alibaba.csp.sentinel.slots.block.RuleConstant;
 7 import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
 8 import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
 9 import org.springframework.boot.SpringApplication;
10 import org.springframework.boot.autoconfigure.SpringBootApplication;
11 
12 import java.util.ArrayList;
13 import java.util.List;
14 
15 @SpringBootApplication
16 public class SentinelExampleApplication {
17 
18     public static void main(String[] args) {
19         SpringApplication.run(SentinelExampleApplication.class, args);
20 
21 
22         // 配置规则.
23         initFlowRules();
24 
25         while (true) {
26             // 1.5.0 版本开始可以直接利用 try-with-resources 特性，自动 exit entry
27             try (Entry entry = SphU.entry("HelloWorld")) {
28                 // 被保护的逻辑
29                 System.out.println("hello world");
30             } catch (BlockException ex) {
31                 // 处理被流控的逻辑
32                 System.out.println("blocked!");
33             }
34         }
35     }
36 
37 
38     private static void initFlowRules() {
39         List<FlowRule> rules = new ArrayList<>();
40 
41         FlowRule rule = new FlowRule();
42         rule.setResource("HelloWorld");
43         rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
44         // Set limit QPS to 20.
45         rule.setCount(20);
46         rules.add(rule);
47 
48         FlowRuleManager.loadRules(rules);
49 
50     }
51 }

TestController.java

 1 package com.cjs.example.sentinel;
 2 
 3 import com.alibaba.csp.sentinel.annotation.SentinelResource;
 4 import org.springframework.web.bind.annotation.GetMapping;
 5 import org.springframework.web.bind.annotation.RestController;
 6 
 7 @RestController
 8 public class TestController {
 9 
10     @GetMapping("/hello")
11     @SentinelResource("hello")
12     public String hello() {
13         return "hello";
14     }
15 
16 }

3. Sentinel 控制台

Sentinel 控制台最少应该包含如下功能：

• 查看机器列表以及健康情况：收集 Sentinel 客户端发送的心跳包，用于判断机器是否在线。
• 监控 (单机和集群聚合)：通过 Sentinel 客户端暴露的监控 API，定期拉取并且聚合应用监控信息，最终可以实现秒级的实时监控。
• 规则管理和推送：统一管理推送规则。
• 鉴权：生产环境中鉴权非常重要。

https://github.com/alibaba/Sentinel/wiki/%E6%8E%A7%E5%88%B6%E5%8F%B0

获取控制台：

方式一：下载已经打好的包

https://github.com/alibaba/Sentinel/releases?

wget https://github.com/alibaba/Sentinel/releases/download/1.7.1/sentinel-dashboard-1.7.1.jar

方式二：通过源码构件?

mvn clean package?

启动控制台

java -Dserver.port=8080 -Dcsp.sentinel.dashboard.server=localhost:8080 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.7.1.jar

默认用户名密码都是sentinel?

4. Sentinel 注解支持

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

@SentinelResource 注解的属性：

• value ：资源名称
• entryType ：the entry type (inbound or outbound)
• blockHandler/blockHandlerClass ：?blockHandler 是对应处理 BlockException 的函数名称。blockHandler 函数访问范围需要是 public，返回类型需要与原方法相匹配，参数类型需要和原方法相匹配并且最后加一个额外的参数，类型为 BlockException。blockHandler 函数默认需要和原方法在同一个类中。若希望使用其他类的函数，则可以指定blockHandlerClass。blockHandlerClass 为对应函数所在类的 Class 对象，注意对应的函数必需为 static 函数，否则无法解析。

• fallback ：fallback 函数名称，可选项，用于在抛出异常的时候提供 fallback 处理逻辑。fallback 函数可以针对所有类型的异常（除了?exceptionsToIgnore?里面排除掉的异常类型）进行处理。fallback 函数签名和位置要求：defaultFallback ：默认的 fallback 函数名称，可选项，通常用于通用的 fallback 逻辑

  • 返回值类型必须与原函数返回值类型一致；
  • 方法参数列表需要和原函数一致，或者可以额外多一个?Throwable?类型的参数用于接收对应的异常；
  • fallback 函数默认需要和原方法在同一个类中。若希望使用其他类的函数，则可以指定?fallbackClass?为对应的类的?Class?对象，注意对应的函数必需为 static 函数，否则无法解析；　
• exceptionsToIgnore ：用于指定哪些异常被排除掉，不会计入异常统计中，也不会进入 fallback 逻辑中，而是会原样抛出?

需要注意的是，若 blockHandler 和 fallback 都进行了配置，则被限流降级而抛出 BlockException 时只会进入 blockHandler 处理逻辑。若未配置 blockHandler、fallback 和 defaultFallback，则被限流降级时会将 BlockException 直接抛出（若方法本身未定义 throws BlockException 则会被 JVM 包装一层 UndeclaredThrowableException）。?

示例：

 1 public class TestService {
 2 
 3     // 对应的 `handleException` 函数需要位于 `ExceptionUtil` 类中，并且必须为 static 函数.
 4     @SentinelResource(value = "test", blockHandler = "handleException", blockHandlerClass = {ExceptionUtil.class})
 5     public void test() {
 6         System.out.println("Test");
 7     }
 8 
 9     // 原函数
10     @SentinelResource(value = "hello", blockHandler = "exceptionHandler", fallback = "helloFallback")
11     public String hello(long s) {
12         return String.format("Hello at %d", s);
13     }
14     
15     // Fallback 函数，函数签名与原函数一致或加一个 Throwable 类型的参数.
16     public String helloFallback(long s) {
17         return String.format("Halooooo %d", s);
18     }
19 
20     // Block 异常处理函数，参数最后多一个 BlockException，其余与原函数一致.
21     public String exceptionHandler(long s, BlockException ex) {
22         // Do some log here.
23         ex.printStackTrace();
24         return "Oops, error occurred at " + s;
25     }
26 } 

可以看到，blockHandler和fallback必须与原方法在同一个类中。如果不想写在同一个类中，可以利用blockHandlerClass来指定类，然后通过blockHandler指定方法名。

如果同时配置了blockHandler和fallback，则BlockException只会进到blockHandler处理逻辑中。

5. Sentinel 基本概念

资源

只要通过 Sentinel API 定义的代码，就是资源，能够被 Sentinel 保护起来。大部分情况下，可以使用方法签名，URL，甚至服务名称作为资源名来标示资源。?

规则

围绕资源的实时状态设定的规则，可以包括流量控制规则、熔断降级规则以及系统保护规则。所有规则可以动态实时调整。?

流量控制

流量控制在网络传输中是一个常用的概念，它用于调整网络包的发送数据。然而，从系统稳定性角度考虑，在处理请求的速度上，也有非常多的讲究。任意时间到来的请求往往是随机不可控的，而系统的处理能力是有限的。我们需要根据系统的处理能力对流量进行控制。Sentinel 作为一个调配器，可以根据需要把随机的请求调整成合适的形状，如下图所示：?

流量控制有以下几个角度：

• 资源的调用关系，例如资源的调用链路，资源和资源之间的关系；
• 运行指标，例如 QPS、线程池、系统负载等；
• 控制的效果，例如直接限流、冷启动、排队等；?

Sentinel 的设计理念是让您自由选择控制的角度，并进行灵活组合，从而达到想要的效果。

熔断降级?

Sentinel 和 Hystrix 的原则是一致的: 当检测到调用链路中某个资源出现不稳定的表现，例如请求响应时间长或异常比例升高的时候，则对这个资源的调用进行限制，让请求快速失败，避免影响到其它的资源而导致级联故障。

在限制的手段上，Sentinel 和 Hystrix 采取了完全不一样的方法。

Hystrix 通过线程池隔离的方式，来对依赖（在 Sentinel 的概念中对应?资源）进行了隔离。这样做的好处是资源和资源之间做到了最彻底的隔离。缺点是除了增加了线程切换的成本（过多的线程池导致线程数目过多），还需要预先给各个资源做线程池大小的分配。?如下图：

Sentinel 对这个问题采取了两种手段:

• 通过并发线程数进行限制

和资源池隔离的方法不同，Sentinel 通过限制资源并发线程的数量，来减少不稳定资源对其它资源的影响。这样不但没有线程切换的损耗，也不需要您预先分配线程池的大小。当某个资源出现不稳定的情况下，例如响应时间变长，对资源的直接影响就是会造成线程数的逐步堆积。当线程数在特定资源上堆积到一定的数量之后，对该资源的新请求就会被拒绝。堆积的线程完成任务后才开始继续接收请求。

• 通过响应时间对资源进行降级

除了对并发线程数进行控制以外，Sentinel 还可以通过响应时间来快速降级不稳定的资源。当依赖的资源出现响应时间过长后，所有对该资源的访问都会被直接拒绝，直到过了指定的时间窗口之后才重新恢复。

系统负载保护

Sentinel 同时提供系统维度的自适应保护能力。防止雪崩，是系统防护中重要的一环。当系统负载较高的时候，如果还持续让请求进入，可能会导致系统崩溃，无法响应。在集群环境下，网络负载均衡会把本应这台机器承载的流量转发到其它的机器上去。如果这个时候其它的机器也处在一个边缘状态的时候，这个增加的流量就会导致这台机器也崩溃，最后导致整个集群不可用。

针对这个情况，Sentinel 提供了对应的保护机制，让系统的入口流量和系统的负载达到一个平衡，保证系统在能力范围之内处理最多的请求。

6. 如何使用Sentinel

Sentinel 可以简单的分为 Sentinel 核心库和 Dashboard。核心库不依赖 Dashboard，但是结合 Dashboard 可以取得最好的效果。

资源，可以是任何东西，服务，服务里的方法，甚至是一段代码。使用 Sentinel 来进行资源保护，主要分为几个步骤：

1. 定义资源
2. 定义规则
3. 检验规则是否生效?

在编码的时候，只需要考虑这个代码是否需要保护，如果需要保护，就将之定义为一个资源。

定义资源的常用方式

方式一：?抛出异常的方式定义资源

SphU?包含了 try-catch 风格的 API。用这种方式，当资源发生了限流之后会抛出?BlockException。这个时候可以捕捉异常，进行限流之后的逻辑处理。示例代码如下：

1 // 1.5.0 版本开始可以利用 try-with-resources 特性
2 // 资源名可使用任意有业务语义的字符串，比如方法名、接口名或其它可唯一标识的字符串。
3 try (Entry entry = SphU.entry("resourceName")) {
4   // 被保护的业务逻辑
5   // do something here...
6 } catch (BlockException ex) {
7   // 资源访问阻止，被限流或被降级
8   // 在此处进行相应的处理操作
9 }

特别地，若 entry 的时候传入了热点参数，那么 exit 的时候也一定要带上对应的参数（exit(count, args)），否则可能会有统计错误。这个时候不能使用 try-with-resources 的方式。另外通过 Tracer.trace(ex) 来统计异常信息时，由于 try-with-resources 语法中 catch 调用顺序的问题，会导致无法正确统计异常数，因此统计异常信息时也不能在 try-with-resources 的 catch 块中调用 Tracer.trace(ex)。

手动 exit 示例：

 1 Entry entry = null;
 2 // 务必保证 finally 会被执行
 3 try {
 4   // 资源名可使用任意有业务语义的字符串，注意数目不能太多（超过 1K），超出几千请作为参数传入而不要直接作为资源名
 5   // EntryType 代表流量类型（inbound/outbound），其中系统规则只对 IN 类型的埋点生效
 6   entry = SphU.entry("自定义资源名");
 7   // 被保护的业务逻辑
 8   // do something...
 9 } catch (BlockException ex) {
10   // 资源访问阻止，被限流或被降级
11   // 进行相应的处理操作
12 } catch (Exception ex) {
13   // 若需要配置降级规则，需要通过这种方式记录业务异常
14   Tracer.traceEntry(ex, entry);
15 } finally {
16   // 务必保证 exit，务必保证每个 entry 与 exit 配对
17   if (entry != null) {
18     entry.exit();
19   }
20 }

热点参数埋点示例：

 1 Entry entry = null;
 2 try {
 3     // 若需要配置例外项，则传入的参数只支持基本类型。
 4     // EntryType 代表流量类型，其中系统规则只对 IN 类型的埋点生效
 5     // count 大多数情况都填 1，代表统计为一次调用。
 6     entry = SphU.entry(resourceName, EntryType.IN, 1, paramA, paramB);
 7     // Your logic here.
 8 } catch (BlockException ex) {
 9     // Handle request rejection.
10 } finally {
11     // 注意：exit 的时候也一定要带上对应的参数，否则可能会有统计错误。
12     if (entry != null) {
13         entry.exit(1, paramA, paramB);
14     }
15 }

SphU.entry()?的参数描述：

方式二、注解方式定义资源

Sentinel 支持通过?@SentinelResource?注解定义资源并配置?blockHandler?和?fallback?函数来进行限流之后的处理。示例：

 1 // 原本的业务方法.
 2 @SentinelResource(blockHandler = "blockHandlerForGetUser")
 3 public User getUserById(String id) {
 4     throw new RuntimeException("getUserById command failed");
 5 }
 6 
 7 // blockHandler 函数，原方法调用被限流/降级/系统保护的时候调用
 8 public User blockHandlerForGetUser(String id, BlockException ex) {
 9     return new User("admin");
10 }

注意?blockHandler?函数会在原方法被限流/降级/系统保护的时候调用，而?fallback?函数会针对所有类型的异常。另外请注意?blockHandler?和?fallback?函数的形式要求。?

方式三、支持异步调用

Sentinel 支持异步调用链路的统计。在异步调用中，需要通过?SphU.asyncEntry(xxx)?方法定义资源，并通常需要在异步的回调函数中调用?exit?方法。示例：

 1 try {
 2     AsyncEntry entry = SphU.asyncEntry(resourceName);
 3 
 4     // 异步调用.
 5     doAsync(userId, result -> {
 6         try {
 7             // 在此处处理异步调用的结果.
 8         } finally {
 9             // 在回调结束后 exit.
10             entry.exit();
11         }
12     });
13 } catch (BlockException ex) {
14     // Request blocked.
15     // Handle the exception (e.g. retry or fallback).
16 }

7. Sentinel 工作主流程

在 Sentinel 里面，所有的资源都对应一个资源名称（resourceName），每次资源调用都会创建一个?Entry?对象。Entry 可以通过对主流框架的适配自动创建，也可以通过注解的方式或调用?SphU?API 显式创建。Entry 创建的时候，同时也会创建一系列功能插槽（slot chain），这些插槽有不同的职责，例如:

• NodeSelectorSlot?：负责收集资源的路径，并将这些资源的调用路径，以树状结构存储起来，用于根据调用路径来限流降级；?
• ClusterBuilderSlot?：则用于存储资源的统计信息以及调用者信息，例如该资源的 RT, QPS, thread count 等等，这些信息将用作为多维度限流，降级的依据；
• StatisticSlot?：则用于记录、统计不同纬度的 runtime 指标监控信息；
• FlowSlot?：用于根据预设的限流规则以及前面 slot 统计的状态，来进行流量控制；
• AuthoritySlot?：则根据配置的黑白名单和调用来源信息，来做黑白名单控制；
• DegradeSlot?：则通过统计信息以及预设的规则，来做熔断降级；
• SystemSlot?：则通过系统的状态，例如 load1 等，来控制总的入口流量；

总体架构图如下：

这个彩色的图貌似更好看一点儿

Sentinel 将?SlotChainBuilder?作为 SPI 接口进行扩展，使得 Slot Chain 具备了扩展的能力。您可以自行加入自定义的 slot 并编排 slot 间的顺序，从而可以给 Sentinel 添加自定义的功能。

8. Sentinel 流量控制

流量控制（flow control），其原理是监控应用流量的 QPS 或并发线程数等指标，当达到指定的阈值时对流量进行控制，以避免被瞬时的流量高峰冲垮，从而保障应用的高可用性。

FlowSlot?会根据预设的规则，结合前面?NodeSelectorSlot、ClusterNodeBuilderSlot、StatisticSlot?统计出来的实时信息进行流量控制。

限流的直接表现是在执行?Entry nodeA = SphU.entry(resourceName)?的时候抛出?FlowException?异常。FlowException?是?BlockException?的子类，您可以捕捉?BlockException?来自定义被限流之后的处理逻辑。

同一个资源可以创建多条限流规则。FlowSlot?会对该资源的所有限流规则依次遍历，直到有规则触发限流或者所有规则遍历完毕。

一条限流规则主要由下面几个因素组成，我们可以组合这些元素来实现不同的限流效果：

• resource ：资源名，即限流规则的作用对象
• count ：限流阈值
• grade ：限流阈值类型（QPS 或并发线程数）
• limitApp ：流控针对的调用来源，若为 default 则不区分调用来源
• strategy ：调用关系限流策略
• controlBehavior ：流量控制效果（直接拒绝、Warm Up、匀速排队）?

8.1. 基于QPS/并发数的流量控制

流量控制主要有两种统计类型，一种是统计并发线程数，另外一种则是统计 QPS。类型由?FlowRule?的?grade?字段来定义。其中，0 代表根据并发数量来限流，1 代表根据 QPS 来进行流量控制。其中线程数、QPS 值，都是由?StatisticSlot?实时统计获取的。

可以通过下面的命令查看实时统计信息：

curl http://localhost:8719/cnode?id=resourceName

并发线程数流量控制

并发线程数限流用于保护业务线程数不被耗尽。例如，当应用所依赖的下游应用由于某种原因导致服务不稳定、响应延迟增加，对于调用者来说，意味着吞吐量下降和更多的线程数占用，极端情况下甚至导致线程池耗尽。为应对太多线程占用的情况，业内有使用隔离的方案，比如通过不同业务逻辑使用不同线程池来隔离业务自身之间的资源争抢（线程池隔离）。这种隔离方案虽然隔离性比较好，但是代价就是线程数目太多，线程上下文切换的 overhead 比较大，特别是对低延时的调用有比较大的影响。Sentinel 并发线程数限流不负责创建和管理线程池，而是简单统计当前请求上下文的线程数目，如果超出阈值，新的请求会被立即拒绝，效果类似于信号量隔离。

QPS流量控制

当 QPS 超过某个阈值的时候，则采取措施进行流量控制。流量控制的效果包括以下几种：直接拒绝、Warm Up、匀速排队。对应?FlowRule?中的?controlBehavior?字段。

8.2. 基于调用关系的流量控制

调用关系包括调用方、被调用方；一个方法又可能会调用其它方法，形成一个调用链路的层次关系。Sentinel 通过?NodeSelectorSlot?建立不同资源间的调用的关系，并且通过?ClusterNodeBuilderSlot?记录每个资源的实时统计信息。

有了调用链路的统计信息，我们可以衍生出多种流量控制手段。

根据调用方限流

ContextUtil.enter(resourceName, origin)?方法中的?origin?参数标明了调用方身份。这些信息会在?ClusterBuilderSlot?中被统计。可通过以下命令来展示不同的调用方对同一个资源的调用数据：?

根据调用链路入口限流：链路限流?

NodeSelectorSlot?中记录了资源之间的调用链路，这些资源通过调用关系，相互之间构成一棵调用树。这棵树的根节点是一个名字为?machine-root?的虚拟节点，调用链的入口都是这个虚节点的子节点。

一棵典型的调用树如下图所示：

具有关系的资源流量控制：关联流量控制

当两个资源之间具有资源争抢或者依赖关系的时候，这两个资源便具有了关联。比如对数据库同一个字段的读操作和写操作存在争抢，读的速度过高会影响写得速度，写的速度过高会影响读的速度。如果放任读写操作争抢资源，则争抢本身带来的开销会降低整体的吞吐量。可使用关联限流来避免具有关联关系的资源之间过度的争抢，举例来说，read_db?和?write_db?这两个资源分别代表数据库读写，我们可以给?read_db?设置限流规则来达到写优先的目的：设置?FlowRule.strategy?为?RuleConstant.RELATE?同时设置?FlowRule.ref_identity?为?write_db。这样当写库操作过于频繁时，读数据的请求会被限流。

Sentinel：万字详解微服务的哨兵机制，我跪了

标签：调用   架构   检验   down   inf   orm   with   不可用   签名   

原文地址：https://blog.51cto.com/14230003/2470598