SailPoint IAM-Protokolle erfassen

Unterstützt in:

In diesem Dokument wird beschrieben, wie Sie SailPoint IAM-Logs (Identity and Access Management) mit Amazon S3 in Google Security Operations aufnehmen können. Der Parser verarbeitet die Logs im JSON- und XML-Format und wandelt sie in das einheitliche Datenmodell (Unified Data Model, UDM) um. Es wird zwischen einzelnen UDM-Ereignissen (ProvisioningPlan, AccountRequest, SOAP-ENV), mehreren UDM-Ereignissen (ProvisioningProject) und UDM-Entitäten (Identity) unterschieden. Für jedes werden spezifische Parsing-Logik und Feldzuordnungen angewendet, einschließlich der generischen Ereignisverarbeitung für Nicht-XML-Daten.

Hinweise

Prüfen Sie, ob folgende Voraussetzungen erfüllt sind:

  • Eine Google SecOps-Instanz.
  • Berechtigter Zugriff auf die SailPoint Identity Security Cloud.
  • Privilegierter Zugriff auf AWS (S3, IAM, Lambda, EventBridge).

SailPoint IAM-Voraussetzungen erfassen (IDs, API-Schlüssel, Organisations-IDs, Tokens)

  1. Melden Sie sich als Administrator in der SailPoint Identity Security Cloud Admin Console an.
  2. Klicken Sie auf Global > Sicherheitseinstellungen > API-Verwaltung.
  3. Klicken Sie auf API-Client erstellen.
  4. Wählen Sie Clientanmeldedaten als Grant-Typ aus.
  5. Geben Sie die folgenden Konfigurationsdetails an:
    • Name: Geben Sie einen aussagekräftigen Namen ein, z. B. Google SecOps Export API.
    • Beschreibung: Geben Sie eine Beschreibung für den API-Client ein.
    • Bereiche: Wählen Sie sp:scopes:all aus.
  6. Klicken Sie auf Erstellen und speichern Sie die generierten API-Anmeldedaten an einem sicheren Ort.
  7. Notieren Sie die Basis-URL Ihres SailPoint-Mandanten (z. B. https://tenant.api.identitynow.com).
  8. Kopieren Sie die folgenden Details und speichern Sie sie an einem sicheren Ort:
    • IDN_CLIENT_ID.
    • IDN_CLIENT_SECRET.
    • IDN_BASE

AWS S3-Bucket und IAM für Google SecOps konfigurieren

  1. Erstellen Sie einen Amazon S3-Bucket. Folgen Sie dazu der Anleitung unter Bucket erstellen.
  2. Speichern Sie den Namen und die Region des Buckets zur späteren Verwendung (z. B. sailpoint-iam-logs).
  3. Erstellen Sie einen Nutzer gemäß dieser Anleitung: IAM-Nutzer erstellen.
  4. Wählen Sie den erstellten Nutzer aus.
  5. Wählen Sie den Tab Sicherheitsanmeldedaten aus.
  6. Klicken Sie im Abschnitt Zugriffsschlüssel auf Zugriffsschlüssel erstellen.
  7. Wählen Sie Drittanbieterdienst als Anwendungsfall aus.
  8. Klicken Sie auf Weiter.
  9. Optional: Fügen Sie ein Beschreibungstag hinzu.
  10. Klicken Sie auf Zugriffsschlüssel erstellen.
  11. Klicken Sie auf CSV-Datei herunterladen, um den Access Key (Zugriffsschlüssel) und den Secret Access Key (geheimer Zugriffsschlüssel) für die zukünftige Verwendung zu speichern.
  12. Klicken Sie auf Fertig.
  13. Wählen Sie den Tab Berechtigungen aus.
  14. Klicken Sie im Bereich Berechtigungsrichtlinien auf Berechtigungen hinzufügen.
  15. Wählen Sie Berechtigungen hinzufügen aus.
  16. Wählen Sie Richtlinien direkt anhängen aus.
  17. Suchen Sie nach der Richtlinie AmazonS3FullAccess.
  18. Wählen Sie die Richtlinie aus.
  19. Klicken Sie auf Weiter.
  20. Klicken Sie auf Berechtigungen hinzufügen.

IAM-Richtlinie und ‑Rolle für S3-Uploads konfigurieren

  1. Rufen Sie in der AWS-Konsole IAM > Richtlinien auf.
  2. Klicken Sie auf Richtlinie erstellen> Tab „JSON“.
  3. Kopieren Sie die folgende Richtlinie und fügen Sie sie ein.

  4. Policy JSON (ersetzen Sie sailpoint-iam-logs, wenn Sie einen anderen Bucket-Namen eingegeben haben):

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowPutObjects",
      "Effect": "Allow",
      "Action": "s3:PutObject",
      "Resource": "arn:aws:s3:::sailpoint-iam-logs/*"
    },
    {
      "Sid": "AllowGetStateObject",
      "Effect": "Allow",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::sailpoint-iam-logs/sailpoint/iam/state.json"
    }
  ]
}

  5. Klicken Sie auf Weiter > Richtlinie erstellen.

  6. Rufen Sie IAM > Rollen > Rolle erstellen > AWS-Service > Lambda auf.

  7. Hängen Sie die neu erstellte Richtlinie an.

  8. Geben Sie der Rolle den Namen SailPointIamToS3Role und klicken Sie auf Rolle erstellen.

Lambda-Funktion erstellen

  1. Rufen Sie in der AWS Console Lambda > Funktionen > Funktion erstellen auf.
  2. Klicken Sie auf Von Grund auf erstellen.

  3. Geben Sie die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Name sailpoint_iam_to_s3
    Laufzeit Python 3.13
    Architektur x86_64
    Ausführungsrolle SailPointIamToS3Role

  4. Nachdem die Funktion erstellt wurde, öffnen Sie den Tab Code, löschen Sie den Stub und fügen Sie den folgenden Code (sailpoint_iam_to_s3.py) ein.

    #!/usr/bin/env python3
# Lambda: Pull SailPoint Identity Security Cloud audit events and store raw JSON payloads to S3
# - Uses /v3/search API with pagination for audit events.
# - Preserves vendor-native JSON format for identity events.
# - Retries with exponential backoff; unique S3 keys to avoid overwrites.

import os, json, time, uuid, urllib.parse
from urllib.request import Request, urlopen
from urllib.error import URLError, HTTPError

import boto3

S3_BUCKET   = os.environ["S3_BUCKET"]
S3_PREFIX   = os.environ.get("S3_PREFIX", "sailpoint/iam/")
STATE_KEY   = os.environ.get("STATE_KEY", "sailpoint/iam/state.json")
WINDOW_SEC  = int(os.environ.get("WINDOW_SECONDS", "3600"))  # default 1h
HTTP_TIMEOUT= int(os.environ.get("HTTP_TIMEOUT", "60"))
IDN_BASE    = os.environ["IDN_BASE"]  # e.g. https://tenant.api.identitynow.com
CLIENT_ID   = os.environ["IDN_CLIENT_ID"]
CLIENT_SECRET = os.environ["IDN_CLIENT_SECRET"]
SCOPE       = os.environ.get("IDN_SCOPE", "sp:scopes:all")
PAGE_SIZE   = int(os.environ.get("PAGE_SIZE", "250"))
MAX_PAGES   = int(os.environ.get("MAX_PAGES", "20"))
MAX_RETRIES = int(os.environ.get("MAX_RETRIES", "3"))
USER_AGENT  = os.environ.get("USER_AGENT", "sailpoint-iam-to-s3/1.0")

s3 = boto3.client("s3")

def _load_state():
    try:
        obj = s3.get_object(Bucket=S3_BUCKET, Key=STATE_KEY)
        return json.loads(obj["Body"].read())
    except Exception:
        return {}

def _save_state(st):
    s3.put_object(
        Bucket=S3_BUCKET,
        Key=STATE_KEY,
        Body=json.dumps(st, separators=(",", ":")).encode("utf-8"),
        ContentType="application/json",
    )

def _iso(ts: float) -> str:
    return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(ts))

def _get_oauth_token() -> str:
    """Get OAuth2 access token using Client Credentials flow"""
    token_url = f"{IDN_BASE.rstrip('/')}/oauth/token"

    data = urllib.parse.urlencode({
        'grant_type': 'client_credentials',
        'client_id': CLIENT_ID,
        'client_secret': CLIENT_SECRET,
        'scope': SCOPE
    }).encode('utf-8')

    req = Request(token_url, data=data, method="POST")
    req.add_header("Content-Type", "application/x-www-form-urlencoded")
    req.add_header("User-Agent", USER_AGENT)

    with urlopen(req, timeout=HTTP_TIMEOUT) as r:
        response = json.loads(r.read())
        return response["access_token"]

def _search_events(access_token: str, created_from: str, search_after: list = None) -> list:
    """Search for audit events using SailPoint's /v3/search API"""
    search_url = f"{IDN_BASE.rstrip('/')}/v3/search"

    # Build search query for events created after specified time
    query_str = f'created:">={created_from}"'

    payload = {
        "indices": ["events"],
        "query": {"query": query_str},
        "sort": ["created", "+id"],
        "limit": PAGE_SIZE
    }

    if search_after:
        payload["searchAfter"] = search_after

    attempt = 0
    while True:
        req = Request(search_url, data=json.dumps(payload).encode('utf-8'), method="POST")
        req.add_header("Content-Type", "application/json")
        req.add_header("Accept", "application/json")
        req.add_header("Authorization", f"Bearer {access_token}")
        req.add_header("User-Agent", USER_AGENT)

        try:
            with urlopen(req, timeout=HTTP_TIMEOUT) as r:
                response = json.loads(r.read())
                # Handle different response formats
                if isinstance(response, list):
                    return response
                return response.get("results", response.get("data", []))
        except (HTTPError, URLError) as e:
            attempt += 1
            print(f"HTTP error on attempt {attempt}: {e}")
            if attempt > MAX_RETRIES:
                raise
            # exponential backoff with jitter
            time.sleep(min(60, 2 ** attempt) + (time.time() % 1))

def _put_events_data(events: list, from_ts: float, to_ts: float, page_num: int) -> str:
    # Create unique S3 key for events data
    ts_path = time.strftime("%Y/%m/%d", time.gmtime(to_ts))
    uniq = f"{int(time.time()*1e6)}_{uuid.uuid4().hex[:8]}"
    key = f"{S3_PREFIX}{ts_path}/sailpoint_iam_{int(from_ts)}_{int(to_ts)}_p{page_num:03d}_{uniq}.json"

    s3.put_object(
        Bucket=S3_BUCKET, 
        Key=key, 
        Body=json.dumps(events, separators=(",", ":")).encode("utf-8"), 
        ContentType="application/json",
        Metadata={
            'source': 'sailpoint-iam',
            'from_timestamp': str(int(from_ts)),
            'to_timestamp': str(int(to_ts)),
            'page_number': str(page_num),
            'events_count': str(len(events))
        }
    )
    return key

def _get_item_id(item: dict) -> str:
    """Extract ID from event item, trying multiple possible fields"""
    for field in ("id", "uuid", "eventId", "_id"):
        if field in item and item[field]:
            return str(item[field])
    return ""

def lambda_handler(event=None, context=None):
    st = _load_state()
    now = time.time()
    from_ts = float(st.get("last_to_ts") or (now - WINDOW_SEC))
    to_ts = now

    # Get OAuth token
    access_token = _get_oauth_token()

    created_from = _iso(from_ts)
    print(f"Fetching SailPoint IAM events from: {created_from}")

    # Handle pagination state
    last_created = st.get("last_created")
    last_id = st.get("last_id")
    search_after = [last_created, last_id] if (last_created and last_id) else None

    pages = 0
    total_events = 0
    written_keys = []
    newest_created = last_created or created_from
    newest_id = last_id or ""

    while pages < MAX_PAGES:
        events = _search_events(access_token, created_from, search_after)

        if not events:
            break

        # Write page to S3
        key = _put_events_data(events, from_ts, to_ts, pages + 1)
        written_keys.append(key)
        total_events += len(events)

        # Update pagination state from last item
        last_event = events[-1]
        last_event_created = last_event.get("created") or last_event.get("metadata", {}).get("created")
        last_event_id = _get_item_id(last_event)

        if last_event_created:
            newest_created = last_event_created
        if last_event_id:
            newest_id = last_event_id

        search_after = [newest_created, newest_id]
        pages += 1

        # If we got less than page size, we're done
        if len(events) < PAGE_SIZE:
            break

    print(f"Successfully retrieved {total_events} events across {pages} pages")

    # Save state for next run
    st["last_to_ts"] = to_ts
    st["last_created"] = newest_created
    st["last_id"] = newest_id
    st["last_successful_run"] = now
    _save_state(st)

    return {
        "statusCode": 200,
        "body": {
            "success": True,
            "pages": pages,
            "total_events": total_events,
            "s3_keys": written_keys,
            "from_timestamp": from_ts,
            "to_timestamp": to_ts,
            "last_created": newest_created,
            "last_id": newest_id
        }
    }

if __name__ == "__main__":
    print(lambda_handler())

  5. Rufen Sie Konfiguration > Umgebungsvariablen auf.

  6. Klicken Sie auf Bearbeiten> Neue Umgebungsvariable hinzufügen.

  7. Geben Sie die in der folgenden Tabelle angegebenen Umgebungsvariablen ein und ersetzen Sie die Beispielwerte durch Ihre Werte.

    Umgebungsvariablen

    Schlüssel Beispielwert
    S3_BUCKET sailpoint-iam-logs
    S3_PREFIX sailpoint/iam/
    STATE_KEY sailpoint/iam/state.json
    WINDOW_SECONDS 3600
    HTTP_TIMEOUT 60
    MAX_RETRIES 3
    USER_AGENT sailpoint-iam-to-s3/1.0
    IDN_BASE https://tenant.api.identitynow.com
    IDN_CLIENT_ID your-client-id (aus Schritt 2)
    IDN_CLIENT_SECRET your-client-secret (aus Schritt 2)
    IDN_SCOPE sp:scopes:all
    PAGE_SIZE 250
    MAX_PAGES 20

  8. Bleiben Sie nach dem Erstellen der Funktion auf der zugehörigen Seite oder öffnen Sie Lambda > Funktionen > Ihre Funktion.

  9. Wählen Sie den Tab Konfiguration aus.

  10. Klicken Sie im Bereich Allgemeine Konfiguration auf Bearbeiten.

  11. Ändern Sie Zeitlimit in 5 Minuten (300 Sekunden) und klicken Sie auf Speichern.

EventBridge-Zeitplan erstellen

  1. Gehen Sie zu Amazon EventBridge > Scheduler > Create schedule (Amazon EventBridge > Scheduler > Zeitplan erstellen).
  2. Geben Sie die folgenden Konfigurationsdetails an:
    • Wiederkehrender Zeitplan: Preis (1 hour).
    • Ziel: Ihre Lambda-Funktion sailpoint_iam_to_s3.
    • Name: sailpoint-iam-1h.
  3. Klicken Sie auf Zeitplan erstellen.

(Optional) IAM-Nutzer mit Lesezugriff und Schlüssel für Google SecOps erstellen

  1. Rufen Sie die AWS-Konsole > IAM > Nutzer auf.
  2. Klicken Sie auf Add users (Nutzer hinzufügen).
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Nutzer: Geben Sie secops-reader ein.
    • Zugriffstyp: Wählen Sie Zugriffsschlüssel – programmatischer Zugriff aus.
  4. Klicken Sie auf Nutzer erstellen.
  5. Minimale Leseberechtigung (benutzerdefiniert) anhängen: Nutzer > secops-reader > Berechtigungen > Berechtigungen hinzufügen > Richtlinien direkt anhängen > Richtlinie erstellen.

  6. JSON:

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject"],
      "Resource": "arn:aws:s3:::sailpoint-iam-logs/*"
    },
    {
      "Effect": "Allow",
      "Action": ["s3:ListBucket"],
      "Resource": "arn:aws:s3:::sailpoint-iam-logs"
    }
  ]
}

  7. Name = secops-reader-policy.

  8. Klicken Sie auf Richtlinie erstellen> suchen/auswählen> Weiter> Berechtigungen hinzufügen.

  9. Erstellen Sie einen Zugriffsschlüssel für secops-reader: Sicherheitsanmeldedaten > Zugriffsschlüssel.

  10. Klicken Sie auf Zugriffsschlüssel erstellen.

  11. Laden Sie die Datei .CSV herunter. Sie fügen diese Werte in den Feed ein.

Feed in Google SecOps konfigurieren, um SailPoint-IAM-Logs aufzunehmen

  1. Rufen Sie die SIEM-Einstellungen > Feeds auf.
  2. Klicken Sie auf + Neuen Feed hinzufügen.
  3. Geben Sie im Feld Feedname einen Namen für den Feed ein, z. B. SailPoint IAM logs.
  4. Wählen Sie Amazon S3 V2 als Quelltyp aus.
  5. Wählen Sie SailPoint IAM als Logtyp aus.
  6. Klicken Sie auf Weiter.
  7. Geben Sie Werte für die folgenden Eingabeparameter an:
    • S3-URI: s3://sailpoint-iam-logs/sailpoint/iam/
    • Optionen zum Löschen der Quelle: Wählen Sie die gewünschte Option zum Löschen aus.
    • Maximales Dateialter: Dateien einschließen, die in den letzten Tagen geändert wurden. Der Standardwert ist 180 Tage.
    • Zugriffsschlüssel-ID: Nutzerzugriffsschlüssel mit Zugriff auf den S3-Bucket.
    • Geheimer Zugriffsschlüssel: Der geheime Schlüssel des Nutzers mit Zugriff auf den S3-Bucket.
    • Asset-Namespace: Der Asset-Namespace.
    • Aufnahmelabels: Das Label, das auf die Ereignisse aus diesem Feed angewendet wird.
  8. Klicken Sie auf Weiter.
  9. Prüfen Sie die neue Feedkonfiguration auf dem Bildschirm Abschließen und klicken Sie dann auf Senden.

UDM-Zuordnungstabelle

Logfeld UDM-Zuordnung Logik
action metadata.description Der Wert des Felds action aus dem Rohlog.
actor.name principal.user.user_display_name Der Wert des Felds actor.name aus dem Rohlog.
attributes.accountName principal.user.group_identifiers Der Wert des Felds attributes.accountName aus dem Rohlog.
attributes.appId target.asset_id „App-ID: “ gefolgt vom Wert des Felds attributes.appId aus dem Rohlog.
attributes.attributeName additional.fields[0].value.string_value Der Wert des Felds attributes.attributeName aus dem Rohlog, der in ein additional.fields-Objekt eingefügt wird. Der Schlüssel ist auf „Attributname“ festgelegt.
attributes.attributeValue additional.fields[1].value.string_value Der Wert des Felds attributes.attributeValue aus dem Rohlog, der in ein additional.fields-Objekt eingefügt wird. Der Schlüssel ist auf „Attributwert“ festgelegt.
attributes.cloudAppName target.application Der Wert des Felds attributes.cloudAppName aus dem Rohlog.
attributes.hostName target.hostname, target.asset.hostname Der Wert des Felds attributes.hostName aus dem Rohlog.
attributes.interface additional.fields[2].value.string_value Der Wert des Felds attributes.interface aus dem Rohlog, der in ein additional.fields-Objekt eingefügt wird. Der Schlüssel ist auf „Interface“ gesetzt.
attributes.operation security_result.action_details Der Wert des Felds attributes.operation aus dem Rohlog.
attributes.previousValue additional.fields[3].value.string_value Der Wert des Felds attributes.previousValue aus dem Rohlog, der in ein additional.fields-Objekt eingefügt wird. Der Schlüssel ist auf „Previous Value“ (Vorheriger Wert) festgelegt.
attributes.provisioningResult security_result.detection_fields.value Der Wert des Felds attributes.provisioningResult aus dem Rohlog, der in ein security_result.detection_fields-Objekt eingefügt wird. Der Schlüssel ist auf „Provisioning Result“ festgelegt.
attributes.sourceId principal.labels[0].value Der Wert des Felds attributes.sourceId aus dem Rohlog, der in ein principal.labels-Objekt eingefügt wird. Der Schlüssel ist auf „Source Id“ (Quell-ID) festgelegt.
attributes.sourceName principal.labels[1].value Der Wert des Felds attributes.sourceName aus dem Rohlog, der in ein principal.labels-Objekt eingefügt wird. Der Schlüssel ist auf „Quellname“ festgelegt.
auditClassName metadata.product_event_type Der Wert des Felds auditClassName aus dem Rohlog.
created metadata.event_timestamp.seconds, metadata.event_timestamp.nanos Der Wert des Felds created aus dem Rohlog, in einen Zeitstempel konvertiert, wenn instant.epochSecond nicht vorhanden ist.
id metadata.product_log_id Der Wert des Felds id aus dem Rohlog.
instant.epochSecond metadata.event_timestamp.seconds Der Wert des Felds instant.epochSecond aus dem Rohlog, der für den Zeitstempel verwendet wird.
ipAddress principal.asset.ip, principal.ip Der Wert des Felds ipAddress aus dem Rohlog.
interface additional.fields[0].value.string_value Der Wert des Felds interface aus dem Rohlog, der in ein additional.fields-Objekt eingefügt wird. Der Schlüssel ist auf „interface“ gesetzt.
loggerName intermediary.application Der Wert des Felds loggerName aus dem Rohlog.
message metadata.description, security_result.description Wird für verschiedene Zwecke verwendet, z. B. zum Festlegen der Beschreibung in Metadaten und security_result sowie zum Extrahieren von XML-Inhalten.
name security_result.description Der Wert des Felds name aus dem Rohlog.
operation target.resource.attribute.labels[0].value, metadata.product_event_type Der Wert des Felds operation aus dem Rohlog, der in ein target.resource.attribute.labels-Objekt eingefügt wird. Der Schlüssel ist auf „operation“ gesetzt. Wird auch für metadata.product_event_type verwendet.
org principal.administrative_domain Der Wert des Felds org aus dem Rohlog.
pod principal.location.name Der Wert des Felds pod aus dem Rohlog.
referenceClass additional.fields[1].value.string_value Der Wert des Felds referenceClass aus dem Rohlog, der in ein additional.fields-Objekt eingefügt wird. Der Schlüssel ist auf „referenceClass“ festgelegt.
referenceId additional.fields[2].value.string_value Der Wert des Felds referenceId aus dem Rohlog, der in ein additional.fields-Objekt eingefügt wird. Der Schlüssel ist auf „referenceId“ festgelegt.
sailPointObjectName additional.fields[3].value.string_value Der Wert des Felds sailPointObjectName aus dem Rohlog, der in ein additional.fields-Objekt eingefügt wird. Der Schlüssel ist auf „sailPointObjectName“ festgelegt.
serverHost principal.hostname, principal.asset.hostname Der Wert des Felds serverHost aus dem Rohlog.
stack additional.fields[4].value.string_value Der Wert des Felds stack aus dem Rohlog, der in ein additional.fields-Objekt eingefügt wird. Der Schlüssel ist auf „Stack“ gesetzt.
status security_result.severity_details Der Wert des Felds status aus dem Rohlog.
target additional.fields[4].value.string_value Der Wert des Felds target aus dem Rohlog, der in ein additional.fields-Objekt eingefügt wird. Der Schlüssel ist auf „target“ gesetzt.
target.name principal.user.userid Der Wert des Felds target.name aus dem Rohlog.
technicalName security_result.summary Der Wert des Felds technicalName aus dem Rohlog.
thrown.cause.message xml_body, detailed_message Der Wert des Felds thrown.cause.message aus dem Rohlog, der zum Extrahieren von XML-Inhalten verwendet wird.
thrown.message xml_body, detailed_message Der Wert des Felds thrown.message aus dem Rohlog, der zum Extrahieren von XML-Inhalten verwendet wird.
trackingNumber additional.fields[5].value.string_value Der Wert des Felds trackingNumber aus dem Rohlog, der in ein additional.fields-Objekt eingefügt wird. Der Schlüssel ist auf „Tracking Number“ (Trackingnummer) festgelegt.
type metadata.product_event_type Der Wert des Felds type aus dem Rohlog.
_version metadata.product_version Der Wert des Felds _version aus dem Rohlog.
– metadata.event_timestamp Abgeleitet aus den Feldern instant.epochSecond oder created.
– metadata.event_type Wird durch die Parserlogik anhand verschiedener Felder bestimmt, darunter has_principal_user, has_target_application, technicalName und action. Der Standardwert ist „GENERIC_EVENT“.
– metadata.log_type Legen Sie diesen Wert auf „SAILPOINT_IAM“ fest.
– metadata.product_name Legen Sie IAM fest.
– metadata.vendor_name Legen Sie diesen Wert auf „SAILPOINT“ fest.
– extensions.auth.type Unter bestimmten Umständen auf „AUTHTYPE_UNSPECIFIED“ festgelegt.
– target.resource.attribute.labels[0].key Legen Sie diesen Wert auf „operation“ fest.

Benötigen Sie weitere Hilfe? Antworten von Community-Mitgliedern und Google SecOps-Experten erhalten