Spring Cloud Alibaba系列-第10节-改造sentinel控制台数据规则推送持久化到nacos

最新推荐文章于 2024-05-01 14:11:54 发布

皮卡肉丘

最新推荐文章于 2024-05-01 14:11:54 发布

阅读量1.4k

点赞数 7

分类专栏： spring cloud alibaba 文章标签： spring cloud alibaba

本文链接：https://blog.csdn.net/weixin_39146499/article/details/109525935

版权

spring cloud alibaba 专栏收录该内容

13 篇文章 4 订阅

订阅专栏

1.7 在sentinel中增加nacos地址

1.8 修改流控规则注入的bean

1.9 修改identity.js

1.10 验证

1.10.1 在sentinel中新增流控规则，查看nacos

2.1.2 在application.properties增加配置

2.1.3 重启consumer服务测试

3. 其他规则进行同步

3.1 熔断降级规则nacos同步

3.1.1 修改dashboard中NacosConfigUtil文件

3.1.2 修改NacosConfig文件

3.1.3 拆分目录

3.1.4 修改DegradeRuleNacosProvider.java中内容

3.1.5 修改DegradeRuleNacosPublisher.java中内容

3.1.6 修改DegradeController.java 文件

3.1.7 测试

3.2 系统规则nacos同步

3.2.1 修改NacosConfig文件

3.2.2 创建包结构，拷贝文件

3.2.3 修改SystemRuleNacosProvider.java中内容

3.2.4 修改SystemRuleNacosPublisher.java中内容

3.2.5 修改SystemController.java 文件

3.2.6 测试

3.3 授权规则nacos同步

3.3.1 修改NacosConfig文件

3.3.2 创建包结构，拷贝文件

3.3.3 修改AuthorityRuleNacosProvider.java中内容

3.3.4 修改AuthorityRuleNacosPublisher.java中内容

3.3.5 修改AuthorityRuleController.java 文件

3.3.6 测试

3.4 参数规则nacos同步

3.4.1 修改NacosConfig文件

3.4.2 创建包结构，拷贝文件

3.4.3 修改ParamFlowRuleNacosProvider.java中内容

3.4.4 修改ParamFlowRuleNacosPublisher.java中内容

3.4.5 修改ParamFlowController.java 文件

观博有逻辑，导航来相助《Spring Cloud Alibaba系列-目录导航》

说明：

版本依赖：

sentinel: sentinel-parent 1.8.1-SNAPSHOT

nacos: 1.3.2

1. sentinel服务端修改

1.1 下载Sentinel源码

源码下载地址：https://github.com/alibaba/Sentinel

1.2 使用idea打开

open项目后，目录如下图：

1.3 启动服务，验证

访问：localhost:8080 出现如下页面，输入账号密码：sentinel sentinel 正常进入页面

1.4 修改pom.xml文件

找到sentinel-dashboard的pom文件，将sentinel-datasource-nacos中的<scope>test</scope>去掉，如下图

1.5 修改sidebar.html

修改前：

修改后：

1.6 将流控的测试代码迁移

将sentinel-dashboard项目中，如下图test中的nacos目录全部移动到man中的rule包下，目录如下图：

找sentinel-dashboard项目中test目录下的nacos目录：

在com.alibaba.csp.sentinel.dashboard.rule包下创建如下图目录，并将上图中的四个文件迁移到此目录中，如下图：

1.7 在sentinel中增加nacos地址

在dashboard的application.properties中增加nacos.address，如下图

1.8 修改流控规则注入的bean

修改 com.alibaba.csp.sentinel.dashboard.controller.v2.FlowControllerV2.java 如下

1.9 修改identity.js

将identity.js下图中FlowServiceV1 修改为FlowServiceV2，否则在簇点链路中修改流控信息会报错

1.10 验证

修改完成后，首先启动nacos，然后启动之前文章创建的生产者与消费者服务，如下图：

然后启动本地的sentinel-dashboard项目：

访问之前使用feign负载的接口：http://localhost:8001/echo/feign/1111，在sentinel页面中出现如下：

1.10.1 在sentinel中新增流控规则，查看nacos

在流控规则中新增流控规则，操作如下：

添加流控规则成功：

查看nacos页面

查看consumer-8001-flow-rules详情

1.10.2 在nacos中修改配置

查看结果已经同步到nacos中，验证在nacos中修改此配置和删除此配置，查看是否生效，效果如图：

1.10.3 在nacos中删除配置

如下图所示，已经删除成功

2. 微服务端的改造

经过上述修改后，已经实现了sentinel流控规则nacos的同步，但是看到网上的资料，说需要进行服务端的改造，目前还不知道用途，暂时作为记录

2.1 修改服务端代码

2.1.1 增加依赖包

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

2.1.2 在application.properties增加配置

2.1.3 重启consumer服务测试

测试步骤与1.10中的测试步骤相同

3. 其他规则进行同步

3.1 熔断降级规则nacos同步

3.1.1 修改dashboard中NacosConfigUtil文件

如下，添加下列内容如图：

    public static final String DEGRADE_DATA_ID_POSTFIX = "-degrade-rules";
    public static final String SYSTEM_DATA_ID_POSTFIX = "-system-rules";
    public static final String AUTHORITY_DATA_ID_POSTFIX = "-authority-rules";

3.1.2 修改NacosConfig文件

增加如下内容，如图：

    @Bean
    public Converter<List<DegradeRuleEntity>, String> degradeRuleEntityEncoder() {
        return JSON::toJSONString;
    }

    @Bean
    public Converter<String, List<DegradeRuleEntity>> degradeRuleEntityDecoder() {
        return s -> JSON.parseArray(s, DegradeRuleEntity.class);
    }

3.1.3 拆分目录

在nacos下创建flow,degrade包，拷贝flow包中的两个java文件到degrade下，并且修改类名Flow为Degrade

3.1.4 修改DegradeRuleNacosProvider.java中内容

修改内容如下图标记位置

3.1.5 修改DegradeRuleNacosPublisher.java中内容

3.1.6 修改DegradeController.java 文件

在下面代码中，需要修改的位置，都已经进行标注，看一下代码后，修改也是比较简单

/*
 * Copyright 1999-2018 Alibaba Group Holding Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.alibaba.csp.sentinel.dashboard.controller;

import java.util.Date;
import java.util.List;

import com.alibaba.csp.sentinel.dashboard.auth.AuthAction;
import com.alibaba.csp.sentinel.dashboard.client.SentinelApiClient;
import com.alibaba.csp.sentinel.dashboard.discovery.MachineInfo;
import com.alibaba.csp.sentinel.dashboard.auth.AuthService.PrivilegeType;
import com.alibaba.csp.sentinel.dashboard.repository.rule.RuleRepository;
import com.alibaba.csp.sentinel.dashboard.rule.DynamicRuleProvider;
import com.alibaba.csp.sentinel.dashboard.rule.DynamicRulePublisher;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.degrade.circuitbreaker.CircuitBreakerStrategy;
import com.alibaba.csp.sentinel.util.StringUtil;

import com.alibaba.csp.sentinel.dashboard.datasource.entity.rule.DegradeRuleEntity;
import com.alibaba.csp.sentinel.dashboard.domain.Result;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * Controller regarding APIs of degrade rules. Refactored since 1.8.0.
 *
 * @author Carpenter Lee
 * @author Eric Zhao
 */
@RestController
@RequestMapping("/degrade")
public class DegradeController {

    private final Logger logger = LoggerFactory.getLogger(DegradeController.class);

    @Autowired
    private RuleRepository<DegradeRuleEntity, Long> repository;

    /**-----修改开始-----**/
    /*@Autowired
    private SentinelApiClient sentinelApiClient;*/
    @Autowired
    @Qualifier("degradeRuleNacosProvider")
    private DynamicRuleProvider<List<DegradeRuleEntity>> ruleProvider;
    @Autowired
    @Qualifier("degradeRuleNacosPublisher")
    private DynamicRulePublisher<List<DegradeRuleEntity>> rulePublisher;
    /**-----修改结束-----**/

    @GetMapping("/rules.json")
    @AuthAction(PrivilegeType.READ_RULE)
    public Result<List<DegradeRuleEntity>> apiQueryMachineRules(String app, String ip, Integer port) {
        if (StringUtil.isEmpty(app)) {
            return Result.ofFail(-1, "app can't be null or empty");
        }
        if (StringUtil.isEmpty(ip)) {
            return Result.ofFail(-1, "ip can't be null or empty");
        }
        if (port == null) {
            return Result.ofFail(-1, "port can't be null");
        }
        try {
            /**-----修改开始-----**/
            //List<DegradeRuleEntity> rules = sentinelApiClient.fetchDegradeRuleOfMachine(app, ip, port);
            List<DegradeRuleEntity> rules = ruleProvider.getRules(app);
            /**-----修改结束-----**/
            rules = repository.saveAll(rules);
            return Result.ofSuccess(rules);
        } catch (Throwable throwable) {
            logger.error("queryApps error:", throwable);
            return Result.ofThrowable(-1, throwable);
        }
    }

    @PostMapping("/rule")
    @AuthAction(PrivilegeType.WRITE_RULE)
    public Result<DegradeRuleEntity> apiAddRule(@RequestBody DegradeRuleEntity entity) throws Exception {
        Result<DegradeRuleEntity> checkResult = checkEntityInternal(entity);
        if (checkResult != null) {
            return checkResult;
        }
        Date date = new Date();
        entity.setGmtCreate(date);
        entity.setGmtModified(date);
        try {
            entity = repository.save(entity);
        } catch (Throwable t) {
            logger.error("Failed to add new degrade rule, app={}, ip={}", entity.getApp(), entity.getIp(), t);
            return Result.ofThrowable(-1, t);
        }
        /**-----修改开始-----**/
        /*if (!publishRules(entity.getApp(), entity.getIp(), entity.getPort())) {
            logger.warn("Publish degrade rules failed, app={}", entity.getApp());
        }*/
        publishRules(entity.getApp());
        /**-----修改结束-----**/
        return Result.ofSuccess(entity);
    }

    @PutMapping("/rule/{id}")
    @AuthAction(PrivilegeType.WRITE_RULE)
    public Result<DegradeRuleEntity> apiUpdateRule(@PathVariable("id") Long id,
                                                     @RequestBody DegradeRuleEntity entity) throws Exception {
        if (id == null || id <= 0) {
            return Result.ofFail(-1, "id can't be null or negative");
        }
        DegradeRuleEntity oldEntity = repository.findById(id);
        if (oldEntity == null) {
            return Result.ofFail(-1, "Degrade rule does not exist, id=" + id);
        }
        entity.setApp(oldEntity.getApp());
        entity.setIp(oldEntity.getIp());
        entity.setPort(oldEntity.getPort());
        entity.setId(oldEntity.getId());
        Result<DegradeRuleEntity> checkResult = checkEntityInternal(entity);
        if (checkResult != null) {
            return checkResult;
        }

        entity.setGmtCreate(oldEntity.getGmtCreate());
        entity.setGmtModified(new Date());
        try {
            entity = repository.save(entity);
        } catch (Throwable t) {
            logger.error("Failed to save degrade rule, id={}, rule={}", id, entity, t);
            return Result.ofThrowable(-1, t);
        }
        /**-----修改开始-----**/
        /*if (!publishRules(entity.getApp(), entity.getIp(), entity.getPort())) {
            logger.warn("Publish degrade rules failed, app={}", entity.getApp());
        }*/
        publishRules(oldEntity.getApp());
        /**-----修改结束-----**/
        return Result.ofSuccess(entity);
    }

    @DeleteMapping("/rule/{id}")
    @AuthAction(PrivilegeType.DELETE_RULE)
    public Result<Long> delete(@PathVariable("id") Long id) throws Exception {
        if (id == null) {
            return Result.ofFail(-1, "id can't be null");
        }

        DegradeRuleEntity oldEntity = repository.findById(id);
        if (oldEntity == null) {
            return Result.ofSuccess(null);
        }

        try {
            repository.delete(id);
        } catch (Throwable throwable) {
            logger.error("Failed to delete degrade rule, id={}", id, throwable);
            return Result.ofThrowable(-1, throwable);
        }
        /**-----修改开始-----**/
        /*if (!publishRules(oldEntity.getApp(), oldEntity.getIp(), oldEntity.getPort())) {
            logger.warn("Publish degrade rules failed, app={}", oldEntity.getApp());
        }*/
        publishRules(oldEntity.getApp());
        /**-----修改结束-----**/
        return Result.ofSuccess(id);
    }

    /**-----修改开始-----**/
    private void publishRules(String app) throws Exception {
        List<DegradeRuleEntity> rules = repository.findAllByApp(app);
        rulePublisher.publish(app, rules);
    }
    /**-----修改结束-----**/

    private <R> Result<R> checkEntityInternal(DegradeRuleEntity entity) {
        if (StringUtil.isBlank(entity.getApp())) {
            return Result.ofFail(-1, "app can't be blank");
        }
        /**-----修改开始-----**/
        /*if (StringUtil.isBlank(entity.getIp())) {
            return Result.ofFail(-1, "ip can't be null or empty");
        }
        if (entity.getPort() == null || entity.getPort() <= 0) {
            return Result.ofFail(-1, "invalid port: " + entity.getPort());
        }*/
        /**-----修改结束-----**/
        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");
        }
        Double threshold = entity.getCount();
        if (threshold == null || threshold < 0) {
            return Result.ofFail(-1, "invalid threshold: " + threshold);
        }
        Integer recoveryTimeoutSec = entity.getTimeWindow();
        if (recoveryTimeoutSec == null || recoveryTimeoutSec <= 0) {
            return Result.ofFail(-1, "recoveryTimeout should be positive");
        }
        Integer strategy = entity.getGrade();
        if (strategy == null) {
            return Result.ofFail(-1, "circuit breaker strategy cannot be null");
        }
        if (strategy < CircuitBreakerStrategy.SLOW_REQUEST_RATIO.getType()
            || strategy > RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT) {
            return Result.ofFail(-1, "Invalid circuit breaker strategy: " + strategy);
        }
        if (entity.getMinRequestAmount()  == null || entity.getMinRequestAmount() <= 0) {
            return Result.ofFail(-1, "Invalid minRequestAmount");
        }
        if (entity.getStatIntervalMs() == null || entity.getStatIntervalMs() <= 0) {
            return Result.ofFail(-1, "Invalid statInterval");
        }
        if (strategy == RuleConstant.DEGRADE_GRADE_RT) {
            Double slowRatio = entity.getSlowRatioThreshold();
            if (slowRatio == null) {
                return Result.ofFail(-1, "SlowRatioThreshold is required for slow request ratio strategy");
            } else if (slowRatio < 0 || slowRatio > 1) {
                return Result.ofFail(-1, "SlowRatioThreshold should be in range: [0.0, 1.0]");
            }
        } else if (strategy == RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO) {
            if (threshold > 1) {
                return Result.ofFail(-1, "Ratio threshold should be in range: [0.0, 1.0]");
            }
        }
        return null;
    }
}

3.1.7 测试

重启sentinel-dashboard服务，进入到sentinel页面，发送http请求，使页面保持下面状态：

新增降级规则如下图：

查看nacos页面是否同步，如下图，已经出现此配置：

进行nacos修改，同步到sentinel中

发布后查看sentinel,查看此降级规则的详细，如下图，发现已经生效：