Coletar registros do Kyriba Treasury Management

Compatível com:

Este documento explica como ingerir registros do Kyriba Treasury Management no Google Security Operations usando o Cloud Storage V2.

A Kyriba é uma plataforma de gestão financeira e de tesouraria baseada na nuvem. Ele gera registros de auditoria para operações de pagamento, acesso de usuários, fluxos de trabalho de aprovação e transações financeiras. O analisador extrai campos dos dados de auditoria da Kyriba e os mapeia para o modelo de dados unificado (UDM), capturando a identidade do usuário, os detalhes da transação, o status de aprovação e os resultados de segurança.

Antes de começar

Verifique se você tem os pré-requisitos a seguir:

  • Uma instância do Google SecOps
  • Um projeto do Google Cloud com a API Storage do Cloud Storage ativada.
  • Permissões para criar e gerenciar buckets do Cloud Storage
  • Permissões para gerenciar políticas do Identity and Access Management (IAM) em buckets do Cloud Storage
  • Permissões para criar serviços do Cloud Run, tópicos do Pub/Sub e jobs do Cloud Scheduler
  • Acesso privilegiado à plataforma Kyriba com autoridade para configurar o acesso à API e gerar credenciais do OAuth2.

Criar um bucket do Cloud Storage

  1. Acesse o console doGoogle 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, kyriba-treasury-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.

Coletar credenciais da API Kyriba

Acessar o URL da instância do Kyriba

  1. Faça login na plataforma Kyriba.
  2. Anote o URL da instância na barra de endereço do navegador.
    • Formato: https://<your-instance>.kyriba.com
    • Exemplo: se você acessar o Kyriba em https://acme.kyriba.com/gateway, o URL da instância será https://acme.kyriba.com.

Criar credenciais da API OAuth2

  1. Faça login na plataforma Kyriba como administrador.
  2. Acesse Administração > Acesso à API.
  3. Clique em Criar ou Adicionar aplicativo.
  4. Informe os seguintes detalhes de configuração:
    • Nome do aplicativo: insira Google Security Operations Integration.
    • Tipo de permissão de acesso: selecione Credenciais do cliente.
  5. Clique em Salvar.
  6. Copie e salve as credenciais com segurança:

    • ID do cliente: copie esse valor.
    • Chave secreta do cliente: copie esse valor.

Verifique as permissões

Para verificar se as credenciais têm as permissões necessárias:

  1. Faça login na plataforma Kyriba.
  2. Acesse Administração > Acesso à API.
  3. Confirme se o aplicativo que você criou está listado e tem o status Ativo.
  4. Verifique se o aplicativo tem acesso ao escopo da API Trilha de auditoria.

Testar o acesso à API

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

    # Replace with your actual credentials
    CLIENT_ID="<your-client-id>"
    CLIENT_SECRET="<your-client-secret>"
    KYRIBA_HOST="https://<your-instance>.kyriba.com"
    
    # Get OAuth2 token
    TOKEN=$(curl -s -X POST "${KYRIBA_HOST}/gateway/oauth/token" \
      -H "Content-Type: application/x-www-form-urlencoded" \
      -d "grant_type=client_credentials&client_id=${CLIENT_ID}&client_secret=${CLIENT_SECRET}" \
      | python3 -c "import sys,json; print(json.load(sys.stdin)['access_token'])")
    
    # Test API access
    curl -v -H "Authorization: Bearer ${TOKEN}" \
      "${KYRIBA_HOST}/gateway/api/v1/audit-trails?startDate=2024-01-01&endDate=2024-01-02"
    

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 Cloud Storage e ser invocada pelo Pub/Sub.

Criar uma conta de serviço

  1. No console do Google Cloud , 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 kyriba-logs-collector-sa.
    • Descrição da conta de serviço: insira Service account for Cloud Run function to collect Kyriba Treasury Management 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: grava registros no bucket do Cloud Storage e gerencia 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 Cloud Storage

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

  1. Acesse Cloud Storage > Buckets.
  2. Clique no nome do bucket (por exemplo, kyriba-treasury-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 (por exemplo, kyriba-logs-collector-sa@PROJECT_ID.iam.gserviceaccount.com)
    • Atribuir papéis: selecione Administrador de objetos do Storage.
  6. Clique em Salvar.

Criar um tópico do 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 Google Cloud , acesse Pub/Sub > Tópicos.
  2. Selecione Criar tópico.
  3. Informe os seguintes detalhes de configuração:
    • ID do tópico: insira kyriba-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 Kyriba e gravá-los no Cloud Storage.

  1. No console do Google Cloud , 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 kyriba-logs-collector
    Região Selecione a região correspondente ao bucket do Cloud Storage (por exemplo, us-central1)
    Ambiente de execução Selecione Python 3.12 ou mais recente.
  5. Na seção Gatilho (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 do Pub/Sub (kyriba-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 a conta de serviço (kyriba-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 kyriba-treasury-logs Nome do bucket do Cloud Storage
    GCS_PREFIX kyriba Prefixo para arquivos de registro
    STATE_KEY kyriba/state.json Caminho do arquivo de estado
    KYRIBA_HOST https://<your-instance>.kyriba.com URL da instância do Kyriba
    CLIENT_ID your-client-id ID do cliente OAuth 2.0
    CLIENT_SECRET your-client-secret Chave secreta do cliente OAuth2
    MAX_RECORDS 1000 Máximo de registros por execução
    PAGE_SIZE 100 Registros por página
    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 (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:

    • Primeiro arquivo: main.py::

        import functions_framework
        from google.cloud import storage
        import json
        import os
        import urllib3
        from datetime import datetime, timezone, timedelta
        import time
        import urllib.parse
      
        # Initialize HTTP client with timeouts
        http = urllib3.PoolManager(
          timeout=urllib3.Timeout(connect=5.0, read=30.0),
          retries=False,
        )
      
        # Initialize Storage client
        storage_client = storage.Client()
      
        # Environment variables
        GCS_BUCKET = os.environ.get('GCS_BUCKET')
        GCS_PREFIX = os.environ.get('GCS_PREFIX', 'kyriba')
        STATE_KEY = os.environ.get('STATE_KEY', 'kyriba/state.json')
        KYRIBA_HOST = os.environ.get('KYRIBA_HOST')
        CLIENT_ID = os.environ.get('CLIENT_ID')
        CLIENT_SECRET = os.environ.get('CLIENT_SECRET')
        MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '1000'))
        PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '100'))
        LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))
      
        def parse_datetime(value: str) -> datetime:
          """Parse ISO datetime string to datetime object."""
          if value.endswith("Z"):
            value = value[:-1] + "+00:00"
          return datetime.fromisoformat(value)
      
        def get_oauth_token(host: str, client_id: str, client_secret: str) -> str:
          """Get OAuth 2.0 access token from Kyriba."""
          token_url = f"{host.rstrip('/')}/gateway/oauth/token"
          data = urllib.parse.urlencode({
            'grant_type': 'client_credentials',
            'client_id': client_id,
            'client_secret': client_secret,
          }).encode('utf-8')
          response = http.request(
            'POST', token_url,
            body=data,
            headers={'Content-Type': 'application/x-www-form-urlencoded'},
          )
          if response.status != 200:
            raise Exception(f"OAuth token request failed: {response.status} {response.data.decode('utf-8')}")
          token_data = json.loads(response.data.decode('utf-8'))
          return token_data['access_token']
      
        @functions_framework.cloud_event
        def main(cloud_event):
          """
          Cloud Run function triggered by Pub/Sub to fetch Kyriba Treasury Management
          audit logs and write them to GCS.
      
          Args:
            cloud_event: CloudEvent object containing Pub/Sub message
          """
      
          if not all([GCS_BUCKET, KYRIBA_HOST, CLIENT_ID, CLIENT_SECRET]):
            print('Error: Missing required environment variables')
            return
      
          try:
            # Get GCS bucket
            bucket = storage_client.bucket(GCS_BUCKET)
      
            # Load state
            state = load_state(bucket, STATE_KEY)
      
            # Determine time window
            now = datetime.now(timezone.utc)
            last_time = None
      
            if isinstance(state, dict) and state.get("last_event_time"):
              try:
                last_time = parse_datetime(state["last_event_time"])
                # Overlap by 2 minutes to catch any delayed events
                last_time = last_time - timedelta(minutes=2)
              except Exception as e:
                print(f"Warning: Could not parse last_event_time: {e}")
      
            if last_time is None:
              last_time = now - timedelta(hours=LOOKBACK_HOURS)
      
            print(f"Fetching logs from {last_time.isoformat()} to {now.isoformat()}")
      
            # Get OAuth token
            token = get_oauth_token(KYRIBA_HOST, CLIENT_ID, CLIENT_SECRET)
            print("Successfully obtained OAuth2 token")
      
            # Fetch logs
            records, newest_event_time = fetch_logs(
              host=KYRIBA_HOST,
              token=token,
              start_time=last_time,
              end_time=now,
              page_size=PAGE_SIZE,
              max_records=MAX_RECORDS,
            )
      
            if not records:
              print("No new log records found.")
              save_state(bucket, STATE_KEY, now.isoformat())
              return
      
            # Write to GCS as NDJSON
            timestamp = now.strftime('%Y%m%d_%H%M%S')
            object_key = f"{GCS_PREFIX}/logs_{timestamp}.ndjson"
            blob = bucket.blob(object_key)
      
            ndjson = '\n'.join([json.dumps(record, ensure_ascii=False) for record in records]) + '\n'
            blob.upload_from_string(ndjson, content_type='application/x-ndjson')
      
            print(f"Wrote {len(records)} records to gs://{GCS_BUCKET}/{object_key}")
      
            # Update state with newest event time
            if newest_event_time:
              save_state(bucket, STATE_KEY, newest_event_time)
            else:
              save_state(bucket, STATE_KEY, now.isoformat())
      
            print(f"Successfully processed {len(records)} records")
      
          except Exception as e:
            print(f'Error processing logs: {str(e)}')
            raise
      
        def load_state(bucket, key):
          """Load state from GCS."""
          try:
            blob = bucket.blob(key)
            if blob.exists():
              state_data = blob.download_as_text()
              return json.loads(state_data)
          except Exception as e:
            print(f"Warning: Could not load state: {e}")
      
          return {}
      
        def save_state(bucket, key, last_event_time_iso: str):
          """Save the last event timestamp to GCS state file."""
          try:
            state = {'last_event_time': last_event_time_iso}
            blob = bucket.blob(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}")
      
        def fetch_logs(host: str, token: str, start_time: datetime, end_time: datetime, page_size: int, max_records: int):
          """
          Fetch audit trail logs from Kyriba API with pagination and rate limiting.
      
          Args:
            host: Kyriba instance URL
            token: OAuth2 access token
            start_time: Start time for log query
            end_time: End time for log query
            page_size: Number of records per page
            max_records: Maximum total records to fetch
      
          Returns:
            Tuple of (records list, newest_event_time ISO string)
          """
          base_url = host.rstrip('/')
          endpoint = f"{base_url}/gateway/api/v1/audit-trails"
      
          headers = {
            'Authorization': f'Bearer {token}',
            'Accept': 'application/json',
            'Content-Type': 'application/json',
            'User-Agent': 'GoogleSecOps-KyribaCollector/1.0',
          }
      
          records = []
          newest_time = None
          page_num = 0
          backoff = 1.0
          offset = 0
      
          start_date = start_time.strftime('%Y-%m-%d')
          end_date = end_time.strftime('%Y-%m-%d')
      
          while True:
            page_num += 1
      
            if len(records) >= max_records:
              print(f"Reached max_records limit ({max_records})")
              break
      
            params = []
            params.append(f"startDate={start_date}")
            params.append(f"endDate={end_date}")
            params.append(f"offset={offset}")
            params.append(f"limit={min(page_size, max_records - len(records))}")
            url = f"{endpoint}?{'&'.join(params)}"
      
            try:
              response = http.request('GET', url, headers=headers)
      
              # Handle rate limiting with exponential backoff
              if response.status == 429:
                retry_after = int(response.headers.get('Retry-After', str(int(backoff))))
                print(f"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"HTTP Error: {response.status}")
                response_text = response.data.decode('utf-8')
                print(f"Response body: {response_text}")
                return [], None
      
              data = json.loads(response.data.decode('utf-8'))
      
              page_results = data.get('results', [])
      
              if not page_results:
                print(f"No more results (empty page)")
                break
      
              print(f"Page {page_num}: Retrieved {len(page_results)} events")
              records.extend(page_results)
      
              # Track newest event time
              for event in page_results:
                try:
                  event_time = event.get('dateTime') or event.get('date')
                  if event_time:
                    if newest_time is None or parse_datetime(event_time) > parse_datetime(newest_time):
                      newest_time = event_time
                except Exception as e:
                  print(f"Warning: Could not parse event time: {e}")
      
              # Check for more results
              if len(page_results) < page_size:
                print(f"Reached last page (size={len(page_results)} < limit={page_size})")
                break
      
              offset += len(page_results)
      
            except Exception as e:
              print(f"Error fetching logs: {e}")
              return [], None
      
          print(f"Retrieved {len(records)} total records from {page_num} pages")
          return records, newest_time
      
    • Segundo arquivo: 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

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 Google Cloud , acesse o Cloud Scheduler.
  2. Clique em Criar job.
  3. Informe os seguintes detalhes de configuração:

    Configuração Valor
    Nome kyriba-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 Selecione o tópico do Pub/Sub (kyriba-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.
  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 (kyriba-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
    Successfully obtained OAuth2 token
    Page 1: Retrieved X events
    Wrote X records to gs://kyriba-treasury-logs/kyriba/logs_YYYYMMDD_HHMMSS.ndjson
    Successfully processed X records
    
  8. Acesse Cloud Storage > Buckets.

  9. Clique no nome do bucket (kyriba-treasury-logs).

  10. Navegue até a pasta de prefixo (kyriba/).

  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 as credenciais do OAuth2 (ID do cliente e chave secreta do cliente) nas variáveis de ambiente.
  • HTTP 403: verifique se o aplicativo da API tem acesso ao escopo da trilha de auditoria.
  • 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.

Recuperar a conta de serviço do Google SecOps

O Google SecOps usa uma conta de serviço exclusiva para ler dados do seu bucket do Cloud Storage. É necessário conceder a essa conta de serviço acesso ao bucket.

Encontrar o e-mail da conta de serviço

  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, Kyriba Treasury Management Logs).
  5. Selecione Google Cloud Storage V2 como o Tipo de origem.
  6. Selecione Kyriba Treasury Management como o Tipo de registro.
  7. Clique em Get Service Account.
  8. Um e-mail exclusivo da conta de serviço será exibido, por 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 Cloud Storage com o caminho do prefixo:

      gs://kyriba-treasury-logs/kyriba/
      
      • Substitua:
        • kyriba-treasury-logs: o nome do bucket do Cloud Storage.
        • kyriba: prefixo/caminho de pasta opcional em que os registros são armazenados (deixe em branco para a raiz).
    • 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 no último número de 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 seu novo feed de notícias 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 de Leitor de objetos do Storage no bucket do Cloud Storage.

  1. Acesse Cloud Storage > Buckets.
  2. Clique no nome do bucket (por exemplo, kyriba-treasury-logs).
  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.

Tabela de mapeamento de UDM

Campo de registro Mapeamento de UDM Lógica
column11 metadata.description Valor copiado diretamente
column16, column17 metadata.event_timestamp Analisado de campos de data e hora usando o filtro de data com os formatos "MM/dd/aaaa hh:mm A" e "MM/dd/aaaa h:m A"
principal_userid metadata.event_type Defina como "USER_RESOURCE_CREATION" se principal_userid não estiver vazio. Caso contrário, defina como "GENERIC_EVENT".
column3 principal.user.company_name Valor copiado diretamente
column15 principal.user.userid Valor copiado diretamente
status sec_result.action Defina como "ALLOW" se o status for "Remitted", caso contrário, "BLOCK"
column6 sec_result.description Valor copiado diretamente
sec_result security_result Valor copiado diretamente
column4 target.location.name Valor copiado diretamente
column1 target.resource.id Valor copiado diretamente
target.resource.name Defina como "TRANSACTION"
target.resource.resource_type
column13 target.user.company_name Valor copiado diretamente
metadata.product_name Defina como "KYRIBA TREASURY"
metadata.vendor_name Defina como "KYRIBA"

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