איסוף יומנים של Cisco Catalyst SD-WAN Manager

גרסת המנתח: 7.0

נתמכים ב:

במאמר הזה מוסבר איך להטמיע יומנים של Cisco Catalyst SD-WAN Manager (לשעבר vManage) ב-Google Security Operations באמצעות Cloud Storage. ‫Cisco Catalyst SD-WAN Manager היא מערכת מרכזית לניהול רשתות שמאפשרת לראות את מארג ה-SD-WAN ולשלוט בו. בעזרת המערכת, אדמינים יכולים לעקוב אחרי ביצועי הרשת, להגדיר כללי מדיניות ולנהל את האבטחה ברשתות ארגוניות מבוזרות.

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

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

  • מכונה של Google SecOps
  • פרויקט ב- Google Cloud עם Cloud Storage API מופעל
  • הרשאות ליצירה ולניהול של קטגוריות של Cloud Storage
  • הרשאות לניהול כללי מדיניות של ניהול זהויות והרשאות גישה (IAM) בקטגוריות של Cloud Storage
  • הרשאות ליצירת שירותי Cloud Run, נושאי Pub/Sub ומשימות ב-Cloud Scheduler
  • גישה עם הרשאות למסוף הניהול של Cisco Catalyst SD-WAN Manager
  • חשבון משתמש ב-Cisco Catalyst SD-WAN Manager עם הרשאות גישה ל-API

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

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

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

איסוף פרטי הכניסה ל-Cisco Catalyst SD-WAN Manager API

יצירת חשבון משתמש ב-API

  1. נכנסים למסוף Cisco Catalyst SD-WAN Manager.
  2. בתפריט, עוברים אל Administration (ניהול) > Manage Users (ניהול משתמשים).
  3. לוחצים על הוספת משתמש.
  4. מזינים את פרטי ההגדרה הבאים:
    • שם משתמש: מזינים שם משתמש לגישה ל-API (לדוגמה, chronicle-api).
    • סיסמה: מזינים סיסמה חזקה.
    • אישור הסיסמה: מזינים שוב את הסיסמה.
    • קבוצת משתמשים: בוחרים קבוצת משתמשים עם הרשאות מתאימות (ראו את הקטע הבא).
  5. לוחצים על הוספה.
  6. מעתיקים את הפרטים הבאים ושומרים אותם במיקום מאובטח:

    • שם משתמש: שם המשתמש שלכם ב-Catalyst SD-WAN Manager.
    • סיסמה: הסיסמה שלכם ב-Catalyst SD-WAN Manager.
    • כתובת ה-URL הבסיסית של Catalyst SD-WAN Manager: כתובת ה-URL הבסיסית של שרת Catalyst SD-WAN Manager (לדוגמה, https://sdwan-manager.example.com:8443).

הגדרת הרשאות משתמשים

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

  1. במסוף Cisco Catalyst SD-WAN Manager, בתפריט, עוברים אל Administration > Manage Users > User Groups.
  2. בוחרים את קבוצת המשתמשים שהוקצתה למשתמש ה-API (או לוחצים על Add User Group כדי ליצור קבוצה חדשה).
  3. לוחצים על Edit.
  4. בקטע תכונה, מוודאים שההרשאות הבאות מופעלות:
    • יומן ביקורת: בוחרים בהרשאת קריאה.
    • התראות: בוחרים בהרשאת קריאה.
    • אירועים: בוחרים בהרשאת קריאה.
  5. לוחצים על עדכון.

אימות הגישה ל-API

לפני שממשיכים בתהליך השילוב, בודקים את פרטי הכניסה:

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

    # Replace with your actual credentials
    SDWAN_HOST="https://sdwan-manager.example.com:8443"
    SDWAN_USERNAME="chronicle-api"
    SDWAN_PASSWORD="your-password"
    
    # Test authentication using session-based login (returns JSESSIONID cookie)
    curl -c cookies.txt -X POST \
      "${SDWAN_HOST}/j_security_check" \
      -H "Content-Type: application/x-www-form-urlencoded" \
      -d "j_username=${SDWAN_USERNAME}&j_password=${SDWAN_PASSWORD}"
    
    # Get CSRF token (X-XSRF-TOKEN)
    curl -b cookies.txt \
      "${SDWAN_HOST}/dataservice/client/token"
    

אם האימות יצליח, הפקודה השנייה תחזיר מחרוזת של אסימון CSRF.

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

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

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

  1. במסוף Google Cloud , נכנסים לדף IAM & Admin > Service Accounts.
  2. לוחצים על Create Service Account.
  3. מזינים את פרטי ההגדרה הבאים:
    • Service account name: מזינים cisco-sdwan-collector-sa.
    • Service account description: מזינים Service account for Cloud Run function to collect Cisco Catalyst SD-WAN Manager 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. לוחצים על סיום.

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

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

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

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

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

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

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

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

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

הודעות Pub/Sub מ-Cloud Scheduler יפעילו את פונקציית Cloud Run כדי לאחזר יומנים מ-Cisco Catalyst SD-WAN Manager API ולכתוב אותם ב-Cloud Storage.

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

    הגדרה ערך
    שם השירות cisco-sdwan-log-collector
    אזור בוחרים את האזור שתואם לקטגוריה של Cloud Storage (לדוגמה, us-central1)
    זמן ריצה בוחרים באפשרות Python 3.12 ואילך.
  5. בקטע טריגר (אופציונלי):

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

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

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

    • חשבון שירות: בוחרים את חשבון השירות (cisco-sdwan-collector-sa).
  9. עוברים לכרטיסייה Containers:

    1. לוחצים על Variables & Secrets.
    2. לוחצים על ‎+ Add variable לכל משתנה סביבה:
    שם משתנה ערך לדוגמה
    GCS_BUCKET cisco-sdwan-logs-bucket
    GCS_PREFIX cisco-sdwan
    STATE_KEY cisco-sdwan/state.json
    SDWAN_HOST https://sdwan-manager.example.com:8443
    SDWAN_USERNAME chronicle-api
    SDWAN_PASSWORD your-sdwan-password
    LOOKBACK_HOURS 1
  10. גוללים למטה בכרטיסייה Variables & Secrets (משתנים וסודות) עד שמגיעים לקטע Requests (בקשות):

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

    • בקטע Resources:
      • ‫Memory: בוחרים באפשרות ‎512 MiB או יותר.
      • מעבד (CPU): בוחרים באפשרות 1.
  12. בקטע Revision scaling:

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

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

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

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

  1. בשדה Entry point, מזינים main.
  2. בכלי לעריכת קוד, יוצרים שני קבצים:

    • main.py:

      import functions_framework
      from google.cloud import storage
      import json
      import os
      import urllib3
      import urllib.parse
      from datetime import datetime, timezone, timedelta
      import time
      
      # Disable SSL warnings for self-signed certificates (testing only)
      urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
      
      # Initialize HTTP client with timeouts
      http = urllib3.PoolManager(
          timeout=urllib3.Timeout(connect=10.0, read=60.0),
          cert_reqs='CERT_NONE',
          retries=urllib3.Retry(total=3, backoff_factor=1)
      )
      
      # Initialize Storage client
      storage_client = storage.Client()
      
      # Environment variables
      SDWAN_HOST = os.environ.get('SDWAN_HOST', '').rstrip('/')
      SDWAN_USERNAME = os.environ.get('SDWAN_USERNAME', '')
      SDWAN_PASSWORD = os.environ.get('SDWAN_PASSWORD', '')
      GCS_BUCKET = os.environ.get('GCS_BUCKET', '')
      GCS_PREFIX = os.environ.get('GCS_PREFIX', 'cisco-sdwan')
      STATE_KEY = os.environ.get('STATE_KEY', 'cisco-sdwan/state.json')
      LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '1'))
      
      class CatalystSDWANAPI:
          """Client for Cisco Catalyst SD-WAN Manager API (formerly vManage)."""
      
          def __init__(self, host, username, password):
              self.host = host
              self.username = username
              self.password = password
              self.jsessionid = None
              self.xsrf_token = None
      
          def authenticate(self):
              """Authenticate using session-based login (j_security_check)."""
              try:
                  login_url = f"{self.host}/j_security_check"
                  login_data = urllib.parse.urlencode({
                      'j_username': self.username,
                      'j_password': self.password
                  }).encode('utf-8')
      
                  response = http.request(
                      'POST',
                      login_url,
                      body=login_data,
                      headers={'Content-Type': 'application/x-www-form-urlencoded'},
                  )
      
                  if b'<html>' in response.data or response.status != 200:
                      print(f"Authentication failed: HTTP {response.status}")
                      return False
      
                  # Extract JSESSIONID from Set-Cookie header
                  cookie_header = response.headers.get('Set-Cookie', '')
                  for part in cookie_header.split(','):
                      if 'JSESSIONID=' in part:
                          self.jsessionid = part.split('JSESSIONID=')[1].split(';')[0]
                          break
      
                  if not self.jsessionid:
                      print("Failed to extract JSESSIONID from response")
                      return False
      
                  # Get XSRF token
                  token_url = f"{self.host}/dataservice/client/token"
                  headers = {
                      'Content-Type': 'application/json',
                      'Cookie': f"JSESSIONID={self.jsessionid}"
                  }
                  response = http.request('GET', token_url, headers=headers)
      
                  if response.status == 200:
                      self.xsrf_token = response.data.decode('utf-8').strip()
                      print("Successfully authenticated with Catalyst SD-WAN Manager")
                      return True
                  else:
                      print(f"Failed to get XSRF token: HTTP {response.status}")
                      return False
      
              except Exception as e:
                  print(f"Authentication error: {e}")
                  return False
      
          def _get_headers(self):
              """Build headers for authenticated API requests."""
              return {
                  'Content-Type': 'application/json',
                  'Accept': 'application/json',
                  'Cookie': f"JSESSIONID={self.jsessionid}",
                  'X-XSRF-TOKEN': self.xsrf_token
              }
      
          def _build_query(self, last_epoch_ms=None):
              """Build a query payload with entry_time filter."""
              query = {
                  "query": {
                      "condition": "AND",
                      "rules": []
                  },
                  "size": 10000
              }
              if last_epoch_ms:
                  query["query"]["rules"].append({
                      "value": [str(last_epoch_ms)],
                      "field": "entry_time",
                      "type": "date",
                      "operator": "greater"
                  })
              else:
                  query["query"]["rules"].append({
                      "value": [str(LOOKBACK_HOURS)],
                      "field": "entry_time",
                      "type": "date",
                      "operator": "last_n_hours"
                  })
              return query
      
          def fetch_data(self, endpoint, last_epoch_ms=None):
              """Fetch data from a /dataservice endpoint using POST with query body."""
              url = f"{self.host}/dataservice/{endpoint}"
              headers = self._get_headers()
              query = self._build_query(last_epoch_ms)
      
              try:
                  response = http.request(
                      'POST',
                      url,
                      body=json.dumps(query),
                      headers=headers,
                  )
      
                  if response.status == 200:
                      return json.loads(response.data.decode('utf-8'))
                  else:
                      print(f"Failed to get {endpoint}: HTTP {response.status}")
                      return None
      
              except Exception as e:
                  print(f"Error fetching {endpoint}: {e}")
                  return None
      
      def load_state(bucket):
          """Load the last run timestamp (epoch ms) from GCS state file."""
          try:
              blob = bucket.blob(STATE_KEY)
              if blob.exists():
                  state_data = json.loads(blob.download_as_text())
                  return state_data.get('last_run_time')
          except Exception as e:
              print(f"Warning: Could not load state: {e}")
          return None
      
      def save_state(bucket, epoch_ms):
          """Save the current run timestamp (epoch ms) to GCS state file."""
          try:
              state_data = {
                  'last_run_time': epoch_ms,
                  'updated_at': datetime.now(timezone.utc).isoformat()
              }
              blob = bucket.blob(STATE_KEY)
              blob.upload_from_string(
                  json.dumps(state_data),
                  content_type='application/json'
              )
              print(f"Saved state: last_run_time={epoch_ms}")
          except Exception as e:
              print(f"Warning: Could not save state: {e}")
      
      def upload_to_gcs(bucket, records, log_type):
          """Upload log records to GCS as NDJSON."""
          if not records:
              print(f"No {log_type} records to upload")
              return 0
      
          dt = datetime.now(timezone.utc)
          object_key = (
              f"{GCS_PREFIX}/{log_type}/"
              f"{dt.strftime('%Y/%m/%d')}/"
              f"{log_type}_{dt.strftime('%Y%m%d_%H%M%S')}.ndjson"
          )
      
          ndjson = '\n'.join(
              json.dumps(record, ensure_ascii=False) for record in records
          ) + '\n'
      
          blob = bucket.blob(object_key)
          blob.upload_from_string(ndjson, content_type='application/x-ndjson')
          print(f"Uploaded {len(records)} {log_type} records to gs://{GCS_BUCKET}/{object_key}")
          return len(records)
      
      @functions_framework.cloud_event
      def main(cloud_event):
          """
          Cloud Run function triggered by Pub/Sub.
          Fetches audit logs, alarms, and events from Cisco Catalyst SD-WAN Manager
          API and writes them to GCS as NDJSON files.
      
          Args:
              cloud_event: CloudEvent object containing Pub/Sub message
          """
          print(f"Starting Cisco Catalyst SD-WAN Manager log collection at {datetime.now(timezone.utc).isoformat()}")
      
          if not all([SDWAN_HOST, SDWAN_USERNAME, SDWAN_PASSWORD, GCS_BUCKET]):
              print("Error: Missing required environment variables")
              return
      
          try:
              bucket = storage_client.bucket(GCS_BUCKET)
      
              # Load last run timestamp
              last_run_time = load_state(bucket)
              if last_run_time:
                  print(f"Resuming from last_run_time={last_run_time}")
              else:
                  print(f"No previous state found, collecting last {LOOKBACK_HOURS} hour(s) of logs")
      
              # Authenticate
              api = CatalystSDWANAPI(SDWAN_HOST, SDWAN_USERNAME, SDWAN_PASSWORD)
              if not api.authenticate():
                  print("Failed to authenticate with Catalyst SD-WAN Manager")
                  return
      
              # Current timestamp for state tracking (epoch milliseconds)
              current_time = int(datetime.now(timezone.utc).timestamp() * 1000)
      
              # Collect audit logs, alarms, and events
              endpoints = [
                  ('audit_logs', 'auditlog'),
                  ('alarms', 'alarms'),
                  ('events', 'events'),
              ]
      
              total_records = 0
              for log_type, endpoint in endpoints:
                  try:
                      print(f"Collecting {log_type} from /dataservice/{endpoint}...")
                      response_data = api.fetch_data(endpoint, last_run_time)
                      if response_data and 'data' in response_data:
                          count = upload_to_gcs(bucket, response_data['data'], log_type)
                          total_records += count
                      else:
                          print(f"No {log_type} data returned")
                  except Exception as e:
                      print(f"Error processing {log_type}: {e}")
                      continue
      
              # Update state
              save_state(bucket, current_time)
      
              print(f"Collection completed. Total records processed: {total_records}")
      
          except Exception as e:
              print(f"Function execution error: {e}")
              raise
      
    • requirements.txt:

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

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

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

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

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

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

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

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

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

בדיקת השילוב

  1. במסוף Cloud Scheduler, מוצאים את המשימה.
  2. לוחצים על Force run כדי להפעיל את המשימה באופן ידני.
  3. מחכים כמה שניות.
  4. עוברים אל Cloud Run > Services.
  5. לוחצים על שם הפונקציה (cisco-sdwan-log-collector).
  6. לוחצים על הכרטיסייה Logs.
  7. מוודאים שהפונקציה בוצעה בהצלחה. חפשו את:

    Starting Cisco Catalyst SD-WAN Manager log collection at ...
    Successfully authenticated with Catalyst SD-WAN Manager
    Collecting audit_logs from /dataservice/auditlog...
    Uploaded N audit_logs records to gs://...
    Collection completed. Total records processed: N
    
  8. נכנסים לדף Cloud Storage > Buckets.

  9. לוחצים על שם הקטגוריה.

  10. עוברים לתיקיית הקידומת (cisco-sdwan/).

  11. מוודאים שנוצרו קובצי .ndjson חדשים עם חותמת הזמן הנוכחית.

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

  • ‫HTTP 401: בודקים את פרטי הכניסה ל-API במשתני הסביבה
  • ‫HTTP 403: צריך לוודא שלחשבון המשתמש יש את הרשאות הקריאה הנדרשות ליומן הביקורת, להתראות ולאירועים.
  • האימות נכשל: צריך לוודא שכתובת ה-URL הבסיסית של Catalyst SD-WAN Manager כוללת את היציאה הנכונה (ברירת המחדל היא 8443)
  • חסרים משתני סביבה: צריך לוודא שכל המשתנים הנדרשים מוגדרים.

הגדרת פיד ב-Google SecOps כדי להטמיע יומנים של Cisco Catalyst SD-WAN Manager

  1. עוברים אל הגדרות > ניהול נתונים > פידים. אם אתם משתמשים בפלטפורמת SIEM בלבד, עוברים אל הגדרות > פידים.
  2. לוחצים על הוספת פיד חדש.
  3. לוחצים על הגדרת פיד יחיד.
  4. בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Cisco Catalyst SD-WAN Manager logs).
  5. בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
  6. בוחרים באפשרות Cisco SD-WAN בתור Log type.
  7. לוחצים על Get Service Account (קבלת חשבון שירות). תוצג כתובת אימייל ייחודית של חשבון שירות, לדוגמה:

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

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

  10. מציינים ערכים לפרמטרים הבאים של הקלט:

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

      gs://cisco-sdwan-logs-bucket/cisco-sdwan/
      
      • מחליפים את:
        • ‫cisco-sdwan-logs-bucket: השם של הקטגוריה ב-Cloud Storage.
        • ‫cisco-sdwan/: נתיב אופציונלי לקידומת או לתיקייה שבהם מאוחסנים היומנים (משאירים ריק בשביל תיקיית הבסיס).
    • אפשרות מחיקת המקור: בוחרים את אפשרות המחיקה המועדפת:

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

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

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

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

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

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

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

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

טבלת מיפוי UDM

שדה ביומן מיפוי UDM היגיון
Tunnel_id_label additional.fields ממוזג
additional_tag additional.fields ממוזג
count_label additional.fields ממוזג
dst_vrf_label additional.fields ממוזג
logfeature_label additional.fields ממוזג
logmodule_label additional.fields ממוזג
meta_sequenceId_label additional.fields ממוזג
msg_label additional.fields ממוזג
qfp_label additional.fields ממוזג
result_label additional.fields ממוזג
rsa_sha256_label additional.fields ממוזג
rsa_type_label additional.fields ממוזג
sequence_label additional.fields ממוזג
src_vrf_label additional.fields ממוזג
tenant_vpn_id_label additional.fields ממוזג
thread_label additional.fields ממוזג
tos_label additional.fields ממוזג
unknown_tenant_label additional.fields ממוזג
vlan_id_label additional.fields ממוזג
vpn_id_label additional.fields ממוזג
description_1 extensions.auth.type מופה: (?i)closed ← AUTHTYPE_UNSPECIFIED
msg1 extensions.auth.type מופה: authenticated ← AUTHTYPE_UNSPECIFIED
msgs extensions.auth.type מופה: (?i)success ← AUTHTYPE_UNSPECIFIED
prod_type extensions.auth.type מופה: (?i)LOGOUT ← AUTHTYPE_UNSPECIFIED
host_name intermediary.asset.hostname מיפוי ישיר
host_name intermediary.hostname מיפוי ישיר
inter_host intermediary.hostname מיפוי ישיר
logmsg metadata.description מיפוי ישיר
message_value metadata.description מיפוי ישיר
msgs metadata.description מיפוי ישיר
date_time metadata.event_timestamp נותח בתור ISO8601
time metadata.event_timestamp נותח בתור ISO8601
time_t metadata.event_timestamp נותח בתור ISO8601
timestamp metadata.event_timestamp נותח בתור ISO8601
description_1 metadata.event_type מופה: (?i)closed ← USER_LOGOUT
has_principal metadata.event_type מופה: true ← NETWORK_CONNECTION, true ← STATUS_UPDATE
has_principal_user metadata.event_type מופה: true ← USER_UNCATEGORIZED
msg1 metadata.event_type מופה: authenticated ← USER_LOGIN
msgs metadata.event_type מופה: (?i)success ← USER_LOGIN
prod_type metadata.event_type מופה: (?i)LOGOUT ← USER_LOGOUT
prod_type metadata.product_event_type מיפוי ישיר
log_id metadata.product_log_id מיפוי ישיר
logid metadata.product_log_id מיפוי ישיר
application_protocol network.application_protocol מופה: (?i)SSH ← SSH
message network.application_protocol מופו: (?i)SSH ← SSH, (?i)netconf ← NETCONF, (?i)dhcp ← DHCP
type1 network.dhcp.type מופה: DHCPDISCOVER ← DISCOVER
message network.ip_protocol מופה: (?i)tcp ← TCP
network_protocol network.ip_protocol מיפוי ישיר
bytes network.sent_bytes מיפוי ישיר
session_id network.session_id מיפוי ישיר
network_host network.tls.cipher מיפוי ישיר
hostname principal.asset.hostname מיפוי ישיר
host principal.asset.ip ממוזג
initiator_ip principal.asset.ip ממוזג
ip principal.asset.ip ממוזג
ipaddress principal.asset.ip ממוזג
logusersrcip principal.asset.ip ממוזג
peer_ip principal.asset.ip ממוזג
principal_ip principal.asset.ip ממוזג
principal_ip1 principal.asset.ip ממוזג
proxy_host principal.asset.ip ממוזג
src_ip principal.asset.ip ממוזג
system_ip principal.asset.ip ממוזג
addr principal.hostname מיפוי ישיר
hostname principal.hostname מיפוי ישיר
host principal.ip ממוזג
initiator_ip principal.ip ממוזג
ip principal.ip ממוזג
ipaddress principal.ip ממוזג
logusersrcip principal.ip ממוזג
peer_ip principal.ip ממוזג
principal_ip principal.ip ממוזג
principal_ip1 principal.ip ממוזג
proxy_host principal.ip ממוזג
src_ip principal.ip ממוזג
system_ip principal.ip ממוזג
initiator_port principal.port מיפוי ישיר
port principal.port מיפוי ישיר
ports principal.port מיפוי ישיר
principal_port principal.port מיפוי ישיר
principal_port1 principal.port מיפוי ישיר
src_port principal.port מיפוי ישיר
process_path principal.process.file.full_path מיפוי ישיר
parent_pid principal.process.parent_process.pid מיפוי ישיר
pid principal.process.pid מיפוי ישיר
process_label principal.resource.attribute.labels ממוזג
process_name_label principal.resource.attribute.labels ממוזג
loguser principal.user.userid מיפוי ישיר
user1 principal.user.userid מיפוי ישיר
user_id principal.user.userid מיפוי ישיר
username principal.user.userid מיפוי ישיר
action security_result.action ממוזג
message security_result.action מופה: (?i)(succeeded/accounting start/open/occurred/update/successfully/success) ← `acti...
classification security_result.category_details ממוזג
msg1 security_result.description מיפוי ישיר
Malware_label security_result.detection_fields ממוזג
direction_label security_result.detection_fields ממוזג
egress_interface_label security_result.detection_fields ממוזג
ingress_interface_label security_result.detection_fields ממוזג
log_prefix_label security_result.detection_fields ממוזג
log_reason_label security_result.detection_fields ממוזג
packet_label security_result.detection_fields ממוזג
policy_label security_result.detection_fields ממוזג
port_label security_result.detection_fields ממוזג
protocol_label security_result.detection_fields ממוזג
proxy_port_label security_result.detection_fields ממוזג
sent_bytes_1_label security_result.detection_fields ממוזג
sent_bytes_2_label security_result.detection_fields ממוזג
tty_label security_result.detection_fields ממוזג
type_label security_result.detection_fields ממוזג
udp_packets_label security_result.detection_fields ממוזג
priority security_result.severity מופה: 1 ← LOW
description_1 security_result.summary מיפוי ישיר
dst_ip target.asset.ip ממוזג
ipadres target.asset.ip ממוזג
logdeviceid target.asset.ip ממוזג
responder_ip target.asset.ip ממוזג
target_ip target.asset.ip ממוזג
target_ip1 target.asset.ip ממוזג
filename target.file.names ממוזג
dst_ip target.ip ממוזג
ipadres target.ip ממוזג
logdeviceid target.ip ממוזג
responder_ip target.ip ממוזג
target_ip target.ip ממוזג
target_ip1 target.ip ממוזג
dst_port target.port מיפוי ישיר
prts target.port מיפוי ישיר
responder_port target.port מיפוי ישיר
target_port target.port מיפוי ישיר
target_port1 target.port מיפוי ישיר
filetype target.process.file.mime_type מיפוי ישיר
parent_identifier_label target.resource.attribute.labels ממוזג
specific_identifer_label target.resource.attribute.labels ממוזג
target_name target.resource.name מיפוי ישיר
instance_id target.resource.product_object_id מיפוי ישיר
target_username target.user.userid מיפוי ישיר
user target.user.userid מיפוי ישיר
לא רלוונטי extensions.auth.type קבוע: AUTHTYPE_UNSPECIFIED
לא רלוונטי metadata.event_type קבוע: USER_LOGIN
לא רלוונטי network.application_protocol קבוע: SSH
לא רלוונטי network.dhcp.type קבוע: DISCOVER
לא רלוונטי network.ip_protocol קבוע: TCP
לא רלוונטי security_result.severity קבוע: LOW
rsa_type event.idm.read_only_udm.additional.fields מופה מיומן השינויים
sha_256 event.idm.read_only_udm.additional.fields מופה מיומן השינויים
NETCONF event.idm.read_only_udm.network.application_protocol מופה מיומן השינויים
TCP event.idm.read_only_udm.network.ip_protocol מופה מיומן השינויים
DHCP event.idm.read_only_udm.network.application_protocol מופה מיומן השינויים
username1 target.user.userid מופה מיומן השינויים
security_result.action ALLOW מופה מיומן השינויים
ip_1 principal.ip מופה מיומן השינויים
ip_2 target.ip מופה מיומן השינויים
port_1 principal.port מופה מיומן השינויים
port_2 target.port מופה מיומן השינויים
message_1 metadata.description מופה מיומן השינויים
malware security_result.detection_fields מופה מיומן השינויים

יומן שינויים

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

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