Überwachung von Microservices mit Prometheus und Grafana

Navendu Pottekkat

Navendu Pottekkat

June 8, 2023

Ecosystem

Kontinuierliche Überwachung ist entscheidend, um Microservice-Systeme robust zu machen. Ohne eine ordnungsgemäße Überwachung können Microservices schnell überlastet werden, was zu Fehlern und Leistungseinbußen führt.

Durch kontinuierliche Überwachung können Entwickler Probleme mit ihren Diensten sofort erkennen und Maßnahmen ergreifen, um größere Schäden zu verhindern. Sie bietet auch Einblicke in die Leistung Ihrer Dienste, sodass Sie fundierte Entscheidungen treffen können.

In diesem Artikel wird vorgestellt, wie Sie die Überwachung für Ihre Microservice-Anwendung mit zwei der beliebtesten Tools in diesem Bereich einrichten können: Prometheus und Grafana.

Der Quellcode und die Docker-Compose-Datei für dieses Tutorial sind in pottekkat/monitoring-101 verfügbar.

Grundlagen von Prometheus

Prometheus ist ein Open-Source-Tool zur Überwachung und Alarmierung. Es "zieht" Metriken (Messwerte) von Microservices ab, indem es HTTP-Anfragen sendet, und speichert die Ergebnisse in einer Zeitreihendatenbank.

Sie können Ihre Dienste instrumentieren, indem Sie die von Prometheus bereitgestellten Client-Bibliotheken verwenden. Dies ermöglicht es Ihnen, benutzerdefinierte Metriken aus Ihren Diensten zu erstellen und zu sammeln.

Prometheus verfügt auch über Exporter, mit denen Sie Metriken abrufen können, die nicht im Prometheus-Format vorliegen. Ein Exporter fungiert als Mittelsmann und transformiert die exportierten Daten in ein für Prometheus lesbares Format.

1-prometheus-architecture.png

Prometheus bietet eine leistungsstarke Abfragesprache, PromQL, um mit diesen gesammelten Daten zu arbeiten. Sie können PromQL verwenden, um komplexe Abfragen zu erstellen, die die Daten filtern, aggregieren und in das gewünschte Format transformieren.

Zusätzlich zum Abrufen von Metriken kann Prometheus auch Alarme auslösen, wenn festgelegte Schwellenwerte überschritten werden. Der Alarmmechanismus ist hochgradig konfigurierbar und kann Benachrichtigungen an Orte wie Slack oder E-Mail senden.

Prometheus verfügt über eine grafische Benutzeroberfläche, mit der Sie die gesammelten Metriken leicht visualisieren können. Es integriert sich auch mit anderen erweiterten Visualisierungstools wie Grafana.

prometheus-dashboard.png

Metriktypen

Prometheus bietet vier Kern-Metriktypen:

  1. Counter: Repräsentiert einen einzelnen monoton ansteigenden Zähler. Sein Wert kann ansteigen oder bei einem Neustart auf Null zurückgesetzt werden. Sie können ihn verwenden, um Metriken wie die Anzahl der bearbeiteten Anfragen darzustellen.
  2. Gauge: Repräsentiert einen numerischen Wert, der steigen oder fallen kann. Sie können ihn verwenden, um Werte wie Speichernutzung oder die Anzahl der Anfragen pro Sekunde darzustellen.
  3. Histogram: Stichproben von Daten in konfigurierbare Buckets. Verwenden Sie es, um Werte wie Anforderungsdauern oder Antwortgrößen darzustellen.
  4. Summary: Ähnlich wie das Histogram berechnet es auch konfigurierbare Werte über ein gleitendes Zeitfenster.

Weitere Informationen zu diesen Metriktypen und deren Verwendung finden Sie in der offiziellen Dokumentation.

Beispielanwendung

Unsere Beispielanwendung besteht aus einem API-Gateway, einer Go-App und einer Python-App.

2-sample-app-flowchart.png

Die Anwendung gibt "Hallo <name>!" in der von Ihnen gewählten Sprache mit dem von Ihnen angegebenen <name> zurück. Apache APISIX wird das API-Gateway sein, das den Datenverkehr zu Ihren Diensten leitet.

Das folgende Diagramm zeigt, wie das System funktioniert.

3-sample-app-sequence.png

  1. Der Benutzer sendet eine GET-Anfrage an APISIX, den Einstiegspunkt für die Anwendung.
  2. APISIX leitet die Anfrage an den Go-Dienst weiter.
  3. Der Go-Dienst sendet eine GET-Anfrage an den Python-Dienst, um "Hallo" in der angegebenen Sprache zu erhalten.
  4. Der Python-Dienst antwortet mit der erforderlichen Übersetzung von "Hallo".
  5. Der Go-Dienst erstellt die erforderliche Antwort unter Verwendung des in der Abfrage angegebenen Namens und sendet sie an APISIX.
  6. APISIX leitet die Antwort an den Benutzer zurück.

Konfigurieren von Prometheus zum Sammeln von Metriken

Wir werden Metriken aus allen Diensten unserer Anwendung instrumentieren und exportieren und sie in Prometheus sammeln. Wir beginnen mit unserem API-Gateway, Apache APISIX.

Exportieren von Metriken aus APISIX

Apache APISIX ist ein Open-Source, Cloud-natives API-Gateway.

Sie müssen nichts über APISIX wissen, um diesem Tutorial zu folgen, und Sie können die bereitgestellte Docker-Compose-Datei verwenden, um alles einzurichten. Um mehr über APISIX zu erfahren, besuchen Sie api7.ai/apisix.

APISIX bietet ein Prometheus-Plugin, das Metriken einfach im Prometheus-Format exportiert. Sie können das Plugin in Ihrer APISIX-Konfigurationsdatei konfigurieren:

apisix:
  enable_admin: false # APISIX im Standalone-Modus ausführen
  config_center: yaml # Verwenden Sie eine YAML-Datei für die Konfiguration, anstatt sie in etcd zu speichern
plugin_attr:
  prometheus:
    export_uri: /prometheus/metrics # Aktivieren Sie das Prometheus-Plugin und exportieren Sie die Metriken zu diesem URI
    enable_export_server: false # Exportieren Sie die Metriken im Standard-Datenebenen-Port

Wir können das Plugin nun auf jeder Route aktivieren, indem wir es zu einer Globalen Regel machen:

routes:
  # leiten Sie Anfragen an /hello/* an die go-app weiter
  - uri: /hello/*
    upstream:
      type: roundrobin
      nodes:
        "go-app:8080": 1
    plugins:
      # entfernen Sie das Präfix "/hello", bevor die Anfrage an die go-app weitergeleitet wird
      proxy-rewrite:
        regex_uri:
          - "/hello/(.*)"
          - "/$1"
  # exportieren Sie Prometheus-Metriken zum angegebenen URI
  - uri: /prometheus/metrics
    plugins:
      public-api:
# Aktivieren Sie das Prometheus-Plugin global auf allen Routen
global_rules:
  - id: 1
    plugins:
      prometheus:
        prefer_name: true
#END

Dadurch werden die Metriken an den Endpunkt /prometheus/metrics in Apache APISIX exportiert.

Weitere Informationen zu den verfügbaren Metriken finden Sie in der Dokumentation.

Instrumentieren und Exportieren von Metriken aus dem Go-Dienst

Prometheus verfügt über eine offizielle Go-Client-Bibliothek zur Instrumentierung von Go-Anwendungen.

Standardmäßig werden die Standard-Go-Metriken von Prometheus bereitgestellt. Sie können auch Ihre eigenen anwendungsspezifischen Metriken erstellen.

In unserem Dienst werden wir die Standardmetriken bereitstellen und unseren eigenen Zählermetrik erstellen, um die Anzahl der Anfragen zu verfolgen:

package main

import (
  "encoding/json"
  "fmt"
  "io/ioutil"
  "log"
  "net/http"
  "os"

  // Prometheus-Pakete
  "github.com/prometheus/client_golang/prometheus"
  "github.com/prometheus/client_golang/prometheus/promauto"
  "github.com/prometheus/client_golang/prometheus/promhttp"
)

// Response speichert die Nachricht, die von der python-app erhalten wurde
type Response struct {
  Message string `json:"message"`
}

// Standardsprache und Name
var (
  lang = "en"
  name = "John"
)

// Erstellen Sie eine neue benutzerdefinierte Prometheus-Zählermetrik
var pingCounter = promauto.NewCounter(
  prometheus.CounterOpts{
    Name: "go_app_request_count",
    Help: "Anzahl der von der go-app bearbeiteten Anfragen",
  },
)

// HelloHandler verarbeitet Anfragen an die go-app
func HelloHandler(w http.ResponseWriter, r *http.Request) {
  lang = r.URL.String()
  name = r.URL.Query()["name"][0]
  
  fmt.Println("Anfrage für", lang, "mit Namen", name)
  pingCounter.Inc()
  
  pUrl := os.Getenv("PYTHON_APP_URL")
  if len(pUrl) == 0 {
    pUrl = "localhost"
  }

  // Rufen Sie die python-app auf, um die Übersetzung zu erhalten
  resp, err := http.Get("http://" + pUrl + ":8000" + lang)
  if err != nil {
    log.Fatalln(err)
  }

  body, err := ioutil.ReadAll(resp.Body)
  if err != nil {
    log.Fatalln(err)
  }

  resp.Body.Close()

  var m Response
  json.Unmarshal(body, &m)

  // Senden Sie die Antwort mit "Hallo name!" in der angegebenen Sprache zurück
  fmt.Fprintf(w, "%s %s!", m.Message, name)
}

func main() {
  // Prometheus-Metriken bereitstellen
  http.Handle("/metrics", promhttp.Handler())
  http.HandleFunc("/", HelloHandler)
  
  http.ListenAndServe(":8080", nil)
}

Dadurch werden die Metriken an den Endpunkt /metrics bereitgestellt. Weitere Informationen zur Go-Client-Bibliothek finden Sie in ihrem GitHub-Repo.

Instrumentieren und Exportieren von Metriken aus dem Python-Dienst

Prometheus verfügt auch über eine offizielle Python-Client-Bibliothek. Es gibt auch Drittanbieter-Bibliotheken, die für bestimmte Anwendungsfälle zugeschnitten sind.

Unser Dienst verwendet FastAPI, und wir werden die prometheus_fastapi_instrumentator-Bibliothek verwenden, um ihn zu instrumentieren:

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

from prometheus_fastapi_instrumentator import Instrumentator

app = FastAPI()

hello = {"en": "Hello", "fr": "Bonjour", "es": "Hola", "ml": "ഹലോ"}

# Stellen Sie die Standard-Python-Metriken am Endpunkt /metrics bereit
Instrumentator().instrument(app).expose(app)

@app.get("/{lang}")
async def get_hello(lang):
    return {"message": hello[lang]}

Weitere Informationen zum Erstellen benutzerdefinierter Metriken finden Sie in der Dokumentation.

Konfigurieren von Prometheus

Wir können nun diese Metriken in Prometheus sammeln und abrufen.

Sie können Prometheus so konfigurieren, dass es Metriken von jedem der Dienste sammelt. Standardmäßig sucht Prometheus nach Metriken im Pfad /metrics:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]
  
  - job_name: "go-app"
    static_configs:
      - targets: ["go-app:8080"]

  - job_name: "python-app"
    static_configs:
      - targets: ["python-app:8000"]

  - job_name: "apisix"
    static_configs:
      - targets: ["apisix:9080"]
    metrics_path: "/prometheus/metrics"

Das war's! Wenn Sie nun das Prometheus-Dashboard öffnen (standardmäßig auf Port 9090) und in der Navigationsleiste auf "Status" und dann auf "Targets" klicken, können Sie den Status der Metriken sehen, die von Ihren Diensten abgerufen werden.

prometheus-target-status.png

Abfragen und Visualisieren von Metriken in Prometheus

Jetzt können Sie das Prometheus-Dashboard verwenden, um Abfragen und komplexe Ausdrücke auszuführen.

prometheus-query.png

Weitere Informationen zum Abfragen von Prometheus finden Sie in der offiziellen Dokumentation.

Verwenden von Grafana zum Abfragen von Prometheus

Grafana ist eine Open-Source-Datenvisualisierungsplattform, die mit Prometheus zusammenarbeitet, um ein umfassendes Tool zum Sammeln, Abfragen und Visualisieren von Metriken bereitzustellen.

Prometheus ist gut darin, Metriken zu sammeln und abzufragen, bietet jedoch nur begrenzte Möglichkeiten zur Erstellung aussagekräftiger Visualisierungen. Grafana überwindet diese Einschränkung, indem es die gesammelten Metriken in Visualisierungen umwandelt.

Grafana ist auch mit vielen anderen Datenquellen als Prometheus kompatibel.

Sobald Sie Grafana bereitgestellt haben, können Sie die Web-Oberfläche öffnen (standardmäßig auf Port 3000).

Zuerst müssen Sie Prometheus als Datenquelle hinzufügen. Gehen Sie dazu zu /datasources oder "Konfiguration" und "Datenquellen". Klicken Sie auf "Datenquelle hinzufügen" und wählen Sie Prometheus aus. Geben Sie an, wo Prometheus bereitgestellt ist, speichern Sie die Einstellungen und testen Sie die Verbindung.

grafana-add-prometheus.png

Verwenden von vorgefertigten Grafana-Dashboards

Grafana hostet ein öffentliches Dashboard-Repository, das vorgefertigte Grafana-Dashboards enthält. Sie können sie in Ihrer Grafana-Instanz verwenden, um schnell relevante Metriken zu visualisieren.

Wir werden das Go Processes-Dashboard verwenden, das den von der Prometheus-Go-Client-Bibliothek veröffentlichten Prozessstatus verarbeitet und visualisiert.

Um diese Vorlage zu importieren, kopieren Sie zuerst ihre ID (6671) aus dem Dashboard-Repository. Gehen Sie in Ihrer Grafana-Oberfläche zu "Dashboards" und wählen Sie "Importieren". Fügen Sie die kopierte ID ein und klicken Sie auf "Laden".

grafana-dashboard.png

Sie können auch andere vorgefertigte Dashboards erkunden oder Ihre eigenen erstellen. Weitere Informationen hierzu finden Sie in der Dokumentation.

Was kommt als Nächstes?

Das war's für dieses Tutorial!

Dieser Artikel war nur eine Einführung in die Einrichtung der Überwachung für Ihre Dienste, und ich ermutige Sie, mehr über Prometheus und Grafana aus den unten genannten Ressourcen zu lernen:

Der vollständige Code und die Docker-Compose-Datei für dieses Tutorial sind in pottekkat/monitoring-101 verfügbar.

Tags:
Monitoring
Prometheus
Grafana