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

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

נתמך ב:

Google SecOps SIEM

במאמר הזה מוסבר איך להטמיע יומנים של בעיות בקבוצת Snyk ב-Google Security Operations באמצעות 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

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

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

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

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

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

קבלת טוקן Snyk API

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

הערה: האסימון הזה ישמש את פונקציית Cloud Run לאימות ב-Snyk API.

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

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

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

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

הערה: למשתמש צריכה להיות אפשרות לראות את יומני הביקורת של הקבוצה ואת הבעיות בקבוצה.

נקודת קצה ל-API של Note

נקודת הקצה הבסיסית של ה-API בארכיטקטורת REST משתנה בהתאם לאזור. מזהים את האזור שלכם ב-Snyk ורושמים את כתובת הבסיס המתאימה של 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.

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

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

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

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

מתן הרשאות IAM בקטגוריית GCS

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

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

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

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

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

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

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

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

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

הגדרה	ערך
שם השירות	`snyk-group-logs-collector`
אזור	בוחרים אזור שתואם ל-GCS Bucket (לדוגמה, `us-central1`)
זמן ריצה	בוחרים באפשרות Python 3.12 ואילך.

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

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

לוחצים על Variables & Secrets (משתנים וסודות).
לוחצים על + הוספת משתנה לכל משתנה סביבתי:

שם המשתנה	ערך לדוגמה
`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`

בכרטיסייה Variables & Secrets, גוללים למטה אל Requests:
- זמן קצוב לתפוגת בקשה: מזינים 600 שניות (10 דקות).
עוברים לכרטיסייה הגדרות במאגרי תגים:
- בקטע Resources (מקורות מידע):
  - זיכרון: בוחרים באפשרות ‎512 MiB או יותר.
  - מעבד: בוחרים באפשרות 1.
- לוחצים על סיום.
גוללים למטה אל סביבת הפעלה:
- בוחרים באפשרות ברירת מחדל (מומלץ).
בקטע שינוי קנה מידה של העריכה:
- מספר המינימום של מופעים: מזינים 0.
- מספר מקסימלי של מופעים: מזינים 100 (או משנים בהתאם לעומס הצפוי).
לוחצים על יצירה.
ממתינים ליצירת השירות (1-2 דקות).
אחרי שיוצרים את השירות, עורך הקוד המוטבע נפתח באופן אוטומטי.

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

מזינים main בFunction entry point

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

הקובץ הראשון: 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.*

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

הערה: הגדרת הטריגר Pub/Sub יוצרת באופן אוטומטי את המינויים וההרשאות הנדרשים.

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

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

במסוף GCP, עוברים אל Cloud Scheduler.
לוחצים על Create Job (יצירת משימה).

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

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

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

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

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

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

בדיקת משימת המתזמן

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

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

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

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

עוברים אל SIEM Settings > Feeds (הגדרות SIEM > פידים).
לוחצים על הוספת פיד חדש.
לוחצים על Configure a single feed (הגדרת פיד יחיד).
בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Snyk Group Audit/Issues).
בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
בוחרים באפשרות Snyk Group level audit/issues logs (יומני ביקורת או בעיות ברמת הקבוצה ב-Snyk) בתור Log type (סוג היומן).
לוחצים על קבלת חשבון שירות. מוצגת כתובת אימייל ייחודית של חשבון השירות, לדוגמה:
```
chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com
```
מעתיקים את כתובת האימייל הזו לשימוש בשלב הבא.

הערה: לכל מופע של Google SecOps יש חשבון שירות ייחודי. אל תשתמשו בחשבונות שירות ממסמכים או מדוגמאות אחרים.

הענקת הרשאות IAM לחשבון השירות של Google SecOps

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

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

הערה: אם אתם מתכננים להשתמש באפשרות המחיקה 'מחיקת קבצים שהועברו' או 'מחיקת קבצים שהועברו וספריות ריקות', צריך להעניק את התפקיד Storage Object Admin במקום Storage Object Viewer.

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

עוברים אל SIEM Settings > Feeds (הגדרות SIEM > פידים).
לוחצים על הוספת פיד חדש.
לוחצים על Configure a single feed (הגדרת פיד יחיד).
בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Snyk Group Audit/Issues).
בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
בוחרים באפשרות Snyk Group level audit/issues logs (יומני ביקורת או בעיות ברמת הקבוצה ב-Snyk) בתור Log type (סוג היומן).
לוחצים על הבא.
מציינים ערכים לפרמטרים הבאים של הקלט:
- כתובת ה-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/
הערה: תמיד צריך לכלול את התו '/' בסוף ה-URI.
- אפשרות מחיקת המקור: בוחרים את אפשרות המחיקה הרצויה:
  - אף פעם: לא נמחקים קבצים אחרי ההעברה (מומלץ לבדיקות).
  - מחיקת קבצים שהועברו: הקבצים נמחקים אחרי שההעברה מסתיימת.
  - מחיקת קבצים שהועברו וספריות ריקות: מחיקת קבצים וספריות ריקות אחרי שההעברה מסתיימת בהצלחה.
הערה: אם בוחרים באפשרות מחיקה, לחשבון השירות צריך להיות תפקיד Storage Object Admin במקום Storage Object Viewer. מעדכנים את ההרשאות ב-IAM בהתאם.
- הגיל המקסימלי של הקובץ: כולל קבצים שעברו שינוי במספר הימים האחרון. ברירת המחדל היא 180 ימים.
- מרחב שמות של נכס: מרחב השמות של הנכס (לדוגמה, snyk.group).
- תוויות להוספה: התווית שתתווסף לאירועים מהפיד הזה.
לוחצים על הבא.
בודקים את ההגדרות של הפיד החדש במסך סיום ולוחצים על שליחה.

טבלת מיפוי UDM

שדה ביומן	מיפוי UDM	היגיון
`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.