‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

איסוף יומנים של Asset Panda

גרסת המנתח: 1.0

נתמך ב:

Google SecOps SIEM

במסמך הזה מוסבר איך להטמיע יומנים של Asset Panda ב-Google Security Operations באמצעות Google Cloud Storage V2.

‫Asset Panda היא פלטפורמה מבוססת-ענן לניהול נכסים, שמאפשרת לארגונים לעקוב אחרי נכסים פיזיים ונכסים דיגיטליים, לנהל אותם ולדווח עליהם לאורך כל מחזור החיים שלהם. ‫Asset Panda API בארכיטקטורת REST מספק גישה ליומני שינויים שמתעדים שינויים ברמת השדה, העברות נכסים, היסטוריית פעולות ופעילות משתמשים בכל קבוצות הנכסים. אפשר לאסוף את יומני השינויים האלה דרך ה-API ולכתוב אותם בקטגוריה של GCS כדי ש-Google SecOps יקלוט אותם.

לפני שמתחילים

חשוב לוודא שיש לכם את הדברים הבאים:

מכונה של Google SecOps
פרויקט ב-GCP שבו מופעל Cloud Storage API
הרשאות ליצירה ולניהול של קטגוריות ב-GCS
הרשאות ליצירת שירותי Cloud Run, נושאי Pub/Sub ומשימות ב-Cloud Scheduler
חשבון Asset Panda עם הרשאת אדמין (נדרש להגדרת API)
מפתח API וסוד של Asset Panda עם הרשאות קריאה

יצירת פרטי כניסה ל-API של Asset Panda

מעבר להגדרת ה-API

נכנסים לחשבון Asset Panda כאדמין.
לוחצים על סמל ההגדרות (גלגל השיניים) בפינה השמאלית העליונה.
לוחצים על API Configuration (הגדרת API).

יצירה של מפתח API

בדף API Configuration (הגדרת API), לוחצים על Create New API Key (יצירת מפתח API חדש).
ממלאים את פרטי ההגדרה הבאים:
- שם: מזינים שם תיאורי למפתח (לדוגמה, SIEM Change Log Collector)
- הרשאות: בוחרים באפשרות קריאה
הערה: מטעמי אבטחה, צריך לתת רק הרשאות קריאה. לא נדרשות הרשאות כתיבה ומחיקה כדי לאסוף יומנים.
לוחצים על Save.
מתעדים את פרטי הכניסה הבאים שמוצגים בתחתית הדף:
- מפתח API (נקרא גם מזהה לקוח)
- API Secret (נקרא גם סוד לקוח)
הערה: ערך ה-API Secret מוצג רק פעם אחת. שומרים את שני הערכים באופן מאובטח. אם מאבדים את הסוד, צריך ליצור מפתח API חדש.

זיהוי מזהי קבוצות

פונקציית Cloud Run צריכה מזהי קבוצות כדי לשלוח שאילתות לגבי אובייקטים ויומני השינויים שלהם. כדי למצוא את מזהי הקבוצות:

ב-Asset Panda, עוברים אל Settings > Group Settings.
לוחצים על הקישור עריכה לצד שם הקבוצה.
שימו לב לערך המספרי שמופיע לקראת סוף כתובת ה-URL בדפדפן. זהו מזהה הקבוצה (לדוגמה, 12345).
חוזרים על הפעולה הזו לכל קבוצה שרוצים לאסוף את יומני השינויים שלה.

בדיקת הגישה ל-API

לפני שממשיכים בתהליך השילוב, בודקים את פרטי הכניסה:
```
API_KEY="your-api-key"
API_SECRET="your-api-secret"

# Test authentication by retrieving account settings
curl -s "https://api.assetpanda.com/v3/settings" \
  -H "Accept: application/json" \
  -H "Access-Key-Id: ${API_KEY}" \
  -H "Access-Key-Secret: ${API_SECRET}"
```
הערה: ב-Asset Panda יש הגבלת קצב של יצירת בקשות של 400 קריאות ל-API לכל חלון של 3 דקות לכל כתובת IP. פונקציית Cloud Run מטפלת בזה באמצעות הגבלת קצב מובנית של יצירת בקשות.

יצירת קטגוריה של Google Cloud Storage

נכנסים למסוף Google Cloud.
בוחרים את הפרויקט או יוצרים פרויקט חדש.
בתפריט הניווט, נכנסים ל-Cloud Storage > Buckets.
לוחצים על Create bucket.

ממלאים את פרטי ההגדרה הבאים:

הגדרה	ערך
Name your bucket	מזינים שם ייחודי ברמה גלובלית (לדוגמה, `asset-panda-change-logs`)
סוג המיקום	בוחרים לפי הצרכים (אזור, שני אזורים, מספר אזורים)
Location	בוחרים את המיקום (לדוגמה, `us-central1`)
סוג אחסון (storage class)	רגיל (מומלץ ליומנים שהגישה אליהם תכופה)
בקרת גישה	אחידה (מומלץ)
כלי הגנה	אופציונלי: הפעלת ניהול גרסאות של אובייקטים או מדיניות שמירת נתונים

לוחצים על יצירה.

יצירת חשבון שירות לפונקציית Cloud Run

לפונקציית Cloud Run נדרש חשבון שירות עם הרשאות כתיבה בקטגוריית GCS, וצריך להפעיל אותה באמצעות Pub/Sub.

יצירת חשבון השירות

במסוף GCP, נכנסים לדף IAM & Admin > Service Accounts.
לוחצים על Create Service Account.
מזינים את פרטי ההגדרה הבאים:
- Service account name: מזינים asset-panda-logs-collector-sa
- Service account description: מזינים Service account for Cloud Run function to collect Asset Panda change logs
לוחצים על יצירה והמשך.
בקטע Grant this service account access to project, מוסיפים את התפקידים הבאים:
1. לוחצים על בחירת תפקיד.
2. מחפשים את התפקיד Storage Object Admin ובוחרים אותו.
3. לוחצים על + הוספת תפקיד.
4. מחפשים את התפקיד Cloud Run Invoker ובוחרים בו.
5. לוחצים על + הוספת תפקיד.
6. מחפשים את התפקיד Cloud Functions Invoker ובוחרים אותו.
לוחצים על Continue.
לוחצים על סיום.

התפקידים האלה נדרשים כדי:

אדמין של אובייקט אחסון: כתיבת יומנים לקטגוריית GCS וניהול קובצי תמונת מצב
Cloud Run Invoker: מאפשר ל-Pub/Sub להפעיל את הפונקציה
מפעיל פונקציות של Cloud Functions: מאפשר להפעיל פונקציות

הענקת הרשאות IAM בקטגוריית GCS

נותנים לחשבון השירות הרשאות כתיבה בקטגוריה של GCS:

נכנסים לדף Cloud Storage > Buckets.
לוחצים על שם הקטגוריה.
עוברים לכרטיסייה Permissions.
לוחצים על הענקת גישה.
מזינים את פרטי ההגדרה הבאים:
- הוספת חשבונות משתמשים: מזינים את כתובת האימייל של חשבון השירות (לדוגמה, asset-panda-logs-collector-sa@PROJECT_ID.iam.gserviceaccount.com)
- הקצאת תפקידים: בוחרים באפשרות אדמין של אובייקטים באחסון.
לוחצים על Save.

יוצרים נושא Pub/Sub

יוצרים נושא Pub/Sub ש-Cloud Scheduler יפרסם בו ופונקציית Cloud Run תירשם אליו.

במסוף GCP, נכנסים לדף Pub/Sub > Topics.
לוחצים על Create topic.
מזינים את פרטי ההגדרה הבאים:
- מזהה הנושא: מזינים asset-panda-logs-trigger
- משאירים את שאר ההגדרות כברירת מחדל.
לוחצים על יצירה.

יצירת פונקציית Cloud Run לאיסוף יומנים

הפונקציה של Cloud Run תופעל על ידי הודעות Pub/Sub מ-Cloud Scheduler כדי לאחזר יומני שינויים מ-Asset Panda REST API ולכתוב אותם ב-GCS.

במסוף GCP, נכנסים ל-Cloud Run.
לוחצים על Create service.
בוחרים באפשרות Function (שימוש בעורך ישיר כדי ליצור פונקציה).

בקטע Configure, מזינים את פרטי ההגדרה הבאים:

הגדרה	ערך
שם השירות	`asset-panda-logs-collector`
אזור	בוחרים את האזור שתואם לקטגוריית ה-GCS (לדוגמה, `us-central1`)
זמן ריצה	בוחרים באפשרות Python 3.12 או גרסה עדכנית יותר.

בקטע טריגר (אופציונלי):
1. לוחצים על + הוספת טריגר.
2. בוחרים באפשרות Cloud Pub/Sub.
3. בקטע Select a Cloud Pub/Sub topic, בוחרים את הנושא asset-panda-logs-trigger.
4. לוחצים על Save.
בקטע אימות:
1. לוחצים על דרישת אימות.
2. בודקים את ניהול הזהויות והרשאות הגישה (IAM).
הערה: Pub/Sub יטפל באופן אוטומטי באימות כשהפונקציה תופעל.
גוללים למטה ומרחיבים את הקטע Containers, Networking, Security.
עוברים לכרטיסייה אבטחה:
- חשבון שירות: בוחרים את חשבון השירות asset-panda-logs-collector-sa

עוברים לכרטיסייה מאגרי תגים:

לוחצים על Variables & Secrets.
לוחצים על ‎+ Add variable לכל משתנה סביבה:

שם משתנה	ערך לדוגמה	תיאור
`GCS_BUCKET`	`asset-panda-change-logs`	שם הקטגוריה ב-GCS
`GCS_PREFIX`	`asset-panda`	קידומת לקובצי יומן
`STATE_KEY`	`asset-panda/state.json`	נתיב קובץ תמונת המצב
`AP_API_KEY`	`your-api-key`	מפתח API של Asset Panda
`AP_API_SECRET`	`your-api-secret`	‫API Secret של Asset Panda
`AP_GROUP_IDS`	`12345,67890`	מזהי קבוצות למעקב, מופרדים בפסיקים
`PAGE_SIZE`	`50`	רשומות לכל דף API (מקסימום 50)
`MAX_RECORDS`	`10000`	מספר הרשומות המקסימלי לכל הרצה
`LOOKBACK_HOURS`	`2`	תקופת המבט לאחור הראשונית

גוללים למטה בקטע Variables & Secrets עד שמגיעים ל-Requests:
- ‫Request timeout: מזינים 600 שניות (10 דקות)
עוברים לכרטיסייה הגדרות:
- בקטע Resources:
  - זיכרון: בוחרים באפשרות ‎512 MiB או יותר
  - מעבד (CPU): בוחרים באפשרות 1
בקטע Revision scaling:
- Minimum number of instances: מזינים 0
- Maximum number of instances: מזינים 100 (או משנים בהתאם לעומס הצפוי)
לוחצים על יצירה.
ממתינים ליצירת השירות (דקה או שתיים).
אחרי שיוצרים את השירות, עורך הקוד המוטבע נפתח באופן אוטומטי.

הוספת קוד פונקציה

בשדה Entry point, מזינים main.

בעורך הקוד, יוצרים שני קבצים:

הקובץ הראשון – 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', 'asset-panda').strip('/')
STATE_KEY = os.environ.get('STATE_KEY') or f"{GCS_PREFIX}/state.json"
AP_API_KEY = os.environ.get('AP_API_KEY')
AP_API_SECRET = os.environ.get('AP_API_SECRET')
AP_GROUP_IDS = os.environ.get('AP_GROUP_IDS', '')
PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '50'))
MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '10000'))
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '2'))

BASE_URL = 'https://api.assetpanda.com'

# Rate limiting: 400 calls per 3 minutes
RATE_LIMIT_CALLS = 400
RATE_LIMIT_WINDOW = 180  # seconds
call_timestamps = []

def rate_limit_wait():
  """Enforce rate limiting of 400 calls per 3-minute window."""
  global call_timestamps
  now = time.time()
  call_timestamps = [t for t in call_timestamps if now - t < RATE_LIMIT_WINDOW]
  if len(call_timestamps) >= RATE_LIMIT_CALLS:
    sleep_time = RATE_LIMIT_WINDOW - (now - call_timestamps[0]) + 1
    print(f"Rate limit approaching. Sleeping {sleep_time:.1f}s...")
    time.sleep(sleep_time)
    call_timestamps = [t for t in call_timestamps if time.time() - t < RATE_LIMIT_WINDOW]
  call_timestamps.append(time.time())

def api_request(method, path, params=None):
  """Make an authenticated request to the Asset Panda API."""
  rate_limit_wait()

  url = f"{BASE_URL}{path}"
  headers = {
    'Accept': 'application/json',
    'Content-Type': 'application/json',
    'Access-Key-Id': AP_API_KEY,
    'Access-Key-Secret': AP_API_SECRET,
  }

  backoff = 1.0
  for attempt in range(3):
    try:
      if method == 'GET':
        response = http.request(method, url, headers=headers, fields=params)
      else:
        body = json.dumps(params or {}).encode('utf-8')
        response = http.request(method, url, headers=headers, body=body)

      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, 60.0)
        continue

      if response.status == 200:
        return json.loads(response.data.decode('utf-8'))

      print(f"HTTP {response.status}: {response.data.decode('utf-8')[:500]}")
      return None

    except Exception as e:
      print(f"Request error (attempt {attempt + 1}): {e}")
      if attempt < 2:
        time.sleep(backoff)
        backoff *= 2

  return None

def parse_datetime(value):
  """Parse ISO datetime string to datetime object."""
  if not value:
    return None
  if value.endswith("Z"):
    value = value[:-1] + "+00:00"
  try:
    return datetime.fromisoformat(value)
  except Exception:
    return None

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

  Args:
    cloud_event: CloudEvent object containing Pub/Sub message
  """
  if not all([GCS_BUCKET, AP_API_KEY, AP_API_SECRET, AP_GROUP_IDS]):
    print('Error: Missing required environment variables')
    return

  group_ids = [gid.strip() for gid in AP_GROUP_IDS.split(',') if gid.strip()]
  if not group_ids:
    print('Error: No group IDs configured')
    return

  try:
    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_run_time"):
      try:
        last_time = parse_datetime(state["last_run_time"])
        if last_time:
          last_time = last_time - timedelta(minutes=2)
      except Exception as e:
        print(f"Warning: Could not parse last_run_time: {e}")

    if last_time is None:
      last_time = now - timedelta(hours=LOOKBACK_HOURS)

    print(f"Collecting change logs from {last_time.isoformat()} to {now.isoformat()}")

    all_records = []

    for group_id in group_ids:
      if len(all_records) >= MAX_RECORDS:
        print(f"Reached max_records limit ({MAX_RECORDS})")
        break

      records = fetch_group_change_logs(group_id, last_time, now)
      all_records.extend(records)
      print(f"Group {group_id}: collected {len(records)} change log entries")

    if not all_records:
      print("No new change 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
    save_state(bucket, STATE_KEY, now.isoformat())
    print(f"Successfully processed {len(all_records)} records")

  except Exception as e:
    print(f'Error processing change logs: {str(e)}')
    raise

def fetch_group_change_logs(group_id, start_time, end_time):
  """
  Fetch change logs for all objects in a group.

  Args:
    group_id: Asset Panda group ID
    start_time: Start time for log query
    end_time: End time for log query

  Returns:
    List of change log records
  """
  records = []
  offset = 0

  # Iterate through objects in the group
  while True:
    if len(records) >= MAX_RECORDS:
      break

    search_data = api_request(
      'POST',
      f'/v3/groups/{group_id}/search_objects',
      {'offset': offset, 'limit': PAGE_SIZE}
    )

    if not search_data:
      break

    objects = search_data.get('objects', [])
    if not objects:
      break

    for obj in objects:
      object_id = obj.get('id')
      if not object_id:
        continue

      change_logs = fetch_object_change_logs(
        object_id, group_id, start_time, end_time
      )
      records.extend(change_logs)

      if len(records) >= MAX_RECORDS:
        break

    total = search_data.get('totals', {}).get('objects', 0)
    offset += len(objects)
    if offset >= total:
      break

  return records

def fetch_object_change_logs(object_id, group_id, start_time, end_time):
  """
  Fetch change logs for a specific object.

  Args:
    object_id: Asset Panda object ID
    group_id: Asset Panda group ID
    start_time: Start time filter
    end_time: End time filter

  Returns:
    List of change log records with metadata
  """
  records = []
  offset = 0

  while True:
    data = api_request(
      'GET',
      f'/v3/entity_objects/{object_id}/change_logs',
      {'limit': PAGE_SIZE, 'offset': offset}
    )

    if not data:
      break

    logs = data.get('change_logs', data.get('data', []))
    if isinstance(logs, dict):
      logs = [logs]

    if not logs:
      break

    for log_entry in logs:
      log_time = parse_datetime(
        log_entry.get('created_at') or log_entry.get('updated_at', '')
      )

      if log_time and log_time < start_time:
        return records
      if log_time and log_time > end_time:
        continue

      log_entry['_group_id'] = group_id
      log_entry['_object_id'] = object_id
      records.append(log_entry)

    if len(logs) < PAGE_SIZE:
      break

    offset += len(logs)

  return records

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_run_time_iso):
  """Save the last run timestamp to GCS state file."""
  try:
    state = {'last_run_time': last_run_time_iso}
    blob = bucket.blob(key)
    blob.upload_from_string(
      json.dumps(state, indent=2),
      content_type='application/json'
    )
    print(f"Saved state: last_run_time={last_run_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

לוחצים על Deploy כדי לשמור ולפרוס את הפונקציה.
מחכים שהפריסה תסתיים (2-3 דקות).

הערה: הגדרת הטריגר של Pub/Sub יוצרת באופן אוטומטי את המינויים וההרשאות הנדרשים. ב-Asset Panda יש הגבלת קצב של 400 קריאות לכל חלון זמן של 3 דקות לכל כתובת IP. הפונקציה כוללת הגבלת קצב מובנית כדי לעמוד במגבלה הזו.

יצירת משימה ב-Cloud Scheduler

‫Cloud Scheduler יפרסם הודעות בנושא Pub/Sub במרווחי זמן קבועים, ויפעיל את פונקציית Cloud Run.

במסוף GCP, נכנסים ל-Cloud Scheduler.
לוחצים על Create Job.

ממלאים את פרטי ההגדרה הבאים:

הגדרה	ערך
שם	`asset-panda-logs-collector-hourly`
אזור	בוחרים את אותו אזור כמו של פונקציית Cloud Run.
תדירות	‫`0 * * * *` (כל שעה, בשעה עגולה)
אזור זמן	בחירת אזור זמן (מומלץ לבחור ב-UTC)
סוג היעד	Pub/Sub
נושא	בוחרים את הנושא `asset-panda-logs-trigger`
גוף ההודעה	‫`{}` (אובייקט JSON ריק)

לוחצים על יצירה.

אפשרויות לתדירות התזמון

בוחרים את התדירות בהתאם לנפח היומן ולדרישות לגבי זמן האחזור:

תדירות	ביטוי Cron	תרחיש לדוגמה
כל שעה	`0 * * * *`	רגיל (מומלץ)
כל שעתיים	`0 /2 * *`	החלשה של עוצמת הקול
כל 6 שעות	`0 /6 * *`	נפח נמוך, עיבוד ברצף (batch processing)

בדיקת השילוב

במסוף Cloud Scheduler, מוצאים את המשימה.
לוחצים על Force run כדי להפעיל את המשימה באופן ידני.
מחכים כמה שניות.
נכנסים לדף Cloud Run > Services.
לוחצים על שם הפונקציה asset-panda-logs-collector.
לוחצים על הכרטיסייה Logs.

מוודאים שהפונקציה בוצעה בהצלחה. חפשו את:

Collecting change logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
Group 12345: collected X change log entries
Wrote X records to gs://asset-panda-change-logs/asset-panda/logs_YYYYMMDD_HHMMSS.ndjson
Successfully processed X records

נכנסים לדף Cloud Storage > Buckets.
לוחצים על שם הקטגוריה.
עוברים לתיקיית הקידומת asset-panda/.
מוודאים שנוצר קובץ .ndjson חדש עם חותמת הזמן הנוכחית.

אם מופיעות שגיאות ביומנים:

‫HTTP 401: בודקים את פרטי הכניסה ל-API במשתני הסביבה. מוודאים שמפתח ה-API והסוד נכונים.
‫HTTP 403: מוודאים שהרשאות הקריאה מופעלות במפתח ה-API.
‫HTTP 429: הגבלת קצב של יצירת בקשות – הפונקציה תנסה שוב באופן אוטומטי עם השהיה.
תוצאות ריקות: צריך לוודא שמזהי הקבוצות שהוגדרו קיימים ומכילים אובייקטים עם היסטוריית שינויים.
משתני סביבה חסרים: ודאו שכל המשתנים הנדרשים מוגדרים.

הגדרת פיד ב-Google SecOps כדי להטמיע יומנים של Asset Panda

עוברים אל הגדרות > ניהול נתונים > פידים. אם אתם משתמשים בפלטפורמה של SIEM בלבד, עוברים אל הגדרות > פידים.
לוחצים על הוספת פיד חדש.
לוחצים על הגדרת פיד יחיד.
בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Asset Panda Change Logs).
בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
בוחרים באפשרות Asset Panda בתור סוג היומן.
לוחצים על Get Service Account (קבלת חשבון שירות). תוצג כתובת אימייל ייחודית של חשבון שירות, לדוגמה:
```
chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com
```
מעתיקים את כתובת האימייל הזו כדי להשתמש בה בשלב הבא.

הערה: לכל מכונה של Google SecOps יש חשבון שירות ייחודי. אל תשתמשו בחשבונות שירות ממסמכים או מדוגמאות אחרים.
לוחצים על הבא.
מציינים ערכים לפרמטרים הבאים של הקלט:
- כתובת ה-URL של קטגוריית האחסון: מזינים את ה-URI של קטגוריית GCS עם נתיב הקידומת:
```
gs://asset-panda-change-logs/asset-panda/
```
  - מחליפים את:
    - ‫asset-panda-change-logs: השם של קטגוריית GCS.
    - ‫asset-panda: נתיב אופציונלי לתיקייה או לתחילית שבהם נשמרים היומנים (משאירים ריק בשביל תיקיית הבסיס).
הערה: תמיד צריך לכלול את הלוכסן (/) בסוף ה-URI.
- אפשרות מחיקת המקור: בוחרים את אפשרות המחיקה המועדפת:
  - Never: אף פעם לא למחוק קבצים אחרי העברות (מומלץ לבדיקה).
  - מחיקת קבצים שהועברו: מחיקת קבצים אחרי שהם הועברו בהצלחה.
  - מחיקת קבצים שהועברו וספריות ריקות: מחיקת קבצים וספריות ריקות אחרי שההעברה מסתיימת.
  הערה: אם בוחרים באפשרות מחיקה, לחשבון השירות צריך להיות התפקיד אדמין של אובייקטים ב-Storage במקום התפקיד 'צפייה באובייקטים ב-Storage'. מעדכנים את הרשאות ה-IAM בהתאם.
- גיל הקובץ המקסימלי: כולל קבצים ששונו במספר הימים האחרונים (ברירת המחדל היא 180 ימים)
- מרחב השמות של הנכס: מרחב השמות של הנכס
- תוויות הטמעה: התווית שתתווסף לאירועים מהפיד הזה
לוחצים על הבא.
בודקים את הגדרות הפיד החדש במסך סיום ולוחצים על שליחה.

מתן הרשאות IAM לחשבון השירות של Google SecOps

לחשבון השירות של Google SecOps צריך להיות התפקיד צפייה באובייקט אחסון בקטגוריה של GCS.

נכנסים לדף Cloud Storage > Buckets.
לוחצים על שם הקטגוריה.
עוברים לכרטיסייה Permissions.
לוחצים על הענקת גישה.
מזינים את פרטי ההגדרה הבאים:
- Add principals: מדביקים את כתובת האימייל של חשבון השירות של Google SecOps.
- Assign roles: בוחרים באפשרות Storage Object Viewer.
לוחצים על Save.

הערה: אם אתם מתכננים להשתמש באפשרות המחיקה "מחיקת קבצים שהועברו" או "מחיקת קבצים שהועברו וספריות ריקות", הקצו את התפקיד אדמין של אובייקטים ב-Cloud Storage במקום "צפייה באובייקטים ב-Cloud Storage".

טבלת מיפוי UDM

שדה ביומן	מיפוי UDM	Logic (פונקציה לוגית)
`array_values_label`	`additional.fields`	ממוזג
`data_label`	`additional.fields`	ממוזג
`field_values_label`	`additional.fields`	ממוזג
`low_values_label`	`additional.fields`	ממוזג
`value_ids_label`	`additional.fields`	ממוזג
`values_label`	`additional.fields`	ממוזג
`display_with_secondary`	`intermediary.user.user_display_name`	מיפוי ישיר
`secondary_name`	`intermediary.user.userid`	מיפוי ישיר
`created_at`	`metadata.event_timestamp`	נותח בתור `RFC 3339`
`has_user`	`metadata.event_type`	מופה: `true` ← `USER_UNCATEGORIZED`
`object_version_ids`	`metadata.product_version`	מיפוי ישיר
`share_url`	`metadata.url_back_to_product`	מיפוי ישיר
`display_name`	`principal.user.user_display_name`	מיפוי ישיר
`id`	`principal.user.userid`	מיפוי ישיר
`account_id_label`	`security_result.detection_fields`	ממוזג
`change_source_label`	`security_result.detection_fields`	ממוזג
`change_trigger_label`	`security_result.detection_fields`	ממוזג
`created_at_label`	`security_result.detection_fields`	ממוזג
`date_format_label`	`security_result.detection_fields`	ממוזג
`docusign_envelope_id_label`	`security_result.detection_fields`	ממוזג
`embedded_into_object_id_label`	`security_result.detection_fields`	ממוזג
`entity_action_id_label`	`security_result.detection_fields`	ממוזג
`entity_id_label`	`security_result.detection_fields`	ממוזג
`entity_id_label1`	`security_result.detection_fields`	ממוזג
`entity_key_label`	`security_result.detection_fields`	ממוזג
`google_calendar_sync_label`	`security_result.detection_fields`	ממוזג
`gps_coordinates_label`	`security_result.detection_fields`	ממוזג
`has_audit_history_label`	`security_result.detection_fields`	ממוזג
`id_label`	`security_result.detection_fields`	ממוזג
`is_archived_label`	`security_result.detection_fields`	ממוזג
`is_deletable_label`	`security_result.detection_fields`	ממוזג
`is_editable_label`	`security_result.detection_fields`	ממוזג
`is_locked_label`	`security_result.detection_fields`	ממוזג
`linked_action_object_id_label`	`security_result.detection_fields`	ממוזג
`modifier_id_label`	`security_result.detection_fields`	ממוזג
`next_step_reservation_uid_label`	`security_result.detection_fields`	ממוזג
`object_appreciation_label`	`security_result.detection_fields`	ממוזג
`object_depreciation_label`	`security_result.detection_fields`	ממוזג
`oid_label`	`security_result.detection_fields`	ממוזג
`old_id_label`	`security_result.detection_fields`	ממוזג
`parent_action_object_id_label`	`security_result.detection_fields`	ממוזג
`predefined_forms_label`	`security_result.detection_fields`	ממוזג
`reservation_notification_label`	`security_result.detection_fields`	ממוזג
`reservation_uid_label`	`security_result.detection_fields`	ממוזג
`returned_label`	`security_result.detection_fields`	ממוזג
`state_label`	`security_result.detection_fields`	ממוזג
`status_label`	`security_result.detection_fields`	ממוזג
`updated_at_label`	`security_result.detection_fields`	ממוזג
`user_id_label`	`security_result.detection_fields`	ממוזג
`version_label`	`security_result.detection_fields`	ממוזג
לא רלוונטי	`metadata.event_type`	קבוע: `USER_UNCATEGORIZED`

יומן שינויים

הצגת יומן השינויים של המנתח הזה

הבעיה עדיין לא נפתרה? קבלת תשובות מחברי הקהילה וממומחי Google SecOps.