随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel 以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。
Sentinel 具有以下特征：
Sentinel 的主要特性：
Sentinel 的开源生态：
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:8080SentinelExampleApplication.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 }Sentinel 控制台最少应该包含如下功能：
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.jarmvn clean package
启动控制台
java -Dserver.port=8080 -Dcsp.sentinel.dashboard.server=localhost:8080 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.7.1.jar默认用户名密码都是sentinel
@SentinelResource 用于定义资源，并提供可选的异常处理和 fallback 配置项
@SentinelResource 注解的属性：
fallback ：fallback 函数名称，可选项，用于在抛出异常的时候提供 fallback 处理逻辑。fallback 函数可以针对所有类型的异常（除了 exceptionsToIgnore 里面排除掉的异常类型）进行处理。fallback 函数签名和位置要求：defaultFallback ：默认的 fallback 函数名称，可选项，通常用于通用的 fallback 逻辑
Throwable 类型的参数用于接收对应的异常；fallbackClass 为对应的类的 Class 对象，注意对应的函数必需为 static 函数，否则无法解析； 需要注意的是，若 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处理逻辑中。
资源
只要通过 Sentinel API 定义的代码，就是资源，能够被 Sentinel 保护起来。大部分情况下，可以使用方法签名，URL，甚至服务名称作为资源名来标示资源。
规则
围绕资源的实时状态设定的规则，可以包括流量控制规则、熔断降级规则以及系统保护规则。所有规则可以动态实时调整。
流量控制
流量控制在网络传输中是一个常用的概念，它用于调整网络包的发送数据。然而，从系统稳定性角度考虑，在处理请求的速度上，也有非常多的讲究。任意时间到来的请求往往是随机不可控的，而系统的处理能力是有限的。我们需要根据系统的处理能力对流量进行控制。Sentinel 作为一个调配器，可以根据需要把随机的请求调整成合适的形状，如下图所示：
流量控制有以下几个角度：
Sentinel 的设计理念是让您自由选择控制的角度，并进行灵活组合，从而达到想要的效果。
熔断降级
Sentinel 和 Hystrix 的原则是一致的: 当检测到调用链路中某个资源出现不稳定的表现，例如请求响应时间长或异常比例升高的时候，则对这个资源的调用进行限制，让请求快速失败，避免影响到其它的资源而导致级联故障。
在限制的手段上，Sentinel 和 Hystrix 采取了完全不一样的方法。
Hystrix 通过线程池隔离的方式，来对依赖（在 Sentinel 的概念中对应 资源）进行了隔离。这样做的好处是资源和资源之间做到了最彻底的隔离。缺点是除了增加了线程切换的成本（过多的线程池导致线程数目过多），还需要预先给各个资源做线程池大小的分配。 如下图：
Sentinel 对这个问题采取了两种手段:
和资源池隔离的方法不同，Sentinel 通过限制资源并发线程的数量，来减少不稳定资源对其它资源的影响。这样不但没有线程切换的损耗，也不需要您预先分配线程池的大小。当某个资源出现不稳定的情况下，例如响应时间变长，对资源的直接影响就是会造成线程数的逐步堆积。当线程数在特定资源上堆积到一定的数量之后，对该资源的新请求就会被拒绝。堆积的线程完成任务后才开始继续接收请求。
除了对并发线程数进行控制以外，Sentinel 还可以通过响应时间来快速降级不稳定的资源。当依赖的资源出现响应时间过长后，所有对该资源的访问都会被直接拒绝，直到过了指定的时间窗口之后才重新恢复。
系统负载保护
Sentinel 同时提供系统维度的自适应保护能力。防止雪崩，是系统防护中重要的一环。当系统负载较高的时候，如果还持续让请求进入，可能会导致系统崩溃，无法响应。在集群环境下，网络负载均衡会把本应这台机器承载的流量转发到其它的机器上去。如果这个时候其它的机器也处在一个边缘状态的时候，这个增加的流量就会导致这台机器也崩溃，最后导致整个集群不可用。
针对这个情况，Sentinel 提供了对应的保护机制，让系统的入口流量和系统的负载达到一个平衡，保证系统在能力范围之内处理最多的请求。
Sentinel 可以简单的分为 Sentinel 核心库和 Dashboard。核心库不依赖 Dashboard，但是结合 Dashboard 可以取得最好的效果。
资源，可以是任何东西，服务，服务里的方法，甚至是一段代码。使用 Sentinel 来进行资源保护，主要分为几个步骤：
在编码的时候，只需要考虑这个代码是否需要保护，如果需要保护，就将之定义为一个资源。
定义资源的常用方式
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 }在 Sentinel 里面，所有的资源都对应一个资源名称（resourceName），每次资源调用都会创建一个 Entry 对象。Entry 可以通过对主流框架的适配自动创建，也可以通过注解的方式或调用 SphU API 显式创建。Entry 创建的时候，同时也会创建一系列功能插槽（slot chain），这些插槽有不同的职责，例如:
总体架构图如下：
这个彩色的图貌似更好看一点儿
Sentinel 将 SlotChainBuilder 作为 SPI 接口进行扩展，使得 Slot Chain 具备了扩展的能力。您可以自行加入自定义的 slot 并编排 slot 间的顺序，从而可以给 Sentinel 添加自定义的功能。
流量控制（flow control），其原理是监控应用流量的 QPS 或并发线程数等指标，当达到指定的阈值时对流量进行控制，以避免被瞬时的流量高峰冲垮，从而保障应用的高可用性。
FlowSlot 会根据预设的规则，结合前面 NodeSelectorSlot、ClusterNodeBuilderSlot、StatisticSlot 统计出来的实时信息进行流量控制。
限流的直接表现是在执行 Entry nodeA = SphU.entry(resourceName) 的时候抛出 FlowException 异常。FlowException 是 BlockException 的子类，您可以捕捉 BlockException 来自定义被限流之后的处理逻辑。
同一个资源可以创建多条限流规则。FlowSlot 会对该资源的所有限流规则依次遍历，直到有规则触发限流或者所有规则遍历完毕。
一条限流规则主要由下面几个因素组成，我们可以组合这些元素来实现不同的限流效果：
流量控制主要有两种统计类型，一种是统计并发线程数，另外一种则是统计 QPS。类型由 FlowRule 的 grade 字段来定义。其中，0 代表根据并发数量来限流，1 代表根据 QPS 来进行流量控制。其中线程数、QPS 值，都是由 StatisticSlot 实时统计获取的。
可以通过下面的命令查看实时统计信息：
curl http://localhost:8719/cnode?id=resourceName并发线程数流量控制
并发线程数限流用于保护业务线程数不被耗尽。例如，当应用所依赖的下游应用由于某种原因导致服务不稳定、响应延迟增加，对于调用者来说，意味着吞吐量下降和更多的线程数占用，极端情况下甚至导致线程池耗尽。为应对太多线程占用的情况，业内有使用隔离的方案，比如通过不同业务逻辑使用不同线程池来隔离业务自身之间的资源争抢（线程池隔离）。这种隔离方案虽然隔离性比较好，但是代价就是线程数目太多，线程上下文切换的 overhead 比较大，特别是对低延时的调用有比较大的影响。Sentinel 并发线程数限流不负责创建和管理线程池，而是简单统计当前请求上下文的线程数目，如果超出阈值，新的请求会被立即拒绝，效果类似于信号量隔离。
QPS流量控制
当 QPS 超过某个阈值的时候，则采取措施进行流量控制。流量控制的效果包括以下几种：直接拒绝、Warm Up、匀速排队。对应 FlowRule 中的 controlBehavior 字段。
调用关系包括调用方、被调用方；一个方法又可能会调用其它方法，形成一个调用链路的层次关系。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。这样当写库操作过于频繁时，读数据的请求会被限流。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
