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 è stata concessa l'autorizzazione per accedere a Cloud Monitoring, Cloud Logging e Cloud Trace attivando l'API Microservices. Questa guida fornisce un'esempio di configurazione dell'osservabilità dei microservizi utilizzando un esempio di Compute Engine.
In linea generale, devi:
- In qualità di sviluppatore di servizi, puoi attivare e controllare il plug-in di osservabilità dei microservizi.
- 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à:
- 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.
- Leggi le informazioni 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 in Eseguire l'instrumentazione delle applicazioni per il plug-in di osservabilità, devi fornire le informazioni di configurazione utilizzando una variabile di ambiente. Per impostazione predefinita, non sono attivate funzionalità di osservabilità. 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 rimanda a un file di configurazione con codifica JSON.GRPC_GCP_OBSERVABILITY_CONFIG: il valore è il corpo della configurazione codificato 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. Non puoi impostare o visualizzare i valori delle variabili di ambiente nella console Google Cloud .
Nella configurazione, puoi impostare un progetto di destinazione a cui vengono caricati i dati di logging, tracing e metriche. Imposti l'ID progetto nel
project_id campo.
Se questo campo viene lasciato vuoto, il plug-in di osservabilità compila automaticamente il valore dell'ID progetto in base alle credenziali predefinite dell'applicazione.
Se le credenziali predefinite dell'applicazione non possono essere identificate 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 in Dati di configurazione per impostare i valori nella variabile di ambiente scelta.
Abilita l'API Microservices
Puoi utilizzare Google Cloud CLI o la console Google Cloud per abilitare l'API Microservices nei tuoi progetti. L'attivazione dell'API Microservice attiva 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 richieste per l'account di servizio. Imposta i seguenti valori:
- PROJECT_ID: sostituisci l'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++. Il repository di esempio si trova su GitHub.
Modifiche alla compilazione
Il supporto dell'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 una dipendenza aggiuntiva (un modulo di osservabilità) e le seguenti modifiche al codice di client o server gRPC esistenti o di 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. Lo stato aiuta a determinare se l'osservabilità è stata inizializzata correttamente. L'oggetto GcpObservability aggiuntivo controlla il ciclo di vita dell'osservabilità e chiude e svuota automaticamente i dati di osservabilità quando esce dall'ambito.
Vai
I plug-in di osservabilità dei microservizi sono supportati per le versioni di gRPC Go v1.54.0
e successive.
Il repository di esempio si trova su 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. La chiamataobservability.End
differita libera le risorse e garantisce che i dati in buffer vengano svuotati prima della chiusura dell'applicazione.
Dopo aver aggiornato il codice dell'applicazione, esegui il comando seguente per aggiornare il filego.mod.
go mod tidy
Java
Per utilizzare l'osservabilità dei microservizi con le applicazioni Java, modifica la build in modo da includere l'elemento grpc-gcp-observability. Utilizza la versione gRPC 1.54.1 o successiva.
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 si trova su 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 che vengano creati canali o server gRPC. La funzione GcpObservability.grpcInit() legge la configurazione dell'osservabilità dei microservizi e la utilizza per configurare gli intercettatori e i tracer globali necessari per le funzionalità di logging, metriche e traccia 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() disalloca 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 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}"
...
}
Utilizzare 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>
Attivare 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.
Attiva le metriche
Per attivare le metriche, aggiungi l'oggetto cloud_monitoring alla configurazione e impostane il valore su {}.
Per ulteriori informazioni sulle metriche, consulta Definizioni delle metriche.
Attiva il monitoraggio
Se prevedi di attivare il monitoraggio in più servizi, assicurati che i servizi supportino la propagazione del contesto della traccia ricevuto dall'upstream (o avviato autonomamente) al downstream.
Per attivare il monitoraggio:
- Aggiungi l'oggetto
cloud_tracealla configurazione. - Imposta
cloud_trace.sampling_ratesu una probabilità che vuoi che la tua applicazione osservi per avviare nuove tracce.- Ad esempio,
1.0indica il monitoraggio di ogni RPC. 0.0significa non avviare nuove tracce.0.5indica che il 50% delle RPC viene monitorato in modo casuale.
- Ad esempio,
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:
- Aggiungi l'oggetto
cloud_loggingalla configurazione. - Aggiungi un pattern a
client_rpc_eventse/oserver_rpc_eventsspecificando 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 le intestazioni e i 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à 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 Compute Engine, quindi configura 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 examples, apri il file README e segui le istruzioni al suo interno.
Quando le istruzioni ti dicono di aprire un'altra finestra del terminale, emetti questo comando:
gcloud compute ssh --project=PROJECT_ID grpc-observability-vm
C++
Dopo aver eseguito la connessione all'istanza VM, esegui un file 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 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
Assicurati di avere 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 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 consoleGoogle Cloud elencate come tracce recenti.
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.
Visualizzare le 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 se l'API Microservices è abilitata. La console Google Cloud richiama l'API Service Usage per verificare se l'API Microservices è attivata 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 riordinando i grafici.
Visualizzare le metriche in Metrics Explorer
Dopo aver configurato l'esempio gRPC o aver strumentato il carico di lavoro, dovresti vedere le metriche generate dai client e dai server gRPC nella consoleGoogle Cloud .
Per visualizzare e tracciare le metriche, segui le istruzioni riportate in Selezionare le metriche durante l'utilizzo di Metrics Explorer
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.
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, vedrai le nuove query suggerite prima. 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 suggerimento finché non sono state registrate voci di log corrispondenti negli ultimi 15 minuti.
Puoi creare query personalizzate. Per istruzioni, consulta la guida al linguaggio delle 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 del record del log gRPC per il filtro. 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 i gRPC
Questa query fornisce una visualizzazione di base delle RPC, fornendo 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 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
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 un'RPC, indipendentemente dal fatto che si tratti di un'RPC unaria o di streaming. 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 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 lo 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.
Definire le 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 viene associata ai dati di monitoraggio come etichette di span, ai dati delle metriche come tag delle metriche 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 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 contiene le seguenti etichette aggiuntive:
{
"DATACENTER" : "SAN_JOSE_DC"
"APP_ID" : "24512"
}
Abilita il logging del 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, aggiornate 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
}
]
}
}
Configurare 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 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/*"
]
}
]
}
}
Stimare il volume dei 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 | Dettagli |
|---|---|
| Eventi generati per una chiamata unaria OK | 6 eventi Una chiamata RPC unitaria OK genera i seguenti 6 eventi per il client o il server:
|
| Dimensioni medie della voce di log | 500 byte per impostazione predefinita Una voce di log viene associata a un evento RPC, che include informazioni dettagliate sul debug per quell'evento, etichette delle risorse ed 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 verranno visualizzate 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
- Per informazioni dettagliate sui dati di configurazione, sulle definizioni delle tracce, sulle definizioni delle metriche e sulle definizioni dei log, consulta la documentazione di riferimento sull'osservabilità dei microservizi.