Raccogliere i log dell'attività utente di Workday

Supportato in:

Questo documento spiega come importare i log di attività utente di Workday in Google Security Operations utilizzando Cloud Storage V2.

Workday è una piattaforma cloud di gestione del capitale umano (HCM) e finanziaria che genera log di attività utente, autenticazione e controllo di sicurezza. L'API REST User Activity Logging fornisce l'accesso programmatico a questi log.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

  • Un'istanza Google SecOps
  • Un progetto Google Cloud con {storage_api} abilitata
  • Autorizzazioni per creare e gestire bucket Cloud Storage
  • Autorizzazioni per gestire i criteri IAM (Identity and Access Management) nei bucket Cloud Storage
  • Autorizzazioni per creare servizi Cloud Run, argomenti Pub/Sub e job Cloud Scheduler
  • Accesso privilegiato a Workday con autorizzazioni di amministratore della sicurezza o equivalenti
  • Logging dell'attività utente abilitato nel tenant Workday

Crea un bucket Cloud Storage

  1. Vai alla consoleGoogle Cloud .
  2. Seleziona il tuo progetto o creane uno nuovo.
  3. Nel menu di navigazione, vai a Cloud Storage > Bucket.
  4. Fai clic su Crea bucket.

  5. Fornisci i seguenti dettagli di configurazione:

    Impostazione Valore
    Assegna un nome al bucket Inserisci un nome univoco globale (ad esempio workday-activity-logs).
    Tipo di località Scegli in base alle tue esigenze (regione singola, a due regioni, multiregionale)
    Località Seleziona la posizione (ad esempio, us-central1).
    Classe di archiviazione Standard (consigliato per i log a cui si accede di frequente)
    Controllo degli accessi Uniforme (consigliato)
    Strumenti di protezione (Facoltativo) Abilita il controllo delle versioni degli oggetti o la policy di conservazione

  6. Fai clic su Crea.

Raccogliere le credenziali API di Workday

Abilita il logging delle attività utente

  1. Accedi al tuo tenant Workday come amministratore della sicurezza.
  2. Nella barra di ricerca di Workday, cerca e apri l'attività Modifica configurazione tenant - Sistema.
  3. Nella sezione Sicurezza, seleziona la casella di controllo Abilita il logging dell'attività utente.
  4. Fai clic su Ok per salvare le modifiche.

Crea un utente di sistema di integrazione (ISU)

  1. Nella barra di ricerca di Workday, cerca Create Integration System User.
  2. Inserisci un Nome utente (ad esempio, ISU_SIEM_Export) e una Password efficace.
  3. Deseleziona la casella di controllo Richiedi nuova password al prossimo accesso.
  4. Fai clic su OK.
  5. Cerca Crea gruppo di sicurezza e crea un Integration System Security Group (Unconstrained).
  6. Aggiungi l'ISU (ISU_SIEM_Export) a questo gruppo di sicurezza.
  7. Cerca Visualizza dominio e individua il dominio Registrazione attività utente. Concedi l'accesso Get al gruppo di sicurezza ISU per questo dominio.
  8. Cerca Attiva modifiche ai criteri di sicurezza in attesa e attiva le modifiche.

Registra un client API per OAuth

  1. Nella barra di ricerca di Workday, cerca Register API Client for Integrations.
  2. Inserisci un Nome client (ad esempio SIEM_OAuth_Client).
  3. Seleziona l'opzione Token di aggiornamento senza scadenza.
  4. Aggiungi l'ambito: Sistema (o l'ambito richiesto per l'API User Activity Logging).
  5. Fai clic su OK.
  6. Copia e salva i seguenti dettagli in una posizione sicura:
    • ID client: l'identificatore del client API.
    • Client secret: il client secret dell'API.
  7. Cerca Gestisci i token di aggiornamento per le integrazioni.
  8. Seleziona l'account ISU (ISU_SIEM_Export).
  9. Genera un nuovo token di aggiornamento per il client API.
  10. Copia e salva il token di aggiornamento.

Determinare l'URL del tenant

L'endpoint API si basa sul tuo tenant Workday. Il formato è:

Componente Valore
Endpoint token https://HOST/ccx/oauth2/TENANT/token
API Activity Logging https://HOST/ccx/api/privacy/v1/TENANT/activityLogging

Verifica le autorizzazioni

Per verificare che l'unità organizzativa disponga delle autorizzazioni necessarie:

  1. Accedi a Workday come amministratore della sicurezza.
  2. Cerca View Integration System User (Visualizza utente di sistema di integrazione) e seleziona l'utente di sistema di integrazione (ISU_SIEM_Export).
  3. Verifica che l'utente sia membro del gruppo di sicurezza con accesso Get al dominio Registrazione dell'attività utente.
  4. Se l'accesso non è presente, aggiorna il gruppo di sicurezza e attiva le modifiche in attesa del criterio di sicurezza.

Testare l'accesso API

  • Testa le tue credenziali prima di procedere con l'integrazione:

    ```bash
# Replace with your actual credentials
CLIENT_ID="your-client-id"
CLIENT_SECRET="your-client-secret"
REFRESH_TOKEN="your-refresh-token"
HOST="your-workday-host"
TENANT="your-tenant"

# Get OAuth access token
TOKEN=$(curl -s -X POST "https://${HOST}/ccx/oauth2/${TENANT}/token" \
    -H "Content-Type: application/x-www-form-urlencoded" \
    -d "grant_type=refresh_token&client_id=${CLIENT_ID}&client_secret=${CLIENT_SECRET}&refresh_token=${REFRESH_TOKEN}" \
    | jq -r '.access_token')

# Test API access
curl -v -H "Authorization: Bearer ${TOKEN}" \
    "https://${HOST}/ccx/api/privacy/v1/${TENANT}/activityLogging?from=2024-01-01T00:00:00Z&to=2024-01-01T01:00:00Z"
```

Crea un account di servizio per la funzione Cloud Run

La funzione Cloud Run richiede un account di servizio con autorizzazioni per scrivere in un bucket Cloud Storage e per essere richiamato da Pub/Sub.

Crea il account di servizio

  1. Nella console Google Cloud, vai a IAM e amministrazione > Service account.
  2. Fai clic su Crea account di servizio.
  3. Fornisci i seguenti dettagli di configurazione:
    • Nome service account: inserisci workday-activity-collector-sa.
    • Descrizione del service account: inserisci Service account for Cloud Run function to collect Workday User Activity logs.
  4. Fai clic su Crea e continua.
  5. Nella sezione Concedi a questo account di servizio l'accesso al progetto, aggiungi i seguenti ruoli:
    1. Fai clic su Seleziona un ruolo.
    2. Cerca e seleziona Storage Object Admin.
    3. Fai clic su + Aggiungi un altro ruolo.
    4. Cerca e seleziona Cloud Run Invoker.
    5. Fai clic su + Aggiungi un altro ruolo.
    6. Cerca e seleziona Cloud Functions Invoker.
  6. Fai clic su Continua.
  7. Fai clic su Fine.

Questi ruoli sono necessari per:

  • Storage Object Admin: scrive i log nel bucket Cloud Storage e gestisce i file di stato
  • Cloud Run Invoker: consente a Pub/Sub di richiamare la funzione
  • Cloud Functions Invoker: consente la chiamata di funzioni

Concedere le autorizzazioni IAM sul bucket Cloud Storage

Concedi al account di servizio le autorizzazioni di scrittura sul bucket Cloud Storage nel seguente modo:

  1. Vai a Cloud Storage > Bucket.
  2. Fai clic sul nome del bucket (ad esempio workday-activity-logs).
  3. Vai alla scheda Autorizzazioni.
  4. Fai clic su Concedi l'accesso.
  5. Fornisci i seguenti dettagli di configurazione:
    • Aggiungi entità: inserisci l'email del account di servizio (ad esempio, workday-activity-collector-sa@your-project.iam.gserviceaccount.com).
    • Assegna i ruoli: seleziona Storage Object Admin.
  6. Fai clic su Salva.

Crea un argomento Pub/Sub

Crea l'argomento Pub/Sub a cui Cloud Scheduler pubblicherà e a cui la funzione Cloud Run si iscriverà.

  1. Nella console Google Cloud, vai a Pub/Sub > Argomenti.
  2. Fai clic su Crea argomento.
  3. Fornisci i seguenti dettagli di configurazione:
    • ID argomento: inserisci workday-activity-trigger.
    • Lascia invariate le altre impostazioni predefinite.
  4. Fai clic su Crea.

Crea una funzione Cloud Run per raccogliere i log

La funzione Cloud Run verrà attivata dai messaggi Pub/Sub di Cloud Scheduler per recuperare i log dall'API Workday User Activity Logging e scriverli in Cloud Storage.

  1. Nella console Google Cloud, vai a Cloud Run.
  2. Fai clic su Scrivi una funzione.

  3. Nella sezione Configura, fornisci i seguenti dettagli di configurazione:

    Impostazione Valore
    Nome servizio workday-activity-collector
    Regione Seleziona la regione corrispondente al bucket Cloud Storage (ad esempio, us-central1)
    Tempo di esecuzione Seleziona Python 3.12 o versioni successive.

  4. Nella sezione Trigger, fai clic su Aggiungi trigger e seleziona Trigger Pub/Sub.

  5. Nel riquadro Trigger Eventarc, fornisci i seguenti dettagli di configurazione:

    • Nome attivatore: mantieni il nome generato o inserisci un nome per l'attivatore.
    • Tipo di trigger: seleziona Origini Google.
    • Provider di eventi: seleziona Pub/Sub.
    • Tipo di evento: seleziona google.cloud.pubsub.topic.v1.messagePublished.
    • Seleziona un argomento Cloud Pub/Sub: scegli l'argomento workday-activity-trigger.
    • Regione: seleziona la stessa regione della funzione.
    • Service account: seleziona il account di servizio workday-activity-collector-sa.

  6. Fai clic su Salva trigger.

  7. Nella sezione Autenticazione:

    1. Seleziona Richiedi autenticazione.
    2. Seleziona Identity and Access Management (IAM).

  8. Vai a Container, networking, sicurezza ed espandilo.

  9. Vai alla scheda Sicurezza:

    • Service account: seleziona il account di servizio workday-activity-collector-sa.

  10. Vai alla scheda Container:

    1. Fai clic su Variabili e secret.
    2. Fai clic su + Aggiungi variabile per ogni variabile di ambiente:
    Nome variabile Valore di esempio Descrizione
    GCS_BUCKET workday-activity-logs Nome del bucket Cloud Storage
    GCS_PREFIX workday Prefisso per i file di log
    STATE_KEY workday-state.json Percorso dello stato, al di fuori del prefisso del log
    WORKDAY_HOST your-workday-host Nome host Workday
    WORKDAY_TENANT your-tenant Nome tenant Workday
    CLIENT_ID your-client-id ID client OAuth
    CLIENT_SECRET your-client-secret Client secret OAuth
    REFRESH_TOKEN your-refresh-token Token di aggiornamento OAuth
    MAX_RECORDS 10000 Numero massimo di record per esecuzione
    PAGE_SIZE 100 Record per pagina
    LOOKBACK_HOURS 24 Periodo di riferimento iniziale

  11. Nella scheda Variabili e secret, vai a Richieste:

    • Timeout richiesta: inserisci 600 secondi (10 minuti).

  12. Vai alla scheda Impostazioni in Container:

    • Nella sezione Risorse:
      • Memoria: seleziona 512 MiB o un valore superiore.
      • CPU: seleziona 1.

  13. Nella sezione Scalabilità della revisione:

    • Numero minimo di istanze: inserisci 0.
    • Numero massimo di istanze: inserisci 100 (o modifica in base al carico previsto).

  14. Fai clic su Crea.

  15. Attendi la creazione del servizio (1-2 minuti).

  16. Dopo aver creato il servizio, si aprirà automaticamente l'editor di codice incorporato.

Aggiungi il codice per la funzione

  1. Inserisci main in Entry point della funzione.

  2. Nell'editor di codice incorporato, crea due file:

    • Primo file: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 hashlib

# 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', 'workday')
STATE_KEY = os.environ.get('STATE_KEY', 'workday-state.json')
WORKDAY_HOST = os.environ.get('WORKDAY_HOST', '')
WORKDAY_TENANT = os.environ.get('WORKDAY_TENANT', '')
CLIENT_ID = os.environ.get('CLIENT_ID', '')
CLIENT_SECRET = os.environ.get('CLIENT_SECRET', '')
REFRESH_TOKEN = os.environ.get('REFRESH_TOKEN', '')
MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '10000'))
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)

# Activity Logging entries carry no per-event identifier (taskId and
# sessionId are reused), so the content hash is the identity.
ID_FIELDS = ()

def event_keys(event):
    """Return every identity this event can be recognised by."""
    keys = {'sha256:' + hashlib.sha256(
        json.dumps(event, sort_keys=True, ensure_ascii=False).encode('utf-8')
    ).hexdigest()}
    for field in ID_FIELDS:
        value = event.get(field)
        if value:
            keys.add(f'{field}:{value}')
    return keys

def get_token():
    """Get OAuth 2.0 access token using refresh token flow."""
    token_url = f"https://{WORKDAY_HOST}/ccx/oauth2/{WORKDAY_TENANT}/token"

    body = f"grant_type=refresh_token&client_id={CLIENT_ID}&client_secret={CLIENT_SECRET}&refresh_token={REFRESH_TOKEN}"

    headers = {
        'Content-Type': 'application/x-www-form-urlencoded',
        'Accept': 'application/json'
    }

    backoff = 1.0
    max_retries = 3

    for attempt in range(max_retries):
        response = http.request('POST', token_url, body=body.encode('utf-8'), headers=headers)

        if response.status == 429:
            retry_after = int(response.headers.get('Retry-After', str(int(backoff))))
            print(f"Rate limited (429) on token request. Retrying after {retry_after}s...")
            time.sleep(retry_after)
            backoff = min(backoff * 2, 30.0)
            continue

        if response.status != 200:
            raise RuntimeError(f"Failed to get access token: {response.status} - {response.data.decode('utf-8')}")

        data = json.loads(response.data.decode('utf-8'))
        return data['access_token']

    raise RuntimeError(f"Failed to get token after {max_retries} retries due to rate limiting")

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

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

    if not all([GCS_BUCKET, WORKDAY_HOST, WORKDAY_TENANT, CLIENT_ID, CLIENT_SECRET, REFRESH_TOKEN]):
        print('Error: Missing required environment variables')
        return

    try:
        bucket = storage_client.bucket(GCS_BUCKET)

        # Load state
        state = load_state(bucket, STATE_KEY)
        seen_keys = load_seen(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"])
                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 access token
        token = get_token()

        # Fetch logs
        records, newest_event_time = fetch_logs(
            token=token,
            start_time=last_time,
            end_time=now,
            page_size=PAGE_SIZE,
            max_records=MAX_RECORDS,
        )

        # Drop the events the overlap window re-read from the previous run
        fresh = [r for r in records if not (event_keys(r) & seen_keys)]
        all_keys = set()
        for record in records:
            all_keys |= event_keys(record)

        if not fresh:
            print("No new log records found.")
            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 fresh]) + '\n'
        blob.upload_from_string(ndjson, content_type='application/x-ndjson')

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

        # Remember every fetched record so the next overlap window skips it
        save_seen(bucket, STATE_KEY, all_keys)

        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(fresh)} 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}")
        raise

    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}")
        raise

def load_seen(bucket, key):
    """Load the event keys written by the previous run (sidecar object)."""
    try:
        blob = bucket.blob(key + '.seen')
        if blob.exists():
            return set(json.loads(blob.download_as_text()))
    except Exception as e:
        print(f"Warning: Could not load seen keys: {e}")
        raise

    return set()

def save_seen(bucket, key, keys):
    """Save the event keys of this run to the sidecar object."""
    try:
        blob = bucket.blob(key + '.seen')
        blob.upload_from_string(
            json.dumps(sorted(keys)),
            content_type='application/json'
        )
        print(f"Saved {len(keys)} event keys for deduplication")
    except Exception as e:
        print(f"Warning: Could not save seen keys: {e}")
        raise

def fetch_logs(token: str, start_time: datetime, end_time: datetime, page_size: int, max_records: int):
    """
    Fetch user activity logs from Workday Activity Logging API with pagination and rate limiting.

    Args:
        token: OAuth 2.0 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 = f"https://{WORKDAY_HOST}/ccx/api/privacy/v1/{WORKDAY_TENANT}/activityLogging"

    headers = {
        'Authorization': f'Bearer {token}',
        'Accept': 'application/json',
        'User-Agent': 'GoogleSecOps-WorkdayCollector/1.0'
    }

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

    from_iso = start_time.strftime('%Y-%m-%dT%H:%M:%SZ')
    to_iso = end_time.strftime('%Y-%m-%dT%H:%M:%SZ')

    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"{base_url}?from={from_iso}&to={to_iso}&limit={current_limit}&offset={offset}"

        try:
            response = http.request('GET', url, headers=headers)

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

            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('requestTime') or event.get('systemAccount', {}).get('signOnDateTime')
                    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 pagination
            total = data.get('total', 0)
            if offset + len(page_results) >= total:
                print(f"Reached end of results (offset={offset + len(page_results)}, total={total})")
                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

    • Secondo file: requirements.txt::

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

  3. Fai clic su Esegui il deployment per salvare la funzione ed eseguirne il deployment.

  4. Attendi il completamento del deployment (2-3 minuti).

Crea un job Cloud Scheduler

Cloud Scheduler pubblica messaggi nell'argomento Pub/Sub a intervalli regolari, attivando la funzione Cloud Run.

  1. Nella console Google Cloud, vai a Cloud Scheduler.
  2. Fai clic su Crea job.

  3. Fornisci i seguenti dettagli di configurazione:

    Impostazione Valore
    Nome workday-activity-collector-hourly
    Regione Seleziona la stessa regione della funzione Cloud Run
    Frequenza 0 * * * * (ogni ora, allo scoccare dell'ora)
    Fuso orario Seleziona il fuso orario (UTC consigliato)
    Tipo di target Pub/Sub
    Argomento Seleziona l'argomento workday-activity-trigger
    Corpo del messaggio {} (oggetto JSON vuoto)

  4. Fai clic su Crea.

Opzioni di frequenza di pianificazione

Scegli la frequenza in base al volume dei log e ai requisiti di latenza:

Frequenza Espressione cron Caso d'uso
Ogni 5 minuti */5 * * * * Volume elevato, bassa latenza
Ogni 15 minuti */15 * * * * Volume medio
Ogni ora 0 * * * * Standard (consigliato)
Ogni 6 ore 0 */6 * * * Volume basso, elaborazione batch
Ogni giorno 0 0 * * * Raccolta dei dati storici

Testare l'integrazione

  1. Nella console Cloud Scheduler, trova il tuo job (workday-activity-collector-hourly).
  2. Fai clic su Forza esecuzione per attivarlo manualmente.
  3. Attendi qualche secondo e vai a Cloud Run > Servizi > workday-activity-collector > Log.

  4. Verifica che la funzione sia stata eseguita correttamente. Cerca:

    Fetching logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
Page 1: Retrieved X events
Wrote X records to gs://workday-activity-logs/workday/logs_YYYYMMDD_HHMMSS.ndjson
Successfully processed X records

  5. Controlla il bucket Cloud Storage (workday-activity-logs) per verificare che i log siano stati scritti.

Se nei log vengono visualizzati errori:

  • HTTP 401: controlla le credenziali OAuth nelle variabili di ambiente
  • HTTP 403: verifica che ISU disponga delle autorizzazioni richieste per il dominio di registrazione dell'attività utente
  • HTTP 429: limitazione della frequenza: la funzione verrà ritentata automaticamente con backoff
  • Impossibile ottenere il token di accesso: verifica che WORKDAY_HOST, WORKDAY_TENANT, CLIENT_ID, CLIENT_SECRET e REFRESH_TOKEN siano corretti

Configura un feed in Google SecOps per importare i log delle attività utente di Workday

  1. Vai a Impostazioni SIEM > Feed.
  2. Fai clic su Aggiungi nuovo feed.
  3. Fai clic su Configura un singolo feed.
  4. Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Workday User Activity Logs).
  5. Seleziona Google Cloud Storage V2 come Tipo di origine.
  6. Seleziona Attività utente Workday come Tipo di log.

  7. Fai clic su Ottieni service account. Verrà visualizzato un indirizzo email del account di servizio univoco, ad esempio:

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

  8. Copia l'indirizzo email. Lo utilizzerai nel passaggio successivo.

  9. Fai clic su Avanti.

  10. Specifica i valori per i seguenti parametri di input:

    • URL bucket di archiviazione: inserisci l'URI del bucket Cloud Storage con il percorso del prefisso:

      gs://workday-activity-logs/workday/
      • Sostituisci:
        • workday-activity-logs: il nome del bucket Cloud Storage.
        • workday: (Facoltativo) prefisso o percorso in cui vengono archiviati i log (lascia vuoto per la radice).

    • Opzione di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze:

      • Non eliminare mai i file: non eliminare mai i file dall'origine (opzione consigliata per i test).
      • Elimina file trasferiti e directory vuote: elimina i file e le directory vuote dall'origine dopo il completamento di un recupero riuscito.

    • Età massima file: includi i file modificati nell'ultimo numero di giorni (il valore predefinito è 180 giorni).

    • Spazio dei nomi dell'asset: lo spazio dei nomi dell'asset.

    • Etichette di importazione: l'etichetta da applicare agli eventi di questo feed.

  11. Fai clic su Avanti.

  12. Controlla la nuova configurazione del feed nella schermata Finalizza e poi fai clic su Invia.

Concedi le autorizzazioni IAM al account di servizio Google SecOps

Il account di servizio Google SecOps ha bisogno di due ruoli nel tuo bucket Cloud Storage: Storage Object Viewer per leggere gli oggetti log e un ruolo a livello di bucket per leggere i metadati del bucket.

  1. Vai a Cloud Storage > Bucket.
  2. Fai clic sul nome del bucket (workday-activity-logs).
  3. Vai alla scheda Autorizzazioni.
  4. Fai clic su Concedi l'accesso.
  5. Fornisci i seguenti dettagli di configurazione:
    • Aggiungi entità: incolla l'email del account di servizio Google SecOps.
    • Assegna ruoli: seleziona entrambi i seguenti ruoli:
      • Visualizzatore oggetti Storage: legge gli oggetti log.
      • Storage Legacy Bucket Reader: legge i metadati del bucket. Se hai selezionato l'opzione di eliminazione Elimina file trasferiti e directory vuote, seleziona Storage Legacy Bucket Writer, che concede anche l'autorizzazione di eliminazione.

  6. Fai clic su Salva.

Tabella di mappatura UDM

Campo log Mappatura UDM Logica
Account_Locked__Disabled_or_Expired_label additional.fields Unita
Authentication_Type_label additional.fields Unita
Created_Moment_label additional.fields Unita
Current_OMS_Version_label additional.fields Unita
Device_is_Trusted_label additional.fields Unita
Elapsed_Time__Minutes_label additional.fields Unita
Failed_Sign_On_label additional.fields Unita
Hire_Date_for_Signon_Worker_label additional.fields Unita
Job_Family_for_Signon_Worker_label additional.fields Unita
Operating_System_label additional.fields Unita
Pay_Rate_type_label additional.fields Unita
Request_Originator_label additional.fields Unita
SAML_Identity_Provider_label additional.fields Unita
Sign-on_Time_label additional.fields Unita
Signoff_Time_label additional.fields Unita
Signon_Day_of_the_Week_label additional.fields Unita
Signon_Hour_of_Day_label additional.fields Unita
Tenant_Access_Read_Only_label additional.fields Unita
UI_Client_Type_label additional.fields Unita
Worker_Active_for_Signon_Worker_label additional.fields Unita
Worker_Type_for_Signon_Worker_label additional.fields Unita
awaiting_details_label additional.fields Unita
data_label additional.fields Unita
evp_nme_label additional.fields Unita
evpminus_label additional.fields Unita
signon_ip_address_label additional.fields Unita
@requestTime metadata.event_timestamp Analizzato come ISO8601
Sign-on_Time metadata.event_timestamp Analizzato come yyyy-MM-ddTHH:mm:ssZZ
event_type metadata.event_type Mappato direttamente
status_code metadata.product_event_type Mappato direttamente
tenant metadata.product_event_type Mappato direttamente
taskId metadata.product_log_id Mappato direttamente
User_Agent network.http.parsed_user_agent Rinominate/mappate
Browser_Type network.http.user_agent Mappato direttamente
User_Agent network.http.user_agent Mappato direttamente
userAgent network.http.user_agent Mappato direttamente
Session_ID network.session_id Mappato direttamente
sessionId network.session_id Mappato direttamente
Client_TLS_Version network.tls.version Rinominate/mappate
Worker principal.asset.hostname Mappato direttamente
ip principal.asset.ip Unita
ipaddress principal.asset.ip Unita
Worker principal.hostname Mappato direttamente
manager_name principal.hostname Mappato direttamente
ip principal.ip Unita
ipaddress principal.ip Unita
Signon_Worker_label principal.user.attribute.labels Unita
Supervisory_Organization_of_Signon_Worker_label principal.user.attribute.labels Unita
System_Account_label principal.user.attribute.labels Unita
Workday_Account_Sign_On_label principal.user.attribute.labels Unita
user_credentials_label principal.user.attribute.labels Unita
User_Name principal.user.email_addresses Unita
Role principal.user.user_display_name Mappato direttamente
manager_id principal.user.userid Mappato direttamente
Active_Session_label security_result.detection_fields Unita
Authentication_Failure_Message_label security_result.detection_fields Unita
Forgotten_Password_Reset_Request_label security_result.detection_fields Unita
Invalid_Credentials_label security_result.detection_fields Unita
Is_Device_Managed_label security_result.detection_fields Unita
MFA_Exempt_label security_result.detection_fields Unita
Password_Changed_label security_result.detection_fields Unita
Position_label security_result.detection_fields Unita
taskDisplayName security_result.summary Mappato direttamente
hostname target.hostname Mappato direttamente
CITY_NME target.location.city Mappato direttamente
Location target.location.city Mappato direttamente
COUNTRY_NME target.location.country_or_region Mappato direttamente
Location_Country_for_Signon_Worker target.location.country_or_region Mappato direttamente
Location_State target.location.state Mappato direttamente
STATE_NME target.location.state Mappato direttamente
Exempt_labels target.resource.attribute.labels Unita
browser_type_label target.resource.attribute.labels Unita
class_of_instance_label target.resource.attribute.labels Unita
device target.resource.resource_subtype Mappato direttamente
device1 target.resource.resource_subtype Mappato direttamente
device target.resource.type Mappato: (?i)(Desktop/Laptop/Mobile/Phone) → DEVICE
device1 target.resource.type Mappato: (?i)(Desktop/Laptop/Mobile/Phone) → DEVICE
BUSINESSGROUP_NME target.user.department Unita
email_name target.user.email_addresses Unita
EMPLOYEE_ID target.user.employee_id Mappato direttamente
Employee_ID target.user.employee_id Mappato direttamente
FIRST_NME target.user.first_name Mappato direttamente
EMPLOYEE_TYPE target.user.group_identifiers Unita
LAST_NME target.user.last_name Mappato direttamente
JOBTITLE_NME target.user.title Mappato direttamente
title target.user.title Mappato direttamente
target.id target.user.userid Mappato direttamente
N/D metadata.product_name Costante: WORKDAY_USER_ACTIVITY
N/D metadata.vendor_name Costante: WORKDAY_USER_ACTIVITY
N/D target.resource.type Costante: DEVICE

Log delle modifiche

Visualizza il log delle modifiche per questo parser

Hai bisogno di ulteriore assistenza? Ricevi risposte dai membri della community e dai professionisti di Google SecOps.