spring cloud集成sentinel实现服务限流

最新推荐文章于 2024-03-18 14:28:21 发布
最新推荐文章于 2024-03-18 14:28:21 发布
阅读量456 收藏 1
点赞数
分类专栏： 开发笔记 java 文章标签： java spring spring boot 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoming120915/article/details/105628071
版权
  1. 引入sentinel的作用
    由于近期商城需要做推广活动，为了防止流量激增导致压垮服务，因此需要对请求进行限流。经过一番搜索，最终锁定了sentinel，因为它是阿里的产品，经过多次双十一的检验，而且还有图形界面供用户设置、观察指标等。
  2. spring cloud集成sentinel
    由于我们使用的框架是spring cloud而不是cloud alibaba，所以在集成时遇到了不少的坑，很多从网上搜索的案例都模糊不清，最终还是通过官方文档（版本说明） 进行配置才搞定的。我使用的是Spring Cloud Finchley版本，因此配置文件如下在这里插入代码片
		<dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>

	<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>2.0.2.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
  1. 网关限流
    我们使用的网关是zuul，同样参考官方文档网关限流，增加配置，然后在启动服务是在VM中增加参数-Dcsp.sentinel.app.type=1（告诉sentinel这是一个网关服务，网关服务和普通服务的功能不同），网关服务多出一个“api管理”，该选型功能很强大也很实用，能够根据请求参数、请求路径、请求ip，请求header等进行限流、降级操作。
		<dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-sentinel-gateway</artifactId>
        </dependency>

网关服务

  1. 规则持久化
    sentinel默认是保存在内存中的，因此每次重启服务就会导致规则丢失（重启sentinel dashboard会导致规则丢失，但是限流不会失效；重启sentinel客户端会导致限流失效，但dashboard规则不会丢失，通过dashboard源码可以知道，sentinel是想规则保存在内存，同时通过rpc将规则发送到客户端，由客户端自行限流）。
    sentinel官方提供了多种持久化扩展（ZooKeeper，Nacos，File，Apollo，Redis…），这里我选择使用redis进行持久化，网上很多针对redis持久化的案例，但是大多出自一处，都是通过修改dashboard源码将规则持久化到redis。但是这种方式只是解决了保存的问题，没有解决读取的问题。上面我说过真正的限流是在各个客户端自行实现的，dashboard只是提供一个设置的入口而已，每个客户端在重启时需要将redis中涉及到自己的规则读取到内存中，因此这里还需要针对客户端做修改，增加如下配置
		<dependency>
            <groupId>com.alibaba.csp</groupId>
            <artifactId>sentinel-datasource-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba.csp</groupId>
            <artifactId>sentinel-api-gateway-adapter-common</artifactId>
        </dependency>
  • 将持久化从dashboard移到客户端
    网上很多很的方案都是在dashboard修改redis持久化配置，我按照网上的方案对dashboard源码进行了修改，确实可以把规则保存到redis中，但是网上的方案都没有涉及客户端服务启动读入规则。当我想要在客户端重启时读入dashboard写入的规则时，发现dashboard和客户端的实体类字段进行有差别，从而导致规则无法读入。因此我转变思维，将持久化操作也放在客户端，由客户端进行持久化、由客户端进行读入，这样就不会出现不兼容的问题。实现WritableDataSurce接口，从而让规则能够持久化到redis
public class RedisWritableDataSource<T> implements WritableDataSource<T> {

    private final RedisClient redisClient;
    private String key;

    public RedisWritableDataSource(RedisConnectionConfig config, String key){
        AssertUtil.notNull(config, "Redis connection config can not be null");
        AssertUtil.notEmpty(key, "Redis ruleKey can not be empty");
        this.redisClient = this.getRedisClient(config);
        this.key = key;
    }

    private RedisClient getRedisClient(RedisConnectionConfig connectionConfig) {
        if (connectionConfig.getRedisSentinels().size() == 0) {
            RecordLog.info("[RedisDataSource] Creating stand-alone mode Redis client", new Object[0]);
            return this.getRedisStandaloneClient(connectionConfig);
        } else {
            RecordLog.info("[RedisDataSource] Creating Redis Sentinel mode Redis client", new Object[0]);
            return this.getRedisSentinelClient(connectionConfig);
        }
    }

    private RedisClient getRedisStandaloneClient(RedisConnectionConfig connectionConfig) {
        char[] password = connectionConfig.getPassword();
        String clientName = connectionConfig.getClientName();
        RedisURI.Builder redisUriBuilder = RedisURI.builder();
        redisUriBuilder.withHost(connectionConfig.getHost()).withPort(connectionConfig.getPort()).withDatabase(connectionConfig.getDatabase()).withTimeout(Duration.ofMillis(connectionConfig.getTimeout()));
        if (password != null) {
            redisUriBuilder.withPassword(connectionConfig.getPassword());
        }

        if (StringUtil.isNotEmpty(connectionConfig.getClientName())) {
            redisUriBuilder.withClientName(clientName);
        }

        return RedisClient.create(redisUriBuilder.build());
    }

    private RedisClient getRedisSentinelClient(RedisConnectionConfig connectionConfig) {
        char[] password = connectionConfig.getPassword();
        String clientName = connectionConfig.getClientName();
        RedisURI.Builder sentinelRedisUriBuilder = RedisURI.builder();
        Iterator var5 = connectionConfig.getRedisSentinels().iterator();

        while(var5.hasNext()) {
            RedisConnectionConfig config = (RedisConnectionConfig)var5.next();
            sentinelRedisUriBuilder.withSentinel(config.getHost(), config.getPort());
        }

        if (password != null) {
            sentinelRedisUriBuilder.withPassword(connectionConfig.getPassword());
        }

        if (StringUtil.isNotEmpty(connectionConfig.getClientName())) {
            sentinelRedisUriBuilder.withClientName(clientName);
        }

        sentinelRedisUriBuilder.withSentinelMasterId(connectionConfig.getRedisSentinelMasterId()).withTimeout(connectionConfig.getTimeout(), TimeUnit.MILLISECONDS);
        return RedisClient.create(sentinelRedisUriBuilder.build());
    }

    @Override
    public void write(T t) throws Exception {
        RedisCommands<String, String> stringRedisCommands = this.redisClient.connect().sync();
        stringRedisCommands.set(key, JSON.toJSONString(t, SerializerFeature.WriteClassName));
    }

    @Override
    public void close() throws Exception {
        this.redisClient.shutdown();
    }
}
  • 客户单启动时读取规则配置
@Configuration
public class GatewayRuleConfig {

    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private Integer port;
    @Value("${spring.redis.password}")
    private String password;
    @Value("${spring.cloud.sentinel.transport.port}")
    private String sentinelPort;

    //限流规则key前缀
    public final String RULE_FLOW = "sentinel_rule_flow_";
    public final String RULE_FLOW_CHANNEL = "sentinel_rule_flow_channel";
    //降级规则key前缀
    public final String RULE_DEGRADE = "sentinel_rule_degrade_";
    public final String RULE_DEGRADE_CHANNEL = "sentinel_rule_degrade_channel";
    //系统规则key前缀
    public final String RULE_SYSTEM = "sentinel_rule_system_";
    public final String RULE_SYSTEM_CHANNEL = "sentinel_rule_system_channel";
    //API分组
    public final String RULE_API = "sentinel_rule_api_";
    public final String RULE_API_CHANNEL = "sentinel_rule_api_channel";
    //gateway规则
    public final String RULE_GATEWAY_FLOW = "sentinel_rule_gateway_flow_";
    public final String RULE_GATEWAY_FLOW_CHANNEL = "sentinel_rule_gateway_flow_channel";

    @PostConstruct
    public void doInit() throws Exception {
        RedisConnectionConfig config = RedisConnectionConfig.builder()
                .withHost(host)
                .withPort(port)
                .withPassword(password)
                .build();

        InetAddress host = InetAddress.getLocalHost();
        initFlowRule(config, host);
        initDegradeRule(config, host);
        initSystemRule(config, host);
        initApiDefinition(config, host);
        initGatewayFlowRule(config, host);
    }

    private void initFlowRule(RedisConnectionConfig config, InetAddress host){
        Converter<String, List<FlowRule>> parser = source -> JSON.parseObject(source,new TypeReference<List<FlowRule>>() {});
        ReadableDataSource<String, List<FlowRule>> redisDataSource = new RedisDataSource<>(config, RULE_FLOW+ SentinelConfig.getAppName()+":"+host.getHostAddress()+":"+sentinelPort, RULE_FLOW_CHANNEL, parser);
        FlowRuleManager.register2Property(redisDataSource.getProperty());

        WritableDataSource<List<FlowRule>> writableDataSource = new RedisWritableDataSource<>(config, RULE_FLOW+ SentinelConfig.getAppName()+":"+host.getHostAddress()+":"+sentinelPort);
        WritableDataSourceRegistry.registerFlowDataSource(writableDataSource);
    }

    private void initDegradeRule(RedisConnectionConfig config, InetAddress host){
        Converter<String, List<DegradeRule>> parser1 = source -> JSON.parseObject(source,new TypeReference<List<DegradeRule>>() {});
        ReadableDataSource<String, List<DegradeRule>> redisDataSource1 = new RedisDataSource<>(config, RULE_DEGRADE+SentinelConfig.getAppName()+":"+host.getHostAddress()+":"+sentinelPort, RULE_DEGRADE_CHANNEL, parser1);
        DegradeRuleManager.register2Property(redisDataSource1.getProperty());

        WritableDataSource<List<DegradeRule>> writableDataSource = new RedisWritableDataSource<>(config, RULE_DEGRADE+ SentinelConfig.getAppName()+":"+host.getHostAddress()+":"+sentinelPort);
        WritableDataSourceRegistry.registerDegradeDataSource(writableDataSource);
    }

    private void initSystemRule(RedisConnectionConfig config, InetAddress host){
        Converter<String, List<SystemRule>> parser2 = source -> JSON.parseObject(source,new TypeReference<List<SystemRule>>() {});
        ReadableDataSource<String, List<SystemRule>> redisDataSource2 = new RedisDataSource<>(config, RULE_SYSTEM+SentinelConfig.getAppName()+":"+host.getHostAddress()+":"+sentinelPort, RULE_SYSTEM_CHANNEL, parser2);
        SystemRuleManager.register2Property(redisDataSource2.getProperty());

        WritableDataSource<List<SystemRule>> writableDataSource = new RedisWritableDataSource<>(config, RULE_SYSTEM+ SentinelConfig.getAppName()+":"+host.getHostAddress()+":"+sentinelPort);
        WritableDataSourceRegistry.registerSystemDataSource(writableDataSource);
    }

    private void initApiDefinition(RedisConnectionConfig config, InetAddress host) throws Exception {
        Converter<String, Set<ApiDefinition>> parser3 = source -> JSON.parseObject(source,new TypeReference<Set<ApiDefinition>>() {});
        ReadableDataSource<String, Set<ApiDefinition>> redisDataSource3 = new RedisDataSource<>(config, RULE_API+SentinelConfig.getAppName()+":"+host.getHostAddress()+":"+sentinelPort, RULE_API_CHANNEL, parser3);
        GatewayApiDefinitionManager.register2Property(redisDataSource3.getProperty());

        WritableDataSource<Set<ApiDefinition>> writableDataSource = new RedisWritableDataSource<>(config, RULE_API+SentinelConfig.getAppName()+":"+host.getHostAddress()+":"+sentinelPort);
        UpdateGatewayApiDefinitionGroupCommandHandler.setWritableDataSource(writableDataSource);
    }

    private void initGatewayFlowRule(RedisConnectionConfig config, InetAddress host) throws Exception {
        Converter<String, Set<GatewayFlowRule>> parser4 = source -> JSON.parseObject(source,new TypeReference<Set<GatewayFlowRule>>() {});
        ReadableDataSource<String, Set<GatewayFlowRule>> redisDataSource4 = new RedisDataSource<>(config, RULE_GATEWAY_FLOW+SentinelConfig.getAppName()+":"+host.getHostAddress()+":"+sentinelPort, RULE_GATEWAY_FLOW_CHANNEL, parser4);
        GatewayRuleManager.register2Property(redisDataSource4.getProperty());

        WritableDataSource<Set<GatewayFlowRule>> writableDataSource = new RedisWritableDataSource<>(config, RULE_GATEWAY_FLOW+SentinelConfig.getAppName()+":"+host.getHostAddress()+":"+sentinelPort);
        UpdateGatewayRuleCommandHandler.setWritableDataSource(writableDataSource);
    }

}

这样就形成了一个闭环，既能够持久化，又能读入内存，修改即时生效。

MLi_hb
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot/Cloud集成Sentinel实现流量控制 | Spring Cloud 23
gmHappy
03-16 1万+
随着微服务的流行，服务和服务之间的稳定性变得越来越重要。 Sentinel 以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。
wotrd-cloud:基于nacos包含网关、认证授权、服务注册、发现、断路降级、限流、配置中心、分库分表等基础组件
04-28
基于nacos的spring cloud微服务框架、集成认证授权、动态网关、分库分表、dubbo开箱即用。 个人博客地址： qq群： 602107221 1、 wotrd-auth： 认证授权服务 2、 wotrd-client： 客户端服务 3、 wotrd-dubbo： dubbo...
若依SpringCloud+Nacos(注册+配置)+Sentinel(限流+熔断)+Seata(分布式事务)+Vue3
03-15
采用前后端分离的模式，微服务版本前端(基于 RuoYi-Vue)。后端采用Spring Boot、Spring Cloud & Alibaba。注册中心、配置中心选型Nacos，权限认证使用Redis。流量控制框架选型Sentinel，分布式事务选型Seata。提供了技术栈（Vue3 Element Plus Vite）版本RuoYi-Cloud-Vue3
SpringBoot项目轻松集成Sentinel：熔断限流实战及核心代码解析
最新发布
知行同学
03-18 1617
springBoot项目集成sentinel详细步骤及实战，并配上部分关键代码，并说明关键注意点
SpringCloud中使用Sentinel实现限流
热门推荐
蹊源的奇思妙想的博客
07-27 1万+
Sentinel Sentinel 是面向微服务的轻量级流量控制框架，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。 Sentinel可以作为Hystrix的替代品，为系统提供服务熔断和服务降级的功能。 服务熔断:根据保险丝的熔断是一个原理，当调用目标服务大量超时和失败，这时候应该熔断掉该服务的调用，从而快速释放资源，这段时间所有对其调用都是快速返回，保证整体服务系统的稳定 服务降级：针对核心业务服务的压力剧增，根据当前业务场景和流量对其他非核心服务进行降级处理，可以进行限流，快速返回等处理
Spring Cloud Alibaba教程 第三弹 Sentinel限流组件介绍
学无止境！
10-12 799
1、Sentinel是什么 随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel 以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性 Sentinel 具有以下特征: 丰富的应用场景：Sentinel 承接了阿里巴巴近 10 年的双十一大促流量的核心场景，例如秒杀（即突发流量控制在系统容量可以承受的范围）、消息削峰填谷、集群流量控制、实时熔断下游不可用应用等。 完备的实时监控：Sentinel 同时提供实时的监控功能。您可以在控制台中看到接入应用的单台机
SpringCloudGateway基于Sentinel的限流
qq_39586619的博客
04-20 1209
SpringCloudGateway基于Sentinel的限流 Sentinel 支持对 Spring Cloud Gateway、Zuul 等主流的 API Gateway 进行限流。 Sentinel介绍： 从 1.6.0 版本开始，Sentinel 提供了 Spring Cloud Gateway 的适配模块，可以提供两种资源维度的限流： * route 维度：即在...
SpringCloudAlibaba - 整合 Sentinel 实现服务限流
Maggieq8324的博客
09-24 662
目录前言具体实现搭建Sentinel控制台 前言 Sentinel 是一个轻量级的流量控制、熔断降级Java库 具体实现 pom.xml <!-- sentinel --> <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId> </depen
springcloud-gateway快速集成sentinel实现限流,并持久化规则到apollo
u014050029的专栏
06-02 7491
官方文档：https://github.com/alibaba/Sentinel/wiki FAQ：https://github.com/alibaba/Sentinel/wiki/FAQ 官方demo：https://github.com/alibaba/Sentinel/tree/master/sentinel-demo 适配依赖：https://github.com/alibaba/Sentinel/wiki/%E4%B8%BB%E6%B5%81%E6%A1%86%E6%9E%B6%E7%9A%
Spring Cloud微服务Sentinel+Apollo限流、熔断实战
qq_41490913的博客
07-17 139
Spring Cloud微服务Sentinel+Apollo限流、熔断实战
【Sentinel】sentinel 集成 apollo 最佳实践
weixin_30338497的博客
09-22 532
【Sentinel】sentinel 集成 apollo 最佳实践 前言   在 sentinel 的控制台设置的规则信息默认都是存在内存当中的。所以无论你是重启了 sentinel 的客户端还是 sentinel 的控制台。你所设置的规则都会丢失。如果想要 sentinel 在线上环境使用，要么花钱用阿里云上的付费版本，要么自己去实现规则的持久化，如果你或你所在的公司不差钱，那么关掉...
spring cloud gateway整合sentinel实现网关限流
08-25
主要介绍了spring cloud gateway整合sentinel实现网关限流,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
microservice-scaffold：基于Spring Cloud（Greenwich.SR2）构建的微服务脚手架（适用于在线系统），已集成注册中心（Nacos Config），配置中心（Nacos Discovery），认证授权（Oauth 2 + JWT），日志处理（ELK + Kafka），限流熔断（AliBaba Sentinel），应用指标监控（Prometheus + Grafana），调用链监控（Pinpoint），以及Spring Boot Admin
01-29
微服务支架基于Spring Cloud（Greenwich.SR2）构建的微服务脚手架，已集成注册中心（Nacos Config），配置中心（Nacos Discovery），认证授权（Oauth 2 + JWT），日志处理（ELK + Kafka），限流熔断（AliBaba ...
（六）Spring Cloud Alibaba Sentinel(含案例源码、案例解析及软件)
奥迪的博客
08-13 924
案例源码gitee地址：https://gitee.com/BanSheng/spring-cloud-alibaba-examples/tree/master/sentinel-example-client Spring Cloud Alibaba Sentinel 一、Sentinel 简介 随着微服务的流行，服务和服务之间的稳定性变得越来越重要。 Sentinel 以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。 Sentinel 具有以下特征: 丰富的.
SpringCloud Alibaba Sentinel限流详解 这一次别在错过
牧小农
05-29 1039
点赞再看，养成习惯，微信搜索【牧小农】关注我获取更多资讯，风里雨里，小农等你，很高兴能够成为你的朋友。 项目源码地址：公众号回复 sentinel，即可免费获取源码 熔断规则 在上一篇文章中我们讲解了流控规则的使用和介绍Sentinel流控规则，今天我们给大家讲解sentinel更多样化的讲解以及流量控制。 官方文档：https://sentinelguard.io/zh-cn/docs/circuit-breaking.html 在面对调用链路中不稳定的资源如何保证高可用？在微服务中一个服务通常会调用.
Spring Cloud Alibaba系列-第12节-GateWay网关使用sentinel限流，规则同步nacos
皮卡肉丘
11-19 3889
目录 1. gateway集成到sentinel 1.1 修改pom文件 1.2网关增加sentinel配置 1.3 验证 1.3.1 启动各个服务 1.3.2 发送请求到网关 1.3.2 观察sentinel页面 2. sentinel网关规则持久化nacos 2.1 修改sentinel源码 2.1.1 在rule.nacos下创建gateway包路径并创建类 2.1.2 修改gatewat controller文件 2.2 进行测试 2.2.1 启动服务： 2.2.2 ..
Gateway配合sentinel自定义限流_Spring Cloud Alibaba系列（五）sentinel实现服务限流降级...
weixin_39902598的博客
11-22 390
一、sentinel是什么sentinel的官方名称叫分布式系统的流量防卫兵。Sentinel 以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。在Spring Cloud项目中最开始我们使用的是Hystrix，目前已停止更新了。现在Spring Cloud官方推荐的是rensilience4j。当然还有我们今天学习的sentinel。Sentinel 具有以下特征:「...
springboot自动配置原理
awodwde的博客
10-10 109
web容器：可以理解成Tomcat 当web容器启动的时候：onStartup会被调用 SPI servlet 3.0实现了 当你项目里面，有某个类或者说某个方法需要在容器启动的时候调用 ： spring和Tomcat是如何关联起来的？spring和Tomcat都实现了servlet的规范 之前我们是使用xml文件方式配置spring的，用的是ClassPathXmlApplicationContext，而现在我们使用的是注解的方式，AnnotationConfigWe...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值