SpringBoot+Grafana+Prometheus+Docker-Compose 快速部署与JVM监控的快速入门的简单案例

标签：info Compose SpringBoot boot Grafana prometheus 线程 CPU 模拟

1. Java项目

1.1 项目结构

1.2 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>info.liberx</groupId>
    <artifactId>Prometheus</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>io.micrometer</groupId>
            <artifactId>micrometer-registry-prometheus</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

说明：

spring-boot-starter-actuator：主要用于提供内置的监控和管理端点，帮助你实时查看和管理应用的健康状态和性能。

micrometer-registry-prometheus：用于将这些监控指标导出到Prometheus，让你可以通过Prometheus和Grafana对应用进行全面的监控和分析。

1.3 application.properties

spring.application.name=Prometheus
management.endpoints.web.exposure.include=health,info,prometheus
management.endpoint.prometheus.enabled=true

说明：

• 可以通过/actuator/health端点查看应用的健康状态，返回的信息可以包括数据库连接、队列状态等。

• 可以通过/actuator/metrics端点，可以查看应用程序的各种性能指标，如内存使用、CPU使用、线程数、GC等。

• 可以通过/actuator/info端点获取应用的基本信息，如版本号、描述等，这些信息可以通过配置文件或其他手段提供

• 可以通过/actuator/prometheus端点，Prometheus服务器可以通过这个端点抓取并存储这些监控指标。

1.4 PrometheusApplication.java

package info.liberx.prometheus;

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

@SpringBootApplication
public class PrometheusApplication {

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

}

1.5 PrometheusController.java

package info.liberx.prometheus.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

@RestController
public class PrometheusController {

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

    // 创建一个线程池用于CPU测试
    private final ExecutorService cpuThreadPool = Executors.newFixedThreadPool(8);

    @GetMapping("/memory-usage")
    public String memoryUsage() {
        // 创建一个1GB大小的数组来消耗内存
        int size = 1024 * 1024 * 1024; // 1 GB
        byte[] memoryBlock = new byte[size];

        // 模拟内存使用，通过填充数组
        Arrays.fill(memoryBlock, (byte) 1);

        logger.info("内存已分配，保持10秒...");

        try {
            // 保持程序运行，以便监控内存使用
            Thread.sleep(10000); // 10秒
        } catch (InterruptedException e) {
            logger.error("线程被中断", e);
            Thread.currentThread().interrupt();
        }

        return "内存使用模拟完成";
    }

    @GetMapping("/high-cpu-usage")
    public String highCpuUsage() {
        // 指定运行时间，单位为秒
        int duration = 10;

        for (int i = 0; i < 8; i++) { // 启动8个线程来消耗CPU
            cpuThreadPool.submit(() -> {
                long endTime = System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(duration);
                while (System.currentTimeMillis() < endTime) {
                    Math.pow(Math.random(), Math.random()); // 持续执行计算
                }
                logger.info("CPU密集型线程已运行{}秒后结束。", duration);
            });
        }

        logger.info("高CPU使用测试已启动，持续{}秒。", duration);

        // 等待任务完成，防止请求过早返回
        cpuThreadPool.shutdown();
        try {
            if (!cpuThreadPool.awaitTermination(duration + 5, TimeUnit.SECONDS)) {
                cpuThreadPool.shutdownNow(); // 超时后强制关闭
            }
        } catch (InterruptedException e) {
            cpuThreadPool.shutdownNow();
            Thread.currentThread().interrupt();
        }

        return "高CPU使用模拟完成，持续时间：" + duration + "秒。";
    }

    @GetMapping("/gc")
    public String gc() {
        for (int i = 0; i < 1000; i++) {
            if (i % 100 == 0) {
                System.gc(); // 手动触发GC
                logger.info("手动GC触发。");
            }
            try {
                Thread.sleep(50); // 让JVM有时间处理
            } catch (InterruptedException e) {
                logger.error("线程被中断", e);
                Thread.currentThread().interrupt();
            }
        }
        return "GC模拟完成";
    }

    @GetMapping("/thread")
    public String thread() {
        ExecutorService threadPool = Executors.newFixedThreadPool(100); // 使用线程池管理线程

        for (int i = 0; i < 100; i++) { // 启动100个线程
            threadPool.submit(() -> {
                try {
                    Thread.sleep(10000); // 每个线程运行10秒
                } catch (InterruptedException e) {
                    logger.error("线程被中断", e);
                    Thread.currentThread().interrupt();
                }
            });
        }

        logger.info("已启动100个线程。");

        // 等待主线程结束后关闭线程池
        threadPool.shutdown();
        try {
            Thread.sleep(15000); // 主线程等待，防止程序过早退出
        } catch (InterruptedException e) {
            logger.error("主线程被中断", e);
            Thread.currentThread().interrupt();
        }
        return "线程模拟完成";
    }
}

说明：

API 功能	请求路径	描述
内存使用模拟	/memory-usage	模拟并监控1GB内存的分配和使用
高CPU使用模拟	/high-cpu-usage	模拟高CPU使用的场景
手动触发GC	/gc	手动触发垃圾回收操作
线程模拟	/thread	启动并模拟100个线程运行

2. Docker-Compose 项目

2.1 项目结构

2.2 docker-compose.yml

version: '3.7'

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml  # 配置文件挂载
      - prometheus_data:/prometheus  # 数据持久化卷挂载
    ports:
      - "9090:9090"
    networks:
      - monitoring

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    volumes:
      - ./grafana.ini:/etc/grafana/grafana.ini  # 配置文件挂载
    ports:
      - "3000:3000"
    networks:
      - monitoring

networks:
  monitoring:
    driver: bridge

volumes:
  prometheus_data:

2.3 grafana.ini

[smtp]
enabled = true
host = smtp.qq.com:465
user = [email protected]
password = xxx
from_address = [email protected]
from_name = Grafana

说明：这是邮箱验证的配置，如果你不需要也可以把docker-compose.yml对应的挂载路径删除。

2.4 prometheus.yml

global:
  scrape_interval: 15s  # 定义全局抓取间隔

scrape_configs:
  - job_name: 'example-service'
    metrics_path: '/actuator/prometheus'  # 指定要抓取的路径
    scheme: 'http'  # 或 'https'，指定协议
    static_configs:
      - targets: ['192.168.186.137:8080']  # 目标主机和端口

说明：192.168.186.137:8080替换成为Java项目的访问地址。

3. 镜像源失效

如果Docker镜像源失效，可以尝试切换以下镜像源：

sudo nano /etc/docker/daemon.json

{
  "registry-mirrors": ["https://register.liberx.info"]
}

sudo systemctl restart docker

4. 测试验证

4.1 启动Docker-Compose项目

docker-compose up -d

启动后，你可以通过以下地址访问：

• Prometheus: http://localhost:9090
• Grafana: http://localhost:3000（默认用户名和密码均为 admin）

4.2 设置中文(可选)

操作：点击右上角头像->Profile->Language->中文简体->Save。

4.3 添加数据源

4.4 添加案例和测试

监控项	PromQL 查询语句
JVM 堆内存使用情况	jvm_memory_used_bytes{area="heap"}
JVM 进程的 CPU 使用率	rate(process_cpu_time_ns_total[$__rate_interval])
GC 停顿次数	rate(jvm_gc_pause_seconds_count[$__rate_interval])
JVM 活动线程数量	jvm_threads_live_threads

API 功能	请求路径	描述
内存使用模拟	/memory-usage	模拟并监控1GB内存的分配和使用
高CPU使用模拟	/high-cpu-usage	模拟高CPU使用的场景
手动触发GC	/gc	手动触发垃圾回收操作
线程模拟	/thread	启动并模拟100个线程运行

说明：说明：需要覆盖然后设置不同的单位，我只是模拟了一个线程的变化添加100个，还有其他接口可以自行测试感受变化，等待时间有点长，所以我就不进行测试了。

4.5 添加警告规则

4.5.1 发送预警（可选）

配置警告规则之前：先设置联系方式，如果你需要开启邮箱发送预警信息，不需要留空即可。

4.5.2 添加警告规则

5. 总结

​ 通过SpringBoot+Grafana+Prometheus+Docker-Compose快速部署和JVM监控的简单入门案例。

标签：info,Compose,SpringBoot,boot,Grafana,prometheus,线程,CPU,模拟
From： https://blog.csdn.net/qq_71387716/article/details/141568334