Questa pagina è stata tradotta dall'API Cloud Translation.

Configura 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 una configurazione di esempio dell'osservabilità dei microservizi con un esempio di Compute Engine.

A livello generale, svolgi le seguenti operazioni:

In qualità di sviluppatore di servizi, puoi attivare e controllare i microservizi per l'osservabilità.
In qualità di operatore di servizio, utilizzi i dati raccolti in vari modi.

I repository gRPC (C++, Go e Java) includono esempi per la dimostrazione Osservabilità dei microservizi.

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

Leggi la panoramica sull'osservabilità dei microservizi.
Assicurati di avere già un progetto o crea un nuovo progetto.
Assicurati di avere un account di servizio esistente creane uno nuovo.
Leggi le due variabili di ambiente supportate, decidi da utilizzare e determina i valori richiesti dalla variabile di ambiente.
Abilitare l'API Microservices.

Scegli una variabile di ambiente di configurazione

Quando attivi il plug-in di osservabilità dei microservizi, descritto in Instrument your application for the observability plugin, devi fornire le informazioni di configurazione utilizzando una variabile di ambiente. Di per impostazione predefinita, nessuna funzionalità di osservabilità è abilitata. Sei tu a impostare la variabile di ambiente sulla VM o sul container su 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 sono 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. 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.

Se questo campo viene lasciato vuoto, il plug-in osservabilità automaticamente compila il valore dell'ID progetto in base alla credenziali predefinite dell'applicazione.
Se credenziali predefinite dell'applicazione non può essere identificato e il campo project_id è vuoto, INIT/START genera o restituisce un errore all'applicazione. L'applicazione deve quindi gestire l'errore.

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. \
  --role=roles/logging.logWriter

gcloud projects add-iam-policy-binding PROJECT_ID> \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID. \
  --role=roles/monitoring.metricWriter

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID. \
  --role=roles/cloudtrace.agent

Instrumenta le tue applicazioni per il plug-in osservabilità

Per instrumentare le tue applicazioni in modo che possano utilizzare i microservizi plug-in observabillity, utilizza le seguenti istruzioni per C++, Java e Go.

C++

Puoi usare C++ con l'osservabilità dei microservizi a partire da gRPC C++ v1.54. La repository di esempio è in GitHub.

Modifiche build

Il supporto per l'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, richiama questo codice:

grpc::GcpObservability::Init();

Verranno restituiti absl::StatusOr<GcpObservability> che dovrebbero essere salvati. 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'osservabilità modulo 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 dall'ambiente crea gli esportatori di conseguenza e inserisce la logica di raccolta al client di connessioni e server creati dopo la chiamata. Il observability.End differito pulisce le risorse e garantisce 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 build delle sezioni degli strumenti di sviluppo Gradle e Maven, grpcVersion è impostato sul valore 1.54.1.

Il repository di esempio è in GitHub.

Modifiche al codice Java richieste

Per lo strumento corretto delle applicazioni Java per i microservizi osservabilità, 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() è sicura per i thread e deve essere chiamata esattamente una volta. Restituisce un'istanza di GcpObservability che devi salvare per chiamare close() in un secondo momento.

GcpObservability.close() annulla l'allocazione delle 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 creazione Gradle

Se usi lo strumento di creazione 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 usi lo strumento di creazione 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 le metriche, il tracciamento e la raccolta dei dati di logging

Le seguenti sezioni contengono istruzioni per attivare la raccolta dei dati in la configurazione e un esempio che mostra le informazioni di configurazione 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 tracciamento

Se prevedi di attivare il tracciamento tra servizi, assicurati che questi ultimi supportare la propagazione del contesto di traccia ricevuto da upstream (o avviato da solo) a downstream.

Per attivare il tracciamento:

Aggiungi l'oggetto cloud_trace alla configurazione.
Imposta cloud_trace.sampling_rate su una probabilità che vuoi che per osservare l'avvio di nuove tracce.
- Ad esempio, 1.0 significa tracciare ogni RPC.
- 0.0 significa che non devi avviare nuove tracce.
- 0.5 significa che il 50% delle RPC viene tracciato in modo casuale.

Se viene presa una decisione positiva sul campionamento a monte, il caricamento dei servizi dura qualunque sia l'impostazione della frequenza di campionamento.

Per scoprire di più sul tracciamento, vedi Definizioni di Trace.

Abilita il logging

Per abilitare il logging, segui questi passaggi:

Aggiungi l'oggetto cloud_logging alla configurazione.
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 di 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à

Utilizza queste istruzioni per creare e connetterti a una VM di Compute Engine dell'istanza e poi configurare l'esempio di osservabilità.

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.

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 di le tue applicazioni gRPC.

Java

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

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

Vai alla directory degli esempi.

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

Nella directory degli esempi, apri il file README e segui le istruzioni nel file.
Quando le istruzioni indicano di aprire un'altra finestra del terminale, esegui questo comando:
```
gcloud compute ssh --project=PROJECT_ID grpc-observability-vm
```

C++

Dopo esserti connesso all'istanza VM, esegui un file binario del server hello-world 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

Da un'altra finestra del terminale, connettiti nuovamente alla VM utilizzando SSH ed esegui questo comando che eseguono il programma 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

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

Clona gli esempi gRPC-Go.

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

Vai al clone della directory gRPC-Go:
```
cd examples/features/observability
```

Esegui il server.

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

In una finestra separata del terminale, 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

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

Visualizza tracce su Cloud Trace

Dopo aver configurato gli esempi o aver instrumentato i carichi di lavoro, dovresti vedere le tracce generate dai client gRPC e dai server gRPC nella Console Google Cloud elencata 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 abiliti sia il logging che il tracciamento, 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 la verifica se l'API Microservices è abilitata in un progetto. L'utente deve disporre Autorizzazione serviceusage.services.list per visualizzare la dashboard.

La dashboard di monitoraggio di microservizi (gRPC) è una dashboard di Google Cloud e non puoi modificarlo direttamente. Per personalizzare la dashboard, devi copiare in una dashboard personalizzata. Dopodiché puoi aggiornare la dashboard personalizzata, ad esempio aggiungendo, eliminando o riorganizzando i grafici.

Visualizza le metriche in Metrics Explorer

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

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

Ispeziona le voci di log in Esplora log

La query suggerita è una funzionalità di Cloud Logging in cui Google Cloud suggerisce un insieme di query basate sui log importati. Puoi fare clic e utilizzare e quelli già pronti.

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

Quando le voci di log corrispondenti alle query suggerite vengono visualizzate in Cloud Logging, di ricevere 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 suggerimento nei 15 minuti precedenti, le query suggerite continuano a essere visualizzati. 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 visualizzare 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 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 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"

Registra i record per gRPC annullati o superati dalla scadenza

Un eccesso di cancellazioni gRPC o superamenti della scadenza può fornire informazioni utili o in caso di perdita di prestazioni o comportamenti imprevisti 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 il tracciamento per la risoluzione dei problemi

Se vedi un evento RPC che indica un comportamento scorretto, puoi trovare l'errore 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. Il 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 o una posizione geografica. 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 non OK:

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

Risultati della query: codice di stato superato per la scadenza. — 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 le informazioni fornite dall'utente alla di osservabilità dei dati. 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 sono definite nella configurazione con un elenco di coppie chiave/valore in il 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 di log ha le seguenti etichette aggiuntive:

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

Esecuzione di 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 etichette personalizzate e delle risorse (fai clic per ingrandire)

Abilita logging dei payload

Puoi abilitare la registrazione del payload utilizzando le variabili di ambiente da te fornite 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 più progetti osservabilità, devi anche impostare il livello autorizzazioni dell'account di servizio. Se l'ID progetto di destinazione è 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 i log di importazione. Puoi fare una stima prima di sottoscrivere la sottoscrizione all'RPC degli eventi 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.
Dimensione logging del payload	0 per impostazione predefinita, può essere configurato La dimensione massima del payload è configurabile nell'osservabilità configurazione. 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 l'ambiente come la codifica one-hot delle variabili categoriche. Se non viene specificata alcuna etichetta, 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 valore QPS di un metodo di chiamata unario è 1 e non vengono abilitato, la dimensione stimata dell'importazione dei log è di circa 7,24 GiB.

Passaggi successivi

Per informazioni dettagliate su dati di configurazione, definizioni delle tracce, metriche Per le definizioni dei log e delle definizioni dei log, consulta la pagina Riferimento per l'osservabilità dei microservizi.