Osservabilità per gRPC senza proxy
Cloud Service Mesh Observability per gRPC proxyless si basa sul plugin OpenTelemetry gRPC 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 mostrano le informazioni sulla topologia della mesh per il traffico di Cloud Service Mesh. Un canale gRPC è considerato abilitato per Cloud Service Mesh se riceve la configurazione dal control plane di Cloud Service Mesh, mentre tutti i server gRPC sono considerati abilitati per Cloud Service Mesh.
Attributi mesh
I seguenti attributi della mesh sono disponibili nelle metriche.
Etichette dell'ambiente locali:
csm.mesh_id
- L'ID della mesh.
- Gli altri attributi dell'ambiente locale vengono ottenuti dalla
risorsa OpenTelemetry.
- Managed Service per Prometheus (GMP) può essere configurato per utilizzare l'infrastruttura Google per archiviare le metriche. Se utilizzi questo metodo, gli attributi delle risorse 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 alle metriche che descrivono l'ambiente in cui viene eseguita l'applicazione.
Etichette dell'ambiente remoto:
csm.remote_workload_type
- Il tipo di peer remoto. ("gcp_kubernetes_engine" per GKE).
- In base al tipo di peer, saranno 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 container.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 workload 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 di servizio: informazioni sul servizio di backend (cluster xDS) a cui viene indirizzato l'RPC. Tieni presente che questa opzione è disponibile solo se il servizio di backend è stato configurato tramite l'API Gateway.
csm.service_name
- Il nome del servizio.
csm.service_namespace_name
- Il nome dello spazio dei nomi del servizio.
Il termine remote_workload si riferisce al peer, ovvero, per i client, il server Il pod di destinazione di una RPC è il workload remoto, mentre per i server, il pod client che ha avviato la RPC è il workload remoto.
Tieni presente che questi attributi non saranno disponibili su grpc.client.attempt.started
e grpc.server.call.started
, poiché tutte le informazioni sulla mesh topologica non sono
disponibili nel punto di raccolta di queste metriche.
Istruzioni per la configurazione dell'osservabilità
Questa sezione spiega come attivare l'osservabilità di Cloud Service Mesh per gRPC senza proxy in una configurazione di mesh di servizi.
C++
Il supporto dell'osservabilità è disponibile solo tramite il sistema di compilazione Bazel. La
destinazione grpcpp_csm_observability
deve essere
aggiunta come dipendenza.
Modifiche al codice richieste
Il seguente codice deve essere aggiunto ai client e ai server gRPC 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, di un server o di credenziali, utilizza l'API CsmObservabilityBuilder per registrare un plug-in. Il seguente esempio mostra come configurare l'osservabilità di Cloud Service Mesh con un esportatore Prometheus.
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
impostare un oggetto MeterProvider
che può essere configurato con gli esportatori.
Java
Per abilitare l'osservabilità di Cloud Service Mesh per le applicazioni Java gRPC, svolgi i seguenti passaggi:
Assicurati che il progetto includa l'artefatto
grpc-gcp-csm-observability
. Utilizza gRPC versione 1.65.0 o successive.All'interno del metodo
main()
, inizializza Cloud Service Mesh Observability fornendo un'istanza SDK OpenTelemetry configurata con unMeterProvider
per raccogliere ed esportare le metriche.Prima di eseguire qualsiasi operazione 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 Cloud Service Mesh Observability per tutti i canali e i server 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 un ClientConn o di un server o di credenziali, configura Cloud Service Mesh Observability a livello globale con un MeterProvider
. L'esempio seguente mostra come configurare l'osservabilità di Cloud Service Mesh. Dopo aver configurato Cloud Service MeshObservability, tutti i canali Cloud Service Mesh e tutti i server selezioneranno un plug-in di statistiche OpenTelemetry configurato con le opzioni fornite e con etichette Cloud Service Mesh aggiuntive. I canali non Cloud Service Mesh riceveranno un
plug-in delle 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
Per l'osservabilità di Cloud Service Mesh sono richieste le seguenti dipendenze gRPC:
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 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 seguente codice per annullare la registrazione e pulire le risorse:
csm_plugin.deregister_global()
Il seguente esempio 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()
Nell'esempio precedente, puoi eseguire lo scraping di localhost:9464/metrics
per ottenere le
metriche riportate da Cloud Service Mesh Observability.
Tieni presente che per il funzionamento degli attributi mesh aggiunti alle metriche gRPC, è necessario configurare i file binari client e server con CsmObservability.
Se utilizzi un'infrastruttura non Google per l'esportazione e l'archiviazione delle metriche, la pipeline di raccolta deve aggiungere attributi alle metriche che descrivono l'ambiente in cui viene eseguita l'applicazione. Questi attributi, insieme a quelli della mesh descritti in precedenza, possono essere utilizzati per visualizzare il traffico in esecuzione sulla mesh.
Modifiche alle specifiche
Cloud Service Mesh Observability determina le informazioni topologiche del mesh tramite le variabili di ambiente che devono essere aggiunte all'ambiente del container, sia per i client che per i server. Queste informazioni vengono rese disponibili ai peer per la generazione di report sulle metriche tramite Cloud Service Mesh Observability.
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 nome del deployment.