Golang-Entwicklung: Verwenden Sie Prometheus, um die Anwendungsleistung zu überwachen

Golang-Entwicklung: Für die Verwendung von Prometheus zur Überwachung der Anwendungsleistung sind bestimmte Codebeispiele erforderlich.

Zusammenfassung: Dieser Artikel stellt vor, wie die Prometheus-Bibliothek in der Golang-Entwicklung zur Überwachung der Anwendungsleistung verwendet wird, und stellt spezifische Codebeispiele bereit, um Entwicklern einen schnellen Einstieg zu erleichtern .

Einführung:

In der modernen Anwendungsentwicklung ist die Überwachung der Anwendungsleistung ein sehr wichtiger Schritt. Durch die Überwachung können wir den Betriebsstatus der Anwendung in Echtzeit verstehen, Probleme rechtzeitig erkennen und Anpassungen vornehmen und so die Stabilität und Leistung der Anwendung verbessern.

Prometheus ist ein Open-Source-Überwachungssystem und eine Zeitreihendatenbank, die im Überwachungsbereich von Cloud-nativen und containerisierten Anwendungen weit verbreitet ist. Es bietet eine Fülle von Überwachungsindikatortypen und -funktionen, mit denen wir Anwendungsleistungsindikatoren in Echtzeit überwachen können.

In diesem Artikel wird anhand eines konkreten Beispiels gezeigt, wie die Prometheus-Bibliothek in der Golang-Entwicklung zur Überwachung der Anwendungsleistung verwendet wird.

Schritt 1: Prometheus installieren und konfigurieren

Zuerst müssen wir Prometheus im System installieren und konfigurieren. Binärdateien können von der offiziellen Website (https://prometheus.io/) heruntergeladen und installiert werden.

Nach Abschluss der Installation müssen Sie die Prometheus-Konfigurationsdatei prometheus.yml konfigurieren. In der Konfigurationsdatei müssen wir die zu überwachenden Ziele und die entsprechenden Metriken definieren.

Wenn wir beispielsweise die Gesamtzahl der HTTP-Anfragen und die Anforderungsverzögerung einer Golang-Anwendung überwachen möchten, können wir die folgende Konfiguration hinzufügen:

scrape_configs:
  - job_name: 'my_app'
    metrics_path: /metrics
    static_configs:
    - targets: ['localhost:8080']

Schritt 2: Prometheus-Überwachungscode zur Golang-Anwendung hinzufügen

Als nächstes führen wir Sie müssen Prometheus zum Golang-Anwendungscode hinzufügen. Zuerst müssen wir die Prometheus-Bibliothek vorstellen:

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

Dann können wir die Indikatoren definieren, die überwacht werden müssen. In unserem Beispiel definieren wir einen Indikator zum Zählen der Gesamtzahl der Anfragen und einen Indikator zum Zählen von Anfrageverzögerungen:

var (
   requestsTotal = prometheus.NewCounterVec(
      prometheus.CounterOpts{
         Name: "http_requests_total",
         Help: "Total number of HTTP requests.",
      },
      []string{"handler", "method"},
   )
   requestDuration = prometheus.NewHistogramVec(
      prometheus.HistogramOpts{
         Name: "http_request_duration_seconds",
         Help: "HTTP request duration in seconds.",
         Buckets: []float64{0.1, 0.2, 0.5, 1, 2, 5},
      },
      []string{"handler", "method"},
   )
)

Als nächstes müssen wir den entsprechenden Überwachungscode zur Verarbeitungsfunktion der Anwendung hinzufügen. Zu Beginn und am Ende jeder Verarbeitungsfunktion können wir die von Prometheus bereitgestellten Überwachungsmethoden nutzen, um Daten zu sammeln und aufzuzeichnen.

Der folgende Code zeigt beispielsweise, wie Prometheus zur Überwachung von HTTP-Anfragen in Golang-Anwendungen verwendet wird:

func handleHello(w http.ResponseWriter, r *http.Request) {
   start := time.Now()

   // 执行实际的处理逻辑

   elapsedTime := time.Since(start).Seconds()
   requestsTotal.WithLabelValues("/hello", r.Method).Inc()
   requestDuration.WithLabelValues("/hello", r.Method).Observe(elapsedTime)
}

Abschließend müssen wir den HTTP-Prozessor von Prometheus einrichten, damit Prometheus die von uns definierten Indikatoren über die HTTP-Schnittstelle erhalten kann.

func main() {
   http.Handle("/metrics", promhttp.Handler())
   http.HandleFunc("/hello", handleHello)
   http.ListenAndServe(":8080", nil)
}

Schritt 3: Starten Sie die Anwendung und greifen Sie auf die Prometheus-Überwachungsschnittstelle zu.

Nach Abschluss der oben genannten Schritte können wir unsere Anwendung starten und auf die Prometheus-Überwachungsschnittstelle zugreifen. Geben Sie http://localhost:9090 in den Browser ein und geben Sie dann den von uns definierten Indikatornamen in das Abfragefeld ein, um die entsprechenden Leistungsindikatordaten anzuzeigen.

Zum Beispiel können wir die Gesamtzahl der Anfragen überprüfen, indem wir http_requests_total abfragen, und die Anforderungsverzögerung überprüfen, indem wir http_request_duration_seconds abfragen.

Zusammenfassung:

Dieser Artikel stellt vor, wie man die Prometheus-Bibliothek in der Golang-Entwicklung verwendet, um die Leistung von Anwendungen zu überwachen, und stellt spezifische Codebeispiele bereit. Über Prometheus können wir problemlos verschiedene Indikatoren der Anwendung sammeln und aufzeichnen und diese über die Prometheus-Überwachungsschnittstelle in Echtzeit anzeigen und analysieren.

Obwohl dieser Artikel nur die grundlegende Verwendung und Beispiele vorstellt, bietet Prometheus umfangreichere Funktionen und Skalierbarkeit, um den Überwachungsanforderungen verschiedener Szenarien und Bedürfnisse gerecht zu werden. Ich hoffe, dieser Artikel kann Lesern, die sich für Prometheus interessieren, helfen und zu mehr Erkundung und Übung anregen.

Das obige ist der detaillierte Inhalt vonGolang-Entwicklung: Verwenden Sie Prometheus, um die Anwendungsleistung zu überwachen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!