Configurare l'osservabilità dei microservizi

Questo documento contiene le informazioni necessarie per configurare il plug-in di osservabilità dei microservizi, instrumentare le applicazioni gRPC e ottenere informazioni da Cloud Monitoring, Cloud Logging e Cloud Trace.

Prima di iniziare

L'osservabilità dei microservizi funziona con qualsiasi deployment a cui sia stata concessa l'autorizzazione per accedere a Cloud Monitoring, Cloud Logging e Cloud Trace abilitando l'API Microservices. Questa guida fornisce un esempio di configurazione dell'osservabilità dei microservizi utilizzando un esempio di Compute Engine.

A livello generale, devi:

  1. In qualità di sviluppatore di servizi, puoi attivare e controllare il plug-in di osservabilità dei microservizi.
  2. In qualità di operatore di servizi, utilizzi i dati raccolti in vari modi.

I repository gRPC (C++, Go e Java) includono esempi per dimostrare l'osservabilità dei microservizi.

Prima di configurare l'osservabilità, completa le seguenti attività:

  1. Leggi la panoramica dell'osservabilità dei microservizi.
  2. Assicurati di avere un progetto esistente o creane uno nuovo.
  3. Assicurati di avere un account di servizio esistente o di crearne uno nuovo.
  4. Leggi informazioni sulle due variabili di ambiente supportate, decidi quale utilizzare e determina i valori richiesti dalla variabile di ambiente.
  5. Abilita l'API Microservices.

Scegliere una variabile di ambiente di configurazione

Quando attivi il plug-in di osservabilità dei microservizi, descritto in Strumentare le applicazioni per il plug-in di osservabilità, devi fornire le informazioni di configurazione utilizzando una variabile di ambiente. Per impostazione predefinita, non sono attive funzionalità di osservabilità. Imposta la variabile di ambiente sulla VM o sul container in cui è in esecuzione l'applicazione o il workload gRPC.

Di seguito sono riportate le variabili di ambiente:

  • GRPC_GCP_OBSERVABILITY_CONFIG_FILE: il valore è un percorso che punta a un file di configurazione con codifica JSON.
  • GRPC_GCP_OBSERVABILITY_CONFIG: il valore è il corpo della configurazione codificato in JSON.

Se vengono impostate entrambe le variabili di ambiente, GRPC_GCP_OBSERVABILITY_CONFIG_FILE ha la precedenza su GRPC_GCP_OBSERVABILITY_CONFIG.

Per applicare la configurazione, devi riavviare l'applicazione gRPC. Non puoi impostare o visualizzare i valori delle variabili di ambiente nella console Google Cloud .

Nella configurazione, puoi impostare un progetto di destinazione in cui vengono caricati i dati di logging, di tracciamento e delle metriche. L'ID progetto viene impostato nel campo project_id.

Utilizza le informazioni in Dati di configurazione per impostare i valori nella variabile di ambiente che scegli.

Abilitare l'API Microservices

Puoi utilizzare gcloud CLI o la console Google Cloud per abilitare l'API Microservices nei tuoi progetti. L'attivazione dell'API Microservices abilita automaticamente l'API Cloud Logging, l'API Cloud Monitoring e l&#3Cloud Trace APIce.

Per abilitare l'API:

gcloud services enable microservices.googleapis.com

Imposta le autorizzazioni del account di servizio

Se utilizzi un account di servizio non predefinito, concedi le autorizzazioni richieste per ilaccount di serviziot. Imposta i seguenti valori:

  • PROJECT_ID: sostituisci l'ID progetto.
  • SERVICE_ACCOUNT_NAME: Sostituisci il nome del account di servizio del tuo progetto.
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 le tue applicazioni per il plug-in di osservabilità

Per instrumentare le applicazioni in modo che possano utilizzare il plug-in di osservabilità dei microservizi, segui le istruzioni riportate di seguito per C++, Java e Go.

C++

Puoi utilizzare C++ con l'osservabilità dei microservizi a partire da gRPC C++ v1.54. Il repository di esempio si trova su GitHub.

Modifiche alla build

Il supporto dell'osservabilità è disponibile solo tramite il sistema di compilazione Bazel. Aggiungi la destinazione grpcpp_gcp_observability come dipendenza.

Modifiche al codice richieste

L'attivazione dell'osservabilità dei microservizi richiede una dipendenza aggiuntiva (un modulo di osservabilità) e le seguenti modifiche al codice dei client, dei server o di entrambi i client gRPC esistenti:

#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
}

Prima di qualsiasi operazione gRPC, inclusa la creazione di un canale, un server o credenziali, richiama quanto segue:

grpc::GcpObservability::Init();

Viene restituito absl::StatusOr<GcpObservability>, che deve essere salvato. Lo stato aiuta a determinare se l'osservabilità è stata inizializzata correttamente. L'oggetto GcpObservability associato controlla la durata dell'osservabilità e chiude e svuota automaticamente i dati di osservabilità quando escono dall'ambito.

Go

I plug-in di osservabilità dei microservizi sono supportati per gRPC Go versione v1.54.0 e successive. Il repository di esempio si trova in GitHub.

Con il modulo Go, l'attivazione dell'osservabilità dei microservizi richiede un modulo di osservabilità e il seguente codice:

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 chiamata observability.Start analizza la configurazione dalle variabili di ambiente, crea gli esportatori di conseguenza e inserisce la logica di raccolta nelle connessioni client e nei server creati dopo la chiamata. La chiamata observability.End differita pulisce le risorse e garantisce che i dati memorizzati nel buffer vengano scaricati prima della chiusura dell'applicazione.

Dopo aver aggiornato il codice dell'applicazione, esegui il comando seguente per aggiornare il file go.mod.

go mod tidy

Java

Per utilizzare l'osservabilità dei microservizi con le applicazioni Java, modifica la build in modo da includere l'artefatto grpc-gcp-observability. Utilizza gRPC versione 1.54.1 o successive.

Negli snippet di build nelle sezioni degli strumenti di build Gradle e Maven, grpcVersion è impostato sul valore 1.54.1.

Il repository di esempio si trova in GitHub.

Modifiche al codice Java richieste

Per instrumentare correttamente le applicazioni Java per l'osservabilità dei microservizi, aggiungi il seguente codice 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();
...
}

Tieni presente che devi chiamare GcpObservability.grpcInit() prima di creare canali o server gRPC. La funzione GcpObservability.grpcInit() legge la configurazione dell'osservabilità dei microservizi e la utilizza per configurare gli intercettori e i tracer globali necessari per la funzionalità di logging, metriche e trace in ogni canale e server creato. GcpObservability.grpcInit() è thread-safe e deve essere chiamato esattamente una volta. Restituisce un'istanza di GcpObservability che devi salvare per chiamare close() in un secondo momento.

GcpObservability.close() dealloca le risorse. I canali o i server creati successivamente non eseguono alcun logging.

GcpObservability implementa java.lang.AutoCloseable, che viene chiuso automaticamente se utilizzi try-with-resource nel seguente modo:

...
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
...
}

Utilizzare lo strumento di compilazione Gradle

Se utilizzi lo strumento di compilazione Gradle, includi quanto segue:

def grpcVersion = '1.54.1'

...

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

Utilizza lo strumento di compilazione Maven (pom.xml)

Se utilizzi lo strumento di compilazione Maven, includi quanto segue:

<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>

Abilitare la raccolta di dati di metriche, tracciamento e logging

Le sezioni seguenti contengono istruzioni per attivare la raccolta dei dati nella configurazione e un esempio che mostra le informazioni di configurazione in una variabile di ambiente.

Abilita metriche

Per attivare le metriche, aggiungi l'oggetto cloud_monitoring alla configurazione e imposta il relativo valore su {}.

Per ulteriori informazioni sulle metriche, consulta Definizioni delle metriche.

Abilita il tracciamento

Se prevedi di attivare la tracciabilità tra i servizi, assicurati che i servizi supportino la propagazione del contesto di traccia ricevuto dall'upstream (o avviato autonomamente) al downstream.

Per attivare la tracciabilità:

  1. Aggiungi l'oggetto cloud_trace alla configurazione.
  2. Imposta cloud_trace.sampling_rate su una probabilità che vuoi che la tua applicazione osservi per avviare nuove tracce.
    • Ad esempio, 1.0 significa tracciare ogni RPC.
    • 0.0 significa non avviare nuove tracce.
    • 0.5 significa che il 50% delle RPC viene tracciato in modo casuale.

Se viene presa una decisione di campionamento positiva a monte, i tuoi servizi caricano gli intervalli indipendentemente dall'impostazione della frequenza di campionamento.

Per saperne di più sulla tracciabilità, consulta Definizioni di traccia.

Abilita il logging

Per attivare la registrazione:

  1. Aggiungi l'oggetto cloud_logging alla configurazione.
  2. Aggiungi un pattern a client_rpc_events e/o server_rpc_events specificando l'insieme di servizi o metodi per i quali vuoi generare la registrazione degli eventi a livello di trasporto e il numero di byte da registrare per le intestazioni e i messaggi.

Per saperne di più sul logging, consulta Definizioni dei record di log.

Esempio di variabile di ambiente

L'esempio seguente imposta le variabili di osservabilità nella variabile di ambiente 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 l'esempio di osservabilità

Segui queste istruzioni per creare e connetterti a un'istanza VM di Compute Engine e poi configura l'esempio di osservabilità.

  1. Crea un'istanza 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. Connettiti all'istanza VM:

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

Continua con le istruzioni per Java, C++ o Go, a seconda del linguaggio delle tue applicazioni gRPC.

Java

  1. Dopo aver effettuato la connessione all'istanza VM, assicurati di aver installato Java 8 o versioni successive.

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

  2. Clona il repository 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. Vai alla directory degli esempi.

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

  4. Nella directory degli esempi, apri il file README e segui le istruzioni contenute nel file.

  5. Quando le istruzioni ti chiedono di aprire un'altra finestra del terminale, esegui questo comando:

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

C++

  1. Dopo aver effettuato la connessione all'istanza VM, esegui un binario del server hello-world in una finestra del terminale.

    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. Da un'altra finestra del terminale, connettiti di nuovo alla VM utilizzando SSH, quindi esegui i seguenti comandi, che eseguono il file binario del client 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. Assicurati di aver installato 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 gli esempi di gRPC-Go.

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

  3. Vai al clone della directory gRPC-Go:

    cd examples/features/observability

  4. Esegui il server.

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

  5. In una finestra del terminale separata, esegui questi comandi.

    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

Visualizza tracce, metriche e voci di log

Segui le istruzioni riportate in questa sezione per visualizzare tracce, metriche e voci di log.

Visualizzare le tracce in Cloud Trace

Dopo aver configurato gli esempi o instrumentato i carichi di lavoro, dovresti visualizzare le tracce generate dai client gRPC e dai server gRPC nella consoleGoogle Cloud elencate come tracce recenti.

Elenco delle tracce di osservabilità dei microservizi.
Elenco delle tracce di osservabilità dei microservizi (fai clic per ingrandire)

Visualizza i log per le tracce

Se abiliti sia la registrazione che la tracciabilità, puoi visualizzare le voci di log per le tracce insieme al grafico a cascata di Cloud Trace o in Esplora log.

Visualizzare le metriche nella dashboard

L'osservabilità dei microservizi fornisce una dashboard di monitoraggio chiamata Monitoraggio microservizi (gRPC) per le metriche definite in Definizioni delle metriche. La dashboard viene visualizzata nella console Google Cloud solo quando l'API Microservices è abilitata. La console Google Cloud chiama l'API Service Usage per verificare se l'API Microservices è abilitata in un progetto. L'utente deve disporre dell'autorizzazione serviceusage.services.list per visualizzare la dashboard.

La dashboard Monitoraggio dei microservizi (gRPC) è una dashboard Google Cloud e non puoi modificarla direttamente. Per personalizzare la dashboard, devi copiarla in una dashboard personalizzata. Puoi quindi aggiornare la dashboard personalizzata, ad esempio aggiungendo, eliminando o riorganizzando i grafici.

Visualizzare le metriche in Metrics Explorer

Dopo aver configurato l'esempio gRPC o instrumentato il carico di lavoro, dovresti visualizzare le metriche generate dai client e dai server gRPC nella consoleGoogle Cloud .

Per visualizzare e rappresentare graficamente le metriche, segui le istruzioni riportate in Selezionare le metriche durante l'utilizzo di Esplora metriche.

Ispezionare le voci di log in Esplora log

La query suggerita è una funzionalità di Cloud Logging in cui Google Cloud suggerisce un insieme di query in base ai log inseriti. Puoi fare clic e utilizzare i filtri preparati.

Query suggerite in Esplora log.
Query suggerite in Esplora log. (fai clic per ingrandire)

Dopo che le voci di log corrispondenti alle query suggerite vengono visualizzate in Cloud Logging, puoi aspettarti di vedere nuove query suggerite in circa 6 minuti. Nella maggior parte dei casi, i nuovi suggerimenti per le query vengono visualizzati prima. Se ci sono voci di log che corrispondono a un suggerimento nei 15 minuti precedenti, le query suggerite continuano a essere visualizzate. Continueranno a essere visualizzati come suggerimento finché non ci saranno voci di log corrispondenti nei 15 minuti precedenti.

Puoi creare query personalizzate. Per istruzioni, consulta la guida al linguaggio di query di Logging. Ad esempio, nel riquadro Query di Esplora log, puoi provare a mostrare tutti i log di debug gRPC con il seguente codice:

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

Puoi utilizzare tutti i campi nel record di log gRPC per il filtraggio. Ecco un esempio di voce di log:

{
  "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"
}

Query suggerite

L'osservabilità dei microservizi fornisce le seguenti query suggerite a Cloud Logging:

Record dei log di intestazione o trailer per gRPC

Questa query fornisce una visualizzazione di base delle chiamate RPC, restituendo informazioni sui peer e risultati RPC.

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

Chiamate gRPC non riuscite

Questa query trova le chiamate RPC che terminano con uno stato diverso da OK.

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

Record dei log per gRPC annullati o con scadenza superata

L'annullamento eccessivo di gRPC o il superamento del termine può fornire informazioni utili sulla perdita di prestazioni o sul comportamento imprevisto dell'applicazione.

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

Utilizzare i log e la tracciatura per la risoluzione dei problemi

Se visualizzi un evento RPC che indica prestazioni scadenti, puoi trovare l'callId nell'evento. Utilizza la seguente query per visualizzare tutti gli eventi che si sono verificati in una RPC, indipendentemente dal fatto che si tratti di una RPC unaria o di streaming. La voce di log precedente viene utilizzata come esempio:

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

Per determinare l'ambito del problema, puoi trovare tutti gli eventi RPC per lo stesso metodo o posizione. La seguente query mostra tutti i log di debug relativi a un metodo RPC specifico, utilizzando il servizio Greeter come esempio:

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

Per controllare le chiamate RPC non riuscite di un codice di stato specifico, puoi aggiungere il codice di stato come una delle condizioni di filtro. La seguente query mostra gli eventi del trailer che terminano con uno stato non corretto:

log_id("microservices.googleapis.com/observability/grpc")
jsonPayload.payload.statusCode!="OK"
Risultati della query: codice di stato Scadenza superata.
Risultati della query: codice di stato Scadenza superata (fai clic per ingrandire)

Opzioni di osservabilità

L'osservabilità dei microservizi include le seguenti funzionalità facoltative.

Definisci le etichette personalizzate

Puoi definire etichette personalizzate, che aggiungono informazioni fornite dagli utenti ai dati di osservabilità. Le etichette personalizzate sono costituite da coppie chiave-valore. Ogni coppia chiave-valore viene allegata ai dati di tracciamento come etichette span, ai dati delle metriche come tag delle metriche e ai dati di logging come etichette voce di log.

Le etichette personalizzate sono definite nella configurazione con un elenco di coppie chiave-valore nel campo labels. Tutte le chiavi e i valori per le etichette personalizzate sono di tipo STRING. L'implementazione legge la configurazione e crea un'etichetta separata per ogni coppia chiave-valore, quindi collega le etichette ai dati di osservabilità.

Ad esempio, questa è una definizione di etichetta:

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

Ogni voce di log ha le seguenti etichette aggiuntive:

{
   "DATACENTER" : "SAN_JOSE_DC"
   "APP_ID" : "24512"
}
Eseguire query sulle etichette in una voce di log.
Esecuzione di query sulle etichette in una voce di log (fai clic per ingrandire)
Grafico a linee che mostra le etichette personalizzate e delle risorse.
Grafico a linee che mostra le etichette personalizzate e delle risorse (fai clic per ingrandire)

Abilita il logging del payload

Per abilitare la registrazione del payload, utilizza le variabili di ambiente fornite al workload. Per attivare la registrazione del payload per i messaggi e le intestazioni HelloWorld, aggiorna il valore dei file di configurazione gcp_observability_server_config.json, gcp_observability_client_config.json o entrambi negli esempi gRPC come segue:

{
   "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 l'osservabilità tra progetti

Puoi impostare il progetto di destinazione in modo esplicito utilizzando la configurazione impostata nella variabile di ambiente GRPC_GCP_OBSERVABILITY_CONFIG. Per l'osservabilità tra progetti, devi anche impostare le autorizzazioni del service account appropriate. Supponendo che l'ID progetto di destinazione sia core-platform-stats, puoi configurare l'osservabilità tra progetti utilizzando la seguente configurazione di esempio:

{
   "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/*"
            ]
         }
      ]
   }
}

Stimare il volume dei log

Questa sezione fornisce informazioni che puoi utilizzare per stimare facoltativamente il volume di inserimento dei log. Puoi fare una stima prima di abbonarti agli eventi RPC dei tuoi servizi.

Elemento Dettaglio
Eventi generati per una chiamata unary OK 6 eventi

Una RPC di chiamata unitaria OK genera i seguenti 6 eventi per il client o il server:

  • CLIENT_HEADER
  • SERVER_HEADER
  • CLIENT_MESSAGE
  • SERVER_MESSAGE
  • CLIENT_HALF_CLOSE
  • SERVER_TRAILER
Dimensioni medie della voce di log 500 byte per impostazione predefinita

Una voce di log corrisponde a un evento RPC, che include le informazioni di debug dettagliate per l'evento, le etichette delle risorse e le etichette personalizzate.
Dimensioni del logging del payload 0 per impostazione predefinita, può essere configurato

La dimensione massima del payload è configurabile nella configurazione dell'osservabilità. Per impostazione predefinita, non viene registrato alcun payload.
Dimensioni delle etichette personalizzate 0 per impostazione predefinita, può essere configurato

Le etichette personalizzate vengono fornite all'applicazione utilizzando le variabili di ambiente. Se non ne viene specificata nessuna, non ci saranno etichette personalizzate

Formula per la stima delle dimensioni totali dell'importazione dei log al mese:

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

Ad esempio, se il valore QPS di un metodo di chiamata unario è 1 e non sono attivate funzionalità aggiuntive, le dimensioni stimate dell'importazione dei log sono circa 7,24 GiB.

Passaggi successivi