Cisco Catalyst SD-WAN Manager-Logs erfassen

Parserversion:7.0

Unterstützt in:

In diesem Dokument wird beschrieben, wie Sie Cisco Catalyst SD-WAN Manager-Logs (früher vManage) mit Google Cloud Storage in Google Security Operations aufnehmen. Cisco Catalyst SD-WAN Manager ist ein zentralisiertes Netzwerkverwaltungssystem, das Transparenz und Kontrolle über das SD-WAN-Fabric bietet. Administratoren können damit die Netzwerkleistung überwachen, Richtlinien konfigurieren und die Sicherheit in verteilten Unternehmensnetzwerken verwalten.

Hinweis

Folgende Voraussetzungen müssen erfüllt sein:

  • Eine Google SecOps-Instanz
  • Ein GCP-Projekt mit aktivierter Cloud Storage API
  • Berechtigungen zum Erstellen und Verwalten von GCS-Buckets
  • Berechtigungen zum Verwalten von IAM-Richtlinien für GCS-Buckets
  • Berechtigungen zum Erstellen von Cloud Run-Diensten, Pub/Sub-Themen und Cloud Scheduler-Jobs
  • Privilegierter Zugriff auf die Verwaltungskonsole von Cisco Catalyst SD-WAN Manager
  • Cisco Catalyst SD-WAN Manager-Nutzerkonto mit API-Zugriffsberechtigungen

Google Cloud Storage-Bucket erstellen

  1. Gehen Sie zur Google Cloud Console.
  2. Wählen Sie Ihr Projekt aus oder erstellen Sie ein neues.
  3. Rufen Sie im Navigationsmenü Cloud Storage > Buckets auf.
  4. Klicken Sie auf Bucket erstellen.

  5. Geben Sie die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Bucket benennen Geben Sie einen global eindeutigen Namen ein, z. B. cisco-sdwan-logs-bucket.
    Standorttyp Wählen Sie die Option aus, die am besten zu Ihren Anforderungen passt (Region, Dual-Region, Multi-Region).
    Standort Wählen Sie den Speicherort aus, z. B. us-central1.
    Speicherklasse Standard (empfohlen für Logs, auf die häufig zugegriffen wird)
    Zugriffskontrolle Einheitlich (empfohlen)
    Schutztools Optional: Objektversionierung oder Aufbewahrungsrichtlinie aktivieren

  6. Klicken Sie auf Erstellen.

Cisco Catalyst SD-WAN Manager-API-Anmeldedaten erfassen

API-Nutzerkonto erstellen

  1. Melden Sie sich in der Cisco Catalyst SD-WAN Manager-Konsole an.
  2. Klicken Sie im Menü auf Verwaltung > Nutzer verwalten.
  3. Klicken Sie auf Add User (Nutzer hinzufügen).
  4. Geben Sie die folgenden Konfigurationsdetails an:
    • Nutzername: Geben Sie einen Nutzernamen für den API-Zugriff ein (z. B. chronicle-api).
    • Passwort: Geben Sie ein starkes Passwort ein.
    • Passwort bestätigen: Geben Sie das Passwort noch einmal ein.
    • Nutzergruppe: Wählen Sie eine Nutzergruppe mit den entsprechenden Berechtigungen aus (siehe nächster Abschnitt).
  5. Klicken Sie auf Hinzufügen.

  6. Kopieren Sie die folgenden Details und speichern Sie sie an einem sicheren Ort:

    • Nutzername: Ihr Catalyst SD-WAN Manager-Nutzername.
    • Password: Ihr Catalyst SD-WAN Manager-Passwort.
    • Catalyst SD-WAN Manager Base URL (Catalyst SD-WAN Manager-Basis-URL): Die Basis-URL Ihres Catalyst SD-WAN Manager-Servers (z. B. https://sdwan-manager.example.com:8443).

Nutzerberechtigungen konfigurieren

Das API-Nutzerkonto benötigt bestimmte Berechtigungen, um auf Audit-Logs, Benachrichtigungen und Ereignisse zuzugreifen.

  1. Gehen Sie in der Cisco Catalyst SD-WAN Manager-Konsole im Menü zu Administration > Manage Users > User Groups (Verwaltung > Nutzer verwalten > Nutzergruppen).
  2. Wählen Sie die Nutzergruppe aus, die dem API-Nutzer zugewiesen ist, oder klicken Sie auf Nutzergruppe hinzufügen, um eine neue Gruppe zu erstellen.
  3. Klicken Sie auf Bearbeiten.
  4. Prüfen Sie im Abschnitt Funktion, ob die folgenden Berechtigungen aktiviert sind:
    • Audit-Log: Wählen Sie die Berechtigung Lesen aus.
    • Wecker: Wählen Sie die Berechtigung Lesen aus.
    • Termine: Wählen Sie die Berechtigung Lesen aus.
  5. Klicken Sie auf Aktualisieren.

API-Zugriff prüfen

Testen Sie Ihre Anmeldedaten, bevor Sie mit der Integration fortfahren:

  1. Öffnen Sie ein Terminal oder eine Eingabeaufforderung.

  2. Führen Sie den folgenden Befehl aus, um die Authentifizierung zu testen:

    # Replace with your actual credentials
SDWAN_HOST="https://sdwan-manager.example.com:8443"
SDWAN_USERNAME="chronicle-api"
SDWAN_PASSWORD="your-password"

# Test authentication using session-based login (returns JSESSIONID cookie)
curl -c cookies.txt -X POST \
  "${SDWAN_HOST}/j_security_check" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "j_username=${SDWAN_USERNAME}&j_password=${SDWAN_PASSWORD}"

# Get CSRF token (X-XSRF-TOKEN)
curl -b cookies.txt \
  "${SDWAN_HOST}/dataservice/client/token"

Wenn die Authentifizierung erfolgreich ist, gibt der zweite Befehl einen CSRF-Token-String zurück.

Dienstkonto für Cloud Run-Funktion erstellen

Für die Cloud Run-Funktion ist ein Dienstkonto mit Berechtigungen zum Schreiben in den GCS-Bucket und zum Aufrufen durch Pub/Sub erforderlich.

Dienstkonto erstellen

  1. Wechseln Sie in der GCP Console zu IAM und Verwaltung > Dienstkonten.
  2. Klicken Sie auf Dienstkonto erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Name des Dienstkontos: Geben Sie cisco-sdwan-collector-sa ein.
    • Beschreibung des Dienstkontos: Geben Sie Service account for Cloud Run function to collect Cisco Catalyst SD-WAN Manager logs ein.
  4. Klicken Sie auf Erstellen und fortfahren.
  5. Fügen Sie im Abschnitt Diesem Dienstkonto Zugriff auf das Projekt erteilen die folgenden Rollen hinzu:
    1. Klicken Sie auf Rolle auswählen.
    2. Suchen Sie nach Storage Object Admin und wählen Sie die Rolle aus.
    3. Klicken Sie auf + Weitere Rolle hinzufügen.
    4. Suchen Sie nach Cloud Run Invoker und wählen Sie die Rolle aus.
    5. Klicken Sie auf + Weitere Rolle hinzufügen.
    6. Suchen Sie nach Cloud Functions Invoker und wählen Sie die Rolle aus.
  6. Klicken Sie auf Weiter.
  7. Klicken Sie auf Fertig.

Diese Rollen sind für Folgendes erforderlich:

  • Storage-Objekt-Administrator: Protokolle in GCS-Bucket schreiben und Statusdateien verwalten
  • Cloud Run Invoker: Pub/Sub darf die Funktion aufrufen.
  • Cloud Functions-Invoker: Funktionsaufruf zulassen

IAM-Berechtigungen für GCS-Bucket erteilen

Gewähren Sie dem Dienstkonto Schreibberechtigungen für den GCS-Bucket:

  1. Rufen Sie Cloud Storage > Buckets auf.
  2. Klicken Sie auf den Namen Ihres Buckets.
  3. Wechseln Sie zum Tab Berechtigungen.
  4. Klicken Sie auf Zugriff erlauben.
  5. Geben Sie die folgenden Konfigurationsdetails an:
    • Hauptkonten hinzufügen: Geben Sie die E-Mail-Adresse des Dienstkontos ein (z. B. cisco-sdwan-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
    • Rollen zuweisen: Wählen Sie Storage Object Admin aus.
  6. Klicken Sie auf Speichern.

Pub/Sub-Thema erstellen

Erstellen Sie ein Pub/Sub-Thema, in dem Cloud Scheduler veröffentlicht und das von der Cloud Run-Funktion abonniert wird.

  1. Rufen Sie in der GCP Console Pub/Sub > Themen auf.
  2. Klicken Sie auf Thema erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Themen-ID: Geben Sie cisco-sdwan-trigger ein.
    • Übernehmen Sie die anderen Einstellungen.
  4. Klicken Sie auf Erstellen.

Cloud Run-Funktion zum Erfassen von Logs erstellen

Die Cloud Run-Funktion wird durch Pub/Sub-Nachrichten von Cloud Scheduler ausgelöst, um Logs von der Cisco Catalyst SD-WAN Manager API abzurufen und in GCS zu schreiben.

  1. Rufen Sie in der GCP Console Cloud Run auf.
  2. Klicken Sie auf Dienst erstellen.
  3. Wählen Sie Funktion aus, um eine Funktion mit einem Inline-Editor zu erstellen.

  4. Geben Sie im Abschnitt Konfigurieren die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Dienstname cisco-sdwan-log-collector
    Region Wählen Sie die Region aus, die Ihrem GCS-Bucket entspricht (z. B. us-central1).
    Laufzeit Wählen Sie Python 3.12 oder höher aus.

  5. Im Abschnitt Trigger (optional):

    1. Klicken Sie auf + Trigger hinzufügen.
    2. Wählen Sie Cloud Pub/Sub aus.
    3. Wählen Sie unter Cloud Pub/Sub-Thema auswählen das Thema (cisco-sdwan-trigger) aus.
    4. Klicken Sie auf Speichern.

  6. Im Abschnitt Authentifizierung:

    1. Wählen Sie Authentifizierung erforderlich aus.
    2. Weitere Informationen finden Sie unter Identity and Access Management (IAM).

  7. Scrollen Sie nach unten und maximieren Sie Container, Netzwerk, Sicherheit.

  8. Rufen Sie den Tab Sicherheit auf:

    • Dienstkonto: Wählen Sie das Dienstkonto aus (cisco-sdwan-collector-sa).

  9. Rufen Sie den Tab Container auf:

    1. Klicken Sie auf Variablen und Secrets.
    2. Klicken Sie für jede Umgebungsvariable auf + Variable hinzufügen:
    Variablenname Beispielwert
    GCS_BUCKET cisco-sdwan-logs-bucket
    GCS_PREFIX cisco-sdwan
    STATE_KEY cisco-sdwan/state.json
    SDWAN_HOST https://sdwan-manager.example.com:8443
    SDWAN_USERNAME chronicle-api
    SDWAN_PASSWORD your-sdwan-password
    LOOKBACK_HOURS 1

  10. Scrollen Sie auf dem Tab Variablen und Secrets nach unten zu Anfragen:

    • Zeitüberschreitung bei Anfrage: Geben Sie 600 Sekunden (10 Minuten) ein.

  11. Rufen Sie den Tab Einstellungen unter Container auf:

    • Im Abschnitt Ressourcen:
      • Arbeitsspeicher: Wählen Sie 512 MiB oder höher aus.
      • CPU: Wählen Sie 1 aus.

  12. Im Abschnitt Versionsskalierung:

    • Mindestanzahl von Instanzen: Geben Sie 0 ein.
    • Maximale Anzahl von Instanzen: Geben Sie 100 ein (oder passen Sie den Wert an die erwartete Last an).

  13. Klicken Sie auf Erstellen.

  14. Warten Sie, bis der Dienst erstellt wurde (1–2 Minuten).

  15. Nachdem der Dienst erstellt wurde, wird automatisch der Inline-Code-Editor geöffnet.

Funktionscode hinzufügen

  1. Geben Sie main in das Feld Einstiegspunkt ein.

  2. Erstellen Sie im Inline-Code-Editor zwei Dateien:

    • main.py:

      import functions_framework
from google.cloud import storage
import json
import os
import urllib3
import urllib.parse
from datetime import datetime, timezone, timedelta
import time

# Disable SSL warnings for self-signed certificates (testing only)
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

# Initialize HTTP client with timeouts
http = urllib3.PoolManager(
    timeout=urllib3.Timeout(connect=10.0, read=60.0),
    cert_reqs='CERT_NONE',
    retries=urllib3.Retry(total=3, backoff_factor=1)
)

# Initialize Storage client
storage_client = storage.Client()

# Environment variables
SDWAN_HOST = os.environ.get('SDWAN_HOST', '').rstrip('/')
SDWAN_USERNAME = os.environ.get('SDWAN_USERNAME', '')
SDWAN_PASSWORD = os.environ.get('SDWAN_PASSWORD', '')
GCS_BUCKET = os.environ.get('GCS_BUCKET', '')
GCS_PREFIX = os.environ.get('GCS_PREFIX', 'cisco-sdwan')
STATE_KEY = os.environ.get('STATE_KEY', 'cisco-sdwan/state.json')
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '1'))

class CatalystSDWANAPI:
    """Client for Cisco Catalyst SD-WAN Manager API (formerly vManage)."""

    def __init__(self, host, username, password):
        self.host = host
        self.username = username
        self.password = password
        self.jsessionid = None
        self.xsrf_token = None

    def authenticate(self):
        """Authenticate using session-based login (j_security_check)."""
        try:
            login_url = f"{self.host}/j_security_check"
            login_data = urllib.parse.urlencode({
                'j_username': self.username,
                'j_password': self.password
            }).encode('utf-8')

            response = http.request(
                'POST',
                login_url,
                body=login_data,
                headers={'Content-Type': 'application/x-www-form-urlencoded'},
            )

            if b'<html>' in response.data or response.status != 200:
                print(f"Authentication failed: HTTP {response.status}")
                return False

            # Extract JSESSIONID from Set-Cookie header
            cookie_header = response.headers.get('Set-Cookie', '')
            for part in cookie_header.split(','):
                if 'JSESSIONID=' in part:
                    self.jsessionid = part.split('JSESSIONID=')[1].split(';')[0]
                    break

            if not self.jsessionid:
                print("Failed to extract JSESSIONID from response")
                return False

            # Get XSRF token
            token_url = f"{self.host}/dataservice/client/token"
            headers = {
                'Content-Type': 'application/json',
                'Cookie': f"JSESSIONID={self.jsessionid}"
            }
            response = http.request('GET', token_url, headers=headers)

            if response.status == 200:
                self.xsrf_token = response.data.decode('utf-8').strip()
                print("Successfully authenticated with Catalyst SD-WAN Manager")
                return True
            else:
                print(f"Failed to get XSRF token: HTTP {response.status}")
                return False

        except Exception as e:
            print(f"Authentication error: {e}")
            return False

    def _get_headers(self):
        """Build headers for authenticated API requests."""
        return {
            'Content-Type': 'application/json',
            'Accept': 'application/json',
            'Cookie': f"JSESSIONID={self.jsessionid}",
            'X-XSRF-TOKEN': self.xsrf_token
        }

    def _build_query(self, last_epoch_ms=None):
        """Build a query payload with entry_time filter."""
        query = {
            "query": {
                "condition": "AND",
                "rules": []
            },
            "size": 10000
        }
        if last_epoch_ms:
            query["query"]["rules"].append({
                "value": [str(last_epoch_ms)],
                "field": "entry_time",
                "type": "date",
                "operator": "greater"
            })
        else:
            query["query"]["rules"].append({
                "value": [str(LOOKBACK_HOURS)],
                "field": "entry_time",
                "type": "date",
                "operator": "last_n_hours"
            })
        return query

    def fetch_data(self, endpoint, last_epoch_ms=None):
        """Fetch data from a /dataservice endpoint using POST with query body."""
        url = f"{self.host}/dataservice/{endpoint}"
        headers = self._get_headers()
        query = self._build_query(last_epoch_ms)

        try:
            response = http.request(
                'POST',
                url,
                body=json.dumps(query),
                headers=headers,
            )

            if response.status == 200:
                return json.loads(response.data.decode('utf-8'))
            else:
                print(f"Failed to get {endpoint}: HTTP {response.status}")
                return None

        except Exception as e:
            print(f"Error fetching {endpoint}: {e}")
            return None

def load_state(bucket):
    """Load the last run timestamp (epoch ms) from GCS state file."""
    try:
        blob = bucket.blob(STATE_KEY)
        if blob.exists():
            state_data = json.loads(blob.download_as_text())
            return state_data.get('last_run_time')
    except Exception as e:
        print(f"Warning: Could not load state: {e}")
    return None

def save_state(bucket, epoch_ms):
    """Save the current run timestamp (epoch ms) to GCS state file."""
    try:
        state_data = {
            'last_run_time': epoch_ms,
            'updated_at': datetime.now(timezone.utc).isoformat()
        }
        blob = bucket.blob(STATE_KEY)
        blob.upload_from_string(
            json.dumps(state_data),
            content_type='application/json'
        )
        print(f"Saved state: last_run_time={epoch_ms}")
    except Exception as e:
        print(f"Warning: Could not save state: {e}")

def upload_to_gcs(bucket, records, log_type):
    """Upload log records to GCS as NDJSON."""
    if not records:
        print(f"No {log_type} records to upload")
        return 0

    dt = datetime.now(timezone.utc)
    object_key = (
        f"{GCS_PREFIX}/{log_type}/"
        f"{dt.strftime('%Y/%m/%d')}/"
        f"{log_type}_{dt.strftime('%Y%m%d_%H%M%S')}.ndjson"
    )

    ndjson = '\n'.join(
        json.dumps(record, ensure_ascii=False) for record in records
    ) + '\n'

    blob = bucket.blob(object_key)
    blob.upload_from_string(ndjson, content_type='application/x-ndjson')
    print(f"Uploaded {len(records)} {log_type} records to gs://{GCS_BUCKET}/{object_key}")
    return len(records)

@functions_framework.cloud_event
def main(cloud_event):
    """
    Cloud Run function triggered by Pub/Sub.
    Fetches audit logs, alarms, and events from Cisco Catalyst SD-WAN Manager
    API and writes them to GCS as NDJSON files.

    Args:
        cloud_event: CloudEvent object containing Pub/Sub message
    """
    print(f"Starting Cisco Catalyst SD-WAN Manager log collection at {datetime.now(timezone.utc).isoformat()}")

    if not all([SDWAN_HOST, SDWAN_USERNAME, SDWAN_PASSWORD, GCS_BUCKET]):
        print("Error: Missing required environment variables")
        return

    try:
        bucket = storage_client.bucket(GCS_BUCKET)

        # Load last run timestamp
        last_run_time = load_state(bucket)
        if last_run_time:
            print(f"Resuming from last_run_time={last_run_time}")
        else:
            print(f"No previous state found, collecting last {LOOKBACK_HOURS} hour(s) of logs")

        # Authenticate
        api = CatalystSDWANAPI(SDWAN_HOST, SDWAN_USERNAME, SDWAN_PASSWORD)
        if not api.authenticate():
            print("Failed to authenticate with Catalyst SD-WAN Manager")
            return

        # Current timestamp for state tracking (epoch milliseconds)
        current_time = int(datetime.now(timezone.utc).timestamp() * 1000)

        # Collect audit logs, alarms, and events
        endpoints = [
            ('audit_logs', 'auditlog'),
            ('alarms', 'alarms'),
            ('events', 'events'),
        ]

        total_records = 0
        for log_type, endpoint in endpoints:
            try:
                print(f"Collecting {log_type} from /dataservice/{endpoint}...")
                response_data = api.fetch_data(endpoint, last_run_time)
                if response_data and 'data' in response_data:
                    count = upload_to_gcs(bucket, response_data['data'], log_type)
                    total_records += count
                else:
                    print(f"No {log_type} data returned")
            except Exception as e:
                print(f"Error processing {log_type}: {e}")
                continue

        # Update state
        save_state(bucket, current_time)

        print(f"Collection completed. Total records processed: {total_records}")

    except Exception as e:
        print(f"Function execution error: {e}")
        raise

    • requirements.txt:

      functions-framework==3.*
google-cloud-storage==2.*
urllib3>=2.0.0
    .

  3. Klicken Sie auf Bereitstellen, um die Funktion zu speichern und bereitzustellen.

  4. Warten Sie, bis die Bereitstellung abgeschlossen ist (2–3 Minuten).

Cloud Scheduler-Job erstellen

Cloud Scheduler veröffentlicht in regelmäßigen Abständen Nachrichten im Pub/Sub-Thema und löst so die Cloud Run-Funktion aus.

  1. Rufen Sie in der GCP Console Cloud Scheduler auf.
  2. Klicken Sie auf Job erstellen.

  3. Geben Sie die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Name cisco-sdwan-log-collector-hourly
    Region Dieselbe Region wie die Cloud Run-Funktion auswählen
    Frequenz 0 * * * * (stündlich zur vollen Stunde)
    Zeitzone Zeitzone auswählen (UTC empfohlen)
    Zieltyp Pub/Sub
    Thema Wählen Sie das Thema aus (cisco-sdwan-trigger).
    Inhalt der Nachricht {} (leeres JSON-Objekt)

  4. Klicken Sie auf Erstellen.

Optionen für die Häufigkeit des Zeitplans

Wählen Sie die Häufigkeit basierend auf dem Logvolumen und den Latenzanforderungen aus:

Häufigkeit Cron-Ausdruck Anwendungsfall
Alle 5 Minuten */5 * * * * Hohes Volumen, niedrige Latenz
Alle 15 Minuten */15 * * * * Mittleres Suchvolumen
Stündlich 0 * * * * Standard (empfohlen)
Alle 6 Stunden 0 */6 * * * Geringes Volumen, Batchverarbeitung
Täglich 0 0 * * * Erhebung von Verlaufsdaten

Integration testen

  1. Suchen Sie in der Cloud Scheduler-Konsole nach Ihrem Job.
  2. Klicken Sie auf Ausführung erzwingen, um den Job manuell auszulösen.
  3. Warten Sie einige Sekunden.
  4. Rufen Sie Cloud Run > Dienste auf.
  5. Klicken Sie auf den Funktionsnamen (cisco-sdwan-log-collector).
  6. Klicken Sie auf den Tab Logs.

  7. Prüfen Sie, ob die Funktion erfolgreich ausgeführt wurde. Darauf sollten Sie achten:

    Starting Cisco Catalyst SD-WAN Manager log collection at ...
Successfully authenticated with Catalyst SD-WAN Manager
Collecting audit_logs from /dataservice/auditlog...
Uploaded N audit_logs records to gs://...
Collection completed. Total records processed: N

  8. Rufen Sie Cloud Storage > Buckets auf.

  9. Klicken Sie auf den Namen Ihres Buckets.

  10. Rufen Sie den Präfixordner (cisco-sdwan/) auf.

  11. Prüfen Sie, ob neue .ndjson-Dateien mit dem aktuellen Zeitstempel erstellt wurden.

Wenn in den Logs Fehler angezeigt werden:

  • HTTP 401: API-Anmeldedaten in Umgebungsvariablen prüfen
  • HTTP 403: Prüfen Sie, ob das Nutzerkonto die erforderlichen Leseberechtigungen für Audit-Log, Alarme und Ereignisse hat.
  • Authentifizierung fehlgeschlagen: Prüfen Sie, ob die Basis-URL von Catalyst SD-WAN Manager den richtigen Port enthält (Standard: 8443).
  • Fehlende Umgebungsvariablen: Prüfen Sie, ob alle erforderlichen Variablen festgelegt sind.

Feed in Google SecOps konfigurieren, um Cisco Catalyst SD-WAN Manager-Logs aufzunehmen

  1. Rufen Sie die SIEM-Einstellungen > Feeds auf.
  2. Klicken Sie auf Neuen Feed hinzufügen.
  3. Klicken Sie auf Einzelnen Feed konfigurieren.
  4. Geben Sie im Feld Feedname einen Namen für den Feed ein, z. B. Cisco Catalyst SD-WAN Manager logs.
  5. Wählen Sie Google Cloud Storage V2 als Quelltyp aus.
  6. Wählen Sie Cisco SD-WAN als Logtyp aus.

  7. Klicken Sie auf Dienstkonto abrufen. Es wird eine eindeutige E-Mail-Adresse für das Dienstkonto angezeigt, z. B.:

    chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com

  8. Kopieren Sie diese E‑Mail-Adresse für den nächsten Schritt.

  9. Klicken Sie auf Weiter.

  10. Geben Sie Werte für die folgenden Eingabeparameter an:

    • Storage-Bucket-URL: Geben Sie den GCS-Bucket-URI mit dem Präfixpfad ein:

      gs://cisco-sdwan-logs-bucket/cisco-sdwan/
      • Ersetzen Sie:
        • cisco-sdwan-logs-bucket: Der Name Ihres GCS-Buckets.
        • cisco-sdwan/: Optionales Präfix/Ordnerpfad, in dem Logs gespeichert werden (für den Stamm leer lassen).

    • Option zum Löschen der Quelle: Wählen Sie die gewünschte Option zum Löschen aus:

      • Nie: Löscht nach Übertragungen nie Dateien (empfohlen für Tests).
      • Übertragene Dateien löschen: Dateien werden nach der erfolgreichen Übertragung gelöscht.
      • Übertragene Dateien und leere Verzeichnisse löschen: Löscht Dateien und leere Verzeichnisse nach der erfolgreichen Übertragung.

    • Maximales Dateialter: Dateien einschließen, die in den letzten Tagen geändert wurden (Standardwert: 180 Tage).

    • Asset-Namespace: Der Asset-Namespace.

    • Aufnahmelabels: Das Label, das auf die Ereignisse aus diesem Feed angewendet werden soll.

  11. Klicken Sie auf Weiter.

  12. Prüfen Sie die neue Feedkonfiguration auf dem Bildschirm Abschließen und klicken Sie dann auf Senden.

Dem Google SecOps-Dienstkonto IAM-Berechtigungen gewähren

Das Google SecOps-Dienstkonto benötigt die Rolle Storage Object Viewer für Ihren GCS-Bucket.

  1. Rufen Sie Cloud Storage > Buckets auf.
  2. Klicken Sie auf den Namen Ihres Buckets.
  3. Wechseln Sie zum Tab Berechtigungen.
  4. Klicken Sie auf Zugriff erlauben.
  5. Geben Sie die folgenden Konfigurationsdetails an:
    • Hauptkonten hinzufügen: Fügen Sie die E‑Mail-Adresse des Google SecOps-Dienstkontos ein.
    • Rollen zuweisen: Wählen Sie Storage Object Viewer aus.

  6. Klicken Sie auf Speichern.

UDM-Zuordnungstabelle

Logfeld UDM-Zuordnung Logik
Tunnel_id_label additional.fields Zusammengeführt
additional_tag additional.fields Zusammengeführt
count_label additional.fields Zusammengeführt
dst_vrf_label additional.fields Zusammengeführt
logfeature_label additional.fields Zusammengeführt
logmodule_label additional.fields Zusammengeführt
meta_sequenceId_label additional.fields Zusammengeführt
msg_label additional.fields Zusammengeführt
qfp_label additional.fields Zusammengeführt
result_label additional.fields Zusammengeführt
rsa_sha256_label additional.fields Zusammengeführt
rsa_type_label additional.fields Zusammengeführt
sequence_label additional.fields Zusammengeführt
src_vrf_label additional.fields Zusammengeführt
tenant_vpn_id_label additional.fields Zusammengeführt
thread_label additional.fields Zusammengeführt
tos_label additional.fields Zusammengeführt
unknown_tenant_label additional.fields Zusammengeführt
vlan_id_label additional.fields Zusammengeführt
vpn_id_label additional.fields Zusammengeführt
description_1 extensions.auth.type Zugeordnet: (?i)closed → AUTHTYPE_UNSPECIFIED
msg1 extensions.auth.type Zugeordnet: authenticated → AUTHTYPE_UNSPECIFIED
msgs extensions.auth.type Zugeordnet: (?i)success → AUTHTYPE_UNSPECIFIED
prod_type extensions.auth.type Zugeordnet: (?i)LOGOUT → AUTHTYPE_UNSPECIFIED
host_name intermediary.asset.hostname Direkt zugeordnet
host_name intermediary.hostname Direkt zugeordnet
inter_host intermediary.hostname Direkt zugeordnet
logmsg metadata.description Direkt zugeordnet
message_value metadata.description Direkt zugeordnet
msgs metadata.description Direkt zugeordnet
date_time metadata.event_timestamp Als ISO8601 geparst
time metadata.event_timestamp Als ISO8601 geparst
time_t metadata.event_timestamp Als ISO8601 geparst
timestamp metadata.event_timestamp Als ISO8601 geparst
description_1 metadata.event_type Zugeordnet: (?i)closed → USER_LOGOUT
has_principal metadata.event_type Zugeordnet: true → NETWORK_CONNECTION, true → STATUS_UPDATE
has_principal_user metadata.event_type Zugeordnet: true → USER_UNCATEGORIZED
msg1 metadata.event_type Zugeordnet: authenticated → USER_LOGIN
msgs metadata.event_type Zugeordnet: (?i)success → USER_LOGIN
prod_type metadata.event_type Zugeordnet: (?i)LOGOUT → USER_LOGOUT
prod_type metadata.product_event_type Direkt zugeordnet
log_id metadata.product_log_id Direkt zugeordnet
logid metadata.product_log_id Direkt zugeordnet
application_protocol network.application_protocol Zugeordnet: (?i)SSH → SSH
message network.application_protocol Zugeordnet: (?i)SSH → SSH, (?i)netconf → NETCONF, (?i)dhcp → DHCP
type1 network.dhcp.type Zugeordnet: DHCPDISCOVER → DISCOVER
message network.ip_protocol Zugeordnet: (?i)tcp → TCP
network_protocol network.ip_protocol Direkt zugeordnet
bytes network.sent_bytes Direkt zugeordnet
session_id network.session_id Direkt zugeordnet
network_host network.tls.cipher Direkt zugeordnet
hostname principal.asset.hostname Direkt zugeordnet
host principal.asset.ip Zusammengeführt
initiator_ip principal.asset.ip Zusammengeführt
ip principal.asset.ip Zusammengeführt
ipaddress principal.asset.ip Zusammengeführt
logusersrcip principal.asset.ip Zusammengeführt
peer_ip principal.asset.ip Zusammengeführt
principal_ip principal.asset.ip Zusammengeführt
principal_ip1 principal.asset.ip Zusammengeführt
proxy_host principal.asset.ip Zusammengeführt
src_ip principal.asset.ip Zusammengeführt
system_ip principal.asset.ip Zusammengeführt
addr principal.hostname Direkt zugeordnet
hostname principal.hostname Direkt zugeordnet
host principal.ip Zusammengeführt
initiator_ip principal.ip Zusammengeführt
ip principal.ip Zusammengeführt
ipaddress principal.ip Zusammengeführt
logusersrcip principal.ip Zusammengeführt
peer_ip principal.ip Zusammengeführt
principal_ip principal.ip Zusammengeführt
principal_ip1 principal.ip Zusammengeführt
proxy_host principal.ip Zusammengeführt
src_ip principal.ip Zusammengeführt
system_ip principal.ip Zusammengeführt
initiator_port principal.port Direkt zugeordnet
port principal.port Direkt zugeordnet
ports principal.port Direkt zugeordnet
principal_port principal.port Direkt zugeordnet
principal_port1 principal.port Direkt zugeordnet
src_port principal.port Direkt zugeordnet
process_path principal.process.file.full_path Direkt zugeordnet
parent_pid principal.process.parent_process.pid Direkt zugeordnet
pid principal.process.pid Direkt zugeordnet
process_label principal.resource.attribute.labels Zusammengeführt
process_name_label principal.resource.attribute.labels Zusammengeführt
loguser principal.user.userid Direkt zugeordnet
user1 principal.user.userid Direkt zugeordnet
user_id principal.user.userid Direkt zugeordnet
username principal.user.userid Direkt zugeordnet
action security_result.action Zusammengeführt
message security_result.action Zugeordnet: (?i)(succeeded/accounting start/open/occurred/update/successfully/success) → `acti...
classification security_result.category_details Zusammengeführt
msg1 security_result.description Direkt zugeordnet
Malware_label security_result.detection_fields Zusammengeführt
direction_label security_result.detection_fields Zusammengeführt
egress_interface_label security_result.detection_fields Zusammengeführt
ingress_interface_label security_result.detection_fields Zusammengeführt
log_prefix_label security_result.detection_fields Zusammengeführt
log_reason_label security_result.detection_fields Zusammengeführt
packet_label security_result.detection_fields Zusammengeführt
policy_label security_result.detection_fields Zusammengeführt
port_label security_result.detection_fields Zusammengeführt
protocol_label security_result.detection_fields Zusammengeführt
proxy_port_label security_result.detection_fields Zusammengeführt
sent_bytes_1_label security_result.detection_fields Zusammengeführt
sent_bytes_2_label security_result.detection_fields Zusammengeführt
tty_label security_result.detection_fields Zusammengeführt
type_label security_result.detection_fields Zusammengeführt
udp_packets_label security_result.detection_fields Zusammengeführt
priority security_result.severity Zugeordnet: 1 → LOW
description_1 security_result.summary Direkt zugeordnet
dst_ip target.asset.ip Zusammengeführt
ipadres target.asset.ip Zusammengeführt
logdeviceid target.asset.ip Zusammengeführt
responder_ip target.asset.ip Zusammengeführt
target_ip target.asset.ip Zusammengeführt
target_ip1 target.asset.ip Zusammengeführt
filename target.file.names Zusammengeführt
dst_ip target.ip Zusammengeführt
ipadres target.ip Zusammengeführt
logdeviceid target.ip Zusammengeführt
responder_ip target.ip Zusammengeführt
target_ip target.ip Zusammengeführt
target_ip1 target.ip Zusammengeführt
dst_port target.port Direkt zugeordnet
prts target.port Direkt zugeordnet
responder_port target.port Direkt zugeordnet
target_port target.port Direkt zugeordnet
target_port1 target.port Direkt zugeordnet
filetype target.process.file.mime_type Direkt zugeordnet
parent_identifier_label target.resource.attribute.labels Zusammengeführt
specific_identifer_label target.resource.attribute.labels Zusammengeführt
target_name target.resource.name Direkt zugeordnet
instance_id target.resource.product_object_id Direkt zugeordnet
target_username target.user.userid Direkt zugeordnet
user target.user.userid Direkt zugeordnet
– extensions.auth.type Konstante: AUTHTYPE_UNSPECIFIED
– metadata.event_type Konstante: USER_LOGIN
– network.application_protocol Konstante: SSH
– network.dhcp.type Konstante: DISCOVER
– network.ip_protocol Konstante: TCP
– security_result.severity Konstante: LOW
rsa_type event.idm.read_only_udm.additional.fields Aus dem Änderungsprotokoll zugeordnet
sha_256 event.idm.read_only_udm.additional.fields Aus dem Änderungsprotokoll zugeordnet
NETCONF event.idm.read_only_udm.network.application_protocol Aus dem Änderungsprotokoll zugeordnet
TCP event.idm.read_only_udm.network.ip_protocol Aus dem Änderungsprotokoll zugeordnet
DHCP event.idm.read_only_udm.network.application_protocol Aus dem Änderungsprotokoll zugeordnet
username1 target.user.userid Aus dem Änderungsprotokoll zugeordnet
security_result.action ALLOW Aus dem Änderungsprotokoll zugeordnet
ip_1 principal.ip Aus dem Änderungsprotokoll zugeordnet
ip_2 target.ip Aus dem Änderungsprotokoll zugeordnet
port_1 principal.port Aus dem Änderungsprotokoll zugeordnet
port_2 target.port Aus dem Änderungsprotokoll zugeordnet
message_1 metadata.description Aus dem Änderungsprotokoll zugeordnet
malware security_result.detection_fields Aus dem Änderungsprotokoll zugeordnet

Änderungsprotokoll

Änderungsprotokoll für diesen Parser ansehen

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