(promethues）node_exporter注册自定义监控数据，简单展示
一、要使用node_exporter通过collect注册自定义监控数据，需要遵循以下步骤：
1.创建一个自定义的collector。Collector是一个Go结构体，它实现了Collector接口的方法。这些方法包括：
Collect(ctx context.Context) (metrics, error): 此方法用于收集和返回自定义指标。
Describe(ctx context.Context, ch chan<- *prometheus.Desc): 此方法用于描述自定义指标。
2.在Collect方法中，编写代码以收集所需的自定义指标。可以使用各种方法和技术来收集这些指标，例如从文件中读取、从网络请求中获取等。
3. 在Describe方法中，编写代码以描述自定义指标。使用prometheus.NewDesc函数创建一个新的描述符，并使用ch通道将其发送到Prometheus服务器。
4.编译和运行自定义的collector。确保collector在Prometheus服务器上运行，以便Prometheus服务器能够从collector中获取自定义指标。
5.在Prometheus服务器上配置自定义的collector。使用Prometheus的配置文件将自定义的collector添加到服务器上。配置文件应指定collector的地址和端口号，以便Prometheus服务器能够与collector通信。
6.启动Prometheus服务器以使用自定义的collector。在启动服务器时，Prometheus将自动加载配置文件并开始从自定义的collector中拉取数据。
7.在Prometheus的查询界面上查看自定义指标。一旦Prometheus服务器开始从自定义的collector中拉取数据，您就可以在查询界面上查看这些数据，并使用它们进行监控和警报。
二、展示实战案例
将监控数据集成到node_exporter上，实现目标跟之前博客一样，只不过是这里采用go语言将监控数据集成到node_exporter
上次博客连接：
基于python编写的服务器之间流量传输netflow_exporter
1.下载node_exporter-master
传送门：点击下载
2. 在collect目录增加自定义监控udf,下面是自定义监控服务器之间网络流量的指标
// Copyright 2020 The Prometheus Authors
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build !nonetworkflow
// +build !nonetworkflow
package collector
import (
"fmt"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"os/exec"
"strconv"
"strings"
"math"
)
const (
// 定义自定义数据指标的子系统名称
// netflow_metrics
customMetricsSubsystem = "netflow_metrics"
)
// 定义 customMetricsCollector 结构体
type customMetricsCollector struct {
logger log.Logger
//...
}
type netflow struct {
//flowSend prometheus.Gauge
//flowReceive prometheus.Gauge
//label *prometheus.CounterVec
flowSend *prometheus.CounterVec
flowReceive *prometheus.CounterVec
}
func NewMetrics(reg prometheus.Registerer) *netflow {
m := &netflow{
flowSend: prometheus.NewCounterVec(
prometheus.CounterOpts{
Name: "flowSend",
Help: "Current flowSend of the Host.",
},
[]string{"host"},
),
flowReceive: prometheus.NewCounterVec(
prometheus.CounterOpts{
Name: "flowReceive",
Help: "Current flowReceive of the Host.",
},
[]string{"host"},
),
}
reg.MustRegister(m.flowSend)
reg.MustRegister(m.flowReceive)
return m
}
func init() {
//1. 在该函数中调用 registerCollector() 函数,注册自定义 customMetricsCollector
registerCollector("netflow_metrics", defaultEnabled, NewCustomMetricsCollector)
}
// 2. 定义 customMetricsCollector 的工厂函数,后续传入 registerCollector() 函数中,以便创建 customMetricsCollector 对象
func NewCustomMetricsCollector(logger log.Logger) (Collector, error) {
return &customMetricsCollector{
logger: logger,
}, nil
}
// 实现 Update() 函数,以便在处理请求时被 Collector.Collect() 调用
func (c *customMetricsCollector) Update(ch chan<- prometheus.Metric) error {
reg := prometheus.NewRegistry()
// Create new metrics and register them using the custom registry.
m := NewMetrics(reg)
//var metricType prometheus.ValueType
//metricType = prometheus.CounterValue
result, err := exec.Command("sh", "-c", "iftop -t -N -n -s 1 2>/dev/null |grep -A 1 -E '^ [0-9]'").Output()
if err != nil {
fmt.Println("Error:", string(result))
} else {
lines := strings.Split(string(result), "\n")
fmt.Println(lines)
fmt.Println(len(lines) - 1)
var count = 1
var groupnum = 0
all_netflow := make(map[string]string)
//send_rece_arr := make([]float64, 6)
var send_flow = ""
for i := 0; i < len(lines)-1; i++ {
//fmt.Println("--------------------------------------++++")
//fmt.Println(lines[i])
slice0 := strings.Split(lines[i], " ")
if (count % 2) != 0 {
groupnum++
//发送
send_arr := make([]string, 7)
var scount = 0
//fmt.Printf("%d 组发送流量：%s\n", groupnum, slice0)
for _, v := range slice0 {
if v != "" {
//fmt.Println(v)
send_arr[scount] = v
scount++
}
}
fmt.Println(send_arr)
fmt.Println(send_arr[1], send_arr[len(send_arr)-2])
send_flow = send_arr[len(send_arr)-2]
} else {
//接收
rece_arr := make([]string, 6)
var rcount = 0
for _, v := range slice0 {
if v != "" {
//fmt.Println(v)
rece_arr[rcount] = v
rcount++
}
}
fmt.Println(rece_arr)
fmt.Println(rece_arr[0], rece_arr[len(rece_arr)-2])
//transformtokb(send_flow)
rece_flow := rece_arr[len(rece_arr)-2]
fmt.Println(transformtokb(send_flow), transformtokb(rece_flow))
send_flow = strconv.FormatFloat(transformtokb(send_flow), 'f', 2, 64)
rece_flow = strconv.FormatFloat(transformtokb(rece_flow), 'f', 2, 64)
all_netflow[rece_arr[0]] = send_flow + "|" + rece_flow
send_flow = ""
}
count++
}
// 流量获取结束
// 把切片里的有效数据放到map中
netflow_send := make(map[string]float64)
netflow_rece := make(map[string]float64)
for desthost, flowsize := range all_netflow {
p_send := 0.00
p_rece := 0.00
p_send, _ = strconv.ParseFloat(strings.Split(flowsize, "|")[0], 2)
p_rece, _ = strconv.ParseFloat(strings.Split(flowsize, "|")[1], 2)
netflow_send[desthost] = p_send
netflow_rece[desthost] = p_rece
m.flowSend.With(prometheus.Labels{"host": desthost}).Add(float64(p_send))
m.flowReceive.With(prometheus.Labels{"host": desthost}).Add(float64(p_rece))
}
}
return nil
}
// 对b/Kb/Mb数据进行转换
func transformtokb(flow string) float64 {
newstr := ""
for _, v := range flow {
if v == 'K' {
//fmt.Println(newstr)
strInt, err := strconv.ParseFloat(newstr, 2)
if err != nil {
fmt.Println("transformtokb v is K",err)
}
finalResult := float64(strInt)
return finalResult
//break
} else if v == 'b' {
//fmt.Println(newstr)
strInt, err := strconv.ParseFloat(newstr, 2)
if err != nil {
fmt.Println("transformtokb v is b",err)
}
//fmt.Println(str_int / 1024)
//var final_result=0.0
//final_result :=
finalResult := math.Round(float64(strInt/1024)*1000) / 1000
return finalResult
//break
} else if v == 'M' {
//fmt.Println(newstr)
strInt, err := strconv.ParseFloat(newstr, 2)
if err != nil {
fmt.Println("transformtokb v is M",err)
}
//fmt.Println(str_int * 1024)
//final_result := float64(str_int * 1024)
finalResult := math.Round(float64(strInt*1024)*1000) / 1000
return finalResult
}
newstr += string(v)
}
return 0
}
3.编译
参照之前编译博客：Linux环境下编译并运行go项目
还可以这样安装go环境：
[root@hadoop1011 ~]# tar -zxvf go1.20.12.linux-amd64.tar.gz -C /usr/local/go1.20.12/
[root@hadoop1011 ~]# vim /etc/profile.d/go.sh
export PATH=$PATH:/usr/local/go1.20.12/go/bin
[root@hadoop1011 ~]# source /etc/profile
[root@hadoop1011 node_exporter-master]# ./node_exporter
新开一个窗口
[root@hadoop1011 node_exporter-master]#curl -L 127.0.0.1:9100/metrics|grep netflow
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
0 0 0 0 0 0 0 0 --:--:-- 0:00:12 --:--:-- 0# HELP node_netflow_receive Receive netflow from remote host.
# TYPE node_netflow_receive gauge
node_netflow_receive{remote_host="192.168.196.73"} 0.813
node_netflow_receive{remote_host="192.168.10.100"} 2529.28
node_netflow_receive{remote_host="192.168.10.101"} 2068.48
node_netflow_receive{remote_host="192.168.10.103"} 1853.44
node_netflow_receive{remote_host="192.168.10.104"} 1710.08
node_netflow_receive{remote_host="192.168.10.99"} 1792
# HELP node_netflow_send Send remote host netflow.
# TYPE node_netflow_send gauge
node_netflow_send{remote_host="192.168.196.73"} 1.72
node_netflow_send{remote_host="192.168.10.100"} 2109.44
node_netflow_send{remote_host="192.168.10.101"} 2805.76
node_netflow_send{remote_host="192.168.10.103"} 2088.96
node_netflow_send{remote_host="192.168.10.104"} 2529.28
node_netflow_send{remote_host="192.168.10.99"} 2078.72
node_scrape_collector_duration_seconds{collector="netflow"} 12.064428387
node_scrape_collector_success{collector="netflow"} 1
100 95019 0 95019 0 0 7873 0 --:--:-- 0:00:12 --:--:-- 23415
[root@hadoop1011 node_exporter-master]#
node_exporter注册自定义监控数据介绍到这里，后面还会继续优化。欢迎评论交流，转发和点赞，收藏！
同时也介绍下公众号：运维仙人，期待您的关注。
