# sentinel-dashboard-nacos

**Repository Path**: luojian8848/sentinel-dashboard-nacos

## Basic Information

- **Project Name**: sentinel-dashboard-nacos
- **Description**: Sentinel数据源永久化到Nacos，源码改造，当前版本1.8.6
- **Primary Language**: Unknown
- **License**: MulanPSL-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 2
- **Created**: 2023-07-31
- **Last Updated**: 2023-07-31

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Sentinel数据持久化到Nacos，源码改造

- 下载 [Sentinel源码](https://github.com/alibaba/Sentinel)
- module目录：sentinel-dashboard
- 改造版本：1.8.6

# 改造结果
![sentinel_nocas_config.png](https://img.huiyong.online/blogDetail/U202111250003/1675339830627sentinel_nocas_config.png)
# 一、文件拷贝进项目
```
com.alibaba.csp.sentinel.dashboard.rule
└─nacos
    │  NacosConfig.java
    │  NacosConfigUtil.java
    │
    ├─authority
    │      AuthorityRuleNacosProvider.java
    │      AuthorityRuleNacosPublisher.java
    │
    ├─degrade
    │      DegradeRuleNacosProvider.java
    │      DegradeRuleNacosPublisher.java
    │
    ├─flow
    │      FlowRuleNacosProvider.java
    │      FlowRuleNacosPublisher.java
    │
    ├─gateway
    │  ├─api
    │  │      GatewayApiNacosProvider.java
    │  │      GatewayApiNacosPublisher.java
    │  │
    │  └─flow
    │          GatewayFlowRuleNacosProvider.java
    │          GatewayFlowRuleNacosPublisher.java
    │
    ├─param
    │      ParamFlowRuleNacosProvider.java
    │      ParamFlowRuleNacosPublisher.java
    │
    └─system
            SystemRuleNacosProvider.java
            SystemRuleNacosPublisher.java
```
# 二、改造变动
## 1、依赖改动
### 1.1、sentinel-dashboard下的pom.xml，新增依赖
```
        <dependency>
            <groupId>com.alibaba.nacos</groupId>
            <artifactId>nacos-api</artifactId>
            <version>1.4.2</version>
        </dependency>
```
### 1.2、 移除 sentinel-datasource-nacos依赖的test
```
        <dependency>
            <groupId>com.alibaba.csp</groupId>
            <artifactId>sentinel-datasource-nacos</artifactId>
            <!--<scope>test</scope>-->
        </dependency>
```
## 2、规则改造
## 2.1、流控规则改造
### 2.1.1、sidebar.html改造
```
          <li ui-sref-active="active" ng-if="!entry.isGateway">
            <a ui-sref="dashboard.flowV1({app: entry.app})">
              <i class="glyphicon glyphicon-filter"></i>&nbsp;&nbsp;流控规则</a>
          </li>

改为

          <li ui-sref-active="active" ng-if="!entry.isGateway">
            <a ui-sref="dashboard.flow({app: entry.app})">
              <i class="glyphicon glyphicon-filter"></i>&nbsp;&nbsp;流控规则</a>
          </li>
```

### 2.1.2、修改"flowRuleDefaultProvider"与"flowRuleDefaultPublisher"
```
@RestController
@RequestMapping(value = "/v2/flow")
public class FlowControllerV2 {

    ...
    //@Autowired
    //private InMemoryRuleRepositoryAdapter<FlowRuleEntity> repository;
    @Autowired
    private RuleRepository<FlowRuleEntity, Long> repository;
    @Autowired
    // @Qualifier("flowRuleDefaultProvider")
    @Qualifier("flowRuleNacosProvider")
    private DynamicRuleProvider<List<FlowRuleEntity>> ruleProvider;
    @Autowired
    // @Qualifier("flowRuleDefaultPublisher")
    @Qualifier("flowRuleNacosPublisher")
    private DynamicRulePublisher<List<FlowRuleEntity>> rulePublisher;
    
    ...
    
```

## 2.2、熔断规则改造
```
public class DegradeController {

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

    @Autowired
    @Qualifier("degradeRuleNacosProvider")
    private DynamicRuleProvider<List<DegradeRuleEntity>> ruleProvider;
    @Autowired
    @Qualifier("degradeRuleNacosPublisher")
    private DynamicRulePublisher<List<DegradeRuleEntity>> rulePublisher;
    //@Autowired
    //private SentinelApiClient sentinelApiClient;

    ...
    
    @GetMapping("/rules.json")
    @AuthAction(PrivilegeType.READ_RULE)
    public Result<List<DegradeRuleEntity>> apiQueryMachineRules(String app, String ip, Integer port) {
        ...
            // List<DegradeRuleEntity> rules = sentinelApiClient.fetchDegradeRuleOfMachine(app, ip, port);
            List<DegradeRuleEntity> rules = ruleProvider.getRules(app);
        ...
    }
    
    
    private boolean publishRules(String app, String ip, Integer port) {
        //List<DegradeRuleEntity> rules = repository.findAllByMachine(MachineInfo.of(app, ip, port));
        //return sentinelApiClient.setDegradeRuleOfMachine(app, ip, port, rules);
        List<DegradeRuleEntity> rules = repository.findAllByApp(app);
        try {
            rulePublisher.publish(app, rules);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
```

## 2.3、热点规则改造
```
public class ParamFlowRuleController {

    ...
    
    @Autowired
    @Qualifier("paramFlowRuleNacosProvider")
    private DynamicRuleProvider<List<ParamFlowRuleEntity>> ruleProvider;
    @Autowired
    @Qualifier("paramFlowRuleNacosPublisher")
    private DynamicRulePublisher<List<ParamFlowRuleEntity>> rulePublisher;
    //@Autowired
    //private SentinelApiClient sentinelApiClient;
    
    @GetMapping("/rules")
    @AuthAction(PrivilegeType.READ_RULE)
    public Result<List<ParamFlowRuleEntity>> apiQueryAllRulesForMachine(@RequestParam String app,
                                                                        @RequestParam String ip,
                                                                        @RequestParam Integer port) {
        ...
            //return sentinelApiClient.fetchParamFlowRulesOfMachine(app, ip, port)
            //    .thenApply(repository::saveAll)
            //    .thenApply(Result::ofSuccess)
            //    .get();
            List<ParamFlowRuleEntity> rules = ruleProvider.getRules(app);
            rules = repository.saveAll(rules);
            return Result.ofSuccess(rules);            
        ...
    }
    
    @PostMapping("/rule")
    @AuthAction(AuthService.PrivilegeType.WRITE_RULE)
    public Result<ParamFlowRuleEntity> apiAddParamFlowRule(@RequestBody ParamFlowRuleEntity entity) {
        ...
            //publishRules(entity.getApp(), entity.getIp(), entity.getPort()).get();
            publishRules(entity.getApp(), entity.getIp(), entity.getPort());
        ...
    }    
        
    ...
    
    @PutMapping("/rule/{id}")
    @AuthAction(AuthService.PrivilegeType.WRITE_RULE)
    public Result<ParamFlowRuleEntity> apiUpdateParamFlowRule(@PathVariable("id") Long id,
                                                              @RequestBody ParamFlowRuleEntity entity) {
        ...
            entity = repository.save(entity);
            //publishRules(entity.getApp(), entity.getIp(), entity.getPort()).get();
            publishRules(entity.getApp(), entity.getIp(), entity.getPort());
        ...
    }
                
    ...
    
    @DeleteMapping("/rule/{id}")
    @AuthAction(PrivilegeType.DELETE_RULE)
    public Result<Long> apiDeleteRule(@PathVariable("id") Long id) {
        ...
            //publishRules(oldEntity.getApp(), oldEntity.getIp(), oldEntity.getPort()).get();
            publishRules(oldEntity.getApp(), oldEntity.getIp(), oldEntity.getPort());
        ...
    }    
    
    ...
            
//    private CompletableFuture<Void> publishRules(String app, String ip, Integer port) {
//        List<ParamFlowRuleEntity> rules = repository.findAllByMachine(MachineInfo.of(app, ip, port));
//        return sentinelApiClient.setParamFlowRuleOfMachine(app, ip, port, rules);
//    }
    private void publishRules(String app, String ip, Integer port) throws Exception {
        List<ParamFlowRuleEntity> rules = repository.findAllByApp(app);
        rulePublisher.publish(app, rules);
    }
}
```

## 2.4、系统规则改造
```
public class SystemController {
    
    ...
    
    @Autowired
    @Qualifier("systemRuleNacosProvider")
    private DynamicRuleProvider<List<SystemRuleEntity>> ruleProvider;
    @Autowired
    @Qualifier("systemRuleNacosPublisher")
    private DynamicRulePublisher<List<SystemRuleEntity>> rulePublisher;
    //@Autowired
    //private SentinelApiClient sentinelApiClient;
    
    @GetMapping("/rules.json")
    @AuthAction(PrivilegeType.READ_RULE)
    public Result<List<SystemRuleEntity>> apiQueryMachineRules(String app, String ip,
                                                               Integer port) {
        ...
            //List<SystemRuleEntity> rules = sentinelApiClient.fetchSystemRuleOfMachine(app, ip, port);
            List<SystemRuleEntity> rules = ruleProvider.getRules(app);
        ...
    }
    
    private boolean publishRules(String app, String ip, Integer port) {
        //List<SystemRuleEntity> rules = repository.findAllByMachine(MachineInfo.of(app, ip, port));
        //return sentinelApiClient.setSystemRuleOfMachine(app, ip, port, rules);
        List<SystemRuleEntity> rules = repository.findAllByApp(app);
        try {
            rulePublisher.publish(app, rules);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
```

## 2.5、授权规则改造
```
@RestController
@RequestMapping(value = "/authority")
public class AuthorityRuleController {

    ...

    @Autowired
    @Qualifier("authorityRuleNacosProvider")
    private DynamicRuleProvider<List<AuthorityRuleEntity>> ruleProvider;
    @Autowired
    @Qualifier("authorityRuleNacosPublisher")
    private DynamicRulePublisher<List<AuthorityRuleEntity>> rulePublisher;
//    @Autowired
//    private SentinelApiClient sentinelApiClient;

    ...
    
    @GetMapping("/rules")
    @AuthAction(PrivilegeType.READ_RULE)
    public Result<List<AuthorityRuleEntity>> apiQueryAllRulesForMachine(@RequestParam String app,
                                                                        @RequestParam String ip,
                                                                        @RequestParam Integer port) {
        ...
            //List<AuthorityRuleEntity> rules = sentinelApiClient.fetchAuthorityRulesOfMachine(app, ip, port);
            List<AuthorityRuleEntity> rules = ruleProvider.getRules(app);
        ...
    }
    
    private boolean publishRules(String app, String ip, Integer port) {
        //List<AuthorityRuleEntity> rules = repository.findAllByMachine(MachineInfo.of(app, ip, port));
        //return sentinelApiClient.setAuthorityRuleOfMachine(app, ip, port, rules);
        List<AuthorityRuleEntity> rules = repository.findAllByApp(app);
        try {
            rulePublisher.publish(app, rules);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }    

```

## 2.6 gateway api分组改造
```
public class GatewayApiController {

    ...

    @Autowired
    @Qualifier("gatewayApiGroupNacosProvider")
    private DynamicRuleProvider<List<ApiDefinitionEntity>> ruleProvider;
    @Autowired
    @Qualifier("gatewayApiGroupNacosPublisher")
    private DynamicRulePublisher<List<ApiDefinitionEntity>> rulePublisher;
//    @Autowired
//    private SentinelApiClient sentinelApiClient;

    @GetMapping("/list.json")
    @AuthAction(AuthService.PrivilegeType.READ_RULE)
    public Result<List<ApiDefinitionEntity>> queryApis(String app, String ip, Integer port) {
        ...
            //List<ApiDefinitionEntity> apis = sentinelApiClient.fetchApis(app, ip, port).get();
            List<ApiDefinitionEntity> apis = ruleProvider.getRules(app);
            repository.saveAll(apis);
        ...
    }
    
    private boolean publishApis(String app, String ip, Integer port) {
        //List<ApiDefinitionEntity> apis = repository.findAllByMachine(MachineInfo.of(app, ip, port));
        //return sentinelApiClient.modifyApis(app, ip, port, apis);
        List<ApiDefinitionEntity> rules = repository.findAllByApp(app);
        try {
            rulePublisher.publish(app, rules);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }    
}
```

## 2.7 gateway 流控规则改造
```
public class GatewayFlowRuleController {
    
    ...

    @Autowired
    private InMemGatewayFlowRuleStore repository;
    @Autowired
    @Qualifier("gatewayFlowRuleNacosProvider")
    private DynamicRuleProvider<List<GatewayFlowRuleEntity>> ruleProvider;
    @Autowired
    @Qualifier("gatewayFlowRuleNacosPublisher")
    private DynamicRulePublisher<List<GatewayFlowRuleEntity>> rulePublisher;
//    @Autowired
//    private SentinelApiClient sentinelApiClient;

    @GetMapping("/list.json")
    @AuthAction(AuthService.PrivilegeType.READ_RULE)
    public Result<List<GatewayFlowRuleEntity>> queryFlowRules(String app, String ip, Integer port) {
        ...
            //List<GatewayFlowRuleEntity> rules = sentinelApiClient.fetchGatewayFlowRules(app, ip, port).get();
            List<GatewayFlowRuleEntity> rules = ruleProvider.getRules(app);
            repository.saveAll(rules);        
        ...
    }
    
    private boolean publishRules(String app, String ip, Integer port) {
        // List<GatewayFlowRuleEntity> rules = repository.findAllByMachine(MachineInfo.of(app, ip, port));
        // return sentinelApiClient.modifyGatewayFlowRules(app, ip, port, rules);
        List<GatewayFlowRuleEntity> rules = repository.findAllByApp(app);
        try {
            rulePublisher.publish(app, rules);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }   
}
```

三、添加application.properties配置
```
server.port=8080
nacos.server-addr=127.0.0.1:8848
nacos.namespace=public
nacos.group=DEFAULT_GROUP
nacos.username=nacos
nacos.password=nacos
```

四、自动填充账号密码
- id="username"
- id="password"
```
    <label class="col-md-2 control-label">用户</label>
    <div class="col-md-9">
        <input class="form-control" id="username" type="text" ng-model="username" autofocus="autofocus" required/>
    </div>
    
    <label class="col-md-2 control-label">密码</label>
    <div class="col-md-9">
        <input class="form-control" id="password" type="password" ng-model="password" />
    </div>                    
```

五、 SpringCloud Sentinel 配置
```
spring:
  cloud:
    # 配置Sentinel流控
    sentinel:
      namespace: Sentinel-Dev
      enabled: true # 自动化配置是否生效
      eager: true   # 禁用控制台懒加载
      transport:
        dashboard: localhost:20010  #配置Sentinel dashboard地址
        client-ip: ${spring.cloud.client.ip-address} # 获取本机IP地址
        port: 8719  #默认8719端口,如果被占用会向上扫描。
      # Nacos 持久化配置规则
      datasource:
        # rule-type类型在com.alibaba.cloud.sentinel.datasource.RuleType 中查找
        # gateway APi 分组
        gw-api-group:
          nacos:
            server-addr: ${spring.cloud.nacos.config.server-addr}
            username: ${spring.cloud.nacos.config.username}
            password: ${spring.cloud.nacos.config.password}
            namespace: ${spring.cloud.sentinel.namespace}
            group-id: DEFAULT_GROUP
            data-id: ${spring.application.name}-gw-api-group-rules
            rule-type: gw-api-group
        # gateway 流控规则
        gw-flow:
          nacos:
            server-addr: ${spring.cloud.nacos.config.server-addr}
            username: ${spring.cloud.nacos.config.username}
            password: ${spring.cloud.nacos.config.password}
            namespace: ${spring.cloud.sentinel.namespace}
            group-id: DEFAULT_GROUP
            data-id: ${spring.application.name}-gw-flow-rules
            rule-type: gw-flow
        # 流控规则
        flow:
          nacos:
            server-addr: ${spring.cloud.nacos.config.server-addr}
            username: ${spring.cloud.nacos.config.username}
            password: ${spring.cloud.nacos.config.password}
            namespace: ${spring.cloud.sentinel.namespace}
            group-id: DEFAULT_GROUP
            data-id: ${spring.application.name}-flow-rules
            rule-type: flow
        # 熔断降级
        degrade:
          nacos:
            server-addr: ${spring.cloud.nacos.config.server-addr}
            username: ${spring.cloud.nacos.config.username}
            password: ${spring.cloud.nacos.config.password}
            namespace: ${spring.cloud.sentinel.namespace}
            group-id: DEFAULT_GROUP
            data-id: ${spring.application.name}-degrade-rules
            rule-type: degrade
        # 热点规则
        param-flow:
          nacos:
            server-addr: ${spring.cloud.nacos.config.server-addr}
            username: ${spring.cloud.nacos.config.username}
            password: ${spring.cloud.nacos.config.password}
            namespace: ${spring.cloud.sentinel.namespace}
            group-id: DEFAULT_GROUP
            data-id: ${spring.application.name}-param-flow-rules
            rule-type: param-flow
        # 系统规则
        system:
          nacos:
            server-addr: ${spring.cloud.nacos.config.server-addr}
            username: ${spring.cloud.nacos.config.username}
            password: ${spring.cloud.nacos.config.password}
            namespace: ${spring.cloud.sentinel.namespace}
            group-id: DEFAULT_GROUP
            data-id: ${spring.application.name}-system-rules
            rule-type: system
        # 授权规则
        authority:
          nacos:
            server-addr: ${spring.cloud.nacos.config.server-addr}
            username: ${spring.cloud.nacos.config.username}
            password: ${spring.cloud.nacos.config.password}
            namespace: ${spring.cloud.sentinel.namespace}
            group-id: DEFAULT_GROUP
            data-id: ${spring.application.name}-authority-rules
            rule-type: authority
```