O Anthos Service Mesh e o Traffic Director agora são Cloud Service Mesh. Para mais informações, consulte a Visão geral do Cloud Service Mesh.

O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Observabilidade para gRPC sem proxy

A observabilidade do Cloud Service Mesh para gRPC sem proxy é baseada no plug-in OpenTelemetry do gRPC, registra métricas (latência, tamanhos de mensagens etc.) para todos os canais e servidores gRPC ativados para o Cloud Service Mesh e fornece outros atributos que mostram informações topológicas da malha para o tráfego do 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 da malha

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

Identificadores de ambiente local:

csm.mesh_id
- O ID da malha.
Outros atributos de ambiente local são extraídos do recurso OpenTelemetry.
- O Serviço Gerenciado para Prometheus (GMP) pode ser configurado para usar a infraestrutura do Google para armazenar métricas. Se você usar esse serviço, 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 vai adicionar atributos às métricas que descrevem o ambiente em que o aplicativo está sendo executado.

Identificadores de ambiente remoto:

csm.remote_workload_type
- O tipo do par remoto. ("gcp_kubernetes_engine" para GKE).
Com base no tipo do par, outros atributos estarão presentes.
- Para um par 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á em execução.
- csm.remote_workload_namespace_name
  - O namespace em que o contêiner está em execução.
- csm.remote_workload_name
  - O nome da carga de trabalho remota. Esse precisa ser 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).

Identificadores de serviço: informações sobre o serviço de back-end (cluster xDS) para o qual o RPC está sendo encaminhado. Isso só estará 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 par. Ou seja, para clientes, o pod do servidor que é o destino de um RPC é a carga de trabalho remota, enquanto para servidores, o pod do cliente que iniciou o 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 nem todas as informações topológicas da malha estã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 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 SetMeterProvider() API em 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 gRPC Java, siga estas etapas:

Verifique se o projeto inclui o artefato grpc-gcp-csm-observability. Use a versão 1.65.0 ou mais recente do gRPC.
No método main(), inicialize a observabilidade do Cloud Service Mesh fornecendo uma instância configurada do SDK 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 OpenTelemetry.

Depois que a instância CsmObservability for criada, invocar registerGlobal() na instância vai ativar 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 do Cloud Service Mesh 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 e servidores do Cloud Service Mesh vão selecionar um plug-in de estatísticas do OpenTelemetry configurado com as opções fornecidas e com outros identificadores 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 identificadores 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 gRPC, use o código a seguir 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, é possível extrair 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 gRPC funcionem, os binários do cliente e do servidor precisam ser configurados com CsmObservability.

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

Mudanças de 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 aos pares para 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.