Recopila registros de problemas del grupo de Snyk

Se admite en los siguientes sistemas operativos:

En este documento, se explica cómo transferir registros de problemas del grupo de Snyk a Google Security Operations con Google Cloud Storage. Snyk es una plataforma de seguridad para desarrolladores que ayuda a las organizaciones a encontrar y corregir vulnerabilidades en dependencias de código abierto, imágenes de contenedores, configuraciones de infraestructura como código y código de la aplicación. Los problemas del grupo de Snyk proporcionan visibilidad de las vulnerabilidades de seguridad y los problemas de licencias en todos los proyectos dentro de un grupo de Snyk.

Antes de comenzar

Asegúrate de cumplir con los siguientes requisitos previos:

  • Una instancia de Google SecOps
  • Un proyecto de GCP con la API de Cloud Storage habilitada
  • Permisos para crear y administrar buckets de GCS
  • Permisos para administrar políticas de IAM en buckets de GCS
  • Permisos para crear funciones de Cloud Run, temas de Pub/Sub y trabajos de Cloud Scheduler
  • Acceso con privilegios al grupo de Snyk (token de API con acceso de lectura; ID de grupo)
  • El rol de administrador de grupo de Snyk asignado al usuario con el token de API (el usuario debe poder ver los registros de auditoría del grupo y los problemas del grupo)

Crea un bucket de Google Cloud Storage

  1. Ve a la consola de Google Cloud.
  2. Selecciona tu proyecto o crea uno nuevo.
  3. En el menú de navegación, ve a Cloud Storage > Buckets.
  4. Haz clic en Crear bucket.

  5. Proporciona los siguientes detalles de configuración:

    Parámetro de configuración Valor
    Asigna un nombre a tu bucket Ingresa un nombre global único (por ejemplo, snyk-group-logs).
    Tipo de ubicación Elige según tus necesidades (regional, birregional o multirregional)
    Ubicación Selecciona la ubicación (por ejemplo, us-central1).
    Clase de almacenamiento Estándar (recomendado para los registros a los que se accede con frecuencia)
    Control de acceso Uniforme (recomendado)
    Herramientas de protección Opcional: Habilita el control de versiones de objetos o la política de retención

  6. Haz clic en Crear.

Recopila el ID del grupo y el token de API de Snyk

Obtén el token de la API de Snyk

  1. Accede a la IU de Snyk en https://app.snyk.io.
  2. Ve a Configuración de la cuenta > Token de API.
  3. Haz clic en Generar para generar el token de API.

  4. Copia y guarda el token en una ubicación segura para usarlo más adelante como SNYK_TOKEN.

Obtén el ID del grupo de Snyk

  1. En la IU de Snyk, cambia a tu grupo.
  2. Ve a Configuración del grupo.
  3. Copia y guarda el ID del grupo de la URL (https://app.snyk.io/group/<GROUP_ID>/...) para usarlo más adelante como GROUP_ID.

Asigna el rol de administrador del grupo

  1. En la IU de Snyk, ve a Group settings > Members.
  2. Ubica al usuario asociado con el token de API.

  3. Asigna el rol de administrador del grupo al usuario.

Extremo de API de Notes

  • El extremo base de la API de REST varía según la región. Identifica tu región de Snyk y anota la URL base de REST correspondiente:

    Región URL base de REST
    SNYK-US-01 https://api.snyk.io/rest
    SNYK-US-02 https://api.us.snyk.io/rest
    SNYK-EU-01 https://api.eu.snyk.io/rest
    SNYK-AU-01 https://api.au.snyk.io/rest

    Usarás esta URL base de REST como API_BASE en la configuración de la función de Cloud Run. El código de la función crea URLs de extremos completas agregando rutas de acceso como /groups/{group_id}/audit_logs/search a esta URL base.

Crea una cuenta de servicio para la función de Cloud Run

La función de Cloud Run necesita una cuenta de servicio con permisos para escribir en el bucket de GCS.

Crea una cuenta de servicio

  1. En Google Cloud Console, ve a IAM y administración > Cuentas de servicio.
  2. Haz clic en Crear cuenta de servicio.
  3. Proporciona los siguientes detalles de configuración:
    • Nombre de la cuenta de servicio: Ingresa snyk-logs-collector-sa.
    • Descripción de la cuenta de servicio: Ingresa Service account for Cloud Run function to collect Snyk Group logs.
  4. Haz clic en Crear y continuar.
  5. En la sección Otorga acceso al proyecto a esta cuenta de servicio, haz lo siguiente:
    1. Haz clic en Seleccionar un rol.
    2. Busca y selecciona Administrador de objetos de Storage.
    3. Haz clic en + Agregar otro rol.
    4. Busca y selecciona Invocador de Cloud Run.
    5. Haz clic en + Agregar otro rol.
    6. Busca y selecciona Invocador de Cloud Functions.
  6. Haz clic en Continuar.
  7. Haz clic en Listo.

Estos roles son necesarios para lo siguiente:

  • Administrador de objetos de Storage: Escribe registros en el bucket de GCS y administra archivos de estado
  • Invocador de Cloud Run: Permite que Pub/Sub invoque la función
  • Invocador de Cloud Functions: Permite la invocación de funciones

Otorga permisos de IAM en el bucket de GCS

Otorga permisos de escritura a la cuenta de servicio en el bucket de GCS:

  1. Ve a Cloud Storage > Buckets.
  2. Haz clic en el nombre de tu bucket.
  3. Ve a la pestaña Permisos.
  4. Haz clic en Otorgar acceso.
  5. Proporciona los siguientes detalles de configuración:
    • Agregar entidades: Ingresa el correo electrónico de la cuenta de servicio (por ejemplo, snyk-logs-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
    • Asignar roles: Selecciona Administrador de objetos de Storage.
  6. Haz clic en Guardar.

Crea un tema de Pub/Sub

Crea un tema de Pub/Sub en el que Cloud Scheduler publicará y al que se suscribirá la función de Cloud Run.

  1. En Google Cloud Console, ve a Pub/Sub > Temas.
  2. Haz clic en Crear tema.
  3. Proporciona los siguientes detalles de configuración:
    • ID del tema: Ingresa snyk-logs-trigger.
    • Deja el resto de la configuración con sus valores predeterminados.
  4. Haz clic en Crear.

Crea una función de Cloud Run para recopilar registros

La función de Cloud Run se activa con mensajes de Pub/Sub de Cloud Scheduler para recuperar registros de la API de Snyk Group y los escribe en GCS.

  1. En Google Cloud Console, ve a Cloud Run.
  2. Haz clic en Crear servicio.
  3. Selecciona Función (usa un editor intercalado para crear una función).

  4. En la sección Configurar, proporciona los siguientes detalles de configuración:

    Parámetro de configuración Valor
    Nombre del servicio snyk-group-logs-collector
    Región Selecciona la región que coincida con tu bucket de GCS (por ejemplo, us-central1).
    Tiempo de ejecución Selecciona Python 3.12 o una versión posterior.

  5. En la sección Activador (opcional), haz lo siguiente:

    1. Haz clic en + Agregar activador.
    2. Selecciona Cloud Pub/Sub.
    3. En Selecciona un tema de Cloud Pub/Sub, elige el tema snyk-logs-trigger.
    4. Haz clic en Guardar.

  6. En la sección Autenticación, haz lo siguiente:

    1. Selecciona Necesita autenticación.
    2. Verifica Identity and Access Management (IAM).

  7. Desplázate hacia abajo y expande Contenedores, redes y seguridad.

  8. Ve a la pestaña Seguridad:

    • Cuenta de servicio: Selecciona la cuenta de servicio snyk-logs-collector-sa.

  9. Ve a la pestaña Contenedores:

    1. Haz clic en Variables y secretos.
    2. Haz clic en + Agregar variable para cada variable de entorno:
    Nombre de la variable Valor de ejemplo
    GCS_BUCKET snyk-group-logs
    GCS_PREFIX snyk/group/
    STATE_KEY snyk/group/state.json
    SNYK_TOKEN your-snyk-api-token
    GROUP_ID your-group-uuid
    API_BASE https://api.snyk.io/rest
    SNYK_AUDIT_API_VERSION 2024-10-15
    SNYK_ISSUES_API_VERSION 2024-10-15
    AUDIT_PAGE_SIZE 100
    ISSUES_PAGE_LIMIT 100
    MAX_PAGES 20
    LOOKBACK_SECONDS 3600

  10. En la pestaña Variables y secretos, desplázate hacia abajo hasta Solicitudes:

    • Tiempo de espera de la solicitud: Ingresa 600 segundos (10 minutos).

  11. Ve a la pestaña Configuración en Contenedores:

    • En la sección Recursos, haz lo siguiente:
      • Memoria: Selecciona 512 MiB o más.
      • CPU: Selecciona 1.
    • Haz clic en Listo.

  12. Desplázate hacia abajo hasta Entorno de ejecución:

    • Selecciona Predeterminado (recomendado).

  13. En la sección Escalamiento de revisión, haz lo siguiente:

    • Cantidad mínima de instancias: Ingresa 0.
    • Cantidad máxima de instancias: Ingresa 100 (o ajusta según la carga esperada).

  14. Haz clic en Crear.

  15. Espera a que se cree el servicio (de 1 a 2 minutos).

  16. Después de crear el servicio, se abrirá automáticamente el editor de código intercalado.

Agrega el código de función

  1. Ingresa main en Punto de entrada de la función.

  2. En el editor de código intercalado, crea dos archivos:

    • Primer archivo: main.py:

          import functions_framework
    from google.cloud import storage
    import json
    import os
    import time
    import urllib.parse
    from urllib.request import Request, urlopen
    from urllib.parse import urlparse, parse_qs
    from urllib.error import HTTPError

    # Initialize Storage client
    storage_client = storage.Client()

    @functions_framework.cloud_event
    def main(cloud_event):
        """
        Cloud Run function triggered by Pub/Sub to fetch logs from Snyk Group API and write to GCS.

        Args:
            cloud_event: CloudEvent object containing Pub/Sub message
        """

        # Get environment variables
        bucket_name = os.environ.get('GCS_BUCKET')
        prefix = os.environ.get('GCS_PREFIX', 'snyk/group/').strip()
        state_key = os.environ.get('STATE_KEY', 'snyk/group/state.json').strip()

        # Snyk API credentials
        api_base = os.environ.get('API_BASE', 'https://api.snyk.io/rest').rstrip('/')
        snyk_token = os.environ.get('SNYK_TOKEN').strip()
        group_id = os.environ.get('GROUP_ID').strip()

        # Page sizes & limits
        audit_size = int(os.environ.get('AUDIT_PAGE_SIZE', '100'))
        issues_limit = int(os.environ.get('ISSUES_PAGE_LIMIT', '100'))
        max_pages = int(os.environ.get('MAX_PAGES', '20'))

        # API versions
        audit_api_version = os.environ.get('SNYK_AUDIT_API_VERSION', '2024-10-15').strip()
        issues_api_version = os.environ.get('SNYK_ISSUES_API_VERSION', '2024-10-15').strip()

        # First-run lookback
        lookback_seconds = int(os.environ.get('LOOKBACK_SECONDS', '3600'))

        if not all([bucket_name, snyk_token, group_id]):
            print('Error: Missing required environment variables')
            return

        try:
            # Get GCS bucket
            bucket = storage_client.bucket(bucket_name)

            # Load state
            state = load_state(bucket, state_key)

            print('Starting Snyk Group logs collection')

            # Pull audit logs
            audit_res = pull_audit_logs(
                bucket, prefix, state, api_base, snyk_token, group_id,
                audit_api_version, audit_size, max_pages, lookback_seconds
            )
            print(f"Audit logs: {audit_res}")

            # Pull issues
            issues_res = pull_issues(
                bucket, prefix, state, api_base, snyk_token, group_id,
                issues_api_version, issues_limit, max_pages
            )
            print(f"Issues: {issues_res}")

            # Save state
            save_state(bucket, state_key, state)

            print('Successfully completed Snyk Group logs collection')

        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: {str(e)}')
        return {}

    def save_state(bucket, key, state):
        """Save state to GCS."""
        try:
            blob = bucket.blob(key)
            blob.upload_from_string(
                json.dumps(state, separators=(',', ':')),
                content_type='application/json'
            )
        except Exception as e:
            print(f'Warning: Could not save state: {str(e)}')

    def _iso(ts):
        """Convert timestamp to ISO format."""
        return time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime(ts))

    def _http_get(url, headers):
        """Make HTTP GET request with retry logic."""
        req = Request(url, method='GET', headers=headers)
        try:
            with urlopen(req, timeout=60) as r:
                return json.loads(r.read().decode('utf-8'))
        except HTTPError as e:
            if e.code in (429, 500, 502, 503, 504):
                delay = int(e.headers.get('Retry-After', '1'))
                time.sleep(max(1, delay))
                with urlopen(req, timeout=60) as r2:
                    return json.loads(r2.read().decode('utf-8'))
            raise

    def _write_page(bucket, prefix, kind, payload):
        """Write page to GCS."""
        ts = time.gmtime()
        key = f"{prefix.rstrip('/')}/{time.strftime('%Y/%m/%d/%H%M%S', ts)}-snyk-{kind}.json"
        blob = bucket.blob(key)
        blob.upload_from_string(
            json.dumps(payload, separators=(',', ':')),
            content_type='application/json'
        )
        return key

    def _next_href(links):
        """Extract next href from links."""
        if not links:
            return None
        nxt = links.get('next')
        if not nxt:
            return None
        if isinstance(nxt, str):
            return nxt
        if isinstance(nxt, dict):
            return nxt.get('href')
        return None

    def pull_audit_logs(bucket, prefix, state, api_base, snyk_token, group_id,
                        audit_api_version, audit_size, max_pages, lookback_seconds):
        """Pull audit logs from Snyk Group API."""
        headers = {
            'Authorization': f'token {snyk_token}',
            'Accept': 'application/vnd.api+json',
        }

        cursor = state.get('audit_cursor')
        pages = 0
        total = 0
        base = f"{api_base}/groups/{group_id}/audit_logs/search"
        params = {
            'version': audit_api_version,
            'size': audit_size
        }

        if cursor:
            params['cursor'] = cursor
        else:
            now = time.time()
            params['from'] = _iso(now - lookback_seconds)
            params['to'] = _iso(now)

        while pages < max_pages:
            url = f"{base}?{urllib.parse.urlencode(params, doseq=True)}"
            payload = _http_get(url, headers)
            _write_page(bucket, prefix, 'audit', payload)

            data_items = (payload.get('data') or {}).get('items') or []
            if isinstance(data_items, list):
                total += len(data_items)

            nxt = _next_href(payload.get('links'))
            if not nxt:
                break

            q = parse_qs(urlparse(nxt).query)
            cur = (q.get('cursor') or [None])[0]
            if not cur:
                break

            params = {
                'version': audit_api_version,
                'size': audit_size,
                'cursor': cur
            }
            state['audit_cursor'] = cur
            pages += 1

        return {
            'pages': pages + 1 if total else pages,
            'items': total,
            'cursor': state.get('audit_cursor')
        }

    def pull_issues(bucket, prefix, state, api_base, snyk_token, group_id,
                    issues_api_version, issues_limit, max_pages):
        """Pull issues from Snyk Group API."""
        headers = {
            'Authorization': f'token {snyk_token}',
            'Accept': 'application/vnd.api+json',
        }

        cursor = state.get('issues_cursor')
        pages = 0
        total = 0
        base = f"{api_base}/groups/{group_id}/issues"
        params = {
            'version': issues_api_version,
            'limit': issues_limit
        }

        if cursor:
            params['starting_after'] = cursor

        while pages < max_pages:
            url = f"{base}?{urllib.parse.urlencode(params, doseq=True)}"
            payload = _http_get(url, headers)
            _write_page(bucket, prefix, 'issues', payload)

            data_items = payload.get('data') or []
            if isinstance(data_items, list):
                total += len(data_items)

            nxt = _next_href(payload.get('links'))
            if not nxt:
                break

            q = parse_qs(urlparse(nxt).query)
            cur = (q.get('starting_after') or [None])[0]
            if not cur:
                break

            params = {
                'version': issues_api_version,
                'limit': issues_limit,
                'starting_after': cur
            }
            state['issues_cursor'] = cur
            pages += 1

        return {
            'pages': pages + 1 if total else pages,
            'items': total,
            'cursor': state.get('issues_cursor')
        }
    ```

    • Segundo archivo: requirements.txt:

      functions-framework==3.*
google-cloud-storage==2.*

  3. Haz clic en Implementar para guardar y, luego, implementar la función.

  4. Espera a que se complete la implementación (de 2 a 3 minutos).

Crea un trabajo de Cloud Scheduler

Cloud Scheduler publica mensajes en el tema de Pub/Sub a intervalos regulares, lo que activa la función de Cloud Run.

  1. En Google Cloud Console, ve a Cloud Scheduler.
  2. Haz clic en Crear trabajo.

  3. Proporciona los siguientes detalles de configuración:

    Parámetro de configuración Valor
    Nombre snyk-group-logs-hourly
    Región Selecciona la misma región que la función de Cloud Run
    Frecuencia 0 * * * * (cada hora en punto)
    Zona horaria Selecciona la zona horaria (se recomienda UTC)
    Tipo de objetivo Pub/Sub
    Tema Selecciona el tema snyk-logs-trigger.
    Cuerpo del mensaje {} (objeto JSON vacío)

  4. Haz clic en Crear.

Opciones de frecuencia de programación

  • Elige la frecuencia según los requisitos de volumen y latencia de los registros:

    Frecuencia Expresión cron Caso de uso
    Cada 5 minutos */5 * * * * Alto volumen y baja latencia
    Cada 15 minutos */15 * * * * Volumen medio
    Cada 1 hora 0 * * * * Estándar (recomendado)
    Cada 6 horas 0 */6 * * * Procesamiento por lotes de bajo volumen
    Diario 0 0 * * * Recopilación de datos históricos

Prueba el trabajo del programador

  1. En la consola de Cloud Scheduler, busca tu trabajo.
  2. Haz clic en Forzar ejecución para activar el DAG de forma manual.
  3. Espera unos segundos y ve a Cloud Run > Servicios > snyk-group-logs-collector > Registros.
  4. Verifica que la función se haya ejecutado correctamente.
  5. Verifica el bucket de GCS para confirmar que se escribieron los registros.

Recupera la cuenta de servicio de Google SecOps

Google SecOps usa una cuenta de servicio única para leer datos de tu bucket de GCS. Debes otorgar acceso a tu bucket a esta cuenta de servicio.

Obtén el correo electrónico de la cuenta de servicio

  1. Ve a Configuración de SIEM > Feeds.
  2. Haz clic en Add New Feed.
  3. Haz clic en Configura un feed único.
  4. En el campo Nombre del feed, ingresa un nombre para el feed (por ejemplo, Snyk Group Audit/Issues).
  5. Selecciona Google Cloud Storage V2 como el Tipo de fuente.
  6. Selecciona Snyk Group level audit/issues logs como Tipo de registro.

  7. Haz clic en Obtener cuenta de servicio. Se muestra un correo electrónico de la cuenta de servicio único, por ejemplo:

    chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com

  8. Copia esta dirección de correo electrónico para usarla en el siguiente paso.

Otorga permisos de IAM a la cuenta de servicio de Google SecOps

La cuenta de servicio de Google SecOps necesita el rol de visualizador de objetos de Storage en tu bucket de GCS.

  1. Ve a Cloud Storage > Buckets.
  2. Haz clic en el nombre de tu bucket.
  3. Ve a la pestaña Permisos.
  4. Haz clic en Otorgar acceso.
  5. Proporciona los siguientes detalles de configuración:
    • Agregar entidades: Pega el correo electrónico de la cuenta de servicio de Google SecOps.
    • Asignar roles: Selecciona Visualizador de objetos de Storage.

  6. Haz clic en Guardar.

Configura un feed en Google SecOps para transferir registros de Snyk Group

  1. Ve a Configuración de SIEM > Feeds.
  2. Haz clic en Add New Feed.
  3. Haz clic en Configura un feed único.
  4. En el campo Nombre del feed, ingresa un nombre para el feed (por ejemplo, Snyk Group Audit/Issues).
  5. Selecciona Google Cloud Storage V2 como el Tipo de fuente.
  6. Selecciona Snyk Group level audit/issues logs como Tipo de registro.
  7. Haz clic en Siguiente.

  8. Especifica valores para los siguientes parámetros de entrada:

    • URL del bucket de almacenamiento: Ingresa el URI del bucket de GCS con la ruta de acceso del prefijo:

      gs://snyk-group-logs/snyk/group/

      • Reemplaza lo siguiente:

        • snyk-group-logs: Es el nombre de tu bucket de GCS.
        • snyk/group/: Es el prefijo o la ruta de carpeta opcional en la que se almacenan los registros (déjalo vacío para la raíz).

      • Ejemplos:

        • Bucket raíz: gs://company-logs/
        • Con prefijo: gs://company-logs/snyk-logs/
        • Con subcarpeta: gs://company-logs/snyk/group/
    • Opción de eliminación del código fuente: Selecciona la opción de eliminación según tu preferencia:
      • Nunca: Nunca borra ningún archivo después de las transferencias (se recomienda para las pruebas).
      • Borrar archivos transferidos: Borra los archivos después de que se transfirieron correctamente.
      • Borrar los archivos transferidos y los directorios vacíos: Borra los archivos y los directorios vacíos después de que se transfirieron correctamente.
    • Antigüedad máxima del archivo: Incluye los archivos modificados en la cantidad de días especificada. El valor predeterminado es de 180 días.
    • Espacio de nombres del activo: Es el espacio de nombres del activo (por ejemplo, snyk.group).
    • Etiquetas de transferencia: Es la etiqueta que se aplicará a los eventos de este feed.

  9. Haz clic en Siguiente.

  10. Revisa la nueva configuración del feed en la pantalla Finalizar y, luego, haz clic en Enviar.

Tabla de asignación de UDM

Campo de registro Asignación de UDM Lógica
gitignore_label additional.fields Combinado
limit_label additional.fields Combinado
version_label additional.fields Combinado
created metadata.event_timestamp Se analizó como RFC3339
org_created metadata.event_timestamp Se analizó como RFC3339
project_created metadata.event_timestamp Se analizó como RFC3339
project_lastTestedDate metadata.event_timestamp Se analizó como RFC3339
has_principal metadata.event_type Asignado: true → NETWORK_CONNECTION, true → STATUS_UPDATE
eventdata metadata.product_event_type Asignada directamente
content.http_method network.http.method Asignada directamente
content.requestId network.session_id Asignada directamente
org_name principal.administrative_domain Asignada directamente
snyk_request_id_label principal.resource.attribute.labels Combinado
org_url principal.url Asignada directamente
groupcreated_label principal.user.attribute.labels Combinado
groupname_label principal.user.attribute.labels Combinado
groupurl_label principal.user.attribute.labels Combinado
orgId_label principal.user.attribute.labels Combinado
orggroupid_label principal.user.attribute.labels Combinado
orgslug_label principal.user.attribute.labels Combinado
groupId principal.user.groupid Asignada directamente
org_group_name principal.user.groupid Asignada directamente
issueCountsBySeverity_critical_label security_result.about.labels Combinado
issueCountsBySeverity_high_label security_result.about.labels Combinado
issueCountsBySeverity_low_label security_result.about.labels Combinado
issueCountsBySeverity_medium_label security_result.about.labels Combinado
content.action security_result.action_details Asignada directamente
project_type target.application Asignada directamente
branch_label target.resource.attribute.labels Combinado
id_label target.resource.attribute.labels Combinado
imageTag_label target.resource.attribute.labels Combinado
isMonitored_label target.resource.attribute.labels Combinado
origin_label target.resource.attribute.labels Combinado
project_id_label target.resource.attribute.labels Combinado
readOnly_label target.resource.attribute.labels Combinado
testFrequency_label target.resource.attribute.labels Combinado
totalDependencies_label target.resource.attribute.labels Combinado
project_id target.resource.id Asignada directamente
project_name target.resource.name Asignada directamente
content_url target.url Asignada directamente
project_browseUrl target.url Asignada directamente
N/A metadata.event_type Constante: NETWORK_CONNECTION
N/A metadata.product_name Constante: SNYK_ISSUES
N/A metadata.vendor_name Constante: SNYK_ISSUES

Registro de cambios

Consulta el registro de cambios de este analizador

¿Necesitas más ayuda? Obtén respuestas de miembros de la comunidad y profesionales de Google SecOps.