Recopila registros de Metabase

Compatible con:

En este documento, se explica cómo transferir registros de Metabase a Google Security Operations con Google Cloud Storage V2.

Metabase es una plataforma de análisis e inteligencia empresarial de código abierto que permite a las organizaciones consultar bases de datos, crear visualizaciones y compilar paneles. En los planes Pro y Enterprise, Metabase almacena las estadísticas de uso y los datos de auditoría en su base de datos de aplicaciones, incluidos los registros de actividad, los registros de vistas y los registros de ejecución de consultas. Una función de Cloud Run consulta la API de Metabase para recuperar estos datos y los escribe en un bucket de GCS para que Google SecOps los transfiera.

Antes de comenzar

Asegúrate de cumplir con los siguientes requisitos previos:

  • Una instancia de Google SecOps
  • Un proyecto de GCP con las APIs de Cloud Storage, Cloud Run, Pub/Sub y Cloud Scheduler habilitadas
  • 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
  • Plan de Metabase Pro o Enterprise (las estadísticas de uso no están disponibles en las ediciones de código abierto o Cloud Starter)
  • Acceso de administrador de Metabase para crear claves de API
  • La base de datos de la aplicación de Metabase agregada como fuente de datos dentro de Metabase (obligatoria para consultar tablas de auditoría a través de la API)

Configura el acceso a la API de Metabase

Para permitir que Google SecOps recupere datos de estadísticas de uso, debes crear una clave de API en Metabase y agregar la base de datos de la aplicación como una fuente de datos que se pueda consultar.

Crea una clave de API

  1. Accede a tu instancia de Metabase como administrador.
  2. Haz clic en el ícono de ajustes de la esquina superior derecha.
  3. Selecciona Configuración de administrador.
  4. Vaya a la pestaña Configuración.
  5. Haz clic en la pestaña Autenticación en el menú de la izquierda.
  6. Desplázate hasta Claves de API y haz clic en Administrar.
  7. Haz clic en el botón Crear clave de API.
  8. Proporciona los siguientes detalles de configuración:
    • Nombre de la clave: Ingresa un nombre descriptivo (por ejemplo, Google SecOps Integration).
    • Grupo: Selecciona un grupo con acceso a la colección de estadísticas de uso y permisos de consulta para la base de datos de la aplicación.
  9. Haz clic en Crear.
  10. Copia y guarda la clave de API de forma segura.

Agrega la base de datos de la aplicación como fuente de datos

Para consultar las tablas de auditoría a través de la API, debes agregar la base de datos de la aplicación de Metabase como fuente de datos dentro de Metabase.

  1. En Metabase, haz clic en el ícono de ajustes de la esquina superior derecha.
  2. Selecciona Configuración de administrador.
  3. Ve a la pestaña Bases de datos.
  4. Haz clic en Agregar una base de datos.
  5. Configura la conexión de la base de datos:
    • Tipo de base de datos: Selecciona PostgreSQL o MySQL (según la base de datos de tu aplicación).
    • Nombre: Ingresa Metabase Application Database.
    • Host: Ingresa el nombre de host de la base de datos de tu aplicación.
    • Puerto: Ingresa el puerto de la base de datos (predeterminado: 5432 para PostgreSQL, 3306 para MySQL).
    • Nombre de la base de datos: Ingresa el nombre de la base de datos de la aplicación (por ejemplo, metabase).
    • Nombre de usuario: Ingresa un usuario de la base de datos con permisos SELECT en las tablas audit_log, view_log y query_execution
    • Contraseña: Ingresa la contraseña de la base de datos
  6. Haz clic en Guardar.
  7. Después de guardar, toma nota del ID de la base de datos de la URL (por ejemplo, https://metabase.example.com/admin/databases/5 significa que el ID de la base de datos es 5).

Verifica los permisos

Para verificar que la clave de API tenga los permisos necesarios, sigue estos pasos:

  1. Accede a Metabase como administrador.
  2. Haz clic en el ícono de ajustes > Configuración de administrador > Personas.
  3. Busca el grupo asignado a la clave de API.
  4. Verifica que el grupo tenga acceso a la colección Estadísticas de uso.
  5. Ve a Configuración de administrador > Permisos > Datos.
  6. Verifica que el grupo tenga acceso Sin restricciones o de Consulta a la base de datos de la aplicación.

Prueba el acceso a la API

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

    # Replace with your actual values
    METABASE_URL="https://your-metabase-instance.com"
    API_KEY="mb_your_api_key_here"
    DATABASE_ID="5"
    
    # Test API key authentication
    curl -s -H "x-api-key: ${API_KEY}" \
      "${METABASE_URL}/api/database" \
      | python3 -m json.tool
    
    # Test querying the application database for audit_log records
    curl -s -X POST "${METABASE_URL}/api/dataset/json" \
      -H "x-api-key: ${API_KEY}" \
      -H "Content-Type: application/json" \
      -d "{\"database\": ${DATABASE_ID}, \"type\": \"native\", \"native\": {\"query\": \"SELECT * FROM audit_log ORDER BY id DESC LIMIT 5\", \"template-tags\": {}}, \"parameters\": []}" \
      | python3 -m json.tool
    

Una respuesta correcta devuelve un array JSON de registros de auditoría recientes.

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 único a nivel global (por ejemplo, metabase-audit-logs).
    Tipo de ubicación Elige una en función de tus necesidades (región, 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.

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 que Pub/Sub la invoque.

Crear 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 metabase-audit-collector-sa
    • Descripción de la cuenta de servicio: Ingresa Service account for Cloud Run function to collect Metabase audit logs
  4. Haz clic en Crear y continuar.
  5. En la sección Otorga acceso al proyecto a esta cuenta de servicio, 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.
  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

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

Crear tema de Pub/Sub

  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 metabase-audit-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 activará con mensajes de Pub/Sub de Cloud Scheduler para recuperar datos de auditoría de la API de Metabase y escribirlos en GCS.

  1. En Google Cloud Console, ve a Cloud Run.
  2. Haz clic en Crear servicio.
  3. Selecciona Función (usa un editor directo 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 metabase-audit-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 metabase-audit-trigger.
    4. Haz clic en Guardar.
  6. En la sección Autenticación, haz lo siguiente:

    1. Selecciona Necesita autenticación.
    2. Verifica la Administración de identidades y accesos (IAM).
  7. Desplázate hacia abajo y expande Contenedores, redes y seguridad.

  8. Ve a la pestaña Seguridad:

    • Cuenta de servicio: Selecciona metabase-audit-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 Descripción
    GCS_BUCKET metabase-audit-logs Nombre del bucket de GCS
    GCS_PREFIX metabase-audit Prefijo para los archivos de registro
    STATE_KEY metabase-audit/state.json Ruta de acceso al archivo de estado
    METABASE_URL https://metabase.yourcompany.com URL base de la instancia de Metabase
    METABASE_API_KEY mb_your_api_key_here Clave de API de Metabase
    DATABASE_ID 5 ID de la base de datos de la aplicación
    LOOKBACK_HOURS 24 Período de visualización inicial
    PAGE_SIZE 2000 Registros por consulta a la API
  10. En la sección Variables y Secrets, 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 la sección Recursos, haz lo siguiente:
      • Memoria: Selecciona 512 MiB o más.
      • CPU: Selecciona 1.
  12. 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.
  13. Haz clic en Crear.

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

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

Agregar el código de función

  1. Ingresa main en el campo Punto de entrada.
  2. 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
      
      http = urllib3.PoolManager(
        timeout=urllib3.Timeout(connect=10.0, read=60.0),
        retries=False,
      )
      
      storage_client = storage.Client()
      
      GCS_BUCKET = os.environ.get('GCS_BUCKET')
      GCS_PREFIX = os.environ.get('GCS_PREFIX', 'metabase-audit')
      STATE_KEY = os.environ.get('STATE_KEY', 'metabase-audit/state.json')
      METABASE_URL = os.environ.get('METABASE_URL', '').rstrip('/')
      API_KEY = os.environ.get('METABASE_API_KEY')
      DATABASE_ID = int(os.environ.get('DATABASE_ID', '1'))
      LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))
      PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '2000'))
      
      TABLES = ['audit_log', 'view_log', 'query_execution']
      
      TABLE_TIME_COLUMNS = {
        'audit_log': 'timestamp',
        'view_log': 'timestamp',
        'query_execution': 'started_at',
      }
      
      @functions_framework.cloud_event
      def main(cloud_event):
        if not all([GCS_BUCKET, METABASE_URL, API_KEY]):
          print('Error: Missing required environment variables')
          return
      
        try:
          bucket = storage_client.bucket(GCS_BUCKET)
          state = load_state(bucket)
          now = datetime.now(timezone.utc)
      
          if isinstance(state, dict) and state.get('last_event_time'):
            try:
              last_val = state['last_event_time']
              if last_val.endswith('Z'):
                last_val = last_val[:-1] + '+00:00'
              last_time = datetime.fromisoformat(last_val)
              last_time = last_time - timedelta(minutes=2)
            except Exception as e:
              print(f"Warning: Could not parse last_event_time: {e}")
              last_time = now - timedelta(hours=LOOKBACK_HOURS)
          else:
            last_time = now - timedelta(hours=LOOKBACK_HOURS)
      
          print(f"Fetching logs from {last_time.isoformat()} to {now.isoformat()}")
      
          all_records = []
          newest_time = None
      
          for table in TABLES:
            time_col = TABLE_TIME_COLUMNS[table]
            records = fetch_table(table, time_col, last_time, now)
            for r in records:
              r['_metabase_table'] = table
              t = r.get(time_col)
              if t and (newest_time is None or str(t) > str(newest_time)):
                newest_time = t
            all_records.extend(records)
            print(f"Table {table}: fetched {len(records)} records")
      
          if not all_records:
            print("No new records found.")
            save_state(bucket, now.isoformat())
            return
      
          timestamp = now.strftime('%Y%m%d_%H%M%S')
          object_key = f"{GCS_PREFIX}/metabase_audit_{timestamp}.ndjson"
          blob = bucket.blob(object_key)
      
          ndjson = '\n'.join(
            [json.dumps(r, ensure_ascii=False, default=str) for r 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}")
      
          save_state(bucket, str(newest_time) if newest_time else now.isoformat())
      
          print(f"Successfully processed {len(all_records)} records")
      
        except Exception as e:
          print(f'Error processing logs: {str(e)}')
          raise
      
      def fetch_table(table, time_col, start_time, end_time):
        start_str = start_time.strftime('%Y-%m-%d %H:%M:%S')
        end_str = end_time.strftime('%Y-%m-%d %H:%M:%S')
      
        all_records = []
        offset = 0
        max_pages = 50
      
        for page in range(max_pages):
          sql = (
            f"SELECT * FROM {table} "
            f"WHERE {time_col} >= '{start_str}' "
            f"AND {time_col} < '{end_str}' "
            f"ORDER BY {time_col} ASC "
            f"LIMIT {PAGE_SIZE} OFFSET {offset}"
          )
      
          query_body = {
            "database": DATABASE_ID,
            "type": "native",
            "native": {
              "query": sql,
              "template-tags": {}
            },
            "parameters": []
          }
      
          url = f"{METABASE_URL}/api/dataset/json"
          response = http.request(
            'POST', url,
            body=json.dumps(query_body).encode('utf-8'),
            headers={
              'x-api-key': API_KEY,
              'Content-Type': 'application/json'
            }
          )
      
          if response.status == 429:
            print(f"Rate limited on {table} query. Stopping pagination.")
            break
      
          if response.status != 200:
            print(f"{table} query failed: {response.status} - "
                f"{response.data.decode('utf-8')}")
            break
      
          page_results = json.loads(response.data.decode('utf-8'))
      
          if not page_results:
            break
      
          all_records.extend(page_results)
          print(f"{table} page {page + 1}: {len(page_results)} records "
              f"(total: {len(all_records)})")
      
          if len(page_results) < PAGE_SIZE:
            break
      
          offset += PAGE_SIZE
      
        return all_records
      
      def load_state(bucket):
        try:
          blob = bucket.blob(STATE_KEY)
          if blob.exists():
            return json.loads(blob.download_as_text())
        except Exception as e:
          print(f"Warning: Could not load state: {e}")
        return {}
      
      def save_state(bucket, last_event_time_iso):
        try:
          state = {
            'last_event_time': last_event_time_iso,
            'last_run': datetime.now(timezone.utc).isoformat()
          }
          blob = bucket.blob(STATE_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}")
      
    • requirements.txt:

    functions-framework==3.*
    google-cloud-storage==2.*
    urllib3>=2.0.0
    
  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

  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 metabase-audit-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 metabase-audit-trigger
    Cuerpo del mensaje {} (objeto JSON vacío)
  4. 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 de bajo volumen
Diario 0 0 * * * Recopilación de datos históricos

Prueba la integración

  1. En la consola de Cloud Scheduler, busca tu trabajo (metabase-audit-collector-hourly).
  2. Haz clic en Forzar ejecución para activar el trabajo de forma manual.
  3. Espera unos segundos.
  4. Ve a Cloud Run > Servicios.
  5. Haz clic en metabase-audit-collector:
  6. Haz clic en la pestaña Registros.
  7. 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
    Table audit_log: fetched X records
    Table view_log: fetched X records
    Table query_execution: fetched X records
    Wrote X records to gs://metabase-audit-logs/metabase-audit/metabase_audit_YYYYMMDD_HHMMSS.ndjson
    Successfully processed X records
    
  8. Ve a Cloud Storage > Buckets.

  9. Haz clic en metabase-audit-logs:

  10. Navega a la carpeta metabase-audit/:

  11. 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 que la variable de entorno METABASE_API_KEY sea correcta y que la clave no se haya borrado ni regenerado.
  • HTTP 403: Verifica que el grupo de la clave de API tenga permisos de consulta para la base de datos de la aplicación.
  • HTTP 429: Límite de frecuencia: la función detendrá la paginación y se reanudará en la próxima ejecución programada.
  • Faltan variables de entorno: Verifica que todas las variables requeridas estén configuradas en la configuración de la función de Cloud Run.
  • Resultados vacíos: Verifica que el DATABASE_ID sea correcto, que la base de datos de la aplicación se haya agregado como fuente de datos y que estés usando Metabase Pro o Enterprise.

Recupera la cuenta de servicio de Google SecOps

  1. Ve a Configuración > Administración de datos > Feeds. Si estás en una plataforma solo de SIEM, ve a Configuración > Feeds.
  2. Haz clic en Agregar feed nuevo.
  3. Haz clic en Configura un feed único.
  4. En el campo Nombre del feed, ingresa un nombre para el feed (por ejemplo, Metabase Audit Logs).
  5. Selecciona Google Cloud Storage V2 como el Tipo de fuente.
  6. Selecciona METABASE como el Tipo de registro.
  7. 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
    
  8. Copia esta dirección de correo electrónico para usarla en el siguiente paso.

  9. Haz clic en Siguiente.

  10. 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://metabase-audit-logs/metabase-audit/
      
    • 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 última cantidad de días (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.

  11. Haz clic en Siguiente.

  12. Revisa la configuración de tu feed de noticias nuevo 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.

  1. Ve a Cloud Storage > Buckets.
  2. Haz clic en metabase-audit-logs:
  3. Ve a la pestaña Permisos.
  4. Haz clic en Otorgar acceso.
  5. Proporciona los siguientes detalles de configuración:
    • Agregar principales: Pega el correo electrónico de la cuenta de servicio de Google SecOps.
    • Asigna roles: Selecciona Visualizador de objetos de Storage.
  6. Haz clic en Guardar.

Tablas de estadísticas de uso

La función de Cloud Run consulta las siguientes tablas de la base de datos de la aplicación de Metabase:

Nombre de la tabla Descripción
audit_log Registros de cambios de configuración, acciones de los usuarios y eventos del sistema
view_log Realiza un seguimiento de las vistas de tarjetas (preguntas o modelos), paneles y tablas.
query_execution Información sobre todas las consultas ejecutadas en todos los paneles

Retención de datos

De forma predeterminada, Metabase conserva los datos de las estadísticas de uso durante 720 días (aproximadamente 2 años). Dos veces al día, Metabase borra automáticamente las filas que superan este umbral. Para cambiar el período de retención, configura la variable de entorno MB_AUDIT_MAX_RETENTION_DAYS cuando ejecutes Metabase.

Tabla de asignación de UDM

Campo de registro Asignación de UDM Lógica
adicional adicional Se cambió el nombre de adicional
Configuración regional additional.fields Se combinan con las etiquetas respectivas (p. ej., locale_label para locale, is_active_label para is_active, etc.).
is_active additional.fields
is_qbnewb additional.fields
group_ids additional.fields
is_superuser additional.fields
login_attributes additional.fields
id additional.fields
sso_source additional.fields
personal_collection_id additional.fields
metadatos metadatos Se cambió el nombre de los metadatos
updated_at metadata.event_timestamp Fecha analizada de updated_at con ISO8601, RFC 3339 o yyyy-MM-ddTHH:mm:ss.SSSSSSZ
has_userid metadata.event_type Se establece en "USER_UNCATEGORIZED" si has_userid == "true"; de lo contrario, se establece en "GENERIC_EVENT".
entidad entidad Se cambió el nombre de la principal
metabase_host principal.url El valor se copia directamente.
date_joined principal.user.attribute.creation_time Fecha analizada de date_joined con ISO8601, RFC 3339 o yyyy-MM-ddTHH:mm:ss.SSSSSSZ
correo electrónico principal.user.email_addresses Combinado desde el correo electrónico
first_name principal.user.first_name El valor se copia directamente.
last_login principal.user.last_login_time Fecha analizada de last_login con ISO8601, RFC 3339 o yyyy-MM-ddTHH:mm:ss.SSSSSSZ
last_name principal.user.last_name El valor se copia directamente.
common_name principal.user.user_display_name El valor se copia directamente.
correo electrónico principal.user.userid Valor copiado directamente del correo electrónico
security_result security_result Combinado de security_result
objetivo objetivo Se cambió el nombre del destino
metadata.product_name metadata.product_name Establece el valor en "METABASE".
metadata.vendor_name metadata.vendor_name Establece el valor en "METABASE".

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.