Coletar registros do Nagios XI

Compatível com:

Este documento explica como ingerir registros do Nagios XI no Google Security Operations usando o Google Cloud Storage V2.

O Nagios XI é uma solução abrangente de monitoramento de infraestrutura que monitora servidores, redes, aplicativos e serviços. Ele rastreia o status do host e do serviço, as métricas de performance e gera alertas para problemas de infraestrutura de TI usando a API REST.

Antes de começar

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

  • Uma instância do Google SecOps
  • Um projeto do GCP com as APIs Cloud Storage, Cloud Run, Pub/Sub e API Cloud Scheduler ativadas
  • 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 Nagios XI com permissões de gerenciamento de usuários
  • Nagios XI versão 5 ou mais recente (suporte à API REST)

Configurar o acesso à API do Nagios XI

Para permitir que o Google SecOps recupere dados de monitoramento, crie uma conta de usuário com acesso à API e permissões somente leitura.

Criar um usuário com acesso somente leitura à API

  1. Faça login na interface da Web do Nagios XI com privilégios de administrador.
  2. Acesse Admin > Manage Users.
  3. Clique em Adicionar novo usuário.
  4. Informe os seguintes detalhes de configuração:
    • Nome de usuário: insira um nome descritivo (por exemplo, chronicle-integration).
    • Senha: digite uma senha segura.
    • Nome: insira Chronicle Integration User.
    • Endereço de e-mail: insira um endereço de e-mail válido.
  5. Na seção Configurações de segurança, configure o seguinte:
    • Nível de autorização: selecione Usuário.
    • Pode ver todos os hosts e serviços: marque esta opção.
    • Acesso somente leitura: marque esta opção.
    • Acesso à API: marque esta opção.
  6. Desmarque as seguintes opções:
    • Forçar alteração de senha no próximo login
    • Enviar informações da conta de usuário por e-mail
    • Criar como contato de monitoramento
  7. Verifique se a opção Conta ativada está marcada.
  8. Clique em Adicionar usuário.

Recuperar a chave de API

  1. Na página Gerenciar usuários, clique na conta de usuário (chronicle-integration).
  2. Na página de configurações da conta de usuário, localize o campo Chave de API.
  3. Copie o valor da chave de API.

Verifique as permissões

Para verificar se a conta tem as permissões necessárias:

  1. Faça login no Nagios XI com a conta de usuário chronicle-integration.
  2. Acesse Início > Status do host.
  3. Se você conseguir ver todos os hosts e serviços monitorados, isso significa que tem as permissões necessárias.
  4. Se você não conseguir ver hosts ou serviços, entre em contato com o administrador para receber a permissão Pode ver todos os hosts e serviços.

Testar o acesso à API

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

    # Replace with your actual values
    NAGIOS_HOST="https://your-nagios-server.example.com"
    API_KEY="your-api-key"
    
    # Test API access - query host status
    curl -k "${NAGIOS_HOST}/nagiosxi/api/v1/objects/hoststatus?apikey=${API_KEY}&pretty=1"
    

    Uma resposta bem-sucedida retorna um objeto JSON com informações de status do host.

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, nagios-xi-logs)
    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.

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

  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 nagios-logs-collector-sa.
    • Descrição da conta de serviço: insira Service account for Cloud Run function to collect Nagios XI 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.

Conceder permissões do IAM no bucket do GCS

  1. Acesse Cloud Storage > Buckets.
  2. Clique no nome do bucket (nagios-xi-logs).
  3. Acesse a guia Permissões.
  4. Clique em Conceder acesso.
  5. Informe os seguintes detalhes de configuração:
    • Adicionar principais: insira o e-mail da conta de serviço (nagios-logs-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

  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 nagios-logs-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 REST do Nagios XI 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 nagios-logs-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 nagios-logs-trigger.
    4. Clique em Salvar.
  6. Na seção Autenticação:

    1. Selecione Exigir autenticação.
    2. Verifique o Identity and Access Management (IAM).
  7. Role para baixo e abra Contêineres, rede, segurança.

  8. Acesse a guia Segurança:

    • Conta de serviço: selecione nagios-logs-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 Descrição
    GCS_BUCKET nagios-xi-logs Nome do bucket do GCS
    GCS_PREFIX nagios-xi Prefixo para arquivos de registro
    STATE_KEY nagios-xi/state.json Caminho do arquivo de estado
    NAGIOS_BASE_URL https://your-nagios-server.example.com URL de base do Nagios XI
    NAGIOS_API_KEY your-api-key Chave de API do Nagios XI
    MAX_RECORDS 1000 Máximo de registros por endpoint por execução
    PAGE_SIZE 200 Registros por página da API
    LOOKBACK_HOURS 24 Período de lookback inicial
  10. Na seção Variáveis e secrets, role para baixo até Solicitações:

    • Tempo limite da solicitação: insira 600 segundos (10 minutos)
  11. Acesse a guia Configurações:

    • 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.
  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
      from datetime import datetime, timezone, timedelta
      import time
      
      http = urllib3.PoolManager(
        timeout=urllib3.Timeout(connect=5.0, read=30.0),
        retries=False,
      )
      
      storage_client = storage.Client()
      
      GCS_BUCKET = os.environ.get('GCS_BUCKET')
      GCS_PREFIX = os.environ.get('GCS_PREFIX', 'nagios-xi')
      STATE_KEY = os.environ.get('STATE_KEY', 'nagios-xi/state.json')
      NAGIOS_BASE_URL = os.environ.get('NAGIOS_BASE_URL', '').rstrip('/')
      NAGIOS_API_KEY = os.environ.get('NAGIOS_API_KEY')
      MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '1000'))
      PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '200'))
      LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))
      
      ENDPOINTS = [
        'hoststatus',
        'servicestatus',
        'statehistory',
        'logentries',
      ]
      
      @functions_framework.cloud_event
      def main(cloud_event):
        if not all([GCS_BUCKET, NAGIOS_BASE_URL, NAGIOS_API_KEY]):
          print('Error: Missing required environment variables')
          return
      
        try:
          bucket = storage_client.bucket(GCS_BUCKET)
          state = load_state(bucket)
          now = datetime.now(timezone.utc)
      
          if isinstance(state, dict) and state.get('last_event_time'):
            try:
              last_val = state['last_event_time']
              if last_val.endswith('Z'):
                last_val = last_val[:-1] + '+00:00'
              last_time = datetime.fromisoformat(last_val)
              last_time = last_time - timedelta(minutes=2)
            except Exception as e:
              print(f"Warning: Could not parse last_event_time: {e}")
              last_time = now - timedelta(hours=LOOKBACK_HOURS)
          else:
            last_time = now - timedelta(hours=LOOKBACK_HOURS)
      
          print(f"Fetching logs from {last_time.isoformat()} to {now.isoformat()}")
      
          start_ts = int(last_time.timestamp())
          end_ts = int(now.timestamp())
      
          all_records = []
          newest_time = None
      
          for endpoint in ENDPOINTS:
            records, endpoint_newest = fetch_nagios_endpoint(
              endpoint, start_ts, end_ts
            )
            for record in records:
              record['_nagios_endpoint'] = endpoint
            all_records.extend(records)
      
            if endpoint_newest:
              if newest_time is None or endpoint_newest > newest_time:
                newest_time = endpoint_newest
      
          if not all_records:
            print("No new records found.")
            save_state(bucket, now.isoformat())
            return
      
          timestamp = now.strftime('%Y%m%d_%H%M%S')
          object_key = f"{GCS_PREFIX}/nagios_logs_{timestamp}.ndjson"
          blob = bucket.blob(object_key)
      
          ndjson = '\n'.join(
            [json.dumps(r, ensure_ascii=False, default=str) for r in all_records]
          ) + '\n'
          blob.upload_from_string(ndjson, content_type='application/x-ndjson')
      
          print(f"Wrote {len(all_records)} records to gs://{GCS_BUCKET}/{object_key}")
      
          if newest_time:
            save_state(bucket, newest_time)
          else:
            save_state(bucket, now.isoformat())
      
          print(f"Successfully processed {len(all_records)} records")
      
        except Exception as e:
          print(f'Error processing logs: {str(e)}')
          raise
      
      def fetch_nagios_endpoint(endpoint, start_ts, end_ts):
        base_url = f"{NAGIOS_BASE_URL}/nagiosxi/api/v1/objects/{endpoint}"
      
        records = []
        newest_time = None
        start_index = 0
        page_num = 0
        backoff = 1.0
      
        while True:
          page_num += 1
      
          if len(records) >= MAX_RECORDS:
            print(f"{endpoint}: Reached max_records limit ({MAX_RECORDS})")
            break
      
          remaining = min(PAGE_SIZE, MAX_RECORDS - len(records))
          params = [
            f"apikey={NAGIOS_API_KEY}",
            f"starttime={start_ts}",
            f"endtime={end_ts}",
            f"records={remaining}",
            f"start={start_index}",
          ]
          url = f"{base_url}?{'&'.join(params)}"
      
          try:
            response = http.request('GET', url)
      
            if response.status == 429:
              retry_after = int(response.headers.get('Retry-After', str(int(backoff))))
              print(f"{endpoint}: Rate limited (429). Retrying after {retry_after}s...")
              time.sleep(retry_after)
              backoff = min(backoff * 2, 30.0)
              continue
      
            backoff = 1.0
      
            if response.status != 200:
              print(f"{endpoint}: HTTP Error {response.status}")
              response_text = response.data.decode('utf-8')
              print(f"Response body: {response_text}")
              break
      
            data = json.loads(response.data.decode('utf-8'))
      
            record_count = data.get('recordcount', 0)
            result_key = get_result_key(endpoint)
            page_results = data.get(result_key, [])
      
            if not page_results:
              print(f"{endpoint}: No more results at offset {start_index}")
              break
      
            print(f"{endpoint} page {page_num}: Retrieved {len(page_results)} events")
            records.extend(page_results)
      
            for event in page_results:
              try:
                event_time = event.get('state_time') or event.get('status_update_time') or event.get('entry_time')
                if event_time:
                  if newest_time is None or event_time > newest_time:
                    newest_time = event_time
              except Exception as e:
                print(f"Warning: Could not parse event time: {e}")
      
            if len(page_results) < remaining:
              print(f"{endpoint}: Reached last page (returned {len(page_results)} < {remaining})")
              break
      
            start_index += len(page_results)
      
          except Exception as e:
            print(f"{endpoint}: Error fetching logs: {e}")
            break
      
        print(f"{endpoint}: Retrieved {len(records)} total records from {page_num} pages")
        return records, newest_time
      
      def get_result_key(endpoint):
        key_map = {
          'hoststatus': 'hoststatus',
          'servicestatus': 'servicestatus',
          'statehistory': 'statehistory',
          'logentries': 'logentry',
        }
        return key_map.get(endpoint, endpoint)
      
      def load_state(bucket):
        try:
          blob = bucket.blob(STATE_KEY)
          if blob.exists():
            return json.loads(blob.download_as_text())
        except Exception as e:
          print(f"Warning: Could not load state: {e}")
        return {}
      
      def save_state(bucket, last_event_time_iso):
        try:
          state = {
            'last_event_time': last_event_time_iso,
            'last_run': datetime.now(timezone.utc).isoformat()
          }
          blob = bucket.blob(STATE_KEY)
          blob.upload_from_string(
            json.dumps(state, indent=2),
            content_type='application/json'
          )
          print(f"Saved state: last_event_time={last_event_time_iso}")
        except Exception as e:
          print(f"Warning: Could not save state: {e}")
      
    • requirements.txt:

      functions-framework==3.*
      google-cloud-storage==2.*
      urllib3>=2.0.0
      
  3. Clique em Implantar para salvar e implantar a função.

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

Criar o job do Cloud Scheduler

  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 nagios-logs-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 Selecionar nagios-logs-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 (nagios-logs-collector-hourly).
  2. Clique em Forçar execução para acionar o job manualmente.
  3. Aguarde alguns segundos.
  4. Acesse Cloud Run > Serviços.
  5. Clique em nagios-logs-collector.
  6. Clique na guia Registros.
  7. Verifique se a função foi executada com sucesso. Procure por:

    Fetching logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
    hoststatus page 1: Retrieved X events
    servicestatus page 1: Retrieved X events
    statehistory page 1: Retrieved X events
    logentries page 1: Retrieved X events
    Wrote X records to gs://nagios-xi-logs/nagios-xi/nagios_logs_YYYYMMDD_HHMMSS.ndjson
    Successfully processed X records
    
  8. Acesse Cloud Storage > Buckets.

  9. Clique em nagios-xi-logs.

  10. Navegue até a pasta nagios-xi/.

  11. Verifique se um novo arquivo .ndjson foi criado com o carimbo de data/hora atual.

Se você encontrar erros nos registros:

  • HTTP 401: verifique se a variável de ambiente NAGIOS_API_KEY está correta e se o usuário tem o acesso à API ativado.
  • HTTP 403: verifique se a conta de usuário tem a permissão Pode ver todos os hosts e serviços.
  • HTTP 429: limitação de taxa. A função vai tentar novamente de forma automática com espera.
  • Variáveis de ambiente ausentes: verifique se todas as variáveis necessárias estão definidas na configuração da função do Cloud Run.

Recuperar a conta de serviço do Google SecOps

  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, Nagios XI Logs GCS).
  5. Selecione Google Cloud Storage V2 como o Tipo de origem.
  6. Selecione Nagios como o Tipo de registro.
  7. Clique em Get Service Account.
  8. Um e-mail exclusivo da conta de serviço é exibido. Exemplo:

    chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com
    
  9. Copie esse endereço de e-mail para usar na próxima etapa.

  10. Clique em Próxima.

  11. 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://nagios-xi-logs/nagios-xi/
      
    • 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.

    • 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 que será aplicado aos eventos desse feed.

  12. Clique em Próxima.

  13. Revise a configuração do novo feed de notícias na tela Finalizar e clique em Enviar.

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

  1. Acesse Cloud Storage > Buckets.
  2. Clique em nagios-xi-logs.
  3. Acesse a guia Permissões.
  4. Clique em Conceder acesso.
  5. Informe os seguintes detalhes de configuração:
    • Adicionar participantes: 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.

Tabela de mapeamento de UDM

Campo de registro Mapeamento de UDM Lógica
src_ip has_principal Defina como "true" se a mesclagem de src_ip com principal.ip e principal.asset.ip for bem-sucedida
src_ip principal.asset.ip Valor copiado diretamente
src_ip principal.ip Valor copiado diretamente
jobid jobid_label.key Defina como "Jobid"
jobid jobid_label.value Valor copiado diretamente
jobid_label principal.resource.attribute.labels Mesclado de jobid_label
pid principal.process.pid Valor copiado diretamente
ent metadata.product_event_type Valor copiado diretamente
descrição metadata.description Valor copiado diretamente
msg_ip has_target Defina como "true" se a mesclagem de msg_ip com target.ip e target.asset.ip for bem-sucedida.
msg_ip target.asset.ip Valor copiado diretamente
msg_ip target.ip Valor copiado diretamente
porta target.port Valor copiado diretamente e convertido em número inteiro
column1 principal.asset.hostname Valor da coluna 1 se ent == "SERVICE ALERT", caso contrário, da coluna 2 se ent == "SERVICE NOTIFICATION"
column1 principal.hostname Valor da coluna 1 se ent == "SERVICE ALERT", caso contrário, da coluna 2 se ent == "SERVICE NOTIFICATION"
column1 principal.user.user_display_name Valor copiado diretamente se ent == "SERVICE NOTIFICATION"
column2 security_result.summary Valor da coluna 3 se ent == "SERVICE ALERT" e a coluna 2 não estiver vazia. Caso contrário, valor da coluna 3 se ent == "SERVICE NOTIFICATION"
column3 security_result.summary Valor da coluna 3 se ent == "SERVICE ALERT" e a coluna 3 não estiver vazia. Caso contrário, valor da coluna 3 se ent == "SERVICE NOTIFICATION"
column4 security_result.severity Valor copiado diretamente se column4 estiver em ["LOW", "MEDIUM", "HIGH", "CRITICAL"] e ent estiver em ["SERVICE NOTIFICATION", "SERVICE ALERT"]
column4 security_result.severity_details Valor copiado diretamente se column4 não estiver em ["LOW", "MEDIUM", "HIGH", "CRITICAL"] e ent estiver em ["SERVICE NOTIFICATION", "SERVICE ALERT"]
has_principal metadata.event_type Defina como "NETWORK_CONNECTION" se has_principal e has_target forem verdadeiros, "STATUS_UPDATE" se has_principal for verdadeiro, "USER_UNCATEGORIZED" se has_principal_user for verdadeiro ou "GENERIC_EVENT"
has_target metadata.event_type
has_principal_user metadata.event_type
security_result event.idm.read_only_udm.security_result Mesclado de security_result
metadados event.idm.read_only_udm.metadata Renomeado de metadados
destino event.idm.read_only_udm.target Renomeado do destino
participante event.idm.read_only_udm.principal Renomeado do principal
rede event.idm.read_only_udm.network Renomeado da rede
metadata.product_name metadata.product_name Defina como "NAGIOS"
metadata.vendor_name metadata.vendor_name Defina como "NAGIOS"

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.