איסוף יומנים של Cisco Application Centric Infrastructure ‏(ACI)

גרסת המנתח: 4.0

נתמכים ב:

במסמך הזה מוסבר איך להטמיע יומני Cisco Application Centric Infrastructure (ACI) ב-Google Security Operations. המנתח מנסה קודם לעבד את יומני Cisco ACI הנכנסים כהודעות syslog באמצעות תבניות Grok. אם הניתוח של syslog נכשל, המערכת מניחה שההודעה היא בפורמט JSON ומנתחת אותה בהתאם. בסיום, הוא ממפה את השדות שחולצו למודל הנתונים המאוחד (UDM).

השילוב הזה תומך בשתי שיטות:

  • אפשרות 1: פורמט Syslog באמצעות סוכן Bindplane
  • אפשרות 2: Cloud Storage בפורמט JSON באמצעות API בארכיטקטורת REST של APIC

כל אפשרות היא עצמאית ואפשר להטמיע אותה בנפרד, בהתאם לדרישות התשתית ולהעדפות של פורמט היומן.

אפשרות 1: Syslog באמצעות סוכן Bindplane

באפשרות הזו מגדירים את Cisco ACI fabric לשלוח הודעות syslog לסוכן Bindplane, שמעביר אותן ל-Google Security Operations לניתוח.

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

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

  • מכונה של Google SecOps
  • מארח עם Windows 2016 ואילך או Linux עם systemd
  • אם אתם משתמשים בשרת proxy, ודאו שהיציאות של חומת האש פתוחות בהתאם לדרישות של סוכן Bindplane.
  • גישה עם הרשאות למסוף Cisco APIC

קבלת פרטי הכניסה ל-Google SecOps בשביל הסוכן של Bindplane

כדי לאמת את סוכן Bindplane ב-Google SecOps, בוחרים באחת מהשיטות הבאות:

  • פריסות חדשות: משתמשים ב-Chronicle API (אפשרות 1).
  • פריסות קודמות: ממשיכים להשתמש בקובץ האימות להטמעת נתונים (אפשרות 2) עד שה-Ingestion API יופסק ב-20 ביולי 2027.
  1. נכנסים למסוףGoogle Cloud ובוחרים את הפרויקט ב- Google Cloud שמקושר למכונה של Google SecOps.
  2. נכנסים לדף IAM & Admin > Service Accounts.
  3. לוחצים על Create service account.
  4. מזינים את פרטי ההגדרה הבאים:
    • Service account name: מזינים שם לחשבון (לדוגמה, bindplane-ingest).
    • Service account description: מזינים תיאור (לדוגמה, Bindplane agent log ingestion).
  5. לוחצים על Create and continue.
  6. בקטע Grant this service account access to project, לוחצים על Select a role ובוחרים באפשרות Chronicle Editor.
  7. לוחצים על המשך ואז על סיום.
  8. לוחצים על חשבון השירות שיצרתם ועוברים לכרטיסייה Keys.
  9. לוחצים על Add key > Create new key.
  10. בוחרים באפשרות JSON ולוחצים על Create. קובץ המפתח יורד למחשב.
  11. שומרים את קובץ המפתח בתור ingestion-auth.json בספריית Bindplane collector (/opt/observiq-otel-collector/ingestion-auth.json ב-Linux או C:\Program Files\observIQ OpenTelemetry Collector\ingestion-auth.json ב-Windows), או מעדכנים את creds_file_path ב-config.yaml כך שיתאים לנתיב שבו שומרים אותו.
  12. עוברים אל IAM & Admin > Settings ומעתיקים את הערך של Project number. תצטרכו אותו כדי להגדיר את הייצוא.

אפשרות 2: הורדת קובץ האימות להטמעת נתונים (מדור קודם)

  1. נכנסים למסוף Google SecOps.
  2. עוברים אל הגדרות > ניהול נתונים > סוכני איסוף. אם אתם משתמשים בפלטפורמת SIEM בלבד, עוברים אל הגדרות > סוכני איסוף.
  3. מורידים את קובץ האימות להטמעת נתונים.
  4. שומרים את הקובץ באופן מאובטח במערכת שבה יותקן סוכן Bindplane.

איך מקבלים מספר לקוח ב-Google SecOps

  1. עוברים אל הגדרות > ניהול > פרופיל. אם אתם משתמשים בפלטפורמה של SIEM בלבד, עוברים אל הגדרות > פרופיל.
  2. מעתיקים את מספר הלקוח מהקטע פרטי הארגון ושומרים אותו.

התקנת הסוכן של Bindplane

מתקינים את הסוכן של Bindplane במערכת ההפעלה Windows או Linux לפי ההוראות הבאות.

התקנת חלונות

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

    msiexec /i "https://github.com/observIQ/bindplane-otel-collector/releases/latest/download/observiq-otel-collector.msi" /quiet
    
  3. מחכים שההתקנה תסתיים.

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

    sc query observiq-otel-collector
    

    השירות אמור להופיע כ-RUNNING.

התקנה ב-Linux

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

    sudo sh -c "$(curl -fsSlL https://github.com/observIQ/bindplane-otel-collector/releases/latest/download/install_unix.sh)" install_unix.sh
    
  3. מחכים שההתקנה תסתיים.

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

    sudo systemctl status observiq-otel-collector
    

    השירות אמור להופיע כפעיל (פועל).

מקורות מידע נוספים להתקנה

לאפשרויות התקנה נוספות ולפתרון בעיות, קראו את מדריך ההתקנה של סוכן Bindplane.

הגדרת סוכן Bindplane להטמעת Syslog ושליחה ל-Google SecOps

גישה לקובץ התצורה

  1. מאתרים את הקובץ config.yaml. בדרך כלל, הוא נמצא בספרייה /opt/observiq-otel-collector/ ב-Linux או בספריית ההתקנה ב-Windows.
  2. פותחים את הקובץ באמצעות כלי לעריכת טקסט (לדוגמה, nano,‏ vi או פנקס הרשימות).

עריכת הקובץ config.yaml

  • הקובץ config.yaml

    receivers:
      udplog:
        # Replace the port and IP address as required
        listen_address: "0.0.0.0:514"
    
    exporters:
      chronicle/chronicle_w_labels:
        protocol: https
        # Region of your instance, for example us, europe, asia-southeast1
        location: <LOCATION>
        # Project number of the Google Cloud project linked to the instance
        project: '<PROJECT_NUMBER>'
        compression: gzip
        # Adjust the path to the credentials file you downloaded
        creds_file_path: '/path/to/ingestion-authentication-file.json'
        # Replace with your actual customer ID
        customer_id: <CUSTOMER_ID>
        endpoint: chronicle.googleapis.com
        # Add optional ingestion labels for better organization
        log_type: 'CISCO_ACI'
        raw_log_field: body
        ingestion_labels:
          service:
    
    pipelines:
      logs/source0__chronicle_w_labels-0:
        receivers:
          - udplog
        exporters:
          - chronicle/chronicle_w_labels
    

פרמטרים להגדרה

מחליפים את ה-placeholders הבאים:

  • ‫listen_address: מחליפים את היציאה וכתובת ה-IP לפי הצורך בתשתית שלכם. כדי להאזין לכל הממשקים ביציאה 514, משתמשים ב-0.0.0.0:514.
  • ‫creds_file_path: מעדכנים את הנתיב שבו נשמר קובץ המפתח של חשבון השירות (אפשרות 1):
    • Linux: /opt/observiq-otel-collector/ingestion-auth.json
    • Windows: C:\Program Files\observIQ OpenTelemetry Collector\ingestion-auth.json
  • ‫customer_id: מחליפים את YOUR_CUSTOMER_ID במספר הלקוח האמיתי מהשלב הקודם.
  • ‫location: מחליפים את <LOCATION> באזור של המכונה של Google SecOps (לדוגמה, us,‏ europe או asia-southeast1). המייצא מוסיף את הערך הזה בתחילת chronicle.googleapis.com. לרשימה המלאה, ראו נקודות קצה אזוריות.
  • ‫project: מחליפים את <PROJECT_NUMBER> במספר הפרויקט שמופיע בקטע IAM & Admin > Settings.
  • ‫endpoint: משאירים את הערך chronicle.googleapis.com.

מייצא API להטמעה מדור קודם

  • אם אתם משתמשים בקובץ האימות להטמעת נתונים מאפשרות 2, החליפו את הבלוק exporters בבלוק הבא. מגדירים את creds_file_path לנתיב של קובץ האימות להטמעת נתונים. אם המכונה נמצאת מחוץ לארה"ב, מחליפים את malachiteingestion-pa.googleapis.com בנקודת הקצה האזורית (לדוגמה, europe-malachiteingestion-pa.googleapis.com).

    exporters:
      chronicle/chronicle_w_labels:
        compression: gzip
        # Adjust the path to the credentials file you downloaded
        creds_file_path: '/path/to/ingestion-authentication-file.json'
        # Replace with your actual customer ID
        customer_id: <CUSTOMER_ID>
        endpoint: malachiteingestion-pa.googleapis.com
        # Add optional ingestion labels for better organization
        log_type: 'CISCO_ACI'
        raw_log_field: body
        ingestion_labels:
          service:
    

שמירת קובץ התצורה

אחרי העריכה, שומרים את הקובץ:

  • Linux: מקישים על Ctrl+O, ואז על Enter, ואז על Ctrl+X
  • Windows: לוחצים על קובץ > שמירה

מפעילים מחדש את הסוכן של Bindplane כדי להחיל את השינויים.

Linux

כדי להפעיל מחדש את הסוכן של Bindplane במערכת Linux:

  1. מפעילים מחדש את הסוכן:

    sudo systemctl restart observiq-otel-collector
    
  2. בדיקת סטטוס השירות:

    sudo systemctl status observiq-otel-collector
    
  3. בודקים אם יש שגיאות ביומני הפעילות של הסוכן:

    sudo journalctl -u observiq-otel-collector -f
    

Windows

  • כדי להפעיל מחדש את הסוכן של Bindplane ב-Windows, בוחרים באחת מהאפשרויות הבאות:

    • שורת הפקודה או PowerShell כאדמין:

      net stop observiq-otel-collector && net start observiq-otel-collector
      
    • מסוף השירותים:

      1. לוחצים על Win+R, מקלידים services.msc ולוחצים על Enter.
      2. מאתרים את observIQ OpenTelemetry Collector.
      3. לוחצים לחיצה ימנית ובוחרים באפשרות הפעלה מחדש.
      4. מוודאים שהשירות פועל:

        sc query observiq-otel-collector
        
      5. בודקים אם יש שגיאות ביומנים:

        type "C:\Program Files\observIQ OpenTelemetry Collector\log\collector.log"
        

הגדרת העברת Syslog ב-Cisco ACI

הגדרת חוזה לניהול מחוץ לתחום (OOB)

  1. נכנסים למסוף Cisco APIC.
  2. עוברים אל Tenants > mgmt > Contracts > Filters.
  3. לוחצים על יצירת מסנן.
  4. מזינים את פרטי ההגדרה הבאים:
    • שם: מזינים syslog-udp-514.
    • שם הרשומה: מזינים syslog.
    • EtherType: בוחרים באפשרות IP.
    • פרוטוקול IP: בוחרים באפשרות UDP.
    • Destination Port Range From: מזינים 514.
    • Destination Port Range To: מזינים 514.
  5. לוחצים על שליחה.

יצירת חוזה ניהול

  1. עוברים אל Tenants > mgmt > Contracts > Standard.
  2. לוחצים על יצירת חוזה.
  3. מזינים את פרטי ההגדרה הבאים:
    • שם: מזינים mgmt-syslog-contract.
    • היקף: בוחרים באפשרות הקשר.
  4. לוחצים על שליחה.
  5. מרחיבים את החוזה ולוחצים על נושאים.
  6. לוחצים על Create Contract Subject.
  7. מזינים את פרטי ההגדרה הבאים:
    • שם: מזינים syslog-subject.
    • החלה בשני הכיוונים: מסמנים את האפשרות הזו.
  8. לוחצים על שליחה.
  9. מרחיבים את הנושא ולוחצים על מסננים.
  10. לוחצים על Create Filter Binding.
  11. בוחרים את המסנן syslog-udp-514.
  12. לוחצים על שליחה.

הגדרת קבוצת יעדים של Syslog

  1. עוברים אל Admin > External Data Collectors > Monitoring Destinations > Syslog.
  2. לוחצים לחיצה ימנית על Syslog ובוחרים באפשרות Create Syslog Monitoring Destination Group (יצירת קבוצת יעדים לניטור Syslog).
  3. מזינים את פרטי ההגדרה הבאים:
    • שם: מזינים Chronicle-Syslog-Group.
    • Admin State (מצב אדמין): בוחרים באפשרות Enabled (מופעל).
    • פורמט: בוחרים באפשרות aci.
  4. לוחצים על הבא.
  5. בתיבת הדו-שיח Create Syslog Monitoring Destination:
    • שם: מזינים Chronicle-BindPlane.
    • מארח: מזינים את כתובת ה-IP של שרת הסוכן של Bindplane.
    • יציאה: מזינים 514.
    • Admin State (מצב אדמין): בוחרים באפשרות Enabled (מופעל).
    • חומרה: בוחרים באפשרות מידע (כדי לתעד יומנים מפורטים).
  6. לוחצים על שליחה.

הגדרת מדיניות מעקב – מעקב אחרי Fabric

  1. עוברים אל Fabric > Fabric Policies > Policies > Monitoring > Common Policy.
  2. מרחיבים את Callhome/Smart Callhome/SNMP/Syslog/TACACS.
  3. לוחצים לחיצה ימנית על Syslog ובוחרים באפשרות Create Syslog Source.
  4. מזינים את פרטי ההגדרה הבאים:
    • שם: מזינים Chronicle-Fabric-Syslog.
    • יומני ביקורת: מסמנים את האפשרות הזו כדי לכלול אירועים שמצריכים בדיקה.
    • אירועים: מסמנים את התיבה כדי לכלול אירועי מערכת.
    • תקלות: מסמנים את התיבה כדי לכלול אירועי תקלות.
    • יומני סשנים: מסמנים את התיבה כדי לכלול יומני סשנים.
    • קבוצת יעדים: בוחרים באפשרות Chronicle-Syslog-Group.
  5. לוחצים על שליחה.

הגדרת מדיניות מעקב – מעקב אחרי גישה

  1. עוברים אל Fabric > Access Policies > Policies > Monitoring > Default Policy.
  2. מרחיבים את Callhome/Smart Callhome/SNMP/Syslog.
  3. לוחצים לחיצה ימנית על Syslog ובוחרים באפשרות Create Syslog Source.
  4. מזינים את פרטי ההגדרה הבאים:
    • שם: מזינים Chronicle-Access-Syslog.
    • יומני ביקורת: מסמנים את האפשרות הזו כדי לכלול אירועים שמצריכים בדיקה.
    • אירועים: מסמנים את התיבה כדי לכלול אירועי מערכת.
    • תקלות: מסמנים את התיבה כדי לכלול אירועי תקלות.
    • יומני סשנים: מסמנים את התיבה כדי לכלול יומני סשנים.
    • קבוצת יעדים: בוחרים באפשרות Chronicle-Syslog-Group.
  5. לוחצים על שליחה.

הגדרת מדיניות להודעות Syslog של המערכת

  1. עוברים אל Fabric > Fabric Policies > Policies > Monitoring > Common Policy.
  2. מרחיבים את הקטע Syslog Messages Policies.
  3. לוחצים על ברירת מחדל.
  4. בקטע מסנן מתקנים:
    • מתקן: בוחרים באפשרות ברירת מחדל.
    • Minimum Severity: משנים ל-information.
  5. לוחצים על שליחה.

אפשרות 2: JSON באמצעות Cloud Storage

באפשרות הזו, ממשק ה-API בארכיטקטורת REST של APIC משמש לאיסוף אירועים, תקלות ויומני ביקורת בפורמט JSON מ-Cisco ACI fabric, ולאחסון שלהם ב-Cloud Storage לצורך הטמעה ב-Google SecOps.

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

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

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

איסוף דרישות מוקדמות של Cisco ACI APIC

קבלת פרטי הכניסה ל-APIC

  1. נכנסים למסוף Cisco APIC באמצעות HTTPS.
  2. עוברים אל Admin > AAA (ב-APIC 6.0 ואילך) או אל Admin > Authentication > AAA (בגרסאות ישנות יותר).

  3. יוצרים משתמש מקומי עם הרשאות מתאימות או משתמשים במשתמש מקומי קיים.

  4. מעתיקים את הפרטים הבאים ושומרים אותם במיקום מאובטח:

    • שם משתמש ב-APIC: משתמש מקומי עם גישת קריאה לנתוני המעקב
    • סיסמת APIC: סיסמת המשתמש
    • כתובת ה-URL של ה-APIC: כתובת ה-URL מסוג HTTPS של ה-APIC (לדוגמה, https://apic.example.com)

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

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

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

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

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

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

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

נותנים לחשבון השירות (cisco-aci-collector-sa) הרשאות כתיבה בקטגוריה של Cloud Storage:

  1. נכנסים לדף Cloud Storage > Buckets.
  2. לוחצים על שם הקטגוריה (לדוגמה, cisco-aci-logs).
  3. עוברים לכרטיסייה Permissions.
  4. לוחצים על הענקת גישה.
  5. מזינים את פרטי ההגדרה הבאים:
    • הוספת חשבונות משתמשים: מזינים את כתובת האימייל של חשבון השירות (לדוגמה, cisco-aci-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-aci-trigger.
    • משאירים את שאר ההגדרות כברירת מחדל.
  4. לוחצים על יצירה.

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

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

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

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

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

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

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

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

    1. לוחצים על Variables & Secrets.
    2. לוחצים על ‎+ Add variable לכל משתנה סביבה:
    שם משתנה ערך לדוגמה תיאור
    GCS_BUCKET cisco-aci-logs שם הקטגוריה של Cloud Storage
    GCS_PREFIX cisco-aci-events קידומת לקובצי יומן
    STATE_KEY cisco-aci-events/state.json נתיב קובץ תמונת המצב
    APIC_URL https://apic.example.com כתובת URL מסוג HTTPS של APIC
    APIC_USERNAME your-apic-username שם המשתמש ב-APIC
    APIC_PASSWORD your-apic-password סיסמת APIC
    PAGE_SIZE 100 רשומות בכל דף
    MAX_PAGES 10 מספר הדפים המקסימלי בכל הפעלה
  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
    from datetime import datetime, timezone, timedelta
    import logging
    
    # Configure logging
    logger = logging.getLogger()
    logger.setLevel(logging.INFO)
    
    # Initialize HTTP client with timeouts
    http = urllib3.PoolManager(
        timeout=urllib3.Timeout(connect=5.0, read=60.0),
        retries=False,
    )
    
    # Initialize Storage client
    storage_client = storage.Client()
    
    # Environment variables
    GCS_BUCKET = os.environ.get('GCS_BUCKET')
    GCS_PREFIX = os.environ.get('GCS_PREFIX', 'cisco-aci-events')
    STATE_KEY = os.environ.get('STATE_KEY', 'cisco-aci-events/state.json')
    APIC_URL = os.environ.get('APIC_URL')
    APIC_USERNAME = os.environ.get('APIC_USERNAME')
    APIC_PASSWORD = os.environ.get('APIC_PASSWORD')
    PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '100'))
    MAX_PAGES = int(os.environ.get('MAX_PAGES', '10'))
    
    @functions_framework.cloud_event
    def main(cloud_event):
        """
        Cloud Run function triggered by Pub/Sub to fetch Cisco ACI logs and write to GCS.
    
        Args:
            cloud_event: CloudEvent object containing Pub/Sub message
        """
    
        if not all([GCS_BUCKET, APIC_URL, APIC_USERNAME, APIC_PASSWORD]):
            logger.error('Error: Missing required environment variables')
            return
    
        try:
            # Get GCS bucket
            bucket = storage_client.bucket(GCS_BUCKET)
    
            # Load state
            state = load_state(bucket, STATE_KEY)
    
            # Determine time window
            last_timestamp = state.get('last_timestamp')
            if not last_timestamp:
                last_timestamp = (datetime.utcnow() - timedelta(hours=1)).isoformat() + 'Z'
    
            logger.info(f"Starting Cisco ACI data collection for bucket: {GCS_BUCKET}")
    
            # Authenticate to APIC
            session_token = authenticate_apic(APIC_URL, APIC_USERNAME, APIC_PASSWORD)
            headers = {
                'Cookie': f'APIC-cookie={session_token}',
                'Accept': 'application/json',
                'Content-Type': 'application/json'
            }
    
            # Data types to collect
            data_types = ['faultInst', 'eventRecord', 'aaaModLR']
            all_collected_data = []
    
            for data_type in data_types:
                logger.info(f"Collecting {data_type} data")
                collected_data = collect_aci_data(
                    APIC_URL,
                    headers,
                    data_type,
                    last_timestamp,
                    PAGE_SIZE,
                    MAX_PAGES
                )
    
                # Tag each record with its type
                for record in collected_data:
                    record['_data_type'] = data_type
    
                all_collected_data.extend(collected_data)
                logger.info(f"Collected {len(collected_data)} {data_type} records")
    
            logger.info(f"Total records collected: {len(all_collected_data)}")
    
            # Store data in GCS if any were collected
            if all_collected_data:
                timestamp_str = datetime.utcnow().strftime('%Y%m%d_%H%M%S')
                s3_key = f"{GCS_PREFIX}/cisco_aci_events_{timestamp_str}.ndjson"
    
                # Convert to NDJSON format (one JSON object per line)
                ndjson_content = '\n'.join(json.dumps(record) for record in all_collected_data)
    
                # Upload to GCS
                blob = bucket.blob(s3_key)
                blob.upload_from_string(
                    ndjson_content,
                    content_type='application/x-ndjson'
                )
    
                logger.info(f"Uploaded {len(all_collected_data)} records to gs://{GCS_BUCKET}/{s3_key}")
    
                # Update state file with latest timestamp from collected data
                latest_timestamp = get_latest_timestamp_from_records(all_collected_data)
                if not latest_timestamp:
                    latest_timestamp = datetime.utcnow().isoformat() + 'Z'
    
                update_state(bucket, STATE_KEY, latest_timestamp)
            else:
                logger.info("No new log records found.")
    
            logger.info(f"Successfully processed {len(all_collected_data)} records")
    
        except Exception as e:
            logger.error(f'Error processing logs: {str(e)}')
            raise
    
    def authenticate_apic(apic_url, username, password):
        """Authenticate to APIC and return session token"""
        login_url = f"{apic_url}/api/aaaLogin.json"
        login_data = {
            "aaaUser": {
                "attributes": {
                    "name": username,
                    "pwd": password
                }
            }
        }
    
        response = http.request(
            'POST',
            login_url,
            body=json.dumps(login_data).encode('utf-8'),
            headers={'Content-Type': 'application/json'},
            timeout=30
        )
    
        if response.status != 200:
            raise RuntimeError(f"APIC authentication failed: {response.status} {response.data[:256]!r}")
    
        response_data = json.loads(response.data.decode('utf-8'))
        token = response_data['imdata'][0]['aaaLogin']['attributes']['token']
        logger.info("Successfully authenticated to APIC")
        return token
    
    def collect_aci_data(apic_url, headers, data_type, last_timestamp, page_size, max_pages):
        """Collect data from APIC REST API with pagination"""
        all_data = []
        page = 0
    
        while page < max_pages:
            # Build API URL with pagination and time filters
            api_url = f"{apic_url}/api/class/{data_type}.json"
            params = [
                f'page-size={page_size}',
                f'page={page}',
                f'order-by={data_type}.created|asc'
            ]
    
            # Add time filter to prevent duplicates
            if last_timestamp:
                params.append(f'query-target-filter=gt({data_type}.created,"{last_timestamp}")')
    
            full_url = f"{api_url}?{'&'.join(params)}"
    
            logger.info(f"Fetching {data_type} page {page} from APIC")
    
            # Make API request
            response = http.request('GET', full_url, headers=headers, timeout=60)
    
            if response.status != 200:
                logger.error(f"API request failed: {response.status} {response.data[:256]!r}")
                break
    
            data = json.loads(response.data.decode('utf-8'))
            records = data.get('imdata', [])
    
            if not records:
                logger.info(f"No more {data_type} records found")
                break
    
            # Extract the actual data from APIC format
            extracted_records = []
            for record in records:
                if data_type in record:
                    extracted_records.append(record[data_type])
    
            all_data.extend(extracted_records)
            page += 1
    
            # If we got less than page_size records, we've reached the end
            if len(records) < page_size:
                break
    
        return all_data
    
    def get_last_timestamp(bucket, state_key):
        """Get the last run timestamp from GCS state file"""
        try:
            blob = bucket.blob(state_key)
            if blob.exists():
                state_data = blob.download_as_text()
                state = json.loads(state_data)
                return state.get('last_timestamp')
        except Exception as e:
            logger.warning(f"Error reading state file: {str(e)}")
    
        return None
    
    def get_latest_timestamp_from_records(records):
        """Get the latest timestamp from collected records to prevent missing events"""
        if not records:
            return None
    
        latest = None
        latest_time = None
    
        for record in records:
            try:
                # Handle both direct attributes and nested structure
                attrs = record.get('attributes', record)
                created = attrs.get('created')
                modTs = attrs.get('modTs')
    
                # Use created or modTs as fallback
                timestamp = created or modTs
    
                if timestamp:
                    if latest_time is None or timestamp > latest_time:
                        latest_time = timestamp
                        latest = record
            except Exception as e:
                logger.debug(f"Error parsing timestamp from record: {e}")
                continue
    
        return latest_time
    
    def update_state(bucket, state_key, timestamp):
        """Update the state file with the current timestamp"""
        try:
            state_data = {
                'last_timestamp': timestamp,
                'updated_at': datetime.utcnow().isoformat() + 'Z'
            }
            blob = bucket.blob(state_key)
            blob.upload_from_string(
                json.dumps(state_data),
                content_type='application/json'
            )
            logger.info(f"Updated state file with timestamp: {timestamp}")
        except Exception as e:
            logger.error(f"Error updating state file: {str(e)}")
    
    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:
            logger.warning(f"Could not load state: {e}")
    
        return {}
    
    • הקובץ השני: 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-aci-collector-15m
    אזור בוחרים את אותו אזור כמו של פונקציית Cloud Run.
    תדירות */15 * * * * (כל 15 דקות)
    אזור זמן בחירת אזור זמן (מומלץ לבחור ב-UTC)
    סוג היעד Pub/Sub
    נושא בוחרים את נושא Pub/Sub (cisco-aci-trigger)
    גוף ההודעה ‫{} (אובייקט JSON ריק)
  4. לוחצים על יצירה.

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

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

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

בדיקת השילוב

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

    Starting Cisco ACI data collection for bucket: cisco-aci-logs
    Successfully authenticated to APIC
    Collecting faultInst data
    Collected X faultInst records
    Collecting eventRecord data
    Collected X eventRecord records
    Collecting aaaModLR data
    Collected X aaaModLR records
    Total records collected: X
    Uploaded X records to gs://cisco-aci-logs/cisco-aci-events/cisco_aci_events_YYYYMMDD_HHMMSS.ndjson
    Successfully processed X records
    
  8. נכנסים לדף Cloud Storage > Buckets.

  9. לוחצים על שם הקטגוריה (cisco-aci-logs).

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

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

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

  • ‫HTTP 401: בודקים את פרטי הכניסה של APIC במשתני הסביבה
  • ‫HTTP 403: מוודאים שלחשבון APIC יש הרשאות קריאה למחלקות faultInst,‏ eventRecord ו-aaaModLR
  • שגיאות בחיבור: מוודאים שפונקציית Cloud Run יכולה להגיע לכתובת ה-URL של APIC ב-TCP/443.
  • חסרים משתני סביבה: צריך לוודא שכל המשתנים הנדרשים מוגדרים.

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

  1. עוברים אל הגדרות > ניהול נתונים > פידים. אם אתם משתמשים בפלטפורמת SIEM בלבד, עוברים אל הגדרות > פידים.
  2. לוחצים על הוספת פיד חדש.
  3. לוחצים על הגדרת פיד יחיד.
  4. בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Cisco ACI JSON logs).
  5. בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
  6. בוחרים באפשרות Cisco Application Centric Infrastructure בתור 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-aci-logs/cisco-aci-events/
    
    • החלפה:
      • ‫cisco-aci-logs: השם של הקטגוריה ב-Cloud Storage.
      • ‫cisco-aci-events: נתיב הקידומת/התיקייה שבהם נשמרים היומנים.
    • אפשרות מחיקת המקור: בוחרים את אפשרות המחיקה המועדפת:
      • אף פעם: לא מוחק קבצים אחרי העברות (מומלץ לבדיקה).
      • מחיקת קבצים שהועברו: מחיקת קבצים אחרי שהועברו בהצלחה.
      • מחיקת קבצים שהועברו וספריות ריקות: מחיקת קבצים וספריות ריקות אחרי העברה מוצלחת.
    • גיל הקובץ המקסימלי: כולל קבצים ששונו במספר הימים האחרונים. ברירת המחדל היא 180 ימים.
    • מרחב השמות של הנכס: מרחב השמות של הנכס.
    • תוויות הטמעה: התווית שנוספה לאירועים מהפיד הזה.
  11. לוחצים על הבא.

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

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

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

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

טבלת מיפוי UDM

שדה ביומן מיפוי UDM היגיון
@timestamp read_only_udm.metadata.event_timestamp הערך נלקח מהשדה "‎@timestamp" ביומן הגולמי ומנותח כחותמת זמן.
aci_tag read_only_udm.metadata.product_log_id הערך נלקח מהשדה aci_tag ביומן הגולמי.
cisco_timestamp - לא ממופים.
DIP read_only_udm.target.ip הערך נלקח מהשדה DIP ביומן הגולמי.
DPort read_only_udm.target.port הערך נלקח מהשדה "DPort" ביומן הגולמי ומומר למספר שלם.
description read_only_udm.security_result.description הערך נלקח מהשדה "תיאור" ביומן הגולמי.
fault_cause read_only_udm.additional.fields.value.string_value הערך נלקח מהשדה fault_cause ביומן הגולמי. המפתח מוגדר כ-"Fault Cause".
שם המארח read_only_udm.principal.hostname הערך נלקח מהשדה hostname ביומן הגולמי.
lifecycle_state read_only_udm.metadata.product_event_type הערך נלקח מהשדה "lifecycle_state" ביומן הגולמי.
log.source.address - לא ממופים.
logstash.collect.host - לא ממופים.
logstash.collect.timestamp read_only_udm.metadata.collected_timestamp הערך נלקח מהשדה "logstash.collect.timestamp" ביומן הגולמי ומנותח כחותמת זמן.
logstash.ingest.host read_only_udm.intermediary.hostname הערך נלקח מהשדה "logstash.ingest.host" ביומן הגולמי.
logstash.irm_environment read_only_udm.additional.fields.value.string_value הערך נלקח מהשדה "logstash.irm_environment" ביומן הגולמי. המפתח מוגדר כ-"IRM_Environment".
logstash.irm_region read_only_udm.additional.fields.value.string_value הערך נלקח מהשדה "logstash.irm_region" ביומן הגולמי. המפתח מוגדר כ-"IRM_Region".
logstash.irm_site read_only_udm.additional.fields.value.string_value הערך נלקח משדה היומן הגולמי logstash.irm_site. המפתח מוגדר כ-"IRM_Site".
logstash.process.host read_only_udm.intermediary.hostname הערך נלקח מהשדה "logstash.process.host" ביומן הגולמי.
הודעה - לא ממופים.
message_class - לא ממופים.
message_code - לא ממופים.
message_content - לא ממופים.
message_dn - לא ממופים.
message_type read_only_udm.metadata.product_event_type הערך נלקח מהשדה "message_type" ביומן הגולמי אחרי הסרת הסוגריים המרובעים.
node_link read_only_udm.principal.process.file.full_path הערך נלקח מהשדה "node_link" ביומן הגולמי.
PktLen read_only_udm.network.received_bytes הערך נלקח מהשדה PktLen ביומן הגולמי ומומר למספר שלם ללא סימן.
תוכנית - לא ממופים.
פרוטו read_only_udm.network.ip_protocol הערך נלקח מהשדה "פרוטוקול" ביומן הגולמי, מומר למספר שלם וממופה לשם של פרוטוקול ה-IP המתאים (למשל, 6 -> TCP).
SIP read_only_udm.principal.ip הערך נלקח מהשדה SIP ביומן הגולמי.
SPort read_only_udm.principal.port הערך נלקח מהשדה SPort ביומן הגולמי ומומר למספר שלם.
syslog_facility - לא ממופים.
syslog_facility_code - לא ממופים.
syslog_host read_only_udm.principal.ip, read_only_udm.observer.ip הערך נלקח מהשדה syslog_host ביומן הגולמי.
syslog_prog - לא ממופים.
syslog_severity read_only_udm.security_result.severity_details הערך נלקח מהשדה syslog_severity ביומן הגולמי.
syslog_severity_code read_only_udm.security_result.severity הערך נלקח מהשדה syslog_severity_code ביומן הגולמי וממופה לרמת החומרה המתאימה: 5, 6, 7 -> INFORMATIONAL;‏ 3, 4 -> MEDIUM;‏ 0, 1, 2 -> HIGH.
syslog5424_pri - לא ממופים.
Vlan-Id read_only_udm.principal.resource.id הערך נלקח מהשדה "Vlan-Id" ביומן הגולמי.
- read_only_udm.metadata.event_type לוגיקה: אם מופיעים "SIP" או "שם מארח" ומופיע "פרוטוקול", מגדירים את הערך "NETWORK_CONNECTION". אחרת, אם מופיע "SIP", ‏ "hostname" או "syslog_host", צריך להגדיר את הערך "STATUS_UPDATE". אחרת, מגדירים את הערך "GENERIC_EVENT".
- read_only_udm.metadata.log_type לוגיקה: צריך להגדיר את הערך CISCO_ACI.
- read_only_udm.metadata.vendor_name לוגיקה: הגדרה ל-"Cisco".
- read_only_udm.metadata.product_name לוגיקה: צריך להגדיר את הערך "ACI".
principal_mac event.idm.read_only_udm.principal.mac וגם event.idm.read_only_udm.principal.asset.mac מופה מיומן השינויים
context_id event.idm.read_only_udm.additional.fields מופה מיומן השינויים
node_number event.idm.read_only_udm.additional.fields מופה מיומן השינויים
code1 event.idm.read_only_udm.security_result.detection_fields מופה מיומן השינויים
code2 event.idm.read_only_udm.security_result.detection_fields מופה מיומן השינויים
pid event.idm.read_only_udm.principal.process.pid מופה מיומן השינויים
src_intf event.idm.read_only_udm.principal.resource.attribute.labels מופה מיומן השינויים
VXLAN event.idm.read_only_udm.network.session_id מופה מיומן השינויים
VlanType event.idm.read_only_udm.additional.fields מופה מיומן השינויים
flag event.idm.read_only_udm.additional.fields מופה מיומן השינויים
Hitcnt event.idm.read_only_udm.additional.fields מופה מיומן השינויים
syslog_facility event.idm.read_only_udm.additional.fields מופה מיומן השינויים
SMac event.idm.read_only_udm.principal.resource.attribute.labels מופה מיומן השינויים
DMac event.idm.read_only_udm.target.resource.attribute.labels מופה מיומן השינויים
path event.idm.read_only_udm.principal.process.file.full_path מופה מיומן השינויים
CName event.idm.read_only_udm.security_result.rule_name מופה מיומן השינויים
i_ip event.idm.read_only_udm.intermediary.ip מופה מיומן השינויים
i_ip event.idm.read_only_udm.intermediary.asset.ip מופה מיומן השינויים
log_id event.idm.read_only_udm.metadata.product_log_id מופה מיומן השינויים
product_event_type event.idm.read_only_udm.metadata.product_event_type מופה מיומן השינויים
severity_action event.idm.read_only_udm.security_result.severity מופה מיומן השינויים
session_id event.idm.read_only_udm.network.session_id מופה מיומן השינויים
protocol event.idm.read_only_udm.additional.fields מופה מיומן השינויים
message_code event.idm.read_only_udm.additional.fields מופה מיומן השינויים
program event.idm.read_only_udm.additional.fields מופה מיומן השינויים
syslog_prog event.idm.read_only_udm.additional.fields מופה מיומן השינויים
message_dn event.idm.read_only_udm.additional.fields מופה מיומן השינויים
message_class event.idm.read_only_udm.additional.fields מופה מיומן השינויים
syslog_facility_code event.idm.read_only_udm.additional.fields מופה מיומן השינויים
syslog5424_pri event.idm.read_only_udm.additional.fields מופה מיומן השינויים
initial_code event.idm.read_only_udm.additional.fields מופה מיומן השינויים
logstash.ingest.timestamp event.idm.read_only_udm.additional.fields מופה מיומן השינויים
cisco_timestamp event.idm.read_only_udm.additional.fields מופה מיומן השינויים

יומן שינויים

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

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