Sviluppa estensioni del parser

Supportata in:

Questo documento spiega come creare estensioni del parser per estrarre i campi dai dati di log non elaborati e mapparli ai campi UDM (Unified Data Model) di destinazione all'interno della piattaforma Google Security Operations.

Il documento descrive la procedura di creazione delle estensioni del parser:

Crea estensioni parser

Le estensioni del parser offrono un modo flessibile per estendere le funzionalità dei parser predefiniti (e personalizzati) esistenti. Le estensioni del parser offrono un modo flessibile per estendere le funzionalità dei parser predefiniti (o personalizzati) esistenti senza sostituirli. Le estensioni ti consentono di personalizzare la pipeline del parser aggiungendo nuova logica di analisi, estraendo e trasformando i campi e aggiornando o rimuovendo le mappature dei campi UDM.

Un'estensione del parser non è la stessa cosa di un parser personalizzato. Puoi creare un parser personalizzato per un tipo di log che non ha un parser predefinito o per disattivare gli aggiornamenti del parser.

Processo di estrazione e normalizzazione del parser

Google SecOps riceve i dati dei log originali come log non elaborati. I parser predefiniti (e personalizzati) estraggono e normalizzano i campi dei log principali in campi UDM strutturati nei record UDM. Rappresenta solo un sottoinsieme dei dati dei log non elaborati originali. Puoi definire estensioni del parser per estrarre i valori dei log non gestiti dai parser predefiniti. Una volta attivate, le estensioni del parser diventano parte del processo di estrazione e normalizzazione dei dati di Google SecOps.

Workflow di importazione e normalizzazione

Definisci nuove estensioni parser

I parser predefiniti contengono insiemi predefiniti di istruzioni di mappatura che specificano come estrarre, trasformare e normalizzare i valori di sicurezza principali. Puoi creare nuove estensioni del parser definendo le istruzioni di mappatura utilizzando l'approccio no-code (Mappa i campi di dati) o l'approccio dello snippet di codice:

  • Approccio no-code

    L'approccio no-code è più adatto per estrazioni semplici da log non elaborati in formato JSON, XML o CSV nativo. Consente di specificare i campi di origine dei log non elaborati e di mappare i campi UDM di destinazione corrispondenti.

    Ad esempio, per estrarre dati di log JSON con un massimo di 10 campi, utilizzando semplici confronti di uguaglianza.

  • Approccio con snippet di codice

    L'approccio con snippet di codice consente di definire istruzioni per estrarre e trasformare i valori dal log non elaborato e assegnarli ai campi UDM. Gli snippet di codice utilizzano la stessa sintassi simile a Logstash del parser predefinito (o personalizzato).

    Questo approccio è applicabile a tutti i formati di log supportati. È la soluzione migliore per questi scenari:

    • Estrazioni di dati complesse o logica complessa.
    • Dati non strutturati che richiedono parser basati su Grok.
    • Formati non JSON come CSV e XML.

    Gli snippet di codice utilizzano le funzioni per estrarre dati specifici dai dati di log non elaborati. Ad esempio, Grok, JSON, KV e XML.

    Nella maggior parte dei casi, è meglio utilizzare l'approccio di mappatura dei dati utilizzato nel parser predefinito (o personalizzato).

Unisci i valori appena estratti nei campi UDM

Una volta attivate, le estensioni del parser uniscono i valori appena estratti nei campi UDM designati nel record UDM corrispondente in base ai principi di unione predefiniti. Ad esempio:

  • Sovrascrivi i valori esistenti: i valori estratti sovrascrivono i valori esistenti nei campi UDM di destinazione.

    L'unica eccezione sono i campi ripetuti, in cui puoi configurare l'estensione del parser per aggiungere nuovi valori durante la scrittura dei dati in un campo ripetuto nel record UDM.

  • L'estensione del parser ha la precedenza: le istruzioni di mappatura dei dati in un'estensione del parser hanno la precedenza su quelle nel parser predefinito (o personalizzato) per quel tipo di log. In caso di conflitto nelle istruzioni di mappatura, l'estensione del parser sovrascriverà il valore impostato per impostazione predefinita.

    Ad esempio, se il parser predefinito mappa un campo del log non elaborato al campo UDM event.metadata.description e l'estensione del parser mappa un campo del log non elaborato diverso allo stesso campo UDM, l'estensione del parser sovrascrive il valore impostato dal parser predefinito.

Selettore dei campi ripetuti

Sia nell'approccio Mappa i campi di dati (no-code) sia in quello Scrivi snippet di codice, puoi controllare il modo in cui l'estensione del parser salva i valori nei campi ripetuti (campi che supportano un array di valori, ad esempio principal.ip). Nel riquadro Estensione (definizione dell'estensione), utilizza il campo Campi ripetuti, che offre le opzioni Aggiungi valori e Sostituisci valori.

Comportamento di aggiunta e sostituzione

Alcuni campi UDM memorizzano un array di valori, ad esempio il campo principal.ip. Il selettore Campi ripetuti ti consente di controllare in che modo l'estensione del parser archivia i dati appena estratti in un campo ripetuto:

  • Aggiungi valori:

    L'estensione del parser aggiungerà il valore appena estratto all'array di valori esistenti nel campo UDM.

  • Sostituisci valori:

    L'estensione del parser sostituirà l'array di valori esistenti nel campo UDM con il valore appena estratto.

Un'estensione del parser può mappare i dati a un campo ripetuto solo quando il campo ripetuto si trova al livello più basso della gerarchia. Ad esempio:

  • La mappatura dei valori a udm.principal.ip è supportata perché il campo ip ripetuto si trova al livello più basso della gerarchia e principal non è un campo ripetuto.
  • La mappatura dei valori a udm.intermediary.hostname non è supportata perché intermediary è un campo ripetuto e non si trova al livello più basso della gerarchia.

La tabella seguente fornisce esempi di come la configurazione del selettore Campi ripetuti influisce sul record UDM generato.

Selezione Campi ripetuti Log di esempio Configurazione dell'estensione parser Risultato generato
Aggiungi valori {"protoPayload":{"@type":"type.AuditLog","authenticationInfo":{"principalEmail":""},"requestMetadata":{"callerIp":"1.1.1.1, 2.2.2.2"}}} Campo precondizione: protoPayload.requestMetadata.callerIp
Valore precondizione: " "
Operatore precondizione: NOT_EQUALS
Campo di dati non elaborati: protoPayload.requestMetadata.callerIp
Campo di destinazione: event.idm.read_only_udm.principal.ip 		metadata:{event_timestamp:{}.....}principal:{Ip:"1.1.1.1, 2.2.2.2"} } }
Aggiungi valori {"protoPayload":{"@type":"type.AuditLog","authenticationInfo":{"principalEmail":""},"requestMetadata":{"callerIp":"2.2.2.2, 3.3.3.3", "name":"Akamai Ltd"}}} Precondizione 1:
Campo precondizione:protoPayload.requestMetadata.callerIp
Valore precondizione: " "
Operatore precondizione: NOT_EQUALS
Campo dati non elaborati: protoPayload.requestMetadata.callerIp
Campo di destinazione: event.idm.read_only_udm.principal.ip

Precondizione 2:
Campo di dati non elaborati: protoPayload.requestMetadata.name
Campo di destinazione: event.idm.read_only_udm.metadata.product_name

 Eventi generati dal parser predefinito prima di applicare l'estensione.
metadata:{event_timestamp:{} ... principal:{ip:"1.1.1.1"}}}

Output dopo l'applicazione dell'estensione.
timestamp:{} idm:{read_only_udm:{metadata:{event_timestamp:{} .... product_name: "Akamai Ltd"}principal:{ip:"1.1.1.1, 2.2.2.2, 3.3.3.3"}}}

Sostituisci valori {"protoPayload":{"@type":"type..AuditLog","authenticationInfo":{"principalEmail":""},"requestMetadata":{"callerIp":"2.2.2.2"}}} Campo precondizione: protoPayload.authenticationInfo.principalEmail
Valore precondizione: " "
Operatore precondizione: NOT_EQUALS
Campo di dati non elaborati: protoPayload.authenticationInfo.principalEmail
Campo di destinazione: event.idm.read_only_udm.principal.ip 		Eventi UDM generati dal parser predefinito prima di applicare l'estensione.
timestamp:{} idm:{read_only_udm:{metadata:{event_timestamp:{} ... principal:{ip:"1.1.1.1"}}}

Output UDM dopo l'applicazione dell'estensione timestamp:{} idm:{read_only_udm:{metadata:{event_timestamp:{} ....} principal:{ip:"2.2.2.2"}}}

Limitazioni

  • Un'estensione del parser per tipo di log: puoi creare una sola estensione del parser per tipo di log.
  • Un solo approccio alle istruzioni di mappatura dei dati: puoi creare un'estensione del parser utilizzando l'approccio no-code o lo snippet di codice, ma non entrambi gli approcci contemporaneamente.
  • Esempi di log per la convalida: per convalidare un'estensione del parser UDM, sono necessari esempi di log degli ultimi 30 giorni. Per maggiori dettagli, consulta Assicurati che esista un parser attivo per il tipo di log.
  • Errori del parser di base: gli errori del parser di base non sono identificabili o correggibili all'interno delle estensioni del parser.
  • Gestione dei campi ripetuti: puoi utilizzare un solo metodo (Aggiungi o Sostituisci) in un'estensione specifica. Fai attenzione quando sostituisci interi oggetti ripetuti per evitare perdite di dati involontarie.
  • Additional.fields viene interpretato come un insieme di coppie chiave-valore, non come un campo ripetuto: di conseguenza, puoi combinare senza problemi sia le mappature UDM del parser sia gli output UDM dell'estensione aggiungendo le rispettive coppie chiave-valore all'insieme.
  • Eventi disambiguati: le estensioni del parser non possono gestire i log con più eventi univoci in un singolo record, ad esempio l'array di Google Drive.
  • XML e no-code: la modalità no-code non è supportata per XML. Utilizza invece il metodo dello snippet di codice.
  • Sintassi del parser rispetto alle regole di rilevamento YARA-L: i parser di importazione e le estensioni del parser utilizzano Logstash Grok e la sintassi di configurazione con filtri (ad esempio grok, mutate, json, date e base64) al momento dell'importazione per analizzare i log non elaborati in Unified Data Model (UDM). I parser non possono utilizzare la sintassi YARA-L, i blocchi dei risultati o le funzioni generatore (come yield). YARA-L 2.0 è un linguaggio di query del motore di rilevamento valutato a valle sugli eventi UDM normalizzati per gli avvisi sulle minacce e non può analizzare i log non elaborati, modificare i campi UDM o eliminare il traffico dei log in entrata.
  • Applicazione solo in avanti per impostazione predefinita: per impostazione predefinita, le estensioni del parser si applicano ai log appena importati solo dal momento dell'attivazione. Se esiste un'esigenza aziendale critica di analizzare nuovamente i log storici con mappature aggiornate, puoi richiedere un'attività di riproduzione dei log di backend tramite l'assistenza Google Cloud . Per saperne di più, consulta Analizza nuovamente i dati storici (riproduzione dei log).
  • Etichette di importazione inaccessibili nella logica del parser: le estensioni del parser non possono leggere le etichette di importazione (metadata.ingestion_labels) per mappare i valori nei campi UDM perché i parser vengono eseguiti in un ambiente di esecuzione in sandbox con visibilità solo sul corpo del log non elaborato.
  • Parole chiave riservate con l'approccio no-code: se i log contengono una delle seguenti parole chiave riservate, utilizza l'approccio con snippet di codice anziché l'approccio no-code:
    • collectionTimestamp
    • createTimestamp
    • enableCbnForLoop
    • event
    • filename
    • message
    • namespace
    • output
    • onErrorCount
    • timestamp
    • timezone
  • Rimuovi le mappature esistenti: puoi rimuovere le mappature dei campi UDM esistenti utilizzando solo l'approccio dello snippet di codice.
  • Nessuna rimozione della mappatura di un campo UDM del nome host utilizzando un'estensione: non puoi annullare (rimuovere) una mappatura di un campo UDM del nome host (ad esempio principal.hostname) utilizzando un'estensione.

Concetti relativi ai parser

I seguenti documenti spiegano concetti importanti relativi ai parser:

Prerequisiti

Prerequisiti per la creazione di estensioni del parser:

  • Deve essere presente un parser predefinito (o personalizzato) attivo per il tipo di log.
  • Google SecOps deve essere in grado di importare e normalizzare i log non elaborati utilizzando un parser predefinito (o personalizzato).
  • Assicurati che il parser predefinito (o personalizzato) attivo per il tipo di log di destinazione abbia importato dati di log non elaborati negli ultimi 30 giorni. Questi dati devono contenere un campione dei campi che intendi estrarre o utilizzare per filtrare i record di log. Verrà utilizzato per convalidare le nuove istruzioni di mappatura dei dati.

Inizia

Prima di creare un'estensione del parser, segui questi passaggi:

  1. Verifica i prerequisiti:

    Assicurati che esista un parser attivo per il tipo di log. Se non ha ancora un parser, creane uno personalizzato.

  2. Identifica i campi da estrarre dai log grezzi:

    Identifica i campi che vuoi estrarre dai log non elaborati.

  3. Seleziona i campi UDM appropriati:

    Seleziona i campi UDM corrispondenti appropriati per mappare i campi dei log non elaborati estratti.

  4. Scegli un approccio di definizione dell'estensione parser:

    Scegli uno dei due approcci di estensione (approcci di mappatura dei dati) per creare l'estensione del parser.

Verifica i prerequisiti

Assicurati che esista un parser attivo per il tipo di log che intendi estendere, come descritto nelle sezioni seguenti:

Assicurati che esista un parser attivo per il tipo di log

Assicurati che esista un parser predefinito (o personalizzato) attivo per il tipo di log che intendi estendere.

Cerca il tipo di log in questi elenchi:

Assicurati che esista un parser personalizzato per il tipo di log

Per assicurarti che esista un parser personalizzato per un tipo di log:

  1. Nella barra di navigazione, seleziona Impostazioni > Gestione dei dati > Parser. Se utilizzi una piattaforma solo SIEM, vai a Impostazioni > Parser.

  2. Cerca nella tabella Parser il tipo di log che vuoi estendere.

Assicurati che il parser sia attivo per il tipo di log

Per verificare se un parser è attivo per un tipo di log, segui questi passaggi:

  1. Nella barra di navigazione, seleziona Impostazioni > Gestione dei dati > Parser. Se utilizzi una piattaforma solo SIEM, vai a Impostazioni > Parser.

  2. Cerca nella tabella Parser il tipo di log che vuoi estendere.

    Se il parser per il tipo di log non è attivo, attivalo:

Identifica i campi da estrarre dai log non elaborati

Analizza il log non elaborato da cui vuoi estrarre i dati per identificare i campi non estratti dal parser predefinito (o personalizzato). Presta attenzione al modo in cui il parser predefinito (o personalizzato) estrae i campi dei log non elaborati e li mappa ai campi UDM corrispondenti.

Per identificare i campi specifici che vuoi estrarre dai log non elaborati, puoi utilizzare gli strumenti di ricerca per identificare i campi:

Per maggiori dettagli sulla ricerca nei log non elaborati, consulta:

Seleziona i campi UDM appropriati

Ora che hai identificato i campi target specifici da estrarre, puoi abbinarli ai campi UDM di destinazione corrispondenti. Stabilisci una mappatura chiara tra i campi di origine dei log non elaborati e i campi UDM di destinazione. Puoi mappare i dati a qualsiasi campo UDM che supporti i tipi di dati standard o i campi ripetuti.

Scegli il campo UDM corretto

Le seguenti risorse possono aiutarti a semplificare la procedura:

Acquisisci familiarità con i concetti principali di UDM

  • Oggetti logici: Evento ed Entità

    Lo schema UDM descrive tutti gli attributi disponibili che archiviano i dati. Ogni record UDM descrive un evento o un'entità. I dati vengono archiviati in campi diversi a seconda che il record descriva un evento o un'entità.

    • Un oggetto Evento UDM archivia i dati relativi all'azione che si è verificata nell'ambiente. Il log eventi originale descrive l'azione così come è stata registrata dal dispositivo, ad esempio firewall o proxy web.
    • Gli oggetti Entità UDM archiviano i dati relativi ai partecipanti o alle entità coinvolti nell'evento UDM, ad esempio asset, utenti o risorse nel tuo ambiente.

  • Struttura di un evento UDM

  • Struttura di un'entità UDM

  • Sostantivi UDM: un sostantivo rappresenta un partecipante o un'entità in un evento UDM. Un sostantivo potrebbe essere, ad esempio, il dispositivo o l'utente che esegue l'attività descritta nell'evento. Un sostantivo potrebbe anche essere il dispositivo o l'utente che è il target dell'attività descritta nell'evento.

    Sostantivo UDM Descrizione
    principal L'entità responsabile dell'avvio dell'azione descritta nell'evento.
    target L'entità che è il destinatario o l'oggetto dell'azione. In una connessione firewall, la macchina che riceve la connessione è la destinazione.
    src Un'entità di origine su cui agisce l'entità. Ad esempio, se un utente copia un file da un computer a un altro, il file e il computer di origine verranno rappresentati come src.
    intermediary Qualsiasi entità che funge da intermediario nell'evento, ad esempio un server proxy. Possono influenzare l'azione, ad esempio bloccando o modificando una richiesta.
    observer Un'entità che monitora e genera report sull'evento, ma non interagisce direttamente con il traffico. Alcuni esempi sono i sistemi di rilevamento delle intrusioni di rete o i sistemi di security information and event management.
    about Qualsiasi altra entità coinvolta nell'evento che non rientra nelle categorie precedenti. Ad esempio, allegati email o DLL caricate durante l'avvio di un processo.

    In pratica, gli oggetti Noun principali e target sono quelli più utilizzati. È inoltre importante notare che le descrizioni precedenti costituiscono l'utilizzo consigliato dei sostantivi. L'utilizzo effettivo può variare in base all'implementazione di un parser di base predefinito o personalizzato.

Comprendi la mappatura dei dati utilizzata dal parser esistente

Ti consigliamo di comprendere la mappatura dei dati esistente utilizzata dal parser predefinito (o personalizzato) tra i campi di origine dei log non elaborati e i campi UDM di destinazione.

Per visualizzare la mappatura dei dati tra i campi di origine dei log non elaborati e i campi UDM di destinazione utilizzati nel parser predefinito (o personalizzato) esistente:

  1. Nella barra di navigazione, seleziona Impostazioni > Gestione dei dati > Parser. Se utilizzi una piattaforma solo SIEM, vai a Impostazioni > Parser.
  2. Cerca nella tabella Parser il tipo di log che vuoi estendere.

  3. Vai alla riga, quindi fai clic su Menu > Visualizza.

    Nella scheda Predefinito (o Personalizzato), la sezione Codice parser mostra la mappatura dei dati tra i campi di origine dei log non elaborati e i campi UDM di destinazione utilizzati nel parser predefinito (o personalizzato) esistente.

Utilizza lo strumento di ricerca UDM

Utilizza lo strumento di ricerca UDM per identificare i campi UDM che corrispondono ai campi di origine dei log non elaborati.

Google SecOps fornisce lo strumento di ricerca UDM per aiutarti a trovare rapidamente i campi UDM di destinazione. Per accedere allo strumento di ricerca UDM, vai a Indagine > Ricerca SIEM.

Consulta i seguenti argomenti per informazioni dettagliate su come utilizzare lo strumento di ricerca UDM:

Esempio di strumento di ricerca UDM

Ad esempio, se nel log non elaborato è presente un campo di origine denominato "packets", utilizza lo strumento di ricerca UDM per trovare potenziali campi UDM di destinazione con "packets" nel nome:

  1. Vai a Indagine > Ricerca SIEM.

  2. Nella pagina Ricerca SIEM, fai clic su Ricerca UDM.

    Si apre la finestra di dialogo Ricerca UDM. Lo strumento di ricerca trova i campi UDM in base al nome del campo o al valore del campo:

    • Ricerca per nome campo: associa la stringa di testo inserita ai nomi dei campi contenenti quel testo.
    • Ricerca per valore del campo: associa il valore inserito ai campi che contengono quel valore nei dati di log archiviati.

  3. Nella finestra di dialogo Ricerca UDM, inserisci "packets" nel campo Cerca valori/campi UDM e seleziona Campi UDM.

    La funzione di ricerca mostrerà un elenco di potenziali campi UDM contenenti il testo "packets" nei nomi dei campi UDM.

  4. Fai clic su ogni riga una alla volta per visualizzare la descrizione di ogni campo UDM.

Considerazioni importanti su UDM per evitare errori

  • Campi dall'aspetto simile: la struttura gerarchica di UDM può portare a campi con nomi simili. Per indicazioni, consulta gli analizzatori sintattici predefiniti. Per maggiori dettagli, consulta Informazioni sulla mappatura dei dati utilizzata dal parser esistente.
  • Mappatura dei campi arbitraria: utilizza l'oggetto additional per i dati che non vengono mappati direttamente a un campo UDM. Per maggiori dettagli, consulta Mappatura di campi arbitrari in UDM.
  • Campi ripetuti: fai attenzione quando utilizzi i campi ripetuti negli snippet di codice. La sostituzione di un intero oggetto potrebbe sovrascrivere i dati originali. L'approccio no-code offre un maggiore controllo sui campi ripetuti. Per i dettagli, consulta Selettore di campi ripetuti.
  • Campi UDM obbligatori per i tipi di eventi UDM: quando assegni un campo UDM metadata.event_type a un record UDM, ogni event_type richiede la presenza di un insieme diverso di campi correlati nel record UDM. Per maggiori dettagli, consulta Scopri di più sull'assegnazione dei campi UDM metadata.event_type.
  • Problemi del parser di base: le estensioni del parser non possono correggere gli errori del parser di base. Il parser di base è il parser predefinito (o personalizzato) che ha creato il record UDM. Valuta opzioni come il miglioramento dell'estensione del parser, la modifica del parser di base o il pre-filtraggio dei log.
Mappatura di campi arbitrari in UDM

Quando non riesci a trovare un campo UDM standard adatto per archiviare i tuoi dati, utilizza l'oggetto additional per archiviarli come coppia chiave-valore personalizzata. In questo modo puoi archiviare informazioni preziose nel record UDM, anche se non esiste un campo UDM corrispondente.

Scegli un approccio per la definizione delle estensioni del parser

Prima di scegliere un approccio per la definizione delle estensioni del parser, devi aver letto queste sezioni:

I passaggi successivi consistono nell'aprire la pagina Parser Extension e nel selezionare l'approccio di estensione da utilizzare per definire l'estensione del parser:

Apri la pagina Estensione parser

La pagina Parser Extension (Estensione parser) ti consente di definire la nuova estensione parser.

Puoi aprire la pagina Estensione parser nei seguenti modi, dal menu Impostazioni, da una Ricerca log non elaborati o da una Ricerca log non elaborati precedente:

Apri dal menu Impostazioni

Per aprire la pagina Estensione parser dal menu Impostazioni:

  1. Nella barra di navigazione, seleziona Impostazioni > Gestione dei dati > Parser. Se utilizzi una piattaforma solo SIEM, vai a Impostazioni > Parser.

    La tabella Parser mostra un elenco di parser predefiniti per tipo di log.

  2. Trova il tipo di log che vuoi estendere, fai clic su Menu > Estendi parser > Crea estensione.

    Viene visualizzata la pagina Parser Extension.

Per aprire la pagina Estensione parser da una Ricerca log non elaborati:

  1. Vai a Indagine > Ricerca SIEM.
  2. Nel campo di ricerca, aggiungi il prefisso raw = all'argomento di ricerca e racchiudi il termine di ricerca tra virgolette. Ad esempio, raw = "example.com".
  3. Fai clic su Esegui ricerca. I risultati vengono visualizzati nel riquadro Log non elaborati.
  4. Fai clic su un log (riga) nel riquadro Log non elaborati. Viene visualizzato il riquadro Visualizzatore eventi.
  5. Fai clic sulla scheda Log non elaborato nel riquadro Visualizzatore eventi. Viene visualizzato il log non elaborato.

  6. Fai clic su Gestisci parser > Estendi parser > Crea estensione (o seleziona Crea estensione > Avanti).

    Viene visualizzata la pagina Parser Extension.

Per aprire la pagina Estensione parser da una Ricerca log non elaborati legacy:

  1. Utilizza la funzionalità legacy Ricerca nei log non elaborati per cercare record simili a quelli che verranno analizzati.
  2. Seleziona un evento (o fai clic sull'icona del log non elaborato) dal riquadro Cronologia per aprire il log non elaborato.

  3. Fai clic su Gestisci parser > Estendi parser > Crea estensione (o seleziona Crea estensione > Avanti).

    Viene visualizzata la pagina Parser Extension.

Pagina Estensione parser

La pagina mostra i riquadri Log non elaborato ed Estensione (definizione dell'estensione):

  • Riquadro Log non elaborato:

    Vengono visualizzati i dati di log non elaborati di esempio per il tipo di log selezionato. Se hai aperto la pagina dalla Ricerca nei log non elaborati, i dati campionati sono il risultato della ricerca. Puoi formattare l'esempio utilizzando il menu Visualizza come (Non elaborato, JSON, CSV, XML o Hex/ASCII) e la casella di controllo Testo a capo.

    1. Verifica che l'esempio di dati di log non elaborati visualizzato sia rappresentativo dei log che verranno elaborati dall'estensione parser.

    2. Fai clic su Anteprima output UDM (o Mostra output UDM) per visualizzare l'output UDM per i dati dei log non elaborati di esempio.

  • Riquadro Estensione (definizione dell'estensione):

    In questo modo puoi definire un'estensione del parser utilizzando uno dei due approcci alle istruzioni di mappatura: Mappa campi di dati (senza codice) o Scrivi snippet di codice (o Scrivi snippet di codice). Non puoi utilizzare entrambi gli approcci nella stessa estensione del parser.

    A seconda dell'approccio scelto, puoi specificare i campi dei dati dei log di origine da estrarre dai log non elaborati in entrata e mapparli ai campi UDM corrispondenti oppure puoi scrivere uno snippet di codice per eseguire queste attività e altro ancora.

Seleziona l'approccio di estensione

Nella pagina Estensione parser, nel riquadro Estensione, nel campo Metodo di estensione, seleziona uno dei seguenti approcci per creare l'estensione parser:

  • Mappatura dei campi di dati (approccio no-code):

    Questo approccio ti consente di specificare i campi nel log non elaborato e di mapparli ai campi UDM di destinazione.

    Questo approccio funziona con i seguenti formati di log non elaborati:

    • JSON nativo, XML nativo o CSV.
    • Intestazione Syslog più JSON nativo, XML nativo o CSV. Puoi creare istruzioni di mappatura dei tipi di campi di dati per i log non elaborati in questi formati: JSON, XML, CSV, SYSLOG + JSON, SYSLOG + XML e SYSLOG + CSV.

    Consulta i passaggi successivi, Istruzioni per la creazione no-code (mappatura dei campi di dati).

  • Approccio Scrivi snippet di codice (o Scrivi snippet di codice):

    Questo approccio ti consente di utilizzare una sintassi simile a Logstash per specificare le istruzioni per estrarre e trasformare i valori dal log non elaborato e assegnarli ai campi UDM nel record UDM.

    • Gli snippet di codice utilizzano la stessa sintassi e le stesse sezioni dei parser predefiniti (o personalizzati). Per saperne di più, consulta Sintassi del parser.

    • Questo approccio funziona con tutti i formati dei dati supportati per quel tipo di log.

    Consulta i passaggi successivi, Istruzioni per la creazione di snippet di codice.

Istruzioni per la creazione di mappe senza codice (campi di dati della mappa)

L'approccio no-code (chiamato anche metodo Mappa i campi di dati) ti consente di specificare i percorsi dei campi dei log non elaborati e di mapparli ai campi UDM di destinazione corrispondenti.

Prima di creare un'estensione del parser utilizzando l'approccio no-code, devi aver completato queste sezioni:

I passaggi successivi per definire l'estensione del parser sono:

  1. Imposta il selettore Campi ripetuti
  2. Definisci un'istruzione di mappatura dei dati per ogni campo
  3. Invia e attiva l'estensione del parser

Definisci un'istruzione di mappatura dei dati per ogni campo

Definisci un'istruzione di mappatura dei dati per ogni campo che vuoi estrarre dal log non elaborato. L'istruzione deve specificare il percorso del campo di origine nel log non elaborato e mapparlo al campo UDM di destinazione.

  1. Se l'esempio di log non elaborato visualizzato nel riquadro Log non elaborato contiene un'intestazione Syslog, vengono visualizzati i campi Syslog e Target. (Alcuni formati di log non contengono un'intestazione Syslog, ad esempio JSON nativo, XML nativo o CSV).

    Google SecOps avrà bisogno dei campi Syslog e Target per pre-elaborare l'intestazione Syslog ed estrarre la parte strutturata del log.

    1. Definisci questi campi:

      • Syslog: si tratta di un pattern definito dall'utente che pre-elabora e separa un'intestazione Syslog dalla parte strutturata di un log non elaborato.

        Specifica il pattern di estrazione, utilizzando Grok ed espressioni regolari, che identifica l'intestazione Syslog e il messaggio di log non elaborato. Per maggiori dettagli, vedi Definisci i campi dell'estrattore Syslog.

      • Target: nome della variabile nel campo Syslog che memorizza la parte strutturata del log.

        Specifica il nome della variabile nel pattern di estrazione che memorizza la parte strutturata del log.

      Questo è un esempio di pattern di estrazione e di nome di variabile rispettivamente per i campi Syslog e Target.

      Campi dell'estrattore syslog

    2. Dopo aver inserito i valori nei campi Syslog e Target, fai clic sul pulsante Convalida.

      La procedura di convalida verifica la presenza di errori di sintassi e di analisi, quindi restituisce uno dei seguenti risultati:

      • Operazione riuscita: vengono visualizzati i campi di mappatura dei dati. Definisci il resto dell'estensione del parser.
      • Errore: viene visualizzato un messaggio di errore. Correggi la condizione di errore prima di continuare.

  2. Facoltativamente, definisci un'istruzione di precondizione.

    Un'istruzione di precondizione identifica un sottoinsieme dei log non elaborati che l'estensione del parser elabora abbinando un valore statico a un campo nel log non elaborato. Se un log non elaborato in entrata soddisfa i criteri della precondizione, l'estensione del parser applica l'istruzione di mappatura. Se i valori non corrispondono, l'estensione del parser non applica l'istruzione di mappatura.

    Completa i seguenti campi:

    • Campo precondizione (o Colonna precondizione per CSV): identificatore del campo nel log non elaborato contenente il valore da confrontare. Inserisci il percorso completo del campo se il formato dei dati dei log è JSON o XML oppure la posizione della colonna se il formato dei dati è CSV.
    • Operatore di precondizione: seleziona Uguale a o Diverso da.
    • Valore precondizione: il valore statico che verrà confrontato con il Campo precondizione nel log non elaborato.

    Per un altro esempio di istruzione di precondizione, consulta No-code - Estrai campi con valore di precondizione.

  3. Mappa il campo dei dati dei log non elaborati al campo UDM di destinazione:

    • Campo dati non elaborati (o Colonna dati non elaborati per CSV): inserisci il percorso completo del campo se il formato dei dati dei log è JSON (ad esempio: jsonPayload.connection.dest_ip) o XML (ad esempio: /Event/Reason-Code) oppure la posizione della colonna se il formato dei dati è CSV (nota: le posizioni dell'indice iniziano da 1).

    • Campo di destinazione: inserisci il nome completo del campo UDM in cui verrà archiviato il valore, ad esempio udm.metadata.collected_timestamp.seconds.

  4. Per continuare ad aggiungere altri campi, fai clic su Aggiungi e inserisci tutti i dettagli delle istruzioni di mappatura per il campo successivo.

Per un altro esempio di mappatura dei campi, consulta No-code - Estrai campi.

Invia e attiva l'estensione del parser

Dopo aver definito le istruzioni di mappatura dei dati per tutti i campi che intendi estrarre dal log non elaborato, invia e attiva l'estensione del parser.

Fai clic su Invia per salvare e convalidare l'istruzione di mappatura.

Google SecOps convalida le istruzioni di mappatura:

  • Se il processo di convalida va a buon fine, lo stato cambia in In tempo reale e le istruzioni di mappatura iniziano a elaborare i dati di log in entrata.

  • Se il processo di convalida non va a buon fine, lo stato diventa Non riuscito e viene visualizzato un errore nel campo Log non elaborato.

    Questo è un esempio di errore di convalida:

      ERROR: generic::unknown: pipeline.ParseLogEntry failed: LOG_PARSING_CBN_ERROR:
  "generic::invalid_argument: pipeline failed: filter mutate (7) failed: copy failure:
  copy source field \"jsonPayload.dest_instance.region\" must not be empty
  (try using replace to provide the value before calling copy)

  "LOG: {"insertId":"14suym9fw9f63r","jsonPayload":{"bytes_sent":"492",
  "connection":{"dest_ip":"10.12.12.33","dest_port":32768,"protocol":6,
  "src_ip":"10.142.0.238","src_port":22},"end_time":"2023-02-13T22:38:30.490546349Z",
  "packets_sent":"15","reporter":"SRC","src_instance":{"project_id":"example-labs",
  "region":"us-east1","vm_name":"example-us-east1","zone":"us-east1-b"},
  "src_vpc":{"project_id":"example-labs","subnetwork_name":"default",
  "vpc_name":"default"},"start_time":"2023-02-13T22:38:29.024032655Z"},
  "logName":"projects/example-labs/logs/compute.googleapis.com%2Fvpc_flows",
  "receiveTimestamp":"2023-02-13T22:38:37.443315735Z","resource":{"labels":
  {"location":"us-east1-b","project_id":"example-labs",
    "subnetwork_id":"00000000000000000000","subnetwork_name":"default"},
    "type":"gce_subnetwork"},"timestamp":"2023-02-13T22:38:37.443315735Z"}

    Stati del ciclo di vita di un'estensione del parser

    Le estensioni parser hanno i seguenti stati del ciclo di vita:

  • DRAFT: estensione del parser appena creata che non è stata ancora inviata.

  • VALIDATING: Google SecOps convalida le istruzioni di mappatura rispetto ai log non elaborati esistenti per garantire che i campi vengano analizzati senza errori.

  • LIVE: l'estensione del parser ha superato la convalida ed è ora in produzione. Estrae e trasforma i dati dai log non elaborati in entrata in record UDM.

  • FAILED: l'estensione del parser non ha superato la convalida.

Scopri di più sui campi dell'estrattore Syslog

I campi dell'estrattore Syslog consentono di separare l'intestazione Syslog da un log strutturato definendo Grok, l'espressione regolare e un token denominato nel pattern dell'espressione regolare per archiviare l'output.

Definisci i campi dell'estrattore Syslog

I valori nei campi Syslog e Target collaborano per definire il modo in cui l'estensione del parser separa l'intestazione Syslog dalla parte strutturata di un log non elaborato. Nel campo Syslog, definisci un'espressione utilizzando una combinazione di sintassi Grok e di espressioni regolari. L'espressione include un nome di variabile che identifica la parte strutturata del log non elaborato. Nel campo Target, specifica il nome della variabile.

L'esempio seguente illustra come funzionano insieme questi campi.

Ecco un esempio di log non elaborato:

<13>1 2022-09-14T15:03:04+00:00 fieldname fieldname - - - {"timestamp": "2021-03-14T14:54:40.842152+0000","flow_id": 1885148860701096, "src_ip": "10.11.22.1","src_port": 51972,"dest_ip": "1.2.3.4","dest_port": 55291,"proto": "TCP"}

Il log non elaborato contiene le seguenti sezioni:

  • Intestazione syslog: <13> 2022-09-14T15:03:04+00:00 fieldname fieldname - - -

  • Evento in formato JSON: {"timestamp": "2021-03-14T14:54:40.842152+0000","flow_id": 1885148860701096, "src_ip": "10.11.22.1","src_port": 51972,"dest_ip": "1.2.3.4","dest_port": 55291,"proto": "TCP"}

Per separare l'intestazione Syslog dalla parte JSON del log non elaborato, utilizza la seguente espressione di esempio nel campo Syslog: %{TIMESTAMP_ISO8601} %{WORD} %{WORD} ([- ]+)?%{GREEDYDATA:msg}

  • Questa parte dell'espressione identifica l'intestazione Syslog: %{TIMESTAMP\_ISO8601} %{WORD} %{WORD} ([- ]+)?
  • Questa parte dell'espressione acquisisce il segmento JSON del log non elaborato: %{GREEDYDATA:msg}

Questo esempio include il nome della variabile msg. Scegli il nome della variabile. L'estensione del parser estrae il segmento JSON del log non elaborato e lo assegna alla variabile msg.

Nel campo Target, inserisci il nome della variabile msg. Il valore memorizzato nella variabile msg viene inserito nelle istruzioni di mappatura dei campi di dati create nell'estensione del parser.

Utilizzando il log non elaborato di esempio, il seguente segmento viene inserito nell'istruzione di mappatura dei dati:

{"timestamp": "2021-03-14T14:54:40.842152+0000","flow_id": 1885148860701096, "src_ip": "10.11.22.1","src_port": 51972,"dest_ip": "1.2.3.4","dest_port": 55291,"proto": "TCP"}

Di seguito sono riportati i campi Syslog e Target completati:

Campi dell'estrattore syslog

La tabella seguente fornisce altri esempi con log di esempio, il pattern di estrazione Syslog, il nome della variabile Target e il risultato.

Esempio di log non elaborato Campo Syslog Campo di destinazione Risultato
<13>1 2022-07-14T15:03:04+00:00 suricata suricata - - - {\"timestamp\": \"2021-03-14T14:54:40.842152+0000\",\"flow_id\": 1885148860701096,\"in_iface\": \"enp94s0\",\"event_type\": \"alert\",\"vlan\": 522,\"src_ip\": \"1.1.2.1\",\"src_port\": 51972,\"dest_ip\": \"1.2.3.4\",\"dest_port\": 55291,\"proto\": \"TCP\"}" %{TIMESTAMP_ISO8601} %{WORD} %{WORD} ([- ]+)?%{GREEDYDATA:msg} msg field_mappings { field: "msg" value: "{\"timestamp\": \"2021-03-14T14:54:40.842152+0000\",\"flow_id\": 1885148860701096,\"in_iface\": \"enp94s0\",\"event_type\": \"alert\",\"vlan\": 522,\"src_ip\": \"1.1.2.1\",\"src_port\": 51972,\"dest_ip\": \"1.2.3.4\",\"dest_port\": 55291,\"proto\": \"TCP\"}" }
<13>1 2022-07-14T15:03:04+00:00 suricata suricata - - - {\"timestamp\": \"2021-03-14T14:54:40.842152+0000\"} - - - {\"timestamp\": \"2021-03-14T14:54:40.842152+0000\",\"flow_id\": 1885148860701096,\"in_iface\": \"enp94s0\",\"event_type\": \"alert\",\"vlan\": 522,\"src_ip\": \"1.1.2.1\",\"src_port\": 51972,\"dest_ip\": \"1.2.3.4\",\"dest_port\": 55291,\"proto\": \"TCP\"} %{TIMESTAMP_ISO8601} %{WORD} %{WORD} ([- ]+)?%{GREEDYDATA:msg1} ([- ]+)?%{GREEDYDATA:msg2} msg2 field_mappings { field: "msg2" value: "{\"timestamp\": \"2021-03-14T14:54:40.842152+0000\",\"flow_id\": 1885148860701096,\"in_iface\": \"enp94s0\",\"event_type\": \"alert\",\"vlan\": 522,\"src_ip\": \"1.1.2.1\",\"src_port\": 51972,\"dest_ip\": \"1.2.3.4\",\"dest_port\": 55291,\"proto\": \"TCP\"}" }
"<13>1 2022-07-14T15:03:04+00:00 suricata suricata - - - {\"timestamp\": \"2021-03-14T14:54:40.842152+0000\"} - - - {\"timestamp\": \"2021-03-14T14:54:40.842152+0000\",\"flow_id\": 1885148860701096,\"in_iface\": \"enp94s0\",\"event_type\": \"alert\",\"vlan\": 522,\"src_ip\": \"1.1.2.1\",\"src_port\": 51972,\"dest_ip\": \"1.2.3.4\",\"dest_port\": 55291,\"proto\": \"TCP\"}" %{TIMESTAMP_ISO8601} %{WORD} %{WORD} ([- ]+)?%{GREEDYDATA:message} ([- ]+)?%{GREEDYDATA:msg2} msg2 Error - message already exists in state and not overwritable.

Scopri di più sull'assegnazione dei campi UDM metadata.event_type

Quando assegni un campo UDM metadata.event_type a un record UDM, viene convalidato per garantire che i campi correlati obbligatori siano presenti nel record UDM. Ogni metadata.event_type UDM richiede un insieme diverso di campi correlati, ad esempio un evento USER_LOGIN senza un user non è utile.

Se manca un campo correlato obbligatorio, la convalida UDM restituisce un errore:

  "error": {
    "code": 400,
    "message": "Request contains an invalid argument.",
    "status": "INVALID_ARGUMENT"
  }

Un parser grok restituisce un errore più dettagliato:

  generic::unknown:
  invalid event 0: LOG_PARSING_GENERATED_INVALID_EVENT:
  "generic::invalid_argument: udm validation failed: target field is not set"

Per trovare i campi obbligatori per un event_type UDM da assegnare, utilizza le seguenti risorse, in cui le guide all'adozione integrano la Guida all'utilizzo di UDM fornendo i campi UDM obbligatori minimi necessari per compilare un metadata.event_type UDM specifico.

Ad esempio, apri il documento e cerca il tipo di evento GROUP_CREATION.

Dovresti visualizzare i seguenti campi UDM minimi, presentati come oggetto UDM:

  {
      "metadata": {
          "event_timestamp": "2023-07-03T13:01:10.957803Z",
          "event_type": "GROUP_CREATION"
      },
      "principal": {
          "user": {
              "userid": "pinguino"
          }
      },
      "target": {
          "group": {
              "group_display_name": "foobar_users"
          }
      }
  }

Istruzioni per la creazione di snippet di codice

L'approccio con snippet di codice ti consente di utilizzare una sintassi simile a Logstash per definire come estrarre e trasformare i valori dal log non elaborato e assegnarli ai campi UDM nel record UDM.

Prima di creare un'estensione del parser utilizzando l'approccio dello snippet di codice, devi aver letto queste sezioni:

I passaggi successivi per definire l'estensione del parser sono:

  1. Per suggerimenti e best practice, consulta Suggerimenti e best practice per la scrittura di istruzioni per gli snippet di codice.
  2. Crea un'istruzione per lo snippet di codice
  3. Invia un'istruzione per lo snippet di codice

Suggerimenti e best practice per la scrittura di istruzioni per gli snippet di codice

Le istruzioni dello snippet di codice possono non riuscire a causa di problemi come pattern Grok errati, operazioni di ridenominazione o sostituzione non riuscite o errori di sintassi. Consulta i seguenti suggerimenti e best practice:

Crea un'istruzione per lo snippet di codice

Le istruzioni dello snippet di codice utilizzano la stessa sintassi e le stesse sezioni del parser predefinito (o personalizzato):

  • Sezione 1. Estrai i dati dal log non elaborato.
  • Sezione 2. Trasformare i dati estratti.
  • Sezione 3. Assegna uno o più valori a un campo UDM.
  • Sezione 4. Associa i campi degli eventi UDM alla chiave @output.

Per creare un'estensione del parser utilizzando l'approccio dello snippet di codice, segui questi passaggi:

  1. Nella pagina Estensione parser, nel riquadro Snippet CBN, inserisci uno snippet di codice per creare l'estensione parser.
  2. Fai clic su Convalida per convalidare le istruzioni di mappatura.

Esempi di istruzioni per gli snippet di codice

L'esempio seguente illustra uno snippet di codice.

Questo è un esempio di log non elaborato (con campi jsonPayload aggiuntivi omessi per brevità):

  {
      "insertId": "00000000",
      "jsonPayload": {
          "packets_sent": "4"
      },
      "timestamp": "2022-05-03T01:45:00.150614953Z"
  }

Questo è un esempio di snippet di codice che mappa il valore in jsonPayload.packets_sent al campo UDM network.sent_bytes:

filter {
  mutate {
    replace => {
      "jsonPayload.packets_sent" => ""
    }
  }
  # Section 1. extract data from the raw JSON log
  json {
    source => "message"
    array_function => "split_columns"
    on_error => "_not_json"
  }
  if [_not_json] {
    drop {
      tag => "TAG_UNSUPPORTED"
    }
  } else {
    # Section 2. transform the extracted data
    if [jsonPayload][packets_sent] not in ["", 0] {
      mutate {
        convert => {
          "jsonPayload.packets_sent" => "uinteger"
        }
        on_error => "_exception1"
      }
      # Section 3. assign the value to a UDM field
      mutate {
        Replace => {
          "event.idm.read_only_udm.network.sent_bytes" => "jsonPayload.packets_sent"
        }
        on_error => "_exception2"
      }
      if ![_exception1] and![_exception2] {
        # Section 4. Bind the UDM fields to the @output key
        mutate {
          merge => {
            "@output" => "event"
          }
        }
      }
    }
  }
}

Invia un'istruzione per lo snippet di codice

  1. Fai clic su Invia per salvare le istruzioni di mappatura.

  2. Google SecOps convalida le istruzioni di mappatura.

    • Se il processo di convalida va a buon fine, lo stato cambia in In tempo reale e le istruzioni di mappatura iniziano a elaborare i dati di log in entrata.
    • Se il processo di convalida non va a buon fine, lo stato diventa Non riuscito e viene visualizzato un errore nel campo Log non elaborato.

Gestisci le estensioni del parser esistenti

Puoi visualizzare, modificare, eliminare e controllare l'accesso alle estensioni del parser esistenti.

Visualizza un'estensione del parser esistente

  1. Nella barra di navigazione, seleziona Impostazioni > Gestione dei dati > Parser. Se utilizzi una piattaforma solo SIEM, vai a Impostazioni > Parser.
  2. Nell'elenco Parser, individua il parser (tipo di log) che vuoi visualizzare. I parser con un'estensione del parser sono indicati dal testo EXTENSION (o EXTN) accanto al nome.

  3. Vai alla riga, quindi fai clic su Menu > Estendi parser > Visualizza estensione.

    Viene visualizzata la scheda Visualizza parser personalizzato/predefinito > Estensione (o la scheda Estensioni) che mostra i dettagli dell'estensione del parser. Il riquadro di riepilogo mostra l'estensione del parser LIVE per impostazione predefinita.

Modifica un'estensione parser

  1. Apri la scheda Visualizza parser personalizzato/predefinito > Estensione (o la scheda Estensioni), come descritto in Visualizza un'estensione del parser esistente.

  2. Fai clic sul pulsante Modifica estensione (o Modifica).

    Viene visualizzata la pagina Estensione parser.

  3. Modifica l'estensione parser.

    • Per annullare la modifica e ignorare le modifiche, fai clic su Ignora bozza (o Ignora estensione).

    • Per eliminare l'estensione del parser in qualsiasi momento, fai clic su Elimina estensione non riuscita (o Elimina estensione).

    • Al termine della modifica dell'estensione del parser, fai clic su Invia.

      Viene eseguito il processo di convalida per convalidare la nuova configurazione.

Elimina un'estensione parser

  1. Apri la scheda Visualizza parser personalizzato/predefinito > Estensione (o la scheda Estensioni), come descritto in Visualizza un'estensione del parser esistente.

  2. Fai clic sul pulsante Elimina estensione.

Controlla l'accesso alle estensioni parser

Per impostazione predefinita, gli utenti con il ruolo Amministratore possono accedere alle estensioni del parser. Puoi controllare chi può visualizzare e gestire le estensioni del parser. Per saperne di più sulla gestione di utenti e gruppi o sull'assegnazione di ruoli, consulta Controllo degli accessi basato su ruoli.

I nuovi ruoli in Google SecOps sono riassunti nella tabella seguente.

Funzionalità Azione Descrizione
Parser Elimina Elimina le estensioni del parser.
Parser Modifica Creare e modificare le estensioni del parser.
Parser Visualizza Visualizzare le estensioni del parser.

Rimuovi le mappature dei campi UDM utilizzando le estensioni del parser

Puoi utilizzare le estensioni del parser per rimuovere una mappatura dei campi UDM esistente.

  1. Fai clic su Impostazioni > Gestione dei dati > Parser. Se utilizzi una piattaforma solo SIEM, vai a Impostazioni > Parser.
  2. Utilizza uno dei seguenti metodi per visualizzare la pagina Parser Extension (Estensione parser):
    • Per un'estensione esistente, fai clic su Menu > Estendi parser > Visualizza estensione.
    • Per le nuove estensioni del parser, fai clic su Menu > Estendi parser > Crea estensione.

  3. Seleziona Scrivi snippet di codice (o Scrivi snippet di codice) come metodo di estensione per aggiungere uno snippet di codice personalizzato che rimuove i valori per campi UDM specifici.

    Per un'estensione esistente, nella scheda Estensione (o Estensioni), fai clic su Modifica estensione (o Modifica) e poi aggiungi lo snippet di codice.

    Per esempi di snippet, consulta Snippet di codice - Rimuovi le mappature esistenti.

  4. Segui i passaggi descritti nell'istruzione per l'invio di uno snippet di codice per inviare l'estensione.

Gestione del fuso orario e formattazione del timestamp

Google SecOps standardizza e serializza i timestamp in formato RFC 3339 UTC con precisione al microsecondo (YYYY-MM-DDTHH:MM:SS.ffffffZ). Se i log di origine forniscono solo una precisione al secondo, la piattaforma aggiunge automaticamente zeri finali alle cifre frazionarie mancanti (.000000Z) per mantenere l'uniformità dello schema.

Se un timestamp dell'evento appare prima dell'ora di importazione (ingested_timestamp < event_timestamp), la discrepanza si verifica in genere quando un'origine emette timestamp dell'orologio locale senza offset del fuso orario ISO (che per impostazione predefinita è UTC) o subisce una deviazione dell'orologio. Puoi risolvere le discrepanze di fuso orario utilizzando uno dei seguenti metodi:

  • Regola i timestamp in un'estensione del parser: utilizza il filtro date in un'estensione del parser dello snippet di codice per specificare il fuso orario di origine:

    if [raw_log] =~ /EST/ {
  date {
    match => [ "timestamp_str", "MMM dd HH:mm:ss" ]
    timezone => "America/New_York"
    target => "event.metadata.event_timestamp"
  }
}

  • Configura un override del fuso orario del raccoglitore del forwarder: vai a Impostazioni > Gestione dei dati > Forwarder, modifica il raccoglitore di destinazione, attiva Esegui l'override del fuso orario e seleziona il fuso orario IANA di origine dal menu Fuso orario (ad esempio, Europe/Paris) per regolare automaticamente i timestamp durante l'importazione.

Hai bisogno di ulteriore assistenza? Ricevi risposte dai membri della community e dai professionisti di Google SecOps.