Configura la observabilidad de microservicios

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

Antes de comenzar

La observabilidad de los microservicios funciona con cualquier implementación a la que se le haya otorgado permiso para acceder a Cloud Monitoring, Cloud Logging y Cloud Trace mediante la habilitación de la API de microservicios. En esta guía, se proporciona una configuración de muestra de observabilidad de microservicios mediante un ejemplo de Compute Engine.

En un alto nivel, puedes seguir los siguientes pasos:

  1. Como desarrollador de servicios, puedes habilitar y controlar el complemento de observabilidad de microservicios.
  2. Como operador de servicios, puedes consumir los datos recopilados de varias maneras.

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. Lee la descripción general de la observabilidad de microservicios.
  2. Asegúrate de tener un proyecto existente o crea uno nuevo.
  3. Asegúrate de tener una cuenta de servicio existente o crea una nueva.
  4. Lee sobre las dos variables de entorno compatibles, decide cuál usar y determina los valores que requiere la variable de entorno.
  5. Habilita la API de microservicios.

Elige una variable de entorno de configuración

Cuando aceptas el complemento de observabilidad de microservicios, que se describe en Instrumenta tus aplicaciones para el complemento de observabilidad, debes proporcionar la información de configuración mediante una variable de entorno. De forma predeterminada, no hay ninguna función de observabilidad habilitada. Configura la variable de entorno en la VM o contenedor en el que se ejecuta la aplicación o carga de trabajo de gRPC.

Las siguientes son las variables de entorno:

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

Si se configuran 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 de gRPC. No puedes configurar o ver los valores de las variables de entorno en la consola de Google Cloud.

En la configuración, puedes establecer un proyecto de destino al que se suben los datos de registro, seguimiento y métricas. Configura el ID del proyecto en el campo project_id.

Usa la información de Datos de configuración para establecer los valores en la variable de entorno que elijas.

Habilita la API de microservicios

Puedes usar la CLI de Google Cloud o la consola para habilitar la API de microservicios en tus proyectos. La habilitación de la API de microservicios de forma automática habilita de forma automática la API de Cloud Logging, la API de Cloud Monitoring y la API de Cloud Trace.

Para habilitar la API, sigue estos pasos:

gcloud services enable microservices.googleapis.com

Configurar permisos de la cuenta de servicio

Si usas una cuenta de servicio no predeterminada, otorga los permisos necesarios para la cuenta de servicio. Configura los siguientes valores:

  • PROJECT_ID: Reemplaza tu ID del 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

Instrumenta tus aplicaciones para el complemento de observabilidad

Si deseas instrumentar tus aplicaciones a fin de que puedan usar el complemento de observabilidad de microservicios, usa las siguientes instrucciones para C++, Java y Go.

C++

Puedes usar C++ con observabilidad de microservicios a partir de gRPC C++ v1.54. El repositorio de ejemplo está en GitHub.

Cambios en la compilación

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

Cambios de código obligatorios

Para habilitar la observabilidad de los microservicios, se requiere una dependencia adicional (un módulo de observabilidad) y el siguiente código cambia a servidores, clientes de gRPC existentes o ambos:

#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 cualquier operación de gRPC, incluida la creación de un canal, un servidor o credenciales, invoca lo siguiente:

grpc::GcpObservability::Init();

Esto muestra absl::StatusOr<GcpObservability>, que se debe guardar. El estado ayuda a determinar si la observabilidad se inicializó de forma correcta. El objeto GcpObservability adjunto controla la vida útil de la observabilidad y cierra y limpia de forma automática los datos de observabilidad cuando quedan fuera del alcance.

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 de Go, la habilitación de la observabilidad de los microservicios requiere 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 exportadores según corresponda e incorpora la lógica de recopilación en las conexiones de clientes y servidores creados después de la llamada. La llamada diferida observability.End limpia los recursos y garantiza que se limpien los datos almacenados en búfer antes de que se cierre la aplicación.

Después de actualizar el código de la aplicación, ejecuta el siguiente comando para actualizar el archivo go.mod.

go mod tidy

Java

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

En los fragmentos de compilación en las secciones de la herramienta de compilación de Gradle y Maven, grpcVersion se establece en el valor 1.54.1.

El repositorio de ejemplo está en GitHub.

Cambios de código Java obligatorios

A fin de instrumentar con éxito tus aplicaciones de Java para la observabilidad de los microservicios, agrega 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 que se cree cualquier canal o servidor de gRPC. La función GcpObservability.grpcInit() lee la configuración de observabilidad de microservicios y la usa para configurar los interceptores y rastreadores globales necesarios para la funcionalidad de registro, métricas y seguimiento en cada canal y servidor creado. GcpObservability.grpcInit() tiene protección de subprocesos y debe llamarse exactamente una vez. Muestra una instancia de GcpObservability que debes guardar para llamar a close() más tarde.

GcpObservability.close() desasigna recursos. Cualquier canal o servidor creado después no realiza ningún registro.

GcpObservability implementa java.lang.AutoCloseable, que se cierra de forma automática si usas try-with-resource 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
...
}

Usa la herramienta de compilación de Gradle

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

def grpcVersion = '1.54.1'

...

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

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

Si usas la herramienta de compilación de 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>

Habilita la recopilación, el registro y la recopilación de datos de métricas

Las siguientes secciones contienen instrucciones para habilitar la recopilación de datos en tu configuración y un ejemplo que muestra la información de configuración en una variable de entorno.

Habilita métricas

Para habilitar las métricas, agrega el objeto cloud_monitoring a la configuración y establece su valor en {}.

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

Habilita el seguimiento

Si planeas habilitar el seguimiento en los servicios, asegúrate de que los servicios admitan la propagación del contexto de seguimiento recibido del ascendente (o iniciado por sí mismo) al descendente.

Para habilitar el seguimiento, haz lo siguiente:

  1. Agrega el objeto cloud_trace a la configuración.
  2. Establece cloud_trace.sampling_rate en una probabilidad que desees que tu aplicación observe para iniciar seguimientos nuevos.
    • Por ejemplo, 1.0 significa hacer un seguimiento de cada RPC.
    • 0.0 significa que no se inicia ningún seguimiento nuevo.
    • 0.5 significa que se hace un seguimiento del 50% de las RPC de forma aleatoria.

Si se toma una decisión de muestreo positiva, tus servicios suben intervalos sin importar la configuración de la tasa de muestreo.

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

Habilitar registro

Para habilitar el registro, haz lo siguiente:

  1. Agrega el objeto cloud_logging a la configuración.
  2. Agrega un patrón a client_rpc_events o server_rpc_events, que especifique el conjunto de servicios o métodos para los que deseas generar registros de eventos a nivel de transporte y la cantidad de bytes que se registrarán para los encabezados y mensajes.

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

Ejemplo de variable de entorno

En el siguiente ejemplo, se establecen 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"
     }
}'

Crea el ejemplo de observabilidad

Usa estas instrucciones para crear una instancia de VM de Compute Engine y conectarte a ella y, luego, configurar el ejemplo de observabilidad.

  1. Cree 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. Conectarte a la instancia de VM:

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

Continúa con las instrucciones para Java, C++ o Go, según el lenguaje de tus aplicaciones de gRPC.

Java

  1. Después de conectarte a la instancia de VM, asegúrate de tener 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 del archivo.

  5. Cuando las instrucciones te indiquen abrir otra ventana de la terminal, ejecuta este comando:

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

C++

  1. Después de conectarte a la instancia de VM, ejecuta un objeto binario del servidor hello-world en una ventana de la 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. Desde otra ventana de terminal, conéctate a la VM de nuevo mediante SSH y, luego, ejecuta los siguientes comandos, que ejecutan el objeto binario de 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 tener 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 a la clonación 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 una ventana de la terminal diferente, 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
    

Visualiza seguimientos, métricas y entradas de registro

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

Ve los seguimientos en Cloud Trace

Después de configurar los ejemplos o instrumentar tus cargas de trabajo, deberías ver que se generaron seguimientos de tus clientes de gRPC y servidores de gRPC en la consola de Google Cloud como seguimientos recientes.

Lista de seguimientos de observabilidad de microservicios.
Lista de seguimiento de observabilidad de microservicios (haz clic para ampliar)

Visualiza registros de seguimientos

Si habilitas el registro y el seguimiento, puedes ver las entradas de registro de los seguimientos junto con el gráfico de cascada de Cloud Trace o en el explorador de registros.

Visualiza métricas en el panel

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

El panel de Supervisión de microservicios (gRPC) es un panel de Google Cloud Platform y no puedes modificarlo directamente. Para personalizar el panel, debes copiar el panel en un panel personalizado. Luego, puedes actualizar el panel personalizado, por ejemplo, agregando, borrando o reorganizando los gráficos.

Consulta métricas en el Explorador de métricas

Después de configurar el ejemplo de gRPC o instrumentar tu carga de trabajo, deberías ver las métricas que generan tus clientes de gRPC y los servidores de gRPC en la consola de Google Cloud.

Para ver y representar métricas, usa las instrucciones en Selecciona métricas cuando uses el Explorador de métricas.

Inspecciona entradas de registro en el Explorador de registros

La consulta sugerida es una función de Cloud Logging en la que Google Cloud sugiere un conjunto de consultas basadas en los registros transferidos. Puedes hacer clic y usar los filtros preparados.

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

Después de que las entradas de registro que coinciden con las consultas sugeridas aparezcan en Cloud Logging, deberías ver nuevas consultas en aproximadamente 6 minutos. En la mayoría de los casos, verás nuevas consultas sugeridas más pronto. Si hay entradas de registro que coincidan con una sugerencia en los últimos 15 minutos, se seguirán mostrando las consultas sugeridas. Aparecen como sugerencias hasta que no haya habido entradas de registro que coincidan en los últimos 15 minutos.

Puedes crear consultas personalizadas. Consulta la guía de lenguaje de consulta de Logging para obtener instrucciones. 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 una entrada de registro de ejemplo:

{
  "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 los microservicios proporciona las siguientes consultas sugeridas a Cloud Logging:

Registros o encabezados de registro para gRPC

Esta consulta proporciona una vista básica de RPC, que genera información de par y resultados de RPC.

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

Llamadas a gRPC con errores

Esta consulta busca los RPC 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 gRPC cancelados o excedidos

La cancelación excesiva de gRPC o incumplimientos de plazos puede proporcionar 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"))

Usa los registros y el seguimiento para solucionar problemas

Si ves un evento de RPC que indica un comportamiento incorrecto, puedes encontrar el callid en el evento. Usa la siguiente consulta para mostrar todos los eventos que ocurrieron en una RPC, sin importar si es una RPC unaria o de transmisión. La entrada de registro anterior se usa como ejemplo:

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

A fin de determinar el alcance del problema, puedes encontrar todos los eventos de RPC para el mismo método o ubicación. La siguiente consulta muestra todos los registros de depuración relacionados con un método de RPC específico, mediante el servicio Greeter como ejemplo:

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

Para verificar las RPC con errores de un código de estado específico, puedes agregar el código de estado como una de las condiciones de filtrado. La siguiente consulta muestra los eventos de finalización que terminan con un estado de error distinto de OK:

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

Opciones de observabilidad

La observabilidad de los microservicios incluye las siguientes funciones opcionales.

Define etiquetas personalizadas

Puedes definir etiquetas personalizadas, que agregan información proporcionada por el usuario a los datos de observabilidad. Las etiquetas personalizadas consisten en 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. Todos los valores y claves de etiquetas personalizadas son del tipo STRING. La implementación lee la configuración y crea una etiqueta distinta para cada par clave-valor y, luego, 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"
}
Consulta etiquetas en una entrada de registro.
Consulta etiquetas en una entrada de registro (haz clic para ampliar)
Gráfico de líneas en el que se muestran etiquetas personalizadas y de recursos.
Gráfico de líneas en el que se muestran las etiquetas personalizadas y de recursos (haz clic para ampliar)

Habilita el registro de carga útil

Puedes habilitar el registro de carga útil mediante las variables de entorno que proporcionas a la carga de trabajo. A fin de activar el registro de carga útil para los encabezados y los mensajes 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
         }
      ]
   }
}

Configura la observabilidad entre proyectos

Puedes establecer el proyecto de destino de forma explícita mediante la configuración establecida en la variable de entorno GRPC_GCP_OBSERVABILITY_CONFIG. Para la observabilidad entre proyectos, también debes establecer los permisos de la cuenta de servicio adecuados. Si suponemos que 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/*"
            ]
         }
      ]
   }
}

Volumen de registros estimado

En esta sección se brinda información que puedes usar para estimar el volumen de transferencia de registros de manera opcional. Puedes realizar 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 RPC de llamada unaria OK genera los siguientes 6 eventos para el cliente o servidor:

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

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

El tamaño máximo de la carga útil se puede establecer en la configuración de observabilidad. De forma predeterminada, no se registra ninguna carga útil.
Tamaño de 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 transferencia de registros por mes:

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

Por ejemplo, si las QPS de un método de llamada unario son 1 y no hay funciones adicionales habilitadas, el tamaño estimado de la transferencia de registros es de alrededor de 7.24 GiB.

¿Qué sigue?