Coletar registros do Cisco Catalyst SD-WAN Manager

Versão do analisador: 7.0

Compatível com:

Google SecOps SIEM

Neste documento, explicamos como ingerir registros do Cisco Catalyst SD-WAN Manager (antigo vManage) no Google Security Operations usando o Google Cloud Storage. O Cisco Catalyst SD-WAN Manager é um sistema centralizado de gerenciamento de rede que oferece visibilidade e controle sobre a estrutura da SD-WAN, permitindo que os administradores monitorem o desempenho da rede, configurem políticas e gerenciem a segurança em redes corporativas distribuídas.

Antes de começar

Verifique se você atende aos seguintes pré-requisitos:

• Uma instância do Google SecOps
• Um projeto do GCP com a API Cloud Storage ativada
• Permissões para criar e gerenciar buckets do GCS
• Permissões para gerenciar políticas do IAM em buckets do GCS
• Permissões para criar serviços do Cloud Run, tópicos do Pub/Sub e jobs do Cloud Scheduler
• Acesso privilegiado ao console de gerenciamento do Cisco Catalyst SD-WAN Manager
• Conta de usuário do Cisco Catalyst SD-WAN Manager com permissões de acesso à API

Criar um bucket do Google Cloud Storage

1. Acesse o Console do Google Cloud.
2. Selecione seu projeto ou crie um novo.
3. No menu de navegação, acesse Cloud Storage > Buckets.
4. Clique em Criar bucket.

5. Informe os seguintes detalhes de configuração:

   Configuração	Valor
   Nomeie seu bucket	Insira um nome globalmente exclusivo (por exemplo, cisco-sdwan-logs-bucket)
   Tipo de local	Escolha de acordo com suas necessidades (região, birregional, multirregional)
   Local	Selecione o local (por exemplo, us-central1).
   Classe de armazenamento	Padrão (recomendado para registros acessados com frequência)
   Controle de acesso	Uniforme (recomendado)
   Ferramentas de proteção	Opcional: ativar o controle de versões de objetos ou a política de retenção

6. Clique em Criar.

Coletar credenciais da API Cisco Catalyst SD-WAN Manager

Criar conta de usuário da API

1. Faça login no console do Cisco Catalyst SD-WAN Manager.
2. No menu, acesse Administração > Gerenciar usuários.
3. Clique em Adicionar usuário.
4. Informe os seguintes detalhes de configuração:
   • Nome de usuário: digite um nome de usuário para o acesso à API (por exemplo, chronicle-api).
   • Senha: digite uma senha forte.
   • Confirmar senha: digite a senha novamente.
   • Grupo de usuários: selecione um grupo de usuários com as permissões adequadas (consulte a próxima seção).
5. Clique em Adicionar.

6. Copie e salve em um local seguro os seguintes detalhes:

   • Nome de usuário: seu nome de usuário do Catalyst SD-WAN Manager.
   • Senha: sua senha do Catalyst SD-WAN Manager.
   • URL de base do Catalyst SD-WAN Manager: o URL de base do servidor do Catalyst SD-WAN Manager (por exemplo, https://sdwan-manager.example.com:8443).
   Observação: essas credenciais serão usadas pela função do Cloud Run para autenticação na API Cisco Catalyst SD-WAN Manager.

Configurar permissões do usuário

A conta de usuário da API requer permissões específicas para acessar registros de auditoria, alarmes e eventos.

1. No console do Cisco Catalyst SD-WAN Manager, no menu, acesse Administration > Manage Users > User Groups.
2. Selecione o grupo de usuários atribuído ao usuário da API ou clique em Add User Group para criar um novo grupo.
3. Clique em Editar.
4. Na seção Recurso, verifique se as seguintes permissões estão ativadas:
   • Registro de auditoria: selecione a permissão Leitura.
   • Alarmes: selecione a permissão Ler.
   • Eventos: selecione a permissão Ler.
5. Clique em Atualizar.

Verificar o acesso à API

Teste suas credenciais antes de prosseguir com a integração:

1. Abra um terminal ou prompt de comando.

2. Execute o seguinte comando para testar a autenticação:

   # 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"
   

Se a autenticação for bem-sucedida, o segundo comando vai retornar uma string de token CSRF.

Observação: em ambientes de produção, configure certificados TLS válidos no Catalyst SD-WAN Manager e verifique os certificados no cliente HTTP. Os exemplos de código usam a verificação de certificado desativada apenas para fins de teste.

Criar uma conta de serviço para a função do Cloud Run

A função do Cloud Run precisa de uma conta de serviço com permissões para gravar no bucket do GCS e ser invocada pelo Pub/Sub.

Criar conta de serviço

1. No Console do GCP, acesse IAM e administrador > Contas de serviço.
2. Clique em Criar conta de serviço.
3. Informe os seguintes detalhes de configuração:
   • Nome da conta de serviço: insira cisco-sdwan-collector-sa.
   • Descrição da conta de serviço: insira Service account for Cloud Run function to collect Cisco Catalyst SD-WAN Manager logs.
4. Clique em Criar e continuar.
5. Na seção Conceder acesso a essa conta de serviço ao projeto, adicione os seguintes papéis:
   1. Clique em Selecionar papel.
   2. Pesquise e selecione Administrador de objetos do Storage.
   3. Clique em + Adicionar outro papel.
   4. Pesquise e selecione Invocador do Cloud Run.
   5. Clique em + Adicionar outro papel.
   6. Pesquise e selecione Invocador do Cloud Functions.
6. Clique em Continuar.
7. Clique em Concluído.

Esses papéis são necessários para:

• Administrador de objetos do Storage: gravar registros no bucket do GCS e gerenciar arquivos de estado
• Invocador do Cloud Run: permite que o Pub/Sub invoque a função.
• Invocador do Cloud Functions: permite a invocação de funções.

Conceder permissões do IAM no bucket do GCS

Conceda à conta de serviço permissões de gravação no bucket do GCS:

1. Acesse Cloud Storage > Buckets.
2. Clique no nome do seu bucket.
3. Acesse a guia Permissões.
4. Clique em Conceder acesso.
5. Informe os seguintes detalhes de configuração:
   • Adicionar participantes: insira o e-mail da conta de serviço (por exemplo, cisco-sdwan-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
   • Atribuir papéis: selecione Administrador de objetos do Storage.
6. Clique em Salvar.

Criar tópico Pub/Sub

Crie um tópico do Pub/Sub em que o Cloud Scheduler vai publicar e a função do Cloud Run vai se inscrever.

1. No Console do GCP, acesse Pub/Sub > Tópicos.
2. Selecione Criar tópico.
3. Informe os seguintes detalhes de configuração:
   • ID do tópico: insira cisco-sdwan-trigger.
   • Não mude as outras configurações.
4. Clique em Criar.

Criar uma função do Cloud Run para coletar registros

A função do Cloud Run será acionada por mensagens do Pub/Sub do Cloud Scheduler para buscar registros da API Cisco Catalyst SD-WAN Manager e gravá-los no GCS.

1. No Console do GCP, acesse o Cloud Run.
2. Clique em Criar serviço.
3. Selecione Função (use um editor in-line para criar uma função).

4. Na seção Configurar, forneça os seguintes detalhes de configuração:

   Configuração	Valor
   Nome do serviço	cisco-sdwan-log-collector
   Região	Selecione a região correspondente ao bucket do GCS (por exemplo, us-central1).
   Ambiente de execução	Selecione Python 3.12 ou mais recente.

5. Na seção Acionador (opcional):

   1. Clique em + Adicionar gatilho.
   2. Selecione Cloud Pub/Sub.
   3. Em Selecionar um tópico do Cloud Pub/Sub, escolha o tópico (cisco-sdwan-trigger).
   4. Clique em Salvar.

6. Na seção Autenticação:

   1. Selecione Exigir autenticação.
   2. Verifique o Identity and Access Management (IAM).
   Observação: o Pub/Sub processa automaticamente a autenticação ao invocar a função.

7. Role para baixo e abra Contêineres, rede, segurança.

8. Acesse a guia Segurança:

   • Conta de serviço: selecione a conta de serviço (cisco-sdwan-collector-sa).

9. Acesse a guia Contêineres:

   1. Clique em Variáveis e secrets.
   2. Clique em + Adicionar variável para cada variável de ambiente:

   Nome da variável	Valor de exemplo
   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. Role para baixo na guia Variáveis e secrets até Solicitações:

    • Tempo limite da solicitação: insira 600 segundos (10 minutos).

11. Acesse a guia Configurações em Contêineres:

    • Na seção Recursos:
      • Memória: selecione 512 MiB ou mais.
      • CPU: selecione 1.

12. Na seção Escalonamento de revisão:

    • Número mínimo de instâncias: insira 0.
    • Número máximo de instâncias: insira 100 (ou ajuste com base na carga esperada).

13. Clique em Criar.

14. Aguarde a criação do serviço (1 a 2 minutos).

15. Depois que o serviço for criado, o editor de código inline será aberto automaticamente.

Adicionar código da função

1. Insira main no campo Ponto de entrada.

2. No editor de código inline, crie dois arquivos:

   • 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
     

   Observação: este script é fornecido como exemplo e não tem suporte oficial. Seu feedback é muito importante para aprimorarmos o produto. Para enviar feedback, clique em Enviar feedback > Feedback sobre o produto de segurança do Google SecOps nesta página.

3. Clique em Implantar para salvar e implantar a função.

4. Aguarde a conclusão da implantação (2 a 3 minutos).

   Observação: a configuração do gatilho do Pub/Sub cria automaticamente as assinaturas e permissões necessárias.

Criar o job do Cloud Scheduler

O Cloud Scheduler vai publicar mensagens no tópico do Pub/Sub em intervalos regulares, acionando a função do Cloud Run.

1. No Console do GCP, acesse o Cloud Scheduler.
2. Clique em Criar job.

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

   Configuração	Valor
   Nome	cisco-sdwan-log-collector-hourly
   Região	Selecione a mesma região da função do Cloud Run
   Frequência	0 * * * * (de hora em hora)
   Fuso horário	Selecione o fuso horário (UTC recomendado)
   Tipo de destino	Pub/Sub
   Tópico	Selecione o tópico (cisco-sdwan-trigger)
   Corpo da mensagem	{} (objeto JSON vazio)

4. Clique em Criar.

Opções de frequência de programação

Escolha a frequência com base no volume de registros e nos requisitos de latência:

Frequência	Expressão Cron	Caso de uso
A cada 5 minutos	*/5 * * * *	Alto volume e baixa latência
A cada 15 minutos	*/15 * * * *	Volume médio
A cada hora	0 * * * *	Padrão (recomendado)
A cada 6 horas	0 */6 * * *	Processamento em lote de baixo volume
Diário	0 0 * * *	Coleta de dados históricos

Testar a integração

1. No console do Cloud Scheduler, encontre seu job.
2. Clique em Forçar execução para acionar o job manualmente.
3. Aguarde alguns segundos.
4. Acesse Cloud Run > Serviços.
5. Clique no nome da função (cisco-sdwan-log-collector).
6. Clique na guia Registros.

7. Verifique se a função foi executada com sucesso. Procure por:

   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. Acesse Cloud Storage > Buckets.

9. Clique no nome do seu bucket.

10. Navegue até a pasta de prefixo (cisco-sdwan/).

11. Verifique se os novos arquivos .ndjson foram criados com o carimbo de data/hora atual.

Se você encontrar erros nos registros:

• HTTP 401: verifique as credenciais da API nas variáveis de ambiente.
• HTTP 403: verifique se a conta de usuário tem as permissões de leitura necessárias para o registro de auditoria, os alarmes e os eventos.
• Falha na autenticação: verifique se o URL de base do Catalyst SD-WAN Manager inclui a porta correta (padrão 8443).
• Variáveis de ambiente ausentes: verifique se todas as variáveis necessárias estão definidas.

Configurar um feed no Google SecOps para ingerir registros do Cisco Catalyst SD-WAN Manager

1. Acesse Configurações > Gerenciamento de dados > Feeds. Se você estiver em uma plataforma somente SIEM, acesse Configurações > Feeds.
2. Clique em Adicionar novo feed.
3. Clique em Configurar um único feed.
4. No campo Nome do feed, insira um nome para o feed (por exemplo, Cisco Catalyst SD-WAN Manager logs).
5. Selecione Google Cloud Storage V2 como o Tipo de origem.
6. Selecione Cisco SD-WAN como o Tipo de registro.

7. Clique em Get Service Account. Um e-mail exclusivo da conta de serviço será exibido, por exemplo:

   [e-mail]
   

8. Copie esse endereço de e-mail para usar na próxima etapa.

   Observação: cada instância do Google SecOps tem uma conta de serviço exclusiva. Não use contas de serviço de outras documentações ou exemplos.

9. Clique em Próxima.

10. Especifique valores para os seguintes parâmetros de entrada:

    • URL do bucket de armazenamento: insira o URI do bucket do GCS com o caminho do prefixo:

      gs://cisco-sdwan-logs-bucket/cisco-sdwan/
      

      • Substitua:
        • cisco-sdwan-logs-bucket: o nome do bucket do GCS.
        • cisco-sdwan/: prefixo/caminho de pasta opcional em que os registros são armazenados (deixe em branco para a raiz).
    Observação: sempre inclua a barra (/) no final do URI.

    • Opção de exclusão da fonte: selecione a opção de exclusão de acordo com sua preferência:

      • Nunca: nunca exclui arquivos após as transferências (recomendado para testes).
      • Excluir arquivos transferidos: exclui arquivos após a transferência.
      • Excluir arquivos transferidos e diretórios vazios: exclui arquivos e diretórios vazios após a transferência.
      Observação: se você selecionar uma opção de exclusão, a conta de serviço precisará ter o papel de Administrador de objetos do Storage em vez de Leitor de objetos do Storage. Atualize as permissões do IAM de acordo.

    • Idade máxima do arquivo: inclua arquivos modificados nos últimos dias (o padrão é 180 dias).

    • Namespace do recurso: o namespace do recurso.

    • Rótulos de ingestão: o rótulo a ser aplicado aos eventos desse feed.

11. Clique em Próxima.

12. Revise a configuração do novo feed na tela Finalizar e clique em Enviar.

Conceder permissões do IAM à conta de serviço do Google SecOps

A conta de serviço do Google SecOps precisa do papel Leitor de objetos do Storage no bucket do GCS.

1. Acesse Cloud Storage > Buckets.
2. Clique no nome do seu bucket.
3. Acesse a guia Permissões.
4. Clique em Conceder acesso.
5. Informe os seguintes detalhes de configuração:
   • Adicionar principais: cole o e-mail da conta de serviço do Google SecOps.
   • Atribuir papéis: selecione Leitor de objetos do Storage.

6. Clique em Salvar.

   Observação: se você planeja usar a opção de exclusão "Excluir arquivos transferidos" ou "Excluir arquivos transferidos e diretórios vazios", conceda o papel de Administrador de objetos do Storage em vez de Leitor de objetos do Storage.

Tabela de mapeamento de UDM

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

Registro de alterações

Confira o registro de alterações deste analisador

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