Configurare l'osservabilità dei microservizi

Questo documento contiene le informazioni necessarie per configurare i microservizi plug-in di osservabilità, instrumenta le tue applicazioni gRPC e ottieni informazioni da Cloud Monitoring, Cloud Logging e Cloud Trace.

Prima di iniziare

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

In linea 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 sull'osservabilità dei microservizi.
  2. Assicurati di avere un progetto esistente o creane uno nuovo.
  3. Assicurati di avere un account di servizio esistente o creane uno nuovo.
  4. Leggi le informazioni sulle due variabili di ambiente supportate, decidi quale utilizzare e determina i valori richiesti dalla variabile di ambiente.
  5. Abilitare l'API Microservices.

Scegli una variabile di ambiente di configurazione

Quando attivi il plug-in di osservabilità dei microservizi, descritto in Eseguire l'instrumentazione delle applicazioni per il plug-in di osservabilità, devi fornire le informazioni di configurazione utilizzando una variabile di ambiente. Di per impostazione predefinita, nessuna funzionalità di osservabilità è abilitata. Imposti la variabile di ambiente sulla VM o sul contenitore in cui è in esecuzione l'applicazione o il carico di lavoro 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 codificati in JSON.

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

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

Nella configurazione, puoi impostare un progetto di destinazione in cui eseguire il logging, di tracciamento e caricati i dati delle metriche. Devi impostare l'ID progetto campo project_id.

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

Abilita l'API Microservices

Puoi utilizzare Google Cloud CLI o la console Google Cloud per abilitare l'API dei microservizi nei tuoi progetti. Abilitazione dell'API dei microservizi abilita automaticamente l'API Cloud Logging, l'API Cloud Monitoring e Cloud Trace API.

Per abilitare l'API:

gcloud services enable microservices.googleapis.com

Impostare le autorizzazioni dell'account di servizio

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

  • PROJECT_ID: sostituisci il tuo ID progetto.
  • SERVICE_ACCOUNT_NAME: sostituisci il nome dell'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

Fornisci strumenti alle 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 dalla versione 1.54 di gRPC C++. La repository di esempio è in GitHub.

Modifiche alla compilazione

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

Modifiche al codice richieste

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

#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 le credenziali, invoca quanto segue:

grpc::GcpObservability::Init();

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

Vai

I plug-in di osservabilità dei microservizi sono supportati per le versioni gRPC Go v1.54.0 e successivi. Il repository di esempio è 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 dei client e nei server creati dopo la chiamata. Il observability.End differito pulisce le risorse e assicura che i dati presenti nel buffer vengano cancellati prima che l'applicazione si chiude.

Una volta aggiornato il codice dell'applicazione, esegui questo comando per aggiornare go.mod.

go mod tidy

Java

Per utilizzare l'osservabilità dei microservizi con le applicazioni Java, modifica la tua build in includono l'artefatto grpc-gcp-observability. Usa gRPC versione 1.54.1 o in un secondo momento.

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

Il repository di esempio è in GitHub.

Modifiche al codice Java richieste

Per eseguire correttamente l'instrumentazione delle 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 qualsiasi canale gRPC o server. La funzione GcpObservability.grpcInit() legge Configurazione dell'osservabilità dei microservizi, che la utilizza per impostare l'ambiente di intercettatori e tracciatori necessari per il logging, le metriche e in ogni canale e server creati. 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() disalloca le risorse. Qualsiasi canale o server creato non verrà eseguito alcun logging.

GcpObservability implementa java.lang.AutoCloseable, che è stato chiuso automaticamente se utilizzi try-with-resource come segue:

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

Usa lo strumento di creazione 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>

Attiva la raccolta dei dati di metriche, monitoraggio 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 abilitare le metriche, aggiungi l'oggetto cloud_monitoring alla configurazione e imposta il valore su {}.

Per saperne di più sulle metriche, consulta Definizioni delle metriche.

Attiva il monitoraggio

Se prevedi di attivare il monitoraggio in più servizi, assicurati che supportino la propagazione del contesto della traccia ricevuto dall'upstream (o avviato autonomamente) al downstream.

Per attivare il monitoraggio:

  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 indica il monitoraggio di ogni RPC.
    • 0.0 significa non avviare nuove tracce.
    • 0.5 indica che il 50% delle RPC viene monitorato in modo casuale.

Se viene presa una decisione di campionamento positiva a monte, i caricamenti dei servizi vengono eseguiti indipendentemente dall'impostazione della frequenza di campionamento.

Per ulteriori informazioni sul monitoraggio, consulta Definizioni dei traccianti.

Abilita il logging

Per attivare il logging:

  1. Aggiungi l'oggetto cloud_logging alla configurazione.
  2. Aggiungi un pattern a una o entrambe le categorie client_rpc_events e server_rpc_events che specifica l'insieme di servizi o metodi per i quali generare il logging degli eventi a livello di trasporto e il numero di byte da registrare per le intestazioni e messaggi.

Per ulteriori informazioni sul logging, consulta Definizioni dei record dei log.

Esempio di variabile di ambiente

L'esempio seguente imposta le variabili di osservabilità nell'ambiente variabile 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 Compute Engine, quindi 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

Procedi 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 avere Java 8 o Java installato in un secondo momento.

    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 nel file.

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

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

C++

  1. Dopo aver eseguito la connessione all'istanza VM, esegui un file 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 tramite 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

Vai

  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 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 i seguenti 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 aver strumentato i carichi di lavoro, dovresti vedere le tracce generate dai client e dai server gRPC nella console Google Cloud elencate come tracce recenti.

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

Visualizza i log per le tracce

Se attivi sia il logging sia il monitoraggio, puoi visualizzare le voci di log per le tracce accanto al grafico a cascata di Cloud Trace o in Esplora log.

Visualizza le metriche nella dashboard

L'osservabilità dei microservizi fornisce una dashboard di monitoraggio chiamata Microservizi Monitoraggio (gRPC) per le metriche definite nelle definizioni delle metriche. La viene visualizzata nella console Google Cloud solo quando l'API Microservices sia abilitato. La console Google Cloud chiama l'API Service Usage per verificare se l'API Microservices è abilitata in un progetto. L'utente deve disporre 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 copiare in una dashboard personalizzata. Puoi quindi aggiornare la dashboard personalizzata, ad esempio aggiungendo, eliminando o riordinando i grafici.

Visualizza le metriche in Metrics Explorer

Dopo aver configurato l'esempio gRPC o aver strumentato il tuo carico di lavoro, dovresti vedere le metriche generate dai client e dai server gRPC nella console Google Cloud.

Per visualizzare e rappresentare su grafico le metriche, utilizza le istruzioni in Selezionare le metriche quando si utilizza Esplora metriche

Esaminare 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 importati. 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, di questi casi, vedrai più velocemente le nuove query suggerite. Se sono presenti voci di log corrispondenti a un suggerimento nei 15 minuti precedenti, le query suggerite continuano a essere visualizzate. Continuano a essere visualizzati come suggerimenti finché non ce ne sono voci di log corrispondenti nei 15 minuti precedenti.

Puoi creare query personalizzate. Consulta le Guida al linguaggio di query di Logging per istruzioni. 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 del record di log gRPC per l'applicazione di filtri. Ecco un esempio di voce del 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 quanto segue query suggerite in Cloud Logging:

Record di log di intestazioni o trailer per gRPC

Questa query offre una visualizzazione di base delle RPC, generando informazioni peer e RPC che consentono di analizzare i dati e visualizzare i risultati.

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

Chiamate gRPC non riuscite

Questa query trova le RPC che terminano con stato non 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

Un numero eccessivo di annullamenti o superamenti della scadenza gRPC 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 un comportamento scorretto, puoi trovare 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 una RPC in modalità flusso. L'elemento di log precedente viene utilizzato 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 la stessa 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 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 lo stato non OK:

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 superato (fai clic per ingrandire)

Opzioni di osservabilità

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

Definisci etichette personalizzate

Puoi definire etichette personalizzate, che aggiungono informazioni fornite dall'utente ai dati di osservabilità. Le etichette personalizzate sono costituite da coppie chiave/valore. Ogni coppia chiave-valore è collegata al tracciamento dei dati come etichette di intervallo, ai dati delle metriche come tag metrica, e ai dati di logging come etichette di voce di log.

Le etichette personalizzate vengono definite nella configurazione con un elenco di coppie chiave-valore nel campo labels. Tutte le chiavi e i valori delle etichette personalizzate sono di tipo STRING. La legge la configurazione e crea un'etichetta separata per ciascuna 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 del log contiene le seguenti etichette aggiuntive:

{
   "DATACENTER" : "SAN_JOSE_DC"
   "APP_ID" : "24512"
}
Eseguire query sulle etichette in una voce di log.
Eseguire query sulle etichette in una voce del 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 logging dei payload

Attiva il logging del payload utilizzando le variabili di ambiente fornite al carico di lavoro. Per attivare il logging del payload per i messaggi e le intestazioni HelloWorld, aggiorna il valore dei file di configurazione gcp_observability_server_config.json e gcp_observability_client_config.json o entrambi negli esempi di gRPC:

{
   "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 l'insieme di configurazione la variabile di ambiente GRPC_GCP_OBSERVABILITY_CONFIG. Per l'osservabilità tra progetti, devi anche impostare le autorizzazioni dell'account di servizio 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/*"
            ]
         }
      ]
   }
}

Stima volume log

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

Elemento Dettaglio
Eventi generati per una chiamata unaria OK 6 eventi

Una chiamata RPC OK genera i seguenti sei eventi per client o server:

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

Una voce di log è mappata a un evento RPC, l'evento RPC include le informazioni di debug dettagliate per l'evento, le etichette delle risorse 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 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 di stima della dimensione totale dell'importazione dei log per mese:

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

Ad esempio, se il QPS di un metodo di chiamata unario è 1 e non sono attivate funzionalità aggiuntive, la dimensione stimata dell'importazione dei log è di circa 7,24 GB.

Passaggi successivi