Observabilité pour gRPC sans proxy
L'observabilité Cloud Service Mesh pour gRPC sans proxy s'appuie sur le plug-in OpenTelemetry gRPC existant. Elle enregistre les métriques (latence, taille des messages, etc.) pour tous les canaux et serveurs gRPC compatibles avec Cloud Service Mesh, et fournit des attributs supplémentaires qui affichent des informations topologiques sur le maillage pour le trafic Cloud Service Mesh. Un canal gRPC est considéré comme compatible avec Cloud Service Mesh s'il reçoit une configuration du plan de contrôle Cloud Service Mesh, tandis que tous les serveurs gRPC sont considérés comme compatibles avec Cloud Service Mesh.
Attributs du maillage
Les attributs de maillage suivants sont disponibles dans les métriques.
Libellés d'environnement local :
csm.mesh_id
- ID du réseau maillé.
- Les autres attributs d'environnement local sont obtenus à partir de la ressource OpenTelemetry.
- Managed Service pour Prometheus (GMP) peut être configuré pour utiliser l'infrastructure Google afin de stocker les métriques. Si vous utilisez cette option, les attributs de ressource qui décrivent l'environnement local de l'application sont automatiquement ajoutés en tant que MonitoredResource.
- Si vous utilisez une infrastructure non Google pour exporter et stocker les métriques, le pipeline de collecte doit ajouter des attributs aux métriques qui décrivent l'environnement sur lequel l'application s'exécute.
Libellés d'environnement à distance :
csm.remote_workload_type
- Type du pair distant. ("gcp_kubernetes_engine" pour GKE).
- Des attributs supplémentaires sont présents en fonction du type de pair.
- Pour un pair exécuté sur GKE :
csm.remote_workload_project_id
- Identifiant du projet associé à cette ressource, tel que "mon-projet".
csm.remote_workload_location
* Emplacement physique du cluster contenant le conteneur.csm.remote_workload_cluster_name
- Cluster sur lequel le conteneur est exécuté.
csm.remote_workload_namespace_name
The namespace where the container is running.
csm.remote_workload_name
- Nom de la charge de travail à distance. Il doit s'agir du nom de l'objet contenant la définition du pod (par exemple, un déploiement, un ReplicaSet ou simplement le nom du pod pour un pod nu).
Libellés de service : informations sur le service de backend (cluster xDS) vers lequel le RPC est routé. Notez que cette option n'est disponible que si le service de backend a été configuré via l'API Gateway.
csm.service_name
- Nom du service.
csm.service_namespace_name
- Nom de l'espace de noms du service.
Le terme remote_workload fait référence au pair. Autrement dit, pour les clients, le Pod de serveur qui est la cible d'un RPC est la charge de travail à distance, tandis que pour les serveurs, le Pod de client qui a lancé le RPC est la charge de travail à distance.
Notez que ces attributs ne seront pas disponibles sur grpc.client.attempt.started
et grpc.server.call.started
, car toutes les informations sur le maillage topologique ne sont pas disponibles au point de collecte de ces métriques.
Instructions de configuration de l'observabilité
Cette section explique comment activer l'observabilité Cloud Service Mesh pour gRPC sans proxy dans une configuration de maillage de services.
C++
La compatibilité de l'observabilité n'est assurée que via le système de compilation Bazel. La cible grpcpp_csm_observability
doit être ajoutée en tant que dépendance.
Modifications de code requises
Le code suivant doit être ajouté à vos clients et serveurs gRPC pour utiliser l'observabilité Cloud Service Mesh.
#include <grpcpp/ext/csm_observability.h>
int main() {
// …
auto observability = grpc::CsmObservabilityBuilder()
.SetMeterProvider(std::move(meter_provider))
.BuildAndRegister();
assert(observability.ok());
// …
}
Avant toute opération gRPC, y compris pour créer un canal, un serveur ou des identifiants, utilisez l'API CsmObservabilityBuilder pour enregistrer un plug-in. L'exemple suivant montre comment configurer l'observabilité Cloud Service Mesh avec un exportateur 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()
sur CsmObservabilityBuilder()
permet aux utilisateurs de définir un objet MeterProvider qui peut être configuré avec des exportateurs.
Java
Pour activer l'observabilité Cloud Service Mesh pour les applications Java gRPC, procédez comme suit :
Assurez-vous que le projet inclut l'artefact
grpc-gcp-csm-observability
. Utilisez gRPC version 1.65.0 ou ultérieure.Dans la méthode
main()
, initialisez Cloud Service Mesh Observability en fournissant une instance configurée du SDK OpenTelemetry avec unMeterProvider
pour collecter et exporter les métriques.Avant d'effectuer des opérations gRPC, comme la configuration d'un canal ou d'un serveur, veillez à utiliser l'API
CsmObservability.Builder()
pour enregistrer le SDK OpenTelemetry.Une fois l'instance CsmObservability créée, l'appel de
registerGlobal()
sur l'instance active Cloud Service Mesh Observability pour tous les canaux et serveurs Cloud Service Mesh.L'exemple suivant montre comment configurer l'observabilité Cloud Service Mesh à l'aide d'un exportateur 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)
}
Go
Avant toute opération gRPC, y compris pour créer un ClientConn ou un serveur, ou des identifiants, configurez l'observabilité Cloud Service Mesh de manière globale avec un MeterProvider
. L'exemple suivant montre comment configurer l'observabilité Cloud Service Mesh. Après avoir configuré l'observabilité Cloud Service Mesh, tous les canaux Cloud Service Mesh et tous les serveurs récupéreront un plug-in de statistiques OpenTelemetry configuré avec les options fournies et avec des libellés Cloud Service Mesh supplémentaires. Les canaux non Cloud Service Mesh recevront un plug-in de statistiques OpenTelemetry sans libellés 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
Les dépendances gRPC suivantes sont requises pour l'observabilité Cloud Service Mesh :
grpcio>=1.65.0
grpcio-observability>=1.65.0
grpcio-csm-observability>=1.65.0
Avant toute opération gRPC, y compris pour créer un canal, un serveur ou des identifiants, utilisez l'API CsmOpenTelemetryPlugin pour créer et enregistrer 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
Après toutes les opérations gRPC, utilisez le code suivant pour annuler l'enregistrement et nettoyer les ressources :
csm_plugin.deregister_global()
L'exemple suivant montre comment configurer l'observabilité Cloud Service Mesh avec un exportateur 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()
Dans l'exemple précédent, vous pouvez extraire localhost:9464/metrics
pour obtenir les métriques signalées par l'observabilité Cloud Service Mesh.
Notez que pour que les attributs de maillage ajoutés aux métriques gRPC fonctionnent, les binaires client et serveur doivent être configurés avec CsmObservability.
Si vous utilisez une infrastructure non Google pour exporter et stocker les métriques, le pipeline de collecte doit ajouter des attributs aux métriques qui décrivent l'environnement sur lequel l'application s'exécute. Ces attributs, ainsi que ceux du maillage décrits précédemment, peuvent être utilisés pour obtenir une vue du trafic s'exécutant sur le maillage.
Modifications des spécifications
L'observabilité Cloud Service Mesh détermine les informations topologiques du maillage via des variables d'environnement qui doivent être ajoutées à l'environnement du conteneur, à la fois pour les clients et les serveurs. Ces informations sont mises à la disposition des pairs pour le reporting des métriques via l'observabilité 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
En remplaçant les éléments suivants :
- IMAGE_NAME par le nom de l'image.
- CONTAINER_NAME par le nom du conteneur.
- CSM_WORKLOAD_NAME par le nom de la charge de travail, par exemple le nom du déploiement.