Beobachtbarkeit für proxyloses gRPC

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

Mesh-Attribute

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

Labels für die lokale Umgebung:

• 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 die Google-Infrastruktur zum Speichern von Messwerten verwendet wird. In diesem Fall werden Ressourcenattribute, die die lokale Umgebung der Anwendung beschreiben, automatisch als MonitoredResourcehinzugefügt.
  • Wenn Sie keine Google-Infrastruktur zum Exportieren und Speichern von Messwerten verwenden, sollten der Erfassungspipeline Attribute zu den Messwerten hinzugefügt werden, die die Umgebung beschreiben, in der die Anwendung ausgeführt wird.

Labels für die Remote-Umgebung:

• csm.remote_workload_type
  • Der Typ des Remote-Peers. „gcp_kubernetes_engine“ für GKE.
• Je nach Typ des Peers sind zusätzliche Attribute vorhanden.
  • Für einen Peer, der in GKE ausgeführt wird:
  • csm.remote_workload_project_id
    • Die ID des Projekts, das mit dieser Ressource verknüpft 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 sind nur verfügbar, wenn der Backend-Dienst über die Gateway API konfiguriert wurde.

• csm.service_name
  • Der Dienstname.
• csm.service_namespace_name
  • Der Namespace-Name des Dienstes.

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 für grpc.client.attempt.started und grpc.server.call.started nicht verfügbar, da am Erfassungspunkt dieser Messwerte nicht alle topologischen Mesh-Informationen verfügbar sind.

Anleitung zur Einrichtung der Beobachtbarkeit

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

#include <grpcpp/ext/csm_observability.h>

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

  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();

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)
}

  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.

}

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

import grpc_csm_observability

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

# Create server or client 

csm_plugin.deregister_global()

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 der Cloud Service Mesh-Beobachtbarkeit gemeldeten Messwerte zu erhalten.

Beachten Sie, dass damit die Mesh-Attribute, die den gRPC-Messwerten hinzugefügt werden, funktionieren, sowohl die Client- als auch die Server-Binärdateien mit CsmObservability eingerichtet werden müssen.

Wenn Sie keine Google-Infrastruktur zum Exportieren und Speichern von Messwerten verwenden, sollten 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 so eine Ansicht des Traffics im Mesh erhalten.

Änderungen der Spezifikation

Die Cloud Service Mesh-Beobachtbarkeit ermittelt die topologischen Mesh-Informationen ü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 die Messwertberichterstellung über die Cloud Service Mesh-Beobachtbarkeit 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 des Deployments .