最新版sentinel监控数据源持久化与influxdb2的集成实现

最新推荐文章于 2024-08-01 20:44:39 发布
最新推荐文章于 2024-08-01 20:44:39 发布
阅读量2.9w 收藏 6
点赞数 1
分类专栏： Spring Cloud 文章标签： spring spring boot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hxx688/article/details/121411463
版权

1. 说明

Sentinel的实时监控数据， 默认是放在内存里面， 采用ConcurrentHashMap结构，只保留5分钟时间内的数据，不能满足实际生产中的监控需要， 这里我们进行二次开发改造。

改造使用的版本：

  1. Sentinel为1.8.X版本
  2. InfluxDB为2.X系列版本

2. Sentinel源码改造

下载Sentinel的源码， 修改sentinel-dashboard模块

在这里插入图片描述

创建包com.alibaba.csp.sentinel.dashboard.influxdb， 将修改的源码放在此包下：

  1. 创建InfluxDB的映射实体

    @Data
@Measurement(name = "sentinelInfo")
public class InfluxDBMetricEntity {

    @Column(name = "time")
    private Instant time;
    @Column(name = "gmtCreate", tag = true)
    private long gmtCreate;
    @Column(name = "gmtModified")
    private long gmtModified;

    /**
     * 监控信息的时间戳
     */
    @Column(name = "app", tag = true)
    private String app;
    @Column(name = "resource", tag = true)
    private String resource;
    @Column(name = "timestamp", tag = true)
    private long timestamp;
    @Column(name = "passQps", tag = true)
    private long passQps;//通过qps
    @Column(name = "successQps", tag = true)
    private long successQps;//成功qps
    @Column(name = "blockQps", tag = true)
    private long blockQps;//限流qps
    @Column(name = "_exceptionQps")
    private long exceptionQps;//异常qps

    /**
     * 所有successQps的rt的和
     */
    @Column(name = "rt", tag = true)
    private double rt;

    /**
     * 本次聚合的总条数
     */
    @Column(name = "count", tag = true)
    private int count;
    @Column(name = "resourceCode", tag = true)
    private int resourceCode;

}

    如果要将字段查询出来， 将tag属性设置为true。

  2. InfluxDB的配置类

    @Configuration
@Data
public class InfluxDBConfig {

    /**
     * influxdb连接URL
     */
    @Value("${spring.influx.url:''}")
    private String influxUrl;

    /**
     * influxdb的访问token权限
     */
    @Value("${spring.influx.token:''}")
    private String influxToken;

    /**
     * org组织名称
     */
    @Value("${spring.influx.org:''}")
    private String influxOrg;

    /**
     * bucket名称
     */
    @Value("${spring.influx.bucket:''}")
    private String influxBucket;


    /**
     * 初始化influx client
     * @return
     */
    @Bean
    public InfluxDBClient influxDBClient() {
        InfluxDBClient influxDBClient = InfluxDBClientFactory.create(influxUrl, influxToken.toCharArray(), influxOrg, influxBucket);
        return influxDBClient;
    }

    /**
     * 创建Write Api （负责写入）
     * @param influxDBClient
     * @return
     */
    @Bean
    public WriteApiBlocking writeApiBlocking (InfluxDBClient influxDBClient) {
        WriteApiBlocking writeApiBlocking = influxDBClient.getWriteApiBlocking();
        return writeApiBlocking;
    }

    /**
     * 创建Query Api （负责查询）
     * @param influxDBClient
     * @return
     */
    @Bean
    public QueryApi queryApi(InfluxDBClient influxDBClient) {
        QueryApi queryApi = influxDBClient.getQueryApi();
        return queryApi;
    }

}

    InfluxDB2.X与influxDB1.X的配置不一样， 不需要配置用户名和密码， 用TOKEN替代， 要增加org与bucket的配置。

    将InfluxDBClient注入Spring容器， 同时分别注入写入与查询的API操作接口。

  3. TOEKN的申请配置

    进入后台，创建TOKEN
    在这里插入图片描述

    再弹出界面， 选择对应的bucket容器
    在这里插入图片描述
    保存后， 会生成一个TOKEN， 点击复制 在这里插入图片描述

  4. 工程配置

    # influxdb连接地址
spring.influx.url=http://10.10.20.32:8086
# influxdb的访问token
spring.influx.token=ZkDPAq8B1XGlT08iT_ZnLFAmiPbndIvomyQ7XZJQtE09KEMJwwunrtExZ9TCcEicuQwRI3riCYGjcqnOLvFQyg==
# org组织名称
spring.influx.org=mirson
# bucket名称
spring.influx.bucket=sentinel_app

  5. InfluxDB的持久化实现

    InfluxDBMetricsRepository完整代码：

    package com.alibaba.csp.sentinel.dashboard.influxdb;

import com.alibaba.csp.sentinel.dashboard.datasource.entity.MetricEntity;
import com.alibaba.csp.sentinel.dashboard.influxdb.config.InfluxDBConfig;
import com.alibaba.csp.sentinel.dashboard.influxdb.entity.InfluxDBMetricEntity;
import com.alibaba.csp.sentinel.dashboard.repository.metric.MetricsRepository;
import com.alibaba.csp.sentinel.util.StringUtil;
import com.influxdb.client.InfluxDBClient;
import com.influxdb.client.QueryApi;
import com.influxdb.client.WriteApiBlocking;
import com.influxdb.client.domain.WritePrecision;
import com.influxdb.query.FluxRecord;
import com.influxdb.query.FluxTable;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.time.Instant;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Component("influxDBMetricsRepository")
public class InfluxDBMetricsRepository implements MetricsRepository<MetricEntity> {

    @Autowired
    private InfluxDBConfig influxDBConfig;

    @Autowired
    public WriteApiBlocking writeApiBlocking;

    @Autowired
    public InfluxDBClient influxDBClient;

    @Autowired
    public QueryApi queryApi;


    /**
     * 保存数据
     * @param metric metric data to save
     */
    @Override
    public synchronized void save(MetricEntity metric) {

        try {
            // 记录数据
            InfluxDBMetricEntity entity = new InfluxDBMetricEntity();
            BeanUtils.copyProperties(metric, entity, new String[]{"gmtCreate", "gmtModified", "timestamp"});
            entity.setResource(metric.getResource());
            entity.setGmtCreate(metric.getGmtCreate().getTime());
            entity.setGmtModified(metric.getGmtModified().getTime());
            entity.setTimestamp(metric.getTimestamp().getTime());
            entity.setPassQps(metric.getPassQps());
            entity.setSuccessQps(metric.getSuccessQps());
            entity.setBlockQps(metric.getBlockQps());
            entity.setExceptionQps(metric.getExceptionQps());
            entity.setRt(metric.getRt());
            entity.setCount(metric.getCount());
            entity.setResourceCode(metric.getResourceCode());
            entity.setTime(Instant.now());
            writeApiBlocking.writeMeasurement(WritePrecision.MS, entity);

        } catch (Exception e) {

            e.printStackTrace();
        }
    }

    /**
     * 批量保存
     * @param metrics metrics to save
     */
    @Override
    public synchronized void saveAll(Iterable<MetricEntity> metrics) {

        if (metrics == null) {
            return;
        }
        metrics.forEach(metric -> {

            save(metric);

        });
    }

    /**
     * 根据时间范围查询数据
     * @param app       application name for Sentinel
     * @param resource  resource name
     * @param startTime start timestamp
     * @param endTime   end timestamp
     * @return
     */
    @Override
    public synchronized List<MetricEntity> queryByAppAndResourceBetween(String app, String resource, long startTime, long endTime) {

        List<MetricEntity> results = new ArrayList<>();
        if (StringUtil.isBlank(app)) {

            return results;
        }

        // 根据APP和RESOURCE查询时间范围内的数据
        String flux = String.format("from(bucket:\"%s\") |> range(start: %s, stop: %s)"
                        + " |> filter(fn: (r) => (r[\"_measurement\"] == \"sentinelInfo\" and r[\"app\"] == \"%s\") and r[\"resource\"] == \"%s\")",
                influxDBConfig.getInfluxBucket(), startTime, endTime, app, resource);

        List<FluxTable> tables = queryApi.query(flux);
        for (FluxTable fluxTable : tables) {
            List<FluxRecord> records = fluxTable.getRecords();
            for (FluxRecord fluxRecord : records) {
                MetricEntity metricEntity = MetricEntity.copyOf(fluxRecord);
                results.add(metricEntity);
            }
        }

        return results;
    }


    @Override
    public synchronized List<String> listResourcesOfApp(String app) {

        List<String> results = new ArrayList<>();
        if (StringUtil.isBlank(app)) {

            return results;
        }
        //查询最近5分钟的指标(实时数据)
        String command = String.format("from(bucket:\"%s\") |> range(start: -5m)"
                        + " |> filter(fn: (r) => (r[\"_measurement\"] == \"sentinelInfo\" and r[\"app\"] == \"%s\") )",
                influxDBConfig.getInfluxBucket(), app);


        List<MetricEntity> influxResults = new ArrayList<>();

        // 查询
        List<FluxTable> tables = queryApi.query(command);
        for (FluxTable fluxTable : tables) {
            List<FluxRecord> records = fluxTable.getRecords();
            for (FluxRecord fluxRecord : records) {
                MetricEntity metricEntity = MetricEntity.copyOf(fluxRecord);
                influxResults.add(metricEntity);
            }
        }

        try {

            if (CollectionUtils.isEmpty(influxResults)) {
                return results;
            }
            Map<String, MetricEntity> resourceCount = new HashMap<>(32);
            for (MetricEntity metricEntity : influxResults) {
                String resource = metricEntity.getResource();
                if (resourceCount.containsKey(resource)) {
                    // 累加统计
                    MetricEntity oldEntity = resourceCount.get(resource);
                    oldEntity.addPassQps(metricEntity.getPassQps());
                    oldEntity.addRtAndSuccessQps(metricEntity.getRt(), metricEntity.getSuccessQps());
                    oldEntity.addBlockQps(metricEntity.getBlockQps());
                    oldEntity.addExceptionQps(metricEntity.getExceptionQps());
                    oldEntity.addCount(1);
                } else {

                    resourceCount.put(resource, metricEntity);
                }
            }
            //排序
            results = resourceCount.entrySet()
                    .stream()
                    .sorted((o1, o2) -> {
                        MetricEntity e1 = o1.getValue();
                        MetricEntity e2 = o2.getValue();
                        int t = e2.getBlockQps().compareTo(e1.getBlockQps());
                        if (t != 0) {

                            return t;
                        }
                        return e2.getPassQps().compareTo(e1.getPassQps());
                    })
                    .map(Map.Entry::getKey)
                    .collect(Collectors.toList());
        } catch (Exception e) {

            e.printStackTrace();
        }
        return results;
    }
}

  6. 需要改造的其他源码

    influxdb的持久化已经实现， 还需要修改相关调用的源码： 在这里插入图片描述

    1） MetricController的改动：

    将原来的内存存储改为influxdb接口进行存储：
    在这里插入图片描述

    2） MetricEntity改动后的完整源码：

    主要增加对象之间互相转换的接口（InfluxDBMetricEntity、FluxRecord）：

    package com.alibaba.csp.sentinel.dashboard.datasource.entity;

import com.alibaba.csp.sentinel.dashboard.influxdb.entity.InfluxDBMetricEntity;
import com.influxdb.query.FluxRecord;

import java.util.Date;

/**
 * @author leyou
 */
public class MetricEntity {
    private Long id;
    private Date gmtCreate;
    private Date gmtModified;
    private String app;
    /**
     * 监控信息的时间戳
     */
    private Date timestamp;
    private String resource;
    private Long passQps;
    private Long successQps;
    private Long blockQps;
    private Long exceptionQps;

    /**
     * summary rt of all success exit qps.
     */
    private double rt;

    /**
     * 本次聚合的总条数
     */
    private int count;

    private int resourceCode;

    /**
     * 对象转换（MetricEntity）
     * @param oldEntity
     * @return
     */
    public static MetricEntity copyOf(MetricEntity oldEntity) {
        MetricEntity entity = new MetricEntity();
        entity.setId(oldEntity.getId());
        entity.setGmtCreate(oldEntity.getGmtCreate());
        entity.setGmtModified(oldEntity.getGmtModified());
        entity.setApp(oldEntity.getApp());
        entity.setTimestamp(oldEntity.getTimestamp());
        entity.setResource(oldEntity.getResource());
        entity.setPassQps(oldEntity.getPassQps());
        entity.setBlockQps(oldEntity.getBlockQps());
        entity.setSuccessQps(oldEntity.getSuccessQps());
        entity.setExceptionQps(oldEntity.getExceptionQps());
        entity.setRt(oldEntity.getRt());
        entity.setCount(oldEntity.getCount());
        return entity;
    }

    /**
     * 对象转换（FluxRecord）
     * @param fluxRecord
     * @return
     */
    public static MetricEntity copyOf(FluxRecord fluxRecord) {
        MetricEntity entity = new MetricEntity();
        entity.setApp(toStr(fluxRecord.getValueByKey("app")));
        entity.setResource(toStr(fluxRecord.getValueByKey("resource")));
        entity.setBlockQps(toLongZero(fluxRecord.getValueByKey("blockQps")));
        entity.setCount(toInt(fluxRecord.getValueByKey("count")));
        entity.setExceptionQps(toLongZero(fluxRecord.getValueByKey("_exceptionQps")));
        entity.setGmtCreate(toDate(toLong(fluxRecord.getValueByKey("gmtCreate"))));
        entity.setGmtModified(toDate(toLong(fluxRecord.getValueByKey("gmtModified"))));
        entity.setPassQps(toLongZero(fluxRecord.getValueByKey("passQps")));
        entity.setSuccessQps(toLongZero(fluxRecord.getValueByKey("successQps")));
        entity.setRt(toDouble(fluxRecord.getValueByKey("rt")));
        entity.setTimestamp(toDate(toLong(fluxRecord.getValueByKey("timestamp"))));
        return entity;
    }

    /**
     * 对象转换（FluxRecord）
     * @param fluxRecord
     * @return
     */
    public static MetricEntity copyOf(InfluxDBMetricEntity fluxRecord) {
        MetricEntity entity = new MetricEntity();
        entity.setGmtCreate(toDate(fluxRecord.getGmtCreate()));
        entity.setGmtModified(toDate(fluxRecord.getGmtModified()));
        entity.setApp(fluxRecord.getApp());
        entity.setTimestamp(toDate(fluxRecord.getTimestamp()));
        entity.setResource(fluxRecord.getResource());
        entity.setPassQps(fluxRecord.getPassQps());
        entity.setBlockQps(fluxRecord.getBlockQps());
        entity.setSuccessQps(fluxRecord.getSuccessQps());
        entity.setExceptionQps(fluxRecord.getExceptionQps());
        entity.setRt(fluxRecord.getRt());
        entity.setCount(fluxRecord.getCount());
        return entity;
    }

    /**
     * 转换为时间
     * @param time
     * @return
     */
    private static Date toDate(Long time) {
        if(null != time) {
            return new Date(time);
        }
        return new Date();
    }


    /**
     * 转换为字符串
     *
     * @param obj
     * @return
     */
    private static String toStr(Object obj) {
        return String.valueOf(obj);
    }

    /**
     * 转为换双精度类型
     *
     * @param obj
     * @return
     */
    private static double toDouble(Object obj) {
        if (null != obj) {
            return Double.valueOf(toStr(obj));
        }
        return 0;
    }


    /**
     * 转换为长整形， 默认为0
     * @param obj
     * @return
     */
    private static Long toLongZero(Object obj) {
        if (null != obj) {
            return Long.valueOf(toStr(obj));
        }
        return 0L;
    }

    /**
     * 转换为长整型
     *
     * @param obj
     * @return
     */
    private static Long toLong(Object obj) {
        if (null != obj) {
            return Long.valueOf(toStr(obj));
        }
        return null;
    }

    /**
     * 转换为整型
     *
     * @param obj
     * @return
     */
    private static int toInt(Object obj) {
        if (null != obj) {
            return Integer.valueOf(toStr(obj));
        }
        return 0;
    }

    public synchronized void addPassQps(Long passQps) {
        this.passQps += passQps;
    }

    public synchronized void addBlockQps(Long blockQps) {
        this.blockQps += blockQps;
    }

    public synchronized void addExceptionQps(Long exceptionQps) {
        this.exceptionQps += exceptionQps;
    }

    public synchronized void addCount(int count) {
        this.count += count;
    }

    public synchronized void addRtAndSuccessQps(double avgRt, Long successQps) {
        this.rt += avgRt * successQps;
        this.successQps += successQps;
    }

    /**
     * {@link #rt} = {@code avgRt * successQps}
     *
     * @param avgRt      average rt of {@code successQps}
     * @param successQps
     */
    public synchronized void setRtAndSuccessQps(double avgRt, Long successQps) {
        this.rt = avgRt * successQps;
        this.successQps = successQps;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Date getGmtCreate() {
        return gmtCreate;
    }

    public void setGmtCreate(Date gmtCreate) {
        this.gmtCreate = gmtCreate;
    }

    public Date getGmtModified() {
        return gmtModified;
    }

    public void setGmtModified(Date gmtModified) {
        this.gmtModified = gmtModified;
    }

    public String getApp() {
        return app;
    }

    public void setApp(String app) {
        this.app = app;
    }

    public Date getTimestamp() {
        return timestamp;
    }

    public void setTimestamp(Date timestamp) {
        this.timestamp = timestamp;
    }

    public String getResource() {
        return resource;
    }

    public void setResource(String resource) {
        this.resource = resource;
        this.resourceCode = resource.hashCode();
    }

    public Long getPassQps() {
        return passQps;
    }

    public void setPassQps(Long passQps) {
        this.passQps = passQps;
    }

    public Long getBlockQps() {
        return blockQps;
    }

    public void setBlockQps(Long blockQps) {
        this.blockQps = blockQps;
    }

    public Long getExceptionQps() {
        return exceptionQps;
    }

    public void setExceptionQps(Long exceptionQps) {
        this.exceptionQps = exceptionQps;
    }

    public double getRt() {
        return rt;
    }

    public void setRt(double rt) {
        this.rt = rt;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public int getResourceCode() {
        return resourceCode;
    }

    public Long getSuccessQps() {
        return successQps;
    }

    public void setSuccessQps(Long successQps) {
        this.successQps = successQps;
    }

    @Override
    public String toString() {
        return "MetricEntity{" +
                "id=" + id +
                ", gmtCreate=" + gmtCreate +
                ", gmtModified=" + gmtModified +
                ", app='" + app + '\'' +
                ", timestamp=" + timestamp +
                ", resource='" + resource + '\'' +
                ", passQps=" + passQps +
                ", blockQps=" + blockQps +
                ", successQps=" + successQps +
                ", exceptionQps=" + exceptionQps +
                ", rt=" + rt +
                ", count=" + count +
                ", resourceCode=" + resourceCode +
                '}';
    }

}

    3） MetricFetcher的改动：

    将持久化接口改为influxdb进行存储：
    在这里插入图片描述

3. 集成验证

sentinel-dashboard也是一个spring boot服务， 这里直接将sentinel-dashboard自身接入Sentinel的管理。

  1. pom配置

    增加sentinel自动化配置依赖：

    <!-- Sentinel 限流组件 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    <version>2.2.6.RELEASE</version>
</dependency>

  2. 工程配置文件

    增加以下Sentinel的配置：

    spring.application.name=sentinel-dashboard
spring.cloud.sentinel.eager=true
spring.cloud.sentinel.transport.dashboard=127.0.0.1:8080

  3. 启动sentinel-dashboard

    进入后台，可以看到sentinel-dashboard已经成功接入，并且能够正常查看监控数据：
    在这里插入图片描述

  4. 进入influxdb监控后台查看数据

    通过对influxdb的查询，可以看到数据已正常记录：
    在这里插入图片描述

  5. 图形化展示

    通过influxdb的dashboard也是可以实现图形化的监控 在这里插入图片描述
    再做具体的监控配置：
    在这里插入图片描述

    图形化展示：
    在这里插入图片描述

    有了influxdb的数据， 我们也可以接入各种监控系统， 比如grafana, 这里就不再赘述。

4. 源码地址

完整源码， Github地址： https://github.com/mirson6/sentinel_modify

麦神-mirson
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
mysql datasource property_Sentinel数据源(datasource)扩展-数据库
weixin_39759995的博客
01-27 329
一、背景sentinel推模式源码中的数据源是可扩展的，源码中只有几种数据源：redis、Apollo、Nacos、Zookeeper等；image.png拉模式中只有一种image.png二、具体实现以mysql为例，作为数据库的数据源1、定义一个MysqlDataSource需要继承AutoRefreshDataSource，然后这是一个模板类，第一个参数表示从DataSource中读取的数据...
SpringBoot 2.0 + InfluxDB+ Sentinel 实时监控数据存储
不是太高的手的专栏
09-23 1438
点击▲关注 “爪哇笔记” 给公众号标星置顶更多精彩 第一时间直达前言阿里巴巴提供的控制台只是用于演示 Sentinel 的基本能力和工作流程，并没有依赖生产环境中所必...
阿里巴巴 Sentinel + InfluxDB + Chronograf 实现监控大屏
08-25
主要介绍了阿里巴巴 Sentinel + InfluxDB + Chronograf 实现监控大屏,本文通过实例代码给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
Sentinel dashboard持久化，持久化到nacos和数据库中（基于sentinel 1.8.2)
LeoHan
12-14 2917
我们知道，Sentinel dashboard默认是是没有持久化功能的，都是保存在内存中的，对于sentinel客户端同样如此，当在sentinel dashboard配置规则的时候，dashboard会获取对应应用配置的dashboard给应用传递消息的http，将规则通过HTTP请求发送给sentinel客户端，同样，sentinel客户端也是没有持久化的都是放在内存中的。 sentinel dashbord通过HTTP向sentinel客户端获取客户端的限流配置，而在dashboard更新配置之后则通
【2024】InfluxDB v2 介绍和安装使用（1）
最新发布
weixin_52315708的博客
08-01 1096
时序数据库全称为时间序列数据库。时间序列数据库主要用于指处理带时间标签（按照时间的顺序变化，即时间序列化）的数据，带时间标签的数据也称为时间序列数据。时序数据的兴起还是榜上了物联网的大风。物联网（Internet of Things，简称IOT）是指通过各种信息传感器实时采集任何需要管理设备的信息，并进行管理。物联网的基础数据具有数据量大、结构单一、时间属性强、查询简单等特点，传统的关系型数据库在面对物联网数据时，显得应对发力，基本上属于功能过剩但性能不足。
Sentinel-dashboard-X 实现Sentinel高可用及规则数据持久化
Morecans的专栏
10-20 692
对于流控规则持久化，社区比较流行采用nacos进行配置管理，但实际上nacos配置最终还是存储在mysql等数据库config_info表中。
sentinel学习第一章：sentinel数据持久化到influxdb，实现流控和服务降级规则持久化到nacos，并实现推模式将规则推送到服务
tansitao110的博客
12-30 425
首先说明为啥要写该博文，其实网上已经有很多相识文章，github上的sentinel文档也有相关说明，但是本人觉得太零散了，感觉写的不好，所以特此总结，让大家少踩点坑，一步到位。对过程不感兴趣的可以直接拉到底部获取已经配置好了的项目github地址 第一步：创建sentinel项目 去github上拉取sentinel源码（https://github.com/alibaba/Sentinel），如果嫌弃阿里开源的sentinel源码太多无用的其他项目也可以去码云上找个sentinel项目 第二步：数据持久
influxdb无法查询tag_面向物联网，UCloud 推出高性能时序数据库 UTSDB-InfluxDB
weixin_39725154的博客
10-27 150
你应该敬畏时间，因为那是一切的密码。—— 电影《星际穿越》近日，UCloud 新发布了一款时间序列数据库 UTSDB (UCloud TimeSeries Database) ，此次上线的 UTSDB-InfluxDB 版基于 InfluxDB v.1.7，完全兼容原生 InfluxDB 协议。后端存储接入 UCloud 自研的 Manul 统一存储，容量可动态扩充，最高可至数百 TB，并通过高效...
Sentinel 连接数据源
sinolover的专栏
12-27 1060
若要载入 Azure Sentinel，首先需要连接到数据源。Azure Sentinel 随附许多适用于 Microsoft 解决方案的现成可用的连接器，提供实时集成（包括 Microsoft 威胁防护解决方案）和 Microsoft 365 源（包括 Office 365、Azure AD、Azure ATP 和 Microsoft Cloud App Security，等等）。此外，内置...
sentinel数据持久化mysql_sentinel控制台监控数据持久化【InfluxDB】
weixin_31414515的博客
01-30 597
根据官方wiki文档，sentinel控制台的实时监控数据，默认仅存储 5 分钟以内的数据。如需持久化，需要定制实现相关接口。1.自行扩展实现 MetricsRepository 接口；2.注册成 Spring Bean 并在相应位置通过 @Qualifier 注解指定对应的 bean name 即可。本文使用时序数据库InfluxDB来进行持久化，从下载开始，一步步编写一个基于InfluxDB的...
influxdb 插入数据_SpringBoot 2.0 + InfluxDB+ Sentinel 实时监控数据存储
weixin_35196629的博客
12-30 157
前言阿里巴巴提供的控制台只是用于演示 Sentinel 的基本能力和工作流程，并没有依赖生产环境中所必需的组件，比如持久化的后端数据库、可靠的配置中心等。目前 Sentinel 采用内存态的方式存储监控和规则数据，监控最长存储时间为 5 分钟，控制台重启后数据丢失。企业版这里推荐一下阿里云的官方版，AHAS Sentinel 控制台 是 Sentinel 控制台的阿里云上版本，提供企业级的控制台服...
influxdb_demo.zip
11-22
InfluxDB（时序数据库），常用的一种使用场景：监控数据统计。每毫秒记录一下电脑内存的使用情况，然后就可以根据统计的数据，利用图形化界面（InfluxDB V1一般配合Grafana）制作内存使用情况的折线图； 可以理解为按时间记录一些数据（常用的监控数据、埋点统计数据等），然后制作图表做统计；
spring-metrics-jdbc:一个简单的 JDBC 支持的“MetricRepository”，它异步更新度量值
06-10
Spring-Metrics-JDBC 一个简单的 JDBC 支持的MetricRepository ，它异步更新度量值。 我们选择了这种方法，因为我们希望将所有指标聚合到我们的数据库中，并且不想在我们的集群中协调导出器。 仍然是一个概念验证
sentinel-mysql规则持久化，持久化规则数据至mysql，包含数据表结构，一键启动
12-29
此外，可能还需要配置规则持久化的相关参数，如开启规则持久化功能、设置数据源等。 `sentinel_dashboard.jar` 是 Sentinel 控制台的可执行文件，用于管理和监控应用的流量规则。当你运行这个 JAR 文件时，Sentinel...
sentinel-dashboard-plus:sentinel dashboard 升级,规则管理及推送持久化到Nacos、实时监控数据存储在ES
05-26
生产环境 sentinel dashboard的使用需改造几个特性：规则管理及推送持久化到Nacos、实时监控数据存储在ES、集成saas平台用户鉴权。 ​ 创建一个maven工程（sentinel-dashboard-plus），引入GitHub上开源的最新...
Sentinel-1.8.6-Nacos作为持久化数据源
03-21
在 Sentinel-1.8.6 版本中，Nacos 被引入作为持久化数据源，这使得 Sentinel 的配置和规则管理变得更加灵活和高效。Nacos 是阿里巴巴提供的一个分布式服务治理平台，它支持服务发现、配置管理和动态配置等功能。 在...
sentinel动态数据源接入
FourZeroZero's home
04-23 626
动态数据源接入apollo sentinel的配置规则通过map的数据结构存储的内存中，当服务器重启后，规则就会失效。所以需要将规则进行持久化存储。 部门中使用的配置中心是apollo，并且apollo具有监听配置变化事件的功能。 改造sentinel-dashboard 创建修改规则推送到apollo 实现DynamicRulePublisher，通过apollo的openapi接口实现配置项的操作。核心代码如下： // 创建或者更新配置项 String flowDataId = Apoll
SENTINEL-sentinel实时监控持久化到InfluxDB中
飞翔的肥仔
04-01 2473
官网解析： 在生产环境中使用 Sentinel 监控 Sentinel 会记录资源访问的秒级数据（若没有访问则不进行记录）并保存在本地日志中，具体格式请见 秒级监控日志文档。Sentinel 控制台可以通过 Sentinel 客户端预留的 HTTP API 从秒级监控日志中拉取监控数据，并进行聚合。 目前 Sentinel 控制台中监控数据聚合后直接存在内存中，未进行持久化，且仅保留最近 5 分钟...
【sentinel dashboard改造，数据源为zk】
大勺哥的博客
12-08 394
改造sentinel dashboard，支持zk数据源数据保存，应用通过zk拉取流控规则数据
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

麦神-mirson

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值