Raccogli i log di Cisco Application Centric Infrastructure (ACI)

Supportato in:

Questo documento spiega come importare i log di Cisco Application Centric Infrastructure (ACI) in Google Security Operations. Il parser tenta innanzitutto di elaborare i log Cisco ACI in entrata come messaggi syslog utilizzando i pattern Grok. Se l'analisi syslog non va a buon fine, il messaggio viene considerato in formato JSON e analizzato di conseguenza. Infine, mappa i campi estratti al modello UDM (Unified Data Model).

Questa integrazione supporta due metodi:

  • Opzione 1: formato Syslog tramite l'agente Bindplane
  • Opzione 2: formato JSON tramite AWS S3 utilizzando l'API REST APIC

Ogni opzione è autonoma e può essere implementata in modo indipendente in base ai requisiti dell'infrastruttura e alle preferenze di formato dei log.

Opzione 1: Syslog tramite l'agente Bindplane

Questa opzione configura Cisco ACI Fabric per inviare messaggi syslog a un agente Bindplane, che li inoltra a Chronicle per l'analisi.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

  • Un'istanza Google SecOps
  • Un host Windows 2016 o versioni successive o Linux con systemd
  • Se l'agente viene eseguito dietro un proxy, assicurati che le porte del firewall siano aperte in base ai requisiti dell'agente Bindplane.
  • Accesso con privilegi alla console Cisco APIC

Recuperare il file di autenticazione importazione di Google SecOps

  1. Accedi alla console Google SecOps.
  2. Vai a Impostazioni SIEM > Agenti di raccolta.
  3. Scarica il file di autenticazione importazione. Salva il file in modo sicuro sul sistema in cui verrà installato Bindplane.

Recuperare l'ID cliente Google SecOps

  1. Accedi alla console Google SecOps.
  2. Vai a Impostazioni SIEM > Profilo.
  3. Copia e salva l'ID cliente dalla sezione Dettagli dell'organizzazione.

Installa l'agente Bindplane

Installa l'agente Bindplane sul sistema operativo Windows o Linux seguendo le istruzioni riportate di seguito.

Installazione di Windows

  1. Apri il prompt dei comandi o PowerShell come amministratore.

  2. Esegui questo comando:

    msiexec /i "https://github.com/observIQ/bindplane-agent/releases/latest/download/observiq-otel-collector.msi" /quiet

Installazione di Linux

  1. Apri un terminale con privilegi root o sudo.

  2. Esegui questo comando:

    sudo sh -c "$(curl -fsSlL https://github.com/observiq/bindplane-agent/releases/latest/download/install_unix.sh)" install_unix.sh

Risorse aggiuntive per l'installazione

Configura l'agente Bindplane per importare Syslog e inviarlo a Google SecOps

  1. Accedi al file di configurazione:

    1. Individua il file config.yaml. In genere si trova nella directory /etc/bindplane-agent/ su Linux o nella directory di installazione su Windows.
    2. Apri il file utilizzando un editor di testo (ad esempio nano, vi o Blocco note).

  2. Modifica il file config.yaml come segue:

    receivers:
  udplog:
    # Replace the port and IP address as required
    listen_address: "0.0.0.0:514"

exporters:
  chronicle/chronicle_w_labels:
    compression: gzip
    # Adjust the path to the credentials file you downloaded in Step 1
    creds_file_path: '/path/to/ingestion-authentication-file.json'
    # Replace with your actual customer ID from Step 2
    customer_id: <CUSTOMER_ID>
    endpoint: malachiteingestion-pa.googleapis.com
    # Add optional ingestion labels for better organization
    log_type: 'CISCO_ACI'
    raw_log_field: body
    ingestion_labels:

service:
  pipelines:
    logs/source0__chronicle_w_labels-0:
      receivers:
        - udplog
      exporters:
        - chronicle/chronicle_w_labels

Riavvia l'agente Bindplane per applicare le modifiche

  • Per riavviare l'agente Bindplane in Linux, esegui questo comando:

    sudo systemctl restart bindplane-agent

  • Per riavviare l'agente Bindplane in Windows, puoi utilizzare la console Servizi o inserire il seguente comando:

    net stop BindPlaneAgent && net start BindPlaneAgent

Configura l'inoltro di Syslog su Cisco ACI

Configura il contratto di gestione fuori banda

  1. Accedi alla console Cisco APIC.
  2. Vai a Tenant > Gestione > Contratti > Filtri.
  3. Fai clic su Crea filtro.
  4. Fornisci i seguenti dettagli di configurazione:
    • Nome: inserisci syslog-udp-514.
    • Nome voce: inserisci syslog.
    • EtherType: seleziona IP.
    • Protocollo IP: seleziona UDP.
    • Intervallo porte di destinazione da: inserisci 514.
    • Intervallo porte di destinazione a: inserisci 514.
  5. Fai clic su Invia.

Crea contratto di gestione

  1. Vai a Tenant > Gestione > Contratti > Standard.
  2. Fai clic su Crea contratto.
  3. Fornisci i seguenti dettagli di configurazione:
    • Nome: inserisci mgmt-syslog-contract.
    • Ambito: seleziona Contesto.
  4. Fai clic su Invia.
  5. Espandi il contratto e fai clic su Materie.
  6. Fai clic su Crea oggetto del contratto.
  7. Fornisci i seguenti dettagli di configurazione:
    • Nome: inserisci syslog-subject.
    • Applica in entrambe le direzioni: seleziona questa opzione.
  8. Fai clic su Invia.
  9. Espandi l'argomento e fai clic su Filtri.
  10. Fai clic su Crea associazione filtro.
  11. Seleziona il filtro syslog-udp-514 creato in precedenza.
  12. Fai clic su Invia.

Configura gruppo di destinazione Syslog

  1. Vai ad Amministrazione > Collector di dati esterni > Destinazioni di monitoraggio > Syslog.
  2. Fai clic con il tasto destro del mouse su Syslog e seleziona Crea gruppo di destinazione di monitoraggio Syslog.
  3. Fornisci i seguenti dettagli di configurazione:
    • Nome: inserisci Chronicle-Syslog-Group.
    • Stato amministratore: seleziona Attivato.
    • Formato: seleziona aci.
  4. Fai clic su Avanti.
  5. Nella finestra di dialogo Crea destinazione di monitoraggio syslog:
    • Nome: inserisci Chronicle-BindPlane.
    • Host: inserisci l'indirizzo IP del server dell'agente Bindplane.
    • Porta: inserisci 514.
    • Stato amministratore: seleziona Attivato.
    • Gravità: seleziona Informazioni (per acquisire log dettagliati).
  6. Fai clic su Invia.

Configura le policy di monitoraggio

Norme di monitoraggio di Fabric

  1. Vai a Fabric > Fabric Policies > Policies > Monitoring > Common Policy.
  2. Espandi Callhome/Smart Callhome/SNMP/Syslog/TACACS.
  3. Fai clic con il tasto destro del mouse su Syslog e seleziona Crea origine Syslog.
  4. Fornisci i seguenti dettagli di configurazione:
    • Nome: inserisci Chronicle-Fabric-Syslog.
    • Log di controllo: seleziona questa opzione per includere gli eventi di controllo.
    • Eventi: seleziona questa opzione per includere gli eventi di sistema.
    • Guasti: seleziona questa opzione per includere gli eventi di guasto.
    • Log di sessione: seleziona questa opzione per includere i log di sessione.
    • Gruppo di destinazione: seleziona Chronicle-Syslog-Group.
  5. Fai clic su Invia.

Policy di monitoraggio dell'accesso

  1. Vai a Fabric > Norme di accesso > Norme > Monitoraggio > Norme predefinite.
  2. Espandi Callhome/Smart Callhome/SNMP/Syslog.
  3. Fai clic con il tasto destro del mouse su Syslog e seleziona Crea origine Syslog.
  4. Fornisci i seguenti dettagli di configurazione:
    • Nome: inserisci Chronicle-Access-Syslog.
    • Log di controllo: seleziona questa opzione per includere gli eventi di controllo.
    • Eventi: seleziona questa opzione per includere gli eventi di sistema.
    • Guasti: seleziona questa opzione per includere gli eventi di guasto.
    • Log di sessione: seleziona questa opzione per includere i log di sessione.
    • Gruppo di destinazione: seleziona Chronicle-Syslog-Group.
  5. Fai clic su Invia.

Configura il criterio per i messaggi syslog di sistema

  1. Vai a Fabric > Fabric Policies > Policies > Monitoring > Common Policy.
  2. Espandi Criteri per i messaggi Syslog.
  3. Fai clic su predefinita.
  4. Nella sezione Filtro struttura:
    • Struttura: seleziona predefinita.
    • Gravità minima: imposta Informazioni.
  5. Fai clic su Invia.

Opzione 2: JSON tramite AWS S3

Questa opzione utilizza l'API REST APIC per raccogliere eventi, errori e audit log in formato JSON da Cisco ACI Fabric e li archivia in AWS S3 per l'importazione di SecOps.

Prima di iniziare

  • Istanza Google SecOps.
  • Accesso con privilegi alla console Cisco APIC.
  • Accesso privilegiato ad AWS (S3, IAM, Lambda, EventBridge).

Raccogli i prerequisiti di Cisco ACI APIC (ID, chiavi API, ID organizzazione, token)

  1. Accedi alla console Cisco APIC utilizzando HTTPS.
  2. Vai ad Admin > AAA (su APIC 6.0+) o Admin > Authentication > AAA (su versioni precedenti).
    • Nota: il percorso del menu AAA è cambiato a partire da APIC 6.0(1).
  3. Crea o utilizza un utente locale esistente con privilegi appropriati.
  4. Copia e salva in una posizione sicura i seguenti dettagli:
    • Nome utente APIC: utente locale con accesso in lettura ai dati di monitoraggio
    • Password API: password utente
    • URL APIC: l'URL HTTPS del tuo APIC (ad esempio, https://apic.example.com)

Configura il bucket AWS S3 e IAM per Google SecOps

  1. Crea un bucket Amazon S3 seguendo questa guida utente: Creazione di un bucket.
  2. Salva il nome e la regione del bucket per riferimento futuro (ad esempio, cisco-aci-logs).
  3. Crea un utente seguendo questa guida utente: Creazione di un utente IAM.
  4. Seleziona l'utente creato.
  5. Seleziona la scheda Credenziali di sicurezza.
  6. Fai clic su Crea chiave di accesso nella sezione Chiavi di accesso.
  7. Seleziona Servizio di terze parti come Caso d'uso.
  8. Fai clic su Avanti.
  9. (Facoltativo) Aggiungi un tag di descrizione.
  10. Fai clic su Crea chiave di accesso.
  11. Fai clic su Scarica file CSV per salvare la chiave di accesso e la chiave di accesso segreta per riferimento futuro.
  12. Fai clic su Fine.
  13. Seleziona la scheda Autorizzazioni.
  14. Fai clic su Aggiungi autorizzazioni nella sezione Norme relative alle autorizzazioni.
  15. Seleziona Aggiungi autorizzazioni.
  16. Seleziona Collega direttamente i criteri.
  17. Cerca i criteri AmazonS3FullAccess.
  18. Seleziona la policy.
  19. Fai clic su Avanti.
  20. Fai clic su Aggiungi autorizzazioni.

Configura il ruolo e il criterio IAM per i caricamenti S3

  1. Nella console AWS, vai a IAM > Policy.
  2. Fai clic su Crea criterio > scheda JSON.

  3. Inserisci la seguente policy:

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowPutObjects",
      "Effect": "Allow",
      "Action": "s3:PutObject",
      "Resource": "arn:aws:s3:::cisco-aci-logs/*"
    },
    {
      "Sid": "AllowGetStateObject",
      "Effect": "Allow",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::cisco-aci-logs/cisco-aci-events/state.json"
    }
  ]
}
    • Sostituisci cisco-aci-logs se hai inserito un nome bucket diverso.

  4. Fai clic su Avanti > Crea policy.

  5. Vai a IAM > Ruoli > Crea ruolo > Servizio AWS > Lambda.

  6. Allega il criterio appena creato e il criterio gestito AWSLambdaBasicExecutionRole.

  7. Assegna al ruolo il nome cisco-aci-lambda-role e fai clic su Crea ruolo.

Crea la funzione Lambda

  1. Nella console AWS, vai a Lambda > Funzioni > Crea funzione.
  2. Fai clic su Autore da zero.

  3. Fornisci i seguenti dettagli di configurazione:

    • Nome: cisco-aci-events-collector
    • Runtime: Python 3.13
    • Architettura: x86_64
    • Ruolo di esecuzione: cisco-aci-lambda-role

  4. Dopo aver creato la funzione, apri la scheda Codice, elimina lo stub e inserisci il seguente codice (cisco-aci-events-collector.py):

    import json
import boto3
import urllib3
import base64
from datetime import datetime, timedelta
import os
import logging

# Configure logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)

# AWS S3 client and HTTP pool manager
s3_client = boto3.client('s3')
http = urllib3.PoolManager()

def lambda_handler(event, context):
    """
    AWS Lambda handler to fetch Cisco ACI events, faults, and audit logs and store them in S3
    """

    try:
        # Get environment variables
        s3_bucket = os.environ['S3_BUCKET']
        s3_prefix = os.environ['S3_PREFIX']
        state_key = os.environ['STATE_KEY']
        apic_url = os.environ['APIC_URL']
        apic_username = os.environ['APIC_USERNAME']
        apic_password = os.environ['APIC_PASSWORD']

        # Optional parameters
        page_size = int(os.environ.get('PAGE_SIZE', '100'))
        max_pages = int(os.environ.get('MAX_PAGES', '10'))

        logger.info(f"Starting Cisco ACI data collection for bucket: {s3_bucket}")

        # Get last run timestamp from state file
        last_timestamp = get_last_timestamp(s3_bucket, state_key)
        if not last_timestamp:
            last_timestamp = (datetime.utcnow() - timedelta(hours=1)).isoformat() + 'Z'

        # Authenticate to APIC
        session_token = authenticate_apic(apic_url, apic_username, apic_password)

        headers = {
            'Cookie': f'APIC-cookie={session_token}',
            'Accept': 'application/json',
            'Content-Type': 'application/json'
        }

        # Data types to collect
        data_types = ['faultInst', 'eventRecord', 'aaaModLR']
        all_collected_data = []

        for data_type in data_types:
            logger.info(f"Collecting {data_type} data")
            collected_data = collect_aci_data(apic_url, headers, data_type, last_timestamp, page_size, max_pages)

            # Tag each record with its type
            for record in collected_data:
                record['_data_type'] = data_type

            all_collected_data.extend(collected_data)
            logger.info(f"Collected {len(collected_data)} {data_type} records")

        logger.info(f"Total records collected: {len(all_collected_data)}")

        # Store data in S3 if any were collected
        if all_collected_data:
            timestamp_str = datetime.utcnow().strftime('%Y%m%d_%H%M%S')
            s3_key = f"{s3_prefix}cisco_aci_events_{timestamp_str}.ndjson"

            # Convert to NDJSON format (one JSON object per line)
            ndjson_content = '\n'.join(json.dumps(record) for record in all_collected_data)

            # Upload to S3
            s3_client.put_object(
                Bucket=s3_bucket,
                Key=s3_key,
                Body=ndjson_content.encode('utf-8'),
                ContentType='application/x-ndjson'
            )

            logger.info(f"Uploaded {len(all_collected_data)} records to s3://{s3_bucket}/{s3_key}")

        # Update state file with latest timestamp from collected data
        latest_timestamp = get_latest_timestamp_from_records(all_collected_data)
        if not latest_timestamp:
            latest_timestamp = datetime.utcnow().isoformat() + 'Z'

        update_state(s3_bucket, state_key, latest_timestamp)

        return {
            'statusCode': 200,
            'body': json.dumps({
                'message': 'Success',
                'total_records_collected': len(all_collected_data),
                'data_types_collected': data_types
            })
        }

    except Exception as e:
        logger.error(f"Error in lambda_handler: {str(e)}")
        return {
            'statusCode': 500,
            'body': json.dumps({
                'error': str(e)
            })
        }

def authenticate_apic(apic_url, username, password):
    """
    Authenticate to APIC and return session token
    """
    login_url = f"{apic_url}/api/aaaLogin.json"
    login_data = {
        "aaaUser": {
            "attributes": {
                "name": username,
                "pwd": password
            }
        }
    }

    response = http.request(
        'POST',
        login_url,
        body=json.dumps(login_data).encode('utf-8'),
        headers={'Content-Type': 'application/json'},
        timeout=30
    )

    if response.status != 200:
        raise RuntimeError(f"APIC authentication failed: {response.status} {response.data[:256]!r}")

    response_data = json.loads(response.data.decode('utf-8'))
    token = response_data['imdata'][0]['aaaLogin']['attributes']['token']
    logger.info("Successfully authenticated to APIC")
    return token

def collect_aci_data(apic_url, headers, data_type, last_timestamp, page_size, max_pages):
    """
    Collect data from APIC REST API with pagination
    """
    all_data = []
    page = 0

    while page < max_pages:
        # Build API URL with pagination and time filters
        api_url = f"{apic_url}/api/class/{data_type}.json"
        params = [
            f'page-size={page_size}',
            f'page={page}',
            f'order-by={data_type}.created|asc'
        ]

        # Add time filter for all data types to prevent duplicates
        time_attr = 'created'
        if last_timestamp:
            params.append(f'query-target-filter=gt({data_type}.{time_attr},"{last_timestamp}")')

        full_url = f"{api_url}?{'&'.join(params)}"

        logger.info(f"Fetching {data_type} page {page} from APIC")

        # Make API request
        response = http.request('GET', full_url, headers=headers, timeout=60)

        if response.status != 200:
            logger.error(f"API request failed: {response.status} {response.data[:256]!r}")
            break

        data = json.loads(response.data.decode('utf-8'))
        records = data.get('imdata', [])

        if not records:
            logger.info(f"No more {data_type} records found")
            break

        # Extract the actual data from APIC format
        extracted_records = []
        for record in records:
            if data_type in record:
                extracted_records.append(record[data_type])

        all_data.extend(extracted_records)
        page += 1

        # If we got less than page_size records, we've reached the end
        if len(records) < page_size:
            break

    return all_data

def get_last_timestamp(bucket, state_key):
    """
    Get the last run timestamp from S3 state file
    """
    try:
        response = s3_client.get_object(Bucket=bucket, Key=state_key)
        state_data = json.loads(response['Body'].read().decode('utf-8'))
        return state_data.get('last_timestamp')
    except s3_client.exceptions.NoSuchKey:
        logger.info("No state file found, starting from 1 hour ago")
        return None
    except Exception as e:
        logger.warning(f"Error reading state file: {str(e)}")
        return None

def get_latest_timestamp_from_records(records):
    """
    Get the latest timestamp from collected records to prevent missing events
    """
    if not records:
        return None

    latest = None
    latest_time = None

    for record in records:
        try:
            # Handle both direct attributes and nested structure
            attrs = record.get('attributes', record)
            created = attrs.get('created')
            modTs = attrs.get('modTs')  # Fallback for some object types

            timestamp = created or modTs
            if timestamp:
                if latest_time is None or timestamp > latest_time:
                    latest_time = timestamp
                    latest = record
        except Exception as e:
            logger.debug(f"Error parsing timestamp from record: {e}")
            continue

    return latest_time

def update_state(bucket, state_key, timestamp):
    """
    Update the state file with the current timestamp
    """
    try:
        state_data = {
            'last_timestamp': timestamp,
            'updated_at': datetime.utcnow().isoformat() + 'Z'
        }

        s3_client.put_object(
            Bucket=bucket,
            Key=state_key,
            Body=json.dumps(state_data).encode('utf-8'),
            ContentType='application/json'
        )

        logger.info(f"Updated state file with timestamp: {timestamp}")

    except Exception as e:
        logger.error(f"Error updating state file: {str(e)}")

  5. Vai a Configurazione > Variabili di ambiente.

  6. Fai clic su Modifica > Aggiungi nuova variabile di ambiente.

  7. Inserisci le seguenti variabili di ambiente fornite, sostituendole con i tuoi valori.

    • S3_BUCKET: cisco-aci-logs
    • S3_PREFIX: cisco-aci-events/
    • STATE_KEY: cisco-aci-events/state.json
    • APIC_URL: https://apic.example.com
    • APIC_USERNAME: <your-apic-username>
    • APIC_PASSWORD: <your-apic-password>
    • PAGE_SIZE: 100 (facoltativo, controlla le dimensioni della paginazione)
    • MAX_PAGES: 10 (facoltativo, limita il numero totale di pagine recuperate per esecuzione)

  8. Dopo aver creato la funzione, rimani sulla relativa pagina (o apri Lambda > Functions > cisco-aci-events-collector).

  9. Seleziona la scheda Configurazione.

  10. Nel riquadro Configurazione generale, fai clic su Modifica.

  11. Modifica Timeout in 5 minuti (300 secondi) e fai clic su Salva.

Creare una pianificazione EventBridge

  1. Vai a Amazon EventBridge > Scheduler > Crea pianificazione.
  2. Fornisci i seguenti dettagli di configurazione:
    • Programma ricorrente: Tariffa (15 minutes).
    • Destinazione: la tua funzione Lambda cisco-aci-events-collector.
    • Nome: cisco-aci-events-collector-15m
  3. Fai clic su Crea pianificazione.

(Facoltativo) Crea chiavi e utente IAM di sola lettura per Google SecOps

  1. Vai alla console AWS > IAM > Utenti > Aggiungi utenti.
  2. Fai clic su Add users (Aggiungi utenti).
  3. Fornisci i seguenti dettagli di configurazione:
    • Utente: inserisci secops-reader.
    • Tipo di accesso: seleziona Chiave di accesso - Accesso programmatico.
  4. Fai clic su Crea utente.
  5. Collega la criterio per la lettura minima (personalizzata): Utenti > secops-reader > Autorizzazioni > Aggiungi autorizzazioni > Collega le norme direttamente > Crea norma.

  6. Nell'editor JSON, inserisci la seguente policy:

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject"],
      "Resource": "arn:aws:s3:::cisco-aci-logs/*"
    },
    {
      "Effect": "Allow",
      "Action": ["s3:ListBucket"],
      "Resource": "arn:aws:s3:::cisco-aci-logs"
    }
  ]
}

  7. Imposta il nome su secops-reader-policy.

  8. Vai a Crea criterio > cerca/seleziona > Avanti > Aggiungi autorizzazioni.

  9. Vai a Credenziali di sicurezza > Chiavi di accesso > Crea chiave di accesso.

  10. Scarica il file CSV (questi valori vengono inseriti nel feed).

Configura un feed in Google SecOps per importare i log Cisco ACI

  1. Vai a Impostazioni SIEM > Feed.
  2. Fai clic su + Aggiungi nuovo feed.
  3. Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Cisco ACI JSON logs).
  4. Seleziona Amazon S3 V2 come Tipo di origine.
  5. Seleziona Cisco Application Centric Infrastructure come Tipo di log.
  6. Fai clic su Avanti.
  7. Specifica i valori per i seguenti parametri di input:
    • URI S3: s3://cisco-aci-logs/cisco-aci-events/
    • Opzioni di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze.
    • Età massima del file: includi i file modificati nell'ultimo numero di giorni. Il valore predefinito è 180 giorni.
    • ID chiave di accesso: chiave di accesso utente con accesso al bucket S3.
    • Chiave di accesso segreta: chiave segreta dell'utente con accesso al bucket S3.
    • Spazio dei nomi dell'asset: lo spazio dei nomi dell'asset.
    • Etichette di importazione: l'etichetta applicata agli eventi di questo feed.
  8. Fai clic su Avanti.
  9. Controlla la nuova configurazione del feed nella schermata Finalizza e poi fai clic su Invia.

Tabella di mappatura UDM

Campo log Mappatura UDM Logic
@timestamp read_only_udm.metadata.event_timestamp Il valore viene estratto dal campo di log non elaborato "@timestamp" e analizzato come timestamp.
aci_tag read_only_udm.metadata.product_log_id Il valore viene estratto dal campo log non elaborato "aci_tag".
cisco_timestamp - Non mappato.
DIP read_only_udm.target.ip Il valore viene estratto dal campo del log non elaborato "DIP".
DPort read_only_udm.target.port Il valore viene estratto dal campo del log non elaborato "DPort" e convertito in numero intero.
descrizione read_only_udm.security_result.description Il valore viene estratto dal campo del log non elaborato "description".
fault_cause read_only_udm.additional.fields.value.string_value Il valore viene estratto dal campo del log non elaborato "fault_cause". La chiave è impostata su "Fault Cause".
nome host read_only_udm.principal.hostname Il valore viene estratto dal campo log non elaborato "hostname".
lifecycle_state read_only_udm.metadata.product_event_type Il valore viene estratto dal campo del log non elaborato "lifecycle_state".
log.source.address - Non mappato.
logstash.collect.host - Non mappato.
logstash.collect.timestamp read_only_udm.metadata.collected_timestamp Il valore viene estratto dal campo log grezzo "logstash.collect.timestamp" e analizzato come timestamp.
logstash.ingest.host read_only_udm.intermediary.hostname Il valore viene estratto dal campo log grezzo "logstash.ingest.host".
logstash.irm_environment read_only_udm.additional.fields.value.string_value Il valore viene estratto dal campo del log non elaborato "logstash.irm_environment". La chiave è impostata su "IRM_Environment".
logstash.irm_region read_only_udm.additional.fields.value.string_value Il valore viene estratto dal campo log non elaborato "logstash.irm_region". La chiave è impostata su "IRM_Region".
logstash.irm_site read_only_udm.additional.fields.value.string_value Il valore viene estratto dal campo log grezzo "logstash.irm_site". La chiave è impostata su "IRM_Site".
logstash.process.host read_only_udm.intermediary.hostname Il valore viene estratto dal campo del log non elaborato "logstash.process.host".
messaggio - Non mappato.
message_class - Non mappato.
message_code - Non mappato.
message_content - Non mappato.
message_dn - Non mappato.
message_type read_only_udm.metadata.product_event_type Il valore viene estratto dal campo del log non elaborato "message_type" dopo la rimozione delle parentesi quadre.
node_link read_only_udm.principal.process.file.full_path Il valore viene estratto dal campo del log non elaborato "node_link".
PktLen read_only_udm.network.received_bytes Il valore viene estratto dal campo del log non elaborato "PktLen" e convertito in un numero intero senza segno.
programma - Non mappato.
Proto read_only_udm.network.ip_protocol Il valore viene estratto dal campo del log non elaborato "Proto", convertito in numero intero e mappato al nome del protocollo IP corrispondente (ad es. 6 -> TCP).
SIP read_only_udm.principal.ip Il valore viene estratto dal campo del log non elaborato "SIP".
SPort read_only_udm.principal.port Il valore viene estratto dal campo del log non elaborato "SPort" e convertito in numero intero.
syslog_facility - Non mappato.
syslog_facility_code - Non mappato.
syslog_host read_only_udm.principal.ip, read_only_udm.observer.ip Il valore viene estratto dal campo del log non elaborato "syslog_host".
syslog_prog - Non mappato.
syslog_severity read_only_udm.security_result.severity_details Il valore viene estratto dal campo del log non elaborato "syslog_severity".
syslog_severity_code read_only_udm.security_result.severity Il valore viene estratto dal campo del log non elaborato "syslog_severity_code" e mappato al livello di gravità corrispondente: 5, 6, 7 -> INFORMATIONAL; 3, 4 -> MEDIUM; 0, 1, 2 -> HIGH.
syslog5424_pri - Non mappato.
Vlan-Id read_only_udm.principal.resource.id Il valore viene estratto dal campo del log non elaborato "Vlan-Id".
- read_only_udm.metadata.event_type Logica: se sono presenti "SIP" o "hostname" e "Proto", imposta il valore su "NETWORK_CONNECTION". Altrimenti, se è presente "SIP", "hostname" o "syslog_host", imposta "STATUS_UPDATE". In caso contrario, impostalo su "GENERIC_EVENT".
- read_only_udm.metadata.log_type Logic: imposta su "CISCO_ACI".
- read_only_udm.metadata.vendor_name Logic: impostalo su "Cisco".
- read_only_udm.metadata.product_name Logica: imposta su "ACI".

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