Abfrage mit der Prometheus API oder UI

Nachdem Sie Google Cloud Managed Service for Prometheus bereitgestellt haben, können Sie die an den verwalteten Dienst gesendeten Daten abfragen und die Ergebnisse in Diagrammen und Dashboards darstellen.

In diesem Dokument werden Messwertbereiche beschrieben, mit denen die abfragbaren Daten und die folgenden Prometheus-basierten Möglichkeiten zum Abrufen und Verwenden der erhobenen Daten festgelegt werden:

Die Prometheus HTTP API
Die Prometheus-Benutzeroberfläche

Alle Abfrageschnittstellen für Managed Service for Prometheus sind so konfiguriert, dass Daten mit der Cloud Monitoring API aus Monarch abgerufen werden. Durch die Abfrage von Monarch anstelle der Abfrage von lokalen Prometheus-Servern erhalten Sie umfassendes globales Monitoring.

Vorbereitung

Wenn Sie den verwalteten Dienst noch nicht bereitgestellt haben, richten Sie die verwaltete Erfassung oder die selbst bereitgestellte Erfassung ein. Sie können diesen Schritt überspringen, wenn Sie nur Cloud Monitoring-Messwerte mit PromQL abfragen möchten.

Konfigurierung Ihrer Umgebung

Führen Sie die folgende Konfiguration aus, um zu vermeiden, dass Sie Ihre Projekt-ID oder den Clusternamen wiederholt eingeben müssen:

Konfigurieren Sie die Befehlszeilentools so:
- Konfigurieren Sie die gcloud CLI so, dass sie auf die ID Ihres Google Cloud-Projekts verweist:
```
gcloud config set project PROJECT_ID
```
- Konfigurieren Sie die kubectl-Befehlszeile für die Verwendung Ihres Clusters:
```
kubectl config set-cluster CLUSTER_NAME
```
Weitere Informationen zu diesen Tools finden Sie hier:
- Übersicht über gcloud-Befehlszeilen
- kubectl-Befehle

Namespace einrichten

Erstellen Sie den Kubernetes-Namespace NAMESPACE_NAME für Ressourcen, die Sie als Teil der Beispielanwendung erstellen:

kubectl create ns NAMESPACE_NAME

Anmeldedaten für das Dienstkonto prüfen

Sie können diesen Abschnitt überspringen, wenn in Ihrem Kubernetes-Cluster Workload Identity aktiviert ist.

Bei Ausführung in GKE ruft Managed Service for Prometheus automatisch Anmeldedaten aus der Umgebung anhand des Compute Engine-Standarddienstkontos ab. Das Standarddienstkonto hat standardmäßig die erforderlichen Berechtigungen monitoring.metricWriter und monitoring.viewer. Wenn Sie Workload Identity nicht verwenden und zuvor eine dieser Rollen aus dem Standardknotendienstkonto entfernt haben, müssen Sie diese fehlenden Berechtigungen wieder hinzufügen, bevor Sie fortfahren.

Wenn Sie nicht GKE ausführen, finden Sie weitere Informationen unter Anmeldedaten explizit angeben.

Dienstkonto für Workload Identity konfigurieren

Sie können diesen Abschnitt überspringen, wenn in Ihrem Kubernetes-Cluster Workload Identity nicht aktiviert ist.

Managed Service for Prometheus erfasst Messwertdaten mithilfe der Cloud Monitoring API. Wenn Ihr Cluster Workload Identity verwendet, müssen Sie dem Kubernetes-Dienstkonto die Berechtigung für die Monitoring API erteilen. In diesem Abschnitt wird Folgendes beschrieben:

Dediziertes Google Cloud-Dienstkonto gmp-test-sa erstellen
Google Cloud-Dienstkonto an das Standard-Kubernetes-Dienstkonto im Test-Namespace NAMESPACE_NAME binden
Dem Google Cloud-Dienstkonto die erforderliche Berechtigung gewähren

Dienstkonto erstellen und binden

Dieser Schritt wird an mehreren Stellen in der Dokumentation zu Managed Service for Prometheus aufgeführt. Wenn Sie diesen Schritt bereits als Teil einer vorherigen Aufgabe ausgeführt haben, müssen Sie ihn nicht wiederholen. Fahren Sie mit Dienstkonto autorisieren fort.

Mit der folgenden Befehlssequenz wird das Dienstkonto gmp-test-sa erstellt und an das Standard-Kubernetes-Dienstkonto im Namespace NAMESPACE_NAME gebunden:

gcloud config set project PROJECT_ID \
&&
gcloud iam service-accounts create gmp-test-sa \
&&
gcloud iam service-accounts add-iam-policy-binding \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:PROJECT_ID.svc.id.goog[NAMESPACE_NAME/default]" \
  gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
&&
kubectl annotate serviceaccount \
  --namespace NAMESPACE_NAME \
  default \
  iam.gke.io/gcp-service-account=gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com

Wenn Sie einen anderen GKE-Namespace oder ein anderes GKE-Dienstkonto verwenden, passen Sie die Befehle entsprechend an.

Dienstkonto autorisieren

Gruppen zusammengehöriger Berechtigungen werden in Rollen zusammengefasst und Sie weisen die Rollen einem Hauptkonto zu, in diesem Beispiel dem Google Cloud-Dienstkonto. Weitere Informationen zu Monitoring-Rollen finden Sie unter Zugriffssteuerung.

Mit dem folgenden Befehl werden dem Google Cloud-Dienstkonto gmp-test-sa die Monitoring API-Rollen zugewiesen, die zum Lesen von Messwertdaten erforderlich sind.

Wenn Sie dem Google Cloud-Dienstkonto im Rahmen der vorherigen Aufgabe bereits eine bestimmte Rolle zugewiesen haben, müssen Sie dies nicht noch einmal tun.

Folgen Sie dieser Anleitung, um Ihr Dienstkonto zum Lesen aus einem Bereich mit Messwerten für mehrere Projekte zu autorisieren, und informieren Sie sich dann unter Abfrage des Projekts ändern.

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/monitoring.viewer

Workload Identity-Konfiguration debuggen

Wenn Sie Probleme mit der Workload Identity haben, lesen Sie die Dokumentation zum Prüfen der Workload Identity-Einrichtung und zur Fehlerbehebung bei Workload Identity.

Da Tippfehler und partielle Kopierfunktionen die häufigsten Fehlerquellen bei der Konfiguration von Workload Identity sind, empfehlen wir dringend die bearbeitbaren Variablen und anklickbaren Symbole, die in die Codebeispiele in dieser Anleitung eingebettet sind.

Workload Identity in Produktionsumgebungen

Das in diesem Dokument beschriebene Beispiel bindet das Google Cloud-Dienstkonto an das Standard-Kubernetes-Dienstkonto und gewährt dem Google Cloud-Dienstkonto alle erforderlichen Berechtigungen zur Verwendung der Monitoring API.

In einer Produktionsumgebung können Sie einen feiner abgestimmten Ansatz mit einem Dienstkonto für jede Komponente nutzen, das jeweils nur minimale Berechtigungen hat. Weitere Informationen zum Konfigurieren von Dienstkonten für die Verwaltung von Workload Identity finden Sie unter Workload Identity verwenden.

Abfragen und Messwertbereiche

Die Daten, die Sie abfragen können, werden durch den Messwertbereich von Cloud Monitoring-Konstrukten festgelegt, unabhängig von der Methode, die Sie zum Abfragen der Daten verwenden. Wenn Sie beispielsweise Grafana verwenden, um Managed Service for Prometheus-Daten abzufragen, muss jeder Messwertbereich als separate Datenquelle konfiguriert werden.

Ein Monitoring-Messwertbereich ist ein schreibgeschütztes Konstrukt, mit dem Sie Messwertdaten abfragen können, die zu mehreren Google Cloud-Projekten gehören. Jeder Messwertbereich wird von einem festgelegten Google Cloud-Projekt gehostet, dem sogenannten Scoping-Projekt.

Standardmäßig ist ein Projekt das den Bereich festlegende Projekt für den eigenen Messwertbereich und der Messwertbereich enthält die Messwerte und die Konfiguration für dieses Projekt. Ein den Bereich festlegendes Projekt kann mehrere überwachte Projekte in seinem Messwertbereich enthalten und die Messwerte und Konfigurationen aus allen überwachten Projekten im Messwertbereich sind für das den Bereich festlegende Projekt sichtbar. Ein überwachtes Projekt kann auch zu mehreren Messwertbereichen gehören.

Wenn Sie die Messwerte in einem den Bereich festlegenden Projekt abfragen und dieses Projekt einen Messwertbereich für mehrere Projekte hostet, können Sie Daten aus mehreren Projekten abrufen. Wenn der Messwertbereich alle Ihre Projekte enthält, werden Ihre Abfragen und Regeln global ausgewertet.

Weitere Informationen zu den Bereich festlegenden Projekten und Messwertbereichen finden Sie unter Messwertbereiche. Informationen zum Konfigurieren eines Messwertbereichs für mehrere Projekte finden Sie unter Messwerte für mehrere Projekte ansehen.

Managed Service for Prometheus-Daten in Cloud Monitoring

Am einfachsten können Sie prüfen, ob Ihre Prometheus-Daten exportiert werden, indem Sie die Cloud Monitoring-Seite "Metrics Explorer" in der Google Cloud Console verwenden, die PromQL unterstützt. Eine Anleitung finden Sie unter Abfragen mit PromQL in Cloud Monitoring.

Eigenständige Prometheus-Frontend-Benutzeroberfläche

Sie können die eigenständige Prometheus-Frontend-Benutzeroberfläche verwenden, um aufgenommene Daten aufzurufen und zu visualisieren. Diese Benutzeroberfläche führt PromQL-Abfragen für alle Daten in Ihrem Google Cloud-Projekt aus, je nach dem Messwertbereich, der mit Ihrem Projekt verknüpft ist.

Die Frontend-Benutzeroberfläche dient auch als Authentifizierungsproxy für den Zugriff auf aufgenommene Daten. Dieses Feature kann für Clienttools verwendet werden, die OAuth2 für Dienstkonten nicht unterstützen, einschließlich Grafana oder horizontales Pod-Autoscaling mit der prometheus-adapter-Bibliothek.

Wir empfehlen dringend, Grafana so zu konfigurieren, dass Daten aus Managed Service for Prometheus mit dem Datenquellen-Synchronizer visualisiert werden. Die Anleitung zum Konfigurieren von Grafana mithilfe der eigenständigen Prometheus-Front-End-UI finden Sie hier als Referenz für Nutzer, die Grafana mit dieser Methode konfiguriert haben.

Frontend-Benutzeroberfläche bereitstellen

Führen Sie die folgenden Befehle aus, um die eigenständige Prometheus-Frontend-Benutzeroberfläche für Managed Service for Prometheus bereitzustellen:

Stellen Sie den Dienst frontend bereit und konfigurieren Sie ihn so, dass das den Bereich festlegende Projekt des Messwertbereichs Ihrer Wahl abgefragt wird:

curl https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.10.0/examples/frontend.yaml |
sed 's/\$PROJECT_ID/PROJECT_ID/' |
kubectl apply -n NAMESPACE_NAME -f -

Führen Sie eine Portweiterleitung des frontend-Dienstes zum lokalen Computer durch. Im folgenden Beispiel wird der Dienst an Port 9090 weitergeleitet:
```
kubectl -n NAMESPACE_NAME port-forward svc/frontend 9090
```
Dieser Befehl gibt nichts zurück und während er ausgeführt wird, meldet er Zugriffe auf die URL.

Wenn Sie weiterhin ein von kube-prometheus installiertes Grafana-Deployment verwenden möchten, stellen Sie stattdessen im Namespace monitoring die eigenständige Prometheus-Frontend-Benutzeroberfläche bereit.

Sie können auf die eigenständige Prometheus-Frontend-Benutzeroberfläche in Ihrem Browser unter der URL http://localhost:9090 zugreifen. Wenn Sie Cloud Shell für diesen Schritt verwenden, können Sie über die Schaltfläche Webvorschau Zugriff erhalten.

Der folgende Screenshot zeigt eine Tabelle in der eigenständigen Prometheus-Frontend-Benutzeroberfläche, in der der Messwert up angezeigt wird:

Messwert in der Prometheus-Benutzeroberfläche ansehen

Sie können auch eine geeignete Authentifizierung und Autorisierung für den Dienst frontend einrichten. Verwenden Sie dazu beispielsweise Identity-Aware Proxy. Weitere Informationen zum Verfügbarmachen von Diensten finden Sie unter Anwendungen über Dienste verfügbar machen.

Abgefragtes Projekt ändern, um Monitoring in mehreren Projekten zu erhalten

Die frontend-Bereitstellung verwendet das konfigurierte Google Cloud-Projekt als den Bereich festlegendes Projekt. Wenn dieses Projekt das den Bereich festlegende Projekt des Messwertbereichs mit mehreren Projekten ist, kann es Messwerte aus allen Projekten im Messwertbereich lesen.

Sie können ein Projekt mit einem Messwertbereich für mehrere Projekte mit dem Flag --query.project-id angeben.

In der Regel verwenden Sie ein dediziertes Projekt als den Bereich festlegendes Projekt. Dieses Projekt ist nicht das Projekt, in dem die frontend-Bereitstellung ausgeführt wird. Gehen Sie so vor, damit die Bereitstellung ein anderes Zielprojekt lesen kann:

Teilen Sie der frontend-Bereitstellung mit, welches Projekt das Zielprojekt ist.
Gewähren Sie dem Dienstkonto die Berechtigung zum Lesen des Zielprojekts. Wenn Sie das Compute Engine-Dienstkonto default verwendet haben, können Sie einen der folgenden Schritte ausführen:
- Aktivieren Sie Workload Identity für Ihren Cluster und folgen Sie den Konfigurationsschritten.
- Geben Sie einen expliziten Dienstkontoschlüssel an.

So gewähren Sie die nötigen Berechtigungen für den Zugriff auf ein anderes Google Cloud-Projekt:

Gewähren Sie dem Dienstkonto die Berechtigung zum Lesen aus dem Zielprojekt, das Sie abfragen möchten:

gcloud projects add-iam-policy-binding SCOPING_PROJECT_ID \
  --member=serviceAccount:gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/monitoring.viewer

Öffnen Sie die zuvor erstellte frontend-Bereitstellung zum Bearbeiten:
```
kubectl -n NAMESPACE_NAME edit deploy frontend
```
Geben Sie das Zielprojekt mit dem Flag --query.project-id an:
```
apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: NAMESPACE_NAME
  name: frontend
spec:
  template
    containers:
    - name: frontend
      args:
      - --query.project-id=SCOPING_PROJECT_ID
...
```
Speichern Sie die Datei und schließen Sie den Editor. Nachdem die Änderung angewendet wurde, werden die Frontend-Pods neu gestartet und fragen das neue den Bereich festlegende Projekt ab.

Frontend-Benutzeroberfläche authentifizieren

Das Deployment frontend unterstützt die Basiszugriffsauthentifizierung für den authentifizierten Zugriff in Version 0.5.0 und höher. Zur Aktivierung der Authentifizierung fügen Sie dem Deployment die Umgebungsvariablen AUTH_USERNAME und AUTH_PASSWORD hinzu:

apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: NAMESPACE_NAME
  name: frontend
spec:
  template
    containers:
    - name: frontend
      env:
      - name: AUTH_USERNAME
        value: USERNAME
      - name: AUTH_PASSWORD
        value: PASSWORD
...

Anmeldedaten explizit angeben

Sie können diesen Abschnitt überspringen, wenn Sie den Container frontend in einem Google Kubernetes Engine-Cluster ausführen. Wenn Sie Probleme mit der Authentifizierung in GKE haben, lesen Sie die Informationen unter Anmeldedaten des Dienstkontos prüfen.

Bei der Ausführung in GKE ruft das Frontend automatisch Anmeldedaten aus der Umgebung anhand des Dienstkontos des Knotens oder der Workload Identity-Einrichtung ab. In Nicht-GKE-Kubernetes-Clustern müssen Anmeldedaten explizit mit Flags oder der Umgebungsvariablen GOOGLE_APPLICATION_CREDENTIALS für das Frontend bereitgestellt werden.

Legen Sie den Kontext auf Ihr Zielprojekt fest:
```
gcloud config set project PROJECT_ID
```
Erstellen Sie ein Dienstkonto:
```
gcloud iam service-accounts create gmp-test-sa
```
Mit diesem Schritt wird das Dienstkonto erstellt, das Sie möglicherweise bereits in der Workload Identity-Anleitung erstellt haben.

Gewähren Sie die erforderlichen Berechtigungen für das Dienstkonto:

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/monitoring.viewer

Erstellen Sie einen Schlüssel für das Dienstkonto und laden Sie ihn herunter:

gcloud iam service-accounts keys create gmp-test-sa-key.json \
  --iam-account=gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com

Fügen Sie dem Nicht-GKE-Cluster die Schlüsseldatei als Secret hinzu:

kubectl -n NAMESPACE_NAME create secret generic gmp-test-sa \
  --from-file=key.json=gmp-test-sa-key.json

Öffnen Sie die Frontend-Deployment-Ressource zur Bearbeitung:
```
kubectl -n NAMESPACE_NAME edit deploy frontend
```
1. Fügen Sie der Ressource den fett formatierten Text hinzu:
```
apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: NAMESPACE_NAME
  name: frontend
spec:
  template
    containers:
    - name: frontend
      args:
      - --query.credentials-file=/gmp/key.json
...
      volumeMounts:
      - name: gmp-sa
        mountPath: /gmp
        readOnly: true
...
    volumes:
    - name: gmp-sa
      secret:
        secretName: gmp-test-sa
...
```
2. Speichern Sie die Datei und schließen Sie den Editor. Nachdem die Änderung angewendet wurde, werden die Pods neu erstellt und beginnen mit der Authentifizierung beim Messwert-Backend mit dem angegebenen Dienstkonto.
Anstelle der Verwendung der in diesem Beispiel festgelegten Flags können Sie den Schlüsseldateipfad mithilfe der Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS festlegen.
Grafana über den Front-End-Proxy verwenden

Managed Service for Prometheus verwendet die integrierte Prometheus-Datenquelle für Grafana. Das bedeutet, dass Sie weiterhin alle von der Community erstellten oder persönlichen Grafana-Dashboards ohne Änderungen verwenden können. Sie können auch Ihre Grafana-Dashboards in Cloud Monitoring importieren.

Bei Google Cloud APIs authentifizieren

Warnung: Wir empfehlen dringend, Grafana zu konfigurieren, um Daten aus Managed Service for Prometheus mit dem Datenquellen-Synchronizer zu visualisieren. Diese Anleitung zum Konfigurieren von Grafana über die eigenständige Prometheus-Front-End-UI finden Sie hier als Referenz für Nutzer, die Grafana mit dieser Methode konfiguriert haben.

Alle Google Cloud APIs erfordern eine Authentifizierung mit OAuth2. Grafana unterstützt jedoch keine OAuth2-Authentifizierung für Dienstkonten, die mit Prometheus-Datenquellen verwendet werden. Wenn Sie Grafana mit Managed Service for Prometheus verwenden möchten, verwenden Sie die eigenständige Prometheus-Frontend-Benutzeroberfläche als Authentifizierungsproxy.

Sie müssen Grafana auf den Proxy der eigenständigen Frontend-Benutzeroberfläche verweisen, um Daten global abzufragen. Wenn Sie diese Schritte nicht ausführen, führt Grafana Abfragen nur für Daten auf dem lokalen Prometheus-Server aus.

Wenn Sie den Dienst der Prometheus-Benutzeroberfläche frontend noch nicht als Proxy bereitgestellt haben, holen Sie dies jetzt mit dem folgenden Befehl nach:
```
curl https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.10.0/examples/frontend.yaml |
sed 's/\$PROJECT_ID/PROJECT_ID/' |
kubectl apply -n NAMESPACE_NAME -f -
```
Für Nicht-GKE-Kubernetes-Cluster wie Anthos-Cluster finden Sie unter Anmeldedaten explizit angeben den frontend-Dienst, der zum Abfragen von Messwerten erforderlich ist.

Unter Abfrageprojekt ändern finden Sie eine Anleitung zum Konfigurieren des Messwertbereichs, der von diesem frontend-Dienst verwendet wird, um Abfragen über mehrere Projekte hinweg durchzuführen.

Wenn Sie bereits ein Grafana-Deployment haben, z. B. eins aus der kube-prometheus-Bibliothek oder eins, das mit einem Helm-Diagramm installiert wurde, können Sie es weiterhin mit Managed Service for Prometheus verwenden. Lesen Sie in diesem Fall die nächsten Schritte unter Datenquelle konfigurieren. Andernfalls müssen Sie zuerst Grafana bereitstellen.

Grafana bereitstellen

Wenn in Ihrem Cluster keine Grafana-Bereitstellung ausgeführt wird, können Sie eine sitzungsspezifische Testbereitstellung zum Experimentieren erstellen.

Wenn Sie eine sitzungsspezifische Grafana-Bereitstellung erstellen möchten, wenden Sie das Manifest grafana.yaml von Managed Service for Prometheus auf Ihren Cluster an und führen Sie eine Portweiterleitung des grafana-Dienstes zu Ihrem lokalen Computer durch. Im folgenden Beispiel wird der Dienst an Port 3000 weitergeleitet.
1. Wenden Sie das grafana.yaml-Manifest an:
```
kubectl -n NAMESPACE_NAME apply -f  https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/beb779d32f4dd531a3faad9f2916617b8d9baefd/examples/grafana.yaml
```
2. Führen Sie eine Portweiterleitung des grafana-Dienstes zum lokalen Computer durch. In diesem Beispiel wird der Dienst an Port 3000 weitergeleitet:
```
kubectl -n NAMESPACE_NAME port-forward svc/grafana 3000
```
  Dieser Befehl gibt nichts zurück und während er ausgeführt wird, meldet er Zugriffe auf die URL.
  
  Sie können Grafana in Ihrem Browser unter der URL http://localhost:3000 mit dem Nutzernamen admin:admin aufrufen.
Datenquelle konfigurieren

Wenn Sie Managed Service for Prometheus in Grafana abfragen möchten, indem Sie die Prometheus-Benutzeroberfläche als Authentifizierungsproxy verwenden, müssen Sie Grafana eine neue Datenquelle hinzufügen. So fügen Sie eine Datenquelle für den verwalteten Dienst hinzu:
1. Wechseln Sie zu Ihrer Grafana-Bereitstellung, indem Sie beispielsweise die URL http://localhost:3000 aufrufen, um die Grafana-Begrüßungsseite zu erreichen.
2. Wählen Sie im Hauptmenü von Grafana die Option Konfiguration und dann Datenquellen aus.
3. Wählen Sie Datenquelle hinzufügen und dann Prometheus als Zeitachsendatenbank aus.
4. Geben Sie im Feld URL des Bereichs HTTP die URL des Managed Service for Prometheus-frontend-Dienstes ein. Wenn Sie die Prometheus-Frontend-Benutzeroberfläche für die Ausführung an Port 9090 konfiguriert haben, ist die Dienst-URL für dieses Feld http://frontend.NAMESPACE_NAME.svc:9090.
  
  Legen Sie im Feld Zeitlimit des HTTP-Bereichs den Wert auf 120 fest.
  
  Wenn Sie den Proxy der Frontend-Benutzeroberfläche mit Basisauthentifizierung konfiguriert haben, aktivieren Sie den Schalter Basisauthentifizierung im Bereich Authentifizierung und geben Sie den Nutzernamen und das Passwort ein.
  
  Legen Sie im Feld Abfragezeitüberschreitung den Wert auf 2m fest.
  
  Wählen Sie im Feld HTTP-Methode die Option GET aus.
  
  Wählen Sie im Feld Prometheus-Typ die Option Prometheus aus.
  
  Wählen Sie im Feld Prometheus-Version 2.40.x oder höher aus.
  
  Wenn Sie mehrere Prometheus-Datenquellen haben, können Sie dieser einen Namen wie "Managed Prometheus-Dienst" geben. Übernehmen Sie die Standardwerte der restlichen Felder.
5. Klicken Sie auf Speichern und Testen und suchen Sie nach der Meldung "Die Datenquelle funktioniert".
Hinweis: Sie können auch den Container frontend als Sidecar im Grafana-Pod bereitstellen. Diese Datenquelle kann darauf unter der URL http://localhost:9090 zugreifen.

Neue Datenquelle verwenden

Sie können jetzt Grafana-Dashboards mit der neuen Datenquelle erstellen. Sie können auch vorhandene Dashboards an die neue Datenquelle weiterleiten. Der folgende Screenshot zeigt ein Grafana-Diagramm mit dem Messwert up:

Managed Service for Prometheus mit Thanos verbinden

Sie können Managed Service for Prometheus mithilfe des Open-Source-Angebots thanos-promql-connector mit einem selbst bereitgestellten Thanos-Stack verbinden. Google Cloud unterstützt diese Einbindung nicht.

Prometheus HTTP API

Managed Service for Prometheus unterstützt die vorgelagerte Prometheus HTTP API unter der URL mit dem Präfix https://monitoring.googleapis.com/v1/projects/PROJECT_ID/location/global/prometheus/api/v1/. Informationen zu den unterstützten Endpunkten finden Sie unter API-Kompatibilität.

Auf diese API kann von jedem Tool zugegriffen werden, das mit einem Standard-Prometheus-Server interagieren kann. Dies ist nur ein API-Endpunkt. Es wird keine Benutzeroberfläche bereitgestellt. Als Google Cloud API verwendet die API die OAuth2-Authentifizierung. Als Teil der Cloud Monitoring API ist der Wert von PROJECT_ID das den Bereich festlegende Projekt eines Messwertbereichs, sodass Sie Daten von jedem Projekt im Messwertbereich abrufen können. Weitere Informationen zum Festlegen des Bereichs finden Sie unter Messwertbereiche.

Geben Sie einen PromQL-Ausdruck an, um diesen Endpunkt zu verwenden. Die folgende sofortige Abfrage ruft beispielsweise alle Zeitachsen mit dem Messwertnamen up ab:
```
curl https://monitoring.googleapis.com/v1/projects/PROJECT_ID/location/global/prometheus/api/v1/query \
  -d "query=up" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)"
```
Wenn die Anfrage erfolgreich ist, gibt die Abfrage ein Ergebnis wie das folgende zurück, das zur besseren Lesbarkeit formatiert wurde:
```
{
  "status":"success",
  "data":{
    "resultType":"vector",
    "result":[{
      "metric": {
        "__name__":"up",
        "cluster":"gmp-test",
        "instance":"prom-example-84c6f547f5-g4ljn:web",
        "job":"prometheus",
        "location":"us-central1-a",
        "project_id":"a-gcp-project"
      },
      "value": [1634873239.971,"1"]
    }]
  }
}
```
Informationen zum Abfragen von Google Cloud-Systemmesswerten mit PromQL finden Sie unter PromQL für Cloud Monitoring-Messwerte.

API-Kompatibilität

Die folgenden Prometheus HTTP API-Endpunkte werden von Managed Service for Prometheus unter der URL mit dem Präfix https://monitoring.googleapis.com/v1/projects/PROJECT_ID/location/global/prometheus/api/v1/ unterstützt.

Eine vollständige Dokumentation finden Sie in der Referenzdokumentation zur Cloud Monitoring API.

Informationen zur PromQL-Kompatibilität finden Sie unter PromQL-Unterstützung.
- Die folgenden Endpunkte werden vollständig unterstützt:
  - /api/v1/query
  - /api/v1/query_range
  - /api/v1/metadata
  - /api/v1/labels
  - /api/v1/query_exemplars
- Der Endpunkt /api/v1/label/<label_name>/values funktioniert nur, wenn das Label __name__ entweder durch Verwendung des Werts <label_name> oder durch genaue Übereinstimmung mit einem Serienselektor angegeben wird. Die folgenden Aufrufe werden beispielsweise vollständig unterstützt:
  - /api/v1/label/__name__/values
  - /api/v1/label/__name__/values?match[]={__name__=~".*metricname.*"}
  - /api/v1/label/labelname/values?match[]={__name__="metricname"}
  Diese Einschränkung führt dazu, dass label_values($label)-Variablenabfragen in Grafana fehlschlagen. Stattdessen können Sie label_values($metric, $label) verwenden. Dieser Abfragetyp wird empfohlen, da damit keine Werte für Labels zu Messwerten abgerufen werden, die für das entsprechende Dashboard nicht relevant sind.
- Der Endpunkt /api/v1/series wird für GET-, aber nicht für POST-Anfragen unterstützt. Wenn Sie den Datenquellensynchronisierung oder Front-End-Proxy verwenden, wird diese Einschränkung für Sie verwaltet. Sie können Ihre Prometheus-Datenquellen in Grafana auch so konfigurieren, dass nur GET-Anfragen gesendet werden. Der Parameter match[] unterstützt den Abgleich regulärer Ausdrücke für das Label __name__ nicht.