איסוף יומני גיבוי של Druva

גרסת המנתח: 2.0

נתמכים ב:

במסמך הזה מוסבר איך לאסוף יומני גיבוי של Druva באמצעות הגדרת פונקציית Cloud Run שמאחזרת אירועים מ-Druva API בארכיטקטורת REST וכותבת אותם בקטגוריה של Cloud Storage, ואז מגדירה פיד של Google Security Operations באמצעות Cloud Storage V2.

‫Druva היא פלטפורמה מבוססת-ענן לניהול נתונים ולהגנה עליהם, שמספקת שירותי גיבוי, תוכנית התאוששות מאסון (DR) וארכיון לנקודות קצה, לאפליקציות SaaS ולעומסי עבודה ארגוניים. הפלטפורמה יוצרת נתיבי ביקורת מקיפים, אירועי גיבוי, פעילויות שחזור והתראות אבטחה שאפשר לשלב עם פתרונות SIEM לצורכי מעקב ותאימות.

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

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

  • מכונה של Google SecOps
  • פרויקט ב- Google Cloud שהחיוב מופעל בו
  • ממשקי ה-API הבאים של Google Cloud מופעלים:
    • Cloud Run functions API
    • Cloud Scheduler API
    • Cloud Storage API
    • Pub/Sub API
    • ‫API של ניהול זהויות והרשאות גישה (IAM)
  • גישה של אדמין ב-Druva Cloud למסוף Druva Cloud Platform
  • גישה ל-Druva Integration Center כדי ליצור פרטי כניסה ל-API

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

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

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

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

כדי לאפשר לפונקציית Cloud Run לאחזר אירועים מ-Druva, צריך ליצור פרטי כניסה ל-API עם אימות OAuth 2.0.

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

  1. נכנסים למסוף Druva Cloud Platform.
  2. בתפריט Global Navigation, בוחרים באפשרות Integration Center.
  3. בחלונית הימנית, לוחצים על פרטי כניסה ל-API.
  4. לוחצים על New Credentials.
  5. בחלון New Credentials, מזינים את הפרטים הבאים: Name: מזינים שם תיאורי (לדוגמה, Google SecOps Cloud Storage Integration).
  6. כדי להחיל הגבלות על הרשאות:
    1. בוחרים באפשרות Druva Cloud Administrator כדי לאפשר גישה מלאה לאחזור נתונים ולשינוי שלהם.
    2. לחלופין, בוחרים באפשרות אדמין של המוצר ובוחרים: תפקיד אדמין ב-Cloud (לקריאה בלבד): כדי להגביל את הגישה לאחזור נתונים בלבד, בלי זכויות שינוי (מומלץ לשילוב עם SIEM)
  7. לוחצים על Save.

תיעוד פרטי הכניסה של ה-API

אחרי שיוצרים את פרטי הכניסה ל-API, מופיע החלון Credential Details:

  1. לוחצים על סמל ההעתקה לצד Client ID כדי להעתיק את הערך ללוח.
  2. שומרים את מזהה הלקוח באופן מאובטח (לדוגמה, McNkxxxx4Vicxxxx4Ldpxxxx/09Uxxxx).
  3. לוחצים על סמל ההעתקה לצד Secret Key (מפתח סודי) כדי להעתיק את הערך ללוח.
  4. שומרים את המפתח הסודי באופן מאובטח (לדוגמה, Xmcxxxx8j5xxxx6NxxxxRbRxxxxNNyPt).

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

יוצרים חשבון שירות ייעודי לפונקציית Cloud Run כדי לגשת ל-Cloud Storage.

  1. במסוף Google Cloud , נכנסים לדף IAM & Admin > Service Accounts.
  2. לוחצים על Create Service Account.
  3. מזינים את פרטי ההגדרה הבאים:
    • שם חשבון השירות: מזינים druva-backup-function (או שם תיאורי)
    • Service account description: מזינים Service account for Druva Backup Cloud Run function
  4. לוחצים על יצירה והמשך.
  5. בקטע Grant this service account access to project, מוסיפים את התפקידים הבאים:
    1. לוחצים על Select a role ובוחרים באפשרות Storage Object Admin.
    2. לוחצים על Add another role ובוחרים את התפקיד Cloud Run Invoker.
  6. לוחצים על Continue.
  7. לוחצים על סיום.
  8. מתעדים את כתובת האימייל של חשבון השירות (לדוגמה, druva-backup-function@PROJECT_ID.iam.gserviceaccount.com).

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

יוצרים נושא Pub/Sub שבו Cloud Scheduler ישתמש כדי להפעיל את פונקציית Cloud Run.

  1. במסוף Google Cloud , נכנסים לדף Pub/Sub > Topics.
  2. לוחצים על Create Topic.
  3. מזינים את פרטי ההגדרה הבאים:
    • מזהה הנושא: מזינים druva-backup-trigger
  4. מבטלים את הסימון של הוספת מינוי כברירת מחדל.
  5. לוחצים על יצירה.

יצירת פונקציית Cloud Run

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

יוצרים פונקציית Cloud Run שמבצעת אימות מול ה-API של Druva באמצעות פרטי כניסה של לקוח OAuth 2.0, מאחזרת אירועים דרך נקודת הקצה של האירועים באמצעות חלוקה לדפים וכותבת את התוצאות כ-NDJSON בקטגוריה של Cloud Storage.

פריסת פונקציית Cloud Run

  1. נכנסים לדף פונקציות Cloud Run במסוף Google Cloud .
  2. לוחצים על Create Function.
  3. ממלאים את פרטי ההגדרה הבאים:

    • Environment: בוחרים באפשרות 2nd gen.
    • שם הפונקציה: מזינים druva-backup-to-gcs
    • Region: בוחרים את האזור הכי קרוב לקטגוריה של Cloud Storage (לדוגמה, us-central1)
    • Trigger type: בוחרים באפשרות Cloud Pub/Sub.
    • נושא ב-Cloud Pub/Sub: בוחרים באפשרות druva-backup-trigger
    • חשבון שירות: בוחרים באפשרות druva-backup-function@PROJECT_ID.iam.gserviceaccount.com
    • הזיכרון שהוקצה: 512 MiB
    • זמן קצוב לתפוגה: 540 שניות
    • מספר המכונות המקסימלי: 1
  4. לוחצים על הבא.

  5. בוחרים באפשרות Python 3.11 בתור Runtime.

  6. מגדירים את Entry point ל-main.

  7. בעורך קוד המקור, מחליפים את התוכן של main.py בתוכן הבא:

    import base64
    import json
    import os
    import time
    from datetime import datetime, timezone, timedelta
    
    import requests
    from google.cloud import storage
    
    GCS_BUCKET = os.environ["GCS_BUCKET"]
    GCS_PREFIX = os.environ.get("GCS_PREFIX", "druva_backup")
    STATE_KEY = os.environ.get("STATE_KEY", "druva_state.json")
    DRUVA_BASE_URL = os.environ.get("DRUVA_BASE_URL", "apis.druva.com")
    CLIENT_ID = os.environ["CLIENT_ID"]
    CLIENT_SECRET = os.environ["CLIENT_SECRET"]
    MAX_RECORDS = int(os.environ.get("MAX_RECORDS", "10000"))
    PAGE_SIZE = int(os.environ.get("PAGE_SIZE", "500"))
    LOOKBACK_HOURS = int(os.environ.get("LOOKBACK_HOURS", "24"))
    
    def get_oauth_token():
        """Obtain OAuth 2.0 access token using client credentials grant."""
        token_url = f"https://{DRUVA_BASE_URL}/token"
        payload = {
            "grant_type": "client_credentials",
            "scope": "read",
        }
        resp = requests.post(
            token_url,
            data=payload,
            auth=(CLIENT_ID, CLIENT_SECRET),
            timeout=30,
        )
        resp.raise_for_status()
        return resp.json()["access_token"]
    
    def load_state(storage_client):
        """Load the persisted state (last event time and tracker) from GCS."""
        bucket = storage_client.bucket(GCS_BUCKET)
        blob = bucket.blob(f"{GCS_PREFIX}/{STATE_KEY}")
        if blob.exists():
            return json.loads(blob.download_as_text())
        return {}
    
    def save_state(storage_client, state):
        """Persist state to GCS."""
        bucket = storage_client.bucket(GCS_BUCKET)
        blob = bucket.blob(f"{GCS_PREFIX}/{STATE_KEY}")
        blob.upload_from_string(
            json.dumps(state),
            content_type="application/json",
        )
    
    def fetch_events(token, state):
        """Fetch events from Druva API with pagination via nextPageToken."""
        events_url = f"https://{DRUVA_BASE_URL}/insync/eventmanagement/v2/events"
        headers = {
            "Authorization": f"Bearer {token}",
            "Accept": "application/json",
        }
    
        params = {"pageSize": PAGE_SIZE}
    
        tracker = state.get("tracker")
        last_event_time = state.get("last_event_time")
    
        if tracker:
            params["tracker"] = tracker
        elif last_event_time:
            params["fromTime"] = last_event_time
        else:
            lookback = datetime.now(timezone.utc) - timedelta(hours=LOOKBACK_HOURS)
            params["fromTime"] = lookback.strftime("%Y-%m-%dT%H:%M:%SZ")
    
        all_events = []
        total_fetched = 0
    
        while total_fetched < MAX_RECORDS:
            resp = requests.get(
                events_url,
                headers=headers,
                params=params,
                timeout=60,
            )
            resp.raise_for_status()
            data = resp.json()
    
            events = data.get("events", [])
            all_events.extend(events)
            total_fetched += len(events)
    
            new_tracker = data.get("tracker")
            next_page_token = data.get("nextPageToken")
    
            if new_tracker:
                state["tracker"] = new_tracker
    
            if next_page_token:
                params["nextPageToken"] = next_page_token
                params.pop("tracker", None)
                params.pop("fromTime", None)
            else:
                break
    
        if all_events:
            last_ts = all_events[-1].get("eventTime", "")
            if last_ts:
                state["last_event_time"] = last_ts
    
        return all_events, state
    
    def write_events_to_gcs(storage_client, events):
        """Write events as NDJSON to GCS."""
        if not events:
            return
    
        now = datetime.now(timezone.utc)
        filename = now.strftime("%Y%m%d_%H%M%S") + ".ndjson"
        blob_path = f"{GCS_PREFIX}/{now.strftime('%Y/%m/%d')}/{filename}"
    
        ndjson_lines = "\n".join(json.dumps(event) for event in events)
    
        bucket = storage_client.bucket(GCS_BUCKET)
        blob = bucket.blob(blob_path)
        blob.upload_from_string(
            ndjson_lines,
            content_type="application/x-ndjson",
        )
        print(f"Wrote {len(events)} events to gs://{GCS_BUCKET}/{blob_path}")
    
    def main(event, context):
        """Cloud Run function entry point triggered by Pub/Sub."""
        storage_client = storage.Client()
    
        token = get_oauth_token()
    
        state = load_state(storage_client)
    
        events, updated_state = fetch_events(token, state)
    
        write_events_to_gcs(storage_client, events)
    
        save_state(storage_client, updated_state)
    
        print(f"Completed: fetched {len(events)} events")
        return f"OK: {len(events)} events"
    
  8. מחליפים את התוכן של requirements.txt בתוכן הבא:

    requests>=2.31.0
    google-cloud-storage>=2.14.0
    

הגדרת משתני סביבה

  1. בהגדרות של פונקציית Cloud Run, עוברים לקטע Runtime, build, connections and security settings.
  2. בקטע Runtime environment variables, מוסיפים את המשתנים הבאים:

    • GCS_BUCKET: השם של הקטגוריה של Cloud Storage (לדוגמה, druva-backup-logs)
    • ‫GCS_PREFIX: נתיב הקידומת של קובצי היומן (לדוגמה, druva_backup)
    • ‫STATE_KEY: שם קובץ תמונת המצב (לדוגמה, druva_state.json)
    • DRUVA_BASE_URL: כתובת ה-URL הבסיסית של Druva API:
      • ‫apis.druva.com ל-Druva Cloud (Standard)
      • ‫govcloudapis.druva.com ל-Druva GovCloud
    • ‫CLIENT_ID: מזהה הלקוח מפרטי הכניסה של Druva API
    • ‫CLIENT_SECRET: המפתח הסודי מפרטי הכניסה ל-API של Druva
    • ‫MAX_RECORDS: המספר המקסימלי של רשומות לאחזור בכל הפעלה (לדוגמה, 10000)
    • ‫PAGE_SIZE: מספר האירועים בכל דף API (מקסימום 500)
    • ‫LOOKBACK_HOURS: מספר השעות שצריך לבדוק בהרצה הראשונה (לדוגמה, 24)
  3. לוחצים על Deploy.

  4. מחכים שהפריסה תסתיים בהצלחה.

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

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

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

    • שם: מזינים druva-backup-scheduler
    • ‫Region: בוחרים את אותו אזור של פונקציית Cloud Run (לדוגמה, us-central1)
    • תיאור: מזינים Triggers Druva Backup log collection every 30 minutes
    • Frequency: מזינים */30 * * * * (כל 30 דקות)
    • אזור זמן: בוחרים את אזור הזמן הרצוי (לדוגמה, UTC)
  4. לוחצים על Continue.

  5. מגדירים את Target:

    • ‫Target type: בוחרים באפשרות Pub/Sub.
    • נושא ב-Cloud Pub/Sub: בוחרים באפשרות druva-backup-trigger
    • גוף ההודעה: מזינים {"trigger": "scheduled"}
  6. לוחצים על יצירה.

בדיקת המשימה ב-Cloud Scheduler

  1. ברשימה Cloud Scheduler, מאתרים את druva-backup-scheduler.
  2. לוחצים על הפעלה מיידית כדי להפעיל את הפונקציה מיד.
  3. כדי לוודא שההטמעה בוצעה, בודקים את הדברים הבאים:
    • היומנים של פונקציית Cloud Run ב-Cloud Run functions > druva-backup-to-gcs > Logs
    • הקטגוריה של Cloud Storage לקובצי NDJSON חדשים ב-Cloud Storage > druva-backup-logs

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

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

  1. עוברים אל הגדרות > ניהול נתונים > פידים. אם אתם משתמשים בפלטפורמת SIEM בלבד, עוברים אל הגדרות > פידים.
  2. לוחצים על הוספת פיד חדש.
  3. לוחצים על הגדרת פיד יחיד.
  4. בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Druva Backup Events).
  5. בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
  6. בוחרים באפשרות Druva Backup בתור סוג היומן.
  7. לוחצים על Get Service Account (קבלת חשבון שירות). תוצג כתובת אימייל ייחודית של חשבון שירות, לדוגמה:

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

הגדרת הפיד

  1. לוחצים על הבא.
  2. מציינים ערכים לפרמטרים הבאים של הקלט:

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

      gs://druva-backup-logs/druva_backup/
      
    • אפשרות מחיקת המקור: בוחרים את אפשרות המחיקה המועדפת:

      • אף פעם: אף קובץ לא נמחק אחרי ההעברה (מומלץ לבדיקה)
      • מחיקת קבצים שהועברו: מחיקת קבצים אחרי שהם הועברו בהצלחה.
      • מחיקת קבצים שהועברו וספריות ריקות: מחיקת קבצים וספריות ריקות אחרי העברה מוצלחת
    • גיל הקובץ המקסימלי: הכללת קבצים ששונו במספר הימים האחרונים (ברירת המחדל היא 180 ימים)

    • מרחב השמות של הנכס: מרחב השמות של הנכס

    • תוויות הטמעה: התווית שתתווסף לאירועים מהפיד הזה

  3. לוחצים על הבא.

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

מתן הרשאות לניהול זהויות והרשאות גישה (IAM) לחשבון השירות של Google SecOps

כדי לקרוא את קובצי היומן שנכתבו על ידי פונקציית Cloud Run, חשבון השירות של Google SecOps צריך את התפקיד צפייה באובייקטים באחסון בקטגוריה של Cloud Storage.

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

טבלת מיפוי UDM

שדה ביומן מיפוי UDM היגיון
inSyncUserID, eventsGroupId, FilesMissed, FilesBackedup, TotalBackupSize, TotalBytesTransferred, facility, inSyncDataSourceID, initiator, event_type additional.fields מיזוג עם תוויות שנוצרו מכל שדה, אם הוא לא ריק
הגורם היוזם extensions.auth.type הגדרה ל-"AUTHTYPE_UNSPECIFIED" אם היוזם תואם לביטוי הרגולרי של כתובת האימייל
metadata.event_type הערך מוגדר כ-"USER_LOGIN" אם הערך של has_target_user הוא true והערך של has_principal הוא true; הערך מוגדר כ-"STATUS_UPDATE" אם הערך של has_principal הוא true והערך של has_target הוא false; אחרת הערך מוגדר כ-"GENERIC_EVENT"
eventID metadata.product_log_id ההמרה למחרוזת
metadata.product_name צריך להגדיר את הערך "DRUVA_BACKUP"
clientVersion metadata.product_version הערך הועתק ישירות
inSyncDataSourceName principal.asset.hostname הערך הועתק ישירות
ip principal.asset.ip מוזג מכתובת IP
inSyncDataSourceName principal.hostname הערך הועתק ישירות
ip principal.ip מוזג מכתובת IP
clientOS principal.platform ההגדרה תהיה "LINUX" אם יש התאמה ל-(?i)Linux, ‏"WINDOWS" אם יש התאמה ל-(?i)windows, ‏"MAC" אם יש התאמה ל-(?i)mac
profileName principal.resource.name הערך הועתק ישירות
profileID principal.resource.product_object_id ההמרה למחרוזת
eventState security_result.action הגדרה ל-"ALLOW" אם יש התאמה ל-(?i)Success, אחרת "BLOCK"
eventState security_result.action_details הערך הועתק ישירות
severity security_result.severity צריך להגדיר "LOW" אם הערך הוא [0,1,2,3,LOW],‏ "MEDIUM" אם הערך הוא [4,5,6,MEDIUM,SUBSTANTIAL,INFO],‏ "HIGH" אם הערך הוא [7,8,HIGH,SEVERE],‏ "CRITICAL" אם הערך הוא [9,10,VERY-HIGH,CRITICAL]
inSyncUserEmail, initiator target.user.email_addresses מוזג מ-inSyncUserEmail; גם מהיוזם אם הוא תואם לביטוי הרגולרי של כתובת אימייל
inSyncUserName target.user.userid הערך הועתק ישירות
metadata.vendor_name צריך להגדיר את הערך "DRUVA_BACKUP"

יומן שינויים

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

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