Sentinel服务流控熔断降级

Sentinel

一.分布式系统遇到的问题

1.服务雪崩

如果其中的订单服务不可用, 就会出现线程池里所有线程都因等待响应而被阻塞, 从而造成整个服务链路不可用，进而导致整个系统的服务雪崩. 如图所示

服务雪崩效应：因服务提供者的不可用导致服务调用者的不可用,并将不可用逐渐放大的过程，就叫服务雪崩效应

导致服务不可用的原因：

在服务提供者不可用的时候，会出现大量重试的情况：用户重试、代码逻辑重试，这些重试最终导致：进一步加大请求流量。所以归根结底导致雪崩效应的最根本原因是：大量请求线程同步等待造成的资源耗尽。当服务调用者使用同步调用时, 会产生大量的等待线程占用系统资源。一旦线程资源被耗尽,服务调用者提供的服务也将处于不可用状态, 于是服务雪崩效应产生了。

	<!--sentinel核心库-->
	<dependency>
	<groupId>com.alibaba.csp</groupId>
	<artifactId>sentinel-core</artifactId>
	<version>1.8.5</version>
	</dependency>

	<dependency>
	<groupId>org.projectlombok</groupId>
	<artifactId>lombok</artifactId>
	<version>1.18.18</version>
	</dependency>

	<!--如果要使用@SentinelResource-->
	<dependency>
	<groupId>com.alibaba.csp</groupId>
	<artifactId>sentinel-annotation-aspectj</artifactId>
	<version>1.8.5</version>
	</dependency>

	<!--整合控制台客户端需要引入 Transport 模块来与 Sentinel 控制台进行通信。-->
	<dependency>
	<groupId>com.alibaba.csp</groupId>
	<artifactId>sentinel-transport-simple-http</artifactId>
	<version>1.8.5</version>
	</dependency>

	@RestController
	@Slf4j
	public class HelloController {

	private static final String RESOURCE_NAME = "hello";
	private static final String USER_RESOURCE_NAME = "user";
	private static final String DEGRADE_RESOURCE_NAME = "degrade";


	// 进行sentinel流控
	@RequestMapping(value = "/hello")
	public String hello() {

	Entry entry = null; //Map.entry 存入用完就要退出
	try {
	// 1.sentinel针对资源进行限制的
	entry = SphU.entry(RESOURCE_NAME);
	// 被保护的业务逻辑
	String str = "hello world";
	log.info("====="+str+"=====");
	return str;
	} catch (BlockException e1) {
	// 资源访问阻止，被限流或被降级
	//进行相应的处理操作
	log.info("block!");
	return "被流控了！";
	} catch (Exception ex) {
	// 若需要配置降级规则，需要通过这种方式记录业务异常
	Tracer.traceEntry(ex, entry);
	} finally {
	if (entry != null) {
	entry.exit();
	}
	}
	return null;
	}

	/**
	* 定义规则
	*注解修饰的init方法就会在Spring容器的启动时自动的执行
	* spring 的初始化方法
	*/
	@PostConstruct //注解修饰的init方法就会在Spring容器的启动时自动的执行
	private static void initFlowRules(){

	// 流控规则
	List<FlowRule> rules = new ArrayList<>();
	// 流控
	FlowRule rule = new FlowRule();
	// 为哪个资源进行流控
	rule.setResource(RESOURCE_NAME);
	// 设置流控规则 QPS
	rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
	// 设置受保护的资源阈值
	// Set limit QPS to 20.
	rule.setCount(1);
	rules.add(rule);

	// 加载配置好的规则
	FlowRuleManager.loadRules(rules);
	}
	}

	//注解修饰的init方法就会在Spring容器的启动时自动的执行
	@PostConstruct

	1.添加依赖<artifactId>sentinel-annotation-aspectj</artifactId>
	2.配置切面支持bean——SentinelResourceAspect(或者直接将Bean添加在启动类中)

	@Configuration
	public class SentinelAspectConfiguration {
	@Bean
	public SentinelResourceAspect sentinelResourceAspect() {
	return new SentinelResourceAspect();
	}
	}

	3.value 定义资源

	(如果使用fallbackClass和blockHandlerClass方法去调用对应类.class,
	然后还要使用blockHandler去指定具体方法，记得方法必须是static)

	4.blockHandler 设置流控降级后的处理方法（默认该方法必须声明在同一个类）
	如果不想在同一个类中 blockHandlerClass 但是方法必须是static

	5.fallback 当接口出现了异常，就可以交给fallback指定的方法进行处理
	如果不想在同一个类中 fallbackClass 但是方法必须是static

	6.fallbac在异常处理类传参中增加一个Throwable 类型的参数，可以通过这个参数来实现捕获不同的异常，从而做对应的异常处理。不然捕捉不到异常。

	7.blockHandle在异常处理类传参中增加一个BlockException 类型的参数，可以通过这个参数来实现捕获不同的异常，从而做对应的异常处理。不然捕捉不到异常。

	!!! blockHandler 如果和fallback同时指定了，则blockHandler优先级更高

	exceptionsToIgnore 排除哪些异常不处理

	@RestController
	@Slf4j
	public class Hello2Controller {

	private static final String USER_RESOURCE_NAME = "user";


	/**
	* @SentinelResource 改善接口中资源定义和被流控降级后的处理方法
	* @param id
	* @return
	*/
	@RequestMapping("/user")
	@SentinelResource(value = USER_RESOURCE_NAME,
	/fallbackClass = FallGetUser.class,/
	fallback = "fallbackHandleForGetUser",
	/exceptionsToIgnore = {ArithmeticException.class},/
	/blockHandlerClass = User.class,/
	blockHandler = "blockHandlerForGetUser")
	public User getUser(String id) {
	System.out.println("--zxy--");
	return new User("zxy");
	}


	public User fallbackHandleForGetUser(String id,Throwable e) {
	e.printStackTrace();
	return new User("异常处理");
	}

	/**
	* 注意：
	* 1. 一定要public
	* 2. 返回值一定要和源方法保证一致，包含源方法的参数。
	* 3. 可以在参数最后添加BlockException 可以区分是什么规则的处理方法
	* @param id
	* @param ex
	* @return
	*/
	public User blockHandlerForGetUser(String id, BlockException ex) {
	ex.printStackTrace();
	return new User("流控！！");
	}

	/**
	* 定义规则
	*
	* spring 的初始化方法
	*/
	@PostConstruct
	private static void initFlowRules(){

	// 流控规则
	List<FlowRule> rules = new ArrayList<>();

	// 通过@SentinelResource来定义资源并配置降级和流控的处理方法
	FlowRule rule2 = new FlowRule();
	//设置受保护的资源
	rule2.setResource(USER_RESOURCE_NAME);
	// 设置流控规则 QPS
	rule2.setGrade(RuleConstant.FLOW_GRADE_QPS);
	// 设置受保护的资源阈值
	// Set limit QPS to 20.
	rule2.setCount(1);

	rules.add(rule2);

	// 加载配置好的规则
	FlowRuleManager.loadRules(rules);
	}
	}

	@RestController
	public class DegradeController {

	private static final String DEGRADE_RESOURCE_NAME = "degrade";

	@SentinelResource(value = DEGRADE_RESOURCE_NAME,
	blockHandler = "blockHandlerForFb",
	entryType = EntryType.IN
	)
	@RequestMapping("/degrade")
	public User degrade(String id) throws InterruptedException {
	// 异常数\比例
	throw new RuntimeException("异常");
	/* 慢调用比例
	TimeUnit.SECONDS.sleep(1);
	return new User("正常");*/
	}

	public User blockHandlerForFb(String id, BlockException e){
	return new User("熔断降级");
	}
	@PostConstruct
	public void initDegradeRule(){

	List<DegradeRule> degradeRules = new ArrayList<>();

	DegradeRule degradeRule = new DegradeRule();

	degradeRule.setResource(DEGRADE_RESOURCE_NAME);
	// 设置规则侧率：异常数
	degradeRule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT);
	// 触发熔断异常数： 2
	degradeRule.setCount(2);
	// 触发熔断最小请求数:2
	degradeRule.setMinRequestAmount(2);
	// 统计时长：单位：ms 1分钟
	degradeRule.setStatIntervalMs(60*1000); // 时间太短不好测
	// 一分钟内：执行了2次出现了2次异常就会触发熔断

	// 熔断持续时长：单位秒
	// 一旦触发了熔断，再次请求对应的接口就会直接调用降级方法。
	// 10秒过了后——半开状态：恢复接口请求调用，
	// 如果第一次请求就异常，再次熔断，不会根据设置的条件进行判定
	degradeRule.setTimeWindow(10);

	degradeRules.add(degradeRule);
	DegradeRuleManager.loadRules(degradeRules);

	}
	}

	java -Dserver.port=8858 -Dsentinel.dashboard.auth.username=zxy -Dsentinel.dashboard.auth.password=123456 -jar C:\Users\zxy\Desktop\Sentinel\sentinel-dashboard-1.8.5.jar
	pause

	1.alibaba整合后不需要注册切面支持bean——SentinelResourceAspect
	2.依靠可视化界面对接口资源的调用和默认异常抛出
	3.@SentinelResource功能更多被用来调用异常抛出

	<!--alibaba Sentinel启动器有着一个就不需要原生中的多个依赖了-->
	<dependency>
	<groupId>com.alibaba.cloud</groupId>
	<artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
	</dependency>

	server:
	port: 8070
	spring:
	application:
	name: order-sentinel
	cloud:
	sentinel:
	transport:
	#添加sentinel的控制台地址
	dashboard: 127.0.0.1:8858

	如果使用了@SentinelResource就选择对应value的接口

	没有使用选择对应http接口

	@Component
	public class MyBlockExceptionHandler implements BlockExceptionHandler {

	Logger log= LoggerFactory.getLogger(this.getClass());

	@Override
	public void handle(HttpServletRequest httpServletRequest, HttpServletResponse response, BlockException e) throws Exception {
	// getRule() 资源规则的详细信息
	log.info("BlockExceptionHandler BlockException================"+e.getRule());

	Result r = null;

	if (e instanceof FlowException) {
	r = Result.error(100,"接口限流了");

	} else if (e instanceof DegradeException) {
	r = Result.error(101,"服务降级了");

	} else if (e instanceof ParamFlowException) {
	r = Result.error(102,"热点参数限流了");

	} else if (e instanceof SystemBlockException) {
	r = Result.error(103,"触发系统保护规则了");

	} else if (e instanceof AuthorityException) {
	r = Result.error(104,"授权规则不通过");
	}

	//返回json数据
	response.setStatus(500);
	response.setCharacterEncoding("utf-8");
	response.setContentType(MediaType.APPLICATION_JSON_VALUE);
	new ObjectMapper().writeValue(response.getWriter(), r);
	}
	}

	public class Result<T> {
	private Integer code;
	private String msg;
	private T data;

	public Result(Integer code, String msg, T data) {
	this.code = code;
	this.msg = msg;
	this.data = data;
	}

	public Result(Integer code, String msg) {
	this.code = code;
	this.msg = msg;
	}

	public Integer getCode() {
	return code;
	}

	public void setCode(Integer code) {
	this.code = code;
	}

	public String getMsg() {
	return msg;
	}

	public void setMsg(String msg) {
	this.msg = msg;
	}

	public T getData() {
	return data;
	}

	public void setData(T data) {
	this.data = data;
	}

	1 getUser
	2 / \
	3 / \
	4 /order/test1 /order/test2

	从1.6.3 版本开始，Sentinel Web filter默认收敛所有URL的入口context，因此链路限流不生效。

	1.7.0 版本开始（对应SCA的2.1.1.RELEASE)，官方在CommonFilter 引入了

	WEB_CONTEXT_UNIFY 参数，用于控制是否收敛context。将其配置为 false 即可根据不同的URL 进行链路限流。

	SCA 2.1.1.RELEASE之后的版本,可以通过配置spring.cloud.sentinel.web-context-unify=false即可关闭收敛

	@Resource
	IOrderService orderService;

	// 链路流控访问/test1
	@RequestMapping("/test1")
	public String test1(){
	return orderService.getUser();
	}
	// 链路流控访问/test2
	@RequestMapping("/test2")
	public String test2(){
	return orderService.getUser();
	}

	@Service
	public class OrderServiceImpl implements IOrderService {

	@Override
	@SentinelResource(value="getUser",blockHandler = "blockHandlerGetUser")
	public String getUser() {
	return "查询用户";
	}

	public String blockHandlerGetUser(BlockException e) {
	return "流控用户";
	}
	}

	@RequestMapping("/flowThread")
	public String flowThread() throws InterruptedException {
	Thread.sleep(100);
	System.out.println("正常访问！");
	return "正常访问";
	}

	@RequestMapping("/err")
	public String err(){
	int a =1/0;
	return "hello";
	}

	/**
	* 热点规则，必须使用@SentinelResource
	* @param id
	* @return
	* @throws InterruptedException
	*/
	@RequestMapping("/get/{id}")
	@SentinelResource(value = "getById",blockHandler = "HotBlockHandler")
	public String getById(@PathVariable("id") Integer id) throws InterruptedException {

	System.out.println("正常访问");
	return "正常访问";
	}

	public String HotBlockHandler(@PathVariable("id") Integer id, BlockException e) throws InterruptedException {

	return "热点异常处理";
	}

	<!--Nacos服务注册发现-->
	<dependency>
	<groupId>com.alibaba.cloud</groupId>
	<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
	</dependency>

	<!-- openfeign 远程调用 -->
	<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-openfeign</artifactId>
	</dependency>

	<dependency>
	<groupId>com.alibaba.cloud</groupId>
	<artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
	</dependency>

	server:
	port: 8041
	spring:
	application:
	name: order-openfeign-sentinel
	cloud:
	nacos:
	server-addr: localhost:8848
	discovery:
	username: nacos
	password: nacos
	namespace: public
	sentinel:
	transport:
	dashboard: 127.0.0.1:8858
	feign:
	#开启OpenFeign对sentinel的支持（整合）
	sentinel:
	enabled: true

	@FeignClient(value = "stock-service",path = "/stock",
	fallback = StockFeignServiceFallback.class)
	public interface StockFeignService {

	@RequestMapping("/reduct2")
	public String reduct2();

	}

	@Component
	public class StockFeignServiceFallback implements StockFeignService{
	@Override
	public String reduct2() {
	return "降级！！";
	}
	}

kidzxy

Sentinel服务流控熔断降级

Sentinel

一.分布式系统遇到的问题

1.服务雪崩

2.解决方法

1.超时机制

2.服务限流（流控）

3.隔离（和服务限流类似）

4.服务熔断（重点！！！）

二.快速开始

1.添加依赖

2.编写测试代码（限流）

3.@SentinelResource注解开发（限流）

3.1注意事项和提前准备

3.2测试@SentinelResource测试代码

4.@SentinelResource测试（服务熔断降级策略）

三.Sentinel dashboard 界面

1.依赖

2.启动

四.SpringCloudAlibaba整合Sentinel（重点）

1.导入依赖

2.yml配置

3.QPS和并发线程数----流控规则

4.公共异常处理

五.流控策略，熔断策略（基于Alibaba和dashboard窗口）

1.直接,关联,链路流控模式

1.直接

2.关联

3.链路

1.配置和理解

2.代码测试

2.快速失败,Warm Up（激增流量)，排队流控效果

1.快速失败

2.Warm Up（针对激增流量)

3.排队等待（针对脉冲流量）

3.慢调用比例，异常比例，异常数熔断规则

1.慢调用比例

2.异常比例

3.异常数

六.热点参数限流，系统保护规则

1.热点参数限流

2.系统保护规则

七.OpenFeign和Sentinel整合

1.依赖

2.application.yml

3.openfegin接口

4.openfegin的fallback实现类

八.Sentinel规则持久化

1.导入依赖

2.yml

3.Nacos添加配置文件

4.流控和熔断配置详情

Sentinel依赖和yml配置总合

公告

搜索

常用链接

随笔档案

阅读排行榜

评论排行榜

最新评论

	<!‐‐sentinel持久化采用 Nacos 作为规则配置数据源‐‐>
	<dependency>
	<groupId>com.alibaba.csp</groupId>
	<artifactId>sentinel-datasource-nacos</artifactId>
	</dependency>

	[
	{
	"resource": "/order/flow",
	"controlBehavior": 0,
	"count": 2,
	"grade": 1,
	"limitApp": "default",
	"strategy": 0
	}
	]

	流控配置：json文件配置的各参数对应的意思：
	resource：资源名，即限流规则的作用对象
	count: 限流阈值
	grade: 限流阈值类型(1:QPS;0:并发线程数
	limitApp: 流控针对的调用来源，若为 default 则不区分调用来源
	strategy: 流控模式(0:直接；1:关联;2:链路)
	controlBehavior: 流控效果(0:快速失败;1:Warm Up(预热模式);2:排队等待)
	// 预热时间（秒，预热模式需要此参数）
	//"warmUpPeriodSec": 10,
	// 超时时间（排队等待模式需要此参数）
	//"maxQueueingTimeMs": 500,
	// 关联资源、入口资源(关联、链路模式)
	//"refResource": "rrr"


	降级规则：
	// 资源名
	"resource": "/test1",
	"limitApp": "default",
	// 熔断策略（0:慢调用比例，1:异常比率，2:异常计数）
	"grade": 0,
	// 最大RT、异常比例阈值、异常数
	"count": 200,
	// 慢调用比例阈值，仅慢调用比例模式有效（1.8.0 引入）
	"slowRatioThreshold": 0.2,
	// 最小请求数
	"minRequestAmount": 5,
	// 当单位统计时长(类中默认1000)
	"statIntervalMs": 1000,
	// 熔断时长
	"timeWindow": 10