איסוף יומנים של בעיות בקבוצות Snyk

נתמך ב:

במסמך הזה מוסבר איך להטמיע ב-Google Security Operations יומנים של בעיות בקבוצות של Snyk באמצעות Google Cloud Storage. ‫Snyk היא פלטפורמת אבטחה למפתחים שעוזרת לארגונים למצוא ולתקן נקודות חולשה ביחסי תלות של קוד פתוח, קובצי אימג' של קונטיינרים, הגדרות של תשתית כקוד וקוד אפליקציה. התכונה "בעיות בקבוצת Snyk" מאפשרת לראות פרצות אבטחה ובעיות ברישיונות בכל הפרויקטים בקבוצת Snyk.

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

ודאו שאתם עומדים בדרישות המוקדמות הבאות:

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

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

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

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

איסוף מזהה הקבוצה וטוקן ה-API של Snyk

קבלת טוקן API של Snyk

  1. נכנסים לממשק המשתמש של Snyk בכתובת https://app.snyk.io.
  2. עוברים אל הגדרות החשבון > אסימון API.
  3. לוחצים על Generate (יצירה) כדי ליצור את אסימון ה-API.
  4. מעתיקים את האסימון ושומרים אותו במיקום מאובטח כדי להשתמש בו בהמשך בתור SNYK_TOKEN.

איך מקבלים מזהה קבוצה ב-Snyk

  1. בממשק המשתמש של Snyk, עוברים לקבוצה.
  2. עוברים אל הגדרות הקבוצה.
  3. מעתיקים את מזהה הקבוצה מכתובת ה-URL (https://app.snyk.io/group/<GROUP_ID>/...) ושומרים אותו לשימוש מאוחר יותר בתור GROUP_ID.

הקצאת תפקיד אדמין בקבוצה

  1. בממשק המשתמש של Snyk, עוברים אל Group settings > Members.
  2. מאתרים את המשתמש שמשויך לאסימון ה-API.
  3. מקצים למשתמש את התפקיד אדמין של קבוצה.

נקודת קצה ל-API של הערות

  • נקודת הקצה הבסיסית של ה-API בארכיטקטורת REST משתנה בהתאם לאזור. מזהים את האזור של Snyk ורושמים את כתובת ה-URL הבסיסית המתאימה ל-REST:

    אזור כתובת ה-URL הבסיסית של REST
    SNYK-US-01 https://api.snyk.io/rest
    SNYK-US-02 https://api.us.snyk.io/rest
    SNYK-EU-01 https://api.eu.snyk.io/rest
    SNYK-AU-01 https://api.au.snyk.io/rest

    כתובת ה-URL הבסיסית הזו של REST תשמש כ-API_BASE בהגדרת פונקציית Cloud Run. קוד הפונקציה יוצר כתובות URL מלאות של נקודות קצה על ידי הוספת נתיבים כמו /groups/{group_id}/audit_logs/search לכתובת ה-URL הבסיסית הזו.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1. במסוף GCP, נכנסים ל-Cloud Run.
  2. לוחצים על Create service.
  3. בוחרים באפשרות Function (שימוש בעורך ישיר כדי ליצור פונקציה).
  4. בקטע Configure, מזינים את פרטי ההגדרה הבאים:

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

    1. לוחצים על + הוספת טריגר.
    2. בוחרים באפשרות Cloud Pub/Sub.
    3. בקטע Select a Cloud Pub/Sub topic, בוחרים את הנושא snyk-logs-trigger.
    4. לוחצים על Save.
  6. בקטע אימות:

    1. לוחצים על דרישת אימות.
    2. בודקים את ניהול הזהויות והרשאות הגישה (IAM).
  7. גוללים למטה ומרחיבים את הקטע Containers, Networking, Security.

  8. עוברים לכרטיסייה אבטחה:

    • חשבון שירות: בוחרים את חשבון השירות snyk-logs-collector-sa.
  9. עוברים לכרטיסייה מאגרי תגים:

    1. לוחצים על Variables & Secrets.
    2. לוחצים על ‎+ Add variable לכל משתנה סביבה:
    שם משתנה ערך לדוגמה
    GCS_BUCKET snyk-group-logs
    GCS_PREFIX snyk/group/
    STATE_KEY snyk/group/state.json
    SNYK_TOKEN your-snyk-api-token
    GROUP_ID your-group-uuid
    API_BASE https://api.snyk.io/rest
    SNYK_AUDIT_API_VERSION 2024-10-15
    SNYK_ISSUES_API_VERSION 2024-10-15
    AUDIT_PAGE_SIZE 100
    ISSUES_PAGE_LIMIT 100
    MAX_PAGES 20
    LOOKBACK_SECONDS 3600
  10. גוללים למטה בכרטיסייה Variables & Secrets (משתנים וסודות) עד שמגיעים לקטע Requests (בקשות):

    • ‫Request timeout: מזינים 600 שניות (10 דקות).
  11. עוברים לכרטיסייה הגדרות בקטע מאגרים:

    • בקטע Resources:
      • זיכרון: בוחרים באפשרות ‎512 MiB או יותר.
      • מעבד (CPU): בוחרים באפשרות 1.
    • לוחצים על סיום.
  12. גוללים למטה אל Execution environment:

    • בוחרים באפשרות ברירת מחדל (מומלץ).
  13. בקטע Revision scaling:

    • מספר מינימלי של מכונות: מזינים 0.
    • Maximum number of instances: מזינים 100 (או משנים בהתאם לעומס הצפוי).
  14. לוחצים על יצירה.

  15. ממתינים ליצירת השירות (דקה או שתיים).

  16. אחרי שיוצרים את השירות, עורך הקוד המוטבע נפתח באופן אוטומטי.

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

  1. מזינים main בשדה Function entry point.
  2. בעורך הקוד, יוצרים שני קבצים:

    • הקובץ הראשון: main.py:

          import functions_framework
          from google.cloud import storage
          import json
          import os
          import time
          import urllib.parse
          from urllib.request import Request, urlopen
          from urllib.parse import urlparse, parse_qs
          from urllib.error import HTTPError
      
          # Initialize Storage client
          storage_client = storage.Client()
      
          @functions_framework.cloud_event
          def main(cloud_event):
              """
              Cloud Run function triggered by Pub/Sub to fetch logs from Snyk Group API and write to GCS.
      
              Args:
                  cloud_event: CloudEvent object containing Pub/Sub message
              """
      
              # Get environment variables
              bucket_name = os.environ.get('GCS_BUCKET')
              prefix = os.environ.get('GCS_PREFIX', 'snyk/group/').strip()
              state_key = os.environ.get('STATE_KEY', 'snyk/group/state.json').strip()
      
              # Snyk API credentials
              api_base = os.environ.get('API_BASE', 'https://api.snyk.io/rest').rstrip('/')
              snyk_token = os.environ.get('SNYK_TOKEN').strip()
              group_id = os.environ.get('GROUP_ID').strip()
      
              # Page sizes & limits
              audit_size = int(os.environ.get('AUDIT_PAGE_SIZE', '100'))
              issues_limit = int(os.environ.get('ISSUES_PAGE_LIMIT', '100'))
              max_pages = int(os.environ.get('MAX_PAGES', '20'))
      
              # API versions
              audit_api_version = os.environ.get('SNYK_AUDIT_API_VERSION', '2024-10-15').strip()
              issues_api_version = os.environ.get('SNYK_ISSUES_API_VERSION', '2024-10-15').strip()
      
              # First-run lookback
              lookback_seconds = int(os.environ.get('LOOKBACK_SECONDS', '3600'))
      
              if not all([bucket_name, snyk_token, group_id]):
                  print('Error: Missing required environment variables')
                  return
      
              try:
                  # Get GCS bucket
                  bucket = storage_client.bucket(bucket_name)
      
                  # Load state
                  state = load_state(bucket, state_key)
      
                  print('Starting Snyk Group logs collection')
      
                  # Pull audit logs
                  audit_res = pull_audit_logs(
                      bucket, prefix, state, api_base, snyk_token, group_id,
                      audit_api_version, audit_size, max_pages, lookback_seconds
                  )
                  print(f"Audit logs: {audit_res}")
      
                  # Pull issues
                  issues_res = pull_issues(
                      bucket, prefix, state, api_base, snyk_token, group_id,
                      issues_api_version, issues_limit, max_pages
                  )
                  print(f"Issues: {issues_res}")
      
                  # Save state
                  save_state(bucket, state_key, state)
      
                  print('Successfully completed Snyk Group logs collection')
      
              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: {str(e)}')
              return {}
      
          def save_state(bucket, key, state):
              """Save state to GCS."""
              try:
                  blob = bucket.blob(key)
                  blob.upload_from_string(
                      json.dumps(state, separators=(',', ':')),
                      content_type='application/json'
                  )
              except Exception as e:
                  print(f'Warning: Could not save state: {str(e)}')
      
          def _iso(ts):
              """Convert timestamp to ISO format."""
              return time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime(ts))
      
          def _http_get(url, headers):
              """Make HTTP GET request with retry logic."""
              req = Request(url, method='GET', headers=headers)
              try:
                  with urlopen(req, timeout=60) as r:
                      return json.loads(r.read().decode('utf-8'))
              except HTTPError as e:
                  if e.code in (429, 500, 502, 503, 504):
                      delay = int(e.headers.get('Retry-After', '1'))
                      time.sleep(max(1, delay))
                      with urlopen(req, timeout=60) as r2:
                          return json.loads(r2.read().decode('utf-8'))
                  raise
      
          def _write_page(bucket, prefix, kind, payload):
              """Write page to GCS."""
              ts = time.gmtime()
              key = f"{prefix.rstrip('/')}/{time.strftime('%Y/%m/%d/%H%M%S', ts)}-snyk-{kind}.json"
              blob = bucket.blob(key)
              blob.upload_from_string(
                  json.dumps(payload, separators=(',', ':')),
                  content_type='application/json'
              )
              return key
      
          def _next_href(links):
              """Extract next href from links."""
              if not links:
                  return None
              nxt = links.get('next')
              if not nxt:
                  return None
              if isinstance(nxt, str):
                  return nxt
              if isinstance(nxt, dict):
                  return nxt.get('href')
              return None
      
          def pull_audit_logs(bucket, prefix, state, api_base, snyk_token, group_id,
                              audit_api_version, audit_size, max_pages, lookback_seconds):
              """Pull audit logs from Snyk Group API."""
              headers = {
                  'Authorization': f'token {snyk_token}',
                  'Accept': 'application/vnd.api+json',
              }
      
              cursor = state.get('audit_cursor')
              pages = 0
              total = 0
              base = f"{api_base}/groups/{group_id}/audit_logs/search"
              params = {
                  'version': audit_api_version,
                  'size': audit_size
              }
      
              if cursor:
                  params['cursor'] = cursor
              else:
                  now = time.time()
                  params['from'] = _iso(now - lookback_seconds)
                  params['to'] = _iso(now)
      
              while pages < max_pages:
                  url = f"{base}?{urllib.parse.urlencode(params, doseq=True)}"
                  payload = _http_get(url, headers)
                  _write_page(bucket, prefix, 'audit', payload)
      
                  data_items = (payload.get('data') or {}).get('items') or []
                  if isinstance(data_items, list):
                      total += len(data_items)
      
                  nxt = _next_href(payload.get('links'))
                  if not nxt:
                      break
      
                  q = parse_qs(urlparse(nxt).query)
                  cur = (q.get('cursor') or [None])[0]
                  if not cur:
                      break
      
                  params = {
                      'version': audit_api_version,
                      'size': audit_size,
                      'cursor': cur
                  }
                  state['audit_cursor'] = cur
                  pages += 1
      
              return {
                  'pages': pages + 1 if total else pages,
                  'items': total,
                  'cursor': state.get('audit_cursor')
              }
      
          def pull_issues(bucket, prefix, state, api_base, snyk_token, group_id,
                          issues_api_version, issues_limit, max_pages):
              """Pull issues from Snyk Group API."""
              headers = {
                  'Authorization': f'token {snyk_token}',
                  'Accept': 'application/vnd.api+json',
              }
      
              cursor = state.get('issues_cursor')
              pages = 0
              total = 0
              base = f"{api_base}/groups/{group_id}/issues"
              params = {
                  'version': issues_api_version,
                  'limit': issues_limit
              }
      
              if cursor:
                  params['starting_after'] = cursor
      
              while pages < max_pages:
                  url = f"{base}?{urllib.parse.urlencode(params, doseq=True)}"
                  payload = _http_get(url, headers)
                  _write_page(bucket, prefix, 'issues', payload)
      
                  data_items = payload.get('data') or []
                  if isinstance(data_items, list):
                      total += len(data_items)
      
                  nxt = _next_href(payload.get('links'))
                  if not nxt:
                      break
      
                  q = parse_qs(urlparse(nxt).query)
                  cur = (q.get('starting_after') or [None])[0]
                  if not cur:
                      break
      
                  params = {
                      'version': issues_api_version,
                      'limit': issues_limit,
                      'starting_after': cur
                  }
                  state['issues_cursor'] = cur
                  pages += 1
      
              return {
                  'pages': pages + 1 if total else pages,
                  'items': total,
                  'cursor': state.get('issues_cursor')
              }
          ```
      
    • הקובץ השני: requirements.txt:

      functions-framework==3.*
      google-cloud-storage==2.*
      
  3. לוחצים על Deploy כדי לשמור ולפרוס את הפונקציה.

  4. מחכים שהפריסה תסתיים (2-3 דקות).

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

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

  1. במסוף GCP, נכנסים ל-Cloud Scheduler.
  2. לוחצים על Create Job.
  3. ממלאים את פרטי ההגדרה הבאים:

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

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

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

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

בדיקת המשימה המתוזמנת

  1. במסוף Cloud Scheduler, מוצאים את המשימה.
  2. לוחצים על הפעלה ידנית כדי להפעיל את המשימה באופן ידני.
  3. מחכים כמה שניות ועוברים אל Cloud Run > Services > snyk-group-logs-collector > Logs.
  4. מוודאים שהפונקציה בוצעה בהצלחה.
  5. בודקים את הקטגוריה ב-GCS כדי לוודא שהיומנים נכתבו.

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

מערכת Google SecOps משתמשת בחשבון שירות ייחודי כדי לקרוא נתונים מהקטגוריה שלכם ב-GCS. אתם צריכים לתת לחשבון השירות הזה גישה לקטגוריה שלכם.

איך מקבלים את כתובת האימייל של חשבון השירות

  1. עוברים אל הגדרות > ניהול נתונים > פידים. אם אתם משתמשים בפלטפורמה של SIEM בלבד, עוברים אל הגדרות > פידים.
  2. לוחצים על הוספת פיד חדש.
  3. לוחצים על הגדרת פיד יחיד.
  4. בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Snyk Group Audit/Issues).
  5. בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
  6. בוחרים באפשרות Snyk Group level audit/issues logs בתור Log type.
  7. לוחצים על Get Service Account (קבלת חשבון שירות). מוצגת כתובת אימייל ייחודית של חשבון שירות, לדוגמה:

    chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com
    
  8. מעתיקים את כתובת האימייל הזו כדי להשתמש בה בשלב הבא.

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

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

  1. נכנסים לדף Cloud Storage > Buckets.
  2. לוחצים על שם הקטגוריה.
  3. עוברים לכרטיסייה Permissions.
  4. לוחצים על הענקת גישה.
  5. מזינים את פרטי ההגדרה הבאים:
    • הוספת חשבונות משתמשים: מדביקים את כתובת האימייל של חשבון השירות של Google SecOps.
    • הקצאת תפקידים: בוחרים באפשרות צפייה באובייקטים באחסון.
  6. לוחצים על Save.

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

  1. עוברים אל הגדרות > ניהול נתונים > פידים. אם אתם משתמשים בפלטפורמה של SIEM בלבד, עוברים אל הגדרות > פידים.
  2. לוחצים על הוספת פיד חדש.
  3. לוחצים על הגדרת פיד יחיד.
  4. בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Snyk Group Audit/Issues).
  5. בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
  6. בוחרים באפשרות Snyk Group level audit/issues logs בתור Log type.
  7. לוחצים על הבא.
  8. מציינים ערכים לפרמטרים הבאים של הקלט:

    • כתובת ה-URL של קטגוריית האחסון: מזינים את ה-URI של קטגוריית GCS עם נתיב הקידומת:

      gs://snyk-group-logs/snyk/group/
      
      • מחליפים את:

        • ‫snyk-group-logs: השם של קטגוריית GCS.
        • ‫snyk/group/: נתיב אופציונלי לתיקייה או לתחילית שבהם נשמרים היומנים (משאירים ריק בשביל תיקיית הבסיס).
      • לדוגמה:

        • קטגוריית הבסיס: gs://company-logs/
        • עם הקידומת: gs://company-logs/snyk-logs/
        • עם תיקיית משנה: gs://company-logs/snyk/group/
    • אפשרות מחיקת המקור: בוחרים את אפשרות המחיקה הרצויה:
      • Never: אף פעם לא למחוק קבצים אחרי העברות (מומלץ לבדיקה).
      • מחיקת קבצים שהועברו: מחיקת קבצים אחרי שהם הועברו בהצלחה.
      • מחיקת קבצים שהועברו וספריות ריקות: מחיקת קבצים וספריות ריקות אחרי שההעברה מסתיימת.
    • גיל הקובץ המקסימלי: כולל קבצים ששונו במספר הימים האחרונים. ברירת המחדל היא 180 ימים.
    • מרחב השמות של הנכס: מרחב השמות של הנכס (לדוגמה, snyk.group).
    • תוויות הטמעה: התווית שתתווסף לאירועים מהפיד הזה.
  9. לוחצים על הבא.

  10. בודקים את הגדרות הפיד החדש במסך סיום ולוחצים על שליחה.

טבלת מיפוי UDM

שדה ביומן מיפוי UDM Logic (פונקציה לוגית)
gitignore_label additional.fields ממוזג
limit_label additional.fields ממוזג
version_label additional.fields ממוזג
created metadata.event_timestamp נותח בתור RFC3339
org_created metadata.event_timestamp נותח בתור RFC3339
project_created metadata.event_timestamp נותח בתור RFC3339
project_lastTestedDate metadata.event_timestamp נותח בתור RFC3339
has_principal metadata.event_type מופה: true ← NETWORK_CONNECTION, true ← STATUS_UPDATE
eventdata metadata.product_event_type מיפוי ישיר
content.http_method network.http.method מיפוי ישיר
content.requestId network.session_id מיפוי ישיר
org_name principal.administrative_domain מיפוי ישיר
snyk_request_id_label principal.resource.attribute.labels ממוזג
org_url principal.url מיפוי ישיר
groupcreated_label principal.user.attribute.labels ממוזג
groupname_label principal.user.attribute.labels ממוזג
groupurl_label principal.user.attribute.labels ממוזג
orgId_label principal.user.attribute.labels ממוזג
orggroupid_label principal.user.attribute.labels ממוזג
orgslug_label principal.user.attribute.labels ממוזג
groupId principal.user.groupid מיפוי ישיר
org_group_name principal.user.groupid מיפוי ישיר
issueCountsBySeverity_critical_label security_result.about.labels ממוזג
issueCountsBySeverity_high_label security_result.about.labels ממוזג
issueCountsBySeverity_low_label security_result.about.labels ממוזג
issueCountsBySeverity_medium_label security_result.about.labels ממוזג
content.action security_result.action_details מיפוי ישיר
project_type target.application מיפוי ישיר
branch_label target.resource.attribute.labels ממוזג
id_label target.resource.attribute.labels ממוזג
imageTag_label target.resource.attribute.labels ממוזג
isMonitored_label target.resource.attribute.labels ממוזג
origin_label target.resource.attribute.labels ממוזג
project_id_label target.resource.attribute.labels ממוזג
readOnly_label target.resource.attribute.labels ממוזג
testFrequency_label target.resource.attribute.labels ממוזג
totalDependencies_label target.resource.attribute.labels ממוזג
project_id target.resource.id מיפוי ישיר
project_name target.resource.name מיפוי ישיר
content_url target.url מיפוי ישיר
project_browseUrl target.url מיפוי ישיר
לא רלוונטי metadata.event_type קבוע: NETWORK_CONNECTION
לא רלוונטי metadata.product_name קבוע: SNYK_ISSUES
לא רלוונטי metadata.vendor_name קבוע: SNYK_ISSUES

יומן שינויים

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

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