Questo documento contiene le informazioni necessarie per configurare il plug-in di osservabilità dei microservizi, eseguire la strumentazione delle 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 è stata concessa l'autorizzazione per accedere a Cloud Monitoring, Cloud Logging e Cloud Trace abilitando l'API Microservices. Questa guida fornisce una configurazione di esempio dell'osservabilità dei microservizi utilizzando un esempio di Compute Engine.
A livello generale, esegui le seguenti operazioni:
- In qualità di sviluppatore di servizi, puoi attivare e controllare il plug-in di osservabilità dei microservizi.
- In qualità di operatore di servizio, puoi utilizzare 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à:
- Leggi la Panoramica dell'osservabilità dei microservizi.
- Assicurati di avere un progetto esistente o creane uno nuovo.
- Assicurati di avere un account di servizio esistente o creane uno nuovo.
- Scopri di più sulle due variabili di ambiente supportate, decidi quale utilizzare e determina i valori richiesti dalla variabile di ambiente.
- Abilita l'API Microservices.
Scegli una variabile di ambiente di configurazione
Quando attivi il plug-in di osservabilità dei microservizi, descritto nella sezione Implementare le applicazioni per il plug-in di osservabilità, devi fornire le informazioni di configurazione utilizzando una variabile di ambiente. Per impostazione predefinita, non sono abilitate funzionalità di osservabilità. Puoi impostare la variabile di ambiente sulla VM o sul container 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 rimanda a un file di configurazione con codifica JSON.GRPC_GCP_OBSERVABILITY_CONFIG: il valore è il corpo della configurazione codificata 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, è necessario 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 caricare i dati di logging, tracciamento e metriche. Puoi impostare l'ID progetto nel campo project_id.
Se questo campo viene lasciato vuoto, il plug-in di osservabilità riempie automaticamente il valore dell'ID progetto in base alle credenziali predefinite dell'applicazione.
Se non è possibile identificare le credenziali predefinite dell'applicazione e il campo
project_idè vuoto, il metodoINIT/STARTgenera 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 attivare l'API dei microservizi nei tuoi progetti. L'abilitazione dell'API Microservice abilita automaticamente l'API Cloud Logging, l'API Cloud Monitoring e l'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 necessarie all'account di servizio. Imposta i seguenti valori:
- PROJECT_ID: sostituisci l'ID progetto.
- SERVICE_ACCOUNT_NAME: sostituisci il nome dell'account di servizio del 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
Strumenti delle applicazioni per il plug-in di osservabilità
Per instrumentare le tue applicazioni in modo che possano usare il plug-in di observabillity 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 è in GitHub.
Modifiche alla build
Il supporto per l'osservabilità è disponibile solo tramite il sistema di compilazione Bazel. Aggiungi il target grpcpp_gcp_observability come dipendenza.
Modifiche al codice richieste
L'attivazione dell'osservabilità dei microservizi richiede un'ulteriore dipendenza (un modulo di osservabilità) e le seguenti modifiche al codice per client, server o entrambi 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 delle credenziali, richiama quanto segue:
grpc::GcpObservability::Init();
Questo restituisce 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 non rientrano nell'ambito.
Go
I plug-in di osservabilità dei microservizi sono supportati per le versioni gRPC Go v1.54.0 e successive.
Il repository di esempio
è in GitHub.
Con il modulo Go, l'attivazione dell'osservabilità dei microservizi richiede un modulo di osservabilità e il codice seguente:
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 chiamataobservability.End
posticipata esegue la pulizia delle risorse e garantisce che i dati nel buffer vengano cancellati prima della chiusura dell'applicazione.
Dopo aver aggiornato il codice dell'applicazione, esegui questo comando 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 delle sezioni degli strumenti di creazione Gradle e Maven, grpcVersion è impostato sul valore 1.54.1.
Il repository di esempio è in GitHub.
Modifiche richieste al codice Java
Per ottimizzare l'osservabilità delle tue applicazioni Java per i microservizi, aggiungi il codice seguente 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 che vengano creati canali o server gRPC. La funzione GcpObservability.grpcInit() legge la configurazione di osservabilità dei microservizi e la utilizza per configurare gli intercettatori e le tracce di tracciamento globali necessari per il logging, le metriche e la funzionalità di traccia in ogni canale e server creato. GcpObservability.grpcInit()
è sicuro per i thread 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. I canali o i server creati
in seguito 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 creazione Gradle
Se utilizzi lo strumento di creazione Gradle, includi quanto segue:
def grpcVersion = '1.54.1'
...
dependencies {
...
implementation "io.grpc:grpc-gcp-observability:${grpcVersion}"
...
}
Utilizza lo strumento di creazione Maven (pom.xml)
Se utilizzi 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 la raccolta dei dati di metriche, tracciamento e logging
Le seguenti sezioni 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 relativo valore su {}.
Per saperne di più sulle metriche, consulta Definizioni delle metriche.
Attiva tracciamento
Se prevedi di attivare il tracciamento tra più servizi, assicurati che i servizi supportino la propagazione del contesto di traccia ricevuto dall'upstream (o avviato automaticamente) al downstream.
Per attivare il tracciamento:
- Aggiungi l'oggetto
cloud_tracealla configurazione. - Imposta
cloud_trace.sampling_ratesu una probabilità che vuoi che l'applicazione osserva per avviare nuove tracce.- Ad esempio,
1.0significa tracciare ogni RPC. 0.0indica di non avviare nuove tracce.0.5significa che il 50% delle RPC viene tracciato in modo casuale.
- Ad esempio,
Se viene presa una decisione di campionamento positiva a monte, i servizi caricano gli intervalli indipendentemente dall'impostazione della frequenza di campionamento.
Per ulteriori informazioni sul tracciamento, consulta Definizioni di Traccia.
Abilita il logging
Per abilitare il logging:
- Aggiungi l'oggetto
cloud_loggingalla configurazione. - Aggiungi un pattern a
client_rpc_eventse aserver_rpc_events, o a entrambi, specificando l'insieme di servizi o metodi per i quali vuoi generare il logging degli eventi a livello di trasporto e il numero di byte da registrare per 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à 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à
Utilizza queste istruzioni per creare e connetterti a un'istanza VM di Compute Engine, quindi 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.iam.gserviceaccount.com
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
Dopo aver eseguito 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
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 contenute.
Quando le istruzioni ti indicano di aprire un'altra finestra del terminale, esegui questo comando:
gcloud compute ssh --project=PROJECT_ID grpc-observability-vm
C++
Dopo aver eseguito la connessione all'istanza VM, esegui un programma binario del server
hello-worldin 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 di nuovo alla VM utilizzando SSH, quindi esegui i comandi seguenti, 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
Go
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 di directory
gRPC-Go:cd examples/features/observability
Esegui il server.
export GRPC_GCP_OBSERVABILITY_CONFIG_FILE=./server/serverConfig.json go run ./server/main.go
Esegui questi comandi in una finestra del terminale separata.
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 strumentato i carichi di lavoro, dovresti vedere le tracce generate dai client gRPC e dai server gRPC nella console Google Cloud elencate come tracce recenti.
Visualizza i log per le tracce
Se abiliti sia il logging che il tracciamento, puoi visualizzare le voci di log per le tracce insieme al grafico a cascata di Cloud Trace o in Esplora log.
Visualizza metriche nella dashboard
L'osservabilità dei microservizi fornisce una dashboard di monitoraggio denominata Monitoraggio dei 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 sia abilitata in un progetto. L'utente deve avere l'autorizzazione serviceusage.services.list per visualizzare la dashboard.
La dashboard di monitoraggio dei microservizi (gRPC) è una dashboard di 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.
Visualizza le metriche in Metrics Explorer
Dopo aver configurato l'esempio gRPC o aver assegnato la strumentazione al carico di lavoro, dovresti visualizzare le metriche generate dai client gRPC e dai server gRPC nella console Google Cloud.
Per visualizzare e tracciare le metriche, segui le istruzioni riportate in Selezionare le metriche quando si utilizza Metrics Explorer
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 sui filtri preparati e usarli.
Dopo che le voci di log corrispondenti alle query suggerite vengono visualizzate in Cloud Logging, puoi aspettarti di vedere le nuove query suggerite in circa 6 minuti. Nella maggior parte dei casi, visualizzi più rapidamente le nuove query suggerite. Se sono presenti voci di log che corrispondono a un suggerimento nei 15 minuti precedenti, continueranno a essere visualizzate le eventuali query suggerite. Continuano a essere visualizzati come suggerimento fino a quando non ci sono state voci di log corrispondenti nei 15 minuti precedenti.
Puoi creare query personalizzate. Per le istruzioni, consulta la guida al linguaggio delle query di Logging. Ad esempio, nel riquadro Query di Esplora log, puoi provare a visualizzare tutti i log di debug gRPC con il codice seguente:
log_id("microservices.googleapis.com/observability/grpc")
Per l'applicazione di filtri, puoi utilizzare tutti i campi del record di log gRPC. 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 di log di intestazione o trailer per gRPC
Questa query offre una visualizzazione di base delle RPC, con 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 RPC che terminano con uno stato non OK.
log_id("microservices.googleapis.com/observability/grpc") AND
jsonPayload.type="SERVER_TRAILER" AND
jsonPayload.payload.statusCode!="OK"
Record di log per gRPC annullati o superate la scadenza
Un annullamento eccessivo di gRPC o il superamento delle scadenze possono fornire informazioni utili sulla perdita di prestazioni o sul comportamento imprevisto delle applicazioni.
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 visualizzi un evento RPC che indica comportamenti dannosi, 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 flusso. La voce di log precedente è 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 la stessa località. La seguente query mostra tutti i log di debug relativi a uno specifico metodo RPC, utilizzando il servizio Greeter come esempio:
log_id("microservices.googleapis.com/observability/grpc")
jsonPayload.serviceName="helloworld.Greeter"
jsonPayload.methodName="SayHello"
Per verificare 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 trailer che terminano con uno stato non OK:
log_id("microservices.googleapis.com/observability/grpc")
jsonPayload.payload.statusCode!="OK"
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 di 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. L'implementazione legge la configurazione e crea un'etichetta separata per ogni coppia chiave-valore, quindi associa le etichette ai dati di osservabilità.
Ad esempio, questa è la definizione di un'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"
}
Abilita il logging del payload
Puoi abilitare il logging del payload utilizzando le variabili di ambiente da te 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, 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 esplicitamente il progetto di destinazione utilizzando il set di configurazione nella 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 impostare 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 possono essere utilizzate per stimare il volume di importazione dei log. Puoi fare una stima prima di sottoscrivere gli eventi RPC dei tuoi servizi.
| Elemento | Dettaglio |
|---|---|
| Eventi generati per una chiamata unaria OK | 6 eventi Una RPC con chiamata unaria OK genera i 6 eventi seguenti per client o server:
|
| Dimensioni medie della voce di log | 500 byte per impostazione predefinita Una voce di log è mappata a un evento RPC, che include informazioni di debug dettagliate per l'evento, etichette delle risorse e etichette personalizzate. |
| Dimensioni di logging del payload | 0 per impostazione predefinita, configurabile La dimensione massima del payload è configurabile nella configurazione di 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 viene specificata, non ci saranno etichette personalizzate |
Dimensione totale dell'importazione di log per formula di stima mensile:
Monthly Log Ingestion = QPS * 6 * (500B + Payload Logging Size + Custom Labels Size) * 2592000
Ad esempio, se il valore QPS di un metodo di chiamata unaria è 1 e non sono abilitate funzionalità aggiuntive, la dimensione stimata di importazione dei log è di circa 7,24 GiB.
Passaggi successivi
- Per informazioni dettagliate sui dati di configurazione, sulle definizioni delle tracce, delle definizioni delle metriche e dei log, consulta Riferimento per l'osservabilità dei microservizi.