Observabilidad de gRPC sin proxy

Vista previa

Este producto o función está sujeto a las "Condiciones de las Ofertas de Fase Previa a la DG" de la sección Condiciones Generales del Servicio de las Condiciones específicas del Servicio. Los productos y las funciones que se encuentran en la fase previa a la DG están disponibles “tal cual” y podrían tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.

Cloud Service Mesh Observability para compilaciones de gRPC sin proxy sobre el el complemento de OpenTelemetry de gRPC existente, registra métricas (latencia, tamaños de mensajes, etc.) de todos los canales y servidores de gRPC que están habilitados para la malla de servicios de Cloud y proporcionan atributos adicionales mostrar información de la malla topológica para el tráfico de Cloud Service Mesh. Un canal de gRPC se considera habilitado para Cloud Service Mesh si obtiene la configuración del plano de control de Cloud Service Mesh, mientras que todos los servidores de gRPC se consideran habilitados para Cloud Service Mesh.

Atributos de malla

Los siguientes atributos de malla están disponibles en las métricas.

Etiquetas de entorno local:

• csm.mesh_id
  • El ID de la malla.
• Otros atributos del entorno local se obtienen del recurso de OpenTelemetry.
  • Se puede configurar Managed Service para Prometheus (GMP) para usar la infraestructura de Google y almacenar métricas. Si usas esta opción, los atributos de recursos que describen el entorno local de la aplicación se agregan automáticamente como MonitoredResource.
  • Si usas una infraestructura ajena a Google para exportar y almacenar métricas, el de recopilación de imágenes debe agregar atributos en las métricas que describan el entorno en el que se ejecuta la aplicación.

Etiquetas de entorno remoto:

• csm.remote_workload_type
  • Es el tipo de par remoto. ("gcp_kubernetes_engine" para GKE).
• Según el tipo de la app similar, habrá atributos adicionales.
  • Para un intercambio de tráfico que se ejecuta en GKE:
  • csm.remote_workload_project_id
    • El identificador del proyecto asociado con este recurso, como “my-project”.
  • csm.remote_workload_location *La ubicación física del clúster que contiene el contenedor.
  • csm.remote_workload_cluster_name
    • El clúster en el que se ejecuta el contenedor
  • csm.remote_workload_namespace_name
    • The namespace where the container is running.
  • csm.remote_workload_name
    • El nombre de la carga de trabajo remota. Debe ser el nombre del objeto que contenga la definición del Pod (por ejemplo, un objeto Deployment, ReplicaSet, o solo el nombre del Pod de un Pod vacío).

Etiquetas de servicio: información sobre el servicio de backend (clúster xDS) que la RPC se está enrutando. Ten en cuenta que esto solo está disponible si el servicio de backend tiene con la API de puerta de enlace.

• csm.service_name
  • El nombre del servicio
• csm.service_namespace_name
  • El nombre del espacio de nombres del servicio.

El término remoto_carga de trabajo hace referencia al intercambio de tráfico, es decir, para clientes, al servidor El Pod de destino de una RPC es la carga de trabajo remota, mientras que, para los servidores, el Pod cliente que inició la RPC es la carga de trabajo remota.

Ten en cuenta que estos atributos no estarán disponibles en grpc.client.attempt.started ni grpc.server.call.started, ya que toda la información de malla topológica no está disponible en el punto de recopilación de estas métricas.

Nota: grpc.client.call.duration no está disponible como métrica. Las métricas grpc.client.attempt.duration y grpc.server.call.duration están disponibles.

Instrucciones de configuración de la observabilidad

En esta sección, se explica cómo habilitar la observabilidad de la malla de servicios de Cloud para gRPC sin proxy en la configuración de una malla de servicios.

C++

La asistencia de observabilidad solo está disponible a través del sistema de compilación de Bazel. El el grpcpp_csm_observability objetivo debe ser agregado como dependencia.

Cambios de código obligatorios

Debes agregar el siguiente código a los clientes y servidores de gRPC en para usar la observabilidad de Cloud Service Mesh.

#include <grpcpp/ext/csm_observability.h>

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

Antes de cualquier operación de gRPC, incluida la creación de un canal, un servidor o credenciales, usar la API de CsmObservabilityBuilder para registrar un complemento. El siguiente ejemplo se muestra cómo configurar la observabilidad de la malla de servicios de Cloud con una instancia de Prometheus exportador.

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

La API de SetMeterProvider() en CsmObservabilityBuilder() permite a los usuarios establecer un objeto MeterProvider que se puede configurar con exportadores.

Java

Para habilitar la observabilidad de Cloud Service Mesh para aplicaciones de gRPC de Java, sigue estos pasos:

1. Asegúrate de que el proyecto incluya el artefacto grpc-gcp-csm-observability. Usa gRPC versión 1.65.0 o posterior.

2. Dentro del método main(), inicializa la observabilidad de Cloud Service Mesh proporcionando una instancia configurada del SDK de OpenTelemetry con un MeterProvider para recopilar y exportar métricas.

   Antes de realizar cualquier operación de gRPC, como configurar un canal o un servidor, asegúrate de usar la API de CsmObservability.Builder() para registrar el SDK de OpenTelemetry.

   Una vez que se crea la instancia de CsmObservability, invocar a registerGlobal() en la instancia habilita la observabilidad de Cloud Service Mesh para todos los canales y servidores de Cloud Service Mesh.

   En el siguiente ejemplo, se muestra cómo configurar la observabilidad de la malla de servicios de Cloud con un exportador de 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

Antes de realizar cualquier operación de gRPC, incluida la creación de un ClientConn o un servidor, o credenciales, configura la observabilidad de la malla de servicios de Cloud de forma global con un MeterProvider. En el siguiente ejemplo, se muestra cómo configurar Cloud Service Mesh Observabilidad. Después de configurar la observabilidad de Cloud Service Mesh, cualquier canal de Cloud Service Mesh y todos los servidores detectarán un complemento de estadísticas de OpenTelemetry configurado con las opciones proporcionadas y con etiquetas adicionales de Cloud Service Mesh. Los canales de malla de servicios que no sean de Cloud obtendrán una Complemento de estadísticas de OpenTelemetry sin etiquetas de malla de servicios de Cloud.

  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

Las siguientes dependencias de gRPC son necesarias para la observabilidad de Cloud Service Mesh:

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

Antes de realizar cualquier operación de gRPC, incluida la creación de un canal, un servidor o credenciales, usa la API de CsmOpenTelemetryPlugin para crear y registrar un plugin:

import grpc_csm_observability

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

# Create server or client 

Después de todas las operaciones de gRPC, usa el siguiente código para anular el registro y limpiar los recursos:

csm_plugin.deregister_global()

En el siguiente ejemplo, se muestra cómo configurar la observabilidad de Cloud Service Mesh con un exportador de 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()

En la muestra anterior, puedes extraer localhost:9464/metrics para obtener la que informa la observabilidad de la malla de servicios de Cloud.

Ten en cuenta que, para que funcionen los atributos de malla agregados a las métricas de gRPC, los objetos binarios del cliente y del servidor deben configurarse con CsmObservability.

Si usas una infraestructura ajena a Google para exportar y almacenar métricas, el de recopilación de imágenes debe agregar atributos en las métricas que describan la en el que se ejecuta la aplicación. Esto, junto con los atributos de malla descritos anteriormente, se puede usar para obtener una vista del tráfico que se ejecuta en la malla.

Cambios de especificaciones

La observabilidad de la malla de servicios de Cloud determina la información topológica de la malla a través de variables de entorno que deben agregarse al entorno del contenedor, para clientes y servidores. Esta información se pone a disposición de los pares para obtener métricas a través de la observabilidad de la malla de servicios de Cloud.

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

Reemplaza lo siguiente:

• IMAGE_NAME por el nombre de la imagen
• CONTAINER_NAME por el nombre del contenedor
• CSM_WORKLOAD_NAME por el nombre de la carga de trabajo, por ejemplo, el nombre de la implementación.