AI 助理
备案控制台
开发者社区 数据库 文章 正文

spring boot +RabbitMQ +InfluxDB+Grafara监控实践

2018-07-23 2851
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 本文需要有相关spring boot 或spring cloud 相关微服务框架的基础，如果您具备相关基础可以很容易的实现下述过程!!!!!!!　　希望本文的所说对需要的您有所帮助　　从这里我们开始进入闲聊阶段。

本文需要有相关spring boot 或spring cloud 相关微服务框架的基础，如果您具备相关基础可以很容易的实现下述过程!!!!!!!

　　希望本文的所说对需要的您有所帮助

　　从这里我们开始进入闲聊阶段。

　　大家都知道 spring boot整合了很多很多的第三方框架，我们这里就简单讨论和使用 性能监控和JVM监控相关的东西。其他的本文不讨论虽然有些关联，所以开篇有说需要有相关spring boot框架基础说了这么多废话，下面真正进入主题。

　　这里首先给大家看下整体的数据流程图，其中两条主线一条是接口或方法性能监控数据收集，还有一条是spring boot 微服务JVM相关指标数据采集，最后都汇总到InfluxDB时序数据库中在用数据展示工具Grafara进行数据展示或报警。

　　

 

 

　　〇、基础服务

　　　　基础服务比较多，其中包括RabbitMQ，Eureka注册中心，influxDB，Grafara（不知道这些东西 请百度或谷歌一下了解相关知识），下面简单说下各基础服务的功能：

　　　　　　RabbitMQ 一款很流行的消息中间件，主要用它来收集spring boot应用监控性能相关信息，为什么是RabbitMQ而不是什么别的 kafka等等，因为测试方便性能也够用，spring boot整合的够完善。

　　　　　　Eureka 注册中心，一般看过或用过spring cloud相关框架的都知道spring cloud注册中心主要推荐使用Eureka！至于为什么不做过多讨论不是本文主要讨论的关注点。本文主要用来同步和获取注册到注册中心的应用的相关信息。

　　　　　　InfluxDB和Grafara为什么选这两个，其他方案如 ElasticSearch 、Logstash 、Kibana，ELK的组合等！原因很显然 influxDB是时序数据库数据的压缩比率比其他（ElasticSearch ）好的很多（当然本人没有实际测试过都是看一些文档）。同时InfluxDB使用SQL非常类似mysql等关系型数据库入门方便，Grafara工具可预警。等等！！！！！！！！！！！

　　　　　　好了工具就简单介绍到这里，至于这些工具怎么部署搭建请搭建先自行找资料学习，还是因为不是本文重点介绍的内容，不深入讨论。如果有docker相关基础的童鞋可以直接下载个镜像启动起来做测试使用（本人就是使用docker启动的上面的基础应用（Eureka除外））

　　一、被监控的应用

　　　　这里不多说被监控应用肯定是spring boot项目但是要引用一下相关包和相关注解以及修改相关配置文件

　　　　包引用，这些包是必须引用的

　　　　

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-sleuth-zipkin-stream</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix</artifactId>
        </dependency>

　　　　　　简单说下呢相关包的功能spring-cloud-starter-netflix-eureka-client用于注册中心使用的包，spring-cloud-starter-stream-rabbit 发送RabbitMQ相关包，spring-boot-starter-actuator发布监控相关rest接口包，

　　　　　　spring-cloud-starter-hystrix熔断性能监控相关包。
　　　　　　
　　　　　　相关注解
@EnableHystrix//开启性能监控
@RefreshScope//刷新配置文件 与本章无关
@EnableAutoConfiguration
@EnableFeignClients//RPC调用与本章无关
@RestController
@SpringBootApplication
public class ServerTestApplication {
    protected final static Logger logger = LoggerFactory.getLogger(ServerTestApplication.class);

    public static void main(String[] args) {
        SpringApplication.run(ServerTestApplication.class, args);
    }
}

　　　　配置文件相关

hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds: 60000
hystrix.threadpool.default.coreSize: 100
spring:
  application:
    name: spring-cloud-server2-test
  rabbitmq:
    host: 10.10.12.21
    port: 5672
    username: user
    password: password

encrypt:
  failOnError: false
server:
  port: 8081
eureka:
  instance:
    appname: spring-cloud-server2-test
    prefer-ip-address: true
  client: 
    serviceUrl:
      defaultZone: http://IP:PORT/eureka/#注册中心地址
    eureka-server-total-connections-per-host: 500
endpoints:
  refresh:
    sensitive: false
  metrics:
    sensitive: false
  dump:
    sensitive: false
  auditevents:
    sensitive: false
  features:
    sensitive: false
  mappings:
    sensitive: false
  trace:
    sensitive: false
  autoconfig:
    sensitive: false
  loggers:
    sensitive: false
View Code

　　　　简单解释一下endpoints下面相关配置，主要就是 原来这些路径是需要授权访问的，通过配置让这些路径接口不再是敏感的需要授权访问的接口这应我们就可以轻松的访问注册到注册中心的每个服务的响应的接口。这里插一句接口性能需要在方法上面加上如下类似相关注解，然后才会有相关性能数据输出

　　@Value("${name}")
    private String name;
    
    @HystrixCommand(commandProperties = {
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "20000") }, threadPoolProperties = {
                    @HystrixProperty(name = "coreSize", value = "64") }, threadPoolKey = "test1")
    @GetMapping("/testpro1")
    public String getStringtest1(){
        
        return name;
    }
　　好了到这里你的应用基本上就具备相关性能输出的能力了。你可以访问

　　如果是上图的接口 你的应用基本OK，为什么是基本因为你截图没有体现性能信息发送RabbitMQ的相关信息。这个需要看日志，加入你失败了评论区在讨论。我们先关注主线。

　　好的spring boot 应用就先说道这里。开始下一主题

 

　　二、性能指标数据采集
 

　　　　刚才访问http://IP:port/hystrix.stream这个显示出来的信息就是借口或方法性能相关信息的输出，如果上面都没有问题的话数据应该发送到了RabbitMQ上面了我们直接去RabbitMQ上面接收相关数据就可以了。
 

　　　　性能指标数据的采集服务主要应用以下包
 

 
 
　　　　　<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.github.miwurster/spring-data-influxdb -->
        <dependency>
            <groupId>org.influxdb</groupId>
            <artifactId>influxdb-java</artifactId>
            <version>2.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
 

 

　　　　直接贴代码
 

 
 
 
 
 
  
package application;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 
 * @author zyg
 *
 */
@SpringBootApplication
public class RabbitMQApplication {

    public static void main(String[] args) {
        SpringApplication.run(RabbitMQApplication.class, args);
    }

}
 
 
 
 View Code 

 

 
 
 
 
 
  
package application;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;    

/**
 * 
 * @author zyg
 *
 */
@Configuration
public class RabbitMQConfig {
    public final static String QUEUE_NAME = "spring-boot-queue";
    public final static String EXCHANGE_NAME = "springCloudHystrixStream";
    public final static String ROUTING_KEY = "#";

    // 创建队列
    @Bean
    public Queue queue() {
        return new Queue(QUEUE_NAME);
    }

    // 创建一个 topic 类型的交换器
    @Bean
    public TopicExchange exchange() {
        return new TopicExchange(EXCHANGE_NAME);
    }

    // 使用路由键（routingKey）把队列（Queue）绑定到交换器（Exchange）
    @Bean
    public Binding binding(Queue queue, TopicExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(ROUTING_KEY);
    }

    @Bean
    public ConnectionFactory connectionFactory() {
        //rabbitmq IP 端口号
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory("IP", 5672);
        connectionFactory.setUsername("user");
        connectionFactory.setPassword("password");
        return connectionFactory;
    }

    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        return new RabbitTemplate(connectionFactory);
    }
}
 
 
 
 View Code 

 

 
 
 
 
 
  
package application;

import java.util.Map;
import java.util.concurrent.TimeUnit;

import org.influxdb.InfluxDB;
import org.influxdb.InfluxDBFactory;
import org.influxdb.dto.Point;
import org.influxdb.dto.Point.Builder;
import org.influxdb.dto.Query;
import org.influxdb.dto.QueryResult;

/**
 * 
 * @author zyg
 *
 */
public class InfluxDBConnect {
    private String username;// 用户名
    private String password;// 密码
    private String openurl;// 连接地址
    private String database;// 数据库

    private InfluxDB influxDB;

    public InfluxDBConnect(String username, String password, String openurl, String database) {
        this.username = username;
        this.password = password;
        this.openurl = openurl;
        this.database = database;
    }

    /** 连接时序数据库；获得InfluxDB **/
    public InfluxDB influxDbBuild() {
        if (influxDB == null) {
            influxDB = InfluxDBFactory.connect(openurl, username, password);
            influxDB.createDatabase(database);

        }
        return influxDB;
    }

    /**
     * 设置数据保存策略 defalut 策略名 /database 数据库名/ 30d 数据保存时限30天/ 1 副本个数为1/ 结尾DEFAULT
     * 表示 设为默认的策略
     */
    public void createRetentionPolicy() {
        String command = String.format("CREATE RETENTION POLICY \"%s\" ON \"%s\" DURATION %s REPLICATION %s DEFAULT",
                "defalut", database, "30d", 1);
        this.query(command);
    }

    /**
     * 查询
     * 
     * @param command
     *            查询语句
     * @return
     */
    public QueryResult query(String command) {
        return influxDB.query(new Query(command, database));
    }

    /**
     * 插入
     * 
     * @param measurement
     *            表
     * @param tags
     *            标签
     * @param fields
     *            字段
     */
    public void insert(String measurement, Map<String, String> tags, Map<String, Object> fields) {
        Builder builder = Point.measurement(measurement);
        builder.time(((long)fields.get("currentTime"))*1000000, TimeUnit.NANOSECONDS);
        builder.tag(tags);
        builder.fields(fields);
        //
        influxDB.write(database, "", builder.build());
    }

    /**
     * 删除
     * 
     * @param command
     *            删除语句
     * @return 返回错误信息
     */
    public String deleteMeasurementData(String command) {
        QueryResult result = influxDB.query(new Query(command, database));
        return result.getError();
    }

    /**
     * 创建数据库
     * 
     * @param dbName
     */
    public void createDB(String dbName) {
        influxDB.createDatabase(dbName);
    }

    /**
     * 删除数据库
     * 
     * @param dbName
     */
    public void deleteDB(String dbName) {
        influxDB.deleteDatabase(dbName);
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getOpenurl() {
        return openurl;
    }

    public void setOpenurl(String openurl) {
        this.openurl = openurl;
    }

    public void setDatabase(String database) {
        this.database = database;
    }
}
 
 
 
 View Code 

 

 
 
 
 
 
  
package application;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 
 * @author zyg
 *
 */
@Configuration
public class InfluxDBConfiguration {
    
    private String username = "admin";//用户名
    private String password = "admin";//密码
    private String openurl = "http://IP:8086";//InfluxDB连接地址
    private String database = "test_db";//数据库
    
    @Bean
    public InfluxDBConnect getInfluxDBConnect(){
        InfluxDBConnect influxDB = new InfluxDBConnect(username, password, openurl, database);
        
        influxDB.influxDbBuild();
        
        influxDB.createRetentionPolicy();
        return influxDB;
    }
}
 
 
 
 View Code 

 

 
 
 
 
 
  
package application;

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * 
 * @author zyg
 *
 */
@Component
public class Consumer {
    protected final static Logger logger = LoggerFactory.getLogger(Consumer.class);

    private ObjectMapper objectMapper = new ObjectMapper();

    @Autowired
    private InfluxDBConnect influxDB;

    @RabbitListener(queues = RabbitMQConfig.QUEUE_NAME)
    public void sendToSubject(org.springframework.amqp.core.Message message) {

        String payload = new String(message.getBody());
        logger.info(payload);

        if (payload.startsWith("\"")) {
            // Legacy payload from an Angel client
            payload = payload.substring(1, payload.length() - 1);
            payload = payload.replace("\\\"", "\"");
        }
        try {
            if (payload.startsWith("[")) {
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> list = this.objectMapper.readValue(payload, List.class);
                for (Map<String, Object> map : list) {
                    sendMap(map);
                }
            } else {
                @SuppressWarnings("unchecked")
                Map<String, Object> map = this.objectMapper.readValue(payload, Map.class);
                sendMap(map);
            }
        } catch (IOException ex) {
            logger.error("Error receiving hystrix stream payload: " + payload, ex);
        }
    }

    private void sendMap(Map<String, Object> map) {
        Map<String, Object> data = getPayloadData(map);
        data.remove("latencyExecute");
        data.remove("latencyTotal");
        Map<String, String> tags = new HashMap<String, String>();
        
        tags.put("type", data.get("type").toString());
        tags.put("name", data.get("name").toString());
        tags.put("instanceId", data.get("instanceId").toString());
        //tags.put("group", data.get("group").toString());
        
        
        influxDB.insert("testaaa", tags, data);

        // for (String key : data.keySet()) {
        // logger.info("{}:{}",key,data.get(key));
        // }


    }

    public static Map<String, Object> getPayloadData(Map<String, Object> jsonMap) {
        @SuppressWarnings("unchecked")
        Map<String, Object> origin = (Map<String, Object>) jsonMap.get("origin");
        String instanceId = null;
        if (origin.containsKey("id")) {
            instanceId = origin.get("host") + ":" + origin.get("id").toString();
        }
        if (!StringUtils.hasText(instanceId)) {
            // TODO: instanceid template
            instanceId = origin.get("serviceId") + ":" + origin.get("host") + ":" + origin.get("port");
        }
        @SuppressWarnings("unchecked")
        Map<String, Object> data = (Map<String, Object>) jsonMap.get("data");
        data.put("instanceId", instanceId);
        return data;
    }

}
 
 
 
 View Code 

 

　　　　这里不多说，就是接收RabbitMQ信息然后保存到InfluxDB数据库中。
 

　　三、JVM相关数据采集
 

　　　　JVM相关数据采集非常简单主要思想就是定时轮训被监控服务的接口地址然后把返回信息插入到InfluxDB中
 

　　　　服务引用的包不多说这个服务是需要注册到注册中心Eureka中的因为需要获取所有服务的监控信息。
 

　　　　插入InfluxDB代码和上面基本类似只不过多了一个批量插入方法
 

　　　　
 

 
 
 
 
 
  
package com.zjs.collection;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

/**
 * 
 * @author zyg
 *
 */
@EnableEurekaClient
@SpringBootApplication
public class ApplictionCollection 
{
    public static void main(String[] args) {
        SpringApplication.run(ApplictionCollection.class, args);
    }
}
 
 
 
 View Code 

 

 
 
 
 
 
  
/**
     * 批量插入
     * 
     * @param measurement
     *            表
     * @param tags
     *            标签
     * @param fields
     *            字段
     */
    public void batchinsert(String measurement, Map<String, String> tags, List<Map<String, Object>> fieldslist) {
        org.influxdb.dto.BatchPoints.Builder batchbuilder=BatchPoints.database(database);

        for (Map<String, Object> map : fieldslist) {
            Builder builder = Point.measurement(measurement);
            tags.put("instanceId", map.get("instanceId").toString());
            builder.time((long)map.get("currentTime"), TimeUnit.NANOSECONDS);
            builder.tag(tags);
            builder.fields(map);
            batchbuilder.point(builder.build());
        }
        
        System.out.println(batchbuilder.build().toString());
        
        influxDB.write(batchbuilder.build());
    }
 
 
 
 View Code 

 

 
 
 
 
 
  
package com.zjs.collection;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.context.annotation.Bean;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;

/**
 * 获取微服务实例
 * 
 * @author zyg
 *
 */
@Component
@SpringBootApplication
@EnableScheduling
public class MicServerInstanceInfoHandle {

    protected final static Logger logger = LoggerFactory.getLogger(MicServerInstanceInfoHandle.class);

    final String pathtail = "/metrics/mem.*|heap.*|threads.*|gc.*|nonheap.*|classes.*";

    Map<String, String> tags;

    ThreadPoolExecutor threadpool;

    @Autowired
    DiscoveryClient dc;

    @Autowired
    RestTemplate restTemplate;

    final static LinkedBlockingQueue<Map<String, Object>> jsonMetrics = new LinkedBlockingQueue<>(1000);

    /**
     * 初始化实例 可以吧相关参数设置到配置文件
     */
    public MicServerInstanceInfoHandle() {
        
        tags = new HashMap<String, String>();
        threadpool = new ThreadPoolExecutor(4, 20, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(100));

    }

    @Autowired
    private InfluxDBConnect influxDB;

    /**
     * metrics数据获取
     */
    @Scheduled(fixedDelay = 2000)
    public void metricsDataObtain() {
        logger.info("开始获取metrics数据");
        List<String> servicelist = dc.getServices();
        for (String str : servicelist) {

            List<ServiceInstance> silist = dc.getInstances(str);

            for (ServiceInstance serviceInstance : silist) {
                threadpool.execute(new MetricsHandle(serviceInstance));
            }
        }
    }

    /**
     * 将数据插入到influxdb数据库
     */
    @Scheduled(fixedDelay = 5000)
    public void metricsDataToInfluxDB() {
        logger.info("开始批量将metrics数据insert-influxdb");
        ArrayList<Map<String, Object>> metricslist = new ArrayList<>();
        MicServerInstanceInfoHandle.jsonMetrics.drainTo(metricslist);

        if (!metricslist.isEmpty()) {
            logger.info("批量插入条数:{}", metricslist.size());
            influxDB.batchinsert("metrics", tags, metricslist);
        }

        logger.info("结束批量metrics数据insert");
    }

    @Bean
    public RestTemplate getRestTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        SimpleClientHttpRequestFactory achrf = new SimpleClientHttpRequestFactory();
        achrf.setConnectTimeout(10000);
        achrf.setReadTimeout(10000);
        restTemplate.setRequestFactory(achrf);
        return restTemplate;

    }

    class MetricsHandle extends Thread {
        
        private ServiceInstance serviceInstanc;
        
        public MetricsHandle(ServiceInstance serviceInstance){
            serviceInstanc=serviceInstance;
        }
        
        @Override
        public void run() {

            try {
                
                logger.info("获取  {}:{}:{} 应用metrics数据",serviceInstanc.getServiceId(),serviceInstanc.getHost(),serviceInstanc.getPort());
                
                @SuppressWarnings("unchecked")
                Map<String, Object> mapdata = restTemplate
                        .getForObject(serviceInstanc.getUri().toString() + pathtail, Map.class);
                mapdata.put("instanceId", serviceInstanc.getServiceId() + ":" + serviceInstanc.getHost() + ":"
                        + serviceInstanc.getPort());
                mapdata.put("type", "metrics");
                mapdata.put("currentTime", System.currentTimeMillis() * 1000000);
                MicServerInstanceInfoHandle.jsonMetrics.add(mapdata);

            } catch (Exception e) {
                logger.error("instanceId:{},host:{},port:{},path:{},exception:{}", serviceInstanc.getServiceId(),
                        serviceInstanc.getHost(), serviceInstanc.getPort(), serviceInstanc.getUri(),
                        e.getMessage());
            }
        }
    }

}
 
 
 
 View Code 

 

　　　　这里简单解释一下这句代码 final String pathtail = "/metrics/mem.*|heap.*|threads.*|gc.*|nonheap.*|classes.*"; ，metrics这个路径下的信息很多但是我们不是都需要所以我们需要有选择的获取这样节省流量和时间。上面关键类MicServerInstanceInfoHandle做了一个多线程访问主要应对注册中心有成百上千个服务的时候单线程可能轮序不过来，同时做了一个队列缓冲，批量插入到InfluxDB。
 

　　四、结果展示
 

　　
 

　　　　
 

　　如果你数据采集成功了就可以绘制出来上面的图形下面是对应的sql
 

　　
 

 
 
SELECT mean("rollingCountFallbackSuccess"), mean("rollingCountSuccess") FROM "testaaa" WHERE ("instanceId" = 'IP:spring-cloud-server1-test:8082' AND "type" = 'HystrixCommand') AND $timeFilter GROUP BY time($__interval) fill(null)

SELECT mean("currentPoolSize") FROM "testaaa" WHERE ("type" = 'HystrixThreadPool' AND "instanceId" = '10.10.12.51:spring-cloud-server1-test:8082') AND $timeFilter GROUP BY time($__interval) fill(null)
 

 

 
 
SELECT "heap", "heap.committed", "heap.used", "mem", "mem.free", "nonheap", "nonheap.committed", "nonheap.used" FROM "metrics" WHERE ("instanceId" = 'SPRING-CLOUD-SERVER1-TEST:10.10.12.51:8082') AND $timeFilter
 

 

　　好了到这里就基本结束了。
 

　　五、优化及设想
 

　　　　上面的基础服务肯定都是需要高可用的，毋庸置疑都是需要学习的。如果有时间我也会向大家一一介绍，大家亦可以去搜索相关资料查看！
 

　　　　可能有人问有一个叫telegraf的小插件直接就能收集相关数据进行聚合结果监控，
 

　　　　其实我之前也是使用的telegraf这个小工具但是发现一个问题，
 

　　　　就是每次被监控的应用重启的时候相关字段名就会变，
 

　　　　因为他采集使用的是类实例的名字作为字段名，这应我们会很不方便，每次重启应用我们都要重新设置sql语句这样非常不友好，
 

　　　　再次感觉收集数据编码难度不大所以自己就写了收集数据的代码！如果有哪位大神对telegraf比较了解可以解决上面我说的问题记得给我留言哦！在这里先感谢！
 

　　　　有些地方是需要优化的，比如一些IP端口什么的都是可以放到配置文件里面的。
 

　　　　还有一种想法就是我可不可以像收集性能信息一样直接应用来收集JVM信息让JVM相关信息直接发送到MQ当中然后再插入InfluxDB中
 

　　六、总结
 

　　　　从spring boot到现在短短的2、3年时间就迅速变得火爆，知识体系也变得完善，开发成本越来越低，
 

　　　　所以普及程度就越来越高，微服务虽然很好但是我们也要很好的善于运用，监控就是重要的一环，
 

　　　　试想一下你的机房运行着成千上万的服务，稳定运行和及时发现有问题的服务是多么重要的一件事情！
 

　　　　希望以上对大家有所帮助

                        
                    

                    
                        

                            

    
文章标签：

    

        

            云消息队列 MQ
        

        

            时序数据库
        

        

            Java
        

        

            监控
        

        

            Spring
        

        

            数据库
        

    



                            

    
关键词：

    

        

            Spring Boot实践
        

        

            Spring实践
        

        

            云消息队列 MQ实践
        

        

            Spring Boot监控
        

        

            Spring监控
        

    



                            
                        

                        

    
相关实践学习

    

        

            
消息队列RocketMQ版：基础消息收发功能体验

            

                
本实验场景介绍消息队列RocketMQ版的基础消息收发功能，涵盖实例创建、Topic、Group资源创建以及消息收发体验等基础功能模块。

                
            

        

        

            
消息队列 MNS 入门课程

            

                
1、消息队列MNS简介   本节课介绍消息队列的MNS的基础概念     2、消息队列MNS特性   本节课介绍消息队列的MNS的主要特性     3、MNS的最佳实践及场景应用   本节课介绍消息队列的MNS的最佳实践及场景应用案例     4、手把手系列：消息队列MNS实操讲   本节课介绍消息队列的MNS的实际操作演示     5、动手实验：基于MNS，0基础轻松构建 Web Client   本节课带您一起基于MNS，0基础轻松构建 Web Client

                
            

        

    



                        
                    
                

                


                

                    

                        

                            
                                
                            
                            

                        

                        zygfengyuwuzu
                        

                        

                    

                    

                        

                            

                            
目录

                        

                        

                    

                

                

                    

                


                

    
相关文章

    

        

            

                

                    杀死一只知更鸟debug
                    
                

                |
                
3月前

                |
                

                    SQL
                    监控
                    druid
                

            

            

                

                    
                        springboot-druid数据源的配置方式及配置后台监控-自定义和导入stater（推荐-简单方便使用）两种方式配置druid数据源
                    
                    
这篇文章介绍了如何在Spring Boot项目中配置和监控Druid数据源，包括自定义配置和使用Spring Boot Starter两种方法。


                    

                        

                            

                                杀死一只知更鸟debug
                                
                            

                            621
                            1
                            
                        

                    

                

                
            

        

        

            

                

                    Codelinghu
                    
                

                |
                
2月前

                |
                

                    并行计算
                    Java
                    数据处理
                

            

            

                

                    
                        SpringBoot高级并发实践：自定义线程池与@Async异步调用深度解析
                    
                    
SpringBoot高级并发实践：自定义线程池与@Async异步调用深度解析

                    

                        

                            

                                Codelinghu
                                
                            

                            190
                            0
                            
                        

                    

                

                
            

        

        

            

                

                    最好zzz
                    
                

                |
                
2月前

                |
                

                    人工智能
                    自然语言处理
                    前端开发
                

            

            

                

                    
                        SpringBoot + 通义千问 + 自定义React组件：支持EventStream数据解析的技术实践
                    
                    
【10月更文挑战第7天】在现代Web开发中，集成多种技术栈以实现复杂的功能需求已成为常态。本文将详细介绍如何使用SpringBoot作为后端框架，结合阿里巴巴的通义千问（一个强大的自然语言处理服务），并通过自定义React组件来支持服务器发送事件（SSE, Server-Sent Events）的EventStream数据解析。这一组合不仅能够实现高效的实时通信，还能利用AI技术提升用户体验。

                    

                        

                            

                                最好zzz
                                
                            

                            187
                            2
                            
                        

                    

                

                
            

        

        

            

                

                    hhzz
                    
                

                |
                
2月前

                |
                

                    消息中间件
                    存储
                    Serverless
                

            

            

                

                    
                        【实践】快速学会使用阿里云消息队列RabbitMQ版
                    
                    
云消息队列 RabbitMQ 版是一款基于高可用分布式存储架构实现的 AMQP 0-9-1协议的消息产品。云消息队列 RabbitMQ 版兼容开源 RabbitMQ 客户端，解决开源各种稳定性痛点（例如消息堆积、脑裂等问题），同时具备高并发、分布式、灵活扩缩容等云消息服务优势。

                    

                        

                            

                                hhzz
                                
                            

                            101
                            2
                            
                        

                    

                

                
            

        

        

            

                

                    DreamSpark
                    
                

                |
                
2月前

                |
                

                    消息中间件
                    安全
                    Java
                

            

            

                

                    
                        云消息队列RabbitMQ实践解决方案评测
                    
                    
一文带你详细了解云消息队列RabbitMQ实践的解决方案优与劣

                    

                        

                            

                                DreamSpark
                                
                            

                            78
                            11
                            
                        

                    

                

                
            

        

        

            

                

                    最好zzz
                    
                

                |
                
1月前

                |
                

                    数据采集
                    Java
                    数据安全/隐私保护
                

            

            

                

                    
                        Spring Boot 3.3中的优雅实践：全局数据绑定与预处理
                    
                    
【10月更文挑战第22天】

在Spring Boot应用中，`@ControllerAdvice`是一个强大的工具，它允许我们在单个位置处理多个控制器的跨切面关注点，如全局数据绑定和预处理。这种方式可以大大减少重复代码，提高开发效率。本文将探讨如何在Spring Boot 3.3中使用`@ControllerAdvice`来实现全局数据绑定与预处理。

                    

                        

                            

                                最好zzz
                                
                            

                            61
                            2
                            
                        

                    

                

                
            

        

        

            

                

                    开发者评测
                    
                

                |
                
2月前

                |
                

                    消息中间件
                

            

            

                

                    
                        解决方案 | 云消息队列RabbitMQ实践获奖名单公布！
                    
                    
云消息队列RabbitMQ实践获奖名单公布！

                    

                        

                            

                                开发者评测
                                
                            

                            62
                            1
                            
                        

                    

                

                
            

        

        

            

                

                    aliyun7689123603-22772
                    
                

                |
                
2月前

                |
                

                    消息中间件
                    存储
                    弹性计算
                

            

            

                

                    
                        云消息队列RabbitMQ实践
                    
                    
云消息队列RabbitMQ实践

                    

                        

                            

                                aliyun7689123603-22772
                                
                            

                            71
                            4
                            
                        

                    

                

                
            

        

        

            

                

                    不游泳的鱼鱼
                    
                

                |
                
2月前

                |
                

                    消息中间件
                    存储
                    弹性计算
                

            

            

                

                    
                        云消息队列 RabbitMQ 版实践解决方案评测
                    
                    
随着企业业务的增长，对消息队列的需求日益提升。阿里云的云消息队列 RabbitMQ 版通过架构优化，解决了消息积压、内存泄漏等问题，并支持弹性伸缩和按量计费，大幅降低资源和运维成本。本文从使用者角度详细评测这一解决方案，涵盖实践原理、部署体验、实际优势及应用场景。

                    

                        

                            

                                不游泳的鱼鱼
                                
                            

                            78
                            2
                            
                        

                    

                

                
            

        

        

            

                

                    叶一一
                    
                

                |
                
2月前

                |
                

                    消息中间件
                    存储
                    监控
                

            

            

                

                    
                        解决方案 | 云消息队列RabbitMQ实践
                    
                    
在实际业务中，网站因消息堆积和高流量脉冲导致系统故障。为解决这些问题，云消息队列 RabbitMQ 版提供高性能的消息处理和海量消息堆积能力，确保系统在流量高峰时仍能稳定运行。迁移前需进行技术能力和成本效益评估，包括功能、性能、限制值及费用等方面。迁移步骤包括元数据迁移、创建用户、网络打通和数据迁移。

                    

                        

                            

                                叶一一
                                
                            

                            69
                            4
                            
                        

                    

                

                
            

        

    



            

            

                
                
                    
                    

    

        

            
热门文章

        

        

            
最新文章

        

    

    

        

            

                
  • 
                    
                        
    
                            
    1
    
                            
                            
    信用算力基于 RocketMQ 实现金融级数据服务的实践
    
                            
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
    2
    
                            
                            
    RabbitMQ入门指南(十一)：延迟消息-延迟消息插件
    
                            
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
    3
    
                            
                            
    解决微信小程序MQTT真机连接问题与合法域名配置SSL问题
    
                            
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    4
    
                            
    RocketMQ 消息发送system busy、broker busy原因分析与解决方案
    
                            
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    5
    
                            
    消息中间件的技术选型心得－RabbitMQ、ActiveMQ和ZeroMQ
    
                            
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    6
    
                            
    STM32通过esp8266连接WiFi接入MQTT服务器
    
                            
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    7
    
                            
    RabbitMQ队列中unacked消息持续时间很久
    
                            
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    8
    
                            
    rabbitmq消息件在idc机房监控中的应用
    
                            
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    9
    
                            
    如何在Docker中配置Mosquitto MQTT代理，以便在容器化环境中运行和管理MQTT通信
    
                            
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    10
    
                            
    STM32配合W5500网卡连接MQTT服务器
    
                            
    
                        
    
                        
                
    • 
            
    
            
    
                
            
    
        
    
        
    
            
    
                
  • 
                    
                        
    
                            
    1
    
                            
                            
    Spring高手之路18——从XML配置角度理解Spring AOP
    
                            
    91
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
    2
    
                            
                            
    Spring Boot中一般如何使用线程池？
    
                            
    720
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
    3
    
                            
                            
    Spring Boot 源码面试知识点
    
                            
    95
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    4
    
                            
    【MongoDB 专栏】MongoDB 与 Spring Boot 的集成实践
    
                            
    241
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    5
    
                            
    深入探索Spring Boot Web应用源码及实战应用
    
                            
    98
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    6
    
                            
    ruoyi-nbcio从spring2.7.18升级springboot到3.1.7，java从java8升级到17（二）
    
                            
    324
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    7
    
                            
    springboot全局自定义异常
    
                            
    40
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    8
    
                            
    RabbitMQ的springboot项目集成使用-01
    
                            
    143
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    9
    
                            
    什么是Spring Boot 自动配置？
    
                            
    51
    
                        
    
                        
                
    • 
                
  • 
                    
                        
    
                            
                            
    10
    
                            
    Spring cloud原理详解
    
                            
    73
    
                        
    
                        
                
    • 
            
    
            
    
                
            
    
        
    
    
    

    
                    
                    
    
    
    
        
    相关课程
    
        更多
    
    
    
    
        
  • 
                SpringBoot实战教程
            
    • 
        
  • 
                精通Spring Cloud Alibaba
            
    • 
        
  • 
                微服务框架 Spring Cloud 快速入门
            
    • 
        
  • 
                SpringBoot快速掌握 - 核心技术
            
    • 
        
  • 
                SpringBoot快速掌握 - 高级应用
            
    • 
        
  • 
                Springboot项目云开发快速迁移
            
    • 
    
    

    
                    
    
    
    
        
    相关电子书
    
        更多
    
    
    
    
        
  • 
                云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
            
    • 
        
  • 
                微服务架构模式与原理Spring Cloud开发实战
            
    • 
        
  • 
                阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库
            
    • 
    
    

    
                    
    
    
    
        
    相关实验场景
    
        更多
    
    
    
    
        
  • 
            快速上手使用Dubbo进行远程调用
        
    • 
        
  • 
            部署RabbitMQ
        
    • 
        
  • 
            Spring-cloud-bus-rocketmq入门与实践
        
    • 
        
  • 
            Spring-cloud-stream-binder-rocketmq入门与实践
        
    • 
        
  • 
            Rocketmq-spring入门与实践
        
    • 
        
  • 
            RocketMQ一站式入门使用
        
    • 
    
    

    
                    
                    
                    
    
                        
    
    
    
        
    下一篇
    
    
    
    阿里云无影云电脑免费试用，最长可试用3个月