Prometheus Client: 優秀的時序資料庫監控工具

一、PrometheusClient概述

PrometheusClient是一個用於監控時序資料庫系統的Go庫，它實現了一組用於監控系統的API，可通過HTTP請求進行訪問。PrometheusClient可以在多種編程語言中用於監控和數據採集，包括Go語言、Python語言等。

PrometheusClient的核心是一個本地時序資料庫，用於存儲系統的監控數據。Prometheus通過在系統中運行一組HTTP客戶端，將監控數據採集到時序資料庫中。時序資料庫和其他常規資料庫有所不同，它們專註於存儲按時間順序採集的樣本數據，以及按屬性標識的時間序列。

PrometheusClient的API提供了豐富的查詢功能，可以實現基於您的監控數據和其他系統數據的強大分析和預測能力。PrometheusClient可以與Grafana等其他數據可視化工具相集成，以便將監控數據可視化呈現。

二、PrometheusClient的安裝和使用

以下是一個簡單的示例，演示如何使用PrometheusClient監控一個Web應用程序的請求數量：

安裝PrometheusClient

go get github.com/prometheus/client_golang/prometheus

這將下載PrometheusClient的源代碼，並將其安裝在您的Go路徑下。

導入PrometheusClient庫

import (
    "net/http"

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

導入PrometheusClient庫，並使用PrometheusClient的API。

定義統計信息的計數器

var (
    requestsTotal = prometheus.NewCounter(prometheus.CounterOpts{
        Name: "example_requests_total",
        Help: "Number of requests received.",
    })
)

創建一個名為requestsTotal的計數器，用於跟蹤總請求數量。

註冊計數器

func init() {
    prometheus.MustRegister(requestsTotal)
}

在init函數中註冊requestsTotal計數器。這將在程序啟動時自動執行。

增加計數器的值

http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    requestsTotal.Inc()
    fmt.Fprintf(w, "Hello, world!")
})

在處理HTTP請求時，使用requestsTotal.Inc()來增加計數器的值。

將Prometheus客戶端Handler註冊到默認HTTP伺服器上

http.Handle("/metrics", promhttp.Handler())
http.ListenAndServe(":8080", nil)

將Prometheus客戶端Handler註冊到默認HTTP伺服器上。這允許Prometheus進行採樣和讀取計數器值的操作。

三、PrometheusClient的使用案例

案例一：監控HTTP請求數量

使用PrometheusClient監控HTTP請求數量和響應時間，以下是示例代碼：

// 定義請求數量和響應時間的計數器和序列
var (
    httpRequestsTotal = prometheus.NewCounterVec(prometheus.CounterOpts{
        Name: "http_requests_total",
        Help: "Number of HTTP requests.",
    }, []string{"code", "method"})

    httpRequestDuration = prometheus.NewSummaryVec(prometheus.SummaryOpts{
        Name: "http_request_duration_seconds",
        Help: "Duration of HTTP requests.",
    }, []string{"code", "method"})
)

// 將計數器和序列註冊到客戶端
func init() {
    prometheus.MustRegister(httpRequestsTotal)
    prometheus.MustRegister(httpRequestDuration)
}

// 記錄請求
func recordRequestCodeAndDuration(r *http.Request, start time.Time, code int) {
    // 計算響應時間
    duration := time.Since(start).Seconds()
    // 計數器增加數量
    httpRequestsTotal.With(prometheus.Labels{"code": strconv.Itoa(code), "method": r.Method}).Inc()
    // 序列增加響應時間
    httpRequestDuration.With(prometheus.Labels{"code": strconv.Itoa(code), "method": r.Method}).Observe(duration)
}

// 創建http.Handler
func main() {
    r := mux.NewRouter()

    // 記錄請求
    r.Use(func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            start := time.Now()
            // 執行下一個處理程序
            next.ServeHTTP(w, r)
            recordRequestCodeAndDuration(r, start, http.StatusOK)
        })
    })

    // 監控所有"/api"請求
    r.Handle("/api", promhttp.InstrumentHandlerDuration(httpRequestDuration.MustCurryWith(prometheus.Labels{"context": "api"}),
        promhttp.InstrumentHandlerCounter(httpRequestsTotal.MustCurryWith(prometheus.Labels{"context": "api"}),
        http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            // 執行操作
         })
    ))

    http.ListenAndServe(":8080", r)
}

此代碼創建了兩個prometheus CounterVec對象和一個SummerVec對象，以記錄所有進入HTTP處理程序的請求數量和處理請求的持續時間。然後，它們使用prometheus.MustRegister方法註冊到客戶端，以允許Prometheus查詢計數器值。最後，使用promhttp.InstrumentHandlerDuration和promhttp.InstrumentHandlerCounter在mux Router上監控所有請求。

案例二：監控Docker容器操作系統狀態

使用PrometheusClient監控Docker守護程序的容器操作系統狀態，以下是示例代碼：

// 定義容器狀態
type ContainerStatus struct {
    Name        string            `json:"name"`
    HostName    string            `json:"hostname"`
    Status      string            `json:"status"`
    CreatedTime string            `json:"created_time"`
}

// 獲取容器狀態
func getContainerStatus() ([]ContainerStatus, error) {
    // 獲取所有容器 ID
    containerIDs, err := getContainerIDs()
    if err != nil {
        return nil, err
    }

    var containerStatuses []ContainerStatus

    // 根據容器 ID 獲取容器狀態
    for _, containerID := range containerIDs {
        cmd := exec.Command("docker", "inspect", "-f", "{{json .State}}", containerID)
        stdout, err := cmd.StdoutPipe()
        if err != nil {
            return nil, err
        }

        if err := cmd.Start(); err != nil {
            return nil, err
        }

        var status map[string]interface{}
        if err := json.NewDecoder(stdout).Decode(&status); err != nil {
            return nil, err
        }

        // 排除已停止的容器
        if status["Running"] == true {
            containerName := status["Name"].(string)
            containerStartTime := time.Unix(0, int64(status["StartedAt"].(float64))*int64(time.Millisecond))
            containerStatuses = append(containerStatuses, ContainerStatus{
                Name:        strings.TrimPrefix(containerName, "/"),
                HostName:    getHostName(),
                Status:      "running",
                CreatedTime: containerStartTime.Format("2006-01-02 15:04:05"),
            })
        }

        if err := cmd.Wait(); err != nil {
            return nil, err
        }
    }

    return containerStatuses, nil
}

// 定義容器狀態的 Gauge 和 Rating
var (
    ContainerUp = prometheus.NewGaugeVec(prometheus.GaugeOpts{
        Name: "container_up",
        Help: "Container up",
    }, []string{"container"})

    ContainerStartTime = prometheus.NewGaugeVec(prometheus.GaugeOpts{
        Name: "container_start_time",
        Help: "Container start time",
    }, []string{"container"})
)

// 註冊 Gauge 和 Rating
func init() {
    prometheus.MustRegister(ContainerUp)
    prometheus.MustRegister(ContainerStartTime)
}

// 獲取主機名
func getHostName() string {
    if hn, err := os.Hostname(); err == nil {
        return hn
    }
    return ""
}

// 獲取容器 ID 列表
func getContainerIDs() ([]string, error) {
    cmd := exec.Command("docker", "ps", "-q")
    stdout, err := cmd.StdoutPipe()
    if err != nil {
        return nil, err
    }

    if err := cmd.Start(); err != nil {
        return nil, err
    }

    var containerIDs []string
    scanner := bufio.NewScanner(stdout)
    for scanner.Scan() {
        containerIDs = append(containerIDs, scanner.Text())
    }

    if err := cmd.Wait(); err != nil {
        return nil, err
    }

    return containerIDs, nil
}

// 主函數
func main() {
    // 定時獲取容器狀態
    go func() {
        for {
            containerStatuses, err := getContainerStatus()
            if err != nil {
                log.Printf("Failed to get container statuses: %s\n", err)
                continue
            }

            for _, container := range containerStatuses {
                ContainerUp.WithLabelValues(container.Name).Set(1)
                if timeSinceStart, err := time.ParseDuration(time.Since(containerStartTime).String()); err == nil {
                    ContainerStartTime.WithLabelValues(container.Name).Set(timeSinceStart.Seconds())
                }
            }

            time.Sleep(time.Minute)
        }
    }()
    http.Handle("/metrics", promhttp.Handler())
    http.ListenAndServe(":8080", nil)
}

此代碼創建了兩個GaugeVec對象（ContainerUp和ContainerStartTime），以記錄將運行的容器數量以及容器的啟動時間。使用prometheus.MustRegister方法將它們註冊到Prometheus客戶端，以允許Prometheus查詢Gauge值。此外，還定期查詢所有容器的ID，根據ID獲取各個容器的狀態並上傳到Prometheus。

四、總結

PrometheusClient在實時監控、分析和預測數據方面非常有價值。它易於部署，靈活性高，並且與多種數據可視化工具集成。這使它成為許多組織在生產環境中部署和管理大規模數據中心所需的理想選擇。

原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-tw/n/285267.html