Prometheus+Grafana监控Springboot应用
Prometheus+Grafana监控Springboot应用
一：简介
-
SpringBoot 的 actuator 提供了监控端点，micrometer产生监控数据。
-
Prometheus 是监控系统，可以从 Springboot 获取监控数据，以时序数据的形式存储，并提供了监控数据的查询服务。
-
Grafana 是专业的 UI 仪表盘系统，支持非常多的数据源，其中就包括 Prometheus，可以便利的从中获取数据，使用仪表盘展示出来。
二：步骤
- 创建应用 – 作为监控目标，产生监控数据。
- 集成 micrometer – 以便对接监控系统 Prometheus。
- 部署 prometheus
- 配置 prometheus – 监控之前创建的 springboot 应用，了解 Prometheus 的查询服务。
- 部署 Grafana
- 添加 Prometheus 数据源
- 添加 JVM 监控仪表盘 – 展示 springboot 应用的 JVM 状态。
- 自定义监控指标
- 动态变更监控目标,使用动态配置的方式。
1. 创建springboot应用 集成 micrometer
创建一个最简的 springboot 应用，添加 micrometer 依赖。
pom.xml ：
<properties>
<java.version>1.8java.version>
properties>
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-actuatorartifactId>
<version>2.7.3version>
dependency>
<dependency>
<groupId>io.micrometergroupId>
<artifactId>micrometer-registry-prometheusartifactId>
<version>1.9.3version>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
<version>2.7.3version>
dependency>
dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-maven-pluginartifactId>
<executions>
<execution>
<goals>
<goal>repackagegoal>
goals>
execution>
executions>
<configuration>
<includeSystemScope>trueincludeSystemScope>
<mainClass>com.demo.DemoApplicationmainClass>
configuration>
plugin>
plugins>
build>
新建：application.properties
spring.application.name=demo
server.port=8080
# 打开所有 Actuator 服务
management.endpoints.web.exposure.include=*
# 将应用名称添加到计量器的 tag 中去,以便 Prometheus 根据应用名区分不同服务
management.metrics.tags.application=${spring.application.name}
package com.demo;
import io.micrometer.core.instrument.MeterRegistry;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.actuate.autoconfigure.metrics.MeterRegistryCustomizer;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
@Bean
MeterRegistryCustomizer<MeterRegistry> configurer(
@Value("${spring.application.name}") String applicationName) {
return (registry) -> registry.config().commonTags("application", applicationName);
}
}
启动服务。访问http://localhost:8080/actuator/prometheus查看监控端点信息：
2. 部署 Prometheus
官网：
https://prometheus.io/
-
可以下载安装包来安装。
-
可以使用 docker 部署。
docker 方式启动：现在还没对接应用，后面加入应用的配置之后可以看到详细的内容。
$ docker pull prom/prometheus
$ docker run --name prometheus -d -p 9090:9090 prom/prometheus
执行完成后就OK了，可以看一下 Prometheus 的界面。
http://localhost:9090/targets 是监控目标列表页：
http://localhost:9090/graph 是查询控制台，也有简单的图表展示：
3. Prometheus + Springboot应用
监控应用，需要在 Prometheus 配置文件中添加应用的相关信息。
查看一下配置文件的默认内容：
$ docker exec -it [容器ID] cat /etc/prometheus/prometheus.yml
需要添加的内容示例为：
- job_name: 'springboot_demo_app'
scrape_interval: 5s
metrics_path: '/actuator/prometheus'
static_configs:
- targets: ['XXX:8080']
"labels": {
"instance": "demo",
"service": "demo-service"
}
metrics_path 指定监控端点的路径。
targets 指定应用的IP端口，这里使用了IP，没有使用localhost，因为 Prometheus 是容器运行的，如果使用 localhost 就会访问容器内部。
配置不是直接在容器内部修改，可以把容器内部的配置文件拷贝出来一份，修改后，重启启动容器，挂载本地修改过的配置文件。
拷贝容器中的配置文件：
$ docker cp [容器ID]:/etc/prometheus/prometheus.yml .
修改配置文件，添加配置，最终的内容：
# my global config
global:
scrape_interval: 15s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
evaluation_interval: 15s # Evaluate rules every 15 seconds. The default is every 1 minute.
# scrape_timeout is set to the global default (10s).
# Alertmanager configuration
alerting:
alertmanagers:
- static_configs:
- targets:
# - alertmanager:9093
# Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
rule_files:
# - "first_rules.yml"
# - "second_rules.yml"
# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.
scrape_configs:
# The job name is added as a label `job=` to any timeseries scraped from this config.
- job_name: 'prometheus'
# metrics_path defaults to '/metrics'
# scheme defaults to 'http'.
static_configs:
- targets: ['localhost:9090']
- job_name: 'springboot_demo_app'
scrape_interval: 5s
metrics_path: '/actuator/prometheus'
static_configs:
- targets: ['XXX:8080']
"labels": {
"instance": "demo",
"service": "demo-service"
}
停掉之前的容器，重新启动：
$ docker stop [容器ID] && docker rm [容器ID]
$ docker run --name prometheus -d \
-p 9090:9090 \
-v [PATH]/prometheus.yml:/etc/prometheus/prometheus.yml \
prom/prometheus
访问监控列表页 http://localhost:9090/targets 就可以看到我们的应用了：
进入查询控制台页面 http://localhost:9090/graph，可以查询一个指标，例如 http_server_requests_seconds_sum，效果：
4. 部署 Grafana
docker方式运行：
$ docker pull grafana/grafana
$ docker run -d -p 3000:3000 --name=grafana grafana/grafana
启动后，访问：http://localhost:3000，默认用户名密码 admin/admin。
5. 添加 Prometheus 数据源
6. 展示应用的 JVM 信息
Grafana 中已经有现成的 JVM 仪表盘，我们直接导入使用即可。
这个仪表盘的编号为 4701。
点击import
至此，Prometheus + Grafana + Springboot 的整体流程已经跑通了，可以通过仪表盘来监控springboot应用信息。
7. 自定义监控指标
需求：监控所有接口的请求次数。
应用中添加依赖：
<dependency>
<groupId>org.aspectjgroupId>
<artifactId>aspectjrtartifactId>
<version>1.9.4version>
dependency>
<dependency>
<groupId>org.aspectjgroupId>
<artifactId>aspectjweaverartifactId>
<version>1.9.4version>
dependency>
<dependency>
<groupId>cglibgroupId>
<artifactId>cglibartifactId>
<version>3.2.12version>
dependency>
使用AOP方式对接口请求计数：
import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.MeterRegistry;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
@Component
@Aspect
public class APICounterAop {
@Pointcut("execution(public * com.demo.controller.*.*(..))")
public void pointCut() {
}
ThreadLocal<Long> startTime = new ThreadLocal<>();
@Autowired
MeterRegistry registry;
private Counter counter;
@PostConstruct
private void init() {
counter = registry.counter("requests_total", "status", "success");
}
@Before("pointCut()")
public void doBefore(JoinPoint joinPoint) throws Throwable {
System.out.println("do before");
counter.increment(); //请求计数
}
@AfterReturning(returning = "returnVal", pointcut = "pointCut()")
public void doAfterReturning(Object returnVal) {
System.out.println("do after");
}
}
创建一个测试接口：
package com.demo.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
@RestController
@RequestMapping("/api/demo")
public class DemoController {
@RequestMapping("/hello")
public String hello() {
return "hello";
}
}
重启应用，多访问几次测试接口，然后查看 Prometheus 中的应用监控端点页面，就可以看到监控结果：
然后，我们把这个指标requests_total{application=“demo”,status=“success”,}在 Grafana 中显示出来。
8. 动态变更监控目标
Prometheus 提供了动态加载的方式，把服务信息放到一个单独的文件中，Prometheus 配置中指定这个外部文件，内容变化后，Prometheus 就会自动重新加载。
服务信息配置文件例如：
[
{
"targets": [
"XXX:8080"
],
"labels": {
"instance": "demo",
"service": "demo-service"
}
}
]
Prometheus 配置文件中的写法：
...
- job_name: 'springboot_demo_app'
scrape_interval: 5s
metrics_path: '/actuator/prometheus'
file_sd_configs:
- files:
- /home/*.json
refresh_interval: 1m
启动 Prometheus 容器时要挂载这个服务信息配置文件的目录：
$ docker run --name prometheus -d -p 9090:9090 \
-v [PATH]/prometheus.yml:/etc/prometheus/prometheus.yml \
-v [PATH]:/home \
prom/prometheus