Observabilidade para gRPC sem proxy

A Observabilidade da Malha de Serviço do Google Cloud para gRPC sem proxy é baseada no plug-in do OpenTelemetry do gRPC, registra métricas (latência, tamanhos de mensagem etc.) para todos os canais e servidores do gRPC que são ativados pela Malha de Serviço do Google Cloud e fornece atributos adicionais que mostram informações topológicas da malha para o tráfego da Malha de Serviço do Google Cloud. Um canal gRPC é considerado ativado pelo Cloud Service Mesh se receber a configuração do plano de controle do Cloud Service Mesh, enquanto todos os servidores gRPC são considerados ativados pelo Cloud Service Mesh.

Atributos de malha

Os seguintes atributos de rede estão disponíveis nas métricas.

Marcadores de ambiente local:

  • csm.mesh_id
    • O ID da malha.
  • Outros atributos de ambiente local são Recurso do OpenTelemetry.
    • O Managed Service para Prometheus (GMP) pode ser configurado para usar a infraestrutura do Google para armazenar métricas. Se você usar esse recurso, os atributos de recursos que descrevem o ambiente local do aplicativo serão adicionados automaticamente como um MonitoredResource.
    • Se você usar uma infraestrutura que não seja do Google para exportar e armazenar métricas, o pipeline de coleta precisará adicionar atributos nas métricas que descrevem o ambiente em que o aplicativo está sendo executado.

Rótulos de ambiente remoto:

  • csm.remote_workload_type
    • O tipo do terminal remoto. ("gcp_kubernetes_engine" para GKE).
  • Com base no tipo de peer, outros atributos estariam presentes.
    • Para um peer em execução no GKE:
    • csm.remote_workload_project_id
      • O identificador do projeto associado a esse recurso, como "my-project".
    • csm.remote_workload_location *O local físico do cluster que contém o contêiner.
    • csm.remote_workload_cluster_name
      • O cluster em que o contêiner está sendo executado.
    • csm.remote_workload_namespace_name
      • The namespace where the container is running.
    • csm.remote_workload_name
      • O nome da carga de trabalho remota. Esse é o nome do objeto que contém a definição do pod (por exemplo, uma implantação, um ReplicaSet ou apenas o nome do pod para um pod simples).

Rótulos de serviço: informações sobre o serviço de back-end (cluster xDS) que o RPC para o qual está sendo roteada. Observe que isso só estará disponível se o serviço de back-end tiver configurado pela API Gateway.

  • csm.service_name
    • O nome do serviço.
  • csm.service_namespace_name
    • O nome do namespace do serviço.

O termo "remote_workload" se refere ao peer, ou seja, para clientes, o pod do servidor que é o destino de uma RPC é a carga de trabalho remota, enquanto para servidores, o pod do cliente que iniciou a RPC é a carga de trabalho remota.

Esses atributos não estarão disponíveis em grpc.client.attempt.started e grpc.server.call.started, já que todas as informações da malha topológica não são disponíveis no local de coleta dessas métricas.

Instruções de configuração de observabilidade

Esta seção explica como ativar a Observabilidade do Cloud Service Mesh para gRPC sem proxy em uma configuração de malha de serviço.

C++

O suporte à observabilidade só está disponível no sistema de compilação do Bazel. O destino grpcpp_csm_observability precisa ser adicionado como uma dependência.

Alterações de código necessárias

O código a seguir precisa ser adicionado aos clientes e servidores gRPC em para usar a observabilidade do 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 qualquer operação gRPC, incluindo a criação de um canal, servidor ou credenciais, use a API CsmObservabilityBuilder para registrar um plug-in. O exemplo a seguir mostra como configurar a observabilidade do Cloud Service Mesh com um 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();

A API SetMeterProvider() em CsmObservabilityBuilder() permite que os usuários defina um MeterProvider. que pode ser configurado com exportadores.

Java

Para ativar a observabilidade do Cloud Service Mesh para aplicativos gRPC em Java, siga estas etapas:

  1. Verifique se o projeto inclui o artefato grpc-gcp-csm-observability. Usar gRPC versão 1.65.0 ou posterior.

  2. No método main(), inicialize a Observabilidade do Cloud Service Mesh fornecendo uma instância configurada do SDK do OpenTelemetry com um MeterProvider para coletar e exportar métricas.

    Antes de executar qualquer operação gRPC, como configurar um canal ou servidor, use a API CsmObservability.Builder() para registrar o SDK do OpenTelemetry.

    Depois que a instância "CsmObservability" é criada, invocar registerGlobal() na instância ativa a observabilidade do Cloud Service Mesh para todos Canais e servidores do Cloud Service Mesh.

    O exemplo a seguir demonstra como configurar a observabilidade do Cloud Service Mesh usando um exportador do 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 qualquer operação gRPC, incluindo a criação de um ClientConn ou Server, ou de nuvem, configurar a observabilidade do Cloud Service Mesh globalmente com um MeterProvider: O exemplo a seguir mostra como configurar a Observabilidade do Cloud Service Mesh. Depois de configurar o Cloud Service MeshObservability, Os canais do Cloud Service Mesh e todos os servidores receberão uma conexão do OpenTelemetry de estatísticas configurado com as opções fornecidas e com recursos Rótulos do Cloud Service Mesh. Os canais que não são do Cloud Service Mesh vão receber um plug-in de estatísticas do OpenTelemetry sem rótulos do 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

As seguintes dependências do gRPC são necessárias para a observabilidade do Cloud Service Mesh:

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

Antes de qualquer operação gRPC, incluindo a criação de um canal, servidor ou credenciais, use a API CsmOpenTelemetryPlugin para criar e registrar um 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

Depois de todas as operações do gRPC, use o código abaixo para cancelar o registro e limpar os recursos:

csm_plugin.deregister_global()

O exemplo a seguir mostra como configurar a observabilidade do Cloud Service Mesh com um exportador do 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()

No exemplo anterior, você pode raspar localhost:9464/metrics para receber as métricas informadas pela Observabilidade do Cloud Service Mesh.

Para que os atributos de malha adicionados às métricas do gRPC funcionem, os os binários de cliente e servidor precisam ser configurados com CsmObservability.

Se você usar uma infraestrutura que não seja do Google para exportar e armazenar métricas, o o pipeline de coleta precisa adicionar atributos às métricas que descrevem o em que o aplicativo está sendo executado. Isso, junto com a malha, atributos descritos anteriormente podem ser utilizados para obter uma visualização do tráfego em execução na malha.

Mudanças na especificação

A Observabilidade do Cloud Service Mesh determina as informações topológicas da malha por meio de variáveis de ambiente que precisam ser adicionadas ao ambiente do contêiner, tanto para clientes quanto para servidores. Essas informações são disponibilizadas para pares para geração de relatórios de métricas pela Observabilidade do 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

Substitua o seguinte:

  • IMAGE_NAME pelo nome da imagem.
  • CONTAINER_NAME pelo nome do contêiner.
  • CSM_WORKLOAD_NAME pelo nome da carga de trabalho, por exemplo, a implantação nome.