从零搭建轻量级微服务监控:主机、Docker、JVM、Go 与 Nginx QPS

2026-07-31后端8 分钟113 次阅读
AI 摘要鱼粮不足,AI 今天先歇着 · 正文在下面

前言:先看得见,再谈调优

两台小服务器、十几个微服务,不一定要先上 Prometheus + Grafana。本文记录我如何用一个 Go 监控服务,把主机资源、Docker 容器、Java JVM、Go runtime、Nginx 访问量和基础告警串成一套轻量监控方案,并解释每个指标究竟是怎么采到的。

做微服务一段时间后,很容易遇到这样的场景:

  • 服务没挂,但接口变慢了,不知道是 CPU、内存、GC 还是数据库;
  • 容器还在运行,可 JVM 已经频繁 Full GC;
  • Go 服务内存一直涨,不知道是正常的 Heap 扩张还是泄漏;
  • Nginx 日志在增长,但没有一个地方能快速看到 QPS、错误请求和热门接口;
  • 机器本身只有 2C2G 或 4C8G,再加一套完整 Prometheus、Grafana、Exporter,监控系统反而先把资源吃掉。

这时最重要的目标不是做出“企业级可观测性平台”,而是先建立一套足够可靠的日常观察面板:知道哪台机器压力大、哪个服务异常、哪类内存正在上涨、访问量有没有变化。

本文的方案采用 Go 编写 s-monitor,保留最近 7 天分钟级数据,并按天汇总流量历史。它更像一套适合个人项目和小型集群的“观察仪表盘”。

一、整体架构

两台服务器时,不需要把监控中心部署两份:

  • A 服务器:部署 s-monitor server + agent,负责存储、查询、gRPC 服务和本机采集;
  • B 服务器:只部署 s-monitor agent,负责采集本机数据并上报;
  • s-admin:通过 gRPC 向 s-monitor 查询,给后台页面提供 REST 接口;
  • Nacos:用于发现微服务实例,避免手工把每个实例 IP 写死;
  • MySQL:只存聚合后的指标点,不存每条 Nginx 原始访问日志。
flowchart LR A["A 服务器<br/>s-monitor server + agent"] -->|MySQL| DB[("s_monitor")] B["B 服务器<br/>s-monitor agent"] -->|HTTP 上报| A N["Nacos"] -->|服务实例发现| A N -->|服务实例发现| B A -->|gRPC| ADMIN["s-admin"] ADMIN --> WEB["cloud-admin-vue<br/>运维管理 / 监控大盘"] A --> JAVA["Java Actuator"] A --> GO["Go /metrics"] A --> DOCKER["Docker Unix Socket"] A --> NGINX["Nginx access.log"]

这里有一个边界很重要:容器指标和应用运行时指标是两回事。

  • Docker 只能告诉我们容器 CPU、内存、网络、运行状态;
  • Java 的新生代、老年代、线程、GC,要从 Spring Boot Actuator 获取;
  • Go 的 Goroutine、Heap、Stack、GC,要从 Go 服务自己的 metrics 接口获取。

二、主机和 Docker 是怎么采集的

1. 主机资源

主机指标包括 CPU、内存、磁盘和网络速率。Go agent 在宿主机中读取系统统计信息,再按固定间隔上报。

建议采集间隔:

指标 建议间隔 原因
主机 CPU、内存、磁盘 15 秒 足够观察资源波动,成本很低
Docker 容器 CPU、内存、网络 15 秒 容器状态和资源变化相对快
Java / Go runtime 30 秒 降低应用指标请求量
Nginx access.log 15 秒 及时生成分钟 QPS
中间件健康检查 30 秒 避免对 Redis、MySQL 等产生额外压力

CPU 使用率不是一次读取就能算出来,它本质上是一个时间段内的增量。网络速率也是一样:先记录累计收发字节数,再与上一次采样相减,除以间隔秒数,得到 bytes/s。

2. Docker 容器

在 Linux 宿主机上,Docker daemon 默认提供 /var/run/docker.sock。把这个 socket 以只读方式挂进 agent 容器,就能调用 Docker API:

yaml 复制代码
volumes:
  - /var/run/docker.sock:/var/run/docker.sock:ro

这样不需要暴露 Docker TCP 端口,也不需要在每台机器安装额外 exporter。

Docker 返回的 CPU 是累计纳秒数,常见计算公式是:

text 复制代码
CPU 使用率 =
容器 CPU 累计增量 / 宿主机 CPU 累计增量
* 在线 CPU 核数
* 100

容器采集到的数据包括:

  • container.up:容器是否运行;
  • container.cpu.usage:容器 CPU 使用率;
  • container.mem.used / container.mem.limit:内存使用和限制;
  • container.net.rx_bytes / container.net.tx_bytes:累计网络收发字节。

为了让没有注册到 Nacos 的容器也能看到,监控程序会为 Java / Go 容器生成一个“服务实例存活点”。但这只是一个兜底展示,真正 JVM、Go runtime 明细仍然要由 HTTP 指标接口采集。

三、Java JVM:通过 Actuator 采什么

Java 服务建议启用 Spring Boot Actuator,并开放 metrics:

yaml 复制代码
management:
  endpoints:
    web:
      exposure:
        include: health,metrics
  endpoint:
    health:
      show-details: always

如果服务有 context path,例如 /blog,监控目标就应该是:

text 复制代码
http://服务地址:端口/blog/actuator

采集器会先请求:

text 复制代码
GET /actuator/metrics

它返回当前服务支持的指标名称。然后再按名称和 tag 查询,例如:

text 复制代码
GET /actuator/metrics/jvm.memory.used?tag=area:heap
GET /actuator/metrics/jvm.memory.used?tag=id:G1%20Eden%20Space
GET /actuator/metrics/jvm.gc.pause?tag=action:end%20of%20young%20GC

1. JVM 内存区

指标 含义 常见观察点
Heap Java 对象主要存放区域 接近上限且持续不回落,留意内存泄漏
Eden 新对象首先进入的新生代区域 持续高位说明分配压力大
Survivor Minor GC 后仍存活对象的过渡区 异常增大可能意味着对象存活时间长
Old 长期存活对象进入的老年代 持续上涨最值得警惕
Metaspace 类元数据、动态代理等 Spring Cloud 服务通常不能配得太小
NonHeap 非堆内存汇总 包含 Metaspace、Code Cache 等

不同 GC 的内存池名称不完全一致。G1 可能叫 G1 Eden Space,Parallel GC 可能叫 PS Eden Space,所以采集器不能只写死一种名称。更稳妥的做法是先读取 Actuator 的 availableTags,再根据 id 中包含 eden、survivor、old、metaspace 来归类。

2. 线程和 GC

常用指标包括:

  • jvm.threads.live:当前存活线程;
  • jvm.threads.daemon:守护线程;
  • jvm.threads.peak:历史峰值线程;
  • jvm.threads.states.*:Runnable、Blocked、Waiting、Timed Waiting;
  • jvm.gc.pause:GC 的次数、总耗时、最大停顿。

GC 不要只看“次数”。更有参考意义的是:

  1. Minor GC 是否突然非常频繁;
  2. Major GC 是否开始出现;
  3. 总停顿是否持续增长;
  4. 单次最大停顿是否过长;
  5. Old 区是否在 GC 后仍然只增不减。

四、Go runtime:不接 Prometheus 也能采

Go 服务不一定需要完整引入 Prometheus。只要服务暴露一个轻量 /metrics 接口,返回 JSON 或 Prometheus 文本格式即可。

常用的 Go 运行时信息来自:

go 复制代码
runtime.ReadMemStats(&mem)
runtime.NumGoroutine()

建议最少暴露:

text 复制代码
goroutines
heap_alloc_bytes
heap_sys_bytes
heap_inuse_bytes
heap_idle_bytes
stack_inuse_bytes
stack_sys_bytes
sys_bytes
gc_count
gc_pause_total_seconds
next_gc_bytes
uptime_seconds
指标 含义 观察方式
Goroutines 当前轻量线程数 持续上涨且不回落,要查泄漏或阻塞
Heap Alloc 仍被对象使用的堆 是最接近“当前对象占用”的指标
Heap Inuse 正在使用的堆页 与 Heap Alloc 对比可看碎片趋势
Heap Idle 空闲但未立刻还给系统的堆页 高不一定异常,是 Go runtime 的正常缓存行为
Stack Inuse goroutine 栈占用 Goroutine 增多时通常一起上涨
Sys Go 向操作系统申请的总内存 不等于真正 RSS,但适合观察趋势
GC Count / Pause GC 次数和累计停顿 用于判断 GC 压力是否变大
Next GC 下一次触发 GC 的堆目标 结合 Heap Alloc 看增长速度

采集器同时兼容两种格式:

  1. JSON:适合项目内部统一封装;
  2. Prometheus text exposition:适合已接入 /metrics 的服务。

解析 Prometheus 文本时,不把 HTTP path、用户 ID 等 label 原样写进数据库。原因很简单:这些维度可能无限增长,高基数标签会让轻量监控很快变重。

五、Nginx access.log:如何从日志得到 QPS、TPS、PV、UV

Nginx 是最贴近用户访问入口的一层。一个典型 access.log 包含:

text 复制代码
客户端 IP - - [时间] "请求方法 路径 协议" 状态码 响应字节 "Referer" "User-Agent" 请求耗时

监控程序并不把每一行日志写进 MySQL,而是使用以下流程:

  1. 为每个日志文件记录内存 offset;
  2. 每次只读取上次 offset 之后的新增内容;
  3. 发现文件大小小于旧 offset,认为发生了日志切割,从文件头重新读取;
  4. 按分钟聚合 PV、UV、状态码、响应字节和平均请求耗时;
  5. 仅保留 Top URL、Top IP 的有限条目,其他合并为 other;
  6. URL 去掉 query string,并把纯数字、长 hash 等动态段归一为 :id、:hash。

例如:

text 复制代码
/api/user/1001?from=home  -> /api/user/:id
/file/9a7b8c...             -> /file/:hash

这样避免每个用户、订单、文件都制造一条新的维度记录。

QPS 和 TPS 到底怎么定义

当前轻量方案的口径:

text 复制代码
QPS = 当前分钟请求数 / 60
TPS = 当前分钟按访问路径聚合后的接口吞吐近似值

因此,页面里的 TPS 更准确地说是“HTTP 请求吞吐”。它适合观察接口流量压力,但不等于严格的业务事务 TPS。

例如“下单”可能会触发一次下单接口、一次库存接口、一次支付回调。若要精确业务 TPS,需要在网关或业务服务中增加统一埋点,按业务动作计数。

六、数据为什么不会爆炸

轻量监控最容易踩的坑,是把每 15 秒的所有原始指标和每一行访问日志永久保存。正确做法是分层保留:

数据层 内容 保留时间
原始指标点 短时间排障使用 24 小时
分钟级指标 主机、实例、容器、Nginx 趋势 7 天
日级流量汇总 PV、UV、状态码、Top URL 90 天或更长

以一个站点为例:

text 复制代码
7 天 * 24 小时 * 60 分钟 = 10,080 条分钟记录

即使有多个服务和多个站点,只保存聚合后的数值,通常也只是几十 MB 到数百 MB 量级,而不是几 GB 的原始日志量。

MySQL 很适合当前场景:

  • 已有运维基础设施;
  • 方便做时间范围查询和聚合;
  • 可通过复合索引支持 target + metric + time 查询;
  • 7 天数据量可控。

SQLite 更适合单机离线工具或个人电脑本地采集。这里涉及两台服务器、agent 上报、后台查询和后续告警,MySQL 的并发与运维体验更稳妥。

七、如何用这套面板做调优

1. CPU 高,但 JVM 堆稳定

优先看:

  • 容器 CPU 是否也高;
  • Runnable 线程是否增加;
  • Nginx QPS 是否同步升高;
  • 某个 Top URL 是否突然占比很高。

可能是流量增加、慢 SQL、死循环、序列化开销或线程池饱和。

2. Old 区一直增长

优先看:

  • Minor GC 后 Old 是否还继续增长;
  • Major GC 是否开始频繁;
  • Heap 是否接近 -Xmx;
  • 是否有大缓存、静态集合、消息堆积、未释放引用。

这时要保留现场,必要时导出 Heap Dump 用 MAT 分析,而不是一上来只加内存。

3. Metaspace 快满

优先看:

  • 动态代理、热部署、脚本执行是否过多;
  • Spring Cloud 服务的 MaxMetaspaceSize 是否配得过低;
  • 是否存在大量类加载器没有释放。

Metaspace OOM 和普通 Heap OOM 不一样。Heap Dump 的对象大小不一定能直接解释 Metaspace 问题,需要结合 Class Loader Explorer 看类加载情况。

4. Go 内存高

先不要看到 Sys 或 Heap Idle 高就判断泄漏。更值得关注的是:

  • Heap Alloc 是否持续上涨且 GC 后不回落;
  • Goroutine 是否持续上涨;
  • GC 次数、累计停顿是否突然增加;
  • 容器内存是否逼近 limit。

Go runtime 会保留一部分空闲堆页,这是为了后续分配更快,属于正常行为。

八、什么时候应该升级到 Prometheus + Grafana

这套轻量方案不是为了替代 Prometheus,而是适合资源有限、指标规模可控的阶段。

当出现以下需求时,可以考虑升级:

  • 数十台以上机器;
  • 大量自定义业务指标;
  • 高维度 label 查询;
  • 长期保存数月甚至数年;
  • 复杂告警表达式和告警路由;
  • Trace、Log、Metric 三件套联动。

到了那个阶段,Prometheus、Grafana、Loki、SkyWalking 或 OpenTelemetry 才会真正发挥价值。

总结

监控的第一目标不是“图表多”,而是能回答问题:

  1. 哪台主机资源紧张?
  2. 哪个容器或服务实例异常?
  3. Java 是堆、老年代、元空间、线程还是 GC 有问题?
  4. Go 是 Goroutine、Heap 还是 GC 出现趋势异常?
  5. 访问量、错误率、热门接口有没有变化?

对于两台小服务器和十几个服务,一个 Go agent + MySQL 分钟聚合 + Nacos 发现 + 后台仪表盘,已经足够支撑日常排障和学习调优。

先让系统“看得见”,再让每一次优化都有数据依据。这个过程本身,就是后端工程能力最扎实的积累。

觉得有用就点个赞,不用登录也能读

评论

0 条
登录 之后才能评论
—
还没有评论,来说第一句