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

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-Channel gilt als Cloud Service Mesh-kompatibel, wenn er seine Konfiguration von der Cloud Service Mesh-Steuerungsebene erhält. Alle gRPC-Server gelten als Cloud Service Mesh-kompatibel.

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) kann so eingerichtet werden, dass Messwerte in der Google-Infrastruktur gespeichert werden. In diesem Fall werden Ressourcenattribute, die die lokale Umgebung der Anwendung beschreiben, automatisch als MonitoredResource hinzugefügt.
- 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.

Labels für Remote-Umgebungen:

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 auf GKE ausgeführt wird:
- csm.remote_workload_project_id
  - Die Kennung des Projekts, das dieser Ressource zugeordnet ist, 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 Remote-Arbeitslast. 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. Diese Funktion ist nur verfügbar, wenn der Backend-Dienst über die Gateway API konfiguriert wurde.

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

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 beschrieben, wie Sie die Cloud Service Mesh-Observability für proxylose gRPC-Dienste in einer Service Mesh-Umgebung aktivieren.

C++

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

Erforderliche Codeänderungen

Der folgende Code muss Ihren gRPC-Clients und ‑Servern hinzugefügt werden, damit Sie die Beobachtbarkeit von Cloud Service Mesh nutzen können.

#include <grpcpp/ext/csm_observability.h>

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

Bevor du gRPC-Vorgänge ausführst, z. B. einen Channel, Server oder Anmeldedaten erstellst, musst du 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 ein MeterProvider-Objekt festlegen, das mit Exporteuren konfiguriert werden kann.

Java

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

Das Projekt muss das grpc-gcp-csm-observability-Artefakt enthalten. Verwenden Sie gRPC Version 1.65.0 oder höher.
Initialisieren Sie die Cloud Service Mesh-Observability innerhalb der main()-Methode, indem Sie einer konfigurierten OpenTelemetry SDK-Instanz einen MeterProvider zum Erfassen und Exportieren von Messwerten zur Verfügung stellen.

Bevor Sie gRPC-Vorgänge wie das Einrichten eines Kanals oder Servers ausführen, müssen Sie das OpenTelemetry SDK mit der CsmObservability.Builder() API registrieren.

Sobald die CsmObservability-Instanz erstellt wurde, wird durch Aufrufen von registerGlobal() auf der Instanz die Cloud Service Mesh-Observability für alle Cloud Service Mesh-Kanäle und ‑Server aktiviert.

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 Mesh Observability eingerichtet haben, wird auf allen Cloud Service Mesh-Kanälen und -Servern ein OpenTelemetry-Statistik-Plug-in verwendet, das mit den bereitgestellten Optionen und zusätzlichen Cloud Service Mesh-Labels konfiguriert ist. Nicht von Cloud Service Mesh unterstützte Channels erhalten ein OpenTelemetry-Statistik-Plug-in 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

Für die Cloud Service Mesh-Observability sind die folgenden gRPC-Abhängigkeiten erforderlich:

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 nicht von Google stammende Infrastruktur verwenden, sollten in der Erfassungspipeline Attribute zu den Messwerten hinzugefügt werden, die die Umgebung beschreiben, in der die Anwendung ausgeführt wird. Zusammen mit den zuvor beschriebenen Mesh-Attributen können Sie sich einen Überblick über den Traffic im Mesh verschaffen.

Änderungen an den technischen Daten

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 über Cloud Service Mesh Observability für Kollegen zur Verfügung gestellt, damit sie Messwerte erfassen können.

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. den Namen der Bereitstellung.