Cisco Application Centric Infrastructure-Logs (ACI) erfassen

Unterstützt in:

In diesem Dokument wird beschrieben, wie Sie Cisco Application Centric Infrastructure (ACI)-Logs in Google Security Operations aufnehmen. Der Parser versucht zuerst, eingehende Cisco ACI-Logs als Syslog-Nachrichten mit Grok-Mustern zu verarbeiten. Wenn das Syslog-Parsing fehlschlägt, wird davon ausgegangen, dass die Nachricht im JSON-Format vorliegt, und sie wird entsprechend geparst. Schließlich werden die extrahierten Felder dem Unified Data Model (UDM) zugeordnet.

Diese Integration unterstützt zwei Methoden:

  • Option 1: Syslog-Format über den Bindplane-Agent
  • Option 2: JSON-Format über AWS S3 mit der APIC REST API

Jede Option ist in sich abgeschlossen und kann unabhängig voneinander implementiert werden, je nach Ihren Infrastrukturanforderungen und bevorzugten Logformaten.

Option 1: Syslog über den Bindplane-Agent

Mit dieser Option wird das Cisco ACI-Fabric so konfiguriert, dass Syslog-Nachrichten an einen Bindplane-Agent gesendet werden, der sie zur Analyse an Chronicle weiterleitet.

Hinweise

Prüfen Sie, ob folgende Voraussetzungen erfüllt sind:

  • Eine Google SecOps-Instanz
  • Ein Windows 2016- oder höher- oder Linux-Host mit systemd
  • Wenn Sie den Agent hinter einem Proxy ausführen, müssen die Firewallports gemäß den Anforderungen des Bindplane-Agents geöffnet sein.
  • Privilegierter Zugriff auf die Cisco APIC-Konsole

Authentifizierungsdatei für die Aufnahme in Google SecOps abrufen

  1. Melden Sie sich in der Google SecOps-Konsole an.
  2. Rufen Sie die SIEM-Einstellungen > Collection Agents auf.
  3. Laden Sie die Authentifizierungsdatei für die Aufnahme herunter. Speichern Sie die Datei sicher auf dem System, auf dem BindPlane installiert wird.

Google SecOps-Kundennummer abrufen

  1. Melden Sie sich in der Google SecOps-Konsole an.
  2. Rufen Sie die SIEM-Einstellungen > Profile auf.
  3. Kopieren und speichern Sie die Kunden-ID aus dem Bereich Organisationsdetails.

BindPlane-Agent installieren

Installieren Sie den Bindplane-Agent auf Ihrem Windows- oder Linux-Betriebssystem gemäß der folgenden Anleitung.

Fenstereinbau

  1. Öffnen Sie die Eingabeaufforderung oder PowerShell als Administrator.

  2. Führen Sie dazu diesen Befehl aus:

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

Linux-Installation

  1. Öffnen Sie ein Terminal mit Root- oder Sudo-Berechtigungen.

  2. Führen Sie dazu diesen Befehl aus:

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

Zusätzliche Installationsressourcen

BindPlane-Agent zum Erfassen von Syslog-Daten und Senden an Google SecOps konfigurieren

  1. Konfigurationsdatei aufrufen:

    1. Suchen Sie die Datei config.yaml. Normalerweise befindet sie sich unter Linux im Verzeichnis /etc/bindplane-agent/ oder unter Windows im Installationsverzeichnis.
    2. Öffnen Sie die Datei mit einem Texteditor (z. B. nano, vi oder Notepad).

  2. Bearbeiten Sie die Datei config.yamlso:

    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
    • Ersetzen Sie den Port und die IP-Adresse nach Bedarf in Ihrer Infrastruktur.
    • Ersetzen Sie <customer_id> durch die tatsächliche Kunden-ID.
    • Aktualisieren Sie /path/to/ingestion-authentication-file.json auf den Pfad, in dem die Authentifizierungsdatei im Abschnitt Get Google SecOps ingestion authentication file (Authentifizierungsdatei für die Google SecOps-Aufnahme abrufen) gespeichert wurde.

Bindplane-Agent neu starten, um die Änderungen zu übernehmen

  • Führen Sie den folgenden Befehl aus, um den Bindplane-Agent unter Linux neu zu starten:

    sudo systemctl restart bindplane-agent

  • Um den Bindplane-Agent unter Windows neu zu starten, können Sie entweder die Konsole Dienste verwenden oder den folgenden Befehl eingeben:

    net stop BindPlaneAgent && net start BindPlaneAgent

Syslog-Weiterleitung in Cisco ACI konfigurieren

Out-of-Band-Management-Vertrag konfigurieren

  1. Melden Sie sich in der Cisco APIC-Konsole an.
  2. Rufen Sie Tenants > mgmt> Contracts> Filters auf.
  3. Klicken Sie auf Filter erstellen.
  4. Geben Sie die folgenden Konfigurationsdetails an:
    • Name: Geben Sie syslog-udp-514 ein.
    • Name des Eintrags: Geben Sie syslog ein.
    • EtherType: Wählen Sie IP aus.
    • IP-Protokoll: Wählen Sie UDP aus.
    • Zielportbereich (von): Geben Sie 514 ein.
    • Zielportbereich bis: Geben Sie 514 ein.
  5. Klicken Sie auf Senden.

Verwaltungsvereinbarung erstellen

  1. Gehen Sie zu Tenants> mgmt> Contracts> Standard.
  2. Klicken Sie auf Vertrag erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Name: Geben Sie mgmt-syslog-contract ein.
    • Umfang: Wählen Sie Kontext aus.
  4. Klicken Sie auf Senden.
  5. Maximieren Sie den Vertrag und klicken Sie auf Themen.
  6. Klicken Sie auf Vertragsgegenstand erstellen.
  7. Geben Sie die folgenden Konfigurationsdetails an:
    • Name: Geben Sie syslog-subject ein.
    • Beide Richtungen anwenden: Aktivieren Sie diese Option.
  8. Klicken Sie auf Senden.
  9. Maximieren Sie das Thema und klicken Sie auf Filter.
  10. Klicken Sie auf Filterbindung erstellen.
  11. Wählen Sie den zuvor erstellten Filter syslog-udp-514 aus.
  12. Klicken Sie auf Senden.

Syslog-Zielgruppe konfigurieren

  1. Klicken Sie auf Verwaltung > Externe Datenerhebungstools > Monitoring-Ziele > Syslog.
  2. Klicken Sie mit der rechten Maustaste auf Syslog und wählen Sie Syslog-Überwachungszielgruppe erstellen aus.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Name: Geben Sie Chronicle-Syslog-Group ein.
    • Admin State (Administratorstatus): Wählen Sie Enabled (Aktiviert) aus.
    • Format: Wählen Sie aci aus.
  4. Klicken Sie auf Weiter.
  5. Gehen Sie im Dialogfeld Syslog-Überwachungsziel erstellen so vor:
    • Name: Geben Sie Chronicle-BindPlane ein.
    • Host: Geben Sie die IP-Adresse Ihres Bindplane-Agent-Servers ein.
    • Port: Geben Sie 514 ein.
    • Admin State (Administratorstatus): Wählen Sie Enabled (Aktiviert) aus.
    • Schweregrad: Wählen Sie Information aus, um detaillierte Logs zu erfassen.
  6. Klicken Sie auf Senden.

Monitoring-Richtlinien konfigurieren

Fabric Monitoring-Richtlinie

  1. Rufen Sie Fabric > Fabric-Richtlinien > Richtlinien > Monitoring > Gemeinsame Richtlinie auf.
  2. Maximieren Sie Callhome/Smart Callhome/SNMP/Syslog/TACACS.
  3. Klicken Sie mit der rechten Maustaste auf Syslog und wählen Sie Syslog-Quelle erstellen aus.
  4. Geben Sie die folgenden Konfigurationsdetails an:
    • Name: Geben Sie Chronicle-Fabric-Syslog ein.
    • Audit-Logs: Aktivieren Sie diese Option, um Audit-Ereignisse einzubeziehen.
    • Ereignisse: Aktivieren Sie das Kästchen, um Systemereignisse einzubeziehen.
    • Fehler: Aktivieren Sie diese Option, um Fehlerereignisse einzubeziehen.
    • Sitzungsprotokolle: Aktivieren Sie diese Option, um Sitzungsprotokolle einzuschließen.
    • Zielgruppe: Wählen Sie Chronicle-Syslog-Group aus.
  5. Klicken Sie auf Senden.

Richtlinie zur Zugriffsüberwachung

  1. Rufen Sie Fabric > Zugriffsrichtlinien > Richtlinien > Monitoring > Standardrichtlinie auf.
  2. Maximieren Sie Callhome/Smart Callhome/SNMP/Syslog.
  3. Klicken Sie mit der rechten Maustaste auf Syslog und wählen Sie Syslog-Quelle erstellen aus.
  4. Geben Sie die folgenden Konfigurationsdetails an:
    • Name: Geben Sie Chronicle-Access-Syslog ein.
    • Audit-Logs: Aktivieren Sie diese Option, um Audit-Ereignisse einzubeziehen.
    • Ereignisse: Aktivieren Sie das Kästchen, um Systemereignisse einzubeziehen.
    • Fehler: Aktivieren Sie diese Option, um Fehlerereignisse einzubeziehen.
    • Sitzungsprotokolle: Aktivieren Sie diese Option, um Sitzungsprotokolle einzuschließen.
    • Zielgruppe: Wählen Sie Chronicle-Syslog-Group aus.
  5. Klicken Sie auf Senden.

Richtlinie für System-Syslog-Meldungen konfigurieren

  1. Rufen Sie Fabric > Fabric-Richtlinien > Richtlinien > Monitoring > Gemeinsame Richtlinie auf.
  2. Maximieren Sie Richtlinien für Syslog-Nachrichten.
  3. Klicken Sie auf Standard.
  4. Führen Sie im Bereich Einrichtungsfilter folgende Schritte aus:
    • Einrichtung: Wählen Sie Standard aus.
    • Mindestschweregrad: Ändern Sie den Wert in Information.
  5. Klicken Sie auf Senden.

Option 2: JSON über AWS S3

Bei dieser Option wird die APIC REST API verwendet, um Ereignisse, Fehler und Audit-Logs im JSON-Format aus dem Cisco ACI-Fabric zu erfassen und zur SecOps-Aufnahme in AWS S3 zu speichern.

Hinweise

  • Google SecOps-Instanz.
  • Privilegierter Zugriff auf die Cisco APIC-Konsole.
  • Privilegierter Zugriff auf AWS (S3, IAM, Lambda, EventBridge).

Cisco ACI APIC-Voraussetzungen erfassen (IDs, API-Schlüssel, Organisations-IDs, Tokens)

  1. Melden Sie sich über HTTPS in der Cisco APIC-Konsole an.
  2. Gehen Sie zu Admin > AAA (auf APIC 6.0+) oder Admin > Authentifizierung > AAA (auf älteren Versionen).
    • Hinweis: Der AAA-Menüpfad hat sich ab APIC 6.0(1) geändert.
  3. Erstellen Sie einen lokalen Nutzer mit den entsprechenden Berechtigungen oder verwenden Sie einen vorhandenen.
  4. Kopieren und speichern Sie die folgenden Details an einem sicheren Ort:
    • APIC-Nutzername: Lokaler Nutzer mit Lesezugriff auf Überwachungsdaten
    • APIC-Passwort: Nutzerpasswort
    • APIC-URL: Die HTTPS-URL Ihres APIC (z. B. https://apic.example.com)

AWS S3-Bucket und IAM für Google SecOps konfigurieren

  1. Erstellen Sie einen Amazon S3-Bucket. Folgen Sie dazu der Anleitung unter Bucket erstellen.
  2. Speichern Sie den Namen und die Region des Buckets zur späteren Verwendung (z. B. cisco-aci-logs).
  3. Erstellen Sie einen Nutzer gemäß dieser Anleitung: IAM-Nutzer erstellen.
  4. Wählen Sie den erstellten Nutzer aus.
  5. Wählen Sie den Tab Sicherheitsanmeldedaten aus.
  6. Klicken Sie im Abschnitt Zugriffsschlüssel auf Zugriffsschlüssel erstellen.
  7. Wählen Sie Drittanbieterdienst als Anwendungsfall aus.
  8. Klicken Sie auf Weiter.
  9. Optional: Fügen Sie ein Beschreibungstag hinzu.
  10. Klicken Sie auf Zugriffsschlüssel erstellen.
  11. Klicken Sie auf CSV-Datei herunterladen, um den Access Key (Zugriffsschlüssel) und den Secret Access Key (geheimer Zugriffsschlüssel) für die zukünftige Verwendung zu speichern.
  12. Klicken Sie auf Fertig.
  13. Wählen Sie den Tab Berechtigungen aus.
  14. Klicken Sie im Bereich Berechtigungsrichtlinien auf Berechtigungen hinzufügen.
  15. Wählen Sie Berechtigungen hinzufügen aus.
  16. Wählen Sie Richtlinien direkt anhängen aus.
  17. Suchen Sie nach der Richtlinie AmazonS3FullAccess.
  18. Wählen Sie die Richtlinie aus.
  19. Klicken Sie auf Weiter.
  20. Klicken Sie auf Berechtigungen hinzufügen.

IAM-Richtlinie und ‑Rolle für S3-Uploads konfigurieren

  1. Rufen Sie in der AWS Console IAM > Richtlinien auf.
  2. Klicken Sie auf Richtlinie erstellen> Tab „JSON“.

  3. Geben Sie die folgende Richtlinie ein:

    {
  "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"
    }
  ]
}
    • Ersetzen Sie cisco-aci-logs, wenn Sie einen anderen Bucket-Namen eingegeben haben.

  4. Klicken Sie auf Weiter > Richtlinie erstellen.

  5. Rufen Sie IAM > Rollen > Rolle erstellen > AWS-Service > Lambda auf.

  6. Hängen Sie die neu erstellte Richtlinie und die verwaltete Richtlinie AWSLambdaBasicExecutionRole an.

  7. Geben Sie der Rolle den Namen cisco-aci-lambda-role und klicken Sie auf Rolle erstellen.

Lambda-Funktion erstellen

  1. Rufen Sie in der AWS Console Lambda > Funktionen > Funktion erstellen auf.
  2. Klicken Sie auf Von Grund auf erstellen.

  3. Geben Sie die folgenden Konfigurationsdetails an:

    • Name: cisco-aci-events-collector
    • Laufzeit: Python 3.13
    • Architektur: x86_64
    • Ausführungsrolle: cisco-aci-lambda-role

  4. Nachdem die Funktion erstellt wurde, öffnen Sie den Tab Code, löschen Sie den Stub und geben Sie den folgenden Code ein (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. Rufen Sie Konfiguration > Umgebungsvariablen auf.

  6. Klicken Sie auf Bearbeiten> Neue Umgebungsvariable hinzufügen.

  7. Geben Sie die folgenden Umgebungsvariablen ein und ersetzen Sie die Platzhalter durch Ihre Werte.

    • 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 (optional, steuert die Paginierungsgröße)
    • MAX_PAGES: 10 (optional, begrenzt die Gesamtzahl der Seiten, die pro Ausführung abgerufen werden)

  8. Bleiben Sie nach dem Erstellen der Funktion auf der zugehörigen Seite oder öffnen Sie Lambda > Funktionen > cisco-aci-events-collector.

  9. Wählen Sie den Tab Konfiguration aus.

  10. Klicken Sie im Bereich Allgemeine Konfiguration auf Bearbeiten.

  11. Ändern Sie Zeitlimit in 5 Minuten (300 Sekunden) und klicken Sie auf Speichern.

EventBridge-Zeitplan erstellen

  1. Gehen Sie zu Amazon EventBridge > Scheduler > Create schedule (Amazon EventBridge > Scheduler > Zeitplan erstellen).
  2. Geben Sie die folgenden Konfigurationsdetails an:
    • Wiederkehrender Zeitplan: Preis (15 minutes).
    • Ziel: Ihre Lambda-Funktion cisco-aci-events-collector.
    • Name: cisco-aci-events-collector-15m.
  3. Klicken Sie auf Zeitplan erstellen.

Optional: IAM-Nutzer mit Lesezugriff und Schlüssel für Google SecOps erstellen

  1. Rufen Sie die AWS-Konsole > IAM > Nutzer > Nutzer hinzufügen auf.
  2. Klicken Sie auf Add users (Nutzer hinzufügen).
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Nutzer: Geben Sie secops-reader ein.
    • Zugriffstyp: Wählen Sie Zugriffsschlüssel – programmatischer Zugriff aus.
  4. Klicken Sie auf Nutzer erstellen.
  5. Minimale Leseberechtigung (benutzerdefiniert) anhängen: Nutzer > secops-reader > Berechtigungen > Berechtigungen hinzufügen > Richtlinien direkt anhängen > Richtlinie erstellen.

  6. Geben Sie im JSON-Editor die folgende Richtlinie ein:

    {
  "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. Legen Sie secops-reader-policy als Name fest.

  8. Gehen Sie zu Richtlinie erstellen > suchen/auswählen > Weiter > Berechtigungen hinzufügen.

  9. Rufen Sie Sicherheitsanmeldedaten > Zugriffsschlüssel > Zugriffsschlüssel erstellen auf.

  10. Laden Sie die CSV herunter (diese Werte werden in den Feed eingegeben).

Feed in Google SecOps konfigurieren, um Cisco ACI-Logs aufzunehmen

  1. Rufen Sie die SIEM-Einstellungen > Feeds auf.
  2. Klicken Sie auf + Neuen Feed hinzufügen.
  3. Geben Sie im Feld Feedname einen Namen für den Feed ein, z. B. Cisco ACI JSON logs.
  4. Wählen Sie Amazon S3 V2 als Quelltyp aus.
  5. Wählen Sie Cisco Application Centric Infrastructure als Logtyp aus.
  6. Klicken Sie auf Weiter.
  7. Geben Sie Werte für die folgenden Eingabeparameter an:
    • S3-URI: s3://cisco-aci-logs/cisco-aci-events/
    • Optionen zum Löschen von Quellen: Wählen Sie die gewünschte Option zum Löschen aus.
    • Maximales Dateialter: Dateien einschließen, die in den letzten Tagen geändert wurden. Der Standardwert ist 180 Tage.
    • Zugriffsschlüssel-ID: Der Nutzerzugriffsschlüssel mit Zugriff auf den S3-Bucket.
    • Geheimer Zugriffsschlüssel: Der geheime Schlüssel des Nutzers mit Zugriff auf den S3-Bucket.
    • Asset-Namespace: Der Asset-Namespace.
    • Aufnahmelabels: Das Label, das auf die Ereignisse aus diesem Feed angewendet wird.
  8. Klicken Sie auf Weiter.
  9. Prüfen Sie die neue Feedkonfiguration auf dem Bildschirm Abschließen und klicken Sie dann auf Senden.

UDM-Zuordnungstabelle

Logfeld UDM-Zuordnung Logik
@timestamp read_only_udm.metadata.event_timestamp Der Wert wird aus dem Rohlogfeld „@timestamp“ übernommen und als Zeitstempel geparst.
aci_tag read_only_udm.metadata.product_log_id Der Wert wird aus dem Rohlogfeld „aci_tag“ übernommen.
cisco_timestamp - Nicht zugeordnet.
DIP read_only_udm.target.ip Der Wert wird aus dem Rohlogfeld „DIP“ übernommen.
DPort read_only_udm.target.port Der Wert wird aus dem Rohlogfeld „DPort“ übernommen und in eine Ganzzahl konvertiert.
Beschreibung read_only_udm.security_result.description Der Wert stammt aus dem Rohlogfeld „description“.
fault_cause read_only_udm.additional.fields.value.string_value Der Wert wird aus dem Rohlogfeld „fault_cause“ übernommen. Der Schlüssel ist auf „Fehlerursache“ festgelegt.
Hostname read_only_udm.principal.hostname Der Wert wird aus dem Rohlogfeld „hostname“ übernommen.
lifecycle_state read_only_udm.metadata.product_event_type Der Wert wird aus dem Rohlogfeld „lifecycle_state“ übernommen.
log.source.address - Nicht zugeordnet.
logstash.collect.host - Nicht zugeordnet.
logstash.collect.timestamp read_only_udm.metadata.collected_timestamp Der Wert wird aus dem Rohlogfeld „logstash.collect.timestamp“ übernommen und als Zeitstempel geparst.
logstash.ingest.host read_only_udm.intermediary.hostname Der Wert wird aus dem Rohlogfeld „logstash.ingest.host“ übernommen.
logstash.irm_environment read_only_udm.additional.fields.value.string_value Der Wert wird aus dem Rohlogfeld „logstash.irm_environment“ übernommen. Der Schlüssel ist auf „IRM_Environment“ festgelegt.
logstash.irm_region read_only_udm.additional.fields.value.string_value Der Wert wird aus dem Rohlogfeld „logstash.irm_region“ übernommen. Der Schlüssel ist auf „IRM_Region“ festgelegt.
logstash.irm_site read_only_udm.additional.fields.value.string_value Der Wert wird aus dem Rohlogfeld „logstash.irm_site“ übernommen. Der Schlüssel ist auf „IRM_Site“ festgelegt.
logstash.process.host read_only_udm.intermediary.hostname Der Wert wird aus dem Rohlogfeld „logstash.process.host“ übernommen.
Nachricht - Nicht zugeordnet.
message_class - Nicht zugeordnet.
message_code - Nicht zugeordnet.
message_content - Nicht zugeordnet.
message_dn - Nicht zugeordnet.
message_type read_only_udm.metadata.product_event_type Der Wert wird aus dem Rohlogfeld „message_type“ übernommen, nachdem die eckigen Klammern entfernt wurden.
node_link read_only_udm.principal.process.file.full_path Der Wert wird aus dem Rohlogfeld „node_link“ übernommen.
PktLen read_only_udm.network.received_bytes Der Wert wird aus dem Rohlogfeld „PktLen“ übernommen und in eine vorzeichenlose Ganzzahl umgewandelt.
über das Programm - Nicht zugeordnet.
Proto read_only_udm.network.ip_protocol Der Wert wird aus dem Rohlogfeld „Proto“ übernommen, in eine Ganzzahl umgewandelt und dem entsprechenden IP-Protokollnamen zugeordnet (z.B. 6 -> TCP).
SIP read_only_udm.principal.ip Der Wert wird aus dem Rohlogfeld „SIP“ übernommen.
SPort read_only_udm.principal.port Der Wert wird aus dem Rohlogfeld „SPort“ übernommen und in eine Ganzzahl konvertiert.
syslog_facility - Nicht zugeordnet.
syslog_facility_code - Nicht zugeordnet.
syslog_host read_only_udm.principal.ip, read_only_udm.observer.ip Der Wert wird aus dem Rohlogfeld „syslog_host“ übernommen.
syslog_prog - Nicht zugeordnet.
syslog_severity read_only_udm.security_result.severity_details Der Wert wird aus dem Rohlogfeld „syslog_severity“ übernommen.
syslog_severity_code read_only_udm.security_result.severity Der Wert wird aus dem Rohlogfeld „syslog_severity_code“ übernommen und der entsprechenden Schweregradstufe zugeordnet: 5, 6, 7 –> INFORMATIONAL; 3, 4 –> MEDIUM; 0, 1, 2 –> HIGH.
syslog5424_pri - Nicht zugeordnet.
VLAN-ID read_only_udm.principal.resource.id Der Wert wird aus dem Rohlogfeld „Vlan-Id“ übernommen.
- read_only_udm.metadata.event_type Logik: Wenn „SIP“ oder „hostname“ und „Proto“ vorhanden sind, wird der Wert auf „NETWORK_CONNECTION“ festgelegt. Andernfalls, wenn „SIP“, „hostname“ oder „syslog_host“ vorhanden ist, auf „STATUS_UPDATE“ setzen. Andernfalls auf „GENERIC_EVENT“ setzen.
- read_only_udm.metadata.log_type Logik: Auf „CISCO_ACI“ festgelegt.
- read_only_udm.metadata.vendor_name Logik: Auf „Cisco“ festgelegt.
- read_only_udm.metadata.product_name Logik: Auf „ACI“ festgelegt.

Benötigen Sie weitere Hilfe? Antworten von Community-Mitgliedern und Google SecOps-Experten erhalten