Observabilidade para gRPC sem proxy

Visualização

Este produto ou recurso está sujeito aos "Termos das ofertas pré-GA" na seção "Termos de Serviço gerais" dos Termos específicos do serviço. Os produtos e recursos pré-GA estão disponíveis "no estado em que se encontram" e podem ter suporte limitado. Para mais informações, consulte as descrições da fase de lançamento.

Observabilidade do Cloud Service Mesh para builds gRPC sem proxy plug-in gRPC OpenTelemetry atual, registra métricas (latência, tamanhos de mensagens etc.) para todos os canais e servidores gRPC com o Cloud Service Mesh ativado e fornece atributos adicionais que mostra as informações topológicas da malha para o tráfego do Cloud Service Mesh. 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 do ambiente local são obtidos do OpenTelemetry Resource.
  • O Managed Service para Prometheus (GMP) pode ser configurado para usar a infraestrutura do Google para armazenar métricas. Se estiver usando isso, atributos de recurso que descrevem o ambiente local do aplicativo são adicionado automaticamente como MonitoredResource (em inglês)
  • 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 de peer remoto. ("gcp_kubernetes_engine" para GKE).
• Com base no tipo do app semelhante, há atributos adicionais.
  • 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. É o nome do objeto que contenha a definição do pod (por exemplo, um Deployment, ReplicaSet, ou apenas o nome de um pod básico).

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. Esse recurso só fica disponível se o serviço de back-end tiver sido 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, porque todas as informações de malha topológica não estão disponíveis no ponto de coleta dessas métricas.

Observação: grpc.client.call.duration não está disponível como métrica. As métricas grpc.client.attempt.duration e grpc.server.call.duration estão disponíveis.

Instruções de configuração da 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 grpcpp_csm_observability de destino 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 exportador do 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();

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

Java

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

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

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 realizar operações 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 servidor ou credenciais, configure a Observabilidade da malha de serviço do Cloud 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 conseguir o métricas relatadas pela observabilidade do Cloud Service Mesh.

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

Se você usar uma infraestrutura que não seja do Google para exportar e armazenar métricas, o pipeline de coleta precisará adicionar atributos às métricas que descrevem o ambiente em que o aplicativo está sendo executado. Isso, junto com os atributos de malha descritos anteriormente, pode ser usado para ter uma visão do tráfego executado na malha.

Alterações na especificação

A observabilidade do Cloud Service Mesh determina as informações topológicas da malha usando variáveis de ambiente que precisam ser adicionadas ao ambiente do contêiner. para clientes e servidores. Essas informações são disponibilizadas aos colegas para fins de métricas. usando a 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, o nome da implantação.