sentinel配置持久化到apollo

最新推荐文章于 2024-07-27 19:53:14 发布
最新推荐文章于 2024-07-27 19:53:14 发布
阅读量977 收藏
点赞数
分类专栏： sentinel 文章标签： sentinel java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guntun8987/article/details/130687984
版权

背景

sentinel-dashborad的配置默认是存储到内存中的，生产环境肯定不能这样使用，官网支持zookeeper、nacos、apollo的配置，本文就来介绍apollo的持久化

apollo

sentinel-dashboard 整合 apollo 进行规则的持久化配置，主要方式是通过 apollo 开放平台的授权方式进行写入与读取。所以需要先在apollo上开放出授权的token

sentinel-dashboard

首先将sentinel下载下来然后找到sentinel-dashboard模块，基于1.8.1版本

新建apllo需要的相关配置 ApolloProperties

@ConfigurationProperties(prefix = "apollo")
@Data
public class ApolloProperties {
    /**
     * apollo地址
     * */
    private String portalUrl;
    
    /**
     * 授权token
     * */
    private String token;
    
    /**
     * appId
     * */
    private String appId;
    
    /**
     * 环境
     * */
    private String env;
    
    /**
     * clusterName(默认为default)
     * */
    private String clusterName;
    
    /**
     * 命名空间
     * */
    private String namespace;
    
    /**
     * 操作人
     * */
    private String operator;
}

新建ApolloConfig 里面包括各种规则和apollo交互需要的编解码工具和操作apollo的api

@Configuration
@EnableConfigurationProperties(ApolloProperties.class)
public class ApolloConfig {
    
    @Autowired
    private ApolloProperties apolloProperties;;
    
    /**
     * 流控规则编码
     */
    @Bean
    public Converter<List<FlowRuleEntity>, String> flowRuleEntityEncoder() {
        return JSON::toJSONString;
    }
    
    /**
     * 流控规则解码
     */
    @Bean
    public Converter<String, List<FlowRuleEntity>> flowRuleEntityDecoder() {
        return s -> JSON.parseArray(s, FlowRuleEntity.class);
    }
    
    /**
     * 降级规则编码
     */
    @Bean
    public Converter<List<DegradeRuleEntity>, String> degradeRuleEntityEncoder() {
        return JSON::toJSONString;
    }
    
    /**
     * 降级规则解码
     */
    @Bean
    public Converter<String, List<DegradeRuleEntity>> degradeRuleEntityDecoder() {
        return s -> JSON.parseArray(s, DegradeRuleEntity.class);
    }
    
    /**
     * 授权规则编码
     */
    @Bean
    public Converter<List<AuthorityRuleEntity>, String> authorityRuleEntityEncoder() {
        return JSON::toJSONString;
    }
    
    /**
     * 授权规则解码
     */
    @Bean
    public Converter<String, List<AuthorityRuleEntity>> authorityRuleEntityDecoder() {
        return s -> JSON.parseArray(s, AuthorityRuleEntity.class);
    }
    
    /**
     * 系统规则编码
     */
    @Bean
    public Converter<List<SystemRuleEntity>, String> systemRuleEntityEncoder() {
        return JSON::toJSONString;
    }
    
    /**
     * 系统规则解码
     */
    @Bean
    public Converter<String, List<SystemRuleEntity>> systemRuleEntityDecoder() {
        return s -> JSON.parseArray(s, SystemRuleEntity.class);
    }
    
    /**
     * 热点规则编码
     */
    @Bean
    public Converter<List<ParamFlowRuleEntity>, String> paramFlowRuleEntityEncoder() {
        return JSON::toJSONString;
    }
    
    /**
     * 热点规则解码
     */
    @Bean
    public Converter<String, List<ParamFlowRuleEntity>> paramFlowRuleEntityDecoder() {
        return s -> JSON.parseArray(s, ParamFlowRuleEntity.class);
    }
    
    /**
     * 集群流控规则编码
     */
    @Bean
    public Converter<List<ClusterAppAssignMap>, String> clusterGroupEntityEncoder() {
        return JSON::toJSONString;
    }
    
    /**
     * 集群流控规则解码
     */
    @Bean
    public Converter<String, List<ClusterAppAssignMap>> clusterGroupEntityDecoder() {
        return s -> JSON.parseArray(s, ClusterAppAssignMap.class);
    }
    
    /**
     * API管理分组编码
     */
    @Bean
    public Converter<List<ApiDefinitionEntity>, String> apiDefinitionEntityEncoder() {
        return JSON::toJSONString;
    }
    
    /**
     * API管理分组解码
     */
    @Bean
    public Converter<String, List<ApiDefinitionEntity>> apiDefinitionEntityDecoder() {
        return s -> JSON.parseArray(s, ApiDefinitionEntity.class);
    }
    
    /**
     * 网关流控规则编码
     */
    @Bean
    public Converter<List<GatewayFlowRuleEntity>, String> gatewayFlowRuleEntityEncoder() {
        return JSON::toJSONString;
    }
    
    /**
     * 网关流控规则解码
     */
    @Bean
    public Converter<String, List<GatewayFlowRuleEntity>> gatewayFlowRuleEntityDecoder() {
        return s -> JSON.parseArray(s, GatewayFlowRuleEntity.class);
    }

    /**
     * 操作apollo的api
     * */
    @Bean
    public ApolloOpenApiClient apolloOpenApiClient() {
        ApolloOpenApiClient client = ApolloOpenApiClient.newBuilder()
            .withPortalUrl(apolloProperties.getPortalUrl())
            .withToken(apolloProperties.getToken())
            .build();
        return client;

    }
}

新建ApolloConfigUtil 用于生成各种规则存储在apollo中的key名称

在这里插入图片描述

public final class ApolloConfigUtil
{
    /**
     * 网关-api分组id
     */
    public static final String GATEWAY_API_GROUP_DATA_ID_POSTFIX = "gw-api-group-rules";
    
    /**
     * 网关-流控规则id
     */
    public static final String GATEWAY_FLOW_DATA_ID_POSTFIX = "gw-flow-rules";
    
    /**
     * 流控规则id
     */
    public static final String FLOW_DATA_ID_POSTFIX = "flow-rules";
    /**
     * 降级规则id
     */
    public static final String DEGRADE_DATA_ID_POSTFIX = "degrade-rules";
    /**
     * 热点规则id
     */
    public static final String PARAM_FLOW_DATA_ID_POSTFIX = "param-flow-rules";
    /**
     * 系统规则id
     */
    public static final String SYSTEM_DATA_ID_POSTFIX = "system-rules";
    /**
     * 授权规则id
     */
    public static final String AUTHORITY_DATA_ID_POSTFIX = "authority-rules";
    /**
     * 集群流控id
     */
    public static final String CLUSTER_GROUP_DATA_ID_POSTFIX = "cluster-group-rules";
    
    private ApolloConfigUtil()
    {
    }
    
    public static String getGatewayFlowDataId(String appName)
    {
        return String.format("%s-%s", appName, GATEWAY_FLOW_DATA_ID_POSTFIX);
    }
    
    public static String getGatewayApiGroupDataId(String appName)
    {
        return String.format("%s-%s", appName, GATEWAY_API_GROUP_DATA_ID_POSTFIX);
    }
    
    public static String getClusterGroupDataId(String appName)
    {
        return String.format("%s-%s", appName, CLUSTER_GROUP_DATA_ID_POSTFIX);
    }
    
    public static String getFlowDataId(String appName)
    {
        return String.format("%s-%s", appName, FLOW_DATA_ID_POSTFIX);
    }
    
    public static String getDegradeDataId(String appName)
    {
        return String.format("%s-%s", appName, DEGRADE_DATA_ID_POSTFIX);
    }
    
    public static String getParamFlowDataId(String appName)
    {
        return String.format("%s-%s", appName, PARAM_FLOW_DATA_ID_POSTFIX);
    }
    
    public static String getSystemDataId(String appName)
    {
        return String.format("%s-%s", appName, SYSTEM_DATA_ID_POSTFIX);
    }
    
    public static String getAuthorityDataId(String appName)
    {
        return String.format("%s-%s", appName, AUTHORITY_DATA_ID_POSTFIX);
    }
}

流控规则持久化apollo

项目提供了DynamicRuleProvider和DynamicRulePublisher两个接口，这是将整个规则的相关操作抽象了出来，一个用户查询、另一个用于新增、修改、删除。项目中test/rule模块下提供了apollo关于流控规则的示例FlowRuleApolloProvider和FlowRuleApolloPublisher，也是将这两个接口进行了实现。本人直接拿这提供好的示例进行改造
FlowRuleApolloProvider

@Component("flowRuleApolloProvider")
public class FlowRuleApolloProvider implements DynamicRuleProvider<List<FlowRuleEntity>> {

    @Autowired
    private ApolloOpenApiClient apolloOpenApiClient;
    @Autowired
    private Converter<String, List<FlowRuleEntity>> converter;
    @Autowired
    private ApolloProperties apolloProperties;

    /**
     * @param appName 服务名
     * */
    @Override
    public List<FlowRuleEntity> getRules(String appName) throws Exception {
        //String appId = "appId";
        String flowDataId = ApolloConfigUtil.getFlowDataId(appName);
        OpenNamespaceDTO openNamespaceDTO = apolloOpenApiClient.getNamespace(apolloProperties.getAppId(), apolloProperties.getEnv(), apolloProperties.getClusterName(), apolloProperties.getNamespace());
        String rules = openNamespaceDTO
            .getItems()
            .stream()
            .filter(p -> p.getKey().equals(flowDataId))
            .map(OpenItemDTO::getValue)
            .findFirst()
            .orElse("");

        if (StringUtil.isEmpty(rules)) {
            return new ArrayList<>();
        }
        return converter.convert(rules);
    }
}

FlowRuleApolloPublisher

@Component("flowRuleApolloPublisher")
public class FlowRuleApolloPublisher implements DynamicRulePublisher<List<FlowRuleEntity>> {

    @Autowired
    private ApolloOpenApiClient apolloOpenApiClient;
    @Autowired
    private Converter<List<FlowRuleEntity>, String> converter;
    @Autowired
    private ApolloProperties apolloProperties;

    @Override
    public void publish(String app, List<FlowRuleEntity> rules) throws Exception {
        AssertUtil.notEmpty(app, "app name cannot be empty");
        if (rules == null) {
            return;
        }

        // Increase the configuration
        //String appId = "appId";
        String flowDataId = ApolloConfigUtil.getFlowDataId(app);
        OpenItemDTO openItemDTO = new OpenItemDTO();
        openItemDTO.setKey(flowDataId);
        openItemDTO.setValue(converter.convert(rules));
        openItemDTO.setComment("Program auto-join");
        openItemDTO.setDataChangeCreatedBy(apolloProperties.getOperator());
        apolloOpenApiClient.createOrUpdateItem(apolloProperties.getAppId(), apolloProperties.getEnv(), apolloProperties.getClusterName(), apolloProperties.getNamespace(), openItemDTO);

        // Release configuration
        NamespaceReleaseDTO namespaceReleaseDTO = new NamespaceReleaseDTO();
        namespaceReleaseDTO.setEmergencyPublish(true);
        namespaceReleaseDTO.setReleaseComment("Modify or add configurations");
        namespaceReleaseDTO.setReleasedBy(apolloProperties.getOperator());
        namespaceReleaseDTO.setReleaseTitle("Modify or add configurations");
        apolloOpenApiClient.publishNamespace(apolloProperties.getAppId(), apolloProperties.getEnv(), apolloProperties.getClusterName(), apolloProperties.getNamespace(), namespaceReleaseDTO);
    }
}

下面是改造controller层，流控规则用到了两个controller，FlowControllerV1和FlowControllerV2
FlowControllerV2

@RestController
@RequestMapping(value = "/v2/flow")
public class FlowControllerV2 {
    
    private final Logger logger = LoggerFactory.getLogger(FlowControllerV2.class);
    
    @Autowired
    private InMemoryRuleRepositoryAdapter<FlowRuleEntity> repository;
    
    @Autowired
    @Qualifier("flowRuleApolloProvider")
    private DynamicRuleProvider<List<FlowRuleEntity>> ruleProvider;
    @Autowired
    @Qualifier("flowRuleApolloPublisher")
    private DynamicRulePublisher<List<FlowRuleEntity>> rulePublisher;
   
    @GetMapping("/rules")
    @AuthAction(PrivilegeType.READ_RULE)
    public Result<List<FlowRuleEntity>> apiQueryMachineRules(@RequestParam String app) {
        if (StringUtil.isEmpty(app)) {
            return Result.ofFail(-1, "app can't be null or empty");
        }
        try {
            List<FlowRuleEntity> rules = ruleProvider.getRules(app);
            if (rules != null && !rules.isEmpty()) {
                for (FlowRuleEntity entity : rules) {
                    entity.setApp(app);
                    if (entity.getClusterConfig() != null && entity.getClusterConfig().getFlowId() != null) {
                        entity.setId(entity.getClusterConfig().getFlowId());
                    }
                }
            }
            rules = repository.saveAll(rules);
            return Result.ofSuccess(rules);
        } catch (Throwable throwable) {
            logger.error("Error when querying flow rules", throwable);
            return Result.ofThrowable(-1, throwable);
        }
    }
    
    private <R> Result<R> checkEntityInternal(FlowRuleEntity entity) {
        if (entity == null) {
            return Result.ofFail(-1, "invalid body");
        }
        if (StringUtil.isBlank(entity.getApp())) {
            return Result.ofFail(-1, "app can't be null or empty");
        }
        if (StringUtil.isBlank(entity.getLimitApp())) {
            return Result.ofFail(-1, "limitApp can't be null or empty");
        }
        if (StringUtil.isBlank(entity.getResource())) {
            return Result.ofFail(-1, "resource can't be null or empty");
        }
        if (entity.getGrade() == null) {
            return Result.ofFail(-1, "grade can't be null");
        }
        if (entity.getGrade() != 0 && entity.getGrade() != 1) {
            return Result.ofFail(-1, "grade must be 0 or 1, but " + entity.getGrade() + " got");
        }
        if (entity.getCount() == null || entity.getCount() < 0) {
            return Result.ofFail(-1, "count should be at lease zero");
        }
        if (entity.getStrategy() == null) {
            return Result.ofFail(-1, "strategy can't be null");
        }
        if (entity.getStrategy() != 0 && StringUtil.isBlank(entity.getRefResource())) {
            return Result.ofFail(-1, "refResource can't be null or empty when strategy!=0");
        }
        if (entity.getControlBehavior() == null) {
            return Result.ofFail(-1, "controlBehavior can't be null");
        }
        int controlBehavior = entity.getControlBehavior();
        if (controlBehavior == 1 && entity.getWarmUpPeriodSec() == null) {
            return Result.ofFail(-1, "warmUpPeriodSec can't be null when controlBehavior==1");
        }
        if (controlBehavior == 2 && entity.getMaxQueueingTimeMs() == null) {
            return Result.ofFail(-1, "maxQueueingTimeMs can't be null when controlBehavior==2");
        }
        if (entity.isClusterMode() && entity.getClusterConfig() == null) {
            return Result.ofFail(-1, "cluster config should be valid");
        }
        return null;
    }
    
    @PostMapping("/rule")
    @AuthAction(value = AuthService.PrivilegeType.WRITE_RULE)
    public Result<FlowRuleEntity> apiAddFlowRule(@RequestBody FlowRuleEntity entity) {
        entity.setApp(app);
        Result<FlowRuleEntity> checkResult = checkEntityInternal(entity);
        if (checkResult != null) {
            return checkResult;
        }
        Date date = new Date();
        entity.setGmtCreate(date);
        entity.setGmtModified(date);
        entity.setLimitApp(entity.getLimitApp().trim());
        entity.setResource(entity.getResource().trim());
        try {
            entity = repository.save(entity);
            publishRules(entity.getApp());
        } catch (Throwable throwable) {
            logger.error("Failed to add flow rule", throwable);
            return Result.ofThrowable(-1, throwable);
        }
        return Result.ofSuccess(entity);
    }
    @PutMapping("/rule/{id}")
    @AuthAction(AuthService.PrivilegeType.WRITE_RULE)
    public Result<FlowRuleEntity> apiUpdateFlowRule(@PathVariable("id") Long id,
                                                    @RequestBody FlowRuleEntity entity) {
        entity.setApp(app);
        if (id == null || id <= 0) {
            return Result.ofFail(-1, "Invalid id");
        }
        FlowRuleEntity oldEntity = repository.findById(id);
        if (oldEntity == null) {
            return Result.ofFail(-1, "id " + id + " does not exist");
        }
        if (entity == null) {
            return Result.ofFail(-1, "invalid body");
        }
        
        entity.setApp(oldEntity.getApp());
        entity.setIp(oldEntity.getIp());
        entity.setPort(oldEntity.getPort());
        Result<FlowRuleEntity> checkResult = checkEntityInternal(entity);
        if (checkResult != null) {
            return checkResult;
        }
        
        entity.setId(id);
        Date date = new Date();
        entity.setGmtCreate(oldEntity.getGmtCreate());
        entity.setGmtModified(date);
        try {
            entity = repository.save(entity);
            if (entity == null) {
                return Result.ofFail(-1, "save entity fail");
            }
            publishRules(oldEntity.getApp());
        } catch (Throwable throwable) {
            logger.error("Failed to update flow rule", throwable);
            return Result.ofThrowable(-1, throwable);
        }
        return Result.ofSuccess(entity);
    }
    
    @DeleteMapping("/rule/{id}")
    @AuthAction(PrivilegeType.DELETE_RULE)
    public Result<Long> apiDeleteRule(@PathVariable("id") Long id) {
        if (id == null || id <= 0) {
            return Result.ofFail(-1, "Invalid id");
        }
        FlowRuleEntity oldEntity = repository.findById(id);
        if (oldEntity == null) {
            return Result.ofSuccess(null);
        }
        
        try {
            repository.delete(id);
            publishRules(oldEntity.getApp());
        } catch (Exception e) {
            return Result.ofFail(-1, e.getMessage());
        }
        return Result.ofSuccess(id);
    }
    
    public void publishRules(/*@NonNull*/ String app) throws Exception {
        List<FlowRuleEntity> rules = repository.findAllByApp(app);
        rulePublisher.publish(app, rules);
    }
}

FlowControllerV2是调用apollo的ruleProvider和rulePublisher完成调用的，我把FlowControllerV1改造成直接调用的FlowControllerV2
FlowControllerV2

@RestController
@RequestMapping(value = "/v2/flow")
public class FlowControllerV2 {
    
    private final Logger logger = LoggerFactory.getLogger(FlowControllerV2.class);
    
    @Autowired
    private InMemoryRuleRepositoryAdapter<FlowRuleEntity> repository;
    
    @Autowired
    @Qualifier("flowRuleApolloProvider")
    private DynamicRuleProvider<List<FlowRuleEntity>> ruleProvider;
    @Autowired
    @Qualifier("flowRuleApolloPublisher")
    private DynamicRulePublisher<List<FlowRuleEntity>> rulePublisher;
    
    @GetMapping("/rules")
    @AuthAction(PrivilegeType.READ_RULE)
    public Result<List<FlowRuleEntity>> apiQueryMachineRules(@RequestParam String app) {
        if (StringUtil.isEmpty(app)) {
            return Result.ofFail(-1, "app can't be null or empty");
        }
        try {
            List<FlowRuleEntity> rules = ruleProvider.getRules(app);
            if (rules != null && !rules.isEmpty()) {
                for (FlowRuleEntity entity : rules) {
                    entity.setApp(app);
                    if (entity.getClusterConfig() != null && entity.getClusterConfig().getFlowId() != null) {
                        entity.setId(entity.getClusterConfig().getFlowId());
                    }
                }
            }
            rules = repository.saveAll(rules);
            return Result.ofSuccess(rules);
        } catch (Throwable throwable) {
            logger.error("Error when querying flow rules", throwable);
            return Result.ofThrowable(-1, throwable);
        }
    }
    
    private <R> Result<R> checkEntityInternal(FlowRuleEntity entity) {
        if (entity == null) {
            return Result.ofFail(-1, "invalid body");
        }
        if (StringUtil.isBlank(entity.getApp())) {
            return Result.ofFail(-1, "app can't be null or empty");
        }
        if (StringUtil.isBlank(entity.getLimitApp())) {
            return Result.ofFail(-1, "limitApp can't be null or empty");
        }
        if (StringUtil.isBlank(entity.getResource())) {
            return Result.ofFail(-1, "resource can't be null or empty");
        }
        if (entity.getGrade() == null) {
            return Result.ofFail(-1, "grade can't be null");
        }
        if (entity.getGrade() != 0 && entity.getGrade() != 1) {
            return Result.ofFail(-1, "grade must be 0 or 1, but " + entity.getGrade() + " got");
        }
        if (entity.getCount() == null || entity.getCount() < 0) {
            return Result.ofFail(-1, "count should be at lease zero");
        }
        if (entity.getStrategy() == null) {
            return Result.ofFail(-1, "strategy can't be null");
        }
        if (entity.getStrategy() != 0 && StringUtil.isBlank(entity.getRefResource())) {
            return Result.ofFail(-1, "refResource can't be null or empty when strategy!=0");
        }
        if (entity.getControlBehavior() == null) {
            return Result.ofFail(-1, "controlBehavior can't be null");
        }
        int controlBehavior = entity.getControlBehavior();
        if (controlBehavior == 1 && entity.getWarmUpPeriodSec() == null) {
            return Result.ofFail(-1, "warmUpPeriodSec can't be null when controlBehavior==1");
        }
        if (controlBehavior == 2 && entity.getMaxQueueingTimeMs() == null) {
            return Result.ofFail(-1, "maxQueueingTimeMs can't be null when controlBehavior==2");
        }
        if (entity.isClusterMode() && entity.getClusterConfig() == null) {
            return Result.ofFail(-1, "cluster config should be valid");
        }
        return null;
    }
    
    @PostMapping("/rule")
    @AuthAction(value = AuthService.PrivilegeType.WRITE_RULE)
    public Result<FlowRuleEntity> apiAddFlowRule(@RequestBody FlowRuleEntity entity) {
        entity.setApp(app);
        Result<FlowRuleEntity> checkResult = checkEntityInternal(entity);
        if (checkResult != null) {
            return checkResult;
        }
        Date date = new Date();
        entity.setGmtCreate(date);
        entity.setGmtModified(date);
        entity.setLimitApp(entity.getLimitApp().trim());
        entity.setResource(entity.getResource().trim());
        try {
            entity = repository.save(entity);
            publishRules(entity.getApp());
        } catch (Throwable throwable) {
            logger.error("Failed to add flow rule", throwable);
            return Result.ofThrowable(-1, throwable);
        }
        return Result.ofSuccess(entity);
    }
    @PutMapping("/rule/{id}")
    @AuthAction(AuthService.PrivilegeType.WRITE_RULE)
    public Result<FlowRuleEntity> apiUpdateFlowRule(@PathVariable("id") Long id,
                                                    @RequestBody FlowRuleEntity entity) {
        entity.setApp(app);
        if (id == null || id <= 0) {
            return Result.ofFail(-1, "Invalid id");
        }
        FlowRuleEntity oldEntity = repository.findById(id);
        if (oldEntity == null) {
            return Result.ofFail(-1, "id " + id + " does not exist");
        }
        if (entity == null) {
            return Result.ofFail(-1, "invalid body");
        }
        
        entity.setApp(oldEntity.getApp());
        entity.setIp(oldEntity.getIp());
        entity.setPort(oldEntity.getPort());
        Result<FlowRuleEntity> checkResult = checkEntityInternal(entity);
        if (checkResult != null) {
            return checkResult;
        }
        
        entity.setId(id);
        Date date = new Date();
        entity.setGmtCreate(oldEntity.getGmtCreate());
        entity.setGmtModified(date);
        try {
            entity = repository.save(entity);
            if (entity == null) {
                return Result.ofFail(-1, "save entity fail");
            }
            publishRules(oldEntity.getApp());
        } catch (Throwable throwable) {
            logger.error("Failed to update flow rule", throwable);
            return Result.ofThrowable(-1, throwable);
        }
        return Result.ofSuccess(entity);
    }
    
    @DeleteMapping("/rule/{id}")
    @AuthAction(PrivilegeType.DELETE_RULE)
    public Result<Long> apiDeleteRule(@PathVariable("id") Long id) {
        if (id == null || id <= 0) {
            return Result.ofFail(-1, "Invalid id");
        }
        FlowRuleEntity oldEntity = repository.findById(id);
        if (oldEntity == null) {
            return Result.ofSuccess(null);
        }
        
        try {
            repository.delete(id);
            publishRules(oldEntity.getApp());
        } catch (Exception e) {
            return Result.ofFail(-1, e.getMessage());
        }
        return Result.ofSuccess(id);
    }
    
    public void publishRules(/*@NonNull*/ String app) throws Exception {
        List<FlowRuleEntity> rules = repository.findAllByApp(app);
        rulePublisher.publish(app, rules);
    }
}

配置文件application.properties

#spring settings
server.servlet.encoding.force=true
server.servlet.encoding.charset=UTF-8
server.servlet.encoding.enabled=true

server.port=8082
csp.sentinel.dashboard.server=localhost:8082
project.name=sentinel-dashboard

#cookie name setting
server.servlet.session.cookie.name=sentinel_dashboard_cookie

#logging settings
logging.level.org.springframework.web=INFO
logging.file.name=${user.home}/logs/csp/sentinel-dashboard.log
logging.pattern.file= %d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n
#logging.pattern.console= %d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n

#auth settings
auth.filter.exclude-urls=/,/auth/login,/auth/logout,/registry/machine,/version
auth.filter.exclude-url-suffixes=htm,html,js,css,map,ico,ttf,woff,png
# If auth.enabled=false, Sentinel console disable login
auth.username=sentinel
auth.password=sentinel

# Inject the dashboard version. It's required to enable
# filtering in pom.xml for this resource file.
sentinel.dashboard.version=@project.version@

apollo.portalUrl = #apollo地址
apollo.token= #token
apollo.appId= appId
apollo.env= #环境
apollo.clusterName= #集群名字，默认default
apollo.namespace= #命令空间
apollo.operator= #操作人，默认apollo

结构

在这里插入图片描述

服务项目

添加依赖

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

application.yml

#服务端口
server:
  port: 8080
# 应用名称
spring:
  application:
    name: test-service
  # nacos
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    sentinel:
      transport:
        port: 8720
        dashboard: localhost:8082
      datasource:
        degrade:
          apollo:
            flowRulesKey: ${spring.application.name}-${spring.cloud.sentinel.datasource.degrade.apollo.rule-ruleType}-rules
            namespace-name: ${sentinel.datasource.rules.apollo.namespace-name}
            ruleType: degrade
        flow:
          apollo:
            flowRulesKey: ${spring.application.name}-${spring.cloud.sentinel.datasource.flow.apollo.ruleType}-rules
            namespace-name: ${sentinel.datasource.rules.apollo.namespace-name}
            ruleType: flow
      eager: true
app:
  id: #appId
apollo:
  meta: #地址
  bootstrap:
    enabled: true
    namespaces:  #命令空间
    eagerLoad:
      enabled: true
sentinel:
  datasource:
    rules:
      apollo:
        namespace-name: #命令空间      
feign:
  sentinel:
    enabled: true
management:
  endpoints:
    web:
      exposure:
        include: '*'
    health:
      show-details: always
  security:
    enabled: false

其他规则和流控规则改造相同，这里就不再介绍了

阿星不是程序员
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Sentinel配置规则持久化
congge
11-01 5477
前言 在上一篇，我们讲解了基于springboot与Sentinel的整合与使用，但是有个很明显的问题就是，一旦服务重启，当前配置的针对某个接口的规则就丢掉了，然后就需要重新再配一遍，这就很坑爹了，如果开发中需要配置的接口太多，这样岂不是让人疯掉 因此需要一个地方来保存dashboard中配置的规则，Sentinel提供了多种持久化的方案，可以集成redis，mysql等，这里为了演示方便，而且与springcloud-alibaba一整套微服务框架无缝集成，使用nacos做规则的保存，下面来看具体的使用步
Spring Cloud微服务Sentinel+Apollo限流、熔断实战
程序员高级码农的博客
03-01 1408
在基于Spring Cloud构建的微服务体系中，服务之间的调用链路会随着系统的演进变得越来越长，这无疑会增加了整个系统的不可靠因素。在并发流量比较高的情况下，由于网络调用之间存在一定的超时时间，链路中的某个服务出现宕机都会大大增加整个调用链路的响应时间，而瞬间的流量洪峰则会导致这条链路上所有服务的可用线程资源被打满，从而造成整体服务的不可用，这也就是我们常说的“
sentinel规则持久化
最新发布
aa35434的博客
07-27 791
修改OrderService，让其监听Nacos中的sentinel规则配置。
Sentinel 规则持久化到 apollo 配置中心
热门推荐
张维鹏的博客
01-28 1万+
Sentinel 规则默认是存储在内存中的，只要服务重启之后对应的规则也会消失，实际的生产中肯定是不允许这种操作，因此 Sentinel 官方推荐在生产架构中使用第三方数据源作为永久存储中心，比如 nacos、apollo、zookeeper。因为这几种数据源都是基于 push 模式，也就是由规则中心统一推送，Sentinel Client 只需通过注册监听器的方式时刻监听变化，并负责获取配置中心推送的配置并更新到本地，这种方式能更好的保证实时性和一致性，并且各个微服务的限流、降级规则都可以永久存储。
利用Apollo进行Sentinel规则持久化
weixin_42072632的博客
05-11 641
什么是sentinel？ Sentinel 是面向分布式服务架构的流量控制组件，主要以流量为切入点，从限流、流量整形、熔断降级、系统负载保护、热点防护等多个维度来帮助开发者保障微服务的稳定性。 源码地址：https://github.com/alibaba/Sentinel 官方文档：https://github.com/alibaba/Sentinel/wiki 为什么要持久化 我们下载好sentinel之后,每次要使用都需要启动sentinel的jar包,在sentinel中添加规则之后,每次重启,所有
Sentinel持久化配置
qq_41683000的博客
06-14 826
Sentinel持久化配置
sentinel配置持久化
weixin_46464169的博客
04-10 328
sentinel nacos 配置持久化
apollo持久化sentinel_Sentinel基于Apollo的持久化改造
weixin_42144086的博客
01-14 244
Sentinel基于Apollo的持久化改造sentinel默认是将用户在dashboard中编辑过的流控信息保存在内存中，所以在重启后，所有之前配置过的流控规则也就不见了。但是sentinel给用户提供了可扩展的接口，用户可以根据自己熟悉的持久化引擎来做一定的相应的改造(apollo、nacos、zookeeper)。这里首先要了解下sentinel的规则管理和推送方式规则管理和推送一般来说，规...
sentienl控制台、客户端持久化到Apollo
zhz的博客
12-23 954
sentinel 学习笔记 前段时间大致用了一下sentinel。但是阿里云的sentinel开源并没有实现持久化，针对这个问题我采用了apollo去实现sentinel的持久化。下面就记录一下实现sentinel持久化的过程。 Sentinel 是什么？ 随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel 是面向分布式服务架构的流量控制组件，主要以流量为切入点，从限流、流量整形、熔断降级、系统负载保护、热点防护等多个维度来帮助开发者保障微服务的稳定性。 github项目地址 如何使用
springboot集成sentinel与apollo进行接口限流规则持久化
wu_dong_liang的博客
03-02 627
客户端集成sentinel与apollo进行接口监控 应用集成sentinel GitHub下载sentinel-dashboard项目1.5.1版本引入到STS中并启动，默认端口为8080 注意：1.6以后的版本添加了登录页面，我们这里不需要所以采用1.5.1版本 在客户端pom文件引入以下依赖 <dependency> <groupId>com.alibaba.csp</groupId> <artifactId>sentinel-c...
9.Sentinel控制台 配置 nacos持久化
qq_44605317的博客
06-16 1272
对于 push 模式的数据源,如远程配置中心（ZooKeeper, Nacos, Apollo等等），我们在sentinel Dashboard配置的规则会同步到Nacos中， Sentinel Dashboard也会从Nacos中获取规则，Nacos会讲规则推送给Sentinel客户端。使用时需要在客户端注册数据源：将对应的读数据源注册至对应的 RuleManager，将写数据源注册至 transport 的。大家可以发现整个过程比较繁重，并且每次都需要更新本地文件，他的性能有一定的影响。
sentinel配置持久化（pull方式和push方式)
buzai5的博客
11-27 1222
sentinel配置持久化（pull方式和push方式)
Sentinel | 配置持久化
乌鲁木齐001号程序员
07-23 957
Sentinel 的工作模式 sentinel 工作模式.png 在 Sentinel 客户端（微服务）中用代码写的配置，在启动后，当有第一次流量进来的时候，会推送给 Sentinel-Dashboard； 在 Sentinel-Dashboard 中的配置，会被推送到 Sentinal 客户端（微服务）； 默认情况下，不论 Sentinel-Dashboard 中的配置还是 Sen...
sentinel规则配置持久化
卷心菜投手
05-21 6005
一、前言 1、官方在sentinel中也已经说了，sentinel用于生产环境，需要做一些自适应的改变，这是官方的一篇文章 在生产环境中使用 Sentinel，其中就有说到规则数据的持久化。具体详细细节我就不再说了。实现方式如下 二、Sentinel持久化 （本地和nacos）两种方法 1、对于文件和nacos的实现网上很多，但是都是一样的，这里用其中一篇文章说明 Sentinel持久化 （本地和nacos）两种方法，就不再细说了。 2、这里主要想做出一点解释，毕竟我一开始按照这些方法做完成后，可能和大
Sentinel-DashBoard持久化到Apollo
oShenQiaQia的博客
09-04 408
公司在对限流熔断技术选型的时候选择了Sentinel，关于Sentinel的介绍这里就不多说了。实际用法的话也不多说了，无非就是本地配置规则、使用Sentinel的DataSource来获取外部的持久化的配置、使用DashBoard来配置。 我这边选择的方式是使用DashBoard，但是DashBoard有个问题就是规则只能保存到内存。其实问题也不大，毕竟用的时候配置一下就行，系统也不可能天天双十一吧，而且DashBoard也不可能一直重启吧。但是我还是做了DashBoard配置持久化到A...
sentinel 阿里 原理_Sentinel 的一些小扩展
weixin_39724362的博客
12-03 173
随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel 是面向分布式服务架构的流量控制组件，主要以流量为切入点，从流量控制、熔断降级、系统自适应保护等多个维度来帮助您保障微服务的稳定性。今天给大家介绍一些在使用过程中会遇到的一些问题。SentinelResource 埋点监控@SentinelResource 可以作用于方法上的熔断降级保护，跟 Hystrix 的@Hystrix...
Sentinel配置持久化到Apollo实战记录
08-22 3554
## 准备工作 最近在接入Sentinel限流中间件中遇到的一些问题和理解写于此，也作为一个学习限流中间件的里程碑阶段总结。 Sentinel的部署很简单,Github下载代码启动,或者下周sentinel-dashboard.jar包启动,Sentinel是一个标准SpringBoot工程,启动方便. 启动命令:java -jar sentinel-dashboard.jar 代码地址:...
sentinel 官方文档_掌门1对1微服务体系 Solar | 阿里巴巴 Sentinel 落地实践
weixin_39702480的博客
11-29 176
前言掌门1对1精耕在线教育领域，近几年业务得到了快速发展，但同时也遭遇了“成长的烦恼”。随着微服务数量不断增加，流量进一步暴增，硬件资源有点不堪重负，那么，如何实现更好的限流熔断降级等流量防护措施，这个课题就摆在了掌门人的面前。由于 Spring Cloud 体系已经演进到第二代，第一代的 Hystrix 限流熔断降级组件已经不大适合现在的业务逻辑和规模，同时它目前被 Spring Cloud 官...
【Sentinel 规则持久化配置】
BridgeCloud的博客
05-08 821
在sentinel-dashboard的test包下，已经编写了对nacos的支持，我们需要将其拷贝到main下。修改OrderService，让其监听Nacos中的sentinel规则配置。SentinelDashboard默认不支持nacos的持久化，需要修改源码。接下来，还要修改前端页面，添加一个支持nacos的菜单。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值