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.

A Observabilidade da Cloud Service Mesh para gRPC sem proxy é baseada no plug-in do gRPC OpenTelemetry, registra métricas (latência, tamanhos de mensagem etc.) para todos os canais e servidores do gRPC que são compatíveis com a Cloud Service Mesh e fornece atributos adicionais que mostram informações topológicas da malha para o tráfego da Cloud Service Mesh. Um canal gRPC é considerado ativado para o 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 para o Cloud Service Mesh.

Atributos de malha

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

Rótulos 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 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 de peer remoto. ("gcp_kubernetes_engine" para o 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) para o qual o RPC está sendo roteado. Isso 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 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 do gRPC 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 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, a invocação de registerGlobal() nela ativa a Observabilidade do Cloud Service Mesh para todos os 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 a Observabilidade do Cloud Service Mesh, todos os canais do Cloud Service Mesh e todos os servidores vão escolher um plug-in de estatísticas do OpenTelemetry configurado com as opções fornecidas e com outros 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 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 conferir o tráfego executado na malha.

Mudanças na especificação

A Observabilidade do Cloud Service Mesh determina as informações topológicas da malha por 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, o nome da implantação.