Recoger registros de Cisco Application Centric Infrastructure (ACI)

Disponible en:

En este documento se explica cómo ingerir registros de Cisco Application Centric Infrastructure (ACI) en Google Security Operations. El analizador primero intenta procesar los registros de Cisco ACI entrantes como mensajes syslog mediante patrones Grok. Si no se puede analizar el syslog, se da por hecho que el mensaje está en formato JSON y se analiza en consecuencia. Por último, asigna los campos extraídos al modelo de datos unificado (UDM).

Esta integración admite dos métodos:

  • Opción 1: formato Syslog a través del agente Bindplane
  • Opción 2: formato JSON a través de AWS S3 mediante la API REST de APIC

Cada opción es independiente y se puede implementar por separado en función de los requisitos de tu infraestructura y de tus preferencias de formato de registro.

Opción 1: Syslog a través del agente de Bindplane

Esta opción configura la estructura de Cisco ACI para enviar mensajes syslog a un agente de Bindplane, que los reenvía a Chronicle para analizarlos.

Antes de empezar

Asegúrate de que cumples los siguientes requisitos previos:

  • Una instancia de Google SecOps
  • Un host Windows 2016 o posterior, o Linux con systemd
  • Si se ejecuta a través de un proxy, asegúrese de que los puertos del cortafuegos estén abiertos según los requisitos del agente Bindplane.
  • Acceso privilegiado a la consola de Cisco APIC

Obtener el archivo de autenticación de ingestión de Google SecOps

  1. Inicia sesión en la consola de Google SecOps.
  2. Ve a Configuración de SIEM > Agentes de recogida.
  3. Descarga el archivo de autenticación de ingestión. Guarda el archivo de forma segura en el sistema en el que se instalará Bindplane.

Obtener el ID de cliente de Google SecOps

  1. Inicia sesión en la consola de Google SecOps.
  2. Ve a Configuración de SIEM > Perfil.
  3. Copia y guarda el ID de cliente de la sección Detalles de la organización.

Instalar el agente de Bindplane

Instala el agente Bindplane en tu sistema operativo Windows o Linux siguiendo las instrucciones que se indican a continuación.

Instalación de ventanas

  1. Abre la petición de comando o PowerShell como administrador.

  2. Ejecuta el siguiente comando:

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

Instalación de Linux

  1. Abre un terminal con privilegios de root o sudo.

  2. Ejecuta el siguiente comando:

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

Recursos de instalación adicionales

Configurar el agente de Bindplane para ingerir Syslog y enviarlo a Google SecOps

  1. Accede al archivo de configuración:

    1. Busca el archivo config.yaml. Normalmente, se encuentra en el directorio /etc/bindplane-agent/ en Linux o en el directorio de instalación en Windows.
    2. Abre el archivo con un editor de texto (por ejemplo, nano, vi o Bloc de notas).

  2. Edita el archivo config.yaml de la siguiente manera:

    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

Reinicia el agente de Bindplane para aplicar los cambios

  • Para reiniciar el agente de Bindplane en Linux, ejecuta el siguiente comando:

    sudo systemctl restart bindplane-agent

  • Para reiniciar el agente de Bindplane en Windows, puedes usar la consola Servicios o introducir el siguiente comando:

    net stop BindPlaneAgent && net start BindPlaneAgent

Configurar el reenvío de Syslog en Cisco ACI

Configurar un contrato de gestión fuera de banda

  1. Inicia sesión en la consola de Cisco APIC.
  2. Vaya a Inquilinos > gestión > Contratos > Filtros.
  3. Haz clic en Crear filtro.
  4. Proporcione los siguientes detalles de configuración:
    • Nombre: escribe syslog-udp-514.
    • Nombre de la entrada: escribe syslog.
    • EtherType: selecciona IP.
    • Protocolo IP: selecciona UDP.
    • Intervalo de puertos de destino (desde): introduce 514.
    • Intervalo de puertos de destino hasta: introduce 514.
  5. Haz clic en Enviar.

Crear contrato de gestión

  1. Ve a Tenants > mgmt > Contracts > Standard.
  2. Haz clic en Crear contrato.
  3. Proporcione los siguientes detalles de configuración:
    • Nombre: escribe mgmt-syslog-contract.
    • Ámbito: selecciona Contexto.
  4. Haz clic en Enviar.
  5. Despliega el contrato y haz clic en Temas.
  6. Haz clic en Crear asunto de contrato.
  7. Proporcione los siguientes detalles de configuración:
    • Nombre: escribe syslog-subject.
    • Aplicar en ambas direcciones: marca esta opción.
  8. Haz clic en Enviar.
  9. Despliega el tema y haz clic en Filtros.
  10. Haga clic en Crear enlace de filtro.
  11. Selecciona el filtro syslog-udp-514 que has creado antes.
  12. Haz clic en Enviar.

Configurar un grupo de destinos Syslog

  1. Vaya a Administrar > Recogedores de datos externos > Destinos de monitorización > Syslog.
  2. Haz clic con el botón derecho en Syslog y selecciona Create Syslog Monitoring Destination Group (Crear grupo de destinos de monitorización de Syslog).
  3. Proporcione los siguientes detalles de configuración:
    • Nombre: escribe Chronicle-Syslog-Group.
    • Estado de administrador: selecciona Habilitado.
    • Formato: selecciona aci.
  4. Haz clic en Siguiente.
  5. En el cuadro de diálogo Crear destino de monitorización de syslog, haz lo siguiente:
    • Nombre: escribe Chronicle-BindPlane.
    • Host: introduce la dirección IP de tu servidor del agente de Bindplane.
    • Puerto: introduce 514.
    • Estado de administrador: selecciona Habilitado.
    • Gravedad: selecciona Información (para registrar los registros detallados).
  6. Haz clic en Enviar.

Configurar políticas de monitorización

Política de monitorización de Fabric

  1. Ve a Fabric > Políticas de Fabric > Políticas > Monitorización > Política común.
  2. Expande Callhome/Smart Callhome/SNMP/Syslog/TACACS.
  3. Haz clic con el botón derecho en Syslog y selecciona Crear fuente Syslog.
  4. Proporcione los siguientes detalles de configuración:
    • Nombre: escribe Chronicle-Fabric-Syslog.
    • Registros de auditoría: marca esta opción para incluir eventos de auditoría.
    • Eventos: marca esta opción para incluir eventos del sistema.
    • Errores: marca esta opción para incluir eventos de error.
    • Registros de sesión: marca esta opción para incluir los registros de sesión.
    • Grupo de destino: selecciona Chronicle-Syslog-Group.
  5. Haz clic en Enviar.

Política de monitorización de accesos

  1. Ve a Fabric > Políticas de acceso > Políticas > Monitorización > Política predeterminada.
  2. Expanda Callhome/Smart Callhome/SNMP/Syslog.
  3. Haz clic con el botón derecho en Syslog y selecciona Crear fuente Syslog.
  4. Proporcione los siguientes detalles de configuración:
    • Nombre: escribe Chronicle-Access-Syslog.
    • Registros de auditoría: marca esta opción para incluir eventos de auditoría.
    • Eventos: marca esta opción para incluir eventos del sistema.
    • Errores: marca esta opción para incluir eventos de error.
    • Registros de sesión: marca esta opción para incluir los registros de sesión.
    • Grupo de destino: selecciona Chronicle-Syslog-Group.
  5. Haz clic en Enviar.

Configurar la política de mensajes Syslog del sistema

  1. Ve a Fabric > Políticas de Fabric > Políticas > Monitorización > Política común.
  2. Despliegue Políticas de mensajes de Syslog.
  3. Haz clic en Predeterminado.
  4. En la sección Facility Filter (Filtro de centro):
    • Instalación: selecciona predeterminado.
    • Gravedad mínima: cambia a información.
  5. Haz clic en Enviar.

Opción 2: JSON a través de AWS S3

Esta opción usa la API REST de APIC para recoger eventos, fallos y registros de auditoría con formato JSON de la estructura de Cisco ACI y los almacena en AWS S3 para que SecOps los ingiera.

Antes de empezar

  • Instancia de Google SecOps.
  • Acceso privilegiado a la consola de Cisco APIC.
  • Acceso con privilegios a AWS (S3, IAM, Lambda y EventBridge).

Recopilar los requisitos previos de Cisco ACI APIC (IDs, claves de API, IDs de organización y tokens)

  1. Inicia sesión en la consola de Cisco APIC mediante HTTPS.
  2. Ve a Administrar > AAA (en APIC 6.0 o versiones posteriores) o Administrar > Autenticación > AAA (en versiones anteriores).
    • Nota: La ruta del menú AAA ha cambiado a partir de APIC 6.0(1).
  3. Crea o usa un usuario local que ya tengas con los privilegios adecuados.
  4. Copia y guarda en un lugar seguro los siguientes detalles:
    • Nombre de usuario de APIC: usuario local con acceso de lectura a los datos de monitorización.
    • Contraseña de la API: contraseña del usuario.
    • URL de APIC: la URL HTTPS de tu APIC (por ejemplo, https://apic.example.com).

Configurar un segmento de AWS S3 y IAM para Google SecOps

  1. Crea un segmento de Amazon S3 siguiendo esta guía de usuario: Crear un segmento.
  2. Guarda el nombre y la región del segmento para consultarlos más adelante (por ejemplo, cisco-aci-logs).
  3. Crea un usuario siguiendo esta guía: Crear un usuario de gestión de identidades y accesos.
  4. Selecciona el usuario creado.
  5. Selecciona la pestaña Credenciales de seguridad.
  6. En la sección Claves de acceso, haz clic en Crear clave de acceso.
  7. Selecciona Servicio de terceros en Caso práctico.
  8. Haz clic en Siguiente.
  9. Opcional: añade una etiqueta de descripción.
  10. Haz clic en Crear clave de acceso.
  11. Haz clic en Descargar archivo CSV para guardar la clave de acceso y la clave de acceso secreta para futuras consultas.
  12. Haz clic en Listo.
  13. Selecciona la pestaña Permisos.
  14. En la sección Políticas de permisos, haz clic en Añadir permisos.
  15. Selecciona Añadir permisos.
  16. Seleccione Adjuntar políticas directamente.
  17. Busca la política AmazonS3FullAccess.
  18. Selecciona la política.
  19. Haz clic en Siguiente.
  20. Haz clic en Añadir permisos.

Configurar la política y el rol de gestión de identidades y accesos para las subidas de S3

  1. En la consola de AWS, vaya a IAM > Políticas.
  2. Haz clic en Crear política > pestaña JSON.

  3. Introduce la siguiente política:

    {
  "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"
    }
  ]
}
    • Sustituye cisco-aci-logs si has introducido otro nombre de segmento.

  4. Haz clic en Siguiente > Crear política.

  5. Ve a IAM > Roles > Crear rol > Servicio de AWS > Lambda.

  6. Adjunta la política que acabas de crear y la política gestionada AWSLambdaBasicExecutionRole.

  7. Dale el nombre cisco-aci-lambda-role al rol y haz clic en Crear rol.

Crear la función Lambda

  1. En la consola de AWS, ve a Lambda > Funciones > Crear función.
  2. Haz clic en Crear desde cero.

  3. Proporciona los siguientes detalles de configuración:

    • Nombre: cisco-aci-events-collector
    • Tiempo de ejecución: Python 3.13
    • Arquitectura: x86_64
    • Rol de ejecución: cisco-aci-lambda-role

  4. Una vez creada la función, abra la pestaña Código, elimine el stub e introduzca el siguiente código (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. Vaya a Configuración > Variables de entorno.

  6. Haz clic en Editar > Añadir nueva variable de entorno.

  7. Introduce las siguientes variables de entorno, sustituyendo los valores por los tuyos.

    • 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 (opcional, controla el tamaño de la paginación)
    • MAX_PAGES 10 (opcional, limita el número total de páginas obtenidas por ejecución)

  8. Una vez creada la función, permanece en su página (o abre Lambda > Funciones > cisco-aci-events-collector).

  9. Seleccione la pestaña Configuración.

  10. En el panel Configuración general, haz clic en Editar.

  11. Cambia Tiempo de espera a 5 minutos (300 segundos) y haz clic en Guardar.

Crear una programación de EventBridge

  1. Ve a Amazon EventBridge > Scheduler > Create schedule (Amazon EventBridge > Programador > Crear programación).
  2. Proporcione los siguientes detalles de configuración:
    • Programación periódica: Precio (15 minutes).
    • Destino: tu función Lambda cisco-aci-events-collector.
    • Nombre: cisco-aci-events-collector-15m.
  3. Haz clic en Crear programación.

Opcional: Crear un usuario y claves de gestión de identidades y accesos de solo lectura para Google SecOps

  1. Ve a Consola de AWS > IAM > Usuarios > Añadir usuarios.
  2. Haz clic en Add users (Añadir usuarios).
  3. Proporcione los siguientes detalles de configuración:
    • Usuario: introduce secops-reader.
    • Tipo de acceso: selecciona Clave de acceso – Acceso programático.
  4. Haz clic en Crear usuario.
  5. Asigna una política de lectura mínima (personalizada): Usuarios > lector-secops > Permisos > Añadir permisos > Asignar políticas directamente > Crear política.

  6. En el editor de JSON, introduce la siguiente política:

    {
  "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. Asigna el nombre secops-reader-policy.

  8. Ve a Crear política > busca o selecciona > Siguiente > Añadir permisos.

  9. Ve a Credenciales de seguridad > Claves de acceso > Crear clave de acceso.

  10. Descarga el archivo CSV (estos valores se introducen en el feed).

Configurar un feed en Google SecOps para ingerir registros de Cisco ACI

  1. Ve a Configuración de SIEM > Feeds.
  2. Haz clic en + Añadir nuevo feed.
  3. En el campo Nombre del feed, introduce un nombre para el feed (por ejemplo, Cisco ACI JSON logs).
  4. Selecciona Amazon S3 V2 como Tipo de fuente.
  5. Seleccione Cisco Application Centric Infrastructure como Tipo de registro.
  6. Haz clic en Siguiente.
  7. Especifique valores para los siguientes parámetros de entrada:
    • URI de S3: s3://cisco-aci-logs/cisco-aci-events/
    • Opciones de eliminación de la fuente: selecciona la opción de eliminación que prefieras.
    • Antigüedad máxima del archivo: incluye los archivos modificados en los últimos días. El valor predeterminado es de 180 días.
    • ID de clave de acceso: clave de acceso de usuario con acceso al bucket de S3.
    • Clave de acceso secreta: clave secreta del usuario con acceso al segmento de S3.
    • Espacio de nombres de recursos: el espacio de nombres de recursos.
    • Etiquetas de ingestión: la etiqueta aplicada a los eventos de este feed.
  8. Haz clic en Siguiente.
  9. Revise la nueva configuración del feed en la pantalla Finalizar y, a continuación, haga clic en Enviar.

Tabla de asignación de UDM

Campo de registro Asignación de UDM Lógica
@timestamp read_only_udm.metadata.event_timestamp El valor se toma del campo de registro sin procesar "@timestamp" y se analiza como una marca de tiempo.
aci_tag read_only_udm.metadata.product_log_id El valor se toma del campo de registro sin procesar "aci_tag".
cisco_timestamp - Sin asignar.
DIP read_only_udm.target.ip El valor se toma del campo de registro sin procesar "DIP".
DPort read_only_udm.target.port El valor se toma del campo de registro sin procesar "DPort" y se convierte en un número entero.
description read_only_udm.security_result.description El valor se toma del campo de registro sin procesar "description".
fault_cause read_only_udm.additional.fields.value.string_value El valor se toma del campo de registro sin procesar "fault_cause". La clave se ha definido como "Fault Cause".
nombre de host read_only_udm.principal.hostname El valor se toma del campo de registro sin procesar "hostname".
lifecycle_state read_only_udm.metadata.product_event_type El valor se toma del campo de registro sin procesar "lifecycle_state".
log.source.address - Sin asignar.
logstash.collect.host - Sin asignar.
logstash.collect.timestamp read_only_udm.metadata.collected_timestamp El valor se toma del campo de registro sin procesar "logstash.collect.timestamp" y se analiza como una marca de tiempo.
logstash.ingest.host read_only_udm.intermediary.hostname El valor se toma del campo de registro sin procesar "logstash.ingest.host".
logstash.irm_environment read_only_udm.additional.fields.value.string_value El valor se toma del campo de registro sin procesar "logstash.irm_environment". La clave se define como "IRM_Environment".
logstash.irm_region read_only_udm.additional.fields.value.string_value El valor se toma del campo de registro sin procesar "logstash.irm_region". La clave se define como "IRM_Region".
logstash.irm_site read_only_udm.additional.fields.value.string_value El valor se toma del campo de registro sin procesar "logstash.irm_site". La clave se define como "IRM_Site".
logstash.process.host read_only_udm.intermediary.hostname El valor se toma del campo de registro sin procesar "logstash.process.host".
mensaje - Sin asignar.
message_class - Sin asignar.
message_code - Sin asignar.
message_content - Sin asignar.
message_dn - Sin asignar.
message_type read_only_udm.metadata.product_event_type El valor se toma del campo de registro sin procesar "message_type" después de quitar los corchetes.
node_link read_only_udm.principal.process.file.full_path El valor se toma del campo de registro sin procesar "node_link".
PktLen read_only_udm.network.received_bytes El valor se toma del campo de registro sin procesar "PktLen" y se convierte en un entero sin signo.
programa - Sin asignar.
Proto read_only_udm.network.ip_protocol El valor se toma del campo de registro sin procesar "Proto", se convierte en un número entero y se asigna al nombre del protocolo IP correspondiente (por ejemplo, 6 -> TCP).
SIP read_only_udm.principal.ip El valor se toma del campo de registro sin procesar "SIP".
SPort read_only_udm.principal.port El valor se toma del campo de registro sin procesar "SPort" y se convierte en un número entero.
syslog_facility - Sin asignar.
syslog_facility_code - Sin asignar.
syslog_host read_only_udm.principal.ip, read_only_udm.observer.ip El valor se toma del campo de registro sin procesar "syslog_host".
syslog_prog - Sin asignar.
syslog_severity read_only_udm.security_result.severity_details El valor se toma del campo de registro sin procesar "syslog_severity".
syslog_severity_code read_only_udm.security_result.severity El valor se toma del campo de registro sin procesar "syslog_severity_code" y se asigna al nivel de gravedad correspondiente: 5, 6 y 7 -> INFORMATIONAL; 3 y 4 -> MEDIUM; 0, 1 y 2 -> HIGH.
syslog5424_pri - Sin asignar.
Vlan-Id read_only_udm.principal.resource.id El valor se toma del campo de registro sin procesar "Vlan-Id".
- read_only_udm.metadata.event_type Lógica: si están presentes "SIP" o "hostname" y "Proto", se asigna el valor "NETWORK_CONNECTION". Si está presente "SIP", "hostname" o "syslog_host", se asigna el valor "STATUS_UPDATE". De lo contrario, se asigna el valor "GENERIC_EVENT".
- read_only_udm.metadata.log_type Logic: se define como "CISCO_ACI".
- read_only_udm.metadata.vendor_name Lógica: se define como "Cisco".
- read_only_udm.metadata.product_name Lógica: se define como "ACI".

¿Necesitas más ayuda? Recibe respuestas de los miembros de la comunidad y de los profesionales de Google SecOps.