Prometheus-Metriken: Überwachen Sie die Leistung Ihrer App
Prometheus-Metriken: Überwachen Sie die Leistung Ihrer App
Was ist Prometheus?
Prometheus ist ein Open-Source-Tool, das die Leistung und den Zustand von Softwaresystemen verfolgt. Es sammelt Datenpunkte, sogenannte Metriken, die Einblicke darin geben, wie gut ein System läuft. Diese Metriken helfen, Probleme frühzeitig zu erkennen und das Systemverhalten zu analysieren. Mit Prometheus können Teams Probleme erkennen, bevor sie sich auf Benutzer auswirken, um zuverlässige und effiziente Dienste aufrechtzuerhalten.
Was sind die Metriken in Prometheus?
In Prometheus sind Metriken numerische Werte, die bestimmte Aspekte des Verhaltens und der Leistung eines Systems im Laufe der Zeit verfolgen. Diese Metriken helfen zu verstehen, wie gut ein System unter verschiedenen Bedingungen funktioniert, und liefern außerdem Warnmeldungen bei Bedingungen, die auf Probleme hinweisen könnten, wie etwa ein plötzlicher Anstieg des Datenverkehrs oder ein Rückgang der Systemleistung. Sie können eine breite Palette von Daten überwachen, von der Anzahl der aktiven Benutzer auf einer Website bis hin zur Menge an Speicher, die eine Anwendung verwendet.
Metrikformat in Prometheus
Metriken in Prometheus werden in einem time-series-Format gespeichert, wobei jede Metrik durch ihren Namen und optionale Schlüssel-Wert-Paare, sogenannte Labels, identifiziert wird, die zusätzlichen Kontext wie Dienstnamen oder Fehlertypen bereitstellen. Das primäre Format für Metrikdaten in Prometheus ist das Prometheus Exposition Format. Dieses Klartextformat ist einfach zu erzeugen und zu parsen und besteht aus Datenzeilen, die den Metriknamen, optionale Labels, den Metrikwert und einen Zeitstempel enthalten.
Die vier Arten von Metriken in Prometheus
Prometheus kategorisiert Metriken in vier Haupttypen: Counter, Gauges, Histograms und Summaries. Jeder Typ erfüllt eine bestimmte Funktion beim Monitoring und bietet unterschiedliche Einblicke in das Verhalten Ihrer Systeme.
Counter-Metriken
Counter-Metriken in Prometheus erfassen, wie oft ein bestimmtes Ereignis auftritt. Sie erhöhen sich nur im Laufe der Zeit oder werden auf null zurückgesetzt, wenn der Prozess neu startet. Daher werden sie zur Verfolgung kumulativer Größen verwendet, wie der Anzahl der verarbeiteten Anfragen, abgeschlossenen Aufgaben oder protokollierten Fehler.
Um einen Counter zu implementieren, der die Anzahl der von einem Server empfangenen Anfragen verfolgt, können Sie das folgende Code-Snippet verwenden. Dieses Beispiel richtet einen Counter ein, um die Gesamtzahl der empfangenen HTTP-Anfragen zu überwachen. Jedes Mal, wenn die Funktion handle_request aufgerufen wird, wird der Counter erhöht.
from prometheus_client import Counter
# Create a counter metric for tracking received requests
request_counter = Counter('http_requests_received_total', 'Total HTTP requests received')
def handle_request(request):
# Process the request
# ...
# Increment the counter by 1 each time this function is called
request_counter.inc()
Best Practices für die Verwendung von Countern
Reset-Bewusstsein: Beachten Sie, dass Counter auf null zurückgesetzt werden, wenn der Prozess neu startet. Gestalten Sie Ihr Monitoring so, dass diese Resets berücksichtigt werden.
Labels verwenden: Verwenden Sie Labels mit Countern, um detailliertere Einblicke zu erhalten, z. B. um zwischen verschiedenen Arten von Fehlern oder Anfragen zu unterscheiden.
Konsistentes Inkrementieren: Stellen Sie sicher, dass der Counter an der richtigen Stelle in Ihrem Code erhöht wird, um die Ereignisse, die Sie verfolgen, genau widerzuspiegeln.
Resets überwachen: Verwenden Sie die rate-Funktion in Abfragen, um die durchschnittliche Steigerungsrate eines Counters pro Sekunde zu berechnen, was Ihnen helfen kann, Trends zu verstehen und Probleme zu erkennen, selbst bei Resets.
Gauge-Metriken
Gauge-Metriken in Prometheus messen Werte, die steigen und fallen können, wie CPU-Temperaturen, aktuelle Zahlen laufender Prozesse oder Mengen an freiem Speicher. Im Gegensatz zu Countern, die nur steigen, spiegeln Gauges den aktuellen Zustand des Systems zu einem bestimmten Zeitpunkt wider, was sie unerlässlich für die Verfolgung schwankender Metriken macht.
Um eine Gauge zu implementieren, die die Menge des freien Speichers in einem System überwacht, können Sie den folgenden Codeausschnitt verwenden. Dieses Beispiel richtet eine Gauge zur Überwachung des freien Speichers ein und aktualisiert den Wert der Gauge durch Aufrufen der Funktion update_free_memory(), die ausgelöst werden sollte, um Systemänderungen widerzuspiegeln.
from prometheus_client import Gauge
# Create a gauge metric to track free memory
free_memory_gauge = Gauge('system_free_memory_bytes', 'Amount of free memory in bytes')
def update_free_memory():
# Assume get_free_memory() is a function that fetches the current free memory
free_memory = get_free_memory()
free_memory_gauge.set(free_memory)
# Update gauge regularly or upon specific system events
update_free_memory()
Tipps zur Nutzung von Gauges
Regelmäßige Aktualisierungen: Stellen Sie sicher, dass Gauges regelmäßig aktualisiert werden, um den aktuellen Zustand des Systems genau widerzuspiegeln.
Kontextbezogene Verwendung: Verwenden Sie Gauges für Metriken, die das Nachverfolgen von Anstiegen und Rückgängen im Laufe der Zeit erfordern, wie etwa Lastdurchschnitte oder verfügbare Systemressourcen.
Missbrauch vermeiden: Achten Sie darauf, Gauges nicht für Metriken zu verwenden, die nur inkrementiert oder dekrementiert werden sollten, wobei ein Counter oder ein Histogramm möglicherweise geeigneter wäre.
Histogramm-Metriken
Histogramme in Prometheus fassen die Verteilung numerischer Daten über eine Reihe vordefinierter Buckets zusammen. Jeder Bucket stellt einen Wertebereich dar, und das Histogramm zählt, wie viele Werte in jeden Bucket fallen. Dieser Metriktyp ist nützlich, um Messungen wie Anforderungslatenzen oder Antwortgrößen zu verfolgen, bei denen das Verständnis der Verteilung mehr Einblick bieten kann, als nur den Durchschnitt zu kennen.
Um ein Histogramm zu implementieren, das die Latenz von HTTP-Anfragen verfolgt, können Sie den folgenden Codeausschnitt verwenden. Dieses Beispiel richtet ein Histogramm mit mehreren Buckets ein, um zu messen, wie lange jede HTTP-Anfrage zur Verarbeitung benötigt. Der with-Block misst automatisch die Dauer der Anforderungsverarbeitung und zeichnet sie im entsprechenden Bucket auf.
from prometheus_client import Histogram
# Define a histogram with buckets for request latency
request_latency_histogram = Histogram('http_request_latency_seconds', 'HTTP request latencies', buckets=[0.1, 0.2, 0.5, 1, 2, 5])
def handle_request(request):
with request_latency_histogram.time():
# Process the request
# This automatically measures the time taken by this block and records it in the histogram
pass
Histogramm-Buckets und ihre Bedeutung
Bucket-Design: Die Wahl der richtigen Buckets ist entscheidend für nützliche Histogramme. Buckets sollten an den Leistungszielen und Schwellenwerten Ihrer Anwendung ausgerichtet sein. Wenn Ihnen beispielsweise wichtig ist, zwischen Anfragen zu unterscheiden, die 0,1 Sekunden und 1 Sekunde dauern, sollten Ihre Buckets diese Intervalle widerspiegeln.
Granularität: Mehr Buckets erhöhen die Granularität des Histogramms, erhöhen aber auch den Speicherverbrauch. Wägen Sie Detailgenauigkeit gegen Ressourceneffizienz ab.
Kumulative Zählung: Prometheus-Histogramme sind kumulativ. Das bedeutet, dass jeder Bucket die Gesamtzahl der Beobachtungen zählt, die in seinen Bereich und alle vorherigen Bereiche fallen. Dadurch werden Perzentile berechnet, die informativer über die Datenverteilung sind als Durchschnittswerte.
Verwendung in Abfragen: Beim Abfragen von Histogrammen können Funktionen wie histogram
_quantile()Quantile aus den kumulativen Buckets berechnen und so leistungsstarke Einblicke in die Leistungsmerkmale Ihres Systems bieten.
Summary-Metriken
Summary-Metriken in Prometheus bieten eine Möglichkeit, Quantile von Beobachtungen, wie etwa das 90. Perzentil von Anforderungslatenzen, direkt im Client zu berechnen. Im Gegensatz zu Histogrammen, die Daten sammeln und in Buckets kategorisieren, berechnen Summaries Streaming-Quantile ohne vordefinierte Buckets. Dadurch sind Summaries ideal für Situationen, in denen präzise Quantilberechnungen erforderlich sind, insbesondere wenn genaue Schwellenwerte wichtig sind, wie etwa beim Reporting zu Service Level Agreements (SLAs).
Um eine Summary zu implementieren, die die Latenz von Datenbankabfragen misst, können Sie den folgenden Codeausschnitt verwenden. Dieses Beispiel richtet eine Summary ein, um die Zeit zu überwachen, die Datenbankabfragen benötigen. Der with-Block misst die Dauer der Abfrage und aktualisiert die Summary mit dieser neuen Beobachtung, wodurch die Berechnung von Quantilen erleichtert wird.
from prometheus_client import Summary
# Create a summary to measure database query latencies
db_query_latency = Summary('db_query_latency_seconds', 'Database query latencies')
def query_database(query):
with db_query_latency.time():
# Execute the database query
# The time taken by this block is automatically recorded and calculated in the summary
pass
Unterschied zwischen Histogrammen und Summaries
Quantilberechnung: Histogramme schätzen Quantile basierend auf den definierten Buckets, was je nach Bucket-Konfiguration zu Ungenauigkeiten führen kann. Summaries berechnen Quantile direkt aus den beobachteten Daten und bieten potenziell mehr Präzision.
Clientseitige Last: Summaries berechnen Quantile auf der Clientseite, was die Rechenlast erhöhen kann, insbesondere bei einer hohen Anzahl von Beobachtungen. Histogramme können mit ihren vordefinierten Buckets die clientseitige Berechnung reduzieren.
Konfiguration: Histogramme erfordern Vorwissen über die Verteilung, um geeignete Buckets festzulegen. Summaries erfordern keine Bucket-Konfiguration, wodurch sie anfangs einfacher bereitzustellen sind, aber potenziell ressourcenintensiver sein können.
Anwendungsfälle: Summaries werden bevorzugt, wenn genaue Echtzeit-Quantile für kritische Metriken benötigt werden, während Histogramme oft besser geeignet sind, um die breitere Verteilung einer Metrik zu erfassen, bei der exakte Schwellenwerte weniger kritisch sind.
Best Practices für das Labeling und Gruppieren von Metriken
Angemessene Verwendung von Labels
Labels in Prometheus sind Schlüssel-Wert-Paare, die Metadaten an Metriken anhängen, um detailliertere und gezieltere Abfragen zu ermöglichen. Sie sind wichtig für die Organisation und Identifizierung von Metriken über Dimensionen wie Servicenamen, Hostnamen oder Fehlertypen hinweg. Hier sind einige Best Practices für die Verwendung von Labels:
Beschreibend und konsistent: Wählen Sie Label-Namen, die ihren Zweck klar beschreiben, und wahren Sie Konsistenz über Ihre Metriken hinweg. Verwenden Sie beispielsweise service für alle Metriken, die den Service identifizieren, zu dem sie gehören.
Notwendige Granularität: Während Labels Ihren Metriken erhebliche Details hinzufügen können, können zu viele Labels die Speicherkosten erhöhen und die Abfrageleistung verringern. Verwenden Sie Labels mit Bedacht, um Granularität und Leistung auszubalancieren.
Hohe Kardinalität vermeiden: Labels mit hoher Kardinalität, wie solche, die möglicherweise jeden einzelnen Benutzer oder jede E-Mail-Adresse kennzeichnen, können die Datengröße erhöhen und die Leistung beeinträchtigen. Beschränken Sie sich auf Labels, die eine angemessene Anzahl unterschiedlicher Werte haben.
Dieses Beispiel zeigt einen Counter, der Labels verwendet, um zwischen verschiedenen HTTP-Methoden und -Status für detaillierte Analyse und Überwachung zu unterscheiden.
from prometheus_client import Counter
# Create a counter with labels for HTTP methods and response statuses
http_requests_total = Counter('http_requests_total', 'Total HTTP requests',
['method', 'status'])
def handle_request(request):
# Increment the counter with the appropriate labels
http_requests_total.labels(method=request.method, status=request.response.status_code).inc()
Strategien zum Gruppieren von Metriken
Das logische Gruppieren von Metriken kann die Klarheit erhöhen und die Leistung von Überwachungssystemen verbessern. Hier sind einige Strategien:
Nach Typ kategorisieren: Gruppieren Sie Metriken nach Typ, z. B. Fehler, Traffic, Latenz usw., um das Finden und Analysieren verwandter Metriken zu erleichtern.
Servicebasierte Gruppierung: Organisieren Sie Metriken nach dem Service, den sie messen. Dies hilft dabei, Probleme innerhalb eines bestimmten Services schnell zu isolieren.
Hierarchische Benennung verwenden: Berücksichtigen Sie bei der Benennung von Metriken eine hierarchische Struktur, die ihre Gruppierung widerspiegelt, wie
service_database_queries_totaloderservice_http_requests_total.
Vorteile effektiver Gruppierung
Verbesserte Abfrageleistung: Logische Gruppierung kann zu effizienteren Abfragen führen, indem die Anzahl der Metriken reduziert wird, die für jede Abfrage gescannt werden müssen.
Einfachere Alert-Verwaltung: Die Gruppierung ähnlicher Metriken vereinfacht die Erstellung von Alert-Regeln und erleichtert die Verwaltung von Alerts in verschiedenen Teilen Ihres Systems.
Bessere Visualisierung: Gruppierte Metriken lassen sich in Dashboards leichter visualisieren, da verwandte Metriken zusammen angezeigt werden können und so eine kohärente Ansicht der Systemleistung bieten.
Abfragen von Metriken mit PromQL
Grundlagen von PromQL und seiner Syntax
PromQL, oder Prometheus Query Language, ist die leistungsstarke Abfragesprache, die von Prometheus verwendet wird, um Daten zu untersuchen und Alerts zu erzeugen. PromQL ermöglicht einfache und komplexe Abfragen, um aus Ihren Metriken genau die benötigten Daten zu berechnen. Die Syntax von PromQL unterstützt die Auswahl und Aggregation von Zeitreihendaten auf Basis von Metriknamen, Labels und Zeitintervallen.
Hauptfunktionen von PromQL:
Instant- und Range-Abfragen: Instant-Abfragen liefern den aktuellen Wert der Zeitreihe für einen bestimmten Zeitpunkt, während Range-Abfragen Werte der Zeitreihe für einen Zeitraum zurückgeben.
Funktionen und Operatoren: PromQL umfasst verschiedene integrierte Funktionen und Operatoren zur Berechnung von Raten, Durchschnittswerten und arithmetischen Operationen zwischen Metriken.
Code-Snippets: Häufige Abfragen für jeden Metriktyp
Counter-Metriken
Diese Abfrage berechnet die durchschnittliche Rate der HTTP-Anfragen pro Sekunde über die letzten 5 Minuten, was für die Überwachung der Verkehrslast auf Ihren Servern nützlich ist.
rate(http_requests_total[5m])
Gauge-Metriken
Diese Instant-Abfrage ruft die aktuelle Menge an freiem Speicher ab und liefert eine Momentaufnahme der Systemressourcen.
node_memory_MemFree_bytes
Histogramm-Metriken
Die folgende Abfrage berechnet das 95. Perzentil der Anfrage-Latenzen über die letzten 10 Minuten, was dabei hilft, Ausreißer in der Webserverleistung zu identifizieren.
histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[10m]))
Summary-Metriken
Die folgende Abfrage berechnet die mediane Latenz verarbeiteter Ereignisse, was für die Bewertung der Leistung von Event-Handling-Systemen entscheidend ist.
quantile(0.5, rate(processed_events_latency_seconds_sum[5m]) / rate(processed_events_latency_seconds_count[5m]))
Tipps für effektive Abfragen mit PromQL:
Geeignete Zeitbereiche verwenden: Wählen Sie Zeitbereiche aus, die aussagekräftige Erkenntnisse liefern, ohne das System durch lange Abfragen historischer Daten zu überlasten.
Label-Filtering nutzen: Verwenden Sie Labels, um Ergebnisse zu filtern und zu verfeinern, und konzentrieren Sie sich auf bestimmte Teilmengen von Daten.
Auf Leistung optimieren: Berücksichtigen Sie beim Schreiben von Abfragen, insbesondere für Dashboards oder Alerts, deren Auswirkungen auf die Leistung und optimieren Sie sie für eine effiziente Ausführung.
Überwachung der Leistung der Milvus Vector Database mit Prometheus
Milvus ist eine Open-Source-, leistungsstarke und hoch skalierbare Vektordatenbank, die unstrukturierte Daten im Milliardenmaßstab mithilfe hochdimensionaler Vektoreinbettungen speichern, indexieren und durchsuchen kann. Sie eignet sich perfekt für den Aufbau moderner KI-Anwendungen wie Retrieval Augmented Generation (RAG), semantische Suche, multimodale Suche und Empfehlungssysteme. Milvus läuft effizient in verschiedenen Umgebungen, von Laptops und Edge-Geräten bis hin zu groß angelegten verteilten Systemen.
Prometheus bietet umfassende Funktionen zur Überwachung der Leistung der Milvus-Vektordatenbank. Milvus lässt sich nahtlos in Prometheus integrieren durch:
Prometheus Endpoint: Sammelt Daten von verschiedenen Exportern.
Prometheus Operator: Vereinfacht die Verwaltung von Prometheus-Monitoring-Setups.
Kube-Prometheus: Vereinfacht das vollständige Monitoring von Kubernetes-Clustern für einen robusten Betrieb.
Durch die Nutzung von Prometheus können Sie kritische Kennzahlen der Milvus-Leistung verfolgen, wie z. B. Abfrageantwortzeiten und Ressourcennutzung (CPU, GPU und Speicher), wodurch eine proaktive Problemlösung und Systemoptimierung ermöglicht werden. Darüber hinaus verbessert die Integration von Prometheus mit Grafana Ihr Monitoring-Framework weiter und bietet detaillierte Dashboards für eine eingehende Analyse und effiziente Wartung von Milvus-Bereitstellungen, die auf GenAI- und Ähnlichkeitssuche-Anwendungen zugeschnitten sind.
Umfassende Anleitungen zur Einrichtung von Prometheus für Milvus und zur Visualisierung von Metriken mit Grafana finden Sie in den folgenden Ressourcen:
So erkennen Sie Suchleistungsengpässe in Vektordatenbanken mit Prometheus und Grafana
Milvus-Metriken mit Grafana visualisieren | Milvus Documentation
Fazit
Zusammenfassend ist Prometheus ein wertvolles Tool zur Überwachung verschiedener Metriken, die den Zustand und die Leistung von Systemen widerspiegeln. Durch die Nutzung der Funktionen von Prometheus zum Verfolgen, Analysieren und Visualisieren kritischer Betriebsdaten können Teams ihre Monitoring-Praktiken verbessern und sicherstellen, dass ihre Systeme nicht nur stabil, sondern auch auf Effizienz optimiert sind. Ob durch das Einrichten von Alerts, um potenzielle Probleme frühzeitig zu erkennen, oder durch die Nutzung detaillierter Dashboards für einen klaren Überblick über Systemmetriken: Prometheus befähigt Entwickler und Administratoren, leistungsstarke und zuverlässige Dienste aufrechtzuerhalten.
FAQs
- Welche vier Arten von Metriken gibt es in Prometheus?
Prometheus kategorisiert Metriken in vier Typen: Counter, Gauges, Histogramme und Summaries. Jeder Typ dient einem bestimmten Monitoring-Zweck, vom Zählen des Auftretens von Ereignissen bis zur Erfassung der Verteilung von Messungen über die Zeit.
- Wie entscheide ich mich zwischen der Verwendung eines Histogramms und einer Summary?
Wählen Sie Histogramme, wenn Sie Verteilungen erfassen müssen und in der Lage sind, im Voraus sinnvolle Buckets zu definieren. Verwenden Sie Summaries, wenn Sie genaue Quantilberechnungen benötigen und keine vordefinierten Buckets erforderlich sind. Die Wahl hängt von Ihrem spezifischen Anwendungsfall und Leistungsüberlegungen ab.
- Was ist PromQL und wie wird es in Prometheus verwendet?
PromQL, oder Prometheus Query Language, ist die leistungsstarke Sprache, die zum Abfragen von Metriken in Prometheus verwendet wird. Sie ermöglicht es Benutzern, Zeitreihendaten auszuwählen und zu aggregieren, Berechnungen durchzuführen und Erkenntnisse aus Metriken basierend auf bestimmten Bedingungen und Zeitbereichen abzuleiten.
- Kann ich Prometheus verwenden, um Anwendungen zu überwachen, die nicht in einer Microservices-Architektur aufgebaut sind?
Ja, Prometheus ist vielseitig genug, um eine breite Palette von Anwendungen zu überwachen, unabhängig davon, ob sie mit einer Microservices-Architektur oder einem eher traditionellen monolithischen Ansatz aufgebaut sind. Es kann so konfiguriert werden, dass es Metriken aus nahezu jeder Quelle abruft, die Daten im Prometheus Exposition Format bereitstellt.
- Welche Best Practices gibt es für das Labeling und Gruppieren von Metriken in Prometheus?
Achten Sie beim Labeling und Gruppieren von Metriken darauf, dass Labels aussagekräftig und über Metriken hinweg konsistent sind. Vermeiden Sie Labels mit hoher Kardinalität, die die Leistung beeinträchtigen können. Gruppieren Sie Metriken logisch nach Typ oder Dienst, um die Übersichtlichkeit zu erhöhen und die Abfrageeffizienz zu verbessern. Dies hilft, ein organisiertes Monitoring-System aufrechtzuerhalten, das einfacher abzufragen und zu verwalten ist.
Zusätzliche Ressourcen
- Was ist Prometheus?
- Was sind die Metriken in Prometheus?
- Metrikformat in Prometheus
- Die vier Arten von Metriken in Prometheus
- Best Practices für das Labeling und Gruppieren von Metriken
- Abfragen von Metriken mit PromQL
- Überwachung der Leistung der Milvus Vector Database mit Prometheus
- Fazit
- FAQs
- Zusätzliche Ressourcen
Inhalte
Kostenlos starten, einfach skalieren
Testen Sie die vollständig verwaltete Vektordatenbank, die für Ihre GenAI-Anwendungen entwickelt wurde.
Zilliz Cloud kostenlos ausprobieren