Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Recopila registros de PingOne Advanced Identity Cloud

Compatible con:

Google SecOps SIEM

En este documento, se explica cómo transferir registros de PingOne Advanced Identity Cloud (anteriormente, ForgeRock Identity Cloud) a Google Security Operations con Google Cloud Storage V2.

PingOne Advanced Identity Cloud es una plataforma de identidad como servicio (IDaaS) nativa de la nube que proporciona capacidades de administración de identidades, administración de accesos y gobierno de identidades. Permite a las organizaciones administrar las identidades de los usuarios, aplicar políticas de autenticación, incluida la autenticación de varios factores, y proporcionar inicio de sesión único en todas las aplicaciones, a la vez que se mantiene el cumplimiento y la seguridad.

Para obtener más información, consulta la documentación de ForgeRock Identity Cloud.

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 servicios de Cloud Run, temas de Pub/Sub y trabajos de Cloud Scheduler
Acceso con privilegios a la consola del administrador de PingOne Advanced Identity Cloud (administrador del arrendatario)
Una clave y un secreto de la API de registro de PingOne Advanced Identity Cloud con acceso a los extremos de supervisión

Crea un bucket de Google Cloud Storage

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

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, `forgerock-identity-cloud-logs`).
Tipo de ubicación	Elige según tus necesidades (región, birregional, 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

Haz clic en Crear.

Crea una clave de la API de registro en PingOne Advanced Identity Cloud

PingOne Advanced Identity Cloud usa claves de la API de Logs para autenticar solicitudes al extremo /monitoring/logs. Esto es independiente de las cuentas de servicio, que se usan para las operaciones de AM/IDM.

Crea la clave de API

Accede a la Consola del administrador de PingOne Advanced Identity Cloud en https://<tenant-env-fqdn>/platform/admin (por ejemplo, https://openam-mycompany-ew2.id.forgerock.io/platform/admin).
Haz clic en el menú de arrendatario (esquina superior derecha).
Haz clic en Configuración del arrendatario.
Haz clic en la pestaña Configuración global.
Haz clic en Log API Keys.
Haz clic en New Log API Key.
Ingresa un nombre descriptivo (por ejemplo, chronicle-log-collector).
Haz clic en Crear.
Copia y guarda los siguientes valores de forma segura:
- api_key_id: Es el identificador de la clave de API.
- api_key_secret: Es el secreto de la clave de API.
Nota: El secreto de la clave de API solo se muestra una vez durante la creación. Si la pierdes, deberás crear una nueva clave de la API de Logs.

Obtén el FQDN de tu entorno de usuario

Accede a la Consola del administrador de PingOne Advanced Identity Cloud.
Haz clic en el menú de arrendatario (esquina superior derecha).
Haz clic en Configuración del arrendatario.
En Detalles, anota el valor de Nombre del arrendatario.
- Formato de producción: openam-<base-name>-<data-region>.id.forgerock.io
- Formato de desarrollo: openam-<base-name>-<data-region>-dev.id.forgerock.io
- Formato de zona de pruebas: openam-<sandbox-name>.forgeblocks.com

Prueba el acceso a la API

Prueba tus credenciales antes de continuar con la integración:

# Replace with your actual tenant FQDN and credentials
TENANT_FQDN="openam-mycompany-ew2.id.forgerock.io"
API_KEY="<your-api-key-id>"
API_SECRET="<your-api-key-secret>"

# List available log sources
curl -v \
    -H "x-api-key: ${API_KEY}" \
    -H "x-api-secret: ${API_SECRET}" \
    "https://${TENANT_FQDN}/monitoring/logs/sources?_prettyPrint=true"

# Retrieve recent audit logs
curl -v \
    -H "x-api-key: ${API_KEY}" \
    -H "x-api-secret: ${API_SECRET}" \
    "https://${TENANT_FQDN}/monitoring/logs?source=am-authentication&_pageSize=5"

Una respuesta correcta devuelve el código HTTP 200 con un objeto JSON que contiene entradas de registro. Si recibes un error HTTP 401, verifica la clave y el secreto de la API. Si recibes el error HTTP 429, significa que superaste el límite de frecuencia de 60 solicitudes por minuto.

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 y ser invocada por Pub/Sub.

Crear cuenta de servicio

En Google Cloud Console, ve a IAM y administración > Cuentas de servicio.
Haz clic en Crear cuenta de servicio.
Proporciona los siguientes detalles de configuración:
- Nombre de la cuenta de servicio: Ingresa forgerock-logs-collector-sa.
- Descripción de la cuenta de servicio: Ingresa Service account for Cloud Run function to collect PingOne Advanced Identity Cloud logs.
Haz clic en Crear y continuar.
En la sección Otorga a esta cuenta de servicio acceso al proyecto, agrega los siguientes roles:
1. Haz clic en Selecciona 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.
Haz clic en Continuar.
Haz clic en Listo.

Estos roles son necesarios para las siguientes acciones:

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:

Ve a Cloud Storage > Buckets.
Haz clic en el nombre de tu bucket (por ejemplo, forgerock-identity-cloud-logs).
Ve a la pestaña Permisos.
Haz clic en Otorgar acceso.
Proporciona los siguientes detalles de configuración:
- Agregar entidades: Ingresa el correo electrónico de la cuenta de servicio (por ejemplo, forgerock-logs-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
- Asignar roles: Selecciona Administrador de objetos de almacenamiento.
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.

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

Crea una función de Cloud Run para recopilar registros

La función de Cloud Run se activará con mensajes de Pub/Sub de Cloud Scheduler para recuperar registros de la API de supervisión de PingOne Advanced Identity Cloud y escribirlos en GCS.

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

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

Parámetro de configuración	Valor
Nombre del servicio	`forgerock-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.

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 forgerock-logs-trigger.
4. Haz clic en Guardar.
En la sección Autenticación, haz lo siguiente:
1. Selecciona Necesita autenticación.
2. Verifica Identity and Access Management (IAM).
Nota: Pub/Sub controlará automáticamente la autenticación cuando invoque la función.
Desplázate hacia abajo y expande Contenedores, redes y seguridad.
Ve a la pestaña Seguridad:
- Cuenta de servicio: Selecciona forgerock-logs-collector-sa.

Ve a la pestaña Contenedores:

Haz clic en Variables y secretos.
Haz clic en + Agregar variable para cada variable de entorno:

Nombre de la variable	Valor de ejemplo	Descripción
`GCS_BUCKET`	`forgerock-identity-cloud-logs`	Nombre del bucket de GCS
`GCS_PREFIX`	`forgerock-logs`	Prefijo para los archivos de registro
`STATE_KEY`	`forgerock-logs/state.json`	Ruta de acceso al archivo de estado
`TENANT_FQDN`	`openam-mycompany-ew2.id.forgerock.io`	FQDN del entorno de usuario de PingOne AIC
`API_KEY`	`<your-api-key-id>`	ID de la clave de API de registro de PingOne AIC
`API_SECRET`	`<your-api-key-secret>`	Secret de la clave de API de PingOne AIC Log
`LOG_SOURCES`	`am-authentication,am-access,am-activity,am-config,idm-access,idm-activity,idm-authentication,idm-sync`	Fuentes de registros separadas por comas
`MAX_RECORDS`	`5000`	Cantidad máxima de registros por fuente y por ejecución
`PAGE_SIZE`	`1000`	Registros por página (máx. 1,000)
`LOOKBACK_HOURS`	`24`	Período de visualización inicial

En la sección Variables y Secrets, desplázate hacia abajo hasta Solicitudes:
- Tiempo de espera de la solicitud: Ingresa 600 segundos (10 minutos).
Ve a la pestaña Configuración:
- En la sección Recursos, haz lo siguiente:
  - Memoria: Selecciona 512 MiB o más.
  - CPU: Selecciona 1.
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).
Haz clic en Crear.
Espera a que se cree el servicio (de 1 a 2 minutos).
Después de crear el servicio, se abrirá automáticamente el editor de código intercalado.

Agregar el código de función

Ingresa main en el campo Punto de entrada.

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

main.py:

import functions_framework
from google.cloud import storage
import json
import os
import urllib3
from datetime import datetime, timezone, timedelta
import time

# 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', 'forgerock-logs')
STATE_KEY = os.environ.get('STATE_KEY', 'forgerock-logs/state.json')
TENANT_FQDN = os.environ.get('TENANT_FQDN')
API_KEY = os.environ.get('API_KEY')
API_SECRET = os.environ.get('API_SECRET')
LOG_SOURCES = os.environ.get('LOG_SOURCES', 'am-authentication,am-access,am-activity,idm-access,idm-activity,idm-authentication')
MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '5000'))
PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '1000'))
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)

@functions_framework.cloud_event
def main(cloud_event):
    """
    Cloud Run function triggered by Pub/Sub to fetch PingOne Advanced Identity Cloud
    logs and write to GCS.

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

    if not all([GCS_BUCKET, TENANT_FQDN, API_KEY, API_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()}")

        # Fetch logs for configured sources
        all_records = []
        newest_event_time = None
        sources = [s.strip() for s in LOG_SOURCES.split(',') if s.strip()]

        for source in sources:
            records, source_newest_time = fetch_logs(
                tenant_fqdn=TENANT_FQDN,
                api_key=API_KEY,
                api_secret=API_SECRET,
                source=source,
                start_time=last_time,
                end_time=now,
                page_size=PAGE_SIZE,
                max_records=MAX_RECORDS,
            )
            all_records.extend(records)

            if source_newest_time:
                if newest_event_time is None or parse_datetime(source_newest_time) > parse_datetime(newest_event_time):
                    newest_event_time = source_newest_time

            print(f"Source '{source}': {len(records)} records")

        if not all_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 all_records]) + '\n'
        blob.upload_from_string(ndjson, content_type='application/x-ndjson')

        print(f"Wrote {len(all_records)} records to gs://{GCS_BUCKET}/{object_key}")

        # 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(all_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(tenant_fqdn: str, api_key: str, api_secret: str, source: str, start_time: datetime, end_time: datetime, page_size: int, max_records: int):
    """
    Fetch logs from PingOne Advanced Identity Cloud Monitoring API with pagination.

    Args:
        tenant_fqdn: Tenant environment FQDN
        api_key: Log API key ID
        api_secret: Log API key secret
        source: Log source (am-authentication, am-access, idm-access, etc.)
        start_time: Start time for log query
        end_time: End time for log query
        page_size: Number of records per page (max 1000)
        max_records: Maximum total records to fetch

    Returns:
        Tuple of (records list, newest_event_time ISO string)
    """
    endpoint = f"https://{tenant_fqdn}/monitoring/logs"

    headers = {
        'x-api-key': api_key,
        'x-api-secret': api_secret,
        'Accept': 'application/json',
        'User-Agent': 'GoogleSecOps-ForgeRockCollector/1.0'
    }

    records = []
    newest_time = None
    page_num = 0
    backoff = 1.0

    begin_time = start_time.strftime('%Y-%m-%dT%H:%M:%SZ')
    end_time_str = end_time.strftime('%Y-%m-%dT%H:%M:%SZ')
    paged_results_cookie = None

    while True:
        page_num += 1

        if len(records) >= max_records:
            print(f"Reached max_records limit ({max_records})")
            break

        current_limit = min(page_size, max_records - len(records))
        url = f"{endpoint}?source={source}&beginTime={begin_time}&endTime={end_time_str}&_pageSize={current_limit}"

        if paged_results_cookie:
            url += f"&_pagedResultsCookie={paged_results_cookie}"

        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('result', [])

            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('timestamp')
                    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
            paged_results_cookie = data.get('pagedResultsCookie')
            if not paged_results_cookie or paged_results_cookie == "-1":
                print(f"Reached last page (no more results)")
                break

        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

requirements.txt:

functions-framework==3.*
google-cloud-storage==2.*
urllib3>=2.0.0

Haz clic en Implementar para guardar y, luego, implementar la función.
Espera a que se complete la implementación (de 2 a 3 minutos).

Nota: La configuración del activador de Pub/Sub crea automáticamente las suscripciones y los permisos necesarios.

Crea un trabajo de Cloud Scheduler

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

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

Proporciona los siguientes detalles de configuración:

Parámetro de configuración	Valor
Nombre	`forgerock-logs-collector-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	Seleccionar `forgerock-logs-trigger`
Cuerpo del mensaje	`{}` (objeto JSON vacío)

Haz clic en Crear.

Opciones de frecuencia de programación

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

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 y volumen bajo
Diario	`0 0 * * *`	Recopilación de datos históricos

Prueba la integración

En la consola de Cloud Scheduler, busca tu trabajo (forgerock-logs-collector-hourly).
Haz clic en Ejecutar forzosamente para activar el trabajo de forma manual.
Espera unos segundos.
Ve a Cloud Run > Servicios.
Haz clic en forgerock-logs-collector.
Haz clic en la pestaña Registros.

Verifica que la función se haya ejecutado correctamente. Busca lo siguiente:

Fetching logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
Source 'am-authentication': X records
Source 'am-access': X records
Wrote X records to gs://forgerock-identity-cloud-logs/forgerock-logs/logs_YYYYMMDD_HHMMSS.ndjson
Successfully processed X records

Ve a Cloud Storage > Buckets.
Haz clic en el nombre de tu bucket (forgerock-identity-cloud-logs).
Navega a la carpeta forgerock-logs/:
Verifica que se haya creado un archivo .ndjson nuevo con la marca de tiempo actual.

Si ves errores en los registros, haz lo siguiente:

HTTP 401: Verifica la clave y el secreto de la API de Log en las variables de entorno.
HTTP 403: Verifica que la clave de API no se haya revocado en PingOne Advanced Identity Cloud.
HTTP 429: Límite de frecuencia (60 solicitudes por minuto por entorno). La función volverá a intentarlo automáticamente con una espera exponencial.
Faltan variables de entorno: Verifica que estén configuradas todas las variables requeridas.

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

Ve a Configuración de SIEM > Feeds.
Haz clic en Agregar feed nuevo.
Haz clic en Configura un feed único.
En el campo Nombre del feed, ingresa un nombre para el feed (por ejemplo, ForgeRock Identity Cloud Logs).
Selecciona Google Cloud Storage V2 como el Tipo de fuente.
Selecciona ForgeRock Identity Cloud como el Tipo de registro.
Haz clic en Obtener cuenta de servicio. Se mostrará un correo electrónico único de la cuenta de servicio, por ejemplo:
```
chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com
```
Copia esta dirección de correo electrónico para usarla en el siguiente paso.

Nota: Cada instancia de Google SecOps tiene una cuenta de servicio única. No uses cuentas de servicio de otros ejemplos o documentación.
Haz clic en Siguiente.
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://forgerock-identity-cloud-logs/forgerock-logs/
```
  Nota: Siempre incluye la barra diagonal final (/) al final del URI.
- 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.
  Nota: Si seleccionas una opción de eliminación, la cuenta de servicio debe tener el rol de Administrador de objetos de Storage en lugar del rol de Visualizador de objetos de Storage. Actualiza los permisos de IAM según corresponda.
- Antigüedad máxima del archivo: Incluye los archivos modificados en la cantidad de días más reciente (el valor predeterminado es 180 días).
- Espacio de nombres del recurso: Es el espacio de nombres del recurso.
- Etiquetas de transferencia: Es la etiqueta que se aplicará a los eventos de este feed.
Haz clic en Siguiente.
Revisa la nueva configuración del feed en la pantalla Finalizar y, luego, haz clic en Enviar.

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.

Ve a Cloud Storage > Buckets.
Haz clic en el nombre de tu bucket (forgerock-identity-cloud-logs).
Ve a la pestaña Permisos.
Haz clic en Otorgar acceso.
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.
Haz clic en Guardar.

Nota: Si planeas usar la opción de eliminación "Borrar archivos transferidos" o "Borrar archivos transferidos y directorios vacíos", otorga el rol de Administrador de objetos de Storage en lugar del rol de Visualizador de objetos de Storage.

Tabla de asignación de UDM

Campo de registro	Asignación de UDM	Lógica
`aav_label`	`additional.fields`	Combinado
`detail_label`	`additional.fields`	Combinado
`id_label`	`additional.fields`	Combinado
`objectId_label`	`additional.fields`	Combinado
`secure_label`	`additional.fields`	Combinado
`source_label`	`additional.fields`	Combinado
`topic_label`	`additional.fields`	Combinado
`trackingId_list`	`additional.fields`	Combinado
`transactionId_label`	`additional.fields`	Combinado
`extensions`	`extensions`	Se cambió el nombre o se asignó
`metadata`	`metadata`	Se cambió el nombre o se asignó
`payload.eventName`	`metadata.product_event_type`	Asignado directamente
`network`	`network`	Se cambió el nombre o se asignó
`x-forwarded-proto`	`network.application_protocol`	Asignado directamente
`payload.http.request.method`	`network.http.method`	Asignado directamente
`value`	`network.http.response_code`	Se cambió el nombre o se asignó
`user-agent`	`network.http.user_agent`	Asignado directamente
`principal`	`principal`	Se cambió el nombre o se asignó
`host`	`principal.asset.hostname`	Asignado directamente
`payload.client.ip`	`principal.asset.ip`	Combinado
`xip`	`principal.asset.ip`	Combinado
`host`	`principal.hostname`	Asignado directamente
`entry.info.ipAddress`	`principal.ip`	Combinado
`payload.client.ip`	`principal.ip`	Combinado
`xip`	`principal.ip`	Combinado
`payload.client.port`	`principal.port`	Se cambió el nombre o se asignó
`user_distinguished_name`	`principal.user.attribute.labels`	Combinado
`payload.userId`	`principal.user.userid`	Asignado directamente
`userId`	`principal.user.userid`	Asignado directamente
`Security_Result`	`security_result`	Combinado
`target`	`target`	Se cambió el nombre o se asignó
`payload.applicationPrincipal.0`	`target.application`	Asignado directamente
`app_label`	`target.resource.attribute.labels`	Combinado
`realm_label`	`target.resource.attribute.labels`	Combinado
`payload.component`	`target.resource.name`	Asignado directamente
`payload.http.request.path`	`target.url`	Asignado directamente
N/A	`additional.fields`	Constante: `topic_label`
N/A	`extensions.auth.type`	Constante: `AUTHTYPE_UNSPECIFIED`
N/A	`metadata.event_type`	Constante: `USER_LOGIN`
N/A	`principal.asset.ip`	Constante: `payload.client.ip`
N/A	`principal.ip`	Constante: `payload.client.ip`
N/A	`principal.user.attribute.labels`	Constante: `user_distinguished_name`
N/A	`security_result`	Constante: `Security_Result`
N/A	`target.resource.attribute.labels`	Constante: `app_label`

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