叶哥Linux技术分享

主题

Prometheus Exporter开发 ​

课程目标 ​

  • 了解Prometheus Exporter的工作原理
  • 掌握自定义Prometheus Exporter的开发方法
  • 学会使用不同语言开发Exporter
  • 理解Exporter的部署和集成方法

1. Prometheus Exporter概述 ​

1.1 什么是Prometheus Exporter ​

Prometheus Exporter是一种用于暴露监控指标的组件，它将系统、应用或服务的指标转换为Prometheus可识别的格式，并通过HTTP接口提供给Prometheus服务器抓取。

1.2 Exporter的工作原理 ​

  1. 指标收集：Exporter从目标系统收集监控指标
  2. 指标转换：将收集到的指标转换为Prometheus支持的格式
  3. 指标暴露：通过HTTP接口（通常是/metrics端点）暴露指标
  4. 指标抓取：Prometheus服务器定期抓取这些指标

1.3 Exporter的类型 ​

  1. 官方Exporter：由Prometheus团队维护的Exporter

    • Node Exporter：系统指标
    • MySQL Exporter：MySQL指标
    • Redis Exporter：Redis指标

  2. 社区Exporter：由社区维护的Exporter

    • 各种第三方应用的Exporter

  3. 自定义Exporter：根据特定需求开发的Exporter

    • 针对特定应用或服务的Exporter

2. Prometheus Exporter开发准备 ​

2.1 开发环境搭建 ​

bash
# 安装Go（推荐用于开发Exporter）
wget https://golang.org/dl/go1.20.0.linux-amd64.tar.gz
tar -C /usr/local -xzf go1.20.0.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin

# 验证安装
go version

# 安装Prometheus客户端库
go get github.com/prometheus/client_golang/prometheus
go get github.com/prometheus/client_golang/prometheus/promhttp

2.2 Exporter开发目录结构 ​

my_exporter/
├── main.go          # Exporter主文件
├── collector/       # 指标收集器目录
│   ├── cpu.go       # CPU指标收集器
│   ├── memory.go    # 内存指标收集器
│   └── disk.go      # 磁盘指标收集器
├── config/          # 配置目录
│   └── config.go    # 配置文件
├── README.md        # 说明文档
└── go.mod           # Go模块文件

3. 使用Go语言开发Prometheus Exporter ​

3.1 基本Exporter结构 ​

go
package main

import (
	"log"
	"net/http"

	"github.com/prometheus/client_golang/prometheus"
	"github.com/prometheus/client_golang/prometheus/promhttp"
)

// 定义指标
var (
	// 计数器类型指标
	requestsTotal = prometheus.NewCounter(
		prometheus.CounterOpts{
			Name: "my_exporter_requests_total",
			Help: "Total number of requests",
		},
	)

	//  gauge类型指标
	cpuUsage = prometheus.NewGauge(
		prometheus.GaugeOpts{
			Name: "my_exporter_cpu_usage",
			Help: "CPU usage percentage",
		},
	)

	// 直方图类型指标
	responseTime = prometheus.NewHistogram(
		prometheus.HistogramOpts{
			Name: "my_exporter_response_time_seconds",
			Help: "Response time in seconds",
		},
	)
)

func init() {
	// 注册指标到默认注册表
	prometheus.MustRegister(requestsTotal)
	prometheus.MustRegister(cpuUsage)
	prometheus.MustRegister(responseTime)
}

func main() {
	// 设置HTTP处理函数
	http.Handle("/metrics", promhttp.Handler())

	// 启动HTTP服务器
	log.Println("Starting server on :9100")
	if err := http.ListenAndServe(":9100", nil); err != nil {
		log.Fatalf("Error starting server: %v", err)
	}
}

3.2 自定义收集器 ​

go
package collector

import (
	"fmt"
	"os/exec"
	"strconv"
	"strings"

	"github.com/prometheus/client_golang/prometheus"
)

// CPUCollector 收集CPU指标
type CPUCollector struct {
	cpuUsage *prometheus.GaugeVec
}

// NewCPUCollector 创建CPU收集器
func NewCPUCollector() *CPUCollector {
	return &CPUCollector{
		cpuUsage: prometheus.NewGaugeVec(
			prometheus.GaugeOpts{
				Name: "node_cpu_usage_percent",
				Help: "CPU usage percentage",
			},
			[]string{"cpu"},
		),
	}
}

// Describe 实现Collector接口
func (c *CPUCollector) Describe(ch chan<- *prometheus.Desc) {
	c.cpuUsage.Describe(ch)
}

// Collect 实现Collector接口
func (c *CPUCollector) Collect(ch chan<- prometheus.Metric) {
	// 收集CPU使用率
	usage, err := c.getCPUUsage()
	if err != nil {
		fmt.Printf("Error getting CPU usage: %v\n", err)
		return
	}

	for cpu, value := range usage {
		c.cpuUsage.WithLabelValues(cpu).Set(value)
	}

	c.cpuUsage.Collect(ch)
}

// getCPUUsage 获取CPU使用率
func (c *CPUCollector) getCPUUsage() (map[string]float64, error) {
	// 执行top命令获取CPU使用率
	cmd := exec.Command("top", "-bn1")
	output, err := cmd.CombinedOutput()
	if err != nil {
		return nil, fmt.Errorf("error executing top: %w", err)
	}

	usage := make(map[string]float64)
	lines := strings.Split(string(output), "\n")

	for _, line := range lines {
		if strings.HasPrefix(line, "%Cpu") {
			// 解析CPU使用率
			parts := strings.Fields(line)
			if len(parts) > 1 {
				// 计算空闲CPU百分比
				idleStr := parts[len(parts)-1]
				idle, err := strconv.ParseFloat(strings.TrimSuffix(idleStr, "%"), 64)
				if err != nil {
					continue
				}
				// 计算使用CPU百分比
				usage["total"] = 100 - idle
			}
			break
		}
	}

	return usage, nil
}

3.3 完整的Exporter实现 ​

go
package main

import (
	"fmt"
	"log"
	"net/http"
	"os"

	"github.com/prometheus/client_golang/prometheus"
	"github.com/prometheus/client_golang/prometheus/promhttp"
	"github.com/prometheus/common/version"
)

// 导入自定义收集器
import (
	"my_exporter/collector"
)

func init() {
	// 设置版本信息
	prometheus.MustRegister(version.NewCollector("my_exporter"))
}

func main() {
	// 创建收集器注册表
	registry := prometheus.NewRegistry()

	// 注册版本信息
	registry.MustRegister(version.NewCollector("my_exporter"))

	// 创建并注册CPU收集器
	cpuCollector := collector.NewCPUCollector()
	registry.MustRegister(cpuCollector)

	// 创建并注册内存收集器
	memoryCollector := collector.NewMemoryCollector()
	registry.MustRegister(memoryCollector)

	// 创建并注册磁盘收集器
	diskCollector := collector.NewDiskCollector()
	registry.MustRegister(diskCollector)

	// 设置HTTP处理函数
	http.Handle("/metrics", promhttp.HandlerFor(registry, promhttp.HandlerOpts{}))
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "<html>\n")
		fmt.Fprintf(w, "<head><title>My Exporter</title></head>\n")
		fmt.Fprintf(w, "<body>\n")
		fmt.Fprintf(w, "<h1>My Exporter</h1>\n")
		fmt.Fprintf(w, "<p><a href='/metrics'>Metrics</a></p>\n")
		fmt.Fprintf(w, "<p>Version: %s</p>\n", version.Info())
		fmt.Fprintf(w, "</body>\n")
		fmt.Fprintf(w, "</html>\n")
	})

	// 获取端口配置
	port := os.Getenv("EXPORTER_PORT")
	if port == "" {
		port = "9100"
	}

	// 启动HTTP服务器
	log.Printf("Starting server on :%s", port)
	if err := http.ListenAndServe(":"+port, nil); err != nil {
		log.Fatalf("Error starting server: %v", err)
	}
}

3. 使用Python开发Prometheus Exporter ​

3.1 Python Exporter基本结构 ​

python
#!/usr/bin/env python3

"""
Python Prometheus Exporter示例
"""

import prometheus_client
from prometheus_client import Counter, Gauge, Histogram
import time
import http.server
import socketserver
import random

# 定义指标
REQUESTS = Counter('my_exporter_requests_total', 'Total requests')
CPU_USAGE = Gauge('my_exporter_cpu_usage', 'CPU usage percentage')
RESPONSE_TIME = Histogram('my_exporter_response_time_seconds', 'Response time in seconds')

# 模拟CPU使用率
def update_cpu_usage():
    while True:
        # 模拟CPU使用率在10-90%之间
        usage = 10 + random.random() * 80
        CPU_USAGE.set(usage)
        time.sleep(5)

# 自定义HTTP请求处理器
class MyRequestHandler(http.server.BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path == '/metrics':
            # 增加请求计数
            REQUESTS.inc()
            
            # 记录响应时间
            start_time = time.time()
            
            # 发送指标
            self.send_response(200)
            self.send_header('Content-Type', prometheus_client.CONTENT_TYPE_LATEST)
            self.end_headers()
            self.wfile.write(prometheus_client.generate_latest())
            
            # 记录响应时间
            response_time = time.time() - start_time
            RESPONSE_TIME.observe(response_time)
        else:
            # 处理其他路径
            self.send_response(200)
            self.send_header('Content-Type', 'text/html')
            self.end_headers()
            self.wfile.write(b"<html><body><h1>My Exporter</h1><p><a href='/metrics'>Metrics</a></p></body></html>")

if __name__ == '__main__':
    # 启动CPU使用率更新线程
    import threading
    cpu_thread = threading.Thread(target=update_cpu_usage)
    cpu_thread.daemon = True
    cpu_thread.start()
    
    # 启动HTTP服务器
    PORT = 9100
    with socketserver.TCPServer(("", PORT), MyRequestHandler) as httpd:
        print(f"Server started on port {PORT}")
        httpd.serve_forever()

3.2 Python自定义收集器 ​

python
#!/usr/bin/env python3

"""
Python自定义收集器示例
"""

import prometheus_client
from prometheus_client import Gauge
import psutil
import time
import http.server
import socketserver

# 自定义收集器类
class SystemCollector:
    def __init__(self):
        # 定义指标
        self.cpu_usage = Gauge('system_cpu_usage_percent', 'CPU usage percentage', ['core'])
        self.memory_usage = Gauge('system_memory_usage_percent', 'Memory usage percentage')
        self.disk_usage = Gauge('system_disk_usage_percent', 'Disk usage percentage', ['mountpoint'])
    
    def collect(self):
        # 收集CPU使用率
        cpu_percent = psutil.cpu_percent(interval=1, percpu=True)
        for i, usage in enumerate(cpu_percent):
            self.cpu_usage.labels(core=f'core{i}').set(usage)
        
        # 收集内存使用率
        memory = psutil.virtual_memory()
        self.memory_usage.set(memory.percent)
        
        # 收集磁盘使用率
        partitions = psutil.disk_partitions()
        for partition in partitions:
            if partition.mountpoint in ['/', '/boot', '/home']:
                try:
                    usage = psutil.disk_usage(partition.mountpoint)
                    self.disk_usage.labels(mountpoint=partition.mountpoint).set(usage.percent)
                except:
                    pass

# 初始化收集器
collector = SystemCollector()

# 定期收集指标
def collect_metrics():
    while True:
        collector.collect()
        time.sleep(10)

# 自定义HTTP请求处理器
class MyRequestHandler(http.server.BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path == '/metrics':
            # 发送指标
            self.send_response(200)
            self.send_header('Content-Type', prometheus_client.CONTENT_TYPE_LATEST)
            self.end_headers()
            self.wfile.write(prometheus_client.generate_latest())
        else:
            # 处理其他路径
            self.send_response(200)
            self.send_header('Content-Type', 'text/html')
            self.end_headers()
            self.wfile.write(b"<html><body><h1>System Exporter</h1><p><a href='/metrics'>Metrics</a></p></body></html>")

if __name__ == '__main__':
    # 启动指标收集线程
    import threading
    collect_thread = threading.Thread(target=collect_metrics)
    collect_thread.daemon = True
    collect_thread.start()
    
    # 启动HTTP服务器
    PORT = 9100
    with socketserver.TCPServer(("", PORT), MyRequestHandler) as httpd:
        print(f"Server started on port {PORT}")
        httpd.serve_forever()

4. Exporter的配置和部署 ​

4.1 Exporter配置 ​

  1. 命令行参数：
go
// 命令行参数配置
flag.StringVar(&listenAddr, "web.listen-address", ":9100", "Address to listen on for web interface and telemetry")
flag.StringVar(&metricsPath, "web.telemetry-path", "/metrics", "Path under which to expose metrics")
flag.StringVar(&configFile, "config.file", "", "Path to configuration file")
flag.Parse()
  1. 配置文件：
yaml
# 配置文件示例
collector:
  cpu: true
  memory: true
  disk: true
  network: false

web:
  listen_address: ":9100"
  telemetry_path: "/metrics"

log:
  level: "info"

4.2 Exporter部署 ​

  1. 二进制部署：
bash
# 编译Exporter
go build -o my_exporter main.go

# 运行Exporter
./my_exporter --web.listen-address=":9100" --web.telemetry-path="/metrics"
  1. 系统服务部署：
bash
# 创建系统服务文件
cat > /etc/systemd/system/my_exporter.service << 'EOF'
[Unit]
Description=My Prometheus Exporter
After=network.target

[Service]
Type=simple
User=prometheus
ExecStart=/usr/local/bin/my_exporter --web.listen-address=":9100"
Restart=always

[Install]
WantedBy=multi-user.target
EOF

# 启用并启动服务
systemctl daemon-reload
systemctl enable my_exporter
systemctl start my_exporter
  1. Docker部署：
bash
# 创建Dockerfile
cat > Dockerfile << 'EOF'
FROM golang:1.20 as builder
WORKDIR /app
COPY . .
RUN go build -o my_exporter main.go

FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/my_exporter /app/
EXPOSE 9100
CMD ["/app/my_exporter", "--web.listen-address=":9100""]
EOF

# 构建Docker镜像
docker build -t my_exporter .

# 运行Docker容器
docker run -d --name my_exporter -p 9100:9100 my_exporter
  1. Kubernetes部署：
yaml
# 创建Deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-exporter
  labels:
    app: my-exporter
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-exporter
  template:
    metadata:
      labels:
        app: my-exporter
      annotations:
        prometheus.io/scrape: "true"
        prometheus.io/port: "9100"
        prometheus.io/path: "/metrics"
    spec:
      containers:
      - name: my-exporter
        image: my_exporter:latest
        ports:
        - containerPort: 9100
        resources:
          limits:
            cpu: 100m
            memory: 128Mi
          requests:
            cpu: 50m
            memory: 64Mi
---
# 创建Service
apiVersion: v1
kind: Service
metadata:
  name: my-exporter
  labels:
    app: my-exporter
spec:
  selector:
    app: my-exporter
  ports:
  - port: 9100
    targetPort: 9100
    name: metrics

5. Exporter的集成和监控 ​

5.1 配置Prometheus抓取 ​

yaml
# prometheus.yml
scrape_configs:
  - job_name: 'my_exporter'
    static_configs:
      - targets: ['my-exporter:9100']
    scrape_interval: 15s
    scrape_timeout: 10s

5.2 创建Grafana仪表板 ​

  1. 导入仪表板：

    • 可以从Grafana.com导入现有的仪表板
    • 也可以创建自定义仪表板

  2. 仪表板示例：

    • CPU使用率图表
    • 内存使用率图表
    • 磁盘使用率图表
    • 请求计数图表

5.3 设置告警规则 ​

yaml
# 告警规则示例
groups:
- name: my_exporter_alerts
  rules:
  - alert: HighCPUUsage
    expr: avg(node_cpu_usage_percent{cpu="total"}) > 80
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "High CPU usage detected"
      description: "CPU usage is above 80% for 5 minutes"

  - alert: HighMemoryUsage
    expr: system_memory_usage_percent > 85
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "High memory usage detected"
      description: "Memory usage is above 85% for 5 minutes"

  - alert: HighDiskUsage
    expr: system_disk_usage_percent > 90
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: "High disk usage detected"
      description: "Disk usage is above 90% for 5 minutes"

6. 实战案例：服务器状态监控Exporter ​

6.1 功能需求 ​

  • 监控服务器的CPU使用率
  • 监控服务器的内存使用率
  • 监控服务器的磁盘使用率
  • 监控服务器的网络流量
  • 监控服务器的进程状态

6.2 Go语言实现 ​

go
package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
	"os/exec"
	"strconv"
	"strings"
	"time"

	"github.com/prometheus/client_golang/prometheus"
	"github.com/prometheus/client_golang/prometheus/promhttp"
	"github.com/prometheus/common/version"
)

// ServerCollector 收集服务器指标
type ServerCollector struct {
	cpuUsage    *prometheus.GaugeVec
	memoryUsage *prometheus.Gauge
	diskUsage   *prometheus.GaugeVec
	networkRx   *prometheus.CounterVec
	networkTx   *prometheus.CounterVec
	processes   *prometheus.Gauge
}

// NewServerCollector 创建服务器收集器
func NewServerCollector() *ServerCollector {
	return &ServerCollector{
		cpuUsage: prometheus.NewGaugeVec(
			prometheus.GaugeOpts{
				Name: "server_cpu_usage_percent",
				Help: "CPU usage percentage",
			},
			[]string{"cpu"},
		),
		memoryUsage: prometheus.NewGauge(
			prometheus.GaugeOpts{
				Name: "server_memory_usage_percent",
				Help: "Memory usage percentage",
			},
		),
		diskUsage: prometheus.NewGaugeVec(
			prometheus.GaugeOpts{
				Name: "server_disk_usage_percent",
				Help: "Disk usage percentage",
			},
			[]string{"mountpoint"},
		),
		networkRx: prometheus.NewCounterVec(
			prometheus.CounterOpts{
				Name: "server_network_receive_bytes_total",
				Help: "Network received bytes total",
			},
			[]string{"interface"},
		),
		networkTx: prometheus.NewCounterVec(
			prometheus.CounterOpts{
				Name: "server_network_transmit_bytes_total",
				Help: "Network transmitted bytes total",
			},
			[]string{"interface"},
		),
		processes: prometheus.NewGauge(
			prometheus.GaugeOpts{
				Name: "server_process_count",
				Help: "Number of processes",
			},
		),
	}
}

// Describe 实现Collector接口
func (c *ServerCollector) Describe(ch chan<- *prometheus.Desc) {
	c.cpuUsage.Describe(ch)
	c.memoryUsage.Describe(ch)
	c.diskUsage.Describe(ch)
	c.networkRx.Describe(ch)
	c.networkTx.Describe(ch)
	c.processes.Describe(ch)
}

// Collect 实现Collector接口
func (c *ServerCollector) Collect(ch chan<- prometheus.Metric) {
	// 收集CPU使用率
	c.collectCPUUsage()

	// 收集内存使用率
	c.collectMemoryUsage()

	// 收集磁盘使用率
	c.collectDiskUsage()

	// 收集网络流量
	c.collectNetworkTraffic()

	// 收集进程数量
	c.collectProcessCount()

	// 发送指标
	c.cpuUsage.Collect(ch)
	c.memoryUsage.Collect(ch)
	c.diskUsage.Collect(ch)
	c.networkRx.Collect(ch)
	c.networkTx.Collect(ch)
	c.processes.Collect(ch)
}

// collectCPUUsage 收集CPU使用率
func (c *ServerCollector) collectCPUUsage() {
	cmd := exec.Command("top", "-bn1")
	output, err := cmd.CombinedOutput()
	if err != nil {
		log.Printf("Error collecting CPU usage: %v", err)
		return
	}

	lines := strings.Split(string(output), "\n")
	for _, line := range lines {
		if strings.HasPrefix(line, "%Cpu") {
			parts := strings.Fields(line)
			if len(parts) > 1 {
				idleStr := parts[len(parts)-1]
				idle, err := strconv.ParseFloat(strings.TrimSuffix(idleStr, "%"), 64)
				if err == nil {
					c.cpuUsage.WithLabelValues("total").Set(100 - idle)
				}
			}
			break
		}
	}
}

// collectMemoryUsage 收集内存使用率
func (c *ServerCollector) collectMemoryUsage() {
	cmd := exec.Command("free", "-m")
	output, err := cmd.CombinedOutput()
	if err != nil {
		log.Printf("Error collecting memory usage: %v", err)
		return
	}

	lines := strings.Split(string(output), "\n")
	for _, line := range lines {
		if strings.HasPrefix(line, "Mem:") {
			parts := strings.Fields(line)
			if len(parts) >= 3 {
				total, _ := strconv.ParseFloat(parts[1], 64)
				used, _ := strconv.ParseFloat(parts[2], 64)
				usage := (used / total) * 100
				c.memoryUsage.Set(usage)
			}
			break
		}
	}
}

// collectDiskUsage 收集磁盘使用率
func (c *ServerCollector) collectDiskUsage() {
	cmd := exec.Command("df", "-h")
	output, err := cmd.CombinedOutput()
	if err != nil {
		log.Printf("Error collecting disk usage: %v", err)
		return
	}

	lines := strings.Split(string(output), "\n")
	for i, line := range lines {
		if i == 0 {
			continue // 跳过表头
		}
		parts := strings.Fields(line)
		if len(parts) >= 6 {
			mountpoint := parts[5]
			usageStr := strings.TrimSuffix(parts[4], "%")
			usage, err := strconv.ParseFloat(usageStr, 64)
			if err == nil {
				c.diskUsage.WithLabelValues(mountpoint).Set(usage)
			}
		}
	}
}

// collectNetworkTraffic 收集网络流量
func (c *ServerCollector) collectNetworkTraffic() {
	cmd := exec.Command("ifconfig")
	output, err := cmd.CombinedOutput()
	if err != nil {
		log.Printf("Error collecting network traffic: %v", err)
		return
	}

	// 简化实现，实际项目中应解析/proc/net/dev
	interfaces := []string{"eth0", "eth1", "wlan0"}
	for _, iface := range interfaces {
		// 模拟网络流量数据
		c.networkRx.WithLabelValues(iface).Inc(100)
		c.networkTx.WithLabelValues(iface).Inc(50)
	}
}

// collectProcessCount 收集进程数量
func (c *ServerCollector) collectProcessCount() {
	cmd := exec.Command("ps", "aux")
	output, err := cmd.CombinedOutput()
	if err != nil {
		log.Printf("Error collecting process count: %v", err)
		return
	}

	lines := strings.Split(string(output), "\n")
	c.processes.Set(float64(len(lines) - 1)) // 减去表头
}

func init() {
	prometheus.MustRegister(version.NewCollector("server_exporter"))
}

func main() {
	// 解析命令行参数
	listenAddr := ":9100"
	metricsPath := "/metrics"

	// 创建收集器
	serverCollector := NewServerCollector()

	// 创建注册表
	registry := prometheus.NewRegistry()
	registry.MustRegister(version.NewCollector("server_exporter"))
	registry.MustRegister(serverCollector)

	// 设置HTTP处理函数
	http.Handle(metricsPath, promhttp.HandlerFor(registry, promhttp.HandlerOpts{}))
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "<html>\n")
		fmt.Fprintf(w, "<head><title>Server Exporter</title></head>\n")
		fmt.Fprintf(w, "<body>\n")
		fmt.Fprintf(w, "<h1>Server Exporter</h1>\n")
		fmt.Fprintf(w, "<p><a href='%s'>Metrics</a></p>\n", metricsPath)
		fmt.Fprintf(w, "<p>Version: %s</p>\n", version.Info())
		fmt.Fprintf(w, "</body>\n")
		fmt.Fprintf(w, "</html>\n")
	})

	// 启动HTTP服务器
	log.Printf("Starting server on %s", listenAddr)
	if err := http.ListenAndServe(listenAddr, nil); err != nil {
		log.Fatalf("Error starting server: %v", err)
	}
}

6.3 部署和使用 ​

  1. 编译和运行：
bash
# 编译
go build -o server_exporter main.go

# 运行
./server_exporter
  1. 验证指标：
bash
# 查看指标
curl http://localhost:9100/metrics
  1. 配置Prometheus：
yaml
scrape_configs:
  - job_name: 'server_exporter'
    static_configs:
      - targets: ['localhost:9100']
    scrape_interval: 15s
  1. 创建Grafana仪表板：
    • 导入仪表板ID：12345（示例）
    • 或创建自定义仪表板

7. Exporter开发最佳实践 ​

7.1 代码规范 ​

  1. 命名规范：

    • 指标名称应使用snake_case格式
    • 指标名称应包含单位（如_bytes, _seconds）
    • 标签名称应使用snake_case格式

  2. 指标类型选择：

    • Counter：用于单调递增的指标（如请求计数）
    • Gauge：用于可增可减的指标（如CPU使用率）
    • Histogram：用于分布情况的指标（如响应时间）
    • Summary：用于分位数统计的指标（如延迟）

  3. 代码结构：

    • 使用模块化设计
    • 分离收集逻辑和暴露逻辑
    • 使用接口定义收集器

7.2 性能优化 ​

  1. 收集频率：

    • 避免过于频繁的收集
    • 根据指标的变化频率调整收集间隔

  2. 资源使用：

    • 避免使用过多的内存
    • 避免使用过多的CPU
    • 避免产生过多的网络流量

  3. 错误处理：

    • 适当处理错误，避免Exporter崩溃
    • 记录错误日志，但不要暴露敏感信息

7.3 安全性 ​

  1. 认证和授权：

    • 考虑添加基本认证
    • 考虑使用TLS加密

  2. 输入验证：

    • 验证所有输入参数
    • 避免命令注入攻击

  3. 信息泄露：

    • 不要在指标中暴露敏感信息
    • 不要在错误消息中暴露敏感信息

8. 课程总结 ​

8.1 重点回顾 ​

  • Prometheus Exporter工作原理：掌握Exporter的基本工作原理和架构
  • Exporter开发方法：学会使用Go和Python开发自定义Exporter
  • Exporter部署和集成：掌握Exporter的部署方法和与Prometheus的集成
  • Exporter最佳实践：遵循Exporter开发的最佳实践

8.2 实践建议 ​

  1. 从简单开始：先开发简单的Exporter，逐步增加复杂度
  2. 参考现有Exporter：学习官方和社区Exporter的实现方法
  3. 测试充分：在不同环境中测试Exporter的可靠性
  4. 文档完善：为Exporter提供详细的文档和使用说明

8.3 进阶学习 ​

  • Operator开发：学习开发Kubernetes Operator
  • Service Mesh：学习Istio等服务网格技术
  • 可观测性平台：学习构建完整的可观测性平台
  • AI驱动的监控：学习使用AI技术增强监控能力

通过本课程的学习，你已经掌握了Prometheus Exporter的开发方法，可以根据实际需求开发各种类型的Exporter，为监控系统提供更多有价值的指标数据。

评论区

专业的Linux技术学习平台，从入门到精通的完整学习路径

Copyright © 2026 叶哥Linux技术分享 - linuxeasy.site