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:
- Como desarrollador de servicios, puedes habilitar y controlar el complemento de observabilidad de microservicios.
- 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:
- Lee la descripción general de la observabilidad de microservicios.
- Asegúrate de tener un proyecto existente o crea uno nuevo.
- Asegúrate de tener una cuenta de servicio existente o crea una nueva.
- Lee sobre las dos variables de entorno compatibles, decide cuál usar y determina los valores que requiere la variable de entorno.
- 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.
Si este campo se deja vacío, el complemento de observabilidad completa de forma automática el valor del ID del proyecto en función de las credenciales predeterminadas de la aplicación.
Si las credenciales predeterminadas de la aplicación no se pueden identificar y el campo
project_idestá vacío, el métodoINIT/STARTgenera o muestra un error en tu aplicación. La aplicación debe manejar el error.
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.
Comienza a usarlo
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:
- Agrega el objeto
cloud_tracea la configuración. - Establece
cloud_trace.sampling_rateen una probabilidad que desees que tu aplicación observe para iniciar seguimientos nuevos.- Por ejemplo,
1.0significa hacer un seguimiento de cada RPC. 0.0significa que no se inicia ningún seguimiento nuevo.0.5significa que se hace un seguimiento del 50% de las RPC de forma aleatoria.
- Por ejemplo,
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:
- Agrega el objeto
cloud_logginga la configuración. - Agrega un patrón a
client_rpc_eventsoserver_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.
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
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
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
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
Ve al directorio de ejemplos.
cd grpc-java/examples/example-gcp-observability
En el directorio de ejemplos, abre el archivo README y sigue las instrucciones del archivo.
Cuando las instrucciones te indiquen abrir otra ventana de la terminal, ejecuta este comando:
gcloud compute ssh --project=PROJECT_ID grpc-observability-vm
C++
Después de conectarte a la instancia de VM, ejecuta un objeto binario del servidor
hello-worlden 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
Desde otra ventana de la terminal, vuelve a conectarte a la VM con 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
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
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
Ve a la clonación del directorio
gRPC-Go:cd examples/features/observability
Ejecuta el servidor.
export GRPC_GCP_OBSERVABILITY_CONFIG_FILE=./server/serverConfig.json go run ./server/main.go
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.
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.
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"
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"
}
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 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:
|
| 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?
- Para obtener información detallada sobre datos de configuración, definiciones de seguimiento, definiciones de métricas y definiciones de registros, consulta la referencia de observabilidad de microservicios.