Configurar la observabilidad de microservicios

Este documento contiene la información que necesitas para configurar el complemento de observabilidad de microservicios, instrumentar tus aplicaciones gRPC y obtener información de Cloud Monitoring, Cloud Logging y Cloud Trace.

Antes de empezar

La observabilidad de microservicios funciona con cualquier despliegue al que se le haya concedido permiso para acceder a Cloud Monitoring, Cloud Logging y Cloud Trace habilitando la API Microservices. En esta guía se muestra un ejemplo de configuración de la observabilidad de microservicios con un ejemplo de Compute Engine.

A grandes rasgos, debes hacer lo siguiente:

  1. Como desarrollador de servicios, puedes habilitar y controlar el complemento de observabilidad de microservicios.
  2. Como operador de servicios, usted consume los datos recogidos de varias formas.

Los repositorios de gRPC (C++, Go y Java) incluyen ejemplos para demostrar la observabilidad de los microservicios.

Antes de configurar la observabilidad, completa las siguientes tareas:

  1. Consulta la descripción general de la observabilidad de microservicios.
  2. Asegúrate de que tienes un proyecto o crea uno.
  3. Asegúrate de que tienes una cuenta de servicio o crea una.
  4. Consulta las dos variables de entorno admitidas, decide cuál quieres usar y determina los valores que necesita la variable de entorno.
  5. Habilita la API Microservices.

Elegir una variable de entorno de configuración

Cuando habilitas el complemento de observabilidad de microservicios, que se describe en el artículo Instrumentar aplicaciones para el complemento de observabilidad, debes proporcionar información de configuración mediante una variable de entorno. De forma predeterminada, no hay ninguna función de observabilidad habilitada. Debes definir la variable de entorno en la VM o el contenedor en el que se ejecute la aplicación o la carga de trabajo de gRPC.

Estas son las variables de entorno:

  • GRPC_GCP_OBSERVABILITY_CONFIG_FILE: el valor es una ruta que apunta a un archivo de configuración codificado en JSON.
  • GRPC_GCP_OBSERVABILITY_CONFIG: el valor es el cuerpo de la configuración codificado en JSON.

Si se definen ambas variables de entorno, GRPC_GCP_OBSERVABILITY_CONFIG_FILE tiene prioridad sobre GRPC_GCP_OBSERVABILITY_CONFIG.

Para aplicar la configuración, debes reiniciar la aplicación gRPC. No puedes definir ni ver los valores de las variables de entorno en la consola Google Cloud .

En la configuración, puede definir un proyecto de destino al que se suban los datos de registro, de seguimiento y de métricas. El ID de proyecto se define en el campo project_id.

Utilice la información de Datos de configuración para definir los valores de la variable de entorno que elija.

Habilitar la API Microservices

Puedes usar la Google Cloud CLI o la Google Cloud consola para habilitar la API Microservices en tus proyectos. Al habilitar la API de microservicios, se habilitan automáticamente las APIs Cloud Logging, Cloud Monitoring y Cloud Trace.

Para habilitar la API, sigue estos pasos:

gcloud services enable microservices.googleapis.com

Definir los permisos de la cuenta de servicio

Si usas una cuenta de servicio que no es la predeterminada, concede los permisos necesarios a la cuenta de servicio. Establece los valores siguientes:

  • PROJECT_ID: sustituye el ID de tu proyecto.
  • SERVICE_ACCOUNT_NAME: sustituye el nombre de la cuenta de servicio de tu proyecto.
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/logging.logWriter

gcloud projects add-iam-policy-binding PROJECT_ID> \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/monitoring.metricWriter

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/cloudtrace.agent

Instrumentar las aplicaciones para el complemento de observabilidad

Para instrumentar tus aplicaciones de forma que puedan usar el complemento de observabilidad de microservicios, sigue las instrucciones de C++, Java y Go.

C++

Puedes usar C++ con la observabilidad de microservicios a partir de gRPC C++ v1.54. El repositorio de ejemplo se encuentra en GitHub.

Cambios en la compilación

La observabilidad solo está disponible a través del sistema de compilación de Bazel. Añade el objetivo grpcpp_gcp_observability como dependencia.

Cambios de código obligatorios

Para habilitar la observabilidad de microservicios, se necesita una dependencia adicional (un módulo de observabilidad) y los siguientes cambios en el código de los clientes, servidores o ambos de gRPC:

#include <grpcpp/ext/gcp_observability.h>

int main(int argc, char** argv) {
  auto observability = grpc::GcpObservability::Init();
  assert(observability.ok());
  …
  // Observability data flushed when object goes out of scope
}

Antes de realizar cualquier operación de gRPC, como crear un canal, un servidor o credenciales, invoca lo siguiente:

grpc::GcpObservability::Init();

Devuelve absl::StatusOr<GcpObservability>, que se debe guardar. El estado ayuda a determinar si la observabilidad se ha inicializado correctamente. El objeto GcpObservability que lo acompaña controla el tiempo de vida de la observabilidad y cierra y vacía automáticamente los datos de observabilidad cuando queda fuera del ámbito.

Go

Los complementos de observabilidad de microservicios son compatibles con las versiones v1.54.0 y posteriores de gRPC Go. El repositorio de ejemplo está en GitHub.

Con el módulo Go, para habilitar la observabilidad de los microservicios, se necesita un módulo de observabilidad y el siguiente código:

import "google.golang.org/grpc/gcp/observability"

func main() {
       ctx, cancel := context.WithTimeout(context.Background(), time.Second)
       defer cancel()
       if err := observability.Start(ctx); err != nil {
              log.Warning("Unable to start gRPC observability:", err)
       }
       defer observability.End()
       …
}

La llamada observability.Start analiza la configuración de las variables de entorno, crea los exportadores correspondientes e inserta la lógica de recogida de datos en las conexiones de cliente y los servidores creados después de la llamada. La llamada diferida observability.End limpia los recursos y asegura que los datos almacenados en el búfer se vacíen antes de que se cierre la aplicación.

Una vez que se haya actualizado el código de la aplicación, ejecuta el siguiente comando para actualizar el archivo go.mod.

go mod tidy

Java

Para usar la observabilidad de microservicios con aplicaciones Java, modifica tu compilación para incluir el artefacto grpc-gcp-observability. Usa la versión 1.54.1 de gRPC o una posterior.

En los fragmentos de compilación de las secciones de herramientas de compilación Gradle y Maven, se ha asignado el valor 1.54.1 a grpcVersion.

El repositorio de ejemplo está en GitHub.

Cambios necesarios en el código Java

Para instrumentar correctamente tus aplicaciones Java para la observabilidad de microservicios, añade el siguiente código a main().

...
import io.grpc.gcp.observability.GcpObservability;
...

// Main application class
...

public static void main(String[] args) {
...
   // call GcpObservability.grpcInit() to initialize & get observability
   GcpObservability observability = GcpObservability.grpcInit();

...
   // call close() on the observability instance to shutdown observability
   observability.close();
...
}

Ten en cuenta que debes llamar a GcpObservability.grpcInit() antes de crear canales o servidores gRPC. La función GcpObservability.grpcInit() lee la configuración de observabilidad de microservicios y la usa para configurar los interceptores y los rastreadores globales necesarios para las funciones de registro, métricas y rastreo de cada canal y servidor creados. GcpObservability.grpcInit() es seguro para subprocesos y debe llamarse exactamente una vez. Devuelve una instancia de GcpObservability que debes guardar para llamar a close() más adelante.

GcpObservability.close() desasigna recursos. Los canales o servidores que se creen después no registrarán nada.

GcpObservability implementa java.lang.AutoCloseable, que se cierra automáticamente si usas try-with-resources de la siguiente manera:

...
import io.grpc.gcp.observability.GcpObservability;
...

// Main application class
...

public static void main(String[] args) {
...
   // call GcpObservability.grpcInit() to initialize & get observability
   try (GcpObservability observability = GcpObservability.grpcInit()) {

...
   } // observability.close() called implicitly
...
}

Usar la herramienta de compilación Gradle

Si usas la herramienta de compilación Gradle, incluye lo siguiente:

def grpcVersion = '1.54.1'

...

dependencies {
...
   implementation "io.grpc:grpc-gcp-observability:${grpcVersion}"
...
}

Usar la herramienta de compilación Maven (pom.xml)

Si usas la herramienta de compilación Maven, incluye lo siguiente:

<properties>
...
  <grpc.version>1.54.1</grpc.version>
...
</properties>

...

<dependencies>
...
 <dependency>
   <groupId>io.grpc</groupId>
   <artifactId>grpc-gcp-observability</artifactId>
   <version>${grpc.version}</version>
 </dependency>
...
</dependencies>

Habilitar la recogida de datos de métricas, de seguimiento y de registro

En las siguientes secciones se incluyen instrucciones para habilitar la recogida de datos en su configuración y un ejemplo que muestra la información de configuración en una variable de entorno.

Habilitar métricas

Para habilitar las métricas, añade el objeto cloud_monitoring a la configuración y asigna el valor {}.

Para obtener más información sobre las métricas, consulta Definiciones de las métricas.

Habilitar el rastreo

Si tienes previsto habilitar el seguimiento en varios servicios, asegúrate de que los servicios admitan la propagación del contexto de seguimiento recibido de los servicios anteriores (o iniciado por sí mismos) a los posteriores.

Para habilitar el seguimiento, haz lo siguiente:

  1. Añada el objeto cloud_trace a la configuración.
  2. Define el cloud_trace.sampling_rate con la probabilidad que quieras que observe tu aplicación para iniciar nuevos rastreos.
    • Por ejemplo, 1.0 significa que se va a registrar cada llamada a procedimiento remoto.
    • 0.0 significa que no se debe iniciar ningún nuevo rastreo.
    • 0.5 significa que el 50% de las llamadas a procedimientos remotos se rastrean de forma aleatoria.

Si se toma una decisión de muestreo positiva en el nivel superior, tus servicios subirán los intervalos independientemente de la configuración de la frecuencia de muestreo.

Para obtener más información sobre el rastreo, consulta Definiciones de rastreo.

Activar el almacenamiento de registros

Para habilitar el registro, haz lo siguiente:

  1. Añada el objeto cloud_logging a la configuración.
  2. Añade un patrón a client_rpc_events o a server_rpc_events (o a ambos) para especificar el conjunto de servicios o métodos para los que quieras generar registros de eventos a nivel de transporte, así como el número de bytes que quieras registrar para los encabezados y los mensajes.

Para obtener más información sobre el registro, consulta Definiciones de registros.

Ejemplo de variable de entorno

En el siguiente ejemplo se definen las variables de observabilidad en la variable de entorno GRPC_GCP_OBSERVABILITY_CONFIG:

export GRPC_GCP_OBSERVABILITY_CONFIG='{
     "project_id": "your-project-here",
     "cloud_logging": {
         "client_rpc_events": [
         {
             "methods": ["google.pubsub.v1.Subscriber/Acknowledge", "google.pubsub.v1.Publisher/CreateTopic"],
             "exclude": true
         },
         {
             "methods": ["google.pubsub.v1.Subscriber/*", "google.pubsub.v1.Publisher/*"],
             "max_metadata_bytes": 4096,
             "max_message_bytes": 4096
         }],
         "server_rpc_events": [{
             "methods": ["*"],
             "max_metadata_bytes": 4096,
             "max_message_bytes": 4096
         }],
     },
     "cloud_monitoring": {},
     "cloud_trace": {
         "sampling_rate": 1.00
     },
     "labels": {
         "SOURCE_VERSION": "J2e1Cf",
         "SERVICE_NAME": "payment-service-1Cf",
         "DATA_CENTER": "us-west1-a"
     }
}'

Crear el ejemplo de observabilidad

Sigue estas instrucciones para crear una instancia de VM de Compute Engine y conectarte a ella. Después, configura el ejemplo de observabilidad.

  1. Crea una instancia de VM:

    gcloud compute instances create grpc-observability-vm \
  --image-family=debian-11 \
  --image-project=debian-cloud \
  --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

  2. Conéctate a la instancia de VM:

    gcloud compute ssh --project=PROJECT_ID grpc-observability-vm

Sigue las instrucciones de Java, C++ o Go, según el lenguaje de tus aplicaciones gRPC.

Java

  1. Después de conectarte a la instancia de VM, asegúrate de que tienes instalado Java 8 o una versión posterior.

    sudo apt update
sudo apt upgrade
sudo apt install git
sudo apt-get install -y openjdk-11-jdk-headless

  2. Clona el repositorio grpc-java.

    export EXAMPLES_VERSION=v1.54.1
git clone -b $EXAMPLES_VERSION --single-branch --depth=1 \
https://github.com/grpc/grpc-java.git

  3. Ve al directorio de ejemplos.

    cd grpc-java/examples/example-gcp-observability

  4. En el directorio de ejemplos, abre el archivo README y sigue las instrucciones que se indican en él.

  5. Cuando las instrucciones te indiquen que abras otra ventana de terminal, introduce este comando:

    gcloud compute ssh --project=PROJECT_ID grpc-observability-vm

C++

  1. Después de conectarte a la instancia de VM, ejecuta un archivo binario del servidor hello-world en una ventana de terminal.

    sudo apt-get update -y
sudo apt-get install -y git build-essential clang
git clone -b v1.54.0 https://github.com/grpc/grpc.git --depth=1
cd grpc
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
export GRPC_GCP_OBSERVABILITY_CONFIG_FILE="$(pwd)/examples/cpp/gcp_observability/helloworld/server_config.json"
tools/bazel run examples/cpp/gcp_observability/helloworld:greeter_server

  2. En otra ventana de terminal, vuelve a conectarte a la máquina virtual mediante SSH y, a continuación, ejecuta los siguientes comandos, que ejecutan el archivo binario del cliente hello-world.

    cd grpc
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
export GRPC_GCP_OBSERVABILITY_CONFIG_FILE="$(pwd)/examples/cpp/gcp_observability/helloworld/client_config.json"
tools/bazel run examples/cpp/gcp_observability/helloworld:greeter_client

Go

  1. Asegúrate de que tienes instalado Go.

    sudo apt-get install -y git
sudo apt install wget
wget https://go.dev/dl/go1.20.2.linux-amd64.tar.gz
sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf \
go1.20.2.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin

  2. Clona los ejemplos de gRPC-Go.

    git clone https://github.com/grpc/grpc-go.git
cd grpc-go/
git checkout -b run-observability-example
875c97a94dca8093bf01ff2fef490fbdd576373d

  3. Ve al clon del directorio gRPC-Go:

    cd examples/features/observability

  4. Ejecuta el servidor.

    export GRPC_GCP_OBSERVABILITY_CONFIG_FILE=./server/serverConfig.json
go run ./server/main.go

  5. En otra ventana de terminal, ejecuta los siguientes comandos.

    export PATH=$PATH:/usr/local/go/bin
cd grpc-go/examples/features/observability
export GRPC_GCP_OBSERVABILITY_CONFIG_FILE=./client/clientConfig.json
go run ./client/main.go

Ver trazas, métricas y entradas de registro

Sigue las instrucciones de esta sección para ver trazas, métricas y entradas de registro.

Ver trazas en Cloud Trace

Después de configurar los ejemplos o de instrumentar tus cargas de trabajo, deberías ver las trazas generadas por tus clientes y servidores gRPC en la consolaGoogle Cloud , que se mostrarán como trazas recientes.

Lista de rastreo de observabilidad de microservicios.
Lista de trazas de observabilidad de microservicios (haz clic en la imagen para ampliarla)

Ver registros de trazas

Si habilitas tanto el registro como el seguimiento, puedes ver las entradas de registro de las trazas junto con el gráfico de cascada de Cloud Trace o en el Explorador de registros.

Ver métricas en el panel de control

La observabilidad de microservicios proporciona un panel de control de monitorización llamado Monitorización de microservicios (gRPC) para las métricas definidas en Definiciones de métricas. El panel de control se muestra en la consola solo cuando la API Microservices está habilitada. Google Cloud La consola Google Cloud llama a la API Service Usage para verificar si la API Microservices está habilitada en un proyecto. El usuario debe tener el permiso serviceusage.services.list para ver el panel de control.

El panel de control Monitorización de microservicios (gRPC) es un Google Cloud panel de control y no puedes modificarlo directamente. Para personalizar el panel de control, debes copiarlo en un panel de control personalizado. Después, puedes actualizar el panel de control personalizado, por ejemplo, añadiendo, eliminando o reorganizando los gráficos.

Ver métricas en el explorador de métricas

Después de configurar el ejemplo de gRPC o de instrumentar tu carga de trabajo, deberías ver las métricas generadas por tus clientes y servidores gRPC en laGoogle Cloud consola.

Para ver y representar métricas en gráficos, sigue las instrucciones de la sección Seleccionar métricas al utilizar el explorador de métricas.

Inspeccionar entradas de registro en el explorador de registros

Las consultas sugeridas son una función de Cloud Logging que Google Cloudsugiere un conjunto de consultas basadas en los registros insertados. Puedes hacer clic en los filtros preparados y usarlos.

Consultas sugeridas en el explorador de registros.
Consultas sugeridas en el Explorador de registros. (haz clic para ampliar)

Una vez que las entradas de registro que coinciden con las consultas sugeridas aparezcan en Cloud Logging, verás nuevas consultas sugeridas en aproximadamente 6 minutos. En la mayoría de los casos, verás las nuevas consultas sugeridas antes. Si hay entradas de registro que coinciden con una sugerencia en los últimos 15 minutos, las consultas sugeridas seguirán mostrándose. Seguirán apareciendo como sugerencia hasta que no haya ninguna entrada de registro coincidente en los 15 minutos anteriores.

Puedes crear consultas personalizadas. Consulta las instrucciones en la guía del lenguaje de consulta de registros. Por ejemplo, en el panel Consulta del Explorador de registros, puedes intentar mostrar todos los registros de depuración de gRPC con el siguiente código:

log_id("microservices.googleapis.com/observability/grpc")

Puedes usar todos los campos del registro de gRPC para filtrar. A continuación, se muestra un ejemplo de entrada de registro:

{
  "insertId": "17kh8vafzuruci",
  "jsonPayload": {
    "authority": "10.84.1.15:50051",
    "sequenceId": "6",
    "serviceName": "helloworld.Greeter",
    "peer": {
      "ipPort": 50051,
      "address": "10.84.1.10",
      "type": "IPV4"
    },
    "callId": "d9577780-c608-4bff-9e12-4d9cdea6b298",
    "type": "SERVER_TRAILER",
    "methodName": "SayHello",
    "payload": {},
    "logger": "CLIENT"
  },
  "resource": {
    "type": "k8s_container",
    "labels": {
      "pod_name": "grpc-client-deployment-155-6967959544-x8ndr",
      "container_name": "grpc-client-container-155",
      "cluster_name": "o11y-cluster",
      "namespace_name": "grpc-client-namespace-155",
      "location": "us-west1-b",
      "project_id": "grpc-greeter"
    }
  },
  "timestamp": "2023-04-05T23:33:41.718523Z",
  "severity": "DEBUG",
  "labels": {
    "environment": "example-client"
  },
  "logName": "projects/grpc-greeter/logs/microservices.googleapis.com%2Fobservability%2Fgrpc",
  "receiveTimestamp": "2023-04-05T23:33:42.712682457Z"
}

Consultas sugeridas

La observabilidad de microservicios proporciona las siguientes consultas sugeridas a Cloud Logging:

Registros de encabezado o tráiler de gRPCs

Esta consulta ofrece una vista básica de las llamadas a procedimientos remotos, que proporciona información de los pares y resultados de las llamadas a procedimientos remotos.

log_id("microservices.googleapis.com/observability/grpc") AND
jsonPayload.type=("CLIENT_HEADER" OR "SERVER_TRAILER")

Llamadas gRPC fallidas

Esta consulta busca las llamadas a procedimientos remotos que terminan con un estado distinto de OK.

log_id("microservices.googleapis.com/observability/grpc") AND
jsonPayload.type="SERVER_TRAILER" AND
jsonPayload.payload.statusCode!="OK"

Registros de los gRPCs cancelados o con plazos superados

Si se cancelan demasiadas solicitudes de gRPC o se supera el plazo, se puede obtener información útil sobre la pérdida de rendimiento o el comportamiento inesperado de la aplicación.

log_id("microservices.googleapis.com/observability/grpc") AND
((jsonPayload.type="SERVER_TRAILER" AND jsonPayload.payload.statusCode=("CANCELLED" OR "DEADLINE_EXCEEDED")) OR (jsonPayload.type="CANCEL"))

Usar registros y seguimiento para solucionar problemas

Si ves un evento de RPC que indica un comportamiento incorrecto, puedes encontrar el callid en el evento. Utilice la siguiente consulta para mostrar todos los eventos que se han producido en una llamada a procedimiento remoto, independientemente de si se trata de una llamada a procedimiento remoto unaria o de streaming. Se usa la entrada de registro anterior como ejemplo:

log_id("microservices.googleapis.com/observability/grpc")
jsonPayload.callid="a358c7b80-3548-4bc8-a33f-b93ba1514904"

Para determinar el alcance del problema, puede buscar todos los eventos de RPC del mismo método o ubicación. La siguiente consulta muestra todos los registros de depuración relacionados con un método RPC específico. En este ejemplo, se usa el servicio Greeter:

log_id("microservices.googleapis.com/observability/grpc")
jsonPayload.serviceName="helloworld.Greeter"
jsonPayload.methodName="SayHello"

Para comprobar las llamadas a RPC fallidas de un código de estado específico, puede añadir el código de estado como una de las condiciones de filtrado. La siguiente consulta muestra los eventos de tráiler que terminan con un estado distinto de OK:

log_id("microservices.googleapis.com/observability/grpc")
jsonPayload.payload.statusCode!="OK"
Resultados de la consulta: código de estado de tiempo de espera superado.
Resultados de la consulta: código de estado de plazo superado (haz clic para ampliar)

Opciones de observabilidad

La observabilidad de los microservicios incluye las siguientes funciones opcionales.

Definir etiquetas personalizadas

Puedes definir etiquetas personalizadas, que añaden información proporcionada por los usuarios a los datos de observabilidad. Las etiquetas personalizadas constan de pares clave-valor. Cada par clave-valor se adjunta a los datos de seguimiento como etiquetas de intervalo, a los datos de métricas como etiquetas de métrica y a los datos de registro como etiquetas de entrada de registro.

Las etiquetas personalizadas se definen en la configuración con una lista de pares clave-valor en el campo labels. Todas las claves y los valores de las etiquetas personalizadas son del tipo STRING. La implementación lee la configuración y crea una etiqueta independiente para cada par clave-valor. Después, adjunta las etiquetas a los datos de observabilidad.

Por ejemplo, esta es una definición de etiqueta:

"labels": {
    "DATACENTER": "SAN_JOSE_DC",
    "APP_ID": "24512"
  }

Cada entrada de registro tiene las siguientes etiquetas adicionales:

{
   "DATACENTER" : "SAN_JOSE_DC"
   "APP_ID" : "24512"
}
Consultar etiquetas en una entrada de registro.
Consultar etiquetas en una entrada de registro (haz clic en la imagen para ampliarla)
Gráfico de líneas que muestra etiquetas personalizadas y de recursos.
Gráfico de líneas que muestra etiquetas personalizadas y de recursos (haz clic en la imagen para ampliarla)

Habilitar el registro de cargas útiles

Para habilitar el registro de cargas útiles, debe proporcionar las variables de entorno a la carga de trabajo. Para activar el registro de cargas útiles de los mensajes y encabezados de HelloWorld, actualiza el valor de los archivos de configuración gcp_observability_server_config.json, gcp_observability_client_config.json o ambos en los ejemplos de gRPC de la siguiente manera:

{
   "cloud_monitoring":{
   },
   "cloud_trace":{
      "sampling_rate":1.0
   },
   "cloud_logging":{
      "client_rpc_events":[
         {
            "methods":[
               "helloworld.Greeter/*"
            ],
            "max_metadata_bytes":4096,
            "max_message_bytes":4096
         }
      ],
      "server_rpc_events":[
         {
            "methods":[
               "helloworld.Greeter/*"
            ],
            "max_metadata_bytes":4096,
            "max_message_bytes":4096
         }
      ]
   }
}

Configurar la observabilidad entre proyectos

Puedes definir el proyecto de destino de forma explícita mediante la configuración definida en la variable de entorno GRPC_GCP_OBSERVABILITY_CONFIG. Para la observabilidad entre proyectos, también debes definir los permisos de cuenta de servicio adecuados. Si el ID del proyecto de destino es core-platform-stats, puedes configurar la observabilidad entre proyectos con la siguiente configuración de ejemplo:

{
   "project_id":"core-platform-stats",
   "cloud_monitoring":{
   },
   "cloud_trace":{
      "sampling_rate":1.0
   },
   "cloud_logging":{
      "client_rpc_events":[
         {
            "methods":[
               "helloworld.Greeter/*"
            ]
         }
      ],
      "server_rpc_events":[
         {
            "methods":[
               "helloworld.Greeter/*"
            ]
         }
      ]
   }
}

Estimar el volumen de registros

En esta sección se proporciona información que puede usar para estimar el volumen de ingesta de registros. Puedes hacer una estimación antes de suscribirte a los eventos de RPC de tus servicios.

Elemento Detalle
Eventos generados para una llamada unaria OK 6 eventos

Una llamada unaria correcta a un RPC genera los 6 eventos siguientes para el cliente o el servidor:

  • CLIENT_HEADER
  • SERVER_HEADER
  • CLIENT_MESSAGE
  • SERVER_MESSAGE
  • CLIENT_HALF_CLOSE
  • SERVER_TRAILER
Tamaño medio de la entrada de registro 500 bytes de forma predeterminada

Una entrada de registro se asigna a un evento RPC. El evento RPC incluye la información de depuración detallada de ese evento, las etiquetas de recursos y las etiquetas personalizadas.
Tamaño de registro de la carga útil 0 de forma predeterminada, se puede configurar

El tamaño máximo de la carga útil se puede configurar en la configuración de observabilidad. De forma predeterminada, no se registra ninguna carga útil.
Tamaño de las etiquetas personalizadas 0 de forma predeterminada, se puede configurar

Las etiquetas personalizadas se proporcionan a la aplicación mediante variables de entorno. Si no se especifica ninguna, no habrá etiquetas personalizadas

Fórmula para calcular el tamaño total de la ingestión de registros al mes:

Monthly Log Ingestion = QPS * 6 * (500B + Payload Logging Size + Custom Labels Size) * 2592000

Por ejemplo, si las consultas por segundo de un método de llamada unario son 1 y no hay funciones adicionales habilitadas, el tamaño de ingestión de registros estimado es de aproximadamente 7,24 GiB.

Siguientes pasos