So fragen Sie Prometheus unter Ubuntu 14.04 ab Teil 2

Prometheus ist ein Open-Source-Überwachungssystem und eine Zeitreihendatenbank. Unter dem Link: / community / tutorials / abfrageverfahren für prometheus-on-ubuntu-14-04-part-1 [Abfragen von Prometheus unter Ubuntu 14.04 Part 1] haben wir drei Demo-Service-Instanzen eingerichtet, denen synthetische Metriken ausgesetzt sind ein Prometheus-Server. Anhand dieser Metriken lernten wir dann, wie mit der Prometheus-Abfragesprache Zeitreihen ausgewählt und gefiltert werden, wie über Dimensionen aggregiert wird und wie Raten und Ableitungen berechnet werden.

Im zweiten Teil dieses Tutorials bauen wir auf dem Setup des ersten Teils auf und lernen erweiterte Abfragetechniken und -muster. Nach diesem Lernprogramm erfahren Sie, wie Sie wertbasierte Filterung anwenden, Vorgänge festlegen, Histogramme erstellen und vieles mehr.

Dieses Tutorial basiert auf dem in link: / community / tutorials / abfrage-an-ubuntu-14-04-part-1 [Abfrage von Prometheus unter Ubuntu 14.04 Part 1] beschriebenen Setup. Sie müssen mindestens die Schritte 1 und 2 dieses Lernprogramms ausführen, um einen Prometheus-Server und drei überwachte Demo-Service-Instanzen einzurichten. Wir werden jedoch auch auf den im ersten Teil erläuterten Abfragesprachentechniken aufbauen und empfehlen, diese vollständig durchzuarbeiten.

In diesem Abschnitt erfahren Sie, wie Sie zurückgegebene Zeitreihen nach ihrem Wert filtern.

Die gebräuchlichste Verwendung für die wertbasierte Filterung sind einfache numerische Warnschwellenwerte. Beispielsweise möchten wir möglicherweise HTTP-Pfade finden, die eine Gesamt-Anforderungsrate von "+ 500 " - Status von mehr als 0,2 pro Sekunde aufweisen, gemittelt über die letzten 15 Minuten. Dazu fragen wir einfach alle Anforderungsraten für den Status " 500 " ab und fügen am Ende des Ausdrucks einen Filteroperator "> 0,2 +" hinzu:

In der Ansicht * Console * sollte das Ergebnis folgendermaßen aussehen:

image: https://assets.digitalocean.com/articles/prometheus_querying/filter_rates_scalar.png [Anforderungsraten nach skalarer Zahl filtern]

Wie bei der binären Arithmetik unterstützt Prometheus jedoch nicht nur das Filtern nach einer einzelnen skalaren Zahl. Sie können auch einen Satz von Zeitreihen basierend auf einem anderen Satz von Reihen filtern. Wieder werden Elemente anhand ihrer Beschriftungssätze abgeglichen, und der Filteroperator wird zwischen übereinstimmenden Elementen angewendet. Nur die Elemente auf der linken Seite, die mit einem Element auf der rechten Seite übereinstimmen und den Filter passieren, werden Teil der Ausgabe. Die Klauseln + on (<labels>) +, + group_left (<labels>) +, + group_right (<labels>) + funktionieren hier genauso wie in arithmetischen Operatoren.

Zum Beispiel könnten wir die "+ 500 " -Statusrate für jede " Job " -, " Instanz " -, " Methode " - und " Pfad " - Kombination auswählen, für die die " 200 " - Statusrate gilt mindestens 50-mal höher als die " 500 +" -Statusrate wie folgt:

Dies wird wie folgt aussehen:

image: https://assets.digitalocean.com/articles/prometheus_querying/series.png [Filtern der Anforderungsraten nach anderen Serien]

Prometheus unterstützt neben +> + auch die üblichen Vergleichsoperatoren +> = +, + ⇐ +, + <+, +! = + Und + == + beim filtern.

Wir wissen jetzt, wie eine Reihe von Zeitreihen entweder auf der Grundlage eines einzelnen numerischen Werts oder auf der Grundlage einer anderen Reihe von Zeitreihenwerten mit übereinstimmenden Bezeichnungen gefiltert werden kann.

In diesem Abschnitt erfahren Sie, wie Sie mit Prometheus-Mengenoperatoren Zeitreihenmengen miteinander korrelieren.

Häufig möchten Sie eine Reihe von Zeitreihen auf der Grundlage einer anderen Reihe filtern. Prometheus stellt dafür den Set-Operator "" und "" zur Verfügung. Für jede Reihe auf der linken Seite des Operators wird versucht, eine Reihe mit denselben Bezeichnungen auf der rechten Seite zu finden. Wenn eine Übereinstimmung gefunden wird, wird die Reihe auf der linken Seite Teil der Ausgabe. Wenn rechts keine übereinstimmende Reihe vorhanden ist, wird die Reihe in der Ausgabe weggelassen.

Beispielsweise können Sie HTTP-Endpunkte mit einer Latenz von mehr als 50 ms (0,05 s) im 90. Perzentil auswählen, jedoch nur für Dimensionskombinationen, die mehr als eine Anforderung pro Sekunde erhalten. Wir werden hier die Funktion + histogram_quantile () + für die Perzentilberechnung verwenden. Wir werden im nächsten Abschnitt genau erklären, wie diese Funktionen funktionieren. Im Moment ist es nur wichtig, dass die 90. Perzentil-Latenz für jede Unterdimension berechnet wird. Um die daraus resultierenden schlechten Latenzen zu filtern und nur diejenigen zu speichern, die mehr als eine Anfrage pro Sekunde erhalten, können wir Folgendes abfragen:

image: https://assets.digitalocean.com/articles/prometheus_querying/intersection.png [Anforderungsraten nach Schnittmenge filtern]

Anstatt die Kreuzung zu nehmen, möchten Sie die Vereinigung manchmal aus zwei Zeitreihen erstellen. Prometheus stellt hierfür den Set-Operator "" oder "" zur Verfügung. Das Ergebnis sind die Serien auf der linken Seite des Vorgangs sowie alle Serien auf der rechten Seite, für die links keine passenden Beschriftungssätze vorhanden sind. Um beispielsweise alle Anfragetarife aufzulisten, die entweder unter 10 oder über 30 liegen, fragen Sie nach:

Das Ergebnis sieht in einem Diagramm folgendermaßen aus:

image: https://assets.digitalocean.com/articles/prometheus_querying/union.png [Erstellen der Union aus zwei Sätzen von Anforderungsraten]

Wie Sie sehen, kann die Verwendung von Wertefiltern und Einstellungsoperationen in Diagrammen dazu führen, dass Zeitreihen innerhalb desselben Diagramms angezeigt und ausgeblendet werden, je nachdem, ob sie mit einem Filter übereinstimmen oder nicht. Im Allgemeinen wird die Verwendung dieser Art von Filterlogik nur für Warnregeln empfohlen.

Sie wissen jetzt, wie Sie Schnittpunkte und Vereinigungen aus beschrifteten Zeitreihen erstellen.

In diesem Abschnitt erfahren Sie, wie Sie Histogrammmetriken interpretieren und daraus Quantile (eine verallgemeinerte Form von Perzentilen) berechnen.

Prometheus unterstützt Histogramm-Metriken, mit denen ein Dienst die Verteilung einer Reihe von Werten aufzeichnen kann. Histogramme verfolgen normalerweise Messungen wie Anforderungslatenzen oder Antwortgrößen, können jedoch grundsätzlich jeden Wert verfolgen, dessen Größe je nach Verteilung schwankt. Prometheus histogrammiert Beispieldaten auf der Clientseite, was bedeutet, dass sie beobachtete Werte unter Verwendung einer Anzahl konfigurierbarer (z. Latenzzeit), und machen Sie diese Buckets dann als einzelne Zeitreihen verfügbar.

Intern werden Histogramme als eine Gruppe von Zeitreihen implementiert, die jeweils die Zählung für einen bestimmten Bereich darstellen (z. "Anfragen unter 10 ms", "Anfragen unter 25 ms", "Anfragen unter 50 ms" usw.). Die Bucket-Zähler sind kumulativ, was bedeutet, dass Buckets für größere Werte die Zählungen für alle Buckets mit niedrigeren Werten enthalten. Bei jeder Zeitreihe, die Teil eines Histogramms ist, wird der entsprechende Bereich durch das spezielle Zeichen "+ le +" (kleiner als oder gleich) gekennzeichnet. Dies fügt allen vorhandenen Dimensionen, die Sie bereits verfolgen, eine zusätzliche Dimension hinzu.

Beispielsweise exportiert unser Demo-Service ein Histogramm "+ demo_api_request_duration_seconds_bucket +", das die Verteilung der API-Anforderungsdauern verfolgt. Da dieses Histogramm 26 Buckets pro nachverfolgter Unterdimension exportiert, weist diese Metrik viele Zeitreihen auf. Betrachten wir zunächst das Rohhistogramm nur für einen Anfragetyp aus einer Instanz:

Sie sollten 26 Serien sehen, die jeweils einen Beobachtungsbereich darstellen, der durch das Zeichen "+ le +" gekennzeichnet ist:

image: https://assets.digitalocean.com/articles/prometheus_querying/histogram.png [RAW-Histogrammserie]

Mithilfe eines Histogramms können Sie Fragen wie "Wie viele meiner Anforderungen dauern länger als 100 ms?" Andererseits möchten Sie häufig eine verwandte Frage beantworten, z. B. "Mit welcher Latenz werden 99% meiner Abfragen abgeschlossen?". Wenn Ihre Histogramm-Buckets fein genug sind, können Sie dies mit der Funktion + histogram_quantile () + berechnen. Diese Funktion erwartet eine Histogrammmetrik (eine Gruppe von Reihen mit '+ le ' Bucket-Bezeichnungen) als Eingabe und Ausgabe entsprechender Quantile. Im Gegensatz zu Perzentilen, die vom 0. bis zum 100. Perzentil reichen, reicht die Zielquantilspezifikation, die die Funktion " histogram_quantile () " als Eingabe erwartet, von " 0 " bis " 1 " (also vom 90. Perzentil) Perzentil würde einem Quantil von " 0,9 +" entsprechen.

Beispielsweise könnten wir versuchen, die 90. Perzentil-API-Latenz über die gesamte Zeit für alle Dimensionen wie folgt zu berechnen:

Dies ist nicht sehr nützlich oder zuverlässig. Die Bucket-Zähler werden zurückgesetzt, wenn einzelne Service-Instanzen neu gestartet werden. In der Regel möchten Sie die aktuelle Wartezeit (z. B. in den letzten 5 Minuten) und nicht die gesamte Zeit der Metrik anzeigen. Sie können dies erreichen, indem Sie eine "+ rate () +" - Funktion auf die zugrunde liegenden Histogramm-Bucket-Zähler anwenden, die sowohl Zählerrücksetzungen als auch die Anstiegsrate jedes Buckets über das angegebene Zeitfenster berücksichtigen.

Berechnen Sie die 90. Perzentil-API-Latenz in den letzten 5 Minuten wie folgt:

Das ist viel besser und wird so aussehen:

image: https://assets.digitalocean.com/articles/prometheus_querying/quantiles_all.png [Berechnete Quantile für alle Anforderungsdimensionen]

Dies zeigt Ihnen jedoch das 90. Perzentil für die Unterdimension eveeey (+ job +, + instance,` + path`, + method n und` + status + `). Auch hier sind wir möglicherweise nicht an all diesen Dimensionen interessiert und möchten einige davon wegsammeln. Glücklicherweise kann der Prometheus-Aggregationsoperator "+ sum " zusammen mit der Funktion " histogram_quantile () +" komponiert werden, damit wir während der Abfragezeit über Dimensionen aggregieren können!

Die folgende Abfrage berechnet die Latenz des 90. Perzentils, teilt das Ergebnis jedoch nur nach den Dimensionen "+ job ", " instance " und " path +" auf:

Das Diagramm sieht nun folgendermaßen aus:

image: https: //assets.digitalocean.com/articles/prometheus_querying/quantiles_some.png [Berechnete Quantile für einige Anforderungsdimensionen]

Die Berechnung von Quantilen aus Histogrammen führt immer zu statistischen Fehlern. Dieser Fehler hängt von Ihren Bucket-Größen, der Verteilung der beobachteten Werte sowie den zu berechnenden Zielquantilen ab. Weitere Informationen hierzu finden Sie in der Prometheus-Dokumentation unter Errors of quantile estimati- on.

Sie wissen jetzt, wie Sie Histogramm-Metriken interpretieren und daraus Quantile für verschiedene Zeitbereiche berechnen können, während Sie gleichzeitig über einige Dimensionen hinweg aggregieren.

In diesem Abschnitt erfahren Sie, wie Sie Metriken verwenden, die Zeitstempel enthalten.

Komponenten im Prometheus-Ökosystem weisen häufig Zeitstempel auf. Dies kann beispielsweise das letzte Mal sein, dass ein Stapeljob erfolgreich abgeschlossen wurde, eine Konfigurationsdatei das letzte Mal erfolgreich neu geladen wurde oder ein Computer gestartet wurde. Standardmäßig werden die Zeiten seit dem 1. Januar 1970 UTC in Sekunden als Unix timestamps dargestellt.

Der Demo-Service macht beispielsweise das letzte Mal verfügbar, wenn ein simulierter Stapeljob erfolgreich war:

Dieser Stapeljob wird simuliert, um einmal pro Minute ausgeführt zu werden, schlägt jedoch bei 25% aller Versuche fehl. Im Fehlerfall behält die Metrik "+ demo_batch_last_success_timestamp_seconds +" ihren letzten Wert bei, bis eine weitere erfolgreiche Ausführung erfolgt.

Wenn Sie den rohen Zeitstempel grafisch darstellen, sieht er ungefähr so ​​aus:

image: https: //assets.digitalocean.com/articles/prometheus_querying/raw_timestamp_data.png [Raw timestamp graph]

Wie Sie sehen, ist der rohe Zeitstempelwert für sich genommen normalerweise nicht sehr nützlich. Stattdessen möchten Sie häufig wissen, wie alt der Zeitstempelwert ist. Ein gängiges Muster besteht darin, den Zeitstempel in der Metrik von der aktuellen Zeit zu subtrahieren, wie dies durch die Funktion + time () + bereitgestellt wird:

Dies gibt die Zeit in Sekunden seit dem letzten erfolgreichen Stapeljoblauf an:

Bild: https://assets.digitalocean.com/articles/prometheus_querying/timestamp_age_graph.jpg [Zeitstempel-Altersgraph]

Wenn Sie dieses Alter von Sekunden in Stunden umrechnen möchten, können Sie das Ergebnis durch + 3600 + teilen:

Ein Ausdruck wie dieser ist sowohl für die grafische Darstellung als auch für die Warnung nützlich. Wenn Sie das Zeitstempelalter wie oben dargestellt sehen, erhalten Sie ein Sägezahndiagramm mit linear ansteigenden Linien und regelmäßigen Rücksetzungen auf "+ 0 ", wenn der Stapeljob erfolgreich abgeschlossen wurde. Wenn eine Sägezahnspitze zu groß wird, deutet dies auf einen Stapeljob hin, der seit langer Zeit nicht abgeschlossen wurde. Sie können auch einen Alarm auslösen, indem Sie dem Ausdruck einen "> +" - Schwellenwertfilter hinzufügen und einen Alarm für die sich ergebenden Zeitreihen auslösen (in diesem Lernprogramm werden jedoch keine Alarmierungsregeln behandelt).

Um einfach Instanzen aufzulisten, für die der Stapeljob in den letzten 1,5 Minuten nicht abgeschlossen wurde, können Sie die folgende Abfrage ausführen:

image: https: //assets.digitalocean.com/articles/prometheus_querying/batch_jobs.png [Batchjobs anzeigen, die dahinter stehen]

Sie wissen jetzt, wie Sie rohe Zeitstempelmetriken in relative Alter umwandeln, was sowohl für die grafische Darstellung als auch für die Warnung hilfreich ist.

In diesem Schritt erfahren Sie, wie Sie die Abfrageausgabe sortieren oder nur die größten oder kleinsten Werte einer Reihe von Reihen auswählen.

In der tabellarischen Ansicht * Console * ist es oft nützlich, die Ausgabeserien nach ihrem Wert zu sortieren. Dies erreichen Sie mit den Funktionen + sort () + (aufsteigende Sortierung) und + sort_desc () + (absteigende Sortierung). Um beispielsweise die Anforderungsraten pro Pfad anzuzeigen, die nach ihrem Wert vom höchsten zum niedrigsten Wert sortiert sind, können Sie Folgendes abfragen:

Die sortierte Ausgabe sieht folgendermaßen aus:

image: https: //assets.digitalocean.com/articles/prometheus_querying/sorted_request_rates.png [Sorted request rates]

Oder vielleicht möchten Sie gar nicht alle Serien zeigen, sondern nur die K größten oder kleinsten Serien. Dafür bietet Prometheus die Funktionen + topk () + und + bottomk () + an. Sie haben jeweils einen K-Wert (wie viele Reihen Sie auswählen möchten) und einen beliebigen Ausdruck, der eine Reihe von Zeitreihen zurückgibt, die gefiltert werden sollen. Um beispielsweise nur die drei höchsten Anforderungsraten pro Pfad und Methode anzuzeigen, können Sie Folgendes abfragen:

image: https: //assets.digitalocean.com/articles/prometheus_querying/top_3_request_rates.png [Die drei besten Anfragetarife]

Während das Sortieren nur in der * Console * -Ansicht nützlich ist, können + topk () + und + bottomk () + auch in Diagrammen nützlich sein. Beachten Sie jedoch, dass bei der Ausgabe die obere oder untere K-Reihe nicht über den gesamten Zeitbereich des Diagramms gemittelt angezeigt wird. Stattdessen berechnet die Ausgabe die obere oder untere K-Reihe für jeden Auflösungsschritt entlang des Diagramms neu. Daher kann Ihre obere oder untere K-Reihe tatsächlich über den Bereich des Diagramms variieren, und Ihr Diagramm kann insgesamt mehr als K-Reihen anzeigen.

Wir haben nun gelernt, wie man die K größten oder kleinsten Serien sortiert oder nur auswählt.

In diesem Schritt erfahren Sie, wie Sie den Kratzzustand unserer Instanzen im Laufe der Zeit überprüfen.

Um den Abschnitt interessanter zu gestalten, beenden wir die erste Ihrer drei Demo-Service-Instanzen im Hintergrund (die Instanz, die Port 8080 überwacht):

Immer wenn Prometheus ein Ziel abkratzt, speichert es eine synthetische Stichprobe mit dem Metriknamen "+ up " und den Bezeichnungen " job " und " instance " der abgekratzten Instanz. Wenn das Kratzen erfolgreich war, wird der Wert der Probe auf " 1 " gesetzt. Es wird auf " 0 +" gesetzt, wenn das Scrape fehlschlägt. Auf diese Weise können wir leicht abfragen, welche Instanzen gerade "hoch" oder "runter" sind:

Dies sollte nun eine Instanz als down anzeigen:

image: https://assets.digitalocean.com/articles/prometheus_querying/instance_health.png [Instanzzustand anzeigen]

Um nur nicht aktive Instanzen anzuzeigen, können Sie nach dem Wert + 0 + filtern:

Sie sollten jetzt nur die Instanz sehen, die Sie beendet haben:

image: https://assets.digitalocean.com/articles/prometheus_querying/down_instances.png [Instanzen anzeigen]

Oder, um die Gesamtanzahl der Down-Instanzen zu erhalten:

Dies zeigt Ihnen eine Anzahl von + 1 +:

image: https: //assets.digitalocean.com/articles/prometheus_querying/down_instance_count.png [Anzeige der Anzahl der Instanzen]

Diese Art von Abfragen ist nützlich für grundlegende Warnmeldungen zum Zustand von Kratzern.

Sie wissen jetzt, wie Sie den Status der Instanz abfragen können.

In diesem Tutorial bauen wir auf dem Fortschritt von link: / community / tutorials / abfrage-an-Ubuntu-14-04-Teil-1 [Abfrage von Prometheus unter Ubuntu 14.04 Teil 1] auf und behandeln mehr Fortgeschrittene Abfragetechniken und -muster. Wir haben gelernt, wie man Reihen nach ihrem Wert filtert, Quantile aus Histogrammen berechnet, mit auf Zeitstempeln basierenden Metriken umgeht und vieles mehr.

Obwohl diese Tutorials nicht alle möglichen Anwendungsfälle für das Abfragen abdecken können, hoffen wir, dass die Beispielabfragen für Sie nützlich sind, wenn Sie echte Abfragen, Dashboards und Warnungen mit Prometheus erstellen. Weitere Informationen zur Abfragesprache von Prometheus finden Sie in der Dokumentation zur Abfragesprache von Prometheus.