Collecter les journaux Cisco Application Centric Infrastructure (ACI)

Compatible avec :

Ce document explique comment ingérer des journaux Cisco Application Centric Infrastructure (ACI) dans Google Security Operations. L'analyseur tente d'abord de traiter les journaux Cisco ACI entrants en tant que messages syslog à l'aide de modèles Grok. Si l'analyse syslog échoue, le message est considéré comme étant au format JSON et est analysé en conséquence. Enfin, il mappe les champs extraits au modèle de données unifié (UDM).

Cette intégration est compatible avec deux méthodes :

  • Option 1 : Format Syslog via l'agent Bindplane
  • Option 2 : Format JSON via AWS S3 à l'aide de l'API REST APIC

Chaque option est autonome et peut être implémentée indépendamment en fonction des exigences de votre infrastructure et de vos préférences concernant le format des journaux.

Option 1 : Syslog via l'agent Bindplane

Cette option configure le fabric Cisco ACI pour envoyer des messages syslog à un agent Bindplane, qui les transfère à Chronicle pour analyse.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

  • Une instance Google SecOps
  • Un hôte Windows 2016 ou version ultérieure, ou Linux avec systemd
  • Si vous exécutez l'agent derrière un proxy, assurez-vous que les ports de pare-feu sont ouverts conformément aux exigences de l'agent Bindplane.
  • Accès privilégié à la console Cisco APIC

Obtenir le fichier d'authentification d'ingestion Google SecOps

  1. Connectez-vous à la console Google SecOps.
  2. Accédez à Paramètres du SIEM > Agents de collecte.
  3. Téléchargez le fichier d'authentification d'ingestion. Enregistrez le fichier de manière sécurisée sur le système sur lequel Bindplane sera installé.

Obtenir l'ID client Google SecOps

  1. Connectez-vous à la console Google SecOps.
  2. Accédez à Paramètres SIEM> Profil.
  3. Copiez et enregistrez le numéro client de la section Informations sur l'organisation.

Installer l'agent Bindplane

Installez l'agent Bindplane sur votre système d'exploitation Windows ou Linux en suivant les instructions ci-dessous.

Installation de fenêtres

  1. Ouvrez l'invite de commandes ou PowerShell en tant qu'administrateur.

  2. Exécutez la commande suivante :

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

Installation de Linux

  1. Ouvrez un terminal avec les droits root ou sudo.

  2. Exécutez la commande suivante :

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

Autres ressources d'installation

Configurer l'agent Bindplane pour ingérer Syslog et l'envoyer à Google SecOps

  1. Accédez au fichier de configuration :

    1. Recherchez le fichier config.yaml. Il se trouve généralement dans le répertoire /etc/bindplane-agent/ sous Linux ou dans le répertoire d'installation sous Windows.
    2. Ouvrez le fichier à l'aide d'un éditeur de texte (par exemple, nano, vi ou le Bloc-notes).

  2. Modifiez le fichier config.yaml comme suit :

    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
    • Remplacez le port et l'adresse IP selon les besoins de votre infrastructure.
    • Remplacez <customer_id> par le numéro client réel.
    • Mettez à jour /path/to/ingestion-authentication-file.json en indiquant le chemin d'accès où le fichier d'authentification a été enregistré dans la section Obtenir le fichier d'authentification pour l'ingestion Google SecOps.

Redémarrez l'agent Bindplane pour appliquer les modifications.

  • Pour redémarrer l'agent Bindplane sous Linux, exécutez la commande suivante :

    sudo systemctl restart bindplane-agent

  • Pour redémarrer l'agent Bindplane sous Windows, vous pouvez utiliser la console Services ou saisir la commande suivante :

    net stop BindPlaneAgent && net start BindPlaneAgent

Configurer le transfert Syslog sur Cisco ACI

Configurer le contrat de gestion hors bande

  1. Connectez-vous à la console Cisco APIC.
  2. Accédez à Tenants > mgmt > Contracts > Filters.
  3. Cliquez sur Créer un filtre.
  4. Fournissez les informations de configuration suivantes :
    • Nom : saisissez syslog-udp-514.
    • Nom de l'entrée : saisissez syslog.
    • EtherType : sélectionnez IP.
    • Protocole IP : sélectionnez UDP.
    • Plage de ports de destination (de) : saisissez 514.
    • Plage de ports de destination (jusqu'à) : saisissez 514.
  5. Cliquez sur Envoyer.

Créer un contrat de gestion

  1. Accédez à Tenants> mgmt> Contracts> Standard.
  2. Cliquez sur Créer un contrat.
  3. Fournissez les informations de configuration suivantes :
    • Nom : saisissez mgmt-syslog-contract.
    • Champ d'application : sélectionnez Contexte.
  4. Cliquez sur Envoyer.
  5. Développez le contrat, puis cliquez sur Sujets.
  6. Cliquez sur Créer un objet de contrat.
  7. Fournissez les informations de configuration suivantes :
    • Nom : saisissez syslog-subject.
    • Appliquer les deux sens : cochez cette option.
  8. Cliquez sur Envoyer.
  9. Développez le sujet, puis cliquez sur Filtres.
  10. Cliquez sur Créer une liaison de filtre.
  11. Sélectionnez le filtre syslog-udp-514 créé précédemment.
  12. Cliquez sur Envoyer.

Configurer un groupe de destinations Syslog

  1. Accédez à Administration > Collecteurs de données externes > Destinations de surveillance > Syslog.
  2. Effectuez un clic droit sur Syslog, puis sélectionnez Créer un groupe de destinations de surveillance Syslog.
  3. Fournissez les informations de configuration suivantes :
    • Nom : saisissez Chronicle-Syslog-Group.
    • État de l'administrateur : sélectionnez Activé.
    • Format : sélectionnez aci.
  4. Cliquez sur Suivant.
  5. Dans la boîte de dialogue Créer une destination de surveillance Syslog :
    • Nom : saisissez Chronicle-BindPlane.
    • Hôte : saisissez l'adresse IP de votre serveur d'agent Bindplane.
    • Port : saisissez 514.
    • État de l'administrateur : sélectionnez Activé.
    • Gravité : sélectionnez Informations (pour capturer les journaux détaillés).
  6. Cliquez sur Envoyer.

Configurer des règles de surveillance

Règles de surveillance de Fabric

  1. Accédez à Fabric > Fabric Policies > Policies > Monitoring > Common Policy (Structure > Règles de structure > Règles > Surveillance > Règle commune).
  2. Développez Callhome/Smart Callhome/SNMP/Syslog/TACACS.
  3. Effectuez un clic droit sur Syslog, puis sélectionnez Créer une source Syslog.
  4. Fournissez les informations de configuration suivantes :
    • Nom : saisissez Chronicle-Fabric-Syslog.
    • Journaux d'audit : cochez cette case pour inclure les événements d'audit.
    • Événements : cochez cette case pour inclure les événements système.
    • Défauts : cochez cette case pour inclure les événements de défaut.
    • Journaux de session : cochez cette case pour inclure les journaux de session.
    • Groupe de destinations : sélectionnez Chronicle-Syslog-Group.
  5. Cliquez sur Envoyer.

Règles de surveillance des accès

  1. Accédez à Structure > Règles d'accès > Règles > Surveillance > Règle par défaut.
  2. Développez Callhome/Smart Callhome/SNMP/Syslog.
  3. Effectuez un clic droit sur Syslog, puis sélectionnez Créer une source Syslog.
  4. Fournissez les informations de configuration suivantes :
    • Nom : saisissez Chronicle-Access-Syslog.
    • Journaux d'audit : cochez cette case pour inclure les événements d'audit.
    • Événements : cochez cette case pour inclure les événements système.
    • Défauts : cochez cette case pour inclure les événements de défaut.
    • Journaux de session : cochez cette case pour inclure les journaux de session.
    • Groupe de destinations : sélectionnez Chronicle-Syslog-Group.
  5. Cliquez sur Envoyer.

Configurer la règle "Messages Syslog système"

  1. Accédez à Fabric > Fabric Policies > Policies > Monitoring > Common Policy (Structure > Règles de structure > Règles > Surveillance > Règle commune).
  2. Développez Règles relatives aux messages Syslog.
  3. Cliquez sur par défaut.
  4. Dans la section Filtre des établissements :
    • Établissement : sélectionnez par défaut.
    • Gravité minimale : remplacez-la par information.
  5. Cliquez sur Envoyer.

Option 2 : JSON via AWS S3

Cette option utilise l'API REST APIC pour collecter les événements, les défauts et les journaux d'audit au format JSON à partir de la structure Cisco ACI, et les stocke dans AWS S3 pour l'ingestion SecOps.

Avant de commencer

  • Instance Google SecOps.
  • Accès privilégié à la console Cisco APIC.
  • Accès privilégié à AWS (S3, IAM, Lambda, EventBridge).

Collecter les conditions préalables de Cisco ACI APIC (ID, clés API, ID d'organisation, jetons)

  1. Connectez-vous à la console Cisco APIC à l'aide du protocole HTTPS.
  2. Accédez à Admin> AAA (sur APIC 6.0 ou version ultérieure) ou Admin> Authentification> AAA (sur les versions antérieures).
    • Remarque : Le chemin d'accès au menu AAA a changé à partir d'APIC 6.0(1).
  3. Créez un utilisateur local ou utilisez-en un existant avec les droits appropriés.
  4. Copiez et enregistrez les informations suivantes dans un emplacement sécurisé :
    • Nom d'utilisateur APIC : utilisateur local disposant d'un accès en lecture aux données de surveillance
    • Mot de passe APIC : mot de passe de l'utilisateur
    • URL APIC : URL HTTPS de votre APIC (par exemple, https://apic.example.com)

Configurer un bucket AWS S3 et IAM pour Google SecOps

  1. Créez un bucket Amazon S3 en suivant ce guide de l'utilisateur : Créer un bucket.
  2. Enregistrez le nom et la région du bucket pour référence ultérieure (par exemple, cisco-aci-logs).
  3. Créez un utilisateur en suivant ce guide de l'utilisateur : Créer un utilisateur IAM.
  4. Sélectionnez l'utilisateur créé.
  5. Sélectionnez l'onglet Informations d'identification de sécurité.
  6. Cliquez sur Créer une clé d'accès dans la section Clés d'accès.
  7. Sélectionnez Service tiers comme Cas d'utilisation.
  8. Cliquez sur Suivant.
  9. Facultatif : Ajoutez un tag de description.
  10. Cliquez sur Créer une clé d'accès.
  11. Cliquez sur Télécharger le fichier CSV pour enregistrer la clé d'accès et la clé d'accès secrète pour référence ultérieure.
  12. Cliquez sur OK.
  13. Sélectionnez l'onglet Autorisations.
  14. Cliquez sur Ajouter des autorisations dans la section Règles relatives aux autorisations.
  15. Sélectionnez Ajouter des autorisations.
  16. Sélectionnez Joindre directement des règles.
  17. Recherchez la règle AmazonS3FullAccess.
  18. Sélectionnez la règle.
  19. Cliquez sur Suivant.
  20. Cliquez sur Ajouter des autorisations.

Configurer la stratégie et le rôle IAM pour les importations S3

  1. Dans la console AWS, accédez à IAM > Stratégies.
  2. Cliquez sur Créer une règle> onglet "JSON".

  3. Saisissez la règle suivante :

    {
  "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"
    }
  ]
}
    • Remplacez cisco-aci-logs si vous avez saisi un autre nom de bucket.

  4. Cliquez sur Suivant > Créer une règle.

  5. Accédez à IAM > Rôles > Créer un rôle > Service AWS > Lambda.

  6. Associez la stratégie que vous venez de créer et la stratégie gérée AWSLambdaBasicExecutionRole.

  7. Nommez le rôle cisco-aci-lambda-role, puis cliquez sur Créer un rôle.

Créer la fonction Lambda

  1. Dans la console AWS, accédez à Lambda > Fonctions > Créer une fonction.
  2. Cliquez sur Créer à partir de zéro.

  3. Fournissez les informations de configuration suivantes :

    • Nom : cisco-aci-events-collector
    • Runtime : Python 3.13
    • Architecture : x86_64
    • Rôle d'exécution : cisco-aci-lambda-role

  4. Une fois la fonction créée, ouvrez l'onglet Code, supprimez le stub et saisissez le code suivant (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. Accédez à Configuration > Variables d'environnement.

  6. Cliquez sur Modifier > Ajouter une variable d'environnement.

  7. Saisissez les variables d'environnement fournies, en remplaçant par vos valeurs.

    • 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 (facultatif, contrôle la taille de la pagination)
    • MAX_PAGES : 10 (facultatif, limite le nombre total de pages extraites par exécution)

  8. Une fois la fonction créée, restez sur sa page (ou ouvrez Lambda > Functions > cisco-aci-events-collector).

  9. Accédez à l'onglet Configuration.

  10. Dans le panneau Configuration générale, cliquez sur Modifier.

  11. Définissez Délai avant expiration sur 5 minutes (300 secondes), puis cliquez sur Enregistrer.

Créer une programmation EventBridge

  1. Accédez à Amazon EventBridge> Scheduler> Create schedule.
  2. Fournissez les informations de configuration suivantes :
    • Planification récurrente : Tarif (15 minutes).
    • Cible : votre fonction Lambda cisco-aci-events-collector.
    • Nom : cisco-aci-events-collector-15m.
  3. Cliquez sur Créer la programmation.

Facultatif : Créez un utilisateur et des clés IAM en lecture seule pour Google SecOps

  1. Accédez à la console AWS> IAM> Utilisateurs> Ajouter des utilisateurs.
  2. Cliquez sur Add users (Ajouter des utilisateurs).
  3. Fournissez les informations de configuration suivantes :
    • Utilisateur : saisissez secops-reader.
    • Type d'accès : sélectionnez Clé d'accès – Accès programmatique.
  4. Cliquez sur Créer un utilisateur.
  5. Associez une stratégie de lecture minimale (personnalisée) : Utilisateurs > secops-reader > Autorisations > Ajouter des autorisations > Associer des stratégies directement > Créer une stratégie.

  6. Dans l'éditeur JSON, saisissez la stratégie suivante :

    {
  "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. Définissez le nom sur secops-reader-policy.

  8. Accédez à Créer une règle > recherchez/sélectionnez > Suivant > Ajouter des autorisations.

  9. Accédez à Identifiants de sécurité> Clés d'accès> Créer une clé d'accès.

  10. Téléchargez le CSV (ces valeurs sont saisies dans le flux).

Configurer un flux dans Google SecOps pour ingérer les journaux Cisco ACI

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur + Ajouter un flux.
  3. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Cisco ACI JSON logs).
  4. Sélectionnez Amazon S3 V2 comme type de source.
  5. Sélectionnez Cisco Application Centric Infrastructure comme type de journal.
  6. Cliquez sur Suivant.
  7. Spécifiez les valeurs des paramètres d'entrée suivants :
    • URI S3 : s3://cisco-aci-logs/cisco-aci-events/
    • Options de suppression de la source : sélectionnez l'option de suppression de votre choix.
    • Âge maximal des fichiers : incluez les fichiers modifiés au cours des derniers jours. La valeur par défaut est de 180 jours.
    • ID de clé d'accès : clé d'accès utilisateur ayant accès au bucket S3.
    • Clé d'accès secrète : clé secrète de l'utilisateur ayant accès au bucket S3.
    • Espace de noms de l'élément : espace de noms de l'élément.
    • Libellés d'ingestion : libellé appliqué aux événements de ce flux.
  8. Cliquez sur Suivant.
  9. Vérifiez la configuration de votre nouveau flux sur l'écran Finaliser, puis cliquez sur Envoyer.

Table de mappage UDM

Champ de journal Mappage UDM Logique
@timestamp read_only_udm.metadata.event_timestamp La valeur est extraite du champ de journal brut "@timestamp" et analysée en tant que code temporel.
aci_tag read_only_udm.metadata.product_log_id La valeur est extraite du champ de journal brut "aci_tag".
cisco_timestamp - Non mappé.
DIP read_only_udm.target.ip La valeur est extraite du champ de journal brut "DIP".
DPort read_only_udm.target.port La valeur est extraite du champ de journal brut "DPort" et convertie en entier.
description read_only_udm.security_result.description La valeur est extraite du champ de journal brut "description".
fault_cause read_only_udm.additional.fields.value.string_value La valeur est extraite du champ de journal brut "fault_cause". La clé est définie sur "Cause du problème".
nom d'hôte read_only_udm.principal.hostname La valeur est extraite du champ de journal brut "hostname".
lifecycle_state read_only_udm.metadata.product_event_type La valeur est extraite du champ de journal brut "lifecycle_state".
log.source.address - Non mappé.
logstash.collect.host - Non mappé.
logstash.collect.timestamp read_only_udm.metadata.collected_timestamp La valeur est extraite du champ de journal brut "logstash.collect.timestamp" et analysée en tant qu'horodatage.
logstash.ingest.host read_only_udm.intermediary.hostname La valeur est extraite du champ de journal brut "logstash.ingest.host".
logstash.irm_environment read_only_udm.additional.fields.value.string_value La valeur est extraite du champ de journal brut "logstash.irm_environment". La clé est définie sur "IRM_Environment".
logstash.irm_region read_only_udm.additional.fields.value.string_value La valeur est extraite du champ de journal brut "logstash.irm_region". La clé est définie sur "IRM_Region".
logstash.irm_site read_only_udm.additional.fields.value.string_value La valeur est extraite du champ de journal brut "logstash.irm_site". La clé est définie sur "IRM_Site".
logstash.process.host read_only_udm.intermediary.hostname La valeur est extraite du champ de journal brut "logstash.process.host".
message - Non mappé.
message_class - Non mappé.
message_code - Non mappé.
message_content - Non mappé.
message_dn - Non mappé.
message_type read_only_udm.metadata.product_event_type La valeur est extraite du champ de journal brut "message_type" après suppression des crochets.
node_link read_only_udm.principal.process.file.full_path La valeur est extraite du champ de journal brut "node_link".
PktLen read_only_udm.network.received_bytes La valeur est extraite du champ de journal brut "PktLen" et convertie en entier non signé.
le programme - Non mappé.
Proto read_only_udm.network.ip_protocol La valeur est extraite du champ de journal brut "Proto", convertie en entier et mappée au nom du protocole IP correspondant (par exemple, 6 > TCP).
SIP read_only_udm.principal.ip La valeur est extraite du champ de journal brut "SIP".
SPort read_only_udm.principal.port La valeur est extraite du champ de journal brut "SPort" et convertie en entier.
syslog_facility - Non mappé.
syslog_facility_code - Non mappé.
syslog_host read_only_udm.principal.ip, read_only_udm.observer.ip La valeur est extraite du champ de journal brut "syslog_host".
syslog_prog - Non mappé.
syslog_severity read_only_udm.security_result.severity_details La valeur est extraite du champ de journal brut "syslog_severity".
syslog_severity_code read_only_udm.security_result.severity La valeur est extraite du champ de journal brut "syslog_severity_code" et mappée au niveau de gravité correspondant : 5, 6, 7 → INFORMATIONAL ; 3, 4 → MEDIUM ; 0, 1, 2 → HIGH.
syslog5424_pri - Non mappé.
Vlan-Id read_only_udm.principal.resource.id La valeur est extraite du champ de journal brut "Vlan-Id".
- read_only_udm.metadata.event_type Logique : si "SIP" ou "hostname" sont présents et que "Proto" est présent, définissez la valeur sur "NETWORK_CONNECTION". Sinon, si "SIP", "hostname" ou "syslog_host" sont présents, définissez la valeur sur "STATUS_UPDATE". Sinon, définissez-le sur "GENERIC_EVENT".
- read_only_udm.metadata.log_type Logique : définissez la valeur sur "CISCO_ACI".
- read_only_udm.metadata.vendor_name Logique : défini sur "Cisco".
- read_only_udm.metadata.product_name Logique : définissez la valeur sur "ACI".

Vous avez encore besoin d'aide ? Obtenez des réponses de membres de la communauté et de professionnels Google SecOps.