Beobachtbarkeit für proxyloses gRPC

Die Cloud Service Mesh-Beobachtbarkeit für proxylose gRPC-Dienste basiert auf dem vorhandenen gRPC OpenTelemetry-Plug-in. Sie erfasst Messwerte (Latenz, Nachrichtengrößen usw.) für alle gRPC-Channels und ‑Server, die für Cloud Service Mesh aktiviert sind, und bietet zusätzliche Attribute, die topologische Mesh-Informationen für Cloud Service Mesh-Traffic enthalten. Ein gRPC-Channel gilt als Cloud Service Mesh-fähig, wenn er Konfigurationen von der Cloud Service Mesh-Steuerungsebene erhält. Alle gRPC-Server gelten als Cloud Service Mesh-fähig.

Mesh-Attribute

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

Umgebungslabels für lokale Produkte:

  • 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. Wenn Sie diese Methode verwenden, werden Ressourcenattribute, die die lokale Umgebung der Anwendung beschreiben, automatisch als MonitoredResource hinzugefügt.
    • Wenn Sie keine Google-Infrastruktur zum Exportieren und Speichern von Messwerten verwenden, sollten der Erfassungspipeline Attribute für die Messwerte hinzugefügt werden, die die Umgebung beschreiben, in der die Anwendung ausgeführt wird.

Umgebungslabels für Remote-Umgebungen:

  • csm.remote_workload_type
    • Der Typ des Remote-Peers. („gcp_kubernetes_engine“ für GKE).
  • Je nach Art des Peers sind zusätzliche Attribute vorhanden.
    • Für einen Peer, der in 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 einfach der Pod-Name für einen Bare-Pod).

Dienstlabels: Informationen zum Backend-Dienst (xDS-Cluster), an den der RPC weitergeleitet wird. Diese Option 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-Namespace.

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

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

Anleitung zur Einrichtung der Beobachtbarkeit

In diesem Abschnitt wird beschrieben, wie Sie Cloud Service Mesh Observability für proxyloses gRPC in einer Service Mesh-Einrichtung aktivieren.

C++

Die Unterstützung für die Beobachtbarkeit ist nur über das Bazel-Build-System 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 Cloud Service Mesh-Beobachtbarkeit 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 Sie gRPC-Vorgänge ausführen, einschließlich des Erstellens eines Channels, Servers oder von Anmeldedaten, verwenden Sie die CsmObservabilityBuilder API, um ein Plug-in zu registrieren. Im folgenden Beispiel wird gezeigt, wie Sie Cloud Service Mesh Observability mit einem Prometheus-Exporter 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 Exportern konfiguriert werden kann.

Java

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

  1. Achten Sie darauf, dass das Projekt das grpc-gcp-csm-observability-Artefakt enthält. Verwenden Sie gRPC Version 1.65.0 oder höher.

  2. Initialisieren Sie in der Methode main() Cloud Service Mesh Observability, indem Sie eine konfigurierte OpenTelemetry SDK-Instanz mit einem MeterProvider bereitstellen, um Messwerte zu erfassen und zu exportieren.

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

    Nachdem die CsmObservability-Instanz erstellt wurde, wird durch Aufrufen von registerGlobal() für die Instanz Cloud Service Mesh Observability für alle Cloud Service Mesh-Channels und -Server aktiviert.

    Im folgenden Beispiel wird gezeigt, wie Sie 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 Cloud Service Mesh Observability global mit einem MeterProvider, bevor Sie gRPC-Vorgänge ausführen, einschließlich des Erstellens einer ClientConn oder eines Servers oder von Anmeldedaten. Im folgenden Beispiel wird gezeigt, wie Sie Cloud Service Mesh Observability einrichten. Nachdem Sie Cloud Service Mesh Observability eingerichtet haben, wird für alle Cloud Service Mesh-Channels und alle Server ein OpenTelemetry-Statistik-Plug-in mit den angegebenen Optionen und zusätzlichen Cloud Service Mesh-Labels konfiguriert. Nicht-Cloud Service Mesh-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

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

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

Bevor Sie gRPC-Vorgänge ausführen, einschließlich des Erstellens eines Kanals, Servers oder Anmeldedaten, 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 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 von Cloud Service Mesh Observability gemeldeten Messwerte zu erhalten.

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

Wenn Sie keine Google-Infrastruktur zum Exportieren und Speichern von Messwerten verwenden, sollten der Erfassungspipeline Attribute für die Messwerte hinzugefügt werden, die die Umgebung beschreiben, in der die Anwendung ausgeführt wird. Zusammen mit den zuvor beschriebenen Mesh-Attributen kann so eine Übersicht über den Traffic im Mesh erstellt werden.

Änderungen der Spezifikationen

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

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 Bildes.
  • CONTAINER_NAME durch den Namen des Containers.
  • CSM_WORKLOAD_NAME durch den Namen der Arbeitslast, z. B. den Namen der Bereitstellung.