Diese Seite wurde von der Cloud Translation API übersetzt.

Beobachtbarkeit von Mikrodiensten einrichten

Dieses Dokument enthält die Informationen, die Sie zum Einrichten des Beobachtbarkeits-Plug-ins für Mikrodienste, zum Instrumentieren Ihrer gRPC-Anwendungen und zum Abrufen von Informationen aus Cloud Monitoring, Cloud Logging und Cloud Trace benötigen.

Hinweis

Die Beobachtbarkeit von Mikrodiensten funktioniert mit jeder Bereitstellung, der durch Aktivieren der Microservices API Zugriff auf Cloud Monitoring, Cloud Logging, und Cloud Trace gewährt wurde. Diese Anleitung enthält ein Beispiel für die Einrichtung der Beobachtbarkeit von Mikrodiensten anhand einer Compute Engine-Umgebung.

Auf übergeordneter Ebene führen Sie diese Schritte aus:

Als Dienstentwickler aktivieren und steuern Sie das Plug-in für die Beobachtbarkeit von Mikrodiensten.
Als Dienstoperator nutzen Sie die erfassten Daten auf verschiedene Arten.

Die gRPC-Repositories (C++, Go und Java) enthalten Beispiele zur Veranschaulichung der Beobachtbarkeit von Mikrodiensten.

Führen Sie die folgenden Aufgaben aus, bevor Sie die Beobachtbarkeit konfigurieren:

Lesen Sie die Übersicht über Mikrodienst-Beobachtbarkeit.
Sie benötigen ein vorhandenes Projekt oder müssen ein neues Projekt erstellen.
Sie benötigen ein vorhandenes Dienstkonto oder müssen ein neues erstellen.
Lesen Sie über die zwei unterstützten Umgebungsvariablen nach und entscheiden Sie, welche verwendet werden soll, und ermitteln Sie die Werte, die für die Umgebungsvariable erforderlich sind.
Aktivieren Sie die Microservices API.

Umgebungsvariable für die Konfiguration auswählen

Wenn Sie das Beobachtbarkeits-Plug-in für Mikrodienste aktivieren, das unter Anwendungen für das Beobachtbarkeits-Plug-in instrumentieren beschrieben wird, müssen Sie die Konfigurationsinformationen mithilfe einer Umgebungsvariablen bereitstellen. Standardmäßig sind keine Beobachtbarkeitsfunktionen aktiviert. Sie legen die Umgebungsvariable auf der VM oder dem Container fest, auf dem die gRPC-Anwendung oder -Arbeitslast ausgeführt wird:

Folgende Umgebungsvariablen sind erforderlich:

GRPC_GCP_OBSERVABILITY_CONFIG_FILE: Der Wert ist ein Pfad, der auf eine JSON-codierte Konfigurationsdatei verweist.
GRPC_GCP_OBSERVABILITY_CONFIG: Der Wert ist der im JSON-Format codierte Text der Konfiguration.

Wenn beide Umgebungsvariablen festgelegt sind, hat GRPC_GCP_OBSERVABILITY_CONFIG_FILE Vorrang vor GRPC_GCP_OBSERVABILITY_CONFIG.

Zum Anwenden der Konfiguration müssen Sie die gRPC-Anwendung neu starten. Sie können die Werte der Umgebungsvariablen in der Google Cloud Console nicht festlegen oder ansehen.

In der Konfiguration können Sie ein Zielprojekt festlegen, in das Logging-, Tracing- und Messwertdaten hochgeladen werden. Sie legen die Projekt-ID im Feld project_id fest.

Wenn dieses Feld leer bleibt, füllt das Beobachtbarkeits-Plug-in den Wert der Projekt-ID automatisch anhand der Standardanmeldedaten für Anwendungen aus.
Wenn die Standardanmeldedaten für Anwendungen nicht identifiziert werden können und das Feld project_id leer ist, löst die Methode INIT/START einen Fehler aus oder gibt einen Fehler an die Anwendung zurück. Die Anwendung muss dann den Fehler verarbeiten.

Legen Sie mit den Informationen unter Konfigurationsdaten die Werte in der von Ihnen ausgewählten Umgebungsvariable fest.

Microservices API aktivieren

Sie können mit der Google Cloud CLI oder mit der Google Cloud Console die Microservices API in Ihren Projekten aktivieren. Durch Aktivierung der Microservices API werden automatisch die Cloud Logging API, die Cloud Monitoring API und die Cloud Trace API aktiviert.

So aktivieren Sie die API:

gcloud services enable microservices.googleapis.com

Dienstkontoberechtigungen festlegen

Wenn Sie kein Standarddienstkonto verwenden, gewähren Sie dem Dienstkonto die erforderlichen Berechtigungen. Stellen Sie folgende Werte ein:

PROJECT_ID: Setzen Sie Ihre Projekt-ID ein.
SERVICE_ACCOUNT_NAME: Setzen Sie den Namen des Dienstkontos Ihres Projekts ein.

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/logging.logWriter

gcloud projects add-iam-policy-binding PROJECT_ID> \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/monitoring.metricWriter

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/cloudtrace.agent

Anwendungen für das Beobachtbarkeits-Plug-in instrumentieren

Verwenden Sie die folgende Anleitung für C++, Java, und Go, um Ihre Anwendungen so zu instrumentieren, dass sie das Mikrodienste-Beobachtbarkeits-Plug-in verwenden können.

C++

Sie können C++ mit der Beobachtbarkeit von Mikrodiensten ab gRPC C++ v1.54 verwenden. Das Beispiel-Repository befindet sich auf GitHub.

Änderungen am Build

Der Support für die Beobachtbarkeit ist nur über das Bazel-Buildsystem verfügbar. Fügen Sie das Ziel grpcpp_gcp_observability als Abhängigkeit hinzu.

Erforderliche Codeänderungen

Die Aktivierung der Beobachtbarkeit von Mikrodiensten erfordert eine zusätzliche Abhängigkeit (ein Beobachtbarkeitsmodul) und die folgenden Codeänderungen an vorhandenen gRPC-Clients, -Servern oder beidem:

#include <grpcpp/ext/gcp_observability.h>

int main(int argc, char** argv) {
  auto observability = grpc::GcpObservability::Init();
  assert(observability.ok());
  …
  // Observability data flushed when object goes out of scope
}

Führen Sie vor allen gRPC-Vorgängen, einschließlich dem Erstellen eines Kanals, Servers oder Anmeldedaten, Folgendes aus:

grpc::GcpObservability::Init();

Es wird absl::StatusOr<GcpObservability> zurückgegeben, was gespeichert werden sollte. Der Status hilft bei der Feststellung, ob die Beobachtbarkeit erfolgreich initialisiert wurde. Das zugehörige GcpObservability-Objekt steuert die Lebensdauer der Beobachtbarkeit und schließt und entfernt Daten zur Beobachtbarkeit automatisch, wenn sie außerhalb des Gültigkeitsbereichs liegen.

Go

Plug-ins für Beobachtbarkeit von Mikrodiensten werden in gRPC Go-Versionen v1.54.0 und höher unterstützt. Das Beispiel-Repository befindet sich auf GitHub.

Wenn Sie die Beobachtbarkeit von Mikrodiensten aktivieren, sind für das Go-Modul ein Beobachtbarkeitsmodul und der folgende Code erforderlich:

import "google.golang.org/grpc/gcp/observability"

func main() {
       ctx, cancel := context.WithTimeout(context.Background(), time.Second)
       defer cancel()
       if err := observability.Start(ctx); err != nil {
              log.Warning("Unable to start gRPC observability:", err)
       }
       defer observability.End()
       …
}

Der Aufruf observability.Start parst die Konfiguration aus Umgebungsvariablen, erstellt entsprechend Exporter und fügt eine Erfassungslogik in Clientverbindungen und Server ein, die nach dem Aufruf erstellt werden. Der zurückgestellte Aufruf observability.End bereinigt Ressourcen und stellt sicher, dass die Daten im Zwischenspeicher gelöscht werden, bevor die Anwendung geschlossen wird.

Führen Sie nach dem Aktualisieren des Anwendungscodes den folgenden Befehl aus, um die Datei go.mod zu aktualisieren.

go mod tidy

Java

Um die Beobachtbarkeit von Mikrodiensten für Java-Anwendungen zu verwenden, ändern Sie den Build so, dass das Artefakt grpc-gcp-observability enthalten ist. Verwenden Sie die gRPC-Version 1.54.1 oder höher.

In den Build-Snippets in den Abschnitten der Gradle- und Maven-Build-Tools ist grpcVersion auf den Wert 1.54.1 festgelegt.

Das Beispiel-Repository befindet sich auf GitHub.

Erforderliche Java-Codeänderungen

Fügen Sie den folgenden Code zu main() hinzu, um Ihre Java-Anwendungen für die Beobachtbarkeit von Mikrodiensten zu instrumentieren.

...
import io.grpc.gcp.observability.GcpObservability;
...

// Main application class
...

public static void main(String[] args) {
...
   // call GcpObservability.grpcInit() to initialize & get observability
   GcpObservability observability = GcpObservability.grpcInit();

...
   // call close() on the observability instance to shutdown observability
   observability.close();
...
}

Sie müssen GcpObservability.grpcInit() aufrufen, bevor gRPC-Kanäle oder -Server erstellt werden. Die Funktion GcpObservability.grpcInit() liest die Konfiguration der Mikrodienst-Beobachtbarkeit und verwendet sie, um die globalen Interceptor und Tracer einzurichten, die für die Logging-, Messwert- und Trace-Funktionalität in jedem erstellten Kanal und Server erforderlich sind. GcpObservability.grpcInit() ist threadsicher und muss genau einmal aufgerufen werden. Die Funktion gibt eine Instanz von GcpObservability zurück, die Sie speichern müssen, um später close() aufrufen zu können.

GcpObservability.close() hebt die Zuweisung von Ressourcen auf. Kanäle, die danach erstellt werden, führen kein Logging durch.

GcpObservability implementiert java.lang.AutoCloseable, das automatisch geschlossen wird, wenn Sie try-with-resources so verwenden:

...
import io.grpc.gcp.observability.GcpObservability;
...

// Main application class
...

public static void main(String[] args) {
...
   // call GcpObservability.grpcInit() to initialize & get observability
   try (GcpObservability observability = GcpObservability.grpcInit()) {

...
   } // observability.close() called implicitly
...
}

Gradle-Build-Tool verwenden

Wenn Sie das Gradle-Build-Tool verwenden, geben Sie Folgendes an:

def grpcVersion = '1.54.1'

...

dependencies {
...
   implementation "io.grpc:grpc-gcp-observability:${grpcVersion}"
...
}

Maven-Build-Tool (pom.xml) verwenden

Wenn Sie das Maven-Build-Tool verwenden, geben Sie Folgendes an:

<properties>
...
  <grpc.version>1.54.1</grpc.version>
...
</properties>

...

<dependencies>
...
 <dependency>
   <groupId>io.grpc</groupId>
   <artifactId>grpc-gcp-observability</artifactId>
   <version>${grpc.version}</version>
 </dependency>
...
</dependencies>

Datenerfassung für Messwerte, Tracing und Logging aktivieren

In den folgenden Abschnitten finden Sie eine Anleitung zum Aktivieren der Datenerfassung in Ihrer Konfiguration und ein Beispiel, das die Konfigurationsinformationen in einer Umgebungsvariablen zeigt.

Messwerte aktivieren

Fügen Sie zum Aktivieren von Messwerten das Objekt cloud_monitoring zur Konfiguration hinzu und setzen Sie den Wert auf {}.

Weitere Informationen zu Messwerten finden Sie unter Definitionen von Messwerten.

Tracing aktivieren

Wenn Sie das Tracing über Dienste hinweg aktivieren möchten, müssen Sie dafür sorgen, dass die Dienste die Weitergabe von Trace-Kontext vom vorgelagerten (oder selbst gestarteten) zum nachgelagerten Dienst unterstützen.

So aktivieren Sie Tracing:

Fügen Sie das Objekt cloud_trace zur Konfiguration hinzu.
Setzen Sie cloud_trace.sampling_rate auf eine Wahrscheinlichkeit, die Ihre Anwendung beobachten soll, um neue Traces zu starten.
- Beispiel: 1.0 bedeutet, dass jeder RPC verfolgt wird.
- 0.0 bedeutet, dass keine neuen Traces gestartet werden.
- 0.5 bedeutet, dass 50% der RPCs nach dem Zufallsprinzip verfolgt werden.

Bei einer positiven Stichprobeentscheidung werden Ihre Dienstuploads unabhängig von der Einstellung der Abtastrate hochgeladen.

Weitere Informationen zum Tracing finden Sie unter Trace-Definitionen.

Logging aktivieren

So aktivieren Sie das Logging:

Fügen Sie das Objekt cloud_logging zur Konfiguration hinzu.
Fügen Sie ein Muster entweder zu client_rpc_events, zu server_rpc_events oder zu beiden hinzu, um die Dienste oder Methoden anzugeben, für die Sie ein Ereignis-Logging auf Transportebene generieren möchten und die Anzahl der zu protokollierenden Byte für Header und Nachrichten.

Weitere Informationen zum Logging finden Sie unter Definitionen von Logeinträgen.

Beispiel für eine Umgebungsvariable

Im folgenden Beispiel werden die Beobachtbarkeitsvariablen in der Umgebungsvariable GRPC_GCP_OBSERVABILITY_CONFIG festgelegt:

export GRPC_GCP_OBSERVABILITY_CONFIG='{
     "project_id": "your-project-here",
     "cloud_logging": {
         "client_rpc_events": [
         {
             "methods": ["google.pubsub.v1.Subscriber/Acknowledge", "google.pubsub.v1.Publisher/CreateTopic"],
             "exclude": true
         },
         {
             "methods": ["google.pubsub.v1.Subscriber/*", "google.pubsub.v1.Publisher/*"],
             "max_metadata_bytes": 4096,
             "max_message_bytes": 4096
         }],
         "server_rpc_events": [{
             "methods": ["*"],
             "max_metadata_bytes": 4096,
             "max_message_bytes": 4096
         }],
     },
     "cloud_monitoring": {},
     "cloud_trace": {
         "sampling_rate": 1.00
     },
     "labels": {
         "SOURCE_VERSION": "J2e1Cf",
         "SERVICE_NAME": "payment-service-1Cf",
         "DATA_CENTER": "us-west1-a"
     }
}'

Beispiel für die Beobachtbarkeit erstellen

Folgen Sie dieser Anleitung, um eine Compute Engine-VM-Instanz zu erstellen und eine Verbindung zu ihr herzustellen, und richten Sie dann das Beispiel für die Beobachtbarkeit ein.

Erstellen Sie eine VM-Instanz:

gcloud compute instances create grpc-observability-vm \
  --image-family=debian-11 \
  --image-project=debian-cloud \
  --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

Verbindung zur VM-Instanz herstellen

gcloud compute ssh --project=PROJECT_ID grpc-observability-vm

Fahren Sie mit der Anleitung für Java, C++ oder Go fort, je nachdem, in welcher Sprache Ihre gRPC-Anwendungen geschrieben sind.

Java

Nachdem Sie eine Verbindung zur VM-Instanz hergestellt haben, prüfen Sie, ob Java 8 oder höher installiert ist.
```
sudo apt update
sudo apt upgrade
sudo apt install git
sudo apt-get install -y openjdk-11-jdk-headless
```

Klonen Sie das grpc-java-Repository.

export EXAMPLES_VERSION=v1.54.1
git clone -b $EXAMPLES_VERSION --single-branch --depth=1 \
https://github.com/grpc/grpc-java.git

Gehen Sie zum Beispielverzeichnis.

cd grpc-java/examples/example-gcp-observability

Öffnen Sie im Verzeichnis „examples“ die README-Datei und folgen Sie der Anleitung darin.
Wenn Sie in der Anleitung aufgefordert werden, ein weiteres Terminalfenster zu öffnen, geben Sie diesen Befehl ein:
```
gcloud compute ssh --project=PROJECT_ID grpc-observability-vm
```

C++

Nachdem Sie eine Verbindung zur VM-Instanz hergestellt haben, führen Sie eine hello-world-Server-Binärdatei in einem Terminalfenster aus.

sudo apt-get update -y
sudo apt-get install -y git build-essential clang
git clone -b v1.54.0 https://github.com/grpc/grpc.git --depth=1
cd grpc
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
export GRPC_GCP_OBSERVABILITY_CONFIG_FILE="$(pwd)/examples/cpp/gcp_observability/helloworld/server_config.json"
tools/bazel run examples/cpp/gcp_observability/helloworld:greeter_server

Stellen Sie über ein anderes Terminalfenster mit SSH wieder eine Verbindung zur VM her und führen Sie dann die folgenden Befehle aus, um die hello-world-Client-Binärdatei auszuführen.

cd grpc
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
export GRPC_GCP_OBSERVABILITY_CONFIG_FILE="$(pwd)/examples/cpp/gcp_observability/helloworld/client_config.json"
tools/bazel run examples/cpp/gcp_observability/helloworld:greeter_client

Go

Go muss installiert sein.

sudo apt-get install -y git
sudo apt install wget
wget https://go.dev/dl/go1.20.2.linux-amd64.tar.gz
sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf \
go1.20.2.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin

Klonen Sie die gRPC-Go-Beispiele.

git clone https://github.com/grpc/grpc-go.git
cd grpc-go/
git checkout -b run-observability-example
875c97a94dca8093bf01ff2fef490fbdd576373d

Rufen Sie den Klon des Verzeichnisses gRPC-Go auf:
```
cd examples/features/observability
```

Server ausführen

export GRPC_GCP_OBSERVABILITY_CONFIG_FILE=./server/serverConfig.json
go run ./server/main.go

Führen Sie in einem separaten Terminalfenster die folgenden Befehle aus.

export PATH=$PATH:/usr/local/go/bin
cd grpc-go/examples/features/observability
export GRPC_GCP_OBSERVABILITY_CONFIG_FILE=./client/clientConfig.json
go run ./client/main.go

Traces, Messwerte und Logeinträge ansehen

Folgen Sie der Anleitung in diesem Abschnitt, um Traces, Messwerte und Logeinträge aufzurufen.

Traces in Cloud Trace ansehen

Nachdem Sie die Beispiele eingerichtet oder Ihre Arbeitslasten instrumentiert haben, sollten die von Ihren gRPC-Clients und gRPC-Servern generierten Traces in der Google Cloud Console als aktuelle Traces aufgeführt werden.

Trace-Liste für Beobachtbarkeit von Mikrodiensten. — Trace-Liste für Beobachtbarkeit von Mikrodiensten (zum Vergrößern klicken)

Logs für Traces ansehen

Wenn Sie sowohl das Logging als auch das Tracing aktivieren, können Sie Logeinträge für Traces zusammen mit dem Cloud Trace-Wasserfalldiagramm oder in Log-Explorer ansehen.

Messwerte im Dashboard aufrufen

Die Beobachtbarkeit von Mikrodiensten bietet ein Monitoring-Dashboard namens Microservices (gRPC) Monitoring für die in den Messwertdefinitionen definierten Messwerte. Das Dashboard wird nur angezeigt, wenn die Microservices API aktiviert ist. Die Google Cloud Console ruft die Service Usage API auf, um zu prüfen, ob die Microservices API in einem Projekt aktiviert ist. Der Nutzer muss die Berechtigung serviceusage.services.list haben, um das Dashboard aufzurufen.

Das Dashboard Microservices (gRPC) Monitoring ist ein Google Cloud-Dashboard, das Sie nicht direkt ändern können. Wenn Sie das Dashboard anpassen möchten, müssen Sie es in ein benutzerdefiniertes Dashboard kopieren. Sie können das benutzerdefinierte Dashboard dann aktualisieren, z. B. in dem Sie die Diagramme hinzufügen, löschen oder neu anordnen.

Messwerte in Metrics Explorer aufrufen

Nachdem Sie die gRPC-Beispiel eingerichtet oder Ihre Arbeitslast instrumentiert haben, sollten Messwerte angezeigt werden, die von Ihren gRPC-Clients und gRPC-Servern in der Google Cloud Console generiert wurden.

Verwenden Sie die Anleitung unter Messwerte bei Verwendung von Metrics Explorer auswählen, um Messwerte anzuzeigen und grafisch darzustellen.

Logeinträge im Log-Explorer prüfen

Vorgeschlagene Abfragen sind ein Cloud Logging-Feature, bei dem Google Cloud eine Reihe von Abfragen basierend auf den aufgenommenen Logs vorschlägt. Sie können die vorbereiteten Filter anklicken und verwenden:

Vorgeschlagene Abfragen im Log-Explorer. (Zum Vergrößern klicken)

Sobald die Logeinträge, die mit den vorgeschlagenen Abfragen übereinstimmen, in Cloud Logging angezeigt werden, können Sie innerhalb von etwa sechs Minuten neue Abfragen sehen. In den meisten Fällen werden neue vorgeschlagene Abfragen früher angezeigt. Wenn Logeinträge vorhanden sind, die mit einem Vorschlag der letzten 15 Minuten übereinstimmen, werden alle vorgeschlagenen Abfragen weiterhin angezeigt. Sie werden weiterhin als Vorschlag angezeigt, bis in den letzten 15 Minuten keine übereinstimmenden Logeinträge gefunden wurden.

Sie können benutzerdefinierte Abfragen erstellen. Eine Anleitung finden Sie unter Anleitung zur Logging-Abfragesprache. Im Abfragebereich des Log-Explorers können Sie beispielsweise versuchen, alle gRPC-Debugging-Logs mit dem folgenden Code anzuzeigen:

log_id("microservices.googleapis.com/observability/grpc")

Sie können alle Felder im gRPC-Logeintrag zum Filtern verwenden. Hier ein Beispiel für einen Logeintrag:

{
  "insertId": "17kh8vafzuruci",
  "jsonPayload": {
    "authority": "10.84.1.15:50051",
    "sequenceId": "6",
    "serviceName": "helloworld.Greeter",
    "peer": {
      "ipPort": 50051,
      "address": "10.84.1.10",
      "type": "IPV4"
    },
    "callId": "d9577780-c608-4bff-9e12-4d9cdea6b298",
    "type": "SERVER_TRAILER",
    "methodName": "SayHello",
    "payload": {},
    "logger": "CLIENT"
  },
  "resource": {
    "type": "k8s_container",
    "labels": {
      "pod_name": "grpc-client-deployment-155-6967959544-x8ndr",
      "container_name": "grpc-client-container-155",
      "cluster_name": "o11y-cluster",
      "namespace_name": "grpc-client-namespace-155",
      "location": "us-west1-b",
      "project_id": "grpc-greeter"
    }
  },
  "timestamp": "2023-04-05T23:33:41.718523Z",
  "severity": "DEBUG",
  "labels": {
    "environment": "example-client"
  },
  "logName": "projects/grpc-greeter/logs/microservices.googleapis.com%2Fobservability%2Fgrpc",
  "receiveTimestamp": "2023-04-05T23:33:42.712682457Z"
}

Vorgeschlagene Abfragen

Beobachtbarkeit von Mikrodiensten bietet die folgenden empfohlenen Abfragen für Cloud Logging:

Header- oder Trailer-Logeinträge für gRPCs

Diese Abfrage bietet eine grundlegende Ansicht der RPCs und liefert Peer-Informationen und RPC-Ergebnisse.

log_id("microservices.googleapis.com/observability/grpc") AND
jsonPayload.type=("CLIENT_HEADER" OR "SERVER_TRAILER")

Fehlgeschlagene gRPC-Aufrufe

Diese Abfrage findet die RPCs, die mit einem anderen Status als "OK" enden.

log_id("microservices.googleapis.com/observability/grpc") AND
jsonPayload.type="SERVER_TRAILER" AND
jsonPayload.payload.statusCode!="OK"

Logeinträge für abgebrochene gRPC-Aufrufe oder solche mit Zeitüberschreitung

Ein übermäßiger gRPC-Abbruch oder Fristüberschreitungen können nützliche Informationen über Leistungsverluste oder ein unerwartetes Anwendungsverhalten liefern.

log_id("microservices.googleapis.com/observability/grpc") AND
((jsonPayload.type="SERVER_TRAILER" AND jsonPayload.payload.statusCode=("CANCELLED" OR "DEADLINE_EXCEEDED")) OR (jsonPayload.type="CANCEL"))

Logs und Tracing für die Fehlerbehebung verwenden

Wenn Sie ein RPC-Ereignis sehen, das auf ein schlechtes Verhalten hinweist, können Sie die callid im Ereignis finden. Verwenden Sie die folgende Abfrage, um alle Ereignisse in einem einzelnen RPC aufzurufen, unabhängig davon, ob es sich um einen unären oder Streaming-RPC handelt. Der vorherige Logeintrag wird als Beispiel verwendet:

log_id("microservices.googleapis.com/observability/grpc")
jsonPayload.callid="a358c7b80-3548-4bc8-a33f-b93ba1514904"

Um den Umfang des Problems zu ermitteln, können Sie alle RPC-Ereignisse für dieselbe Methode oder denselben Standort suchen. In der folgenden Abfrage werden alle Debugging-Logs angezeigt, die sich auf eine bestimmte RPC-Methode beziehen, wobei der Greeter-Dienst als Beispiel verwendet wird:

log_id("microservices.googleapis.com/observability/grpc")
jsonPayload.serviceName="helloworld.Greeter"
jsonPayload.methodName="SayHello"

Um die fehlgeschlagenen RPCs eines bestimmten Statuscodes zu prüfen, können Sie den Statuscode als eine der Filterbedingungen hinzufügen. Die folgende Abfrage zeigt die Trailer-Ereignisse, die mit dem Status "Nicht OK" enden:

log_id("microservices.googleapis.com/observability/grpc")
jsonPayload.payload.statusCode!="OK"

Abfrageergebnisse: Statuscode „Frist überschritten“ (zum Vergrößern anklicken)

Optionen für die Beobachtbarkeit

Die Beobachtbarkeit von Mikrodiensten umfasst die folgenden optionalen Funktionen.

Benutzerdefinierte Labels definieren

Sie können benutzerdefinierte Labels definieren, die den Beobachtbarkeitsdaten vom Nutzer bereitgestellte Informationen hinzufügen. Benutzerdefinierte Labels bestehen aus Schlüssel/Wert-Paaren. Jedes Schlüssel/Wert-Paar wird an Tracing-Daten als Span-Labels, an Messwertdaten als Messwert-Tags und an Logging-Daten als Logeintrag-Labels angehängt.

Benutzerdefinierte Labels werden in der Konfiguration mit einer Liste von Schlüssel/Wert-Paaren im Feld labels definiert. Alle Schlüssel und Werte für benutzerdefinierte Labels sind vom Typ STRING. Die Implementierung liest die Konfiguration und erstellt ein separates Label für jedes Schlüssel/Wert-Paar. Anschließend wird das Labels an die Beobachtbarkeitsdaten angehängt:

Hier ist beispielsweise eine Labeldefinition:

"labels": {
    "DATACENTER": "SAN_JOSE_DC",
    "APP_ID": "24512"
  }

Jeder Logeintrag enthält folgende zusätzliche Labels:

{
   "DATACENTER" : "SAN_JOSE_DC"
   "APP_ID" : "24512"
}

Labels in einem Logeintrag abfragen. — Labels in einem Logeintrag abfragen (zum Vergrößern klicken)

Liniendiagramm mit benutzerdefinierten und Ressourcenlabels (zum Vergrößern klicken)

Nutzlast-Logging aktivieren

Sie aktivieren das Nutzlast-Logging mit den Umgebungsvariablen, die Sie für die Arbeitslast angeben. Zum Aktivieren des Nutzlast-Loggings für HelloWorld-Nachrichten und -Header aktualisieren Sie den Wert der Konfigurationsdateien gcp_observability_server_config.json, gcp_observability_client_config.json oder von beiden in den gRPC-Beispielen und zwar so:

{
   "cloud_monitoring":{
   },
   "cloud_trace":{
      "sampling_rate":1.0
   },
   "cloud_logging":{
      "client_rpc_events":[
         {
            "methods":[
               "helloworld.Greeter/*"
            ],
            "max_metadata_bytes":4096,
            "max_message_bytes":4096
         }
      ],
      "server_rpc_events":[
         {
            "methods":[
               "helloworld.Greeter/*"
            ],
            "max_metadata_bytes":4096,
            "max_message_bytes":4096
         }
      ]
   }
}

Projektübergreifende Beobachtbarkeit einrichten

Sie können das Zielprojekt explizit mit der in der Umgebungsvariablen GRPC_GCP_OBSERVABILITY_CONFIG festgelegten Konfiguration festlegen. Für eine projektübergreifende Beobachtbarkeit müssen Sie auch die entsprechenden Berechtigungen für das Dienstkonto festlegen. Angenommen, die Zielprojekt-ID lautet core-platform-stats, können Sie die projektübergreifende Beobachtbarkeit mit der folgenden Beispielkonfiguration einrichten:

{
   "project_id":"core-platform-stats",
   "cloud_monitoring":{
   },
   "cloud_trace":{
      "sampling_rate":1.0
   },
   "cloud_logging":{
      "client_rpc_events":[
         {
            "methods":[
               "helloworld.Greeter/*"
            ]
         }
      ],
      "server_rpc_events":[
         {
            "methods":[
               "helloworld.Greeter/*"
            ]
         }
      ]
   }
}

Logvolumen schätzen

Dieser Abschnitt enthält Informationen, mit denen Sie das Volumen der Logaufnahme schätzen können. Wir empfehlen, eine Schätzung durchzuführen, bevor Sie die RPC-Ereignisse Ihrer Dienste abonnieren.

Posten	Details
Für einen unären OK-Aufruf generierte Ereignisse	6 Ereignisse Ein unärer OK-RPC generiert die folgenden sechs Ereignisse für Client oder Server: CLIENT_HEADER SERVER_HEADER CLIENT_MESSAGE SERVER_MESSAGE CLIENT_HALF_CLOSE SERVER_TRAILER
Durchschnittliche Größe des Logeintrags	Standardmäßig 500 Byte Ein Logeintrag wird genau einem RPC-Ereignis zugeordnet. Das RPC-Ereignis enthält detaillierte Debugging-Informationen für dieses Ereignis, Ressourcen-Labels und benutzerdefinierte Labels
Nutzlast-Logging-Größe	Standardmäßig 0; kann konfiguriert werden Die maximale Nutzlastgröße kann in der Beobachtbarkeitskonfiguration festgelegt werden. Standardmäßig wird keine Nutzlast protokolliert.
Größe benutzerdefinierter Labels	Standardmäßig 0; kann konfiguriert werden benutzerdefinierte Labels werden der Anwendung mithilfe von Umgebungsvariablen bereitgestellt. Wenn keines angegeben ist, gibt es keine benutzerdefinierten Tags.

Formel zur Schätzung der Gesamtgröße der Logaufnahme pro Monat:

Monthly Log Ingestion = QPS * 6 * (500B + Payload Logging Size + Custom Labels Size) * 2592000

Wenn die Abfragen pro Sekunde bei einer unären Aufrufmethode 1 sind und keine zusätzlichen Features aktiviert sind, beträgt die geschätzte Logaufnahmegröße ungefähr 7,24 GiB.

Nächste Schritte

Ausführliche Informationen zu Konfigurationsdaten, Trace-Definitionen, Messwertdefinitionen und Logdefinitionen finden Sie in der Referenz zur Mikrodienste-Beobachtbarkeit.