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

איסוף יומני ביקורת של Harness IO

נתמך ב:

Google SecOps SIEM

במאמר הזה מוסבר איך להטמיע יומני ביקורת של Harness IO ב-Google Security Operations באמצעות Google Cloud Storage. ‫Harness היא פלטפורמת DevOps ופיתוח רציף (continuous delivery) שמספקת כלים להכנת תוכנה להפצה, ל-feature flag, לניהול עלויות בענן ולבדיקות אבטחה.

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

חשוב לוודא שמתקיימות הדרישות המוקדמות הבאות:

מופע של Google SecOps
פרויקט ב-GCP עם Cloud Storage API מופעל
הרשאות ליצירה ולניהול של מאגרי GCS
הרשאות לניהול מדיניות IAM בקטגוריות GCS
הרשאות ליצירת שירותי Cloud Run, נושאי Pub/Sub ומשימות Cloud Scheduler
גישה עם הרשאות מיוחדות ל-Harness, עם ההרשאות הבאות:
- יצירת מפתחות API
- יומני ביקורת של גישה
- הצגת הגדרות החשבון

איסוף פרטי הכניסה ל-Harness API

יצירת מפתח API ב-Harness

נכנסים ל-Harness Platform.
לוחצים על פרופיל המשתמש.
עוברים אל My API Keys (מפתחות ה-API שלי).
לוחצים על + API Key (מפתח API).
מספקים את פרטי ההגדרה הבאים:
- שם: מזינים שם תיאורי (לדוגמה, Google SecOps Integration).
- תיאור: תיאור אופציונלי.
לוחצים על Save.
לוחצים על + Token (אסימון חדש) כדי ליצור אסימון חדש.
מזינים את פרטי ההגדרה הבאים:
- שם: מזינים Chronicle Feed Token.
- הגדרת תפוגה: בוחרים את זמן התפוגה המתאים או ללא תפוגה (לשימוש בסביבת ייצור).
לוחצים על יצירת אסימון.
מעתיקים ושומרים את ערך הטוקן באופן מאובטח. הטוקן הזה ישמש כערך של הכותרת x-api-key.

הערה: האסימון מוצג רק פעם אחת. אם איבדתם אותו, תצטרכו ליצור אסימון חדש.
הערה: לאסימון ה-API צריכה להיות הרשאה core_audit_view לגשת ליומני ביקורת. בדרך כלל מקבלים את ההרשאה הזאת באמצעות הקצאות תפקידים ב-Harness.

קבלת מספר החשבון ב-Harness

ב-Harness Platform, רושמים את מזהה החשבון מכתובת ה-URL.

כתובת URL לדוגמה: https://app.harness.io/ng/account/YOUR_ACCOUNT_ID/.... החלק YOUR_ACCOUNT_ID הוא מזהה החשבון שלכם.

אפשר גם לעבור אל הגדרות חשבון > סקירה כללית כדי לראות את מזהה החשבון.

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

הערה: מזהה החשבון נדרש לכל בקשות ה-API ל-Harness.

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

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

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

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

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

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

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

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

במסוף GCP, נכנסים לדף IAM & Admin > Service Accounts.
לוחצים על יצירת חשבון שירות.
מספקים את פרטי ההגדרה הבאים:
- Service account name: מזינים harness-audit-collector-sa.
- תיאור חשבון השירות: מזינים Service account for Cloud Run function to collect Harness IO audit 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 ובוחרים אותו.
לוחצים על Continue.
לוחצים על סיום.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

שם המשתנה	ערך לדוגמה	תיאור
`HARNESS_ACCOUNT_ID`	מספר החשבון שלכם ב-Harness	מזהה החשבון מ-Harness
`HARNESS_API_KEY`	טוקן מפתח ה-API	אסימון עם הרשאות audit:read
`GCS_BUCKET`	`harness-io-logs`	שם קטגוריית GCS
`GCS_PREFIX`	`harness/audit`	קידומת לאובייקטים ב-GCS
`STATE_KEY`	`harness/audit/state.json`	נתיב קובץ תמונת המצב ב-GCS

משתני סביבה אופציונליים:

שם משתנה	ערך ברירת המחדל	תיאור
`HARNESS_API_BASE`	`https://app.harness.io`	כתובת ה-URL הבסיסית של Harness API (החלפה במקרים של מופעים באירוח עצמי)
`PAGE_SIZE`	`50`	אירועים לכל דף (עד 100)
`START_MINUTES_BACK`	`60`	תקופת המבט לאחור הראשונית בדקות
`FILTER_MODULES`	ללא	מודולים מופרדים בפסיקים (לדוגמה, `CD,CI,CE`)
`FILTER_ACTIONS`	ללא	פעולות מופרדות בפסיקים (לדוגמה, `CREATE,UPDATE,DELETE`)
`STATIC_FILTER`	ללא	מסנן מוגדר מראש: `EXCLUDE_LOGIN_EVENTS` או `EXCLUDE_SYSTEM_EVENTS`
`MAX_RETRIES`	`3`	מספר הניסיונות המקסימלי להגבלת קצב של יצירת בקשות

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

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

מזינים main בFunction entry point

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

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

import functions_framework
from google.cloud import storage
import json
import os
import urllib3
from datetime import datetime, timedelta, timezone
import time

# Initialize HTTP client
http = urllib3.PoolManager()

# Initialize Storage client
storage_client = storage.Client()

# Configuration from Environment Variables
API_BASE = os.environ.get("HARNESS_API_BASE", "https://app.harness.io").rstrip("/")
ACCOUNT_ID = os.environ["HARNESS_ACCOUNT_ID"]
API_KEY = os.environ["HARNESS_API_KEY"]
BUCKET = os.environ["GCS_BUCKET"]
PREFIX = os.environ.get("GCS_PREFIX", "harness/audit").strip("/")
STATE_KEY = os.environ.get("STATE_KEY", "harness/audit/state.json")
PAGE_SIZE = min(int(os.environ.get("PAGE_SIZE", "50")), 100)
START_MINUTES_BACK = int(os.environ.get("START_MINUTES_BACK", "60"))

# Optional filters
FILTER_MODULES = os.environ.get("FILTER_MODULES", "").split(",") if os.environ.get("FILTER_MODULES") else None
FILTER_ACTIONS = os.environ.get("FILTER_ACTIONS", "").split(",") if os.environ.get("FILTER_ACTIONS") else None
STATIC_FILTER = os.environ.get("STATIC_FILTER")
MAX_RETRIES = int(os.environ.get("MAX_RETRIES", "3"))

# HTTP headers for Harness API
HDRS = {
    "x-api-key": API_KEY,
    "Content-Type": "application/json",
    "Accept": "application/json",
}

def read_state(bucket):
    """Read checkpoint state from GCS."""
    try:
        blob = bucket.blob(STATE_KEY)
        if blob.exists():
            state_data = blob.download_as_text()
            state = json.loads(state_data)
            since_ms = state.get("since")
            page_token = state.get("pageToken")
            print(f"State loaded: since={since_ms}, pageToken={page_token}")
            return since_ms, page_token
    except Exception as e:
        print(f"Warning: Could not load state: {e}")

    print("No state file found, starting fresh collection")
    start_time = datetime.now(timezone.utc) - timedelta(minutes=START_MINUTES_BACK)
    since_ms = int(start_time.timestamp() * 1000)
    print(f"Initial since timestamp: {since_ms} ({start_time.isoformat()})")
    return since_ms, None

def write_state(bucket, since_ms, page_token=None):
    """Write checkpoint state to GCS."""
    state = {
        "since": since_ms,
        "pageToken": page_token,
        "lastRun": int(time.time() * 1000),
        "lastRunISO": datetime.now(timezone.utc).isoformat()
    }
    try:
        blob = bucket.blob(STATE_KEY)
        blob.upload_from_string(
            json.dumps(state, indent=2),
            content_type="application/json"
        )
        print(f"State saved: since={since_ms}, pageToken={page_token}")
    except Exception as e:
        print(f"Error writing state: {e}")
        raise

def fetch_harness_audits(since_ms, page_token=None, retry_count=0):
    """
    Fetch audit logs from Harness API with retry logic.
    API Endpoint: POST /audit/api/audits/listV2
    """
    try:
        # Build URL with query parameters
        url = (
            f"{API_BASE}/audit/api/audits/listV2"
            f"?accountIdentifier={ACCOUNT_ID}"
            f"&pageSize={PAGE_SIZE}"
        )
        if page_token:
            url += f"&pageToken={page_token}"

        print(f"Fetching from: {url[:100]}...")

        # Build request body with time filter and optional filters
        body_data = {
            "startTime": since_ms,
            "endTime": int(time.time() * 1000),
            "filterType": "Audit"
        }

        if FILTER_MODULES:
            body_data["modules"] = [m.strip() for m in FILTER_MODULES if m.strip()]
            print(f"Applying module filter: {body_data['modules']}")

        if FILTER_ACTIONS:
            body_data["actions"] = [a.strip() for a in FILTER_ACTIONS if a.strip()]
            print(f"Applying action filter: {body_data['actions']}")

        if STATIC_FILTER:
            body_data["staticFilter"] = STATIC_FILTER
            print(f"Applying static filter: {STATIC_FILTER}")

        # Make POST request
        response = http.request(
            'POST',
            url,
            body=json.dumps(body_data).encode('utf-8'),
            headers=HDRS,
            timeout=30.0
        )

        resp_data = json.loads(response.data.decode('utf-8'))

        if "status" not in resp_data:
            print(f"Response missing 'status' field: {response.data[:200]}")

        # Check response status
        if resp_data.get("status") != "SUCCESS":
            error_msg = resp_data.get("message", "Unknown error")
            raise Exception(f"API returned status: {resp_data.get('status')} - {error_msg}")

        # Extract data from response structure
        data_obj = resp_data.get("data", {})
        if not data_obj:
            print("Response 'data' object is empty or missing")

        events = data_obj.get("content", [])
        has_next = data_obj.get("hasNext", False)
        next_token = data_obj.get("pageToken")

        print(f"API response: {len(events)} events, hasNext={has_next}, pageToken={next_token}")

        if not events and data_obj:
            print(f"Empty events but data present. Data keys: {list(data_obj.keys())}")

        return {
            "events": events,
            "hasNext": has_next,
            "pageToken": next_token
        }

    except Exception as e:
        if hasattr(e, 'status') and e.status == 429:
            retry_after = 60
            print(f"Rate limit exceeded. Retry after {retry_after} seconds (attempt {retry_count + 1}/{MAX_RETRIES})")
            if retry_count < MAX_RETRIES:
                print(f"Waiting {retry_after} seconds before retry...")
                time.sleep(retry_after)
                print(f"Retrying request (attempt {retry_count + 2}/{MAX_RETRIES})")
                return fetch_harness_audits(since_ms, page_token, retry_count + 1)
            else:
                raise Exception(f"Max retries ({MAX_RETRIES}) exceeded for rate limiting")
        print(f"Error in fetch_harness_audits: {e}")
        raise

def upload_to_gcs(bucket, events):
    """Upload audit events to GCS in JSONL format."""
    if not events:
        print("No events to upload")
        return None

    try:
        # Create JSONL content (one JSON object per line)
        jsonl_lines = [json.dumps(event) for event in events]
        jsonl_content = "\n".join(jsonl_lines)

        # Generate GCS key with timestamp
        timestamp = datetime.now(timezone.utc)
        key = (
            f"{PREFIX}/"
            f"{timestamp:%Y/%m/%d}/"
            f"harness-audit-{timestamp:%Y%m%d-%H%M%S}.jsonl"
        )

        # Upload to GCS
        blob = bucket.blob(key)
        blob.upload_from_string(
            jsonl_content,
            content_type="application/x-ndjson"
        )
        blob.metadata = {
            "event-count": str(len(events)),
            "source": "harness-audit-function",
            "collection-time": timestamp.isoformat()
        }
        blob.patch()

        print(f"Uploaded {len(events)} events to gs://{BUCKET}/{key}")
        return key

    except Exception as e:
        print(f"Error uploading to GCS: {e}")
        raise

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

    Args:
        cloud_event: CloudEvent object containing Pub/Sub message
    """
    print("=== Harness Audit Collection Started ===")
    print(f"Configuration: API_BASE={API_BASE}, ACCOUNT_ID={ACCOUNT_ID[:8]}..., PAGE_SIZE={PAGE_SIZE}")

    if FILTER_MODULES:
        print(f"Module filter enabled: {FILTER_MODULES}")
    if FILTER_ACTIONS:
        print(f"Action filter enabled: {FILTER_ACTIONS}")
    if STATIC_FILTER:
        print(f"Static filter enabled: {STATIC_FILTER}")

    try:
        # Get GCS bucket
        bucket = storage_client.bucket(BUCKET)

        # Step 1: Read checkpoint state
        since_ms, page_token = read_state(bucket)

        if page_token:
            print("Resuming pagination from saved pageToken")
        else:
            since_dt = datetime.fromtimestamp(since_ms / 1000, tz=timezone.utc)
            print(f"Starting new collection from: {since_dt.isoformat()}")

        # Step 2: Collect all events with pagination
        all_events = []
        current_page_token = page_token
        page_count = 0
        max_pages = 100
        has_next = True

        while has_next and page_count < max_pages:
            page_count += 1
            print(f"--- Fetching page {page_count} ---")

            # Fetch one page of results
            result = fetch_harness_audits(since_ms, current_page_token)

            # Extract events
            events = result.get("events", [])
            all_events.extend(events)
            print(f"Page {page_count}: {len(events)} events (total: {len(all_events)})")

            # Check pagination status
            has_next = result.get("hasNext", False)
            current_page_token = result.get("pageToken")

            if not has_next:
                print("Pagination complete (hasNext=False)")
                break

            if not current_page_token:
                print("hasNext=True but no pageToken, stopping pagination")
                break

            # Small delay between pages to avoid rate limiting
            time.sleep(0.5)

        if page_count >= max_pages:
            print(f"Reached max pages limit ({max_pages}), stopping")

        # Step 3: Upload collected events to GCS
        if all_events:
            gcs_key = upload_to_gcs(bucket, all_events)
            print(f"Successfully uploaded {len(all_events)} total events")
        else:
            print("No new events to upload")
            gcs_key = None

        # Step 4: Update checkpoint state
        if not has_next:
            # Pagination complete - update since to current time for next run
            new_since = int(time.time() * 1000)
            write_state(bucket, new_since, None)
            print(f"Pagination complete, state updated with new since={new_since}")
        else:
            # Pagination incomplete - save pageToken for continuation
            write_state(bucket, since_ms, current_page_token)
            print("Pagination incomplete, saved pageToken for next run")

        # Step 5: Log result
        result = {
            "status": "Success",
            "eventsCollected": len(all_events),
            "pagesProcessed": page_count,
            "paginationComplete": not has_next,
            "gcsKey": gcs_key,
            "filters": {
                "modules": FILTER_MODULES,
                "actions": FILTER_ACTIONS,
                "staticFilter": STATIC_FILTER
            }
        }
        print(f"Collection completed: {json.dumps(result)}")

    except Exception as e:
        print(f"Collection failed: {e}")
        raise
    finally:
        print("=== Harness Audit Collection Finished ===")

הקובץ השני: requirements.txt:

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

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

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

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

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

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

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

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

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

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

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

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

בדיקת השילוב

במסוף Cloud Scheduler, מוצאים את העבודה.
לוחצים על הפעלת המשימה בכוח כדי להפעיל את המשימה באופן ידני.
מחכים כמה שניות.
עוברים אל Cloud Run > Services.
לוחצים על שם הפונקציה (harness-audit-collector).
לוחצים על הכרטיסייה Logs (יומנים).

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

=== Harness Audit Collection Started ===
State loaded: since=... or No state file found, starting fresh collection
--- Fetching page 1 ---
API response: X events, hasNext=...
Uploaded X events to gs://harness-io-logs/harness/audit/...
Successfully processed X records
=== Harness Audit Collection Finished ===

עוברים אל Cloud Storage > Buckets (קטגוריות).
לוחצים על שם הקטגוריה.
עוברים לתיקיית הקידומת (harness/audit/).
מוודאים שנוצר קובץ .jsonl חדש עם חותמת הזמן הנוכחית.

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

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

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

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

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

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

עוברים אל SIEM Settings > Feeds.
לוחצים על הוספת פיד חדש.
לוחצים על הגדרת פיד יחיד.
בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Harness Audit Logs).
בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
בוחרים באפשרות Harness IO בתור סוג היומן.
לוחצים על Get Service Account (קבלת חשבון שירות). מוצגת כתובת אימייל ייחודית של חשבון שירות, לדוגמה:
```
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 להטמעה של יומנים של Harness IO

עוברים אל SIEM Settings > Feeds (הגדרות SIEM > פידים).
לוחצים על הוספת פיד חדש.
לוחצים על הגדרת פיד יחיד.
בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Harness Audit Logs).
בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
בוחרים באפשרות Harness IO בתור סוג היומן.
לוחצים על הבא.
מציינים ערכים לפרמטרים הבאים של הקלט:
- כתובת ה-URL של קטגוריית האחסון: מזינים את ה-URI של קטגוריית GCS עם נתיב הקידומת:
```
gs://harness-io-logs/harness/audit/
```
  - מחליפים את:
    - ‫harness-io-logs: השם של קטגוריית GCS.
    - ‫harness/audit: קידומת או נתיב תיקייה שבהם מאוחסנים היומנים.
  - לדוגמה:
    - קטגוריית הבסיס: gs://company-logs/
    - עם קידומת: gs://company-logs/harness-logs/
    - עם תיקיית משנה: gs://company-logs/harness/audit/
הערה: תמיד צריך לכלול את הלוכסן (/) בסוף ה-URI.
- אפשרות למחיקת המקור: בוחרים את אפשרות המחיקה לפי ההעדפה שלכם:
  - אף פעם: לא נמחקים קבצים אחרי ההעברה (מומלץ לבדיקות).
  - מחיקת קבצים שהועברו: הקבצים נמחקים אחרי שההעברה מסתיימת.
  - מחיקת קבצים שהועברו וספריות ריקות: מחיקת קבצים וספריות ריקות אחרי שההעברה מסתיימת בהצלחה.
    
    הערה: אם בוחרים באפשרות מחיקה, לחשבון השירות צריך להיות התפקיד אדמין של אובייקטים ב-Storage במקום התפקיד "צפייה באובייקטים ב-Storage". מעדכנים את ההרשאות ב-IAM בהתאם.
- הגיל המקסימלי של הקובץ: כולל קבצים שעברו שינוי במספר הימים האחרון. ברירת המחדל היא 180 ימים.
- מרחב השמות של הנכס: מרחב השמות של הנכס. מזינים harness.audit.
- תוויות להוספה: התווית שתתווסף לאירועים מהפיד הזה.
לוחצים על הבא.
בודקים את ההגדרות של הפיד החדש במסך סיום ולוחצים על שליחה.

יומן שינויים

צפייה ביומן השינויים של כלי הניתוח הזה

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