Se usó la API de Cloud Translation para traducir esta página.

Configura una aplicación de gRPC en Google Cloud con observabilidad de microservicios

Las herramientas de observabilidad de microservicios permiten instrumentar aplicaciones para recopilar y presentar datos de telemetría en Cloud Monitoring, Cloud Logging y Cloud Trace desde cargas de trabajo de gRPC implementadas en Google Cloud y en otros lugares. La observabilidad de los microservicios funciona con cualquier implementación a la que se le haya otorgado permiso para acceder a Monitoring, Logging y Trace habilitando la API de microservicios.

En este instructivo, aprenderás a usar las funciones de observabilidad de microservicios. Para esto, debes crear una aplicación sencilla de gRPC en Google Cloud con Compute Engine y, además, instrumentarla con la observabilidad de microservicios. Luego, verás cómo funcionan con Monitoring y Logging.

Crea una VM de Compute Engine y conéctate a ella

Usa estas instrucciones para crear una instancia de VM de Compute Engine y conectarte a ella. En la VM, implementa la aplicación y, luego, instruméntala con la observabilidad de microservicios.

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

Conéctate a la instancia de VM.

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

Implementa la aplicación en la VM de Compute Engine

Puedes implementar una aplicación de tu elección en la VM de Compute Engine que creaste en el paso anterior y, luego, omitir este paso. De lo contrario, puedes usar un ejemplo para continuar con instrucciones en tu lenguaje de preferencia.

C++

Luego de conectarte a la instancia de VM, ejecuta el siguiente comando.

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

Go

Asegúrate de tener Go instalado.

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 gRPC-Go.

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

Java

Luego 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

Crea el archivo de configuración de observabilidad de gRPC Google Cloud

Necesitas un archivo de configuración de observabilidad de gRPC Google Cloud independiente para habilitar la observabilidad de microservicios para el servidor y el cliente. La ubicación de este archivo se exporta como GRPC_GCP_OBSERVABILITY_CONFIG_FILE en los pasos siguientes. Usa las siguientes instrucciones para configurar los distintos parámetros en el archivo de configuración.

Ejemplo `GRPC_GCP_OBSERVABILITY_CONFIG_FILE`

{
  "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": 0.5,
  }
  "labels": {
    "SOURCE_VERSION": "J2e1Cf",
    "SERVICE_NAME": "payment-service-1Cf",
    "DATA_CENTER": "us-west1-a"
  }
}

Las siguientes secciones incluyen instrucciones para habilitar la recopilación de datos en la configuración de los componentes individuales. Si usaste el ejemplo de gRPC en este instructivo, puedes usar esta configuración tal como está (luego de actualizar your-project-here) o usarla como plantilla para la aplicación y un ejemplo en el que se muestran los pasos de configuración en una variable de entorno.

Habilita las 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 métricas.

Habilita el seguimiento

Para habilitar el seguimiento, haz lo siguiente:

Agrega el objeto cloud_trace a la configuración.
Establece la cloud_trace.sampling_rate en 0.5, que realiza un seguimiento aleatorio del 50% de las RPC.

Si planeas habilitar el seguimiento entre servicios, asegúrate de que admitan la propagación del contexto de seguimiento recibido en sentido upstream (o iniciado por sí mismo) a downstream.

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

Habilita el registro

Para habilitar el registro, haz lo siguiente:

Agrega el objeto cloud_logging a la configuración.
Agrega un patrón a client_rpc_events o server_rpc_events, o bien a ambos, que especifique el conjunto de servicios o métodos para los que quieres 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.

Instrumenta las aplicaciones para el complemento de observabilidad

Si quieres instrumentar las aplicaciones con el objetivo de que puedan usar el complemento de observabilidad de microservicios, sigue las instrucciones que se indican a continuación para tu lenguaje de preferencia.

C++

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

La asistencia de observabilidad solo está disponible a través del sistema de compilación de Bazel. Agrega el grpcpp_gcp_observability objetivo como una dependencia.
Para habilitar la observabilidad de microservicios, se requiere una dependencia adicional (un módulo de observabilidad). Además, el siguiente código cambia a servidores y 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 realizar 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 determina si la observabilidad se inicializó de forma correcta. El objeto GcpObservability adjunto controla la vida útil de la observabilidad y, además, cierra y limpia automáticamente 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, habilitar la observabilidad de 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 y, además, incorpora la lógica de recopilación en las conexiones de clientes y en servidores creados luego 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.

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

go mod tidy

Java

Si debes usar la observabilidad de microservicios con aplicaciones de Java, modifica la 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 de 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.

Para instrumentar con éxito las aplicaciones de Java para la observabilidad de 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 ajustar 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. Devuelve una instancia de GcpObservability, la cual debes guardar para poder llamar a close() más tarde.

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

GcpObservability implementa java.lang.AutoCloseable, que se cierra automáticamente 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>

Ejecutar la aplicación

Sigue las instrucciones de esta sección solo si usaste el ejemplo de gRPC para el instructivo. Puedes modificar el comando run para orientar el objeto binario de la aplicación.

Ejecuta el servidor

C++

Crea una sesión SSH en la VM.

Exporta variables de entorno. Sigue los pasos definidos más arriba para crear server_config.json.

  export GOOGLE_CLOUD_PROJECT=$PROJECT_ID
  export GRPC_GCP_OBSERVABILITY_CONFIG_FILE="$(pwd)/examples/cpp/gcp_observability/helloworld/server_config.json"

Ejecuta la aplicación del servidor shell cd grpc tools/bazel run examples/cpp/gcp_observability/helloworld:greeter_server.

Go

Crea una sesión SSH en la VM.
Exporta variables de entorno. Sigue los pasos definidos más arriba para crear server_config.json.
```
export GRPC_GCP_OBSERVABILITY_CONFIG_FILE=./server/serverConfig.json
```
Ejecuta la aplicación del servidor shell go run ./server/main.go.

Java

En el directorio de ejemplos, abre el archivo README y sigue las instrucciones que contiene.
Cuando se te indique que debes abrir otra ventana de terminal, ejecuta este comando: shell gcloud compute ssh --project=$PROJECT_ID grpc-observability-vm

Ejecuta el cliente

C++

Crea otra sesión SSH en la VM.

Exporta variables de entorno. Sigue los pasos definidos más arriba para crear un archivo client_config.json.

  export GOOGLE_CLOUD_PROJECT=$PROJECT_ID
  export GRPC_GCP_OBSERVABILITY_CONFIG_FILE="$(pwd)/examples/cpp/gcp_observability/helloworld/client_config.json"

Ejecuta la aplicación cliente.

cd grpc
tools/bazel run examples/cpp/gcp_observability/helloworld:greeter_client

Go

Crea otra sesión SSH en la VM.
Exporta variables de entorno. Sigue los pasos definidos más arriba para crear un archivo client_config.json. shell export GRPC_GCP_OBSERVABILITY_CONFIG_FILE=./client/clientConfig.json

Ejecuta la aplicación cliente.

cd grpc-go/examples/features/observability
go run ./client/main.go

Java

En el directorio de ejemplos, abre el archivo README y sigue las instrucciones que contiene.
Cuando se te indique que debes abrir otra ventana de terminal, ejecuta este comando: shell gcloud compute ssh --project=$PROJECT_ID grpc-observability-vm

Configura una aplicación de gRPC en Google Cloud con observabilidad de microservicios Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Crea una VM de Compute Engine y conéctate a ella

Implementa la aplicación en la VM de Compute Engine

C++

Go

Java

Crea el archivo de configuración de observabilidad de gRPC Google Cloud

Ejemplo GRPC_GCP_OBSERVABILITY_CONFIG_FILE

Habilita las métricas

Habilita el seguimiento

Habilita el registro

Instrumenta las aplicaciones para el complemento de observabilidad

C++

Go

Java

Usa la herramienta de compilación de Gradle

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

Ejecutar la aplicación

Ejecuta el servidor

C++

Go

Java

Ejecuta el cliente

C++

Go

Java

Configura una aplicación de gRPC en Google Cloud con observabilidad de microservicios

Ejemplo `GRPC_GCP_OBSERVABILITY_CONFIG_FILE`