首页手记 Sentinel+Nacos限流规则持久化资料入门教程

Sentinel+Nacos限流规则持久化资料入门教程

标签：

Spring Cloud 中间件微服务

概述

本文介绍了如何利用Sentinel与Nacos实现限流规则的持久化管理，通过Sentinel强大的流量控制能力和Nacos的动态配置推送，确保服务在高流量情况下稳定运行。文中详细描述了如何将Sentinel的限流规则持久化到Nacos，并通过动态更新规则，实现灵活的服务治理。同时，提供了完整的示例代码，帮助读者更好地理解和应用sentinel+Nacos限流规则持久化资料。

Sentinel与Nacos简介

什么是Sentinel

Sentinel 是阿里巴巴开源的一款针对Java应用的流量控制组件，它能够帮助开发者有效控制流量，防止系统因过载而崩溃。Sentinel 提供了一系列的流量控制策略，包括基于QPS、并发数、系统负载、响应时间等维度的限流策略，同时支持链路追踪、热点参数限流等功能，适用于微服务架构下的流量管理。

Sentinel 的核心功能包括：

流量控制：根据预设的规则，控制进入系统的流量，防止系统过载。
系统保护：监控系统的负载情况，当系统负载超过阈值时启动保护机制，限制系统负载，避免系统崩溃。
降级：在出现异常和错误时，自动降级非核心功能，确保核心功能的正常运行。
参数校验：对请求参数进行校验，防止参数不符合预期时导致系统异常。
API 级流量控制：对API级别的流量进行控制，实现细粒度的流量管理。

Sentinel 的设计目标在于提供极致的流量控制能力，便于集成到现有的应用中，同时保持对系统性能的影响降到最低。

什么是Nacos

Nacos 是阿里巴巴开源的一款动态服务发现、配置管理和服务管理平台。它帮助开发者构建可伸缩、高可用的服务架构，并提供了服务发现、配置管理、服务管理等功能。Nacos 可以在服务提供者和服务消费者之间提供自动化的服务发现机制，同时支持配置的动态推送和版本管理。Nacos 通过提供一个集中的配置存储和推送机制，使得配置管理更加方便和灵活。

Nacos 的主要功能包括：

服务发现：提供服务的注册和发现功能，实现服务间通信的动态配置。
配置管理：支持配置的集中存储和推送，实现配置的动态变更。
服务管理：提供服务的生命周期管理，包括服务的注册、注销、服务状态监控等。

Nacos 通过提供这些功能，大大简化了微服务架构下的服务管理和配置管理过程，使得微服务架构更加灵活、可伸缩和稳定。

Sentinel与Nacos的作用及应用场景

Sentinel 和 Nacos 在微服务架构中扮演着重要的角色。Sentinel 主要负责流量控制和系统保护，确保服务在高流量情况下仍能稳定运行；Nacos 则负责服务发现和配置管理，确保服务之间的通信高效且配置实时更新。

应用场景

流量控制：Sentinel 能够根据系统的实时负载情况，动态调整流量的输入，避免系统因流量过大导致服务不可用。
服务发现与负载均衡：Nacos 提供服务发现功能，通过动态更新服务节点信息，实现服务之间的高效通信。
配置中心：Nacos 作为配置中心，能够实时推送配置变更，使得应用能够快速响应配置的变化。
故障转移与降级：Sentinel 提供系统保护功能，在系统负载过高时能够自动进行流量限制或者服务降级，避免故障扩散。
监控与报警：通过 Sentinel 和 Nacos 的集成，可以实现对服务状态的实时监控，并设置报警机制，保证系统的稳定运行。

示例代码

以下是一个简单的 Sentinel 和 Nacos 集成的示例：

// Sentinel 配置
import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.csp.sentinel.slots.datasource.FileDataSourceBuilder;
import com.alibaba.csp.sentinel.transport.config.ServerTransportConfig;
import com.alibaba.csp.sentinel.datasource.Converter;

public class SentinelConfig implements InitFunc {
    @Override
    public void init() throws Exception {
        // 文件配置来源
        FlowRuleManager.loadRules(FileDataSourceBuilder.buildFromFile("rules.json"));
        // 配置Sentinel的网络传输设置
        ServerTransportConfig transportConfig = new ServerTransportConfig();
        transportConfig.setServerPort(8080);
        transportConfig.setRegister(false);
    }
}

// Nacos 配置
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.exception.NacosException;

public class NacosConfig {
    public static void main(String[] args) throws NacosException {
        String serverAddr = "localhost:8848";
        String dataId = "example";
        String group = "DEFAULT_GROUP";
        String config = ConfigService.getConfig(serverAddr, dataId, group);
        System.out.println("Config from Nacos: " + config);
    }
}

在上述代码中，Sentinel 通过文件来源来加载限流规则，而 Nacos 则通过其配置服务拉取配置信息。这两个组件可以结合使用，实现更强大的服务治理功能。

准备工作

安装与配置Sentinel

Sentinel安装

引入依赖：首先需要在项目的 pom.xml 或 build.gradle 文件中引入 Sentinel 相关的依赖。

<!-- Maven 依赖 -->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-core</artifactId>
    <version>1.8.2</version>
</dependency>
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-datasource-nacos</artifactId>
    <version>1.8.2</version>
</dependency>

初始化配置：初始化 Sentinel 的配置，包括流量规则和系统规则的加载。

import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.csp.sentinel.slots.datasource.FileDataSourceBuilder;
import com.alibaba.csp.sentinel.transport.config.ServerTransportConfig;
import com.alibaba.csp.sentinel.datasource.Converter;

public class SentinelConfig implements InitFunc {
    @Override
    public void init() throws Exception {
        // 文件配置来源
        FlowRuleManager.loadRules(FileDataSourceBuilder.buildFromFile("rules.json"));
        // 配置Sentinel的网络传输设置
        ServerTransportConfig transportConfig = new ServerTransportConfig();
        transportConfig.setServerPort(8080);
        transportConfig.setRegister(false);
    }
}

Sentinel配置

流量规则文件：在项目的资源目录下创建一个 rules.json 文件，用于存储限流规则。

[
    {
        "resource": "com.example.demo.service.UserService",
        "grade": 1,
        "limitApp": "default",
        "count": 10,
        "strategy": 0,
        "controlBehavior": 0,
        "clusterMode": 0
    }
]

系统规则文件：创建一个 system-rules.json 文件，用于存储系统保护规则。

[
    {
        "resource": "com.example.demo.service.UserService",
        "grade": 0,
        "count": 1000,
        "statIntervalMs": 5000,
        "controlBehavior": 0,
        "clusterMode": 0
    }
]

安装与配置Nacos

Nacos安装

下载与安装：从 Nacos 官方网站下载 Nacos Server，并按照官方文档进行安装。

# 下载Nacos
wget https://github.com/alibaba/Nacos/releases/download/2.0.3/nacos-server-2.0.3.tar.gz

# 解压Nacos
tar -xzf nacos-server-2.0.3.tar.gz

# 进入Nacos目录
cd nacos

# 启动Nacos Server
sh bin/startup.sh -m standalone

访问Nacos：启动 Nacos 后，可以通过浏览器访问 http://localhost:8848/nacos，默认用户名和密码为 admin/nacos。

Nacos配置

注册服务：在 Nacos 中注册一个服务，用于后续的服务发现和配置管理。

# 注册服务
sh bin/nacos-cli.sh -c add persistent demo demo demo

创建配置文件：在 Nacos 中创建一个配置文件，用于存储应用配置，例如数据库连接字符串等。

# 创建配置文件
curl -X POST 'http://localhost:8848/nacos/v2/console/config_center/pushConfig?dataId=demo&group=DEFAULT_GROUP&content=database.url=jdbc:mysql://localhost:3306/demo&tenant=nacos'

配置Sentinel使用Nacos作为数据源

引入依赖：在 pom.xml 或 build.gradle 文件中引入 Sentinel Nacos 数据源依赖。

<!-- Maven 依赖 -->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-datasource-nacos</artifactId>
    <version>1.8.2</version>
</dependency>

配置Nacos数据源：通过代码配置 Sentinel 使用 Nacos 作为数据源。

import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.csp.sentinel.datasource.Converter;
import com.alibaba.csp.sentinel.datasource.nacos.NacosDataSource;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.exception.NacosException;

public class NacosDataSourceConfig implements InitFunc {
    @Override
    public void init() throws Exception {
        String serverAddr = "localhost:8848";
        String dataId = "sentinel_rules";
        String group = "DEFAULT_GROUP";
        String tenant = "nacos";

        ConfigService configService = ConfigService.createNacosConfigService(serverAddr, dataId, group, tenant);
        Converter<String, List<FlowRule>> converter = new FlowRuleConverter();
        FlowRuleManager.loadRules(new NacosDataSource<String, List<FlowRule>>(serverAddr, dataId, group, tenant, converter));
    }
}

启动Sentinel：启动 Sentinel 后，Sentinel 将从 Nacos 中动态加载限流规则。

public class SentinelApplication {
    public static void main(String[] args) {
        Sentinel.init(new NacosDataSourceConfig());
    }
}

通过上述配置，Sentinel 将使用 Nacos 作为数据源，动态加载限流规则，实现规则的持久化管理。

创建限流规则

添加限流规则的基本步骤

定义资源：首先需要定义一个资源，即需要进行流量控制的服务或方法。

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;

public class UserService {
    @SentinelResource(value = "getUserById")
    public User getUserById(Long id, BlockException ex) {
        if (ex != null) {
            System.out.println("Flow limit or block exception: " + ex.getMessage());
            return null;
        }
        return new User(id, "Alice");
    }
}

// User 类
public class User {
    private Long id;
    private String name;

    public User(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

创建规则：创建一个限流规则，配置限流的参数，如QPS、并发数等。

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

public class ResourceRule {
    private static final String RESOURCE_NAME = "getUserById";

    public static List<FlowRule> buildFlowRules() {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule(RESOURCE_NAME);
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rules.add(rule);
        return rules;
    }
}

加载规则：将规则加载到 Sentinel 系统中。

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

public class SentinelInitFunc implements InitFunc {
    @Override
    public void init() throws Exception {
        FlowRuleManager.loadRules(ResourceRule.buildFlowRules());
    }
}

初始化Sentinel：在应用启动时，通过 Sentinel 初始化器加载规则。

public class SentinelApplication {
    public static void main(String[] args) {
        Sentinel.init(new SentinelInitFunc());
    }
}

测试限流规则的有效性

为了验证限流规则的有效性，可以通过模拟大量请求来测试系统是否能够在达到设定的限流阈值后自动限制流量。

发送请求：编写一个测试程序，向服务发送大量的请求。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class LoadTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(100);
        for (int i = 0; i < 100; i++) {
            executorService.submit(() -> {
                System.out.println("Requesting...");
                UserService userService = new UserService();
                userService.getUserUserById(1L);
            });
        }
        executorService.shutdown();
        try {
            executorService.awaitTermination(60, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

观察结果：运行测试程序后，观察服务的响应情况。如果限流规则有效，当请求量超过预设的限流阈值后，服务将返回限流异常。

通过上述步骤，可以验证限流规则是否已经正确应用到服务中并有效工作。

限流规则持久化至Nacos

配置Sentinel将限流规则持久化到Nacos

定义数据源：定义 Nacos 作为 Sentinel 的数据源。

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.FlowRuleManager;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.exception.NacosException;

public class NacosDataSourceConfig implements InitFunc {
    @Override
    public void init() throws Exception {
        String serverAddr = "localhost:8848";
        String dataId = "sentinel_rules";
        String group = "DEFAULT_GROUP";
        String tenant = "nacos";

        ConfigService configService = ConfigService.createNacosConfigService(serverAddr, dataId, group, tenant);
        Converter<String, List<FlowRule>> converter = new FlowRuleConverter();
        FlowRuleManager.loadRules(new NacosDataSource<String, List<FlowRule>>(serverAddr, dataId, group, tenant, converter));
    }
}

创建Nacos配置：在 Nacos 中创建一个新的配置文件，用于存储 Sentinel 的限流规则。

# 创建配置文件
curl -X POST 'http://localhost:8848/nacos/v2/console/config_center/pushConfig?dataId=sentinel_rules&group=DEFAULT_GROUP&content=[{"resource":"getUserById","grade":1,"limitApp":"default","count":10,"strategy":0,"controlBehavior":0,"clusterMode":0}]&tenant=nacos'

启动Sentinel：在 Sentinel 应用程序启动时，加载 Nacos 数据源。

public class SentinelApplication {
    public static void main(String[] args) {
        Sentinel.init(new NacosDataSourceConfig());
    }
}

通过上述配置，Sentinel 将从 Nacos 中动态加载限流规则，实现规则的持久化管理。

手动测试持久化功能

为了验证持久化功能的有效性，可以手动更新 Nacos 中的限流规则配置文件，查看 Sentinel 是否能够正确加载新的规则。

更新Nacos配置：修改 Nacos 中的限流规则配置文件，例如将限流阈值从 10 更改为 5。

# 更新配置文件
curl -X POST 'http://localhost:8848/nacos/v2/console/config_center/pushConfig?dataId=sentinel_rules&group=DEFAULT_GROUP&content=[{"resource":"getUserById","grade":1,"limitApp":"default","count":5,"strategy":0,"controlBehavior":0,"clusterMode":0}]&tenant=nacos'

验证规则更新：发送测试请求，验证新的限流规则是否生效。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class LoadTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(100);
        for (int i = 0; i < 100; i++) {
            executorService.submit(() -> {
                System.out.println("Requesting...");
                UserService userService = new UserService();
                userService.getUserUserById(1L);
            });
        }
        executorService.shutdown();
        try {
            executorService.awaitTermination(60, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

观察结果：运行测试程序后，如果新的规则生效，服务响应将会受到新的限流阈值的限制。

通过上述步骤，可以验证限流规则是否能够成功持久化到 Nacos，并且在 Nacos 中更新规则后，Sentinel 能够正确加载并应用新的规则。

动态更新限流规则

通过Nacos动态更新Sentinel规则

为了实现动态更新限流规则，可以通过 Nacos 的配置推送功能，动态更新 Sentinel 的限流规则配置文件。

配置Nacos推送：配置 Nacos 的配置推送功能，使得当配置文件发生变化时，能够自动将新的配置推送到 Sentinel。

import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.csp.sentinel.datasource.Converter;
import com.alibaba.csp.sentinel.datasource.nacos.NacosDataSource;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.exception.NacosException;

public class NacosDataSourceConfig implements InitFunc {
    @Override
    public void init() throws Exception {
        String serverAddr = "localhost:8848";
        String dataId = "sentinel_rules";
        String group = "DEFAULT_GROUP";
        String tenant = "nacos";

        ConfigService configService = ConfigService.createNacosConfigService(serverAddr, dataId, group, tenant);
        Converter<String, List<FlowRule>> converter = new FlowRuleConverter();
        FlowRuleManager.loadRules(new NacosDataSource<String, List<FlowRule>>(serverAddr, dataId, group, tenant, converter));
    }
}

编写更新逻辑：编写一个程序，用于动态更新 Nacos 中的限流规则配置文件。

import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.exception.NacosException;

public class DynamicRuleUpdater {
    public static void main(String[] args) throws NacosException {
        String serverAddr = "localhost:8848";
        String dataId = "sentinel_rules";
        String group = "DEFAULT_GROUP";
        String tenant = "nacos";

        // 构造新的配置内容
        String newConfig = "[{\"resource\":\"getUserById\",\"grade\":1,\"limitApp\":\"default\",\"count\":5,\"strategy\":0,\"controlBehavior\":0,\"clusterMode\":0}]";

        // 更新Nacos配置
        ConfigService configService = ConfigService.createNacosConfigService(serverAddr, dataId, group, tenant);
        configService.publishConfig(dataId, group, newConfig);
    }
}

启动Sentinel：启动 Sentinel 应用程序，使其能够从 Nacos 中动态加载新的限流规则。

public class SentinelApplication {
    public static void main(String[] args) {
        Sentinel.init(new NacosDataSourceConfig());
    }
}

通过上述步骤，Sentinel 将能够动态更新其限流规则，实现更灵活的服务治理。

验证规则更新的效果

为了验证动态更新规则的效果，可以通过发送测试请求来验证新的限流规则是否生效。

发送测试请求：编写一个程序，用于发送大量请求，以验证新的限流规则是否生效。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class LoadTestAfterUpdate {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(100);
        for (int i = 0; i < 100; i++) {
            executorService.submit(() -> {
                System.out.println("Requesting...");
                UserService userService = new UserService();
                userService.getUserUserById(1L);
            });
        }
        executorService.shutdown();
        try {
            executorService.awaitTermination(60, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

观察结果：运行测试程序后，如果新的规则生效，服务响应将会受到新的限流阈值的限制。

通过上述步骤，可以验证动态更新限流规则的功能是否有效。

常见问题与解决方法

常见问题及解决策略

Sentinel 无法加载规则：
- 问题描述：Sentinel 无法加载存储在文件或 Nacos 中的限流规则。
- 解决方法：检查文件路径是否正确，确认文件格式是否符合要求。如果是 Nacos，确保 Nacos 服务正常运行，且数据ID和组名正确。
流量控制无效：
- 问题描述：已设置限流规则，但实际运行时并未生效。
- 解决方法：检查资源名称是否正确，确保资源名称和方法注解一致。此外，确保限流规则已成功加载并应用。
Nacos 配置推送失败：
- 问题描述：配置文件更新后，Sentinel 未能加载最新的规则。
- 解决方法：检查 Nacos 配置推送功能是否正常，确保推送的配置文件格式正确，且 Nacos 和 Sentinel 的数据源配置一致。
服务发现失败：
- 问题描述：Sentinel 和 Nacos 集成后，服务发现失败。
- 解决方法：检查 Nacos 服务发现配置，确保客户端和服务端的 IP、端口等信息一致。确认 Nacos 服务是否正常启动。
监控报警不生效：
- 问题描述：虽然设置了监控报警，但实际运行时并未收到报警信息。
- 解决方法：检查报警配置是否正确，确保报警条件和规则一致。确认监控系统是否正常运行，且报警信息已正确配置。

注意事项及建议

规范性：在配置文件中使用统一格式，确保代码和配置的一致性。例如，资源名称和方法注解应保持一致。
调试信息：在开发和测试阶段，尽量保留详细的日志信息，便于问题排查。
性能优化：合理设置限流规则，避免过高的限流阈值导致资源浪费，同时防止过低的阈值导致服务不可用。
多环境适应：确保限流规则能够适应不同的环境，例如开发环境、测试环境和生产环境。
持续监控：持续监控服务状态，确保限流规则和配置文件的更新能够及时生效。

通过遵循上述建议，可以更好地利用 Sentinel 和 Nacos 的功能，确保服务的可靠性和稳定性。

实践示例

下面是一个完整的示例，展示如何使用 Sentinel 和 Nacos 实现限流规则的持久化和动态更新。

示例代码

首先，创建一个简单的 Java 应用程序，用于演示如何使用 Sentinel 和 Nacos 实现限流规则的持久化和动态更新。

创建服务端代码

创建服务端代码

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;

public class UserService {
    @SentinelResource(value = "getUserById")
    public User getUserById(Long id, BlockException ex) {
        if (ex != null) {
            System.out.println("Flow limit or block exception: " + ex.getMessage());
            return null;
        }
        return new User(id, "Alice");
    }
}

// User 类
public class User {
    private Long id;
    private String name;

    public User(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

初始化Sentinel

import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.csp.sentinel.datasource.Converter;
import com.alibaba.csp.sentinel.datasource.nacos.NacosDataSource;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.exception.NacosException;

public class NacosDataSourceConfig implements InitFunc {
    @Override
    public void init() throws Exception {
        String serverAddr = "localhost:8848";
        String dataId = "sentinel_rules";
        String group = "DEFAULT_GROUP";
        String tenant = "nacos";

        ConfigService configService = ConfigService.createNacosConfigService(serverAddr, dataId, group, tenant);
        Converter<String, List<FlowRule>> converter = new FlowRuleConverter();
        FlowRuleManager.loadRules(new NacosDataSource<String, List<FlowRule>>(serverAddr, dataId, group, tenant, converter));
    }
}

启动Sentinel

public class SentinelApplication {
    public static void main(String[] args) {
        Sentinel.init(new NacosDataSourceConfig());
    }
}

创建测试代码

创建一个简单的测试程序

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class LoadTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(100);
        for (int i = 0; i < 100; i++) {
            executorService.submit(() -> {
                System.out.println("Requesting...");
                UserService userService = new UserService();
                userService.getUserUserById(1L);
            });
        }
        executorService.shutdown();
        try {
            executorService.awaitTermination(60, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

创建规则更新程序

import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.exception.NacosException;

public class DynamicRuleUpdater {
    public static void main(String[] args) throws NacosException {
        String serverAddr = "localhost:8848";
        String dataId = "sentinel_rules";
        String group = "DEFAULT_GROUP";
        String tenant = "nacos";

        // 构造新的配置内容
        String newConfig = "[{\"resource\":\"getUserById\",\"grade\":1,\"limitApp\":\"default\",\"count\":5,\"strategy\":0,\"controlBehavior\":0,\"clusterMode\":0}]";

        // 更新Nacos配置
        ConfigService configService = ConfigService.createNacosConfigService(serverAddr, dataId, group, tenant);
        configService.publishConfig(dataId, group, newConfig);
    }
}

启动Nacos服务

启动Nacos服务

# 下载Nacos
wget https://github.com/alibaba/Nacos/releases/download/2.0.3/nacos-server-2.0.3.tar.gz

# 解压Nacos
tar -xzf nacos-server-2.0.3.tar.gz

# 进入Nacos目录
cd nacos

# 启动Nacos Server
sh bin/startup.sh -m standalone

创建Nacos配置

# 创建配置文件
curl -X POST 'http://localhost:8848/nacos/v2/console/config_center/pushConfig?dataId=sentinel_rules&group=DEFAULT_GROUP&content=[{"resource":"getUserById","grade":1,"limitApp":"default","count":10,"strategy":0,"controlBehavior":0,"clusterMode":0}]&tenant=nacos'

运行测试程序

运行测试程序

java -cp "target/classes:lib/*" LoadTest

更新规则并验证

java -cp "target/classes:lib/*" DynamicRuleUpdater
java -cp "target/classes:lib/*" LoadTestAfterUpdate

通过上述步骤，可以验证 Sentinel 和 Nacos 集成的限流规则持久化和动态更新功能是否有效。

通过以上示例代码，可以更加直观地看到如何配置和使用 Sentinel 和 Nacos 实现限流规则的持久化和动态更新，确保服务的可靠性和稳定性。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

30秒到达战场

手记
篇

粉丝

95

获赞与收藏

569

关注作者，订阅最新文章

阅读免费教程

Spring Cloud Hystrix

15个小节 6139 120

后端通用面试教程

41个小节 30583 343

网络编程入门教程

20个小节 12561 237

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空