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.
- Ad esempio,
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
eserver_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.](https://cloud.google.com/static/stackdriver/docs/solutions/grpc/images/trace-ss.png?authuser=3&hl=it)
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.
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"
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"
}
![Grafico a linee che mostra le etichette personalizzate e delle risorse.](https://cloud.google.com/static/stackdriver/docs/solutions/grpc/images/custom-location-tags.png?authuser=3&hl=it)
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:
|
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.