Osservabilità per gRPC senza proxy

Osservabilità di Cloud Service Mesh per le build gRPC senza proxy si basa su plug-in gRPC OpenTelemetry esistente, registra le metriche (latenza, dimensioni dei messaggi e così via) per tutti i canali e i server gRPC abilitati per Cloud Service Mesh e fornisce attributi aggiuntivi che mostra le informazioni sul mesh topologico per il traffico di Cloud Service Mesh. Una gRPC è considerato abilitato per Cloud Service Mesh se riceve dal piano di controllo Cloud Service Mesh, mentre tutte le istanze gRPC sono considerati Cloud Service Mesh abilitati.

Attributi mesh

I seguenti attributi mesh sono disponibili nelle metriche.

Etichette dell'ambiente locale:

  • csm.mesh_id
    • L'ID mesh.
  • Gli altri attributi dell'ambiente locale vengono ottenuti dalla risorsa OpenTelemetry.
    • Managed Service per Prometheus (GMP) puoi essere configurato per utilizzare l'infrastruttura di Google per archiviare le metriche. Se utilizzi questa opzione, gli attributi della risorsa che descrivono l'ambiente locale dell'applicazione vengono aggiunti automaticamente come MonitoredResource.
    • Se utilizzi un'infrastruttura non Google per l'esportazione e l'archiviazione delle metriche, la pipeline di raccolta deve aggiungere attributi nelle metriche che descrivono e l'ambiente su cui è in esecuzione l'applicazione.

Etichette dell'ambiente remoto:

  • csm.remote_workload_type
    • Il tipo di peer remoto. ("gcp_kubernetes_engine" per GKE).
  • A seconda del tipo di peer, sono presenti attributi aggiuntivi.
    • Per un peer in esecuzione su GKE:
    • csm.remote_workload_project_id
      • L'identificatore del progetto associato a questa risorsa, ad esempio "my-project".
    • csm.remote_workload_location * La posizione fisica del cluster che contiene il contenitore.
    • csm.remote_workload_cluster_name
      • Il cluster in cui è in esecuzione il container.
    • csm.remote_workload_namespace_name
      • The namespace where the container is running.
    • csm.remote_workload_name
      • Il nome del carico di lavoro remoto. Deve essere il nome dell'oggetto che contiene la definizione del pod (ad esempio un deployment, un set di repliche o semplicemente il nome del pod per un pod nudo).

Etichette servizio: informazioni sul servizio di backend (cluster xDS) a cui viene indirizzata la chiamata RPC. Tieni presente che questa opzione è disponibile solo se il servizio di backend configurato mediante l'API Gateway.

  • csm.service_name
    • Il nome del servizio.
  • csm.service_namespace_name
    • Il nome dello spazio dei nomi del servizio.

Il termine carico di lavoro remoto si riferisce al peer, ovvero, per i client, il server Il pod target di una RPC è il carico di lavoro remoto, mentre per i server il pod del client che ha avviato la RPC è il carico di lavoro remoto.

Tieni presente che questi attributi non saranno disponibili a partire dal giorno grpc.client.attempt.started e grpc.server.call.started poiché tutte le informazioni della mesh topologica non sono disponibili nel punto di raccolta di queste metriche.

Istruzioni per la configurazione dell'osservabilità

Questa sezione spiega come abilitare Cloud Service Mesh Observability per gRPC senza proxy su una configurazione mesh di servizi.

C++

Il supporto per l'osservabilità è disponibile solo tramite il sistema di compilazione Bazel. Il target grpcpp_csm_observability deve essere aggiunto come dipendenza.

Modifiche al codice richieste

Il seguente codice deve essere aggiunto ai client e ai server gRPC in per utilizzare l'osservabilità di Cloud Service Mesh.

#include <grpcpp/ext/csm_observability.h>

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

Prima di qualsiasi operazione gRPC, inclusa la creazione di un canale, un server o le credenziali, utilizza l'API CsmObservabilityBuilder per registrare un plug-in. L'esempio seguente mostra come configurare l'osservabilità di Cloud Service Mesh con un Prometheus esportatore.

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

L'API SetMeterProvider() su CsmObservabilityBuilder() consente agli utenti di imposta un MeterProvider che può essere configurato con gli esportatori.

Java

Per abilitare l'osservabilità di Cloud Service Mesh per le applicazioni gRPC Java, segui questi passaggi:

  1. Assicurati che il progetto includa l'artefatto grpc-gcp-csm-observability. Utilizza gRPC versione 1.65.0 o successive.

  2. All'interno del metodo main(), inizializza l'osservabilità di Cloud Service Mesh fornendo un configurato l'istanza dell'SDK OpenTelemetry con un MeterProvider da raccogliere ed esportare le metriche.

    Prima di eseguire operazioni gRPC come la configurazione di un canale o di un server, assicurati di utilizzare l'API CsmObservability.Builder() per registrare l'SDK OpenTelemetry.

    Una volta creata l'istanza CsmObservability, l'invocazione di registerGlobal() sull'istanza attiva l'osservabilità di Cloud Service Mesh per tutti i canali e i server di Cloud Service Mesh.

    L'esempio seguente mostra come configurare l'osservabilità di Cloud Service Mesh utilizzando un esportatore Prometheus.

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

Vai

Prima di qualsiasi operazione gRPC, inclusa la creazione di ClientConn o Server o di credenziali, configura l'osservabilità di Cloud Service Mesh a livello globale con un MeterProvider. L'esempio seguente mostra come configurare Cloud Service Mesh Osservabilità. Dopo aver configurato Cloud Service MeshObservability, qualsiasi I canali mesh di servizi Cloud e tutti i server acquisiranno un valore OpenTelemetry plug-in delle statistiche configurato con le opzioni fornite e con Etichette Cloud Service Mesh. I canali non Cloud Service Mesh riceveranno un plug-in per le statistiche OpenTelemetry senza le etichette Cloud Service Mesh.

  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

Le seguenti dipendenze gRPC sono necessarie per Cloud Service Mesh Osservabilità:

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

Prima di qualsiasi operazione gRPC, inclusa la creazione di un canale, un server o delle credenziali, utilizza l'API CsmOpenTelemetryPlugin per creare e registrare un plug-in:

import grpc_csm_observability

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

# Create server or client

Dopo tutte le operazioni gRPC, utilizza il codice seguente per annullare la registrazione ed eseguire la pulizia di risorse:

csm_plugin.deregister_global()

L'esempio seguente mostra come configurare l'osservabilità di Cloud Service Mesh con un esportatore Prometheus:

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

Nel sample precedente, puoi eseguire lo scraping di localhost:9464/metrics per ottenere le metriche registrate da Cloud Service Mesh Observability.

Tieni presente che, affinché gli attributi mesh aggiunti alle metriche gRPC funzionino, sia i file binari del client e del server devono essere impostati con CsmObservability.

Se utilizzi un'infrastruttura non Google per l'esportazione e l'archiviazione delle metriche, la pipeline di raccolta dovrebbe aggiungere attributi nelle metriche che descrivono dell'ambiente in cui è in esecuzione l'applicazione. Insieme al mesh descritti in precedenza, possono essere utilizzati per ottenere una panoramica del traffico, in esecuzione sul mesh.

Modifiche alle specifiche

L'osservabilità di Cloud Service Mesh determina le informazioni topologiche del mesh tramite variabili di ambiente che devono essere aggiunte all'ambiente del contenitore, sia per i client sia per i server. Queste informazioni vengono messe a disposizione dei peer per i report sulle metriche tramite l'osservabilità di Cloud Service Mesh.

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

Sostituisci quanto segue:

  • IMAGE_NAME con il nome dell'immagine.
  • CONTAINER_NAME con il nome del contenitore.
  • CSM_WORKLOAD_NAME con il nome del carico di lavoro, ad esempio il deployment nome.