Questo documento spiega come trovare le voci di log instradate da Cloud Logging alle tabelle BigQuery. I sink di log caricano i dati di log in BigQuery in piccoli batch, il che ti consente di eseguire query sui dati senza eseguire un job di caricamento. Per aiutarti a creare query e comprendere il formato del tuo BigQuery, questo documento descrive anche le Schema di BigQuery per i log con routing.
Cloud Logging utilizza API di streaming legacy per creare un flusso di voci di log in BigQuery. In genere, le voci di log sono visibili in BigQuery entro un minuto. Tuttavia, quando viene creata una nuova tabella, potrebbero essere necessari diversi minuti prima che sono disponibili le prime voci di log.
Prima di iniziare
Per una discussione concettuale degli elementi di destinazione, consulta Panoramica dei modelli di routing e archiviazione: elementi di destinazione.
Per istruzioni su come eseguire il routing dei log, consulta Esegui il routing dei log alle destinazioni supportate.
Per informazioni su come vengono denominati i campi delle voci di voce di log, consulta Schema di BigQuery per i log con routing.
Visualizza i log
Per visualizzare i log inviati a BigQuery:
-
Nella console Google Cloud, vai alla pagina BigQuery:
Puoi trovare questa pagina anche utilizzando la barra di ricerca.
Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.
Le voci di log sono visibili nella scheda Dettagli oppure puoi eseguire una query sulla tabella per visualizzare i dati.
Query di esempio
Per informazioni sulla sintassi delle query BigQuery, consulta Riferimento per le query. Particolarmente utili sono le funzioni carattere jolly della tabella, che consentono di eseguire query su più tabelle, e l'operatore appiattimento, che consente di visualizzare i dati dei campi ripetuti.
Esempio di query Compute Engine
La seguente query BigQuery recupera le voci di log di più giorni e di più tipi di log:
La query cerca negli ultimi tre giorni dei log
syslog
eapache-access
. La query è stata effettuata il 23 febbraio 2020 e riguarda tutte le voci di log ricevute il 21 e il 22 febbraio, più le voci di log ricevute il 23 febbraio fino al momento in cui è stata eseguita la query.La query recupera i risultati per una singola istanza Compute Engine,
1554300700000000000
.
SELECT timestamp AS Time, logName as Log, textPayload AS Message FROM (TABLE_DATE_RANGE(my_bq_dataset.syslog_, DATE_ADD(CURRENT_TIMESTAMP(), -2, 'DAY'), CURRENT_TIMESTAMP())), (TABLE_DATE_RANGE(my_bq_dataset.apache_access_, DATE_ADD(CURRENT_TIMESTAMP(), -2, 'DAY'), CURRENT_TIMESTAMP())) WHERE resource.type == 'gce_instance' AND resource.labels.instance_id == '1554300700000000000' ORDER BY time;
Ecco alcuni esempi di righe di output:
Row | Time | Log | Message --- | ----------------------- | ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- 5 | 2020-02-21 03:40:14 UTC | projects/project-id/logs/syslog | Feb 21 03:40:14 my-gce-instance collectd[24281]: uc_update: Value too old: name = 15543007601548826368/df-tmpfs/df_complex-used; value time = 1424490014.269; last cache update = 1424490014.269; 6 | 2020-02-21 04:17:01 UTC | projects/project-id/logs/syslog | Feb 21 04:17:01 my-gce-instance /USR/SBIN/CRON[8082]: (root) CMD ( cd / && run-parts --report /etc/cron.hourly) 7 | 2020-02-21 04:49:58 UTC | projects/project-id/logs/apache-access | 128.61.240.66 - - [21/Feb/2020:04:49:58 +0000] "GET / HTTP/1.0" 200 536 "-" "masscan/1.0 (https://github.com/robertdavidgraham/masscan)" 8 | 2020-02-21 05:17:01 UTC | projects/project-id/logs/syslog | Feb 21 05:17:01 my-gce-instance /USR/SBIN/CRON[9104]: (root) CMD ( cd / && run-parts --report /etc/cron.hourly) 9 | 2020-02-21 05:30:50 UTC | projects/project-id/log/syslogapache-access | 92.254.50.61 - - [21/Feb/2020:05:30:50 +0000] "GET /tmUnblock.cgi HTTP/1.1" 400 541 "-" "-"
Query di App Engine di esempio
La seguente query BigQuery recupera le informazioni non riuscite Richieste App Engine dell'ultimo mese:
SELECT timestamp AS Time, protoPayload.host AS Host, protoPayload.status AS Status, protoPayload.resource AS Path FROM (TABLE_DATE_RANGE(my_bq_dataset.appengine_googleapis_com_request_log_, DATE_ADD(CURRENT_TIMESTAMP(), -1, 'MONTH'), CURRENT_TIMESTAMP())) WHERE protoPayload.status != 200 ORDER BY time
Ecco alcuni risultati:
Row | Time | Host | Status | Path --- | ----------------------- | ------------------------------------- | ------ | ------ 6 | 2020-02-12 19:35:02 UTC | default.my-gcp-project-id.appspot.com | 404 | /foo?thud=3 7 | 2020-02-12 19:35:21 UTC | default.my-gcp-project-id.appspot.com | 404 | /foo 8 | 2020-02-16 20:17:19 UTC | my-gcp-project-id.appspot.com | 404 | /favicon.ico 9 | 2020-02-16 20:17:34 UTC | my-gcp-project-id.appspot.com | 404 | /foo?thud=%22what???%22
Schema BigQuery per i log con routing
Gli schemi delle tabelle BigQuery per i log instradati si basano sulla struttura del tipo LogEntry e sui contenuti dei payload dei log. Cloud Logging applica anche regole per abbreviare i nomi dei campi dello schema BigQuery per gli audit log e per alcuni campi del payload strutturato. Puoi visualizzare lo schema della tabella selezionando una tabella con log indirizzato nel Interfaccia di BigQuery.
Convenzioni di denominazione dei campi
Esistono alcune convenzioni di denominazione che si applicano ai campi delle voci di log quando si inviano i log a BigQuery:
I nomi dei campi di voce di log non possono superare i 128 caratteri.
I nomi dei campi di voce di log possono essere composti solo da caratteri alfanumerici. Eventuali caratteri non supportati vengono rimossi dai nomi dei campi e sostituiti con caratteri underscore. Ad esempio,
jsonPayload.foo%%
verrà trasformato ajsonPayload.foo__
.I nomi dei campi di voce di log devono iniziare con un carattere alfanumerico, anche dopo transformation; vengono rimossi tutti i trattini bassi.
Per i campi voce di log che fanno parte del tipo LogEntry, la riga i nomi dei campi BigQuery corrispondenti sono esattamente gli stessi nei campi voce di log.
Per tutti i campi voce di log forniti dall'utente, il valore I nomi dei campi BigQuery sono normalizzati in minuscolo, ma viene mantenuta in altro modo.
Per i campi nei payload strutturati, purché l'indicatore
@type
non sia i nomi dei campi BigQuery corrispondenti sono normalizzati alle lettere minuscole, ma in caso contrario la denominazione viene mantenuta.Per informazioni sui payload strutturati in cui l'indicatore
@type
è vedi Campi di payload con@type
in questa pagina.
I seguenti esempi mostrano come vengono applicate queste convenzioni di denominazione:
Campo della voce di log | Mappatura del tipo LogEntry | Nome campo BigQuery |
---|---|---|
insertId |
insertId |
insertId |
textPayload |
textPayload |
textPayload |
httpRequest.status |
httpRequest.status |
httpRequest.status |
httpRequest.requestMethod.GET |
httpRequest.requestMethod.[ABC] |
httpRequest.requestMethod.get |
resource.labels.moduleid |
resource.labels.[ABC] |
resource.labels.moduleid |
jsonPayload.MESSAGE |
jsonPayload.[ABC] |
jsonPayload.message |
jsonPayload.myField.mySubfield |
jsonPayload.[ABC].[XYZ] |
jsonPayload.myfield.mysubfield |
Campi del payload con @type
Questa sezione illustra i nomi dei campi dello schema BigQuery per i log
voci i cui payload contengono l'indicatore @type
. Sono incluse le voci del log di controllo indirizzate a BigQuery.
I payload nelle voci di log possono contenere dati strutturati. Qualsiasi campo strutturato può includi un indicatore di tipo facoltativo nel formato seguente:
@type: type.googleapis.com/[TYPE]
Le regole di denominazione spiegano perché il campo protoPayload
di una voce di log di controllo potrebbe essere mappato al campo protopayload_auditlog
dello schema BigQuery.
Regole di denominazione per @type
I campi strutturati con specificatori di tipo vengono solitamente assegnati ai nomi dei campi BigQuery a cui è stato aggiunto [TYPE]
. Il valore di [TYPE]
può essere una stringa qualsiasi.
Le regole di denominazione per @type
si applicano solo al livello superiore di jsonPayload
o
protoPayload
; i campi nidificati vengono ignorati. Nel caso dei contenuti strutturati di primo livello,
nei campi del payload, Logging rimuove il prefisso type.googleapis.com
.
Ad esempio, la tabella seguente mostra la mappatura della struttura di primo livello dei campi payload ai nomi dei campi BigQuery:
Payload | Payload @type | Campo Payload | Nome campo BigQuery |
---|---|---|---|
jsonPayload |
(nessuno) | statusCode |
jsonPayload.statusCode |
jsonPayload |
type.googleapis.com/abc.Xyz |
statusCode |
jsonpayload_abc_xyz.statuscode |
protoPayload |
(nessuno) | statusCode |
protoPayload.statuscode |
protoPayload |
type.googleapis.com/abc.Xyz |
statusCode |
protopayload_abc_xyz.statuscode |
Alle regole precedenti per i campi con specificatori di tipo si applicano alcune eccezioni:
Nei log delle richieste di App Engine, il nome del payload nei log inviati a BigQuery è
protoPayload
, anche se il payload include un specificatore di tipo.Cloud Logging applica alcune regole speciali per Nomi dei campi dello schema BigQuery per gli audit log. Questo argomento è trattato nella sezione Campi dei log di controllo di questa pagina.
Esempio
Questo esempio mostra come vengono denominati e utilizzati i campi del payload strutturati quando ricevute da BigQuery.
Supponiamo che il payload di una voce di log sia strutturato come segue:
jsonPayload: {
@type: "type.googleapis.com/google.cloud.v1.CustomType"
name_a: {
sub_a: "A value"
}
name_b: {
sub_b: 22
}
}
La mappatura ai campi di BigQuery è la seguente:
Il campo strutturato di primo livello
jsonPayload
contiene un indicatore@type
. Il suo nome BigQuery èjsonpayload_v1_customtype
.I campi nidificati vengono trattati con Regole di denominazione BigQuery, come specificatore del tipo non si applicano ai campi nidificati.
Pertanto, i seguenti nomi BigQuery sono definiti per il log payload della voce:
jsonpayload_v1_customtype
jsonpayload_v1_customtype._type
jsonpayload_v1_customtype.name_b
jsonpayload_v1_customtype.name_b.sub_b
jsonpayload_v1_customtype.name_a
jsonpayload_v1_customtype.name_a.sub_a
Campi degli audit log
Se non utilizzi i log di controllo inviati a BigQuery, puoi saltare questa sezione.
I campi del payload del log di controllo protoPayload.request
, protoPayload.response
e protoPayload.metadata
hanno specificatori @type
, ma vengono trattati come dati JSON. Vale a dire, i nomi degli schemi BigQuery sono il loro campo
con l'aggiunta di Json
e contengono dati stringa in formato JSON.
I due set di nomi dei campi del payload degli audit log sono elencati di seguito tabella:
Campo di immissione del log | Nome campo BigQuery |
---|---|
protoPayload |
protopayload_auditlog |
protopayload.metadata |
protopayload_auditlog.metadataJson |
protoPayload.serviceData |
protopayload_auditlog.servicedata_v1_bigquery Esempio: protopayload_auditlog.servicedata_v1_bigquery.tableInsertRequest |
protoPayload.request |
protopayload_auditlog.requestJson |
protoPayload.response |
protopayload_auditlog.responseJson |
Tieni presente che la convenzione di denominazione serviceData
è specifica per i log di controllo generati da BigQuery e poi inoltrati da Cloud Logging a BigQuery. Queste voci di audit log contengono un
Campo serviceData
con un specificatore @type di
type.googleapis.com/google.cloud.bigquery.logging.v1.auditdata
.
Esempio
Una voce dell'audit log generata da BigQuery ha un campo con seguente nome:
protoPayload.serviceData.tableInsertRequest
Se questa voce di log venisse inoltrata a BigQuery, come verrebbe fatto riferimento al campo tableInsertRequest
? Prima dell'abbreviazione del nome,
il nome del campo corrispondente in BigQuery sarebbe:
protopayload_google_cloud_audit_auditlog.servicedata_google_cloud_bigquery_logging_v1_auditdata.tableInsertRequest
Dopo l'abbreviazione del nome, viene fatto riferimento allo stesso campo nelle tabelle BigQuery come segue:
protopayload_auditlog.servicedata_v1_bigquery.tableInsertRequest
Organizzazione della tabella
Questa sezione fornisce una panoramica tabelle partizionate per i log con routing in BigQuery.
Quando esegui il routing dei log su un set di dati BigQuery, Logging crea tabelle per contenere le voci di log. La prima voce di log ricevuta da BigQuery determina lo schema per la tabella BigQuery di destinazione. BigQuery crea una tabella le cui colonne si basano sui campi della prima voce di log e suoi tipi. Le voci di log successive potrebbero causare una mancata corrispondenza dello schema. Per su quando si verificano e come vengono gestiti, consulta Mancate corrispondenze nello schema.
Esistono due tipi di tabella per cui
Logging organizza i dati che instrada: tabelle con suddivisione in date e
tabelle partizionate. Entrambi i tipi di tabella suddividono i dati dei log in base ai log
voci timestamp
campi. Tuttavia, ci sono due differenze fondamentali tra
tipi di tabella come segue:
Prestazioni: una tabella partizionata suddivide una tabella grande in una tabella più piccola partizioni di memoria, in modo da poter migliorare le prestazioni delle query e, di conseguenza, controlla i costi di BigQuery riducendo il numero di byte letto da una query.
Nomenclatura delle tabelle: i tipi di tabelle utilizzano convenzioni di denominazione diverse, come discusso nella sezione di seguito.
Organizzazione della tabella
Le voci di log vengono suddivise con sharding in tabelle BigQuery organizzazione e nomi si basano sugli elementi nomi di log e timestamp.
I nomi delle tabelle hanno come suffisso la data di calendario del fuso orario UTC della voce di log timestamp, utilizzando il formato di base ISO 8601 (AAAAMMGG).
La tabella seguente mostra esempi di come vengono visualizzati nomi di log e timestamp di esempio mappate ai nomi delle tabelle in BigQuery:
Nome log | Voce del log timestamp 1 |
Nome della tabella BigQuery (con suddivisione in date) |
Nome tabella BigQuery (partizionata) |
---|---|---|---|
syslog |
2017-05-23T18:19:22.135Z |
syslog_20170523 |
syslog |
apache-access |
2017-01-01T00:00:00.000Z |
apache_access_20170101 |
apache_access |
compute.googleapis.com/activity_log |
2017-12-31T23:59:59.999Z |
compute_googleapis_com_activity_log_20171231 |
compute_googleapis_com_activity_log |
1 I timestamp voce di log sono espressi in UTC (Coordinated universale).
Creazione delle tabelle partizionate
Quando crei un sink per instradare i log a BigQuery, puoi utilizzare tabelle con suddivisione in partizioni per data o tabelle partizionate. La selezione predefinita è una tabella suddivisa in parti in base alla data:
Per istruzioni su come creare i sink, consulta le risorse seguenti:
Console Google Cloud: Indirizza i log alle destinazioni supportate.
Google Cloud CLI:
gcloud logging sinks create
Mancate corrispondenze nello schema
La prima voce di log ricevuta da BigQuery determina lo schema per la tabella BigQuery di destinazione. BigQuery crea una tabella le cui colonne si basano sui campi della prima voce di log e suoi tipi.
Si verifica una mancata corrispondenza dello schema quando le voci di log vengono scritte nella destinazione tabella e si verifica uno dei seguenti errori:
Una voce di log successiva modifica il tipo di campo di un campo esistente nella tabella.
Ad esempio, se il campo
jsonPayload.user_id
della voce di log iniziale è unstring
, la voce di log genera una tabella con un tipo di stringa corrispondente . Se in un secondo momento inizi a registrarejsonPayload.user_id
comearray
, si verifica una mancata corrispondenza dello schema.Una nuova voce di log contiene un campo che non è nello schema attuale e l'inserimento di questo campo nella tabella di destinazione supererebbe il limite di colonne BigQuery.
La tabella di destinazione può accettare il nuovo campo se questo non genera la visualizzazione della colonna limite da superare.
Quando BigQuery identifica una mancata corrispondenza dello schema, crea una tabella
all'interno del set di dati corrispondente
per archiviare le informazioni sull'errore. La
determina il nome della tabella. Per le tabelle con suddivisione in parti in base alla data, il formato dei nomi è
export_errors_YYYYMMDD
. Per le tabelle partizionate, il formato di denominazione è
export_errors
. Per ulteriori informazioni, vedi Organizzazione della tabella.
Quando esegui il routing delle voci di log, Logging invia i messaggi in batch in BigQuery. BigQuery utilizza le seguenti regole per determinare in quale tabella vengono scritte le voci di log nel batch corrente di messaggi:
Quando si verifica una modifica del tipo di campo, nella tabella degli errori vengono registrate solo le voci di log che hanno causato una mancata corrispondenza dello schema. Registra le voci del batch corrente di messaggi che non vengono scritte una mancata corrispondenza dello schema nella tabella di destinazione originale.
Quando viene superato il limite di colonne, tutte le voci di log nel batch corrente di messaggi vengono scritte in nella tabella degli errori.
Schema della tabella degli errori
La tabella degli errori contiene i dati di LogEntry
e le informazioni
relative alla mancata corrispondenza:
logEntry
: contiene la voce di log completa. ma la voce di log convertito da JSON in una stringa.schemaErrorDetail
: contiene il messaggio di errore completo restituito da in BigQuery.sink
: contiene il percorso completo della risorsa per il sink di log.logName
: estratto daLogEntry
.timestamp
: estratto daLogEntry
.receiveTimestamp
: estratto daLogEntry
.severity
: estratto daLogEntry
.insertId
: estratto dalla tabellaLogEntry
.trace
: estratto dalla tabellaLogEntry
.resourceType
: estratto daLogEntry
.
Logging comunica le mancate corrispondenze dello schema progetto Google Cloud che contiene il sink di routing nei seguenti modi:
- I proprietari del progetto ricevono un'email. Dettagli includi l'ID progetto Google Cloud, il nome del sink e la destinazione.
- Nella pagina Attività della console Google Cloud viene visualizzato un errore,
Stackdriver Config error
. I dettagli includono il nome e la destinazione del sink e un link a un esempio di voce di log che ha causato l'errore.
Previeni le future mancate corrispondenze dei tipi di campo
Per correggere le mancate corrispondenze del tipo di campo per le voci di log successive, correggi il tipo di campo in modo che corrisponda allo schema corrente. Per informazioni su come correggere un tipo di campo, consulta Modificare il tipo di dati di una colonna.
A volte il tipo di campo non può essere modificato, ad esempio, non puoi modificare tipo di campo per i log generati automaticamente da Google Cloud i servizi di machine learning. Per evitare mancate corrispondenze dello schema quando non puoi modificare un tipo di campo, rinomina la tabella o modifica i parametri del sink in modo che Logging ricrei la tabella in un set di dati diverso. Per istruzioni, vedi Gestisci i sink.
Risoluzione dei problemi
Se nella destinazione del sink sembrano mancare dei log o se sospetti che il sink non stia instradando correttamente i log, consulta Risolvere i problemi relativi all'instradamento dei log.
Prezzi
Cloud Logging non addebita alcun costo per il routing dei log a una destinazione supportata. Tuttavia, la destinazione potrebbe applicare dei costi.
Ad eccezione del bucket di log _Required
,
Cloud Logging addebita un costo per trasferire i log nei bucket di log.
per un'archiviazione più lunga del periodo di conservazione predefinito del bucket di log.
Cloud Logging non addebita alcun costo per la copia dei log, per la definizione degli ambiti di log, o per le query inviate tramite Pagine Esplora log o Analisi dei log.
Per ulteriori informazioni, consulta i seguenti documenti:
- Riepilogo dei prezzi di Cloud Logging
Costi di destinazione:
- I costi di generazione dei log di flusso VPC si applicano quando invii e poi escludi i log di flusso Virtual Private Cloud da Cloud Logging.