Sentinel限流学习入门教程-原创手记-慕课网

概述

本文详细介绍了Sentinel限流学习的相关内容，包括Sentinel的简介、作用和应用场景，以及与其他限流工具的对比。文章还深入讲解了Sentinel的核心概念、基本使用方法、实战技巧，以及与Spring Cloud集成的应用扩展。通过本文的学习，读者可以更好地理解和掌握Sentinel的使用，提高系统的稳定性和可用性。

Sentinel限流学习入门教程

Sentinel简介

Sentinel是什么

Sentinel 是一款开源的、轻量级的、分布式服务保护框架，旨在提供全面的流量控制、熔断降级、系统保护等功能。它可以帮助开发者保护服务免受流量过载、系统负载过高以及依赖服务不可用等问题的影响，从而保障系统的稳定性和可用性。

Sentinel的作用和应用场景

作用

流量控制：根据业务需要来控制流量，如限制QPS（每秒查询率）、并发数等，防止流量突增导致系统过载。
熔断降级：当依赖的服务出现问题时，如请求响应时间过长或请求失败率过高，可以及时切断请求，减少不必要的资源消耗。
系统保护：可以监控系统的CPU、内存等资源使用情况，当资源使用率过高时，自动减少流量，从而保护系统稳定运行。
授权规则：可以控制哪些用户或者请求可以访问服务，实现细粒度的访问控制。
API分组规则：可以将API划分成不同的组，方便管理和维护。

应用场景

Web应用：对于一些高并发访问的Web应用，可以通过Sentinel进行流量控制，避免瞬间大量的请求导致服务器崩溃。
微服务架构：在微服务架构中，可以通过Sentinel进行服务间的依赖保护，防止某个服务的故障影响到整个系统。
大数据处理：在实时处理大数据的场景中，可以通过Sentinel控制数据处理的流量，避免数据处理任务过载。
API网关：在API网关层部署Sentinel，可以有效控制访问API的流量，保护后端服务。

Sentinel与其他限流工具的对比

工具	主要功能	特点	适用场景
Sentinel	流量控制、熔断降级、系统保护、授权规则、API分组规则	开源、轻量级、易于集成、支持多种编程语言和框架	Web应用、微服务架构、大数据处理、API网关
Hystrix	熔断降级、服务降级、线程隔离、信号量隔离	Java语言专用、功能强大、社区活跃	微服务架构、Spring Cloud、Netflix体系的微服务
Resilience4j	熔断降级、服务降级、线程隔离、信号量隔离	轻量级、易于集成、支持多种编程语言	微服务架构、Kotlin/Java项目、独立使用
Zuul	路由、过滤、熔断降级	Spring Cloud生态中的API网关，功能全面	API网关、微服务架构中的网关
Nginx	路由、负载均衡、反向代理、限流	通用性强、社区成熟、可以做多种网络服务	作为反向代理和负载均衡，也可以用于限流
Zuul2	路由、过滤、熔断降级、限流	Spring Cloud生态中的API网关，支持异步处理	API网关、微服务架构中的网关
Dubbo Filter	服务治理、服务降级、服务路由、限流	Java语言专用、社区活跃、功能丰富	Dubbo RPC服务治理
Zuul Microgrid	路由、熔断降级、限流	Spring Cloud生态中的API网关，支持异步处理	API网关、微服务架构中的网关
Zuul Resilience4j	路由、熔断降级、限流	Spring Cloud生态中的API网关，支持异步处理	API网关、微服务架构中的网关

Sentinel的核心概念

流量规则

流量规则用于控制进入系统的流量，在系统负载过高时，可以通过限制QPS（每秒查询率）、并发数等方式来保护系统。

流量规则的配置方式

流量规则可以通过静态配置文件或者动态配置中心来配置。

示例代码：通过静态配置文件配置流量规则

import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

public class MyFlowRuleInitFunc implements InitFunc {
    @Override
    public void init() throws Exception {
        FlowRule rule = new FlowRule();
        rule.setResource("HelloWorld");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setLimitApp("default");
        FlowRuleManager.loadRules(Collections.singletonList(rule));
    }
}

上述代码创建了一个流量规则，对资源HelloWorld进行限流，限制每秒最多处理10个请求。

示例代码：通过动态配置中心配置流量规则

import com.alibaba.csp.sentinel.datasource.Converter;
import com.alibaba.csp.sentinel.datasource.nacos.NacosDataSource;
import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

import java.util.List;

public class NacosFlowRuleConfigurator implements InitFunc, Converter<List<FlowRule>, String> {
    @Override
    public void init() throws Exception {
        String serverAddr = "127.0.0.1:8848";
        String dataId = "sentinel_flow_rules";
        String group = "DEFAULT_GROUP";
        NacosDataSource<List<FlowRule>> nacosDataSource = new NacosDataSource<>(serverAddr, group, dataId, this);
        nacosDataSource.addListener((config) -> {
            FlowRuleManager.loadRules(config);
        });
    }

    @Override
    public List<FlowRule> convert(String s) {
        // 解析字符串为规则列表
        // 这里简单返回一个默认规则列表
        return Collections.singletonList(new FlowRule());
    }
}

上述代码展示了如何通过Nacos动态配置流量规则，当Nacos中的配置发生变化时，Sentinel会自动更新规则。

系统保护规则

系统保护规则用于监控系统的资源使用情况，如CPU、内存使用率等。当这些资源的使用率超过阈值时，Sentinel会自动减少流入系统的流量，从而保护系统稳定运行。

系统保护规则的配置方式

系统保护规则可以通过静态配置文件或者动态配置中心来配置。

示例代码：通过静态配置文件配置系统保护规则

import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.system.SystemRule;
import com.alibaba.csp.sentinel.slots.system.SystemRuleManager;

public class MySystemRuleInitFunc implements InitFunc {
    @Override
    public void init() throws Exception {
        SystemRule rule = new SystemRule();
        rule.setGrade(RuleConstant.SYSTEM_PROTECT_GRADE_CPU);
        rule.setCount(100);
        rule.setLimitApp("default");
        SystemRuleManager.loadRules(Collections.singletonList(rule));
    }
}

上述代码创建了一个系统保护规则，当CPU使用率超过100%时，会触发保护机制，限制流入系统的流量。

示例代码：通过动态配置中心配置系统保护规则

import com.alibaba.csp.sentinel.datasource.Converter;
import com.alibaba.csp.sentinel.datasource.nacos.NacosDataSource;
import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.system.SystemRule;
import com.alibaba.csp.sentinel.slots.system.SystemRuleManager;

import java.util.List;

public class NacosSystemRuleConfigurator implements InitFunc, Converter<List<SystemRule>, String> {
    @Override
    public void init() throws Exception {
        String serverAddr = "127.0.0.1:8848";
        String dataId = "sentinel_system_rules";
        String group = "DEFAULT_GROUP";
        NacosDataSource<List<SystemRule>> nacosDataSource = new NacosDataSource<>(serverAddr, group, dataId, this);
        nacosDataSource.addListener((config) -> {
            SystemRuleManager.loadRules(config);
        });
    }

    @Override
    public List<SystemRule> convert(String s) {
        // 解析字符串为规则列表
        // 这里简单返回一个默认规则列表
        return Collections.singletonList(new SystemRule());
    }
}

上述代码展示了如何通过Nacos动态配置系统保护规则，当Nacos中的配置发生变化时，Sentinel会自动更新规则。

授权规则

授权规则用于控制哪些用户或者请求可以访问服务，实现细粒度的访问控制。授权规则可以通过静态配置文件或者动态配置中心来配置。

授权规则的配置方式

授权规则可以通过静态配置文件或者动态配置中心来配置。

示例代码：通过静态配置文件配置授权规则

import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.authorize.AuthorizeRule;
import com.alibaba.csp.sentinel.slots.authorize.AuthorizeRuleManager;

public class MyAuthorizeRuleInitFunc implements InitFunc {
    @Override
    public void init() throws Exception {
        AuthorizeRule rule = new AuthorizeRule();
        rule.setResource("HelloWorld");
        rule.setStrategy(RuleConstant.AUTH_STRATEGY_WHITE_LIST);
        rule.setUserId("user1");
        AuthorizeRuleManager.loadRules(Collections.singletonList(rule));
    }
}

上述代码创建了一个授权规则，允许用户user1访问资源HelloWorld。

示例代码：通过动态配置中心配置授权规则

import com.alibaba.csp.sentinel.datasource.Converter;
import com.alibaba.csp.sentinel.datasource.nacos.NacosDataSource;
import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.authorize.AuthorizeRule;
import com.alibaba.csp.sentinel.slots.authorize.AuthorizeRuleManager;

import java.util.List;

public class NacosAuthorizeRuleConfigurator implements InitFunc, Converter<List<AuthorizeRule>, String> {
    @Override
    public void init() throws Exception {
        String serverAddr = "127.0.0.1:8848";
        String dataId = "sentinel_authorize_rules";
        String group = "DEFAULT_GROUP";
        NacosDataSource<List<AuthorizeRule>> nacosDataSource = new NacosDataSource<>(serverAddr, group, dataId, this);
        nacosDataSource.addListener((config) -> {
            AuthorizeRuleManager.loadRules(config);
        });
    }

    @Override
    public List<AuthorizeRule> convert(String s) {
        // 解析字符串为规则列表
        // 这里简单返回一个默认规则列表
        return Collections.singletonList(new AuthorizeRule());
    }
}

上述代码展示了如何通过Nacos动态配置授权规则，当Nacos中的配置发生变化时，Sentinel会自动更新规则。

API分组规则

API分组规则用于将API划分成不同的组，方便管理和维护。API分组规则可以通过静态配置文件或者动态配置中心来配置。

API分组规则的配置方式

API分组规则可以通过静态配置文件或者动态配置中心来配置。

示例代码：通过静态配置文件配置API分组规则

import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.csp.sentinel.slots.block.authorize.AuthorizeRule;
import com.alibaba.csp.sentinel.slots.block.authorize.AuthorizeRuleManager;

public class MyApiGroupRuleInitFunc implements InitFunc {
    @Override
    public void init() throws Exception {
        FlowRule flowRule = new FlowRule();
        flowRule.setResource("HelloWorld");
        flowRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        flowRule.setCount(10);
        flowRule.setLimitApp("default");
        FlowRuleManager.loadRules(Collections.singletonList(flowRule));

        AuthorizeRule authorizeRule = new AuthorizeRule();
        authorizeRule.setResource("HelloWorld");
        authorizeRule.setStrategy(RuleConstant.AUTH_STRATEGY_WHITE_LIST);
        authorizeRule.setUserId("user1");
        AuthorizeRuleManager.loadRules(Collections.singletonList(authorizeRule));
    }
}

上述代码创建了一个API分组规则，将资源HelloWorld的流量规则和授权规则配置在一起，方便管理和维护。

示例代码：通过动态配置中心配置API分组规则

import com.alibaba.csp.sentinel.datasource.Converter;
import com.alibaba.csp.sentinel.datasource.nacos.NacosDataSource;
import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.csp.sentinel.slots.block.authorize.AuthorizeRule;
import com.alibaba.csp.sentinel.slots.block.authorize.AuthorizeRuleManager;

import java.util.List;

public class NacosApiGroupRuleConfigurator implements InitFunc, Converter<List<Object>, String> {
    @Override
    public void init() throws Exception {
        String serverAddr = "127.0.0.1:8848";
        String dataId = "sentinel_api_group_rules";
        String group = "DEFAULT_GROUP";
        NacosDataSource<List<Object>> nacosDataSource = new NacosDataSource<>(serverAddr, group, dataId, this);
        nacosDataSource.addListener((config) -> {
            if (config instanceof List) {
                ((List<Object>) config).forEach(rule -> {
                    if (rule instanceof FlowRule) {
                        FlowRuleManager.loadRules(Collections.singletonList((FlowRule) rule));
                    } else if (rule instanceof AuthorizeRule) {
                        AuthorizeRuleManager.loadRules(Collections.singletonList((AuthorizeRule) rule));
                    }
                });
            }
        });
    }

    @Override
    public List<Object> convert(String s) {
        // 解析字符串为规则列表
        // 这里简单返回一个默认规则列表
        return Collections.singletonList(new Object());
    }
}

上述代码展示了如何通过Nacos动态配置API分组规则，当Nacos中的配置发生变化时，Sentinel会自动更新规则。

Sentinel的基本使用

快速开始：搭建Sentinel环境

为了开始使用Sentinel，需要先搭建Sentinel的运行环境。通常情况下，Sentinel可以通过Maven或Gradle等构建工具引入到项目中。

搭建环境的步骤

引入依赖：在项目中引入Sentinel的依赖。
初始化配置：通过配置文件或代码初始化Sentinel的规则。

示例代码：Maven构建文件中引入Sentinel依赖

<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-core</artifactId>
    <version>1.8.4</version>
</dependency>
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-datasource-nacos</artifactId>
    <version>1.8.4</version>
</dependency>

上述代码展示了如何在pom.xml文件中引入Sentinel的核心库以及Nacos数据源库。

初始化配置：通过配置文件或代码初始化Sentinel的规则。

示例代码：通过代码初始化Sentinel的规则

import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

public class MyInitFunc implements InitFunc {
    @Override
    public void init() throws Exception {
        FlowRule rule = new FlowRule();
        rule.setResource("HelloWorld");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setLimitApp("default");
        FlowRuleManager.loadRules(Collections.singletonList(rule));
    }
}

上述代码展示了如何通过代码初始化Sentinel的规则，创建了一个流量规则，对资源HelloWorld进行限流，限制每秒最多处理10个请求。

添加规则：手动添加和动态配置

Sentinel支持手动添加规则和动态配置规则。

手动添加规则

手动添加规则可以通过代码或者配置文件的方式进行。

示例代码：通过代码手动添加流量规则

import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

public class MyInitFunc implements InitFunc {
    @Override
    public void init() throws Exception {
        FlowRule rule = new FlowRule();
        rule.setResource("HelloWorld");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setLimitApp("default");
        FlowRuleManager.loadRules(Collections.singletonList(rule));
    }
}

上述代码展示了如何通过代码手动添加流量规则。

示例代码：通过配置文件手动添加流量规则

# 静态配置文件示例
sentinel.flow.rule=HelloWorld,10,1,DEFAULT

上述代码展示了如何在静态配置文件中手动添加流量规则。

动态配置规则

动态配置规则可以通过Nacos、Zookeeper等配置中心进行实时的规则更新。

示例代码：使用Nacos动态配置流量规则

import com.alibaba.csp.sentinel.datasource.Converter;
import com.alibaba.csp.sentinel.datasource.nacos.NacosDataSource;
import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

import java.util.List;

public class NacosFlowRuleConfigurator implements InitFunc, Converter<List<FlowRule>, String> {
    @Override
    public void init() throws Exception {
        String serverAddr = "127.0.0.1:8848";
        String dataId = "sentinel_flow_rules";
        String group = "DEFAULT_GROUP";
        NacosDataSource<List<FlowRule>> nacosDataSource = new NacosDataSource<>(serverAddr, group, dataId, this);
        nacosDataSource.addListener((config) -> {
            FlowRuleManager.loadRules(config);
        });
    }

    @Override
    public List<FlowRule> convert(String s) {
        // 解析字符串为规则列表
        // 这里简单返回一个默认规则列表
        return Collections.singletonList(new FlowRule());
    }
}

上述代码展示了如何通过Nacos动态配置流量规则，当Nacos中的配置发生变化时，Sentinel会自动更新规则。

示例代码：使用Zookeeper动态配置流量规则

import com.alibaba.csp.sentinel.datasource.Converter;
import com.alibaba.csp.sentinel.datasource.zookeeper.ZookeeperDataSource;
import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

import java.util.List;

public class ZookeeperFlowRuleConfigurator implements InitFunc, Converter<List<FlowRule>, String> {
    @Override
    public void init() throws Exception {
        String serverAddr = "127.0.0.1:2181";
        String path = "/sentinel_flow_rules";
        ZookeeperDataSource<List<FlowRule>> dataSource = new ZookeeperDataSource<>(serverAddr, path, this);
        dataSource.addListener((config) -> {
            FlowRuleManager.loadRules(config);
        });
    }

    @Override
    public List<FlowRule> convert(String s) {
        // 解析字符串为规则列表
        // 这里简单返回一个默认规则列表
        return Collections.singletonList(new FlowRule());
    }
}

上述代码展示了如何通过Zookeeper动态配置流量规则，当Zookeeper中的配置发生变化时，Sentinel会自动更新规则。

观察效果：监控与报警机制

Sentinel内置了监控和报警机制，可以实时监控系统的运行状态，并在系统出现问题时及时报警。

监控与报警机制的配置方式

监控和报警机制可以通过Sentinel的Dashboard界面进行配置。

示例代码：通过Dashboard界面配置监控与报警机制

// 无需代码示例，仅通过Dashboard界面配置

上述代码展示了如何通过Dashboard界面配置监控与报警机制，例如设置报警阈值和报警方式。

示例代码：通过代码配置监控与报警机制

import com.alibaba.csp.sentinel.dashboard.init.InitFunc;
import com.alibaba.csp.sentinel.dashboard.metric.MetricData;
import com.alibaba.csp.sentinel.dashboard.metric.MetricDataPublisher;

public class MyDashboardInitFunc implements InitFunc {
    @Override
    public void init() throws Exception {
        MetricDataPublisher publisher = new MetricDataPublisher();
        publisher.setMetricData(new MetricData(1L, 1L, 1L, 1L, 1L, 1L, 1L));
        publisher.publish();
    }
}

上述代码展示了如何通过代码配置监控与报警机制，例如设置监控数据的采集频率和报警方式。

Sentinel限流实战

实战案例：常见限流场景模拟

在实际场景中，例如Web应用、微服务架构中的API网关等，可以使用Sentinel进行限流。

示例代码：Web应用中的流量控制

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloWorldController {
    @GetMapping("/hello")
    @SentinelResource(value = "HelloWorld", blockHandler = "handleException")
    public String helloWorld() {
        return "Hello World!";
    }

    public String handleException(BlockException ex) {
        return "Blocked by Sentinel";
    }
}

上述代码展示了如何在Web应用中使用Sentinel进行流量控制，对资源HelloWorld进行限流，当请求超过阈值时，会返回一个默认的“Blocked by Sentinel”消息。

示例代码：微服务架构中的流量控制

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ServiceController {
    @GetMapping("/service")
    @SentinelResource(value = "ServiceResource", blockHandler = "handleException")
    public String serviceResource() {
        return "Service Resource";
    }

    public String handleException(BlockException ex) {
        return "Blocked by Sentinel";
    }
}

上述代码展示了如何在微服务架构中使用Sentinel进行流量控制，对资源ServiceResource进行限流，当请求超过阈值时，会返回一个默认的“Blocked by Sentinel”消息。

实战技巧：动态调整策略与限流阈值

在实战中，可以通过动态调整策略和限流阈值来适应不同的业务需求。

示例代码：动态调整流量规则

import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;

public class DynamicFlowRuleAdjustment {
    public static void main(String[] args) {
        FlowRule rule = new FlowRule();
        rule.setResource("HelloWorld");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setLimitApp("default");
        FlowRuleManager.loadRules(Collections.singletonList(rule));

        // 动态调整阈值
        rule.setCount(20); // 将阈值调整为20
        FlowRuleManager.loadRules(Collections.singletonList(rule));
    }
}

上述代码展示了如何动态调整流量规则，当业务需求发生变化时，可以实时调整阈值。

示例代码：动态调整系统保护规则

import com.alibaba.csp.sentinel.slots.system.SystemRuleManager;
import com.alibaba.csp.sentinel.slots.system.SystemRule;

public class DynamicSystemRuleAdjustment {
    public static void main(String[] args) {
        SystemRule rule = new SystemRule();
        rule.setGrade(RuleConstant.SYSTEM_PROTECT_GRADE_CPU);
        rule.setCount(100);
        rule.setLimitApp("default");
        SystemRuleManager.loadRules(Collections.singletonList(rule));

        // 动态调整阈值
        rule.setCount(200); // 将阈值调整为200
        SystemRuleManager.loadRules(Collections.singletonList(rule));
    }
}

上述代码展示了如何动态调整系统保护规则，当业务需求发生变化时，可以实时调整系统保护规则的阈值。

Sentinel的应用扩展

Sentinel与Spring Cloud集成

Sentinel与Spring Cloud的集成可以方便地在微服务架构中部署和使用。

示例代码：Spring Cloud中集成Sentinel

import com.alibaba.csp.sentinel.adapter.spring.webmvc.SentinelSpringCloudWebAutoConfiguration;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Import;

@SpringBootApplication
@Import(SentinelSpringCloudWebAutoConfiguration.class)
public class SentinelSpringCloudApplication {
    public static void main(String[] args) {
        SpringApplication.run(SentinelSpringCloudApplication.class, args);
    }
}

上述代码展示了如何在Spring Cloud中集成Sentinel，通过@Import注解引入Sentinel的Web自动配置。

示例代码：Spring Cloud中配置Sentinel

# application.yml
spring:
  cloud:
    sentinel:
      transport:
        port: 8719
        dashboard: localhost:8080
      web:
        slow:
          threshold: 1000
          slowRatioThreshold: 0.1

上述代码展示了如何在Spring Cloud中配置Sentinel，设置Sentinel与Dashboard的连接信息和Web应用的慢调用阈值。

Sentinel与微服务架构的结合

在微服务架构中，Sentinel可以有效地进行服务间的依赖保护，防止某个服务的故障影响到整个系统。

示例代码：微服务架构中的依赖保护

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DependencyController {
    @GetMapping("/dependency")
    @SentinelResource(value = "DependencyService", fallback = "fallbackMethod")
    public String dependencyService() {
        // 调用依赖服务
        return "Dependency Service";
    }

    public String fallbackMethod(BlockException ex) {
        return "Dependency Service Fallback";
    }
}

上述代码展示了如何在微服务架构中使用Sentinel进行依赖保护，当依赖服务出现问题时，会返回一个默认的“Dependency Service Fallback”消息。

Sentinel常见问题及解决

常见问题汇总

规则配置不生效：检查规则是否正确加载，配置是否正确。
规则无法动态更新：检查配置中心是否正确配置，网络连接是否正常。
监控数据不准确：检查监控数据的采集方式和采集频率是否正确。
系统保护规则不生效：检查系统资源监控配置是否正确，监控数据是否正确采集。

常见问题解决思路

规则配置不生效：可以通过Sentinel的Dashboard界面查看规则是否加载成功，或者通过日志查看是否有错误信息。

import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

public class DebugInitFunc implements InitFunc {
    @Override
    public void init() throws Exception {
        FlowRule rule = new FlowRule();
        rule.setResource("HelloWorld");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setLimitApp("default");
        FlowRuleManager.loadRules(Collections.singletonList(rule));
        System.out.println("Flow rule initialized: " + rule);
    }
}

上述代码展示了如何通过代码初始化规则时打印日志，以便调试规则是否加载成功。

规则无法动态更新：可以通过配置中心的控制台查看规则是否已经更新成功，或者检查网络连接是否正常。

import com.alibaba.csp.sentinel.datasource.Converter;
import com.alibaba.csp.sentinel.datasource.nacos.NacosDataSource;
import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

import java.util.List;

public class DebugNacosFlowRuleConfigurator implements InitFunc, Converter<List<FlowRule>, String> {
    @Override
    public void init() throws Exception {
        String serverAddr = "127.0.0.1:8848";
        String dataId = "sentinel_flow_rules";
        String group = "DEFAULT_GROUP";
        NacosDataSource<List<FlowRule>> nacosDataSource = new NacosDataSource<>(serverAddr, group, dataId, this);
        nacosDataSource.addListener((config) -> {
            System.out.println("Received new flow rule: " + config);
            FlowRuleManager.loadRules(config);
        });
    }

    @Override
    public List<FlowRule> convert(String s) {
        // 解析字符串为规则列表
        // 这里简单返回一个默认规则列表
        return Collections.singletonList(new FlowRule());
    }
}

上述代码展示了如何通过Nacos动态配置规则时打印日志，以便调试规则是否更新成功。

监控数据不准确：可以通过Sentinel的Dashboard界面查看监控数据的采集方式和采集频率是否正确，或者检查监控插件是否正确配置。

import com.alibaba.csp.sentinel.dashboard.init.InitFunc;
import com.alibaba.csp.sentinel.dashboard.metric.MetricData;
import com.alibaba.csp.sentinel.dashboard.metric.MetricDataPublisher;

public class DebugMetricInitFunc implements InitFunc {
    @Override
    public void init() throws Exception {
        MetricDataPublisher publisher = new MetricDataPublisher();
        publisher.setMetricData(new MetricData(1L, 1L, 1L, 1L, 1L, 1L, 1L));
        publisher.publish();
        System.out.println("Metric data published to Dashboard.");
    }
}

上述代码展示了如何通过代码发布监控数据时打印日志，以便调试监控数据是否正确发布。

系统保护规则不生效：可以通过Sentinel的Dashboard界面查看系统保护规则是否配置正确，或者检查系统资源监控数据是否正确采集。

import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.system.SystemRule;
import com.alibaba.csp.sentinel.slots.system.SystemRuleManager;

public class DebugSystemRuleInitFunc implements InitFunc {
    @Override
    public void init() throws Exception {
        SystemRule rule = new SystemRule();
        rule.setGrade(RuleConstant.SYSTEM_PROTECT_GRADE_CPU);
        rule.setCount(100);
        rule.setLimitApp("default");
        SystemRuleManager.loadRules(Collections.singletonList(rule));
        System.out.println("System rule initialized: " + rule);
    }
}

上述代码展示了如何通过代码初始化系统保护规则时打印日志，以便调试规则是否加载成功。

结语

本文详细介绍了Sentinel的基本概念、使用方法以及实战技巧，通过实际案例和代码示例帮助读者更好地理解和掌握Sentinel的使用。希望读者能够通过本文的学习，灵活运用Sentinel保护自己的服务，提高系统的稳定性和可用性。