Configurar e gerenciar pipelines de tratamento de dados

Compatível com:

O recurso Processamento de dados oferece um controle robusto de pré-análise sobre a ingestão de dados do Google Security Operations. É possível filtrar eventos, transformar campos ou encobrir valores sensíveis para otimizar a compatibilidade de dados, reduzir custos e proteger informações sensíveis no Google SecOps.

Este documento orienta você em todo o fluxo de trabalho de ingestão e processamento de dados usando o console do Bindplane. Assim, você pode aprender a:

  • Configure a conexão com uma instância de destino do Google SecOps.
  • Crie um pipeline do Google SecOps.
  • Configurar o tratamento de dados, incluindo streams e processadores.
  • Implante o pipeline para iniciar a ingestão e o processamento de dados.
  • Monitore fluxos e processadores de pipeline no console do Google SecOps.

É possível configurar o processamento de fluxos de dados locais e na nuvem usando o console de gerenciamento do Bindplane ou diretamente com as APIs públicas do pipeline de dados do Google SecOps.

O tratamento de dados consiste nos seguintes elementos:

  • Streams: um ou mais streams alimentam dados no pipeline de processamento de dados. Cada stream é configurada para um tipo específico.
  • Nó do processador: o processamento de dados tem um nó do processador que contém um ou mais processadores. Cada processador especifica uma ação a ser realizada nos dados (por exemplo, filtrar, transformar e encobrir) à medida que eles fluem pelo pipeline.
  • Destino: a instância de destino do Google SecOps é onde os dados processados são enviados.

Casos de uso

Como exemplos de casos de uso, temos:

  • Remover pares de chave-valor vazios dos registros brutos.
  • Editar dados confidenciais
  • Adicione rótulos de ingestão do conteúdo bruto do registro.
  • Em ambientes de várias instâncias, aplique rótulos de ingestão aos dados de registros de ingestão direta para identificar a instância do fluxo de origem (comoGoogle Cloud Workspace).
  • Filtre dados do Palo Alto Cortex por valores de campo.
  • Reduza os dados do SentinelOne por categoria.
  • Extraia informações do host de feeds e registros de ingestão direta e mapeie-as para o campo ingestion_source do Cloud Monitoring.

Pré-requisitos

Se você pretende usar o console do Bindplane para gerenciar o processamento de dados do Google SecOps, siga estas etapas:

  1. No console do Google Security Operations, conceda ao instalador as funções de administrador predefinidas necessárias. Para mais detalhes, consulte Atribuir a função de administrador do IAM do projeto em um projeto dedicado.

  2. Em Atribuir papéis, selecione os seguintes papéis predefinidos do Identity and Access Management:

    • Administrador da API Chronicle (roles/chronicle.admin)

  3. Instale o console do servidor do BindPlane. Para SaaS ou no local, consulte Instalar o console do servidor Bindplane.

  4. No console do Bindplane, conecte uma instância de destino do Google SecOps ao seu projeto do Bindplane. Para mais detalhes, consulte Conectar-se a uma instância do Google SecOps.

Gerenciar atrasos no reconhecimento de dados de SecOps de baixo volume

Os usuários da API de ingestão que configuram o próprio agente podem ter um aumento no tempo de confirmação dos pipelines de SecOps de baixo volume no pipeline de processamento de dados.

As médias de latência podem aumentar de 700 ms para até 2 segundos. Aumente os períodos de tempo limite e a memória conforme necessário. O tempo de confirmação diminui quando a capacidade de processamento de dados excede 4 MB.

Conectar a uma instância do Google SecOps

Antes de começar, confirme se você tem permissões de administrador do projeto do Bindplane para acessar a página Integrações do projeto.

A instância do Google SecOps serve como destino para a saída de dados.

Para se conectar a uma instância do Google SecOps usando o console do Bindplane, faça o seguinte:

  1. No console do Bindplane, acesse a página Gerenciar seu projeto.
  2. Acesse o card Integrações e clique em Conectar ao Google SecOps para abrir a janela Editar integração.

  3. Insira os detalhes da instância de destino do Google SecOps.
    Essa instância ingere os dados processados (saída do seu processamento de dados) da seguinte maneira:

    Campo Descrição
    Região Região da sua instância do Google SecOps.
    Para encontrar a instância no console doGoogle Cloud , acesse Segurança > Detecções e controles > Google Security Operations > Detalhes da instância.
    ID do cliente ID do cliente da sua instância do Google SecOps.

    No console do Google SecOps, acesse Configurações do SIEM > Perfil > Detalhes da organização.
    Google Cloud número do projeto Google Cloud Número do projeto da sua instância do Google SecOps.

    Para encontrar o número do projeto no console do Google SecOps, acesse Configurações do SIEM > Perfil > Detalhes da organização.
    Credenciais As credenciais da conta de serviço são o valor JSON necessário para autenticar e acessar as APIs do Google SecOps Data Pipeline. Extraia esse valor JSON do arquivo de credencial da conta de serviço do Google.

    A conta de serviço precisa estar localizada no mesmo projeto Google Cloud da sua instância do Google SecOps e exige privilégios de administrador da API Chronicle (roles/chronicle.admin).

    Para informações sobre como criar uma conta de serviço e fazer o download do arquivo JSON, consulte Criar e excluir chaves de conta de serviço.

  4. Clique em Conectar. Se os detalhes da conexão estiverem corretos e você se conectar ao Google SecOps, espere o seguinte:

    • Uma conexão com a instância do Google SecOps será aberta.
    • Na primeira vez que você se conecta, os Pipelines do SecOps aparecem no console do Bindplane.
    • O console do Bindplane mostra todos os dados processados que você configurou anteriormente para essa instância usando a API. O sistema converte alguns processadores que você configurou usando a API em processadores do Bindplane e mostra outros no formato bruto da linguagem de transformação do OpenTelemetry (OTTL). É possível usar o console do Bindplane para editar pipelines e processadores configurados anteriormente com a API.

  5. Depois de criar uma conexão com uma instância do Google SecOps, é possível criar um pipeline do SecOps e configurar o processamento de dados usando o console do Bindplane.

Configurar o processamento de dados usando o console do Bindplane

Com o console do Bindplane, é possível gerenciar os dados processados do Google SecOps, incluindo a configuração de pipelines usando a API.

Antes de começar

Antes de começar, recomendamos que você leia estas recomendações importantes:

  • Os streams baseados em push que chamam a API Backstory estão descontinuados e não oferecem mais suporte ao processamento de dados. Migre suas integrações para usar a API Chronicle Ingestion.
  • Para instalar o console do Bindplane pela primeira vez ou conectar uma instância de destino do Google SecOps ao seu projeto do Bindplane, consulte Pré-requisitos.
  • Como alternativa ao uso do console do Bindplane, você pode chamar as APIs do Google SecOps diretamente para configurar e gerenciar o tratamento de dados. Para mais detalhes, consulte Usar as APIs do pipeline de dados do Google SecOps.
  • Os dados ingeridos de encaminhadores e do Bindplane são marcados com um collectorID distinto dos fluxos de ingestão direta. Para oferecer suporte à visibilidade completa do registro, selecione todos os métodos de ingestão ao consultar fontes de dados ou faça referência explícita ao collectorID relevante ao interagir com a API.

Siga estas etapas para provisionar e implantar um novo pipeline de processamento de registros no Google SecOps, geralmente usando o console do Bindplane:

  1. Crie um pipeline de SecOps.
  2. Configurar o processamento de dados.
    1. Configure fluxos.
    2. Configurar processadores.
  3. Implante um pipeline de processamento de dados.

Criar um pipeline do Google SecOps

Um pipeline do Google SecOps é um contêiner para você configurar um contêiner de processamento de dados. Para criar um novo contêiner de pipeline do Google SecOps, faça o seguinte:

  1. No console do Bindplane, clique na guia Pipelines do SecOps para abrir a página Pipelines do SecOps.
  2. Clique em Criar pipeline de SecOps.
  3. Na janela Criar novo pipeline do SecOps, defina o Tipo de pipeline do SecOps como Google SecOps (padrão).

  4. Insira um Nome do pipeline do SecOps e uma Descrição.

  5. Clique em Criar. O novo contêiner de pipeline aparece na página Pipelines do SecOps.

  6. Configure os fluxos e processadores do contêiner de processamento de dados.

Configurar um contêiner de tratamento de dados

Um contêiner de tratamento de dados especifica streams de dados para ingestão e processadores (por exemplo, filtrar, transformar ou encobrir) para manipular os dados à medida que eles fluem para a instância de destino do Google SecOps.

Um card de configuração de pipeline é uma visualização do pipeline de processamento de dados em que é possível configurar os streams de dados e o nó do processador:

  • Um fluxo ingere dados de acordo com as especificações configuradas e os envia para o contêiner. Um contêiner de processamento de dados pode ter um ou mais fluxos, cada um configurado para um fluxo diferente.
  • O nó de processador consiste em processadores que manipulam os dados à medida que eles fluem para a instância de destino do Google SecOps.

Para configurar um contêiner de processamento de dados, faça o seguinte:

  1. Crie um pipeline de SecOps.
  2. No console do Bindplane, clique na guia Pipelines do SecOps para abrir a página Pipelines do SecOps.
  3. Selecione o pipeline de SecOps em que você quer configurar o novo contêiner de tratamento de dados.

  4. No card de configuração Pipeline:

    1. Adicionar um fluxo.
    2. Configure o nó de processador. Para adicionar um processador usando o console do Bindplane, consulte Configurar processadores para mais detalhes.

  5. Depois que essas configurações forem concluídas, consulte Implantar o processamento de dados para começar a processar os dados.

Adicionar um stream

Para adicionar um stream, faça o seguinte:

  1. No card de configuração Pipeline, clique em adicionar Adicionar stream para abrir a janela Criar stream.

  2. Na janela Criar stream de SecOps, insira detalhes para estes campos:

    Campo Descrição
    Tipo de registro Selecione o tipo de registro dos dados a serem ingeridos. Por exemplo, CrowdStrike Falcon (CS_EDR).
    Observação: um ícone de aviso indica que o tipo de registro já está configurado em outro fluxo (neste ou em outro pipeline na sua instância do Google SecOps).

    Para usar um tipo de registro indisponível, primeiro exclua-o da outra configuração de stream.

    Para instruções sobre como encontrar a configuração de fluxo em que o tipo de registro está configurado, consulte Filtrar configurações do pipeline de SecOps.
    Método de ingestão Selecione o método de ingestão que será usado para ingerir os dados do tipo de registro selecionado. Esses métodos de ingestão foram definidos anteriormente para sua instância do Google SecOps.

    Selecione uma das seguintes opções:

    • Todos os métodos de ingestão: inclui todos os métodos de ingestão para o tipo de registro selecionado. Ao selecionar essa opção, você não poderá adicionar streams subsequentes que usam métodos de ingestão específicos para o mesmo tipo de registro. Exceção: é possível selecionar outros métodos de ingestão específicos não configurados para esse tipo de registro em outros fluxos.
    • Método de ingestão específico, como Cloud Native Ingestion, Feed, Ingestion API ou Workspace.
    Feed Se você selecionar Feed como o método de ingestão, um campo vai aparecer com uma lista de nomes de feeds disponíveis (pré-configurados na sua instância do Google SecOps) para o tipo de registro selecionado. Selecione o feed relevante para concluir a configuração. Para ver e gerenciar seus feeds disponíveis, acesse Configurações do SIEM > Tabela de feeds.

  3. Clique em Adicionar transmissão para salvar a nova transmissão de dados, que vai aparecer imediatamente no card de configuração Pipeline. O fluxo é conectado automaticamente ao nó do processador e ao Destino do Google SecOps.

Filtrar configurações de pipeline do SecOps

A barra de pesquisa na página Pipelines do SecOps permite filtrar e localizar seus pipelines do SecOps (contêineres de processamento de dados) com base em vários elementos de configuração. É possível filtrar pipelines pesquisando critérios específicos, como tipo de registro, método de ingestão ou nome do feed.

Use a seguinte sintaxe para filtrar:

  • logtype:value
  • ingestionmethod:value
  • feed:value

Por exemplo, para identificar configurações de stream que contêm um tipo de registro específico, digite logtype: na barra de pesquisa e selecione o tipo de registro na lista resultante.

Configurar processadores

Um contêiner de tratamento de dados tem um nó de processador, que contém um ou mais processadores. Cada processador manipula os dados de fluxo de forma sequencial:

  1. O primeiro processador processa os dados brutos de stream.
  2. A saída resultante do primeiro processador se torna imediatamente a entrada para o próximo processador na sequência.
  3. Essa sequência continua para todos os processadores subsequentes, na ordem exata em que aparecem no painel Processadores, com a saída de um se tornando a entrada do próximo.

A tabela a seguir lista os processadores:

Tipo de processador Capacidade
Filtro Filtrar por condição
Filtro Filtrar por status HTTP
Filtro Filtrar por nome da métrica
Filtro Filtrar por regex
Filtro Filtrar por gravidade
Encobrimento Editar dados confidenciais
Transformar Adicionar campos
Transformar Coalesce
Transformar Concat
Transformar Copiar campo
Transformar Excluir campos
Transformar Marshal
Transformar Mover campo
Transformar Analisar CSV
Transformar Analisar JSON
Transformar Analisar valor-chave
Transformar Analisar campos de gravidade
Transformar Analisar carimbo de data/hora
Transformar Analisar com regex
Transformar Analisar XML
Transformar renomear campos;
Transformar Reescrever carimbo de data/hora
Transformar Divisão
Transformar Transformar
  1. Configure o nó do processador adicionando, removendo ou mudando a sequência de um ou mais processadores.

Adicionar um processador

Para adicionar um processador, siga estas etapas:

  1. No card de configuração Pipeline, clique no nó Processador para abrir a janela Editar processadores. A janela Editar processadores é dividida nestes painéis, organizados por fluxo de dados:

    • Entrada (ou dados de origem): dados de registro de stream recentes (antes do processamento)
    • Configuração (ou lista de processadores): processadores e configurações deles.
    • Saída (ou resultados): dados de registro de resultados recentes (após o processamento)

    Se o pipeline já tiver sido lançado, o sistema vai mostrar os dados de registro de entrada recentes (antes do processamento) e os dados de registro de saída recentes (após o processamento) nos painéis.

  2. Clique em Adicionar processador para mostrar a lista de processadores. Para sua conveniência, a lista de processadores é agrupada por tipo. Para organizar a lista e adicionar seus próprios pacotes, selecione um ou mais processadores e clique em Adicionar novos pacotes de processadores.

  3. Na lista de processadores, selecione um Processador para adicionar.

  4. Configure o processador conforme necessário.

  5. Clique em Salvar para salvar a configuração do processador no nó Processador.

O sistema testa imediatamente a nova configuração processando uma nova amostra dos dados de fluxo de entrada (no painel Entrada) e mostra os dados de saída resultantes no painel Saída.

Implantar um pipeline de tratamento de dados

Depois que as configurações de stream e processador forem concluídas, implante o pipeline para começar a processar os dados da seguinte maneira:

  1. Clique em Iniciar lançamento. Isso ativa imediatamente o tratamento de dados e permite que a infraestrutura segura do Google comece a processar os dados de acordo com sua configuração.

  2. Se o lançamento for bem-sucedido, o número da versão do contêiner de tratamento de dados será incrementado e exibido ao lado do nome do contêiner.

Ver detalhes do tratamento de dados no console do Google SecOps

As seções a seguir descrevem como visualizar detalhes do processamento de dados no console do Google SecOps:

Ver todas as configurações de tratamento de dados

  1. No console do Google SecOps, acesse Configurações do SIEM > Tratamento de dados, onde é possível conferir todos os pipelines configurados.
  2. Na barra de pesquisa Pipelines de dados de entrada, procure qualquer pipeline que você criou. É possível pesquisar por elementos, como nome do pipeline ou componentes. Os resultados da pesquisa mostram os processadores do pipeline e um resumo da configuração.
  3. No resumo do pipeline, você pode realizar qualquer uma das seguintes ações:
    • Revise as configurações do processador.
    • Copie os detalhes da configuração.
    • Clique em Abrir no Bindplane para acessar e gerenciar o pipeline diretamente no console do Bindplane.

Ver feeds configurados

Para ver os feeds configurados no seu sistema, faça o seguinte:

  1. No console do Google SecOps, acesse Configurações do SIEM > Feeds. A página Feeds mostra todos os feeds que você configurou no sistema.
  2. Mantenha o ponteiro sobre cada linha para mostrar o menu ⋮ Mais, onde é possível ver detalhes, editar, desativar ou excluir o feed.
  3. Clique em Ver detalhes para abrir a janela de detalhes.
  4. Clique em Abrir no Bindplane para abrir a configuração de stream desse feed no console do Bindplane.

Conferir detalhes do tratamento de dados (tipos de registros disponíveis)

Para conferir detalhes do tratamento de dados na página Tipos de registros disponíveis, onde você pode ver todos os tipos de registros disponíveis, faça o seguinte:

  1. No console do Google SecOps, acesse Configurações do SIEM > Tipos de registros disponíveis. A página principal mostra todos os tipos de registros.
  2. Mantenha o ponteiro sobre cada linha do feed para mostrar o menu more_vert Mais. Nesse menu, é possível ver, editar, desativar ou excluir detalhes do feed.
  3. Clique em Ver processamento de dados para conferir a configuração do feed.
  4. Clique em Abrir no Bindplane para abrir a configuração do processador no console do Bindplane.

Usar métodos de pipeline de dados do Google SecOps

Os métodos de pipeline de dados do Google SecOps oferecem ferramentas abrangentes para gerenciar seus dados processados. Esses métodos incluem criar, atualizar, excluir e listar pipelines, além de associar feeds e tipos de registros a eles.

Casos de uso

Esta seção contém exemplos de casos de uso típicos relacionados a métodos de pipeline de dados.

Para usar os exemplos nesta seção, faça o seguinte:

  • Substitua os parâmetros específicos do cliente (por exemplo, URLs e IDs de feed) por parâmetros adequados ao seu ambiente.
  • Insira sua própria autenticação. Nesta seção, os tokens de autenticação são omitidos com ******.

Listar todos os pipelines em uma instância específica do Google SecOps

O comando a seguir lista todos os pipelines que existem em uma instância específica do Google SecOps:

curl --location 'https://abc.def.googleapis.com/v123/projects/projectabc-byop/locations/us/instances/aaaa1aa1-111a-11a1-1111-11111a1aa1aa/logProcessingPipelines' \
--header 'Authorization: Bearer ******'

Criar um pipeline básico com um processador

Para criar um pipeline básico com o processador de transformação e associar três fontes a ele, faça o seguinte:

  1. Execute este comando:

    curl --location 'https://abc.def.googleapis.com/v123/projects/projectabc-byop/locations/us/instances/aaaa1aa1-111a-11a1-1111-11111a1aa1aa/logProcessingPipelines' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer ******' \
--data '{
    "displayName": "Example Pipeline",
    "description": "My description",
    "processors": [
        {
            "transformProcessor": {
                "statements": [
                    "set(attributes[\"myKey1\"], \"myVal1\")",
                    "set(attributes[\"myKey2\"], \"myVal2\")"
                ]
            }
        }
    ]
}'

  2. Na resposta, copie o valor do campo displayName.

  3. Execute o comando a seguir para associar três fluxos (tipo de registro, tipo de registro com ID do coletor e feed) ao pipeline. Use o valor do campo displayName como o valor de {pipelineName}.

    curl --location 'https://abc.def.googleapis.com/v123/{pipelineName}:associateStreams' \
    --header 'Content-Type: application/json' \
--header 'Authorization: Bearer ******' \
--data '{
    "streams": [
        {
            "logType": "MICROSOFT_SENTINEL"
        },
        {
            "logType": "A10_LOAD_BALANCER",
            "collectorId": "dddddddd-dddd-dddd-dddd-dddddddddddd"
        },
        {
            "feed": "1a1a1a1a-1a1a-1a1a-1a1a-1a1a1a1a1a1a"
        }
    ]
}'

Criar um pipeline com três processadores

O pipeline usa os seguintes processadores:

  • Transformar: transforma e analisa o corpo do registro como JSON.
  • Filtro: filtra os registros que correspondem a uma condição com base no corpo analisado.
  • Encobrimento: encobre dados que correspondem aos valores sensíveis predefinidos do Bindplane.

Para criar um pipeline e associar três fontes a ele, faça o seguinte:

  1. Execute este comando:

    curl --location 'https://abc.def.googleapis.com/v123/projects/projectabc-byop/locations/us/instances/aaaa1aa1-111a-11a1-1111-11111a1aa1aa/logProcessingPipelines' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer ******' \
--data-raw '{
    "displayName": "My Pipeline 2",
    "description": "My description 2",
    "processors": [
        {
            "transformProcessor": {
                "statements": [
                    "merge_maps(\n  body,\n  ParseJSON(\n    body\n  ),\n  \"upsert\"\n) where IsMap(body) and true\n",
                    "set(\n  body,\n  ParseJSON(\n    body\n  )\n) where not IsMap(body) and true\n"
                ],
                "errorMode": "IGNORE"
            }
        },
        {
            "filterProcessor": {
                "logConditions": [
                    "true and severity_number != 0 and severity_number < 9"
                ]
            }
        },
        {
            "redactProcessor": {
                "blockedValues": [
                    "\\b[A-Z]{2}\\d{2}(?: ?[A-Z0-9]){11,31}(?:\\s[A-Z0-9])*\\b",
                    "\\b([0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}\\b",
                    "\\b(?:(?:(?:\\d{4}[- ]?){3}\\d{4}|\\d{15,16}))\\b",
                    "\\b(?:(?:19|20)?\\d{2}[-/])?(?:0?[1-9]|1[0-2])[-/](?:0?[1-9]|[12]\\d|3[01])(?:[-/](?:19|20)?\\d{2})?\\b",
                    "\\b[a-zA-Z0-9._/\\+\\-—|]+@[A-Za-z0-9\\-—|]+\\.[a-zA-Z|]{2,6}\\b",
                    "\\b(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\\b",
                    "\\b(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\\b",
                    "\\b((\\+|\\b)[1l][\\-\\. ])?\\(?\\b[\\dOlZSB]{3,5}([\\-\\. ]|\\) ?)[\\dOlZSB]{3}[\\-\\. ][\\dOlZSB]{4}\\b",
                    "\\+[1-9]\\d{0,2}(?:[-.\\s]?\\(?\\d+\\)?(?:[-.\\s]?\\d+)*)\\b",
                    "\\b\\d{3}[- ]\\d{2}[- ]\\d{4}\\b",
                    "\\b[A-Z][A-Za-z\\s\\.]+,\\s{0,1}[A-Z]{2}\\b",
                    "\\b\\d+\\s[A-z]+\\s[A-z]+(\\s[A-z]+)?\\s*\\d*\\b",
                    "\\b\\d{5}(?:[-\\s]\\d{4})?\\b",
                    "\\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}\\b"
                ],
                "allowAllKeys": true,
                "allowedKeys": [
                    "__bindplane_id__"
                ],
                "ignoredKeys": [
                    "__bindplane_id__"
                ],
                "redactAllTypes": true
            }
        }
    ]
}'

  2. Na resposta, copie o valor do campo displayName.

  3. Execute o comando a seguir para associar três fluxos (tipo de registro, tipo de registro com ID do coletor e feed) ao pipeline. Use o valor do campo displayName como o valor de {pipelineName}. 

    curl --location 'https://abc.def.googleapis.com/v123/{pipelineName}:associateStreams' \
    --header 'Content-Type: application/json' \
--header 'Authorization: Bearer ******' \
--data '{
    "streams": [
        {
            "logType": "MICROSOFT_SENTINEL"
        },
        {
            "logType": "A10_LOAD_BALANCER",
            "collectorId": "dddddddd-dddd-dddd-dddd-dddddddddddd"
        },
        {
            "feed": "1a1a1a1a-1a1a-1a1a-1a1a-1a1a1a1a1a1a"
        }
    ]
}'

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