Mengumpulkan log CASB Cisco CloudLock

Didukung di:

Dokumen ini menjelaskan cara menyerap log Cisco CloudLock CASB ke Google Security Operations menggunakan Google Cloud Storage .Parser mengekstrak kolom dari log JSON, mengubah, dan memetakannya ke Unified Data Model (UDM). Fungsi ini menangani parsing tanggal, mengonversi kolom tertentu menjadi string, memetakan kolom ke entitas UDM (metadata, target, hasil keamanan, tentang), dan melakukan iterasi melalui kecocokan untuk mengekstrak kolom deteksi, yang pada akhirnya menggabungkan semua data yang diekstrak ke dalam kolom @output.

Cisco CloudLock adalah Cloud Access Security Broker (CASB) cloud-native yang memberikan visibilitas dan kontrol atas aplikasi cloud. Solusi ini membantu organisasi menemukan IT bayangan, menerapkan kebijakan pencegahan kebocoran data, mendeteksi ancaman, dan mempertahankan kepatuhan di seluruh aplikasi SaaS.

Sebelum memulai

Pastikan Anda memiliki prasyarat berikut:

  • Instance Google SecOps
  • Project GCP dengan Cloud Storage API yang diaktifkan
  • Izin untuk membuat dan mengelola bucket GCS
  • Izin untuk mengelola kebijakan IAM di bucket GCS
  • Izin untuk membuat layanan Cloud Run, topik Pub/Sub, dan tugas Cloud Scheduler
  • Akses istimewa ke konsol admin Cisco CloudLock

Mendapatkan prasyarat Cisco CloudLock API

Untuk memulai, hubungi Dukungan Cloudlock untuk mendapatkan URL Cloudlock API Anda. Buat token akses di aplikasi Cloudlock dengan memilih tab Authentication & API di halaman Settings dan mengklik Generate.

  1. Login ke konsol admin Cisco CloudLock.
  2. Buka Setelan > Authentication & API.
  3. Di bagian API, klik Generate untuk membuat token akses Anda.
  4. Salin dan simpan detail berikut di lokasi yang aman:
    • Token Akses API
    • URL Dasar API (disediakan oleh Dukungan Cisco CloudLock di [email protected])

Membuat bucket Google Cloud Storage

  1. Buka Google Cloud console.
  2. Pilih project Anda atau buat project baru.
  3. Di menu navigasi, buka Cloud Storage > Buckets.
  4. Klik Create bucket.

  5. Berikan detail konfigurasi berikut:

    Setelan Nilai
    Beri nama bucket Anda Masukkan nama yang unik secara global (misalnya, cisco-cloudlock-logs)
    Location type Pilih berdasarkan kebutuhan Anda (Region, Dual-region, Multi-region)
    Lokasi Pilih lokasi (misalnya, us-central1)
    Kelas penyimpanan Standar (direkomendasikan untuk log yang sering diakses)
    Access control Seragam (direkomendasikan)
    Alat perlindungan Opsional: Aktifkan pembuatan versi objek atau kebijakan retensi

  6. Klik Buat.

Buat akun layanan untuk Cloud Run Function

Fungsi Cloud Run memerlukan akun layanan dengan izin untuk menulis ke bucket GCS.

Membuat akun layanan

  1. Di GCP Console, buka IAM & Admin > Service Accounts.
  2. Klik Create Service Account.
  3. Berikan detail konfigurasi berikut:
    • Nama akun layanan: Masukkan cloudlock-data-export-sa.
    • Deskripsi akun layanan: Masukkan Service account for Cloud Run function to collect Cisco CloudLock logs.
  4. Klik Create and Continue.
  5. Di bagian Berikan akun layanan ini akses ke project:
    1. Klik Pilih peran.
    2. Telusuri dan pilih Storage Object Admin.
    3. Klik + Add another role.
    4. Telusuri dan pilih Cloud Run Invoker.
    5. Klik + Add another role.
    6. Telusuri dan pilih Cloud Functions Invoker.
  6. Klik Lanjutkan.
  7. Klik Selesai.

Memberikan izin IAM pada bucket GCS

Beri akun layanan izin tulis di bucket GCS:

  1. Buka Cloud Storage > Buckets.
  2. Klik nama bucket Anda.
  3. Buka tab Izin.
  4. Klik Grant access.
  5. Berikan detail konfigurasi berikut:
    • Tambahkan prinsipal: Masukkan email akun layanan (misalnya, cloudlock-data-export-sa@PROJECT_ID.iam.gserviceaccount.com).
    • Tetapkan peran: Pilih Storage Object Admin.
  6. Klik Simpan.

Membuat topik Pub/Sub

Buat topik Pub/Sub yang akan dipublikasikan oleh Cloud Scheduler dan akan dilanggan oleh fungsi Cloud Run.

  1. Di GCP Console, buka Pub/Sub > Topics.
  2. Klik Create topic.
  3. Berikan detail konfigurasi berikut:
    • ID Topik: Masukkan cloudlock-data-export-trigger.
    • Biarkan setelan lainnya tetap default.
  4. Klik Buat.

Membuat fungsi Cloud Run untuk mengumpulkan log

Fungsi Cloud Run akan dipicu oleh pesan Pub/Sub dari Cloud Scheduler untuk mengambil log dari Cisco CloudLock API dan menuliskannya ke GCS.

  1. Di GCP Console, buka Cloud Run.
  2. Klik Create service.
  3. Pilih Function (gunakan editor inline untuk membuat fungsi).

  4. Di bagian Konfigurasi, berikan detail konfigurasi berikut:

    Setelan Nilai
    Nama layanan cloudlock-data-export
    Wilayah Pilih region yang cocok dengan bucket GCS Anda (misalnya, us-central1)
    Runtime Pilih Python 3.12 atau yang lebih baru

  5. Di bagian Pemicu (opsional):

    • Klik + Tambahkan pemicu.
    • Pilih Cloud Pub/Sub.
    • Di Select a Cloud Pub/Sub topic, pilih topik (cloudlock-data-export-trigger).
    • Klik Simpan.

  6. Di bagian Authentication:

    • Pilih Wajibkan autentikasi.
    • Periksa Identity and Access Management (IAM).

  7. Scroll ke dan luaskan Containers, Networking, Security.

  8. Buka tab Security:

    • Akun layanan: Pilih akun layanan (cloudlock-data-export-sa).

  9. Buka tab Containers:

    • Klik Variables & Secrets.

    • Klik + Tambahkan variabel untuk setiap variabel lingkungan:

      Nama Variabel Nilai Contoh
      GCS_BUCKET cisco-cloudlock-logs
      GCS_PREFIX cloudlock/
      STATE_KEY cloudlock/state.json
      CLOUDLOCK_API_TOKEN your-api-token
      CLOUDLOCK_API_BASE https://api.cloudlock.com

  10. Scroll ke bawah di tab Variables & Secrets ke Requests:

    • Waktu tunggu permintaan: Masukkan 600 detik (10 menit).

  11. Buka tab Setelan di Penampung:

    • Di bagian Materi:
      • Memori: Pilih 512 MiB atau yang lebih tinggi.
      • CPU: Pilih 1.
    • Klik Selesai.

  12. Scroll ke Lingkungan eksekusi:

    • Pilih Default (direkomendasikan).

  13. Di bagian Penskalaan revisi:

    • Jumlah minimum instance: Masukkan 0.
    • Jumlah maksimum instance: Masukkan 100 (atau sesuaikan berdasarkan perkiraan beban).

  14. Klik Buat.

  15. Tunggu hingga layanan dibuat (1-2 menit).

  16. Setelah layanan dibuat, editor kode inline akan terbuka secara otomatis.

Menambahkan kode fungsi

  1. Masukkan main di Function entry point

  2. Di editor kode inline, buat dua file:

    • File pertama: main.py:

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

# Initialize HTTP client
http = urllib3.PoolManager()

# Initialize Storage client
storage_client = storage.Client()

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

    Args:
        cloud_event: CloudEvent object containing Pub/Sub message
    """

    # Get environment variables
    bucket_name = os.environ.get('GCS_BUCKET')
    prefix = os.environ.get('GCS_PREFIX', 'cloudlock/')
    state_key = os.environ.get('STATE_KEY', 'cloudlock/state.json')
    api_token = os.environ.get('CLOUDLOCK_API_TOKEN')
    api_base = os.environ.get('CLOUDLOCK_API_BASE')

    if not all([bucket_name, api_token, api_base]):
        print('Error: Missing required environment variables')
        return

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

        # Load state (last processed offset for each endpoint)
        state = load_state(bucket, state_key)

        print(f'Processing logs with state: {state}')

        # Create Authorization header
        headers = {
            'Authorization': f'Bearer {api_token}',
            'Content-Type': 'application/json'
        }

        # Fetch incidents data (using offset-based pagination)
        incidents_offset = state.get('incidents_offset', 0)
        incidents, new_incidents_offset = fetch_cloudlock_incidents(
            http, api_base, headers, incidents_offset
        )

        if incidents:
            upload_to_gcs_ndjson(bucket, prefix, 'incidents', incidents)
            print(f'Uploaded {len(incidents)} incidents to GCS')
            state['incidents_offset'] = new_incidents_offset

        # Fetch activities data (using time-based filtering with offset pagination)
        activities_last_time = state.get('activities_last_time')
        if not activities_last_time:
            activities_last_time = (datetime.now(timezone.utc) - timedelta(hours=24)).isoformat()

        activities_offset = state.get('activities_offset', 0)
        activities, new_activities_offset, newest_activity_time = fetch_cloudlock_activities(
            http, api_base, headers, activities_last_time, activities_offset
        )

        if activities:
            upload_to_gcs_ndjson(bucket, prefix, 'activities', activities)
            print(f'Uploaded {len(activities)} activities to GCS')
            state['activities_offset'] = new_activities_offset
            if newest_activity_time:
                state['activities_last_time'] = newest_activity_time

        # Fetch entities data (using offset-based pagination)
        entities_offset = state.get('entities_offset', 0)
        entities, new_entities_offset = fetch_cloudlock_entities(
            http, api_base, headers, entities_offset
        )

        if entities:
            upload_to_gcs_ndjson(bucket, prefix, 'entities', entities)
            print(f'Uploaded {len(entities)} entities to GCS')
            state['entities_offset'] = new_entities_offset

        # Update consolidated state
        state['updated_at'] = datetime.now(timezone.utc).isoformat()
        save_state(bucket, state_key, state)

        print('CloudLock data export completed successfully')

    except Exception as e:
        print(f'Error processing logs: {str(e)}')
        raise

def make_api_request(http, url, headers, retries=3):
    """Make API request with exponential backoff retry logic."""
    for attempt in range(retries):
        try:
            response = http.request('GET', url, headers=headers)

            if response.status == 200:
                return response
            elif response.status == 429:
                # Rate limit
                retry_after = int(response.headers.get('Retry-After', 60))
                print(f'Rate limited, waiting {retry_after} seconds')
                time.sleep(retry_after)
            else:
                print(f'API request failed with status {response.status}: {response.data.decode("utf-8")}')
        except Exception as e:
            print(f'Request attempt {attempt + 1} failed: {str(e)}')
            if attempt < retries - 1:
                wait_time = 2 ** attempt
                time.sleep(wait_time)
            else:
                raise

    return None

def fetch_cloudlock_incidents(http, api_base, headers, start_offset=0):
    """
    Fetch incidents data from Cisco CloudLock API using offset-based pagination.

    Note: The CloudLock API does not support updated_after parameter. This function
    uses offset-based pagination. For production use, consider implementing time-based
    filtering using created_at or updated_at fields in the response data.
    """
    url = f"{api_base}/api/v2/incidents"

    limit = 1000
    offset = start_offset
    all_data = []

    try:
        while True:
            # Build URL with parameters
            full_url = f"{url}?limit={limit}&offset={offset}"

            print(f"Fetching incidents with offset: {offset}")

            response = make_api_request(http, full_url, headers)
            if not response:
                break

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

            # CloudLock API returns items in 'items' array
            batch_data = data.get('items', [])

            if not batch_data:
                print("No more incidents to fetch")
                break

            all_data.extend(batch_data)

            # Check if we've reached the end
            total = data.get('total', 0)
            results = data.get('results', len(batch_data))

            print(f"Fetched {results} incidents (total available: {total})")

            if results < limit or offset + results >= total:
                print("Reached end of incidents")
                break

            offset += limit

        print(f"Fetched {len(all_data)} total incidents")
        return all_data, offset

    except Exception as e:
        print(f"Error fetching incidents: {str(e)}")
        return [], start_offset

def fetch_cloudlock_activities(http, api_base, headers, from_time, start_offset=0):
    """
    Fetch activities data from Cisco CloudLock API using time-based filtering and offset pagination.
    """
    url = f"{api_base}/api/v2/activities"

    limit = 1000
    offset = start_offset
    all_data = []
    newest_time = None

    try:
        while True:
            # Build URL with time filter and pagination
            full_url = f"{url}?limit={limit}&offset={offset}"

            print(f"Fetching activities with offset: {offset}")

            response = make_api_request(http, full_url, headers)
            if not response:
                break

            data = json.loads(response.data.decode('utf-8'))
            batch_data = data.get('items', [])

            if not batch_data:
                print("No more activities to fetch")
                break

            # Filter activities by time (client-side filtering since API may not support time parameters)
            filtered_batch = []
            for item in batch_data:
                item_time = item.get('timestamp') or item.get('created_at')
                if item_time and item_time >= from_time:
                    filtered_batch.append(item)
                    if not newest_time or item_time > newest_time:
                        newest_time = item_time

            all_data.extend(filtered_batch)

            results = data.get('results', len(batch_data))
            total = data.get('total', 0)

            print(f"Fetched {results} activities, {len(filtered_batch)} after time filter (total available: {total})")

            if results < limit or offset + results >= total:
                print("Reached end of activities")
                break

            offset += limit

        print(f"Fetched {len(all_data)} total activities")
        return all_data, offset, newest_time

    except Exception as e:
        print(f"Error fetching activities: {str(e)}")
        return [], start_offset, None

def fetch_cloudlock_entities(http, api_base, headers, start_offset=0):
    """
    Fetch entities data from Cisco CloudLock API using offset-based pagination.

    Note: This endpoint requires the Entity Cache feature. If not enabled,
    use the incident entities endpoint as an alternative.
    """
    url = f"{api_base}/api/v2/entities"

    limit = 1000
    offset = start_offset
    all_data = []

    try:
        while True:
            full_url = f"{url}?limit={limit}&offset={offset}"

            print(f"Fetching entities with offset: {offset}")

            response = make_api_request(http, full_url, headers)
            if not response:
                break

            data = json.loads(response.data.decode('utf-8'))
            batch_data = data.get('items', [])

            if not batch_data:
                print("No more entities to fetch")
                break

            all_data.extend(batch_data)

            results = data.get('results', len(batch_data))
            total = data.get('total', 0)

            print(f"Fetched {results} entities (total available: {total})")

            if results < limit or offset + results >= total:
                print("Reached end of entities")
                break

            offset += limit

        print(f"Fetched {len(all_data)} total entities")
        return all_data, offset

    except Exception as e:
        print(f"Error fetching entities: {str(e)}")
        return [], start_offset

def upload_to_gcs_ndjson(bucket, prefix, data_type, data):
    """Upload data to GCS bucket in NDJSON format (one JSON object per line)."""
    timestamp = datetime.now(timezone.utc).strftime('%Y/%m/%d/%H')
    filename = f"{prefix}{data_type}/{timestamp}/cloudlock_{data_type}_{int(datetime.now(timezone.utc).timestamp())}.jsonl"

    try:
        # Convert to NDJSON format
        ndjson_content = '\n'.join([json.dumps(item, separators=(',', ':')) for item in data])

        blob = bucket.blob(filename)
        blob.upload_from_string(
            ndjson_content,
            content_type='application/x-ndjson'
        )

        print(f"Successfully uploaded {filename} to GCS")

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

def load_state(bucket, key):
    """Load state from GCS with separate tracking for each endpoint."""
    try:
        blob = bucket.blob(key)
        if blob.exists():
            state_data = blob.download_as_text()
            return json.loads(state_data)
    except Exception as e:
        print(f'Warning: Could not load state: {str(e)}')

    print("No previous state found, starting fresh")
    return {}

def save_state(bucket, key, state):
    """Save consolidated state to GCS."""
    try:
        blob = bucket.blob(key)
        blob.upload_from_string(
            json.dumps(state, indent=2),
            content_type='application/json'
        )
        print("Updated state successfully")
    except Exception as e:
        print(f"Error updating state: {str(e)}")
        raise
      • File kedua: requirements.txt:
      functions-framework==3.*
google-cloud-storage==2.*
urllib3>=2.0.0

  3. Klik Deploy untuk menyimpan dan men-deploy fungsi.

  4. Tunggu hingga deployment selesai (2-3 menit).

Buat tugas Cloud Scheduler

Cloud Scheduler memublikasikan pesan ke topik Pub/Sub secara berkala, sehingga memicu fungsi Cloud Run.

  1. Di GCP Console, buka Cloud Scheduler.
  2. Klik Create Job.

  3. Berikan detail konfigurasi berikut:

    Setelan Nilai
    Nama cloudlock-data-export-hourly
    Wilayah Pilih region yang sama dengan fungsi Cloud Run
    Frekuensi 0 * * * * (setiap jam, tepat pada waktunya)
    Zona waktu Pilih zona waktu (UTC direkomendasikan)
    Jenis target Pub/Sub
    Topik Pilih topik (cloudlock-data-export-trigger)
    Isi pesan {} (objek JSON kosong)

  4. Klik Buat.

Opsi frekuensi jadwal

  • Pilih frekuensi berdasarkan volume log dan persyaratan latensi:

    Frekuensi Ekspresi Cron Kasus Penggunaan
    Setiap 5 menit */5 * * * * Volume tinggi, latensi rendah
    Setiap 15 menit */15 * * * * Volume sedang
    Setiap jam 0 * * * * Standar (direkomendasikan)
    Setiap 6 jam 0 */6 * * * Volume rendah, pemrosesan batch
    Harian 0 0 * * * Pengumpulan data historis

Menguji tugas penjadwal

  1. Di konsol Cloud Scheduler, temukan tugas Anda.
  2. Klik Jalankan paksa untuk memicu secara manual.
  3. Tunggu beberapa detik, lalu buka Cloud Run > Services > cloudlock-data-export > Logs.
  4. Pastikan fungsi berhasil dieksekusi.
  5. Periksa bucket GCS untuk mengonfirmasi bahwa log telah ditulis.

Mengambil akun layanan Google SecOps

Google SecOps menggunakan akun layanan unik untuk membaca data dari bucket GCS Anda. Anda harus memberi akun layanan ini akses ke bucket Anda.

Dapatkan email akun layanan

  1. Buka Setelan SIEM > Feed.
  2. Klik Tambahkan Feed Baru.
  3. Klik Konfigurasi satu feed.
  4. Di kolom Nama feed, masukkan nama untuk feed (misalnya, Cisco CloudLock logs).
  5. Pilih Google Cloud Storage V2 sebagai Source type.
  6. Pilih Cisco CloudLock sebagai Log type.

  7. Klik Get Service Account. Email akun layanan yang unik akan ditampilkan, misalnya:

    chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com

  8. Salin alamat email ini untuk digunakan di langkah berikutnya.

Memberikan izin IAM ke akun layanan Google SecOps

Akun layanan Google SecOps memerlukan peran Storage Object Viewer di bucket GCS Anda.

  1. Buka Cloud Storage > Buckets.
  2. Klik nama bucket Anda.
  3. Buka tab Izin.
  4. Klik Grant access.
  5. Berikan detail konfigurasi berikut:
    • Add principals: Tempel email akun layanan Google SecOps.
    • Tetapkan peran: Pilih Storage Object Viewer.
  6. Klik Simpan.

Mengonfigurasi feed di Google SecOps untuk menyerap log Cisco CloudLock

  1. Buka Setelan SIEM > Feed.
  2. Klik Tambahkan Feed Baru.
  3. Klik Konfigurasi satu feed.
  4. Di kolom Nama feed, masukkan nama untuk feed (misalnya, Cisco CloudLock logs).
  5. Pilih Google Cloud Storage V2 sebagai Source type.
  6. Pilih Cisco CloudLock sebagai Log type.
  7. Klik Berikutnya.

  8. Tentukan nilai untuk parameter input berikut:

    • URL bucket penyimpanan: Masukkan URI bucket GCS dengan jalur awalan:

      gs://cisco-cloudlock-logs/cloudlock/

      • Ganti:

        • cisco-cloudlock-logs: Nama bucket GCS Anda.
        • cloudlock/: Awalan/jalur folder opsional tempat log disimpan (biarkan kosong untuk root).

      • Contoh:

        • Bucket root: gs://cisco-cloudlock-logs/
        • Dengan awalan: gs://cisco-cloudlock-logs/cloudlock/
        • Dengan subfolder: gs://cisco-cloudlock-logs/cloudlock/incidents/

    • Opsi penghapusan sumber: Pilih opsi penghapusan sesuai preferensi Anda:

      • Jangan pernah: Tidak pernah menghapus file apa pun setelah transfer (direkomendasikan untuk pengujian).
      • Hapus file yang ditransfer: Menghapus file setelah transfer berhasil.

      • Hapus file yang ditransfer dan direktori kosong: Menghapus file dan direktori kosong setelah transfer berhasil.

    • Usia File Maksimum: Menyertakan file yang diubah dalam beberapa hari terakhir. Defaultnya adalah 180 hari.

    • Namespace aset: Namespace aset.

    • Label penyerapan: Label yang akan diterapkan ke peristiwa dari feed ini.

  9. Klik Berikutnya.

  10. Tinjau konfigurasi feed baru Anda di layar Selesaikan, lalu klik Kirim.

Tabel pemetaan UDM

Kolom Log Pemetaan UDM Logika
created_at about.resource.attribute.labels.key Nilai kolom created_at ditetapkan ke kunci label.
created_at about.resource.attribute.labels.value Nilai kolom created_at ditetapkan ke nilai label.
created_at about.resource.attribute.creation_time Kolom created_at diuraikan sebagai stempel waktu dan dipetakan.
entity.id target.asset.product_object_id Kolom entity.id diganti namanya.
entity.ip target.ip Kolom entity.ip digabungkan ke kolom IP target.
entity.mime_type target.file.mime_type Kolom entity.mime_type diganti namanya saat entity.origin_type adalah "document".
entity.name target.application Kolom entity.name diganti namanya saat entity.origin_type adalah "app".
entity.name target.file.full_path Kolom entity.name diganti namanya saat entity.origin_type adalah "document".
entity.origin_id target.resource.product_object_id Kolom entity.origin_id diganti namanya.
entity.origin_type target.resource.resource_subtype Kolom entity.origin_type diganti namanya.
entity.owner_email target.user.email_addresses Kolom entity.owner_email digabungkan ke kolom email pengguna target jika cocok dengan regex email.
entity.owner_email target.user.user_display_name Kolom entity.owner_email akan diganti namanya jika tidak cocok dengan regex email.
entity.owner_name target.user.user_display_name Kolom entity.owner_name diganti namanya saat entity.owner_email cocok dengan regex email.
entity.vendor.name target.platform_version Kolom entity.vendor.name diganti namanya.
id metadata.product_log_id Kolom id diganti namanya.
incident_status metadata.product_event_type Kolom incident_status diganti namanya.
metadata.event_timestamp Nilai di-hardcode ke "updated_at". Nilai berasal dari kolom updated_at. Kolom updated_at diuraikan sebagai stempel waktu dan dipetakan.
security_result.detection_fields.key Ditetapkan ke "true" jika severity adalah "ALERT" dan incident_status adalah "NEW". Dikonversi ke boolean.
security_result.detection_fields.value Ditetapkan ke "true" jika severity adalah "ALERT" dan incident_status adalah "NEW". Dikonversi ke boolean.
metadata.event_type Nilai di-hardcode ke "GENERIC_EVENT".
metadata.product_name Nilai dikodekan secara permanen menjadi "CISCO_CLOUDLOCK_CASB".
metadata.vendor_name Nilai dikodekan secara permanen ke "CloudLock".
metadata.product_version Nilai di-hardcode ke "Cisco".
security_result.alert_state Disetel ke "ALERTING" jika severity adalah "ALERT" dan incident_status bukan "RESOLVED" atau "DISMISSED". Disetel ke "NOT_ALERTING" jika severity adalah "ALERT" dan incident_status adalah "RESOLVED" atau "DISMISSED".
security_result.detection_fields.key Diperoleh dari array kecocokan, khususnya kunci setiap objek kecocokan.
security_result.detection_fields.value Diperoleh dari array kecocokan, khususnya nilai setiap objek kecocokan.
security_result.rule_id Diperoleh dari policy.id.
security_result.rule_name Diperoleh dari policy.name.
security_result.severity Tetapkan ke "INFORMATIONAL" jika tingkat keparahan adalah "INFO". Ditetapkan ke "CRITICAL" jika tingkat keparahan adalah "CRITICAL". Diperoleh dari tingkat keparahan.
security_result.summary Nilai ditetapkan ke "jumlah kecocokan: " yang digabungkan dengan nilai match_count.
target.resource.resource_type Ditetapkan ke "STORAGE_OBJECT" jika entity.origin_type adalah "document".
target.url Diperoleh dari entity.direct_url saat entity.origin_type adalah "document".
policy.id security_result.rule_id Kolom policy.id diganti namanya.
policy.name security_result.rule_name Kolom policy.name diganti namanya.
tingkat keseriusan, security_result.severity_details Kolom tingkat keparahan diganti namanya.
updated_at about.resource.attribute.labels.key Nilai kolom updated_at ditetapkan ke kunci label.
updated_at about.resource.attribute.labels.value Nilai kolom updated_at ditetapkan ke nilai label.
updated_at about.resource.attribute.last_update_time Kolom updated_at diuraikan sebagai stempel waktu dan dipetakan.

Perlu bantuan lebih lanjut? Dapatkan jawaban dari anggota Komunitas dan profesional Google SecOps.