Anthos Service Mesh und Traffic Director heißen jetzt Cloud Service Mesh. Weitere Informationen finden Sie in der Übersicht zu Cloud Service Mesh.

Diese Seite wurde von der Cloud Translation API übersetzt.

Beobachtbarkeit für proxylose gRPC-Dienste

Die Beobachtbarkeit von Cloud Service Mesh für proxylose gRPC-Dienste basiert auf dem vorhandenen gRPC OpenTelemetry-Plug-in. Es werden Messwerte (z. B. Latenz und Nachrichtengröße) für alle gRPC-Kanäle und ‑Server erfasst, die für Cloud Service Mesh aktiviert sind. Außerdem werden zusätzliche Attribute bereitgestellt, die topologische Mesh-Informationen für Cloud Service Mesh-Traffic enthalten. Ein gRPC wird als Cloud Service Mesh-aktiviert betrachtet, wenn Konfiguration über die Cloud Service Mesh-Steuerungsebene, während alle gRPC-Dienste werden Server als für Cloud Service Mesh aktiviert betrachtet.

Mesh-Attribute

Die folgenden Mesh-Attribute sind für Messwerte verfügbar.

Labels für lokale Umgebungen:

csm.mesh_id
- Die Mesh-ID.
Andere Attribute der lokalen Umgebung werden aus der OpenTelemetry-Ressource abgerufen.
- Managed Service for Prometheus (GMP) können so eingerichtet werden, dass Messwerte in der Google-Infrastruktur gespeichert werden. Wenn Sie diese Funktion verwenden, Ressourcenattribute, die die lokale Umgebung der Anwendung beschreiben, sind automatisch hinzugefügt als MonitoredResource angeben.
- Wenn Sie zum Exportieren und Speichern von Messwerten keine Google-Infrastruktur verwenden, sollten Sie in der Erfassungspipeline Attribute zu den Messwerten hinzufügen, die die Umgebung beschreiben, in der die Anwendung ausgeführt wird.

Remote-Umgebungslabels:

csm.remote_workload_type
- Der Typ des Remote-Peers. („gcp_kubernetes_engine“ für GKE).
Je nach Peertyp sind zusätzliche Attribute vorhanden.
- Für einen Peer, der in GKE ausgeführt wird:
- csm.remote_workload_project_id
  - Die Kennung des mit dieser Ressource verknüpften Projekts, z. B. „my-project“.
- csm.remote_workload_location *Der physische Standort des Clusters, der den Container enthält.
- csm.remote_workload_cluster_name
  - Der Cluster, in dem der Container ausgeführt wird.
- csm.remote_workload_namespace_name
  - The namespace where the container is running.
- csm.remote_workload_name
  - Der Name der Remotearbeitslast. Dies sollte der Name des Objekts sein, das die Pod-Definition enthält (z. B. ein Deployment, ein ReplicaSet oder nur der Pod-Name für einen Bare Pod).

Dienstlabels: Informationen zum Back-End-Dienst (xDS-Cluster), an den die RPC weitergeleitet wird. Dies ist nur verfügbar, wenn der Back-End-Dienst Gateway API konfiguriert.

csm.service_name
- Der Dienstname.
csm.service_namespace_name
- Der Name des Dienst-Namespace.

Der Begriff „remote_workload“ bezieht sich auf den Peer. Bei Clients ist der Server-Pod, der das Ziel eines RPC ist, die Remote-Arbeitslast. Bei Servern ist der Client-Pod, der den RPC initiiert hat, die Remote-Arbeitslast.

Diese Attribute sind für grpc.client.attempt.started und grpc.server.call.started nicht verfügbar, da nicht alle topologischen Mesh-Informationen am Erfassungspunkt dieser Messwerte verfügbar sind.

Anleitung zur Einrichtung der Beobachtbarkeit

In diesem Abschnitt wird erläutert, wie Sie die Cloud Service Mesh-Beobachtbarkeit für proxylose gRPC-Dienste in einer Service Mesh-Einrichtung.

C++

Der Support für die Beobachtbarkeit ist nur über das Bazel-Buildsystem verfügbar. Die Ziel-grpcpp_csm_observability muss als Abhängigkeit hinzugefügt.

Erforderliche Codeänderungen

Der folgende Code muss Ihren gRPC-Clients und -Servern in um die Cloud Service Mesh-Beobachtbarkeit zu nutzen.

#include <grpcpp/ext/csm_observability.h>

int main() {
  // …
  auto observability = grpc::CsmObservabilityBuilder()
                          .SetMeterProvider(std::move(meter_provider))
                          .BuildAndRegister();
  assert(observability.ok());
  // …
}

Bevor Sie gRPC-Vorgänge ausführen, z. B. einen Channel, Server oder Anmeldedaten erstellen, müssen Sie mit der CsmObservabilityBuilder API ein Plug-in registrieren. Im folgenden Beispiel wird gezeigt, wie Sie die Cloud Service Mesh-Observability mit einem Prometheus-Exporteur einrichten.

  opentelemetry::exporter::metrics::PrometheusExporterOptions opts;
  opts.url = "0.0.0.0:9464";
  auto prometheus_exporter =
      opentelemetry::exporter::metrics::PrometheusExporterFactory::Create(opts);
  auto meter_provider =
      std::make_shared<opentelemetry::sdk::metrics::MeterProvider>();
  meter_provider->AddMetricReader(std::move(prometheus_exporter));
  auto observability = grpc:::CsmObservabilityBuilder()
                          .SetMeterProvider(std::move(meter_provider))
                          .BuildAndRegister();

Mit der SetMeterProvider() API auf CsmObservabilityBuilder() können Nutzer MeterProvider festlegen Objekt, das mit Exportern konfiguriert werden kann.

Java

So aktivieren Sie die Cloud Service Mesh-Beobachtbarkeit für Java gRPC-Anwendungen: führen Sie die folgenden Schritte aus:

Das Projekt muss das grpc-gcp-csm-observability-Artefakt enthalten. Verwenden Sie gRPC-Version 1.65.0 oder höher.
Initialisieren Sie in der Methode main() die Cloud Service Mesh-Beobachtbarkeit durch Angabe eines OpenTelemetry SDK-Instanz mit einer MeterProvider zum Erfassen und Messwerte exportieren.

Bevor Sie gRPC-Vorgänge wie das Einrichten eines Kanals oder verwenden Sie die CsmObservability.Builder() API, um Registrieren Sie das OpenTelemetry SDK.

Nachdem die CsmObservability-Instanz erstellt wurde, führt der Aufruf registerGlobal() für die Instanz aktiviert die Cloud Service Mesh-Beobachtbarkeit für alle Kanäle und Server von Cloud Service Mesh.

Im folgenden Beispiel wird gezeigt, wie Sie die Cloud Service Mesh-Observability mit einem Prometheus-Exporter einrichten.

import io.grpc.gcp.csm.observability.CsmObservability;
...

public static void main(String[] args) {
    ...

    int prometheusPort = 9464;

    SdkMeterProvider sdkMeterProvider = SdkMeterProvider.builder()
        .registerMetricReader(
            PrometheusHttpServer.builder().setPort(prometheusPort).build())
        .build();

    OpenTelemetrySdk openTelemetrySdk = OpenTelemetrySdk.builder()
        .setMeterProvider(sdkMeterProvider)
        .build();

    CsmObservability observability = new CsmObservability.Builder()
        .sdk(openTelemetrySdk)
        .build();
    observability.registerGlobal();

    // ... (continue with channel and server configuration)
}

Go

Konfigurieren Sie die Cloud Service Mesh-Beobachtbarkeit vor allen gRPC-Vorgängen, einschließlich dem Erstellen einer ClientConn oder eines Servers oder von Anmeldedaten, global mit einer MeterProvider. Im folgenden Beispiel wird gezeigt, wie Sie die Cloud Service Mesh-Observability einrichten. Nachdem Sie Cloud Service MeshObservability eingerichtet haben, werden alle Cloud Service Mesh-Kanäle und alle Server erkennen eine OpenTelemetry Statistik-Plug-in mit verfügbaren Optionen und zusätzlichen Cloud Service Mesh-Labels. Nicht-Cloud-Service-Mesh-Kanäle erhalten eine OpenTelemetry-Plug-in für Statistiken ohne Cloud Service Mesh-Labels.

  import (
  "context"

  "google.golang.org/grpc/stats/opentelemetry"
  "google.golang.org/grpc/stats/opentelemetry/csm"

  "go.opentelemetry.io/otel/sdk/metric"
)

func main() {
  reader := metric.NewManualReader()
  provider := metric.NewMeterProvider(metric.WithReader(reader))
  opts := opentelemetry.Options{
    MetricsOptions: opentelemetry.MetricsOptions{
        MeterProvider: provider,
    },
  }
  cleanup := csm.EnableObservability(context.Background(), opts)
  defer cleanup()
  // Any created ClientConns and servers will be configured with an
  // OpenTelemetry stats plugin configured with provided options.

}

Python

Die folgenden gRPC-Abhängigkeiten sind für Cloud Service Mesh erforderlich Beobachtbarkeit:

grpcio>=1.65.0
grpcio-observability>=1.65.0
grpcio-csm-observability>=1.65.0

Bevor Sie gRPC-Vorgänge ausführen, z. B. einen Kanal, Server oder Anmeldedaten erstellen, verwenden Sie die CsmOpenTelemetryPlugin API, um ein Plug-in zu erstellen und zu registrieren:

import grpc_csm_observability

# ...
csm_plugin = grpc_csm_observability.CsmOpenTelemetryPlugin(
    meter_provider=[your_meter_provider],
)
csm_plugin.register_global()

# Create server or client

Verwenden Sie nach allen gRPC-Vorgängen den folgenden Code, um Ressourcen abzumelden und zu bereinigen:

csm_plugin.deregister_global()

Im folgenden Beispiel wird gezeigt, wie Sie die Cloud Service Mesh-Observability mit einem Prometheus-Exporter einrichten:

import grpc_csm_observability
from opentelemetry.exporter.prometheus import PrometheusMetricReader
from prometheus_client import start_http_server

start_http_server(port=9464, addr="0.0.0.0")
reader = PrometheusMetricReader()
meter_provider = MeterProvider(metric_readers=[reader])
csm_plugin = CsmOpenTelemetryPlugin(
    meter_provider=meter_provider,
)
csm_plugin.register_global()

# Clean up after use

csm_plugin.deregister_global()

Im vorherigen Beispiel können Sie localhost:9464/metrics abrufen, um die Messwerte zu erhalten, die von Cloud Service Mesh Observability erfasst werden.

Damit die den gRPC-Messwerten hinzugefügten Mesh-Attribute funktionieren, müssen sowohl die Client- als auch die Server-Binärdateien mit CsmObservability eingerichtet werden.

Wenn Sie zum Exportieren und Speichern von Messwerten eine Drittanbieter-Infrastruktur verwenden, Sammlungspipeline Attribute zu den Metriken hinzufügen, die die in der die Anwendung ausgeführt wird. Dies zusammen mit dem Mesh-Netzwerk anhand der oben beschriebenen Attribute einen Überblick im Mesh-Netzwerk ausgeführt wird.

Änderungen der Spezifikationen

Bei der Cloud Service Mesh-Observability werden die topologischen Informationen des Mesh über Umgebungsvariablen ermittelt, die sowohl für Clients als auch für Server zur Umgebung des Containers hinzugefügt werden müssen. Diese Informationen werden Peers für Metriken zur Verfügung gestellt Cloud Service Mesh-Beobachtbarkeit.

spec:
  containers:
  - image: IMAGE_NAME
    name: CONTAINER_NAME
    env:
    - name: GRPC_XDS_BOOTSTRAP
      value: "/tmp/grpc-xds/td-grpc-bootstrap.json" #created by td-grpc-bootstrap
    - name: POD_NAME
      valueFrom:
        fieldRef:
          fieldPath: metadata.name
    - name: NAMESPACE_NAME
      valueFrom:
        fieldRef:
          fieldPath: metadata.namespace
     - name: CSM_WORKLOAD_NAME
       value: CSM_WORKLOAD_NAME
     - name: CONTAINER_NAME
       value: CONTAINER_NAME
     - name: OTEL_RESOURCE_ATTRIBUTES
       value: k8s.pod.name=$(POD_NAME),k8s.namespace.name=$(NAMESPACE_NAME),k8s.container.name=CONTAINER_NAME

Ersetzen Sie Folgendes:

IMAGE_NAME durch den Namen des Bilds.
CONTAINER_NAME durch den Namen des Containers.
CSM_WORKLOAD_NAME durch den Namen der Arbeitslast, z. B. die Bereitstellung Namen.