Recolha registos da infraestrutura centrada na aplicação (ACI) da Cisco

Suportado em:

Google secops SIEM

Nota: esta funcionalidade está abrangida pelos Termos das Ofertas de Pré-DG dos Termos Específicos do serviço Google Security Operations. As funcionalidades de pré-DG podem ter suporte limitado e as alterações às funcionalidades de pré-DG podem não ser compatíveis com outras versões de pré-DG. Para mais informações, consulte as diretrizes dos serviços de apoio técnico do Google SecOps e os Termos Específicos dos Serviços do Google SecOps.

Este documento explica como ingerir registos da infraestrutura centrada em aplicações (ACI) da Cisco no Google Security Operations. O analisador tenta primeiro processar os registos do Cisco ACI como mensagens syslog através de padrões Grok. Se a análise do syslog falhar, assume que a mensagem está no formato JSON e analisa-a em conformidade. Por último, mapeia os campos extraídos para o modelo de dados unificado (UDM).

Esta integração suporta dois métodos:

• Opção 1: formato Syslog através do agente Bindplane
• Opção 2: formato JSON através do AWS S3 com a API REST APIC

Cada opção é autónoma e pode ser implementada de forma independente com base nos seus requisitos de infraestrutura e preferências de formato de registo.

Opção 1: Syslog através do agente Bindplane

Esta opção configura a estrutura do Cisco ACI para enviar mensagens syslog a um agente do Bindplane, que as encaminha para o Chronicle para análise.

Antes de começar

Certifique-se de que cumpre os seguintes pré-requisitos:

• Uma instância do Google SecOps
• Um anfitrião Windows 2016 ou posterior, ou Linux com systemd
• Se estiver a ser executado através de um proxy, certifique-se de que as portas da firewall estão abertas de acordo com os requisitos do agente Bindplane
• Acesso privilegiado à consola do Cisco APIC

Obtenha o ficheiro de autenticação de carregamento do Google SecOps

1. Inicie sessão na consola Google SecOps.
2. Aceda a Definições do SIEM > Agentes de recolha.
3. Transfira o ficheiro de autenticação de carregamento. Guarde o ficheiro de forma segura no sistema onde o Bindplane vai ser instalado.

Obtenha o ID de cliente do Google SecOps

1. Inicie sessão na consola Google SecOps.
2. Aceda a Definições do SIEM > Perfil.
3. Copie e guarde o ID do cliente da secção Detalhes da organização.

Instale o agente do Bindplane

Instale o agente do Bindplane no seu sistema operativo Windows ou Linux de acordo com as seguintes instruções.

Instalação de janelas

1. Abra a Linha de comandos ou o PowerShell como administrador.

2. Execute o seguinte comando:

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

Instalação do Linux

1. Abra um terminal com privilégios de raiz ou sudo.

2. Execute o seguinte comando:

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

Recursos de instalação adicionais

• Para ver opções de instalação adicionais, consulte este guia de instalação.

Configure o agente Bindplane para carregar o Syslog e enviá-lo para o Google SecOps

1. Aceda ao ficheiro de configuração:

   1. Localize o ficheiro config.yaml. Normalmente, encontra-se no diretório /etc/bindplane-agent/ no Linux ou no diretório de instalação no Windows.
   2. Abra o ficheiro com um editor de texto (por exemplo, nano, vi ou Bloco de notas).

2. Edite o ficheiro config.yaml da seguinte forma:

   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
   

   • Substitua a porta e o endereço IP conforme necessário na sua infraestrutura.
   • Substitua <customer_id> pelo ID de cliente real.
   • Atualize /path/to/ingestion-authentication-file.json para o caminho onde o ficheiro de autenticação foi guardado na secção Obtenha o ficheiro de autenticação de carregamento do Google SecOps.

Reinicie o agente do Bindplane para aplicar as alterações

• Para reiniciar o agente do Bindplane no Linux, execute o seguinte comando:

  sudo systemctl restart bindplane-agent
  

• Para reiniciar o agente Bindplane no Windows, pode usar a consola Serviços ou introduzir o seguinte comando:

  net stop BindPlaneAgent && net start BindPlaneAgent
  

Configure o encaminhamento de Syslog no Cisco ACI

Configure o contrato de gestão fora da banda

1. Inicie sessão na consola Cisco APIC.
2. Aceda a Inquilinos > gestão > Contratos > Filtros.
3. Clique em Criar filtro.
4. Forneça os seguintes detalhes de configuração:
   • Nome: introduza syslog-udp-514.
   • Nome da entrada: introduza syslog.
   • EtherType: selecione IP.
   • Protocolo IP: selecione UDP.
   • Intervalo de portas de destino de: introduza 514.
   • Intervalo de portas de destino até: introduza 514.
5. Clique em Enviar.

Crie um contrato de gestão

1. Aceda a Inquilinos > gestão > Contratos > Padrão.
2. Clique em Criar contrato.
3. Forneça os seguintes detalhes de configuração:
   • Nome: introduza mgmt-syslog-contract.
   • Âmbito: selecione Contexto.
4. Clique em Enviar.
5. Expanda o contrato e clique em Assuntos.
6. Clique em Criar assunto do contrato.
7. Forneça os seguintes detalhes de configuração:
   • Nome: introduza syslog-subject.
   • Aplicar ambas as direções: selecione esta opção.
8. Clique em Enviar.
9. Expanda o assunto e clique em Filtros.
10. Clique em Criar associação de filtros.
11. Selecione o filtro syslog-udp-514 criado anteriormente.
12. Clique em Enviar.

Configure o grupo de destino do Syslog

1. Aceda a Administração > Coletor de dados externos > Destinos de monitorização > Syslog.
2. Clique com o botão direito do rato em Syslog e selecione Criar grupo de destino de monitorização do Syslog.
3. Forneça os seguintes detalhes de configuração:
   • Nome: introduza Chronicle-Syslog-Group.
   • Estado de administrador: selecione Ativado.
   • Formato: selecione aci.
4. Clicar em Seguinte.
5. Na caixa de diálogo Criar destino de monitorização Syslog:
   • Nome: introduza Chronicle-BindPlane.
   • Anfitrião: introduza o endereço IP do servidor do agente Bindplane.
   • Porta: introduza 514.
   • Estado de administrador: selecione Ativado.
   • Gravidade: selecione informações (para capturar registos detalhados).
6. Clique em Enviar.

Configure políticas de monitorização

Política de Monitorização de Tecidos

1. Aceda a Fabric > Políticas do Fabric > Políticas > Monitorização > Política comum.
2. Expanda Callhome/Smart Callhome/SNMP/Syslog/TACACS.
3. Clique com o botão direito do rato em Syslog e selecione Criar origem Syslog.
4. Forneça os seguintes detalhes de configuração:
   • Nome: introduza Chronicle-Fabric-Syslog.
   • Registos de auditoria: selecione esta opção para incluir eventos de auditoria.
   • Eventos: selecione para incluir eventos do sistema.
   • Falhas: selecione para incluir eventos de falhas.
   • Registos de sessões: selecione esta opção para incluir registos de sessões.
   • Grupo de destinos: selecione Chronicle-Syslog-Group.
5. Clique em Enviar.

Política de Monitorização de Acessos

1. Aceda a Fabric > Políticas de acesso > Políticas > Monitorização > Política predefinida.
2. Expanda Callhome/Smart Callhome/SNMP/Syslog.
3. Clique com o botão direito do rato em Syslog e selecione Criar origem Syslog.
4. Forneça os seguintes detalhes de configuração:
   • Nome: introduza Chronicle-Access-Syslog.
   • Registos de auditoria: selecione esta opção para incluir eventos de auditoria.
   • Eventos: selecione para incluir eventos do sistema.
   • Falhas: selecione para incluir eventos de falhas.
   • Registos de sessões: selecione esta opção para incluir registos de sessões.
   • Grupo de destinos: selecione Chronicle-Syslog-Group.
5. Clique em Enviar.

Configure a política de mensagens Syslog do sistema

1. Aceda a Fabric > Políticas do Fabric > Políticas > Monitorização > Política comum.
2. Expanda Políticas de mensagens Syslog.
3. Clique em predefinição.
4. Na secção Filtro de instalações:
   • Instalação: selecione predefinição.
   • Gravidade mínima: altere para informação.
5. Clique em Enviar.

Opção 2: JSON através do AWS S3

Esta opção usa a API REST APIC para recolher eventos, falhas e registos de auditoria formatados em JSON do tecido Cisco ACI e armazená-los no AWS S3 para carregamento do SecOps.

Antes de começar

• Instância do Google SecOps.
• Acesso privilegiado à consola Cisco APIC.
• Acesso privilegiado à AWS (S3, IAM, Lambda e EventBridge).

Recolha os pré-requisitos do Cisco ACI APIC (IDs, chaves da API, IDs da organização, tokens)

1. Inicie sessão na consola Cisco APIC através de HTTPS.
2. Aceda a Admin > AAA (no APIC 6.0 ou superior) ou Admin > Authentication > AAA (em versões mais antigas).
   • Nota: o caminho do menu AAA foi alterado a partir do APIC 6.0(1).
3. Crie ou use um utilizador local existente com os privilégios adequados.
4. Copie e guarde numa localização segura os seguintes detalhes:
   • Nome de utilizador da APIC: utilizador local com acesso de leitura aos dados de monitorização
   • Palavra-passe da APIC: palavra-passe do utilizador
   • URL do APIC: o URL HTTPS do seu APIC (por exemplo, https://apic.example.com)

Configure o contentor do AWS S3 e o IAM para o Google SecOps

1. Crie um contentor do Amazon S3 seguindo este manual do utilizador: Criar um contentor.
2. Guarde o nome e a região do contentor para referência futura (por exemplo, cisco-aci-logs).
3. Crie um utilizador seguindo este guia do utilizador: criar um utilizador do IAM.
4. Selecione o utilizador criado.
5. Selecione o separador Credenciais de segurança.
6. Clique em Criar chave de acesso na secção Chaves de acesso.
7. Selecione Serviço de terceiros como Exemplo de utilização.
8. Clicar em Seguinte.
9. Opcional: adicione uma etiqueta de descrição.
10. Clique em Criar chave de acesso.
11. Clique em Transferir ficheiro CSV para guardar a chave de acesso e a chave de acesso secreta para referência futura.
12. Clique em Concluído.
13. Selecione o separador Autorizações.
14. Clique em Adicionar autorizações na secção Políticas de autorizações.
15. Selecione Adicionar autorizações.
16. Selecione Anexar políticas diretamente.
17. Pesquise a política AmazonS3FullAccess.
18. Selecione a política.
19. Clicar em Seguinte.
20. Clique em Adicionar autorizações.

Configure a política e a função de IAM para carregamentos do S3

1. Na consola da AWS, aceda a IAM > Políticas.
2. Clique em Criar política > separador JSON.

3. Introduza a seguinte 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"
       }
     ]
   }
   

   • Substitua cisco-aci-logs se tiver introduzido um nome de contentor diferente.

4. Clique em Seguinte > Criar política.

5. Aceda a IAM > Funções > Criar função > Serviço AWS > Lambda.

6. Anexe a política recém-criada e a política gerida AWSLambdaBasicExecutionRole.

7. Dê o nome cisco-aci-lambda-role à função e clique em Criar função.

Crie a função Lambda

1. Na consola da AWS, aceda a Lambda > Functions > Create function.
2. Clique em Criar do zero.

3. Faculte os seguintes detalhes de configuração:

   • Nome: cisco-aci-events-collector
   • Tempo de execução: Python 3.13
   • Arquitetura: x86_64
   • Função de execução: cisco-aci-lambda-role

4. Depois de criar a função, abra o separador Código, elimine o fragmento de código e introduza o seguinte 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. Aceda a Configuração > Variáveis de ambiente.

6. Clique em Editar > Adicionar nova variável de ambiente.

7. Introduza as seguintes variáveis de ambiente fornecidas, substituindo-as pelos seus valores.

   • 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 o tamanho da paginação)
   • MAX_PAGES: 10 (opcional, limita o total de páginas obtidas por execução)

8. Depois de criar a função, permaneça na respetiva página (ou abra Lambda > Functions > cisco-aci-events-collector).

9. Selecione o separador Configuração.

10. No painel Configuração geral, clique em Editar.

11. Altere Tempo limite para 5 minutos (300 segundos) e clique em Guardar.

    Nota: o tempo limite é um limite superior rígido, o que significa que, se a função ainda estiver em execução quando o temporizador atingir 5 minutos, o AWS Lambda termina-a. Qualquer execução mais curta termina normalmente. Só lhe é cobrado o tempo de execução real.

Importante: se o seu APIC usar certificados autoassinados, pode ter de configurar a validação de certificados SSL. Considere usar o AWS Certificate Manager ou adicionar certificados de AC fidedignos ao seu ambiente Lambda.

Crie um horário do EventBridge

1. Aceda a Amazon EventBridge > Scheduler > Create schedule.
2. Forneça os seguintes detalhes de configuração:
   • Programação recorrente: Taxa (15 minutes).
   • Destino: a sua função Lambda cisco-aci-events-collector.
   • Nome: cisco-aci-events-collector-15m.
3. Clique em Criar horário.

Opcional: crie um utilizador e chaves da IAM só de leitura para o Google SecOps

1. Aceda a AWS Console > IAM > Users > Add users.
2. Clique em Adicionar utilizadores.
3. Forneça os seguintes detalhes de configuração:
   • Utilizador: introduza secops-reader.
   • Tipo de acesso: selecione Chave de acesso – Acesso programático.
4. Clique em Criar utilizador.
5. Anexe a política de leitura mínima (personalizada): Users > secops-reader > Permissions > Add permissions > Attach policies directly > Create policy.

6. No editor JSON, introduza a seguinte 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. Defina o nome como secops-reader-policy.

8. Aceda a Criar política > pesquise/selecione > Seguinte > Adicionar autorizações.

9. Aceda a Credenciais de segurança > Chaves de acesso > Criar chave de acesso.

10. Transfira o CSV (estes valores são introduzidos no feed).

Configure um feed no Google SecOps para carregar registos do Cisco ACI

1. Aceda a Definições do SIEM > Feeds.
2. Clique em + Adicionar novo feed.
3. No campo Nome do feed, introduza um nome para o feed (por exemplo, Cisco ACI JSON logs).
4. Selecione Amazon S3 V2 como o Tipo de origem.
5. Selecione Cisco Application Centric Infrastructure como o Tipo de registo.
6. Clicar em Seguinte.
7. Especifique valores para os seguintes parâmetros de entrada:
   • URI do S3: s3://cisco-aci-logs/cisco-aci-events/
   • Opções de eliminação de origens: selecione a opção de eliminação de acordo com a sua preferência.
   • Idade máxima do ficheiro: inclua ficheiros modificados no último número de dias. A predefinição é 180 dias.
   • ID da chave de acesso: chave de acesso do utilizador com acesso ao contentor do S3.
   • Chave de acesso secreta: chave secreta do utilizador com acesso ao contentor do S3.
   • Espaço de nomes do recurso: o espaço de nomes do recurso.
   • Etiquetas de carregamento: a etiqueta aplicada aos eventos deste feed.
8. Clicar em Seguinte.
9. Reveja a nova configuração do feed no ecrã Finalizar e, de seguida, clique em Enviar.

Tabela de mapeamento da UDM

Campo de registo	Mapeamento da UDM	Lógica
@timestamp	read_only_udm.metadata.event_timestamp	O valor é retirado do campo de registo não processado "@timestamp" e analisado como uma data/hora.
aci_tag	read_only_udm.metadata.product_log_id	O valor é retirado do campo de registo não processado "aci_tag".
cisco_timestamp	-	Não mapeado.
DIP	read_only_udm.target.ip	O valor é retirado do campo de registo não processado "DIP".
DPort	read_only_udm.target.port	O valor é retirado do campo de registo não processado "DPort" e convertido em número inteiro.
descrição	read_only_udm.security_result.description	O valor é retirado do campo de registo não processado "description".
fault_cause	read_only_udm.additional.fields.value.string_value	O valor é retirado do campo de registo não processado "fault_cause". A chave está definida como "Fault Cause" (Causa da falha).
hostname	read_only_udm.principal.hostname	O valor é retirado do campo de registo não processado "hostname".
lifecycle_state	read_only_udm.metadata.product_event_type	O valor é retirado do campo de registo não processado "lifecycle_state".
log.source.address	-	Não mapeado.
logstash.collect.host	-	Não mapeado.
logstash.collect.timestamp	read_only_udm.metadata.collected_timestamp	O valor é retirado do campo de registo não processado "logstash.collect.timestamp" e analisado como uma data/hora.
logstash.ingest.host	read_only_udm.intermediary.hostname	O valor é retirado do campo de registo não processado "logstash.ingest.host".
logstash.irm_environment	read_only_udm.additional.fields.value.string_value	O valor é retirado do campo de registo não processado "logstash.irm_environment". A chave está definida como "IRM_Environment".
logstash.irm_region	read_only_udm.additional.fields.value.string_value	O valor é retirado do campo de registo não processado "logstash.irm_region". A chave está definida como "IRM_Region".
logstash.irm_site	read_only_udm.additional.fields.value.string_value	O valor é retirado do campo de registo não processado "logstash.irm_site". A chave está definida como "IRM_Site".
logstash.process.host	read_only_udm.intermediary.hostname	O valor é retirado do campo de registo não processado "logstash.process.host".
mensagem	-	Não mapeado.
message_class	-	Não mapeado.
message_code	-	Não mapeado.
message_content	-	Não mapeado.
message_dn	-	Não mapeado.
message_type	read_only_udm.metadata.product_event_type	O valor é retirado do campo de registo não processado "message_type" após a remoção dos parênteses retos.
node_link	read_only_udm.principal.process.file.full_path	O valor é retirado do campo de registo não processado "node_link".
PktLen	read_only_udm.network.received_bytes	O valor é retirado do campo de registo não processado "PktLen" e convertido em número inteiro sem sinal.
programa	-	Não mapeado.
Proto	read_only_udm.network.ip_protocol	O valor é retirado do campo de registo não processado "Proto", convertido em número inteiro e mapeado para o nome do protocolo IP correspondente (por exemplo, 6 -> TCP).
SIP	read_only_udm.principal.ip	O valor é retirado do campo de registo não processado "SIP".
SPort	read_only_udm.principal.port	O valor é retirado do campo de registo não processado "SPort" e convertido em número inteiro.
syslog_facility	-	Não mapeado.
syslog_facility_code	-	Não mapeado.
syslog_host	read_only_udm.principal.ip, read_only_udm.observer.ip	O valor é retirado do campo de registo não processado "syslog_host".
syslog_prog	-	Não mapeado.
syslog_severity	read_only_udm.security_result.severity_details	O valor é retirado do campo de registo não processado "syslog_severity".
syslog_severity_code	read_only_udm.security_result.severity	O valor é retirado do campo de registo não processado "syslog_severity_code" e mapeado para o nível de gravidade correspondente: 5, 6, 7 -> INFORMATIONAL; 3, 4 -> MEDIUM; 0, 1, 2 -> HIGH.
syslog5424_pri	-	Não mapeado.
Vlan-Id	read_only_udm.principal.resource.id	O valor é retirado do campo de registo não processado "Vlan-Id".
-	read_only_udm.metadata.event_type	Lógica: se "SIP" ou "hostname" estiver presente e "Proto" estiver presente, defina como "NETWORK_CONNECTION". Caso contrário, se estiver presente "SIP", "hostname" ou "syslog_host", defina como "STATUS_UPDATE". Caso contrário, defina como "GENERIC_EVENT".
-	read_only_udm.metadata.log_type	Lógica: definido como "CISCO_ACI".
-	read_only_udm.metadata.vendor_name	Lógica: definido como "Cisco".
-	read_only_udm.metadata.product_name	Lógica: definido como "ACI".

Precisa de mais ajuda? Receba respostas de membros da comunidade e profissionais da Google SecOps.