Observabilidade para gRPC sem proxy

A observabilidade da malha de serviços na nuvem para compilações gRPC sem proxy baseia-se no plug-in gRPC OpenTelemetry existente, regista métricas (latência, tamanhos das mensagens, etc.) para todos os canais e servidores gRPC com a malha de serviços na nuvem ativada e fornece atributos adicionais que mostram informações topológicas da malha para o tráfego da malha de serviços na nuvem. Um canal gRPC é considerado ativado para o Cloud Service Mesh se receber configuração do plano de controlo 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.

Etiquetas de ambiente local:

  • csm.mesh_id
    • O ID da malha.
  • Outros atributos do ambiente local são obtidos a partir do recurso OpenTelemetry.
    • O Managed Service for Prometheus (GMP) pode ser configurado para usar a infraestrutura Google para armazenar métricas. Se usar esta opção, os atributos de recursos que descrevem o ambiente local da aplicação são adicionados automaticamente como um MonitoredResource.
    • Se usar uma infraestrutura não pertencente à Google para exportar e armazenar métricas, o pipeline de recolha deve adicionar atributos às métricas que descrevem o ambiente em que a aplicação está a ser executada.

Etiquetas de ambiente remoto:

  • csm.remote_workload_type
    • O tipo do par remoto. ("gcp_kubernetes_engine" para o GKE).
  • Com base no tipo do par, estão presentes atributos adicionais.
    • Para um par em execução no GKE:
    • csm.remote_workload_project_id
      • O identificador do projeto associado a este recurso, como "my-project".
    • csm.remote_workload_location * A localização física do cluster que contém o contentor.
    • csm.remote_workload_cluster_name
      • O cluster onde o contentor está a ser executado.
    • csm.remote_workload_namespace_name
      • The namespace where the container is running.
    • csm.remote_workload_name
      • O nome da carga de trabalho remota. Este deve ser o nome do objeto que contém a definição do pod (por exemplo, uma implementação, um ReplicaSet ou apenas o nome do pod para um pod simples).

Etiquetas de serviço: informações sobre o serviço de back-end (cluster xDS) para o qual o RPC está a ser encaminhado. Tenha em atenção que esta opção só está disponível se o serviço de back-end tiver sido configurado através da API Gateway.

  • csm.service_name
    • O nome do serviço.
  • csm.service_namespace_name
    • O nome do espaço de nomes do serviço.

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

Tenha em atenção que estes atributos não estão disponíveis no grpc.client.attempt.started e no grpc.server.call.started, uma vez que todas as informações de malha topológica não estão disponíveis no ponto de recolha destas métricas.

Instruções de configuração da observabilidade

Esta secção explica como ativar a observabilidade da Cloud Service Mesh para gRPC sem proxy numa configuração de service mesh.

C++

O apoio técnico de observabilidade só está disponível através do sistema de compilação do Bazel. O destino grpcpp_csm_observability tem de ser adicionado como uma dependência.

Alterações de código necessárias

Tem de adicionar o seguinte código aos seus clientes e servidores gRPC para usar a observabilidade da 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 quaisquer operações gRPC, incluindo a criação de um canal, um servidor ou credenciais, use a API CsmObservabilityBuilder para registar um plug-in. O exemplo seguinte mostra como configurar a observabilidade da malha de serviços na nuvem 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 utilizadores definam um objeto MeterProvider que pode ser configurado com exportadores.

Java

Para ativar a observabilidade da Cloud Service Mesh para aplicações Java gRPC, siga estes passos:

  1. Certifique-se de que o projeto inclui o artefacto grpc-gcp-csm-observability. Use a versão 1.65.0 ou posterior do gRPC.

  2. No método main(), inicialize a observabilidade da malha de serviços na nuvem fornecendo uma instância do SDK do OpenTelemetry configurada com um MeterProvider para recolher e exportar métricas.

    Antes de realizar quaisquer operações gRPC, como configurar um canal ou um servidor, certifique-se de que usa a API CsmObservability.Builder() para registar o SDK OpenTelemetry.

    Depois de criar a instância CsmObservability, a invocação de registerGlobal() na instância ativa a observabilidade da malha de serviço na nuvem para todos os canais e servidores da malha de serviço na nuvem.

    O exemplo seguinte demonstra como configurar a observabilidade da malha de serviços na nuvem através de 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)
}

Ir

Antes de quaisquer operações gRPC, incluindo a criação de um ClientConn ou um servidor, ou credenciais, configure a observabilidade da Cloud Service Mesh globalmente com um MeterProvider. O exemplo seguinte mostra como configurar a observabilidade do Cloud Service Mesh. Depois de configurar a observabilidade da Cloud Service Mesh, todos os canais da Cloud Service Mesh e todos os servidores vão receber um plugin de estatísticas do OpenTelemetry configurado com as opções fornecidas e com etiquetas da Cloud Service Mesh adicionais. Os canais do Non Cloud Service Mesh vão receber um plug-in de estatísticas do OpenTelemetry sem etiquetas 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 quaisquer operações gRPC, incluindo a criação de um canal, um servidor ou credenciais, use a API CsmOpenTelemetryPlugin para criar e registar 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

Após todas as operações gRPC, use o seguinte código para anular o registo e limpar os recursos:

csm_plugin.deregister_global()

O exemplo seguinte mostra como configurar a observabilidade da 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, pode extrair localhost:9464/metrics para obter as métricas comunicadas pela observabilidade da malha de serviços na nuvem.

Tenha em atenção que, para que os atributos de malha adicionados às métricas gRPC funcionem, os binários do cliente e do servidor têm de ser configurados com CsmObservability.

Se usar uma infraestrutura não pertencente à Google para exportar e armazenar métricas, o pipeline de recolha deve adicionar atributos às métricas que descrevem o ambiente em que a aplicação está a ser executada. Isto, juntamente com os atributos da malha descritos anteriormente, pode ser usado para obter uma vista do tráfego em execução na malha.

Alterações às especificações

A observabilidade da malha de serviços na nuvem determina as informações topológicas da malha através de variáveis de ambiente que têm de ser adicionadas ao ambiente do contentor, tanto para clientes como para servidores. Estas informações são disponibilizadas aos pares para relatórios de métricas através da observabilidade da malha de serviços na nuvem.

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

Substituir o seguinte:

  • IMAGE_NAME com o nome da imagem.
  • CONTAINER_NAME com o nome do contentor.
  • CSM_WORKLOAD_NAME com o nome da carga de trabalho, por exemplo, o nome da implementação.