Prometheus Datentypen und Prinzipien

1. Einführung

Prometheus ist ein Open-Source-Systemüberwachungs- und Alarmierungstoolkit, das ursprünglich bei SoundCloud entwickelt wurde. Eine Kernkomponente von Prometheus ist sein Datenmodell, das die verschiedenen Datentypen definiert, die zur Darstellung überwachter Metriken verwendet werden. Das Verständnis dieser Datentypen ist entscheidend für die effektive Nutzung von Prometheus zum Sammeln, Speichern und Abfragen von Überwachungsdaten. Dieser Artikel befasst sich mit Prometheus-Datentypen, bietet Python-Codebeispiele zur Veranschaulichung ihrer Verwendung, analysiert, wie sie sich im Laufe der Zeit ändern (innerhalb von einer Minute und fünf Minuten), erklärt die zugrunde liegenden Änderungsprinzipien und stellt schließlich ein Prometheus-Flussdiagramm unter Verwendung englischer Bash-Box-Diagramme vor.

2. Prometheus-Datentypen

2.1 Zähler

Ein Zähler in Prometheus ist eine kumulative Metrik, die einen einzelnen numerischen Wert darstellt, der nur ansteigt. Er wird typischerweise verwendet, um Ereignisse wie die Anzahl der bedienten Anfragen, erledigten Aufgaben oder aufgetretenen Fehler zu zählen.

Python-Codebeispiel

from prometheus_client import Counter

# Erstellen einer Zählermetrik
request_counter = Counter('http_requests_total', 'Gesamtzahl der HTTP-Anfragen')

# Simulieren einiger HTTP-Anfragen
for _ in range(10):
    request_counter.inc()

print(request_counter._value.get())

Erläuterung:

• Importieren der Counter-Klasse aus der prometheus_client-Bibliothek.
• Erstellen eines Zählers namens http_requests_total mit einer Hilfestellung.
• Simulieren von 10 HTTP-Anfragen durch Erhöhen des Zählers.
• Ausgabe des aktuellen Zählerwerts.

Datenänderung im Laufe der Zeit

• Eine Minute: Angenommen, ein Webserver empfängt 10 Anfragen pro Minute. Wenn der anfängliche Zählerwert 50 beträgt, steigt er nach einer Minute auf 60.
• Fünf Minuten: Bei einer konstanten Rate von 10 Anfragen pro Minute erhöht sich der Zähler über fünf Minuten um 50 und erreicht von einem Anfangswert von 50 den Wert 100.

Änderungsprinzip: Zähler erhöhen sich um 1 jedes Mal, wenn das verfolgte Ereignis eintritt. Prometheus speichert die kumulative Summe im Laufe der Zeit, und der Wert nimmt nie auf natürliche Weise ab, was ihn ideal für die Verfolgung langfristiger Ereignistrends macht.

2.2 Gauge

Ein Gauge ist eine Metrik, die einen einzelnen numerischen Wert darstellt, der beliebig steigen oder fallen kann. Er wird zur Messung von Werten wie Temperatur, Speichernutzung oder gleichzeitigen Verbindungen verwendet.

Python-Codebeispiel

from prometheus_client import Gauge

# Erstellen einer Gauge-Metrik
memory_usage_gauge = Gauge('memory_usage_bytes', 'Speichernutzung in Bytes')

# Simulieren von Änderungen der Speichernutzung
memory_usage_gauge.set(1024)
memory_usage_gauge.inc(512)
memory_usage_gauge.dec(256)

print(memory_usage_gauge._value.get())

Erläuterung:

• Importieren der Gauge-Klasse und Erstellen eines Gauge namens memory_usage_bytes.
• Setzen des Anfangswerts auf 1024 Byte, Erhöhen um 512 und Verringern um 256.
• Ausgabe des endgültigen Gauge-Werts (1280 Byte).

Datenänderung im Laufe der Zeit

• Eine Minute: Die Speichernutzung kann schnell schwanken. Wenn beispielsweise der Anfangswert 1024 Byte beträgt und Prozesse zusätzlich 300 Byte verbrauchen, steigt der Gauge auf 1324 Byte. Wenn Prozesse 100 Byte freigeben, fällt er auf 1224 Byte.
• Fünf Minuten: Werte können mehrere Änderungen erfahren (z. B. 1024 → 1324 → 1200 → 1500 → 1400 → 1600 Byte über fünf Minuten).

Änderungsprinzip: Gauges können explizit gesetzt, erhöht oder verringert werden. Prometheus zeichnet den aktuellen Wert in jedem Abtastintervall auf und spiegelt den Echtzeitzustand der überwachten Entität wider.

2.3 Histogramm

Ein Histogramm nimmt Beobachtungen (z. B. Anfragedauern oder Antwortgrößen) als Stichprobe und zählt sie in konfigurierbaren Buckets, während es auch eine Summe aller Werte bereitstellt.

Python-Codebeispiel

from prometheus_client import Histogram
import random

# Erstellen einer Histogrammmetrik mit angegebenen Buckets
request_duration_histogram = Histogram(
    'http_request_duration_seconds',
    'HTTP-Anfragedauer in Sekunden',
    buckets=(0.1, 0.2, 0.3, 0.4, 0.5)
)

# Simulieren von 20 Anfragedauern
for _ in range(20):
    duration = random.uniform(0, 0.6)
    request_duration_histogram.observe(duration)

# Ergebnisse ausgeben
print(f"Summe: {request_duration_histogram._sum.get()}")
print(f"Anzahl: {request_duration_histogram._count.get()}")
for bucket, count in request_duration_histogram._buckets.items():
    print(f"Bucket {bucket}: {count.get()}")

Erläuterung:

• Definieren eines Histogramms mit Buckets für 0,1–0,5 Sekunden.
• Simulieren von 20 Anfragedauern und Aufzeichnen dieser mithilfe von observe().
• Ausgabe der Gesamtsumme, Anzahl und Bucket-Verteilungen.

Datenänderung im Laufe der Zeit

• Eine Minute: Neue Beobachtungen (z. B. 25 Anfragen in einer Minute) erhöhen die Anzahl und Summe, und die Bucket-Anzahlen werden basierend auf den tatsächlichen Dauern aktualisiert.
• Fünf Minuten: Kumulierte Beobachtungen führen zu größeren Anzahlen und Summen, wobei sich die Bucket-Verteilungen verschieben, wenn mehr Anfragen mit langer Dauer auftreten.

Änderungsprinzip: Jede Beobachtung wird einem Bucket zugewiesen, und die Summe wird aktualisiert. Histogramme erstellen Datenverteilungen im Laufe der Zeit und ermöglichen die Analyse von Wertebereichen und -größen.

2.4 Zusammenfassung

Eine Zusammenfassung nimmt Beobachtungen als Stichprobe und berechnet Quantile (z. B. Median, 90. Perzentil), um Datenverteilungen zusammenzufassen, im Gegensatz zu Histogrammen, die feste Buckets verwenden.

Python-Codebeispiel

from prometheus_client import Summary

# Erstellen einer Zusammenfassung mit Labels für Endpunkte
response_size_summary = Summary(
    'http_response_size_bytes',
    'HTTP-Antwortgröße in Bytes',
    labelnames=['endpoint']
)

# Aufzeichnen von Beobachtungen für verschiedene Endpunkte
response_size_summary.labels(endpoint='/api/v1/users').observe(1024)
response_size_summary.labels(endpoint='/api/v1/posts').observe(2048)

# Ergebnisse ausgeben
print(f"Summe: {response_size_summary._sum.get()}")
print(f"Anzahl: {response_size_summary._count.get()}")
for quantile, sum_val in response_size_summary._quantile_sum.items():
    print(f"Quantil {quantile}: {sum_val.get()}")

Erläuterung:

• Erstellen einer Zusammenfassung mit einem endpoint-Label, um API-Routen zu unterscheiden.
• Aufzeichnen von Antwortgrößen für zwei Endpunkte und Ausgabe von Summen, Anzahlen und Quantildaten.

Datenänderung im Laufe der Zeit

• Eine Minute: Neue Anfragen aktualisieren die Anzahl, Summe und Quantile. Beispielsweise können größere Antworten den Wert des 90. Perzentils erhöhen.
• Fünf Minuten: Kumulierte Daten verbessern die Quantilgenauigkeit, wobei Anzahlen und Summen wachsen und Verteilungen langfristige Trends widerspiegeln.

Änderungsprinzip: Beobachtungen aktualisieren die laufende Summe, Anzahl und Quantilberechnungen (mithilfe von Algorithmen wie gleitenden Fenstern). Quantile passen sich dynamisch an, um die neuesten Datenverteilungen widerzuspiegeln.

3. Prometheus-Flussdiagramm (Englische Bash-Box-Diagramme)

+-------------------+
| Prometheus Server |
+-------------------+
|                   |
|  Data Collection  |
|  (Pull Model)     |
|                   |
|  Targets         |<---+
|  (Exporters)     |    |
|                   |    |
+-------------------+    |
                        |
+-------------------+    |
|  Exporter         |    |
|  (e.g., Node     |    |
|  Exporter)       |    |
+-------------------+    |
                        |
|  Metrics          |    |
|  (Counter, Gauge, |    |
|  Histogram,       |    |
|  Summary)         |    |
+-------------------+    |
                        |
|  Push Metrics      |<---+
|  to Prometheus    |
+-------------------+  
|                   |
|  Data Storage     |
|  (TSDB - Time -    |
|  Series Database) |
|                   |
+-------------------+  
|                   |
|  Querying        |
|  (PromQL)        |
|                   |
+-------------------+  
|                   |
|  Visualization   |
|  (e.g., Grafana) |
|                   |
+-------------------+

Flussdiagrammerklärung:

1. Prometheus Server ruft Metriken von Zielen (Exportern) mithilfe eines Pull-basierten Modells ab.
2. Exporter (z. B. Node Exporter) sammeln Metriken von Systemen und stellen sie in Prometheus-kompatiblen Formaten bereit.
3. Metriken (Zähler, Gauges, Histogramme, Zusammenfassungen) werden an den Prometheus Server gesendet.
4. Der Server speichert Metriken in seiner Zeitreihendatenbank (TSDB).
5. Benutzer fragen Metriken mithilfe von PromQL ab.
6. Abgefragte Daten werden über Tools wie Grafana visualisiert.

4. Fazit

Das Verständnis von Prometheus-Datentypen ist entscheidend für eine effektive Systemüberwachung:

• Zähler verfolgen kumulative Ereignisse.
• Gauges überwachen schwankende Werte.
• Histogramme analysieren Datenverteilungen in Buckets.
• Zusammenfassungen bieten quantilbasierte Einblicke.

Python-Beispiele veranschaulichen Implementierung und zeitliche Änderungen, während das Flussdiagramm den Datenfluss von Prometheus von der Erfassung bis zur Visualisierung umreißt. Mit diesem Wissen können Benutzer Prometheus nutzen, um ihre Systeme effizient zu überwachen und zu verwalten.

Leapcell: Das Beste aus Serverlosem Webhosting

Leapcell ist die ideale Plattform für die Bereitstellung von Python-Diensten.

🚀 Entwickeln Sie mit Ihrer Lieblingssprache

Entwickeln Sie mühelos in JavaScript, Python, Go oder Rust.

🌍 Stellen Sie unbegrenzt Projekte kostenlos bereit

Zahlen Sie nur für die Ressourcennutzung – keine Anfragen, keine Gebühren.

⚡ Pay-as-You-Go, keine versteckten Kosten

Keine Leerlaufgebühren, nur nahtlose Skalierbarkeit.

📖 Erkunden Sie unsere Dokumentation 🔹 Folgen Sie uns auf Twitter: @LeapcellHQ