Observabilité pour gRPC sans proxy

Preview

Ce produit ou cette fonctionnalité est soumis aux "Conditions des offres de pré-DG" de la section "Conditions générales du service" des Conditions spécifiques du service. Les produits et fonctionnalités de pré-DG sont proposés "en l'état" et peuvent avoir une prise en charge limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

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.

Remarque : grpc.client.call.duration n'est pas disponible en tant que métrique. Les métriques grpc.client.attempt.duration et grpc.server.call.duration sont disponibles.

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 :

1. Assurez-vous que le projet inclut l'artefact grpc-gcp-csm-observability. Utilisez gRPC version 1.65.0 ou ultérieure.

2. Dans la méthode main(), initialisez Cloud Service Mesh Observability en fournissant une instance configurée du SDK OpenTelemetry avec un MeterProvider 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.