Esta página foi traduzida pela API Cloud Translation.

Encaminhador do Google Security Operations para Windows no Docker

Neste documento, descrevemos como instalar e configurar o encaminhador do Google Security Operations para Windows no Docker.

Requisitos do sistema

Confira a seguir recomendações gerais. Para recomendações específicas para seu sistema, entre em contato com o suporte de Operações de segurança do Google.

Versão do Windows Server: o encaminhador das Operações de segurança do Google é compatível com o Microsoft Windows Server 2022.
RAM: 1,5 GB para cada tipo de registro coletado. Por exemplo, detecção e resposta de endpoint (EDR), DNS e DHCP são tipos de registro separados. Você precisaria de 4,5 GB de RAM para coletar dados para os três. Para uma lista de analisadores padrão e tipos de registro compatíveis, consulte analisadores padrão compatíveis.
CPU: duas CPUs são suficientes para lidar com menos de 10.000 eventos por segundo (EPS) em todos os tipos de dados. Se você espera enviar mais de 10.000 EPS, são necessárias de 4 a 6 CPUs.
Disco: 100 MB de espaço em disco são suficientes, independente da quantidade de dados processados pelo encaminhador das Operações de Segurança do Google. Você pode armazenar o disco em buffer adicionando os parâmetros write_to_disk_buffer_enabled e write_to_disk_dir_path ao arquivo de configuração.

Exemplo:
```
- <collector>:
     common:
         ...
         write_to_disk_buffer_enabled: true
         write_to_disk_dir_path: directory_path 
         ...
```

Intervalos de endereços IP do Google

Talvez seja necessário que o intervalo de endereços IP seja aberto ao definir uma configuração do encaminhador do Google Security Operations, como ao definir a configuração do seu firewall. O Google não pode fornecer uma lista específica de endereços IP. No entanto, você pode conseguir intervalos de endereços IP do Google.

Verificar a configuração do firewall

Se você tiver firewalls ou proxies autenticados entre o contêiner de encaminhador do Google Security Operations e a Internet, eles exigirão regras para permitir o acesso aos seguintes hosts do Google Cloud:

Tipo de conexão	Destino	Port
TCP	malachiteingestion-pa.googleapis.com	443
TCP	asia-northeast1-malachiteingestion-pa.googleapis.com	443
TCP	asia-south1-malachiteingestion-pa.googleapis.com	443
TCP	asia-southeast1-malachiteingestion-pa.googleapis.com	443
TCP	australia-southeast1-malachiteingestion-pa.googleapis.com	443
TCP	europe-malachiteingestion-pa.googleapis.com	443
TCP	europe-west2-malachiteingestion-pa.googleapis.com	443
TCP	europe-west3-malachiteingestion-pa.googleapis.com	443
TCP	europe-west6-malachiteingestion-pa.googleapis.com	443
TCP	europe-west12-malachiteingestion-pa.googleapis.com	443
TCP	me-central1-malachiteingestion-pa.googleapis.com	443
TCP	me-central2-malachiteingestion-pa.googleapis.com	443
TCP	me-west1-malachiteingestion-pa.googleapis.com	443
TCP	northamerica-northeast2-malachiteingestion-pa.googleapis.com	443
TCP	accounts.google.com	443
TCP	gcr.io	443
TCP	oauth2.googleapis.com	443
TCP	storage.googleapis.com	443

Verifique a conectividade de rede com o Google Cloud seguindo estas etapas:

Inicie o Windows PowerShell com privilégios de administrador (clique em Iniciar, digite PowerShell, clique com o botão direito do mouse em Windows PowerShell e clique em Executar como administrador).

Execute o comando a seguir.

C:\> test-netconnection <host> -port <port>

O comando retorna que TcpTestSucceeded é true.

Exemplo:

C:\> test-netconnection malachiteingestion-pa.googleapis.com -port 443
ComputerName     :  malachiteingestion-pa.googleapis.com
RemoteAddress    : 198.51.100.1
RemotePort       : 443
InterfaceAlias   : Ethernet
SourceAddress    : 203.0.113.1
TcpTestSucceeded : True

Instalar o Docker no Microsoft Windows

Nesta seção, descrevemos como instalar o Docker no Microsoft Windows usando a interface de linha de comando e o PowerShell.

Vantagens do encaminhador das Operações de segurança do Google usando um contêiner:

Melhor segurança por meio do isolamento:
- O ambiente e os requisitos do cliente não afetam o encaminhador de Operações de segurança do Google.
- O ambiente e os requisitos do encaminhador das Operações de segurança do Google não afetam o cliente.
- O mecanismo de distribuição de contêineres já existe e pode ser particular e separado para o Google Cloud e os clientes. Para saber mais, consulte Artifact Registry.

Conclua as etapas a seguir no Microsoft Windows Server Core 2022.

Ativar o recurso de contêiner do Microsoft Windows.
```
Install-WindowsFeature containers -Restart
```

Execute o seguinte comando no modo de administrador do PowerShell para instalar o Docker CE:

Invoke-WebRequest -UseBasicParsing "https://raw.githubusercontent.com/microsoft/Windows-Containers/Main/helpful_tools/Install-DockerCE/install-docker-ce.ps1" -o install-docker-ce.ps1

.\install-docker-ce.ps1

Execute o comando docker ps para testar a interface de linha de comando do Docker. Ele retorna uma lista de contêineres em execução. Se o comando não listar nenhum contêiner em execução, a instalação será bem-sucedida. Se o Docker não for instalado corretamente, um erro será exibido.

Para mais informações, consulte Começar: preparar janelas para contêineres.

Para implantações empresariais, instale o Mirantis Container Runtime, também conhecido como Docker EE.

Configurar o encaminhador de Operações de segurança do Google

Para configurar o encaminhador do Google Security Operations para Windows no Docker, consulte Gerenciar configurações do encaminhador usando a interface do Google Security Operations.

Ao configurar o encaminhador do Google Security Operations, verifique se todos os caminhos dele começam com o prefixo "c:".

Qualquer alteração feita no arquivo de configuração será aplicada automaticamente pelo encaminhador das Operações de Segurança do Google em até cinco minutos.

Para coletar dados de pacote usando o encaminhador de Operações de segurança do Google para Windows no Docker, consulte Coletar dados de pacotes.

Execute o encaminhador do Google Security Operations no contêiner do Docker

Se você estiver fazendo upgrade do encaminhador do Google Security Operations, comece limpando as execuções anteriores do Docker. No exemplo a seguir, o nome do contêiner do Docker é cfps.
```
docker stop cfps

docker rm cfps
```
Consiga a imagem mais recente do Docker no Google Cloud usando este comando pull do Docker.
```
docker pull gcr.io/chronicle-container/cf_production_stable_windows
```
Inicie o encaminhador das Operações de segurança do Google no contêiner do Docker.
```
docker run `
--detach `
--name cfps `
--restart=always `
--log-opt max-size=100m `
--log-opt max-file=10 `
-p 10514:10514 `
-v C:\config\:C:/opt/chronicle/external `
gcr.io/chronicle-container/cf_production_stable_windows
```
É possível adicionar várias portas usando várias opções ou vários intervalos. Por exemplo: -p 3001:3000 -p 2023:2022 ou -p 7000-8000:7000-8000

Observação: os números de porta fornecidos no exemplo de código são exemplos. Substitua os números de porta de acordo com seus requisitos.

Ver registros do encaminhador

Para visualizar os registros de encaminhador das Operações de segurança do Google, execute o seguinte comando:

  sudo docker logs cfps

Para ver o caminho do arquivo em que os registros são armazenados, execute o seguinte comando:

docker inspect --format='{{.LogPath}}' CONTAINER_NAME

Para visualizar os registros em execução em tempo real, execute o seguinte comando:

  sudo docker logs cfps -f

Para armazenar os registros em um arquivo, execute o seguinte comando:

  sudo docker logs cfps &> logs.txt

Desinstalar o encaminhador do Google Security Operations

Os comandos do Docker a seguir permitem interromper e desinstalar ou remover o encaminhador do Google Security Operations.

Este comando interrompe o contêiner do encaminhador do Google Security Operations:

  docker stop cfps

Este comando remove o contêiner do encaminhador do Google Security Operations:

  docker rm cfps

Fazer upgrade do encaminhador de Operações de segurança do Google

Como o encaminhador do Google Security Operations para Windows no Docker é constantemente atualizado usando um script de shell na imagem do Docker, não é necessário fornecer nenhum executável para isso.

Coleta de dados

As seções a seguir ajudam você a configurar o encaminhador do Google Security Operations para ingerir diferentes tipos de dados, que são encaminhados para a instância do Google Security Operations.

Não configure um valor maior que 1 MB para batch_n_bytes. Se você configurar um valor maior que 1 MB, ele será automaticamente redefinido para esse valor.

Coletar dados do Splunk

É possível configurar o encaminhador das Operações de segurança do Google para encaminhar seus dados do Splunk para as Operações de segurança do Google. O Google Cloud configura o encaminhador de Operações de segurança do Google com as seguintes informações para encaminhar seus dados do Splunk:

URL para a API REST do Splunk (por exemplo, https://10.0.113.15:8089).
Consultas Splunk para gerar dados para cada um dos tipos de dados necessários (por exemplo, index=dns).

FORWARDER_NAME.conf
output:
collectors:
  - splunk:
      common:
        enabled: true
        data_type: WINDOWS_DNS
        data_hint: "#fields ts      uid     id.orig_h       id.orig_p       id.resp_h         id.resp_p       proto   trans_id        query   qclass  qclass_name"
        batch_n_seconds: 10
        batch_n_bytes: 819200
      url: https://127.0.0.1:8089
      is_ignore_cert: true
      minimum_window_size: 10s
      maximum_window_size: 30s
      query_string: search index=* sourcetype=dns
      query_mode: realtime

Disponibilize as credenciais da sua conta do Splunk para o encaminhador de Operações de segurança do Google. Para fazer isso, crie um arquivo creds.txt.

Para usar um arquivo creds.txt:

Crie um arquivo local para suas credenciais do Splunk e nomeie-o como creds.txt.

Observação: verifique se as credenciais estão armazenadas com segurança. Não encaminhe suas credenciais do Splunk para o Google Cloud.
Insira seu nome de usuário na primeira linha e a senha na segunda linha:
```
cat creds.txt

myusername
mypassword
```
Para usar o encaminhador de Operações de segurança do Google para acessar uma instância do Splunk, copie o arquivo creds.txt para o diretório de configuração (o mesmo diretório em que se encontram os arquivos de configuração). Exemplo:
```
cp creds.txt c:/opt/chronicle/config/creds.txt
```
Verifique se o arquivo creds.txt está no local correto:
```
ls c:/opt/chronicle/config
```

Coletar dados de syslog

O encaminhador das Operações de segurança do Google pode funcionar como um servidor syslog. Você pode configurar qualquer dispositivo ou servidor compatível com o envio de dados de syslog em uma conexão TCP ou UDP para encaminhar os dados ao encaminhador de Operações de segurança do Google. É possível controlar os dados exatos que o dispositivo ou o servidor envia para o encaminhador de Operações de segurança do Google. O encaminhador de Operações de Segurança do Google poderá encaminhar os dados a esse serviço.

O arquivo de configuração FORWARDER_NAME.conf (fornecido pelo Google Cloud) especifica quais portas monitorar para cada tipo de dados encaminhados (por exemplo, porta 10514). Por padrão, o encaminhador de Operações de segurança do Google aceita conexões TCP e UDP.

Configurar rsyslog

Para configurar o rsyslog, você precisa especificar um destino para cada porta (por exemplo, cada tipo de dado). Consulte a documentação do sistema para saber a sintaxe correta. Os exemplos a seguir ilustram a configuração de destino "rsyslog":

Tráfego de registro TCP: dns.* @@192.168.0.12:10514
Tráfego de registro UDP: dns.* @192.168.0.12:10514

Ativar TLS para configurações syslog

É possível ativar o TLS para a conexão syslog com o encaminhador do Google Security Operations. No arquivo de configuração do encaminhador do Google Security Operations (FORWARDER_NAME.conf), especifique o local do seu certificado gerado e da chave de certificado, conforme mostrado no exemplo a seguir:

certificado	`c:/opt/chronicle/external/certs/client_generated_cert.pem`
certificate_key	`c:/opt/chronicle/external/certs/client_generated_cert.key`

Com base no exemplo mostrado, modifique o arquivo de configuração do encaminhador do Google Security Operations (FORWARDER_NAME.conf) da seguinte maneira:

  collectors:
- syslog:
    common:
      enabled: true
      data_type: WINDOWS_DNS
      data_hint:
      batch_n_seconds: 10
      batch_n_bytes: 1048576
    tcp_address: 0.0.0.0:10515
    tcp_buffer_size: 65536
    connection_timeout_sec: 60
    certificate: "c:/opt/chronicle/external/certs/client_generated_cert.pem"
    certificate_key: "c:/opt/chronicle/external/certs/client_generated_cert.key"
    minimum_tls_version: "TLSv1_3"

Alguns pontos importantes a serem observados:

É possível configurar o tamanho do buffer TCP. O tamanho padrão do buffer TCP é de 64 KB.
O valor padrão e recomendado para connection_timeout é de 60 segundos. Se a conexão ficar inativa por um tempo especificado, a conexão TCP será encerrada.
A versão de TLS mínima é verificada em relação à versão de TLS da solicitação de entrada. A versão de TLS da solicitação de entrada precisa ser posterior à versão mínima de TLS. A versão de TLS mínima precisa ser um dos seguintes valores: TLSv1_0, TLSv1_1, TLSv1_2, TLSv1_3.

É possível criar um diretório "certs" no diretório de configuração e armazenar os arquivos de certificado nele.

Coletar dados de arquivos

Um coletor de arquivos é projetado para buscar os registros de um arquivo. O arquivo precisa estar vinculado ao contêiner do Docker.

Use este método se você quiser fazer o upload manual dos registros de um único arquivo de registros. Isso pode ser usado para preencher os registros de um arquivo de registro específico.

Inicie o encaminhador do Google Security Operations pelo contêiner do Docker:

  docker run `
    --name cfps `
    --log-opt max-size=100m `
    --log-opt max-file=10 `
    -p 10514:10514 `
    -v c:/opt/chronicle/config:c:/opt/chronicle/external `
    -v c:/var/log/crowdstrike/falconhoseclient:c:/opt/chronicle/edr `
     gcr.io/chronicle-container/cf_production_stable

É possível adicionar várias portas usando várias opções ou vários intervalos. Por exemplo: -p 3001:3000 -p 2023:2022 ou -p 7000-8000:7000-8000

O comando docker run é fundamental para mapear o volume de carga para o contêiner.

Com base nesse exemplo, modifique a configuração do encaminhador do Google Security Operations (arquivo FORWARDER_NAME.conf) da seguinte maneira. O arquivo sample.txt precisa estar presente na pasta /var/log/crowdstrike/falconhostclient.

 collectors:
  - file:
       common:
         enabled: true
         data_type: CS_EDR
         data_hint:
         batch_n_seconds: 10
         batch_n_bytes: 1048576
       file_path: c:/opt/chronicle/edr/output/sample.txt
       filter:

Configurações de sinalização

skip_seek_to_end (bool): essa flag é definida como false por padrão, e a entrada do arquivo envia apenas novas linhas de registro como entrada. Definir como true faz com que todas as linhas de registro anteriores sejam enviadas novamente durante as reinicializações do encaminhador. Isso causa a duplicação de registros. Definir essa flag como true é útil em determinadas situações (por exemplo, durante interrupções), porque a reinicialização do encaminhador envia as linhas de registro ausentes novamente.

poll (bool): o coletor de arquivos usa a biblioteca Tail para verificar se há mudanças no sistema de arquivos. Ao definir essa flag como true, a biblioteca Tail usa o método de pesquisa em vez do método de notificação padrão.

Coletar dados do pacote

O encaminhador de Operações de segurança do Google pode capturar pacotes diretamente de uma interface de rede usando Npcap em sistemas Windows.

Os pacotes são capturados e enviados para o Google Cloud em vez das entradas de registro. A captura é feita somente a partir de uma interface local.

Entre em contato com o Suporte das Operações de segurança do Google para atualizar o arquivo de configuração do encaminhador das Operações de segurança do Google para oferecer suporte à captura de pacotes.

Para executar um encaminhador de captura de pacotes (PCAP), você precisa do seguinte:

Instale o Npcap no host do Microsoft Windows.
Conceda privilégios de administrador ou raiz do encaminhador das Operações de segurança do Google para monitorar a interface de rede.
Nenhuma opção de linha de comando é necessária.
Na instalação do Npcap, ative o modo de compatibilidade do WinPcap.

Para configurar um encaminhador PCAP, o Google Cloud precisa do GUID da interface usada para capturar pacotes. Execute getmac.exe na máquina em que você planeja instalar o encaminhador das Operações de segurança do Google (o servidor ou a máquina que detecta a porta do span) e envie a saída para as Operações de segurança do Google.

Se preferir, modifique o arquivo de configuração. Localize a seção PCAP e substitua o valor do GUID mostrado ao lado da interface pelo GUID exibido na execução de getmac.exe.

Por exemplo, esta é uma seção original de PCAP:

- pcap:
      common:
        enabled: true
        data_type: PCAP_DNS
        batch_n_seconds: 10
        batch_n_bytes: 1048576
      interface: \Device\NPF_{1A7E7C8B-DD7B-4E13-9637-0437AB1A12FE}
      bpf: udp port 53

Esta é a saída da execução de getmac.exe:

C:\>getmac.exe
  Physical Address    Transport Name
  ===========================================================================
  A4-73-9F-ED-E1-82   \Device\Tcpip_{2E0E9440-ABFF-4E5B-B43C-E188FCAD1234}

E, finalmente, veja a seção revisada do PCAP com o novo GUID:

- pcap:
      common:
        enabled: true
        data_type: PCAP_DNS
        batch_n_seconds: 10
        batch_n_bytes: 1048576
      interface: \Device\NPF_{2E0E9440-ABFF-4E5B-B43C-E188FCAD9734}
      bpf: udp port 53

Coletar dados do tópico Kafka

É possível ingerir dados dos tópicos do Kafka da mesma forma que faz com o syslog. Os grupos de consumidores são usados para permitir que você implante até três encaminhadores das Operações de segurança do Google e extraia dados do mesmo tópico do Kafka. Para saber mais, consulte o Kafka.

Para mais informações sobre os grupos de consumidores do Kafka, consulte Grupos de consumidores do Kafka.

Exemplo de configuração: entrada do Kafka

A seguinte configuração do encaminhador do Google Security Operations mostra como configurá-lo para ingerir dados dos tópicos do Kafka.

Arquivo FORWARDER_NAME.conf

collectors:
- kafka:
      common:
        batch_n_bytes: 1048576
        batch_n_seconds: 10
        data_hint: null
        data_type: NIX_SYSTEM
        enabled: true
      topic: example-topic
      group_id: chronicle-forwarder
      timeout: 60s
      brokers: ["broker-1:9092", "broker-2:9093"]
      tls:
        insecureSkipVerify: true
        certificate: "c:/path/to/cert.pem"
        certificate_key: "c:/path/to/cert.key"
- syslog:
      common:
        batch_n_bytes: 1048576
        batch_n_seconds: 10
        data_hint: null
        data_type: WINEVTLOG
        enabled: true
      tcp_address: 0.0.0.0:30001
      connection_timeout_sec: 60

Arquivo FORWARDER_NAME_auth.conf

collectors:
- kafka:
      username: user
      password: password
- syslog:

Coletar dados do WebProxy

O encaminhador do Google Security Operations pode capturar dados do WebProxy diretamente de uma interface de rede usando o Npcap e enviá-los ao Google Cloud.

Para ativar a captura de dados do WebProxy para seu sistema, entre em contato com o Suporte de Operações de Segurança do Google.

Antes de executar um encaminhador WebProxy, faça o seguinte:

Instale o Npcap no host do Microsoft Windows. Ative o modo de compatibilidade do WinPcap durante a instalação.
Conceda privilégios raiz ou de administrador ao encaminhador do Google Security Operations para monitorar a interface de rede.
Para configurar um encaminhador do WebProxy, o Google Cloud precisa do GUID da interface usada para capturar os pacotes do WebProxy.

Execute getmac.exe na máquina em que você quer instalar o encaminhador de Operações de segurança do Google e enviar a saída para as Operações de segurança do Google. Como alternativa, modifique o arquivo de configuração. Localize a seção WebProxy e substitua o GUID mostrado ao lado da interface pelo que aparece depois da execução de getmac.exe.

Modifique o arquivo de configuração do encaminhador do Google Security Operations (FORWARDER_NAME.conf) da seguinte maneira:
```
  - webproxy:
    common:
        enabled : true
        data_type: <Your LogType>
        batch_n_seconds: 10
        batch_n_bytes: 1048576
      interface: \Device\NPF_{2E0E9440-ABFF-4E5B-B43C-E188FCAD9734}
      bpf: tcp and dst port 80
```

Personalizar configurações

A tabela a seguir lista parâmetros importantes usados no arquivo de configuração do encaminhador.

Parâmetro	Descrição
data_type	O tipo de dados de registro que o coletor pode coletar e processar.
metadados	Metadados, que substituem os metadados globais.
max_file_buffer_bytes	Número máximo de bytes que podem ser acumulados no disco ou no buffer do arquivo. O valor padrão é `1073741824`, que é 1 GB.
max_memory_buffer_bytes	Número máximo de bytes que podem ser acumulados no buffer de memória. O valor padrão é `1073741824`, que é 1 GB.
write_to_disk_dir_path	O caminho a ser usado para o arquivo ou buffer de disco.
write_to_disk_buffer_enabled	Se `true`, o buffer de disco será usado em vez do buffer de memória. O valor padrão é `false`.
batch_n_bytes	Número máximo de bytes que podem ser acumulados pelo coletor. Depois disso, os dados são agrupados em lote. O valor padrão é `1048576`, que é 1 MB.
batch_n_seconds	O número de segundos após os quais os dados coletados pelo coletor são agrupados. O valor padrão é de 11 segundos.
data_hint	Formato de dados que o coletor pode receber (geralmente o cabeçalho do arquivo de registros que descreve o formato).

Para uma lista extensa de parâmetros usados no arquivo de configuração, consulte Campos de configuração do encaminhador e Campos de configuração do coletor.

Ativar a compactação de dados

A compactação de registros reduz o consumo de largura de banda da rede ao transferir registros para o Google Security Operations. No entanto, a compactação pode causar um aumento no uso da CPU. A compensação entre o uso da CPU e a largura de banda depende de muitos fatores, incluindo o tipo de dados de registro, a compactação dos dados, a disponibilidade de ciclos de CPU no host que executa o encaminhador do Google Security Operations e a necessidade de reduzir o consumo de largura de banda da rede.

Por exemplo, os registros baseados em texto são bem compactados e podem proporcionar uma economia significativa na largura de banda com baixo uso da CPU. No entanto, os payloads criptografados de pacotes brutos não são compactados corretamente, o que aumenta o uso da CPU.

A compactação de registros fica desativada por padrão. Ativar a compactação de registro pode reduzir o consumo de largura de banda. No entanto, ativar a compactação de registros também pode aumentar o uso da CPU. Saiba o que fazer.

Para ativar a compactação de registro, defina o campo compression como true no arquivo de configuração do encaminhador do Google Security Operations, conforme mostrado no exemplo a seguir:

Arquivo FORWARDER_NAME.conf

output:
  compression: true
    url: malachiteingestion-pa.googleapis.com:443
    identity:
      identity:
      collector_id: 10479925-878c-11e7-9421-10604b7cb5c1
      customer_id: ebdc4bb9-878b-11e7-8455-10604b7cb5c1
...

Arquivo FORWARDER_NAME_auth.conf

output:
  identity:
    secret_key: |
    {
     "type": "service_account",
...
    }

Configurar o armazenamento em buffer de disco

O armazenamento em buffer de disco permite armazenar em buffer as mensagens acumuladas no disco, e não na memória. As mensagens acumuladas podem ser armazenadas em caso de falha do encaminhador do Google Security Operations ou do host subjacente. Esteja ciente de que ativar o armazenamento em buffer do disco pode afetar o desempenho.

Se o armazenamento em buffer do disco estiver desativado, o encaminhador do Google Security Operations usará 1 GB de memória (RAM) para cada tipo de registro (por exemplo, para cada conector). Especifique o parâmetro de configuração max_memory_buffer_bytes. A memória máxima permitida é de 4 GB.

É possível configurar o armazenamento em buffer automático de disco para usar um buffer compartilhado dinamicamente entre coletores, que lida melhor com picos de tráfego. Para ativar o buffer compartilhado dinamicamente, adicione o seguinte na configuração do encaminhador:

auto_buffer:
  enabled: true
  target_memory_utilization: 80

Se o armazenamento em buffer automático de disco estiver ativado, mas target_memory_utilization não estiver definido, ele usará um valor padrão de 70.

Se você estiver executando o encaminhador do Google Security Operations usando o Docker, o Google recomenda ativar um volume separado do volume de configuração para fins de isolamento. Além disso, cada entrada precisa ser isolada com o próprio diretório ou volume para evitar conflitos.

Exemplo de configuração: armazenamento em buffer de disco

A configuração a seguir inclui a sintaxe para ativar o armazenamento em buffer do disco:

collectors:
- syslog:
    common:
      write_to_disk_buffer_enabled: true
      # c:/buffers/NIX_SYSTEM is part of the external mounted volume for the
forwarder
      write_to_disk_dir_path: c:/buffers/NIX_SYSTEM
      max_file_buffer_bytes: 1073741824
      batch_n_bytes: 1048576
      batch_n_seconds: 10
      data_hint: null
      data_type: NIX_SYSTEM
      enabled: true
    tcp_address: 0.0.0.0:30000
    connection_timeout_sec: 60
- syslog:
    common:
      batch_n_bytes: 1048576
      batch_n_seconds: 10
      data_hint: null
      data_type: WINEVTLOG
      enabled: true
    tcp_address: 0.0.0.0:30001
    connection_timeout_sec: 60

Definir filtros de expressão regular

Os filtros de expressão regular permitem filtrar registros com base nas correspondências de expressões regulares em registros brutos.

Os filtros utilizam a syntax RE2.

Os filtros precisam incluir uma expressão regular e, opcionalmente, definir um comportamento quando há uma correspondência. O comportamento padrão em uma correspondência é de bloco. Você também pode configurá-la explicitamente como bloqueio.

Como alternativa, especifique filtros com o comportamento allow. Se você especificar filtros allow, o encaminhador do Google Security Operations bloqueará todos os registros que não corresponderem a pelo menos um filtro allow.

É possível definir um número arbitrário de filtros. Os filtros de bloqueio têm prioridade sobre os filtros allow.

Quando os filtros são definidos, é necessário atribuir um nome a eles. Os nomes dos filtros ativos serão informados ao Google Security Operations usando métricas de integridade do encaminhador. Os filtros definidos na raiz da configuração são mesclados com os filtros definidos no nível do coletor. Os filtros de nível do coletor têm precedência em casos de nomes conflitantes. Se nenhum filtro for definido no nível raiz ou do coletor, o comportamento será "Permitir todos".

Exemplo de configuração: filtros de expressão regular

Na seguinte configuração do encaminhador das Operações de segurança do Google, os registros WINEVTLOG que não correspondem ao filtro raiz (allow_filter) são bloqueados. Considerando a expressão regular, o filtro só permite registros com prioridades entre 0 e 99. No entanto, todos os registros NIX_SYSTEM que contenham "foo" ou "bar" serão bloqueados, independente da allow_filter. Isso ocorre porque os filtros usam um OR lógico. Todos os registros são processados até que um filtro seja acionado.

regex_filters:
  allow_filter:
    regexp: ^<[1-9][0-9]?$>.*$
    behavior_on_match: allow
collectors:
- syslog:
    common:
      regex_filters:
        block_filter_1:
          regexp: ^.*foo.*$
          behavior_on_match: block
        block_filter_2:
          regexp: ^.*bar.*$
      batch_n_bytes: 1048576
      batch_n_seconds: 10
      data_hint: null
      data_type: NIX_SYSTEM
      enabled: true
    tcp_address: 0.0.0.0:30000
    connection_timeout_sec: 60
- syslog:
    common:
      batch_n_bytes: 1048576
      batch_n_seconds: 10
      data_hint: null
      data_type: WINEVTLOG
      enabled: true
    tcp_address: 0.0.0.0:30001
    connection_timeout_sec: 60

Configurar rótulos arbitrários

Os identificadores são usados para anexar metadados arbitrários a registros usando pares de chave-valor. Os rótulos podem ser configurados para todo um encaminhador das Operações de segurança do Google ou dentro de um coletor específico de um encaminhador de Operações de segurança do Google. Se ambos forem fornecidos, os rótulos serão mesclados com as chaves do coletor, tendo precedência sobre as chaves do encaminhador das Operações de segurança do Google se as chaves se sobrepuserem.

Exemplo de configuração: rótulos arbitrários

Na seguinte configuração do encaminhador das Operações de segurança do Google, os pares de chave e valor foo=bar e meow=mix estão anexados aos registros WINEVTLOG, e os pares de chave e valor foo=baz e meow=mix estão anexados aos registros NIX_SYSTEM.

metadata:
  labels:
    foo: bar
    meow: mix
collectors:
syslog:
    common:
      metadata:
        labels:
          foo: baz
          meow: mix
      batch_n_bytes: 1048576
      batch_n_seconds: 10
      data_hint: null
      data_type: NIX_SYSTEM
      enabled: true
    tcp_address: 0.0.0.0:30000
    connection_timeout_sec: 60
syslog:
    common:
      batch_n_bytes: 1048576
      batch_n_seconds: 10
      data_hint: null
      data_type: WINEVTLOG
      enabled: true
    tcp_address: 0.0.0.0:30001
    connection_timeout_sec: 60

Configurar namespaces

Use rótulos de namespace para identificar registros de segmentos de rede distintos e endereços IP sobrepostos de eliminação de conflito. É possível configurar um rótulo de namespace para um encaminhador inteiro do Google Security Operations ou dentro de um coletor específico dele. Se ambos estiverem incluídos, o namespace do coletor específico terá precedência.

Qualquer namespace configurado para o encaminhador das Google Security Operations aparece com os recursos associados na interface do usuário das Google Security Operations. Também é possível pesquisar namespaces usando o recurso de pesquisa do Google Security Operations.

Para informações sobre como visualizar namespaces na interface do usuário das Operações de segurança do Google, clique aqui.

Exemplo de configuração: namespaces

Na configuração do encaminhador do Google Security Operations a seguir, os registros WINEVTLOG são anexados ao namespace FORWARDER e os registros NIX_SYSTEM são anexados ao namespace CORPORATE.

metadata:
  namespace: FORWARDER
collectors:
- syslog:
      common:
        metadata:
          namespace: CORPORATE
        batch_n_bytes: 1048576
        batch_n_seconds: 10
        data_hint: null
        data_type: NIX_SYSTEM
        enabled: true
      tcp_address: 0.0.0.0:30000
      connection_timeout_sec: 60
- syslog:
      common:
        batch_n_bytes: 1048576
        batch_n_seconds: 10
        data_hint: null
        data_type: WINEVTLOG
        enabled: true
      tcp_address: 0.0.0.0:30001
      connection_timeout_sec: 60

Configurar opções de balanceamento de carga e alta disponibilidade

O encaminhador do Google Security Operations para Windows no Docker pode ser implantado em um ambiente em que um balanceador de carga de camada 4 esteja instalado entre a fonte de dados e as instâncias de encaminhador das Google Security Operations. Isso permite que você distribua a coleta de registros em vários encaminhadores das Operações de segurança do Google ou envie registros para outro encaminhador das Operações de segurança do Google se um deles falhar. Esse recurso só é compatível com o tipo de coleção "syslog".

O encaminhador do Google Security Operations para Windows no Docker inclui um servidor HTTP integrado que responde a verificações de integridade HTTP do balanceador de carga. O servidor HTTP também ajuda a garantir que os registros não sejam perdidos durante a inicialização ou o encerramento de um encaminhador do Google Security Operations.

Configure o servidor HTTP, o balanceamento de carga e as opções de alta disponibilidade na seção server do arquivo de configuração do encaminhador do Google Security Operations. Essas opções são compatíveis com a definição de durações de tempo limite e códigos de status retornados em resposta a verificações de integridade recebidas no programador de contêiner e implantações baseadas em orquestração, bem como de balanceadores de carga convencionais.

Use os caminhos de URL abaixo para verificações de integridade, prontidão e atividade. Os valores <host:port> são definidos na configuração do encaminhador das Operações de segurança do Google.

http://<host:port>/meta/available: verificações de atividade para programadores/orquestradores de contêiner, como o Kubernetes.
http://<host:port>/meta/ready: verificações de prontidão e verificações de integridade do balanceador de carga tradicional.

A seguinte configuração do encaminhador do Google Security Operations é um exemplo de balanceamento de carga e alta disponibilidade:

collectors:
- syslog:
    common:
      batch_n_bytes: 1048576
      batch_n_seconds: 10
      data_hint: null
      data_type: NIX_SYSTEM
      enabled: true
    tcp_address: 0.0.0.0:30000
    connection_timeout_sec: 60
- syslog:
    common:
      batch_n_bytes: 1048576
      batch_n_seconds: 10
      data_hint: null
      data_type: WINEVTLOG
      enabled: true
    tcp_address: 0.0.0.0:30001
    connection_timeout_sec: 60
server:
  graceful_timeout: 15s
  drain_timeout: 10s
  http:
    port: 8080
    host: 0.0.0.0
    read_timeout: 3s
    read_header_timeout: 3s
    write_timeout: 3s
    idle_timeout: 3s
    routes:
    - meta:
        available_status: 204
        ready_status: 204
        unready_status: 503

Caminho de configuração	Descrição
servidor : Graceful_timeout	A quantidade de tempo que o encaminhador das Operações de segurança do Google retorna uma verificação de prontidão/integridade ruim e ainda aceita novas conexões. Esse também é o tempo de espera entre receber um sinal para parar e realmente iniciar o encerramento do próprio servidor. Isso permite que o balanceador de carga remova o encaminhador do Google Security Operations do pool.
servidor : run_timeout	O tempo que o encaminhador das Operações de segurança do Google aguarda o fechamento das conexões ativas por conta própria antes de ser fechado pelo servidor.
servidor : http : porta	O número da porta que o servidor HTTP detecta para verificações de integridade do balanceador de carga. O valor precisa estar entre 1024 e 65535.
servidor : http : host	O endereço IP ou nome do host que pode ser resolvido para endereços IP que o servidor deve detectar. Se estiver vazio, o valor padrão será o sistema local (0.0.0.0).
servidor : http : read_timeout	Usado para ajustar o servidor HTTP. Normalmente, não é preciso alterar a configuração padrão. O tempo máximo permitido para ler toda a solicitação, tanto o cabeçalho quanto o corpo. É possível definir read_timeout e read_header_timeout.
servidor : http : read_header_timeout	Usado para ajustar o servidor HTTP. Normalmente, não é preciso alterar a configuração padrão. A quantidade máxima de tempo permitida para ler cabeçalhos de solicitação. A leitura da conexão de que o prazo é redefinido após a leitura do cabeçalho.
servidor : http : write_timeout	Usado para ajustar o servidor HTTP. Normalmente, não é preciso alterar a configuração padrão. O tempo máximo permitido para enviar uma resposta. Ele é redefinido quando um novo cabeçalho de solicitação é lido.
servidor : http : sleep_timeout	Usado para ajustar o servidor HTTP. Normalmente, não é preciso alterar a configuração padrão. O período máximo de espera pela próxima solicitação quando as conexões inativas estiverem ativadas. Se missing_timeout for zero, o valor read_timeout será usado. Se ambos forem zero, o read_header_timeout será usado.
routes : meta : Ready_status	O código de status que o encaminhador das Operações de segurança do Google retorna quando está pronto para aceitar o tráfego em uma das seguintes situações: A verificação de prontidão é recebida de um programador ou orquestrador de contêiner, como o Kubernetes. A verificação de integridade é recebida de um balanceador de carga tradicional.
routes : meta : familiesy_status	O código de status que o encaminhador do Google Security Operations retorna quando não está pronto para aceitar o tráfego.
routes : meta : available_status	O código de status que o encaminhador das Operações de Segurança do Google retorna quando uma verificação de atividade é recebida e quando ele está disponível. Programadores/orquestradores de contêiner, como o Kubernetes, geralmente enviam verificações de atividade.