Mengumpulkan log perangkat Armis

Versi Parser: 2.0

Didukung di:

Google SecOps SIEM

Dokumen ini menjelaskan cara menyerap log perangkat Armis ke Google Security Operations menggunakan Google Cloud Storage V2.

Armis Centrix adalah platform kecerdasan aset kelas perusahaan yang dirancang untuk memberikan visibilitas dan perlindungan bagi perangkat terkelola, tidak terkelola, dan IoT/OT. Aliran data Armis Devices menangkap inventaris perangkat lengkap yang diamati di seluruh jaringan yang dipantau, termasuk detail hardware, atribut jaringan, penilaian risiko, dan metadata klasifikasi. Log inventaris perangkat ini dapat diekspor melalui Armis REST API dan ditulis ke bucket GCS untuk penyerapan oleh Google SecOps.

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 membuat layanan Cloud Run, topik Pub/Sub, dan tugas Cloud Scheduler
• Instance Armis Centrix dengan akses API
• Kunci rahasia Armis API dengan izin untuk membaca data perangkat

Membuat kunci rahasia Armis API

1. Login ke konsol Armis Centrix di https://<your-instance>.armis.com.
2. Buka Setelan > Pengelolaan Aset & Keamanan > Pengelolaan API.
3. Klik Create untuk membuat kunci rahasia API baru.
4. Dialog akan menampilkan kunci rahasia.
5. Salin dan simpan kunci rahasia dengan aman.

Penting: Kunci rahasia hanya ditampilkan sekali selama pembuatan. Simpan di lokasi yang aman. Anda akan memerlukan kunci ini untuk mengautentikasi permintaan API.

Memverifikasi akses API

• Uji kredensial Anda sebelum melanjutkan integrasi:

  ARMIS_INSTANCE="https://your-instance.armis.com"
  ARMIS_SECRET_KEY="your-secret-key"
  
  # Get access token
  ACCESS_TOKEN=$(curl -s -X POST "${ARMIS_INSTANCE}/api/v1/access_token/" \
      -d "secret_key=${ARMIS_SECRET_KEY}" \
      | python3 -c "import sys,json; print(json.load(sys.stdin)['data']['access_token'])")
  
  echo "Access Token: ${ACCESS_TOKEN}"
  
  # Test device search
  curl -s "${ARMIS_INSTANCE}/api/v1/search/" \
      -H "Authorization: ${ACCESS_TOKEN}" \
      -G \
      --data-urlencode "aql=in:devices timeFrame:\"1 Hours\"" \
      --data-urlencode "length=1" \
      --data-urlencode "fields=id,name,type,category,model,manufacturer,ipAddress,macAddress,operatingSystem,riskLevel,site,firstSeen,lastSeen" \
      | python3 -m json.tool
  

  Catatan: Token akses bersifat sementara. Untuk fungsi Cloud Run, token akan otomatis diperbarui sebelum setiap pengumpulan data dijalankan.

Membuat bucket Google Cloud Storage

1. Buka Konsol Google Cloud.
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
   Memberi nama bucket Anda	Masukkan nama yang unik secara global (misalnya, armis-device-logs)
   Location type	Pilih sesuai kebutuhan Anda (Region, Dual-region, Multi-region)
   Location	Pilih lokasi (misalnya, us-central1)
   Storage class	Standard (direkomendasikan untuk log yang sering diakses)
   Kontrol akses	Seragam (direkomendasikan)
   Alat perlindungan	Opsional: Mengaktifkan pembuatan versi objek atau kebijakan retensi

6. Klik Create.

Membuat akun layanan untuk fungsi Cloud Run

Fungsi Cloud Run memerlukan akun layanan dengan izin untuk menulis ke bucket GCS dan dipanggil oleh Pub/Sub.

Membuat akun layanan

1. Di Konsol GCP, buka IAM & Admin > Service Accounts.
2. Klik Create Service Account.
3. Berikan detail konfigurasi berikut:
   • Service account name: Masukkan armis-devices-collector-sa
   • Service account description: Masukkan Service account for Cloud Run function to collect Armis device inventory logs
4. Klik Create and Continue.
5. Di bagian Grant this service account access to project, tambahkan peran berikut:
   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 Done.

Peran ini diperlukan untuk:

• Storage Object Admin: Menulis log ke bucket GCS dan mengelola state file
• Cloud Run Invoker: Mengizinkan Pub/Sub memanggil fungsi
• Cloud Functions Invoker: Mengizinkan pemanggilan fungsi

Memberikan izin IAM di 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 entitas: Masukkan email akun layanan (misalnya, armis-devices-collector-sa@PROJECT_ID.iam.gserviceaccount.com)
   • Assign roles: Pilih Storage Object Admin
6. Klik Simpan.

Membuat topik Pub/Sub

Buat topik Pub/Sub yang akan dipublikasikan oleh Cloud Scheduler dan di-subscribe oleh fungsi Cloud Run.

1. Di Konsol GCP, buka Pub/Sub > Topics.
2. Klik Create topic.
3. Berikan detail konfigurasi berikut:
   • ID Topik: Masukkan armis-devices-trigger
   • Biarkan setelan lainnya sesuai default
4. Klik Create.

Membuat fungsi Cloud Run untuk mengumpulkan log

Fungsi Cloud Run akan dipicu oleh pesan Pub/Sub dari Cloud Scheduler untuk mengambil data inventaris perangkat dari Armis REST API dan menulisnya ke GCS.

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

4. Di bagian Configure, berikan detail konfigurasi berikut:

   Setelan	Nilai
   Nama layanan	armis-devices-collector
   Region	Pilih region yang cocok dengan bucket GCS Anda (misalnya, us-central1)
   Runtime	Pilih Python 3.12 atau yang lebih baru

5. Di bagian Trigger (optional):

   1. Klik + Tambahkan pemicu.
   2. Pilih Cloud Pub/Sub.
   3. Di Select a Cloud Pub/Sub topic, pilih topik armis-devices-trigger.
   4. Klik Simpan.

6. Di bagian Authentication:

   1. Pilih Wajibkan autentikasi.
   2. Periksa Identity and Access Management (IAM).
   Catatan: Pub/Sub akan otomatis menangani autentikasi saat memanggil fungsi.

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

8. Buka tab Keamanan:

   • Service account: Pilih akun layanan armis-devices-collector-sa

9. Buka tab Penampung:

   1. Klik Variables & Secrets.
   2. Klik + Add variable untuk setiap variabel lingkungan:

   Nama Variabel	Nilai Contoh	Deskripsi
   GCS_BUCKET	armis-device-logs	Nama bucket GCS
   GCS_PREFIX	armis-devices	Awalan untuk file log
   STATE_KEY	armis-devices/state.json	Jalur file status
   ARMIS_INSTANCE_URL	https://your-instance.armis.com	URL instance Armis
   ARMIS_SECRET_KEY	your-secret-key	Kunci rahasia API Armis
   PAGE_SIZE	1000	Data per halaman API
   MAX_RECORDS	50000	Data maksimum per operasi
   LOOKBACK_HOURS	24	Periode lihat balik awal

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

    • Waktu tunggu permintaan: Masukkan 540 detik (9 menit)

11. Buka tab Setelan:

    • Di bagian Resources:
      • Memory: Pilih 512 MiB atau lebih tinggi
      • CPU: Pilih 1

12. Di bagian Revision scaling:

    • Minimum number of instances: Masukkan 0
    • Maximum number of instances: Masukkan 100 (atau sesuaikan berdasarkan beban yang diharapkan)

13. Klik Create.

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

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

Menambahkan kode fungsi

1. Masukkan main di kolom 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
     import urllib.parse
     from datetime import datetime, timezone, timedelta
     import time
     
     # 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', 'armis-devices').strip('/')
     STATE_KEY = os.environ.get('STATE_KEY') or f"{GCS_PREFIX}/state.json"
     ARMIS_INSTANCE_URL = os.environ.get('ARMIS_INSTANCE_URL', '').rstrip('/')
     ARMIS_SECRET_KEY = os.environ.get('ARMIS_SECRET_KEY')
     PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '1000'))
     MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '50000'))
     LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))
     
     DEVICE_FIELDS = [
       'id', 'name', 'type', 'category', 'model', 'manufacturer',
       'ipAddress', 'macAddress', 'operatingSystem', 'operatingSystemVersion',
       'riskLevel', 'site', 'tags', 'firstSeen', 'lastSeen',
       'boundaries', 'customProperties', 'dataSources', 'userIds',
       'visibility', 'ppiSensitive'
     ]
     
     def parse_datetime(value):
       """Parse ISO datetime string to datetime object."""
       if not value:
         return None
       if value.endswith("Z"):
         value = value[:-1] + "+00:00"
       try:
         return datetime.fromisoformat(value)
       except Exception:
         try:
           return datetime.strptime(value, '%Y-%m-%dT%H:%M:%S')
         except Exception:
           return None
     
     def get_access_token():
       """Obtain an access token from the Armis API."""
       url = f"{ARMIS_INSTANCE_URL}/api/v1/access_token/"
       body = urllib.parse.urlencode({'secret_key': ARMIS_SECRET_KEY})
       response = http.request(
         'POST', url,
         body=body,
         headers={'Content-Type': 'application/x-www-form-urlencoded'}
       )
       if response.status != 200:
         raise Exception(
           f"Failed to get access token: HTTP {response.status} - "
           f"{response.data.decode('utf-8')}"
         )
       data = json.loads(response.data.decode('utf-8'))
       return data['data']['access_token']
     
     @functions_framework.cloud_event
     def main(cloud_event):
       """
       Cloud Run function triggered by Pub/Sub to fetch
       Armis Device inventory records and write to GCS.
     
       Args:
         cloud_event: CloudEvent object containing Pub/Sub message
       """
     
       if not all([GCS_BUCKET, ARMIS_INSTANCE_URL, ARMIS_SECRET_KEY]):
         print('Error: Missing required environment variables')
         return
     
       try:
         bucket = storage_client.bucket(GCS_BUCKET)
     
         # Load state
         state = load_state(bucket, STATE_KEY)
     
         # Determine time window
         now = datetime.now(timezone.utc)
         last_time = None
     
         if isinstance(state, dict) and state.get("last_event_time"):
           try:
             last_time = parse_datetime(state["last_event_time"])
             # Overlap by 2 minutes to catch delayed events
             if last_time:
               last_time = last_time - timedelta(minutes=2)
           except Exception as e:
             print(f"Warning: Could not parse last_event_time: {e}")
     
         if last_time is None:
           last_time = now - timedelta(hours=LOOKBACK_HOURS)
     
         print(
           f"Fetching device logs from "
           f"{last_time.isoformat()} to {now.isoformat()}"
         )
     
         # Get access token
         access_token = get_access_token()
         print("Successfully obtained Armis access token.")
     
         # Fetch device records
         records, newest_event_time = fetch_device_logs(
           access_token=access_token,
           start_time=last_time,
           end_time=now,
         )
     
         if not records:
           print("No new device records found.")
           save_state(bucket, STATE_KEY, now.isoformat())
           return
     
         # Write to GCS as NDJSON
         timestamp = now.strftime('%Y%m%d_%H%M%S')
         object_key = f"{GCS_PREFIX}/logs_{timestamp}.ndjson"
         blob = bucket.blob(object_key)
     
         ndjson = '\n'.join(
           [json.dumps(record, ensure_ascii=False) for record in records]
         ) + '\n'
         blob.upload_from_string(
           ndjson, content_type='application/x-ndjson'
         )
     
         print(
           f"Wrote {len(records)} records to "
           f"gs://{GCS_BUCKET}/{object_key}"
         )
     
         # Update state
         if newest_event_time:
           save_state(bucket, STATE_KEY, newest_event_time)
         else:
           save_state(bucket, STATE_KEY, now.isoformat())
     
         print(f"Successfully processed {len(records)} records")
     
       except Exception as e:
         print(f'Error processing device logs: {str(e)}')
         raise
     
     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:
         print(f"Warning: Could not load state: {e}")
       return {}
     
     def save_state(bucket, key, last_event_time_iso):
       """Save the last event timestamp to GCS state file."""
       try:
         state = {'last_event_time': last_event_time_iso}
         blob = bucket.blob(key)
         blob.upload_from_string(
           json.dumps(state, indent=2),
           content_type='application/json'
         )
         print(f"Saved state: last_event_time={last_event_time_iso}")
       except Exception as e:
         print(f"Warning: Could not save state: {e}")
     
     def fetch_device_logs(access_token, start_time, end_time):
       """
       Fetch device inventory logs from Armis REST API with pagination.
     
       Args:
         access_token: Armis API access token
         start_time: Start time for log query
         end_time: End time for log query
     
       Returns:
         Tuple of (records list, newest_event_time ISO string)
       """
       base_url = f"{ARMIS_INSTANCE_URL}/api/v1/search/"
       headers = {'Authorization': access_token}
     
       # Build AQL query with time filter
       start_str = start_time.strftime('%Y-%m-%dT%H:%M:%S')
       aql_query = f'in:devices after:{start_str}'
     
       records = []
       newest_time = None
       page_from = 0
       backoff = 1.0
     
       while True:
         if len(records) >= MAX_RECORDS:
           print(f"Reached max_records limit ({MAX_RECORDS})")
           break
     
         params = {
           'aql': aql_query,
           'from': str(page_from),
           'orderBy': 'lastSeen',
           'length': str(PAGE_SIZE),
           'fields': ','.join(DEVICE_FIELDS),
         }
     
         try:
           response = http.request(
             'GET', base_url,
             fields=params,
             headers=headers
           )
     
           # Handle rate limiting with exponential backoff
           if response.status == 429:
             retry_after = int(
               response.headers.get(
                 'Retry-After', str(int(backoff))
               )
             )
             print(
               f"Rate limited (429). "
               f"Retrying after {retry_after}s..."
             )
             time.sleep(retry_after)
             backoff = min(backoff * 2, 30.0)
             continue
     
           # Handle token expiry
           if response.status == 401:
             print("Access token expired, refreshing...")
             access_token = get_access_token()
             headers = {'Authorization': access_token}
             continue
     
           backoff = 1.0
     
           if response.status != 200:
             print(f"HTTP Error: {response.status}")
             response_text = response.data.decode('utf-8')
             print(f"Response body: {response_text}")
             return records, newest_time
     
           data = json.loads(response.data.decode('utf-8'))
           result = data.get('data', {}).get('results', [])
           total = data.get('data', {}).get('total', 0)
           count = data.get('data', {}).get('count', 0)
           next_from = data.get('data', {}).get('next')
     
           if not result:
             print(f"No more results (empty page)")
             break
     
           print(
             f"Page from={page_from}: Retrieved {count} devices "
             f"(total: {total})"
           )
           records.extend(result)
     
           # Track newest event time using lastSeen
           for device in result:
             try:
               event_time = device.get('lastSeen')
               if event_time:
                 if newest_time is None:
                   newest_time = event_time
                 else:
                   current_dt = parse_datetime(event_time)
                   newest_dt = parse_datetime(newest_time)
                   if (
                     current_dt and newest_dt
                     and current_dt > newest_dt
                   ):
                     newest_time = event_time
             except Exception as e:
               print(
                 f"Warning: Could not parse "
                 f"event time: {e}"
               )
     
           # Check pagination
           if next_from is None or count < PAGE_SIZE:
             print("Reached last page")
             break
     
           page_from = next_from
     
         except Exception as e:
           print(f"Error fetching device logs: {e}")
           return records, newest_time
     
       print(f"Retrieved {len(records)} total device records")
       return records, newest_time
     

     Catatan: Skrip ini disediakan sebagai contoh dan tidak didukung secara resmi. Kami menerima masukan tentang cara meningkatkan kualitasnya. Untuk mengirimkan masukan, klik Kirim Masukan > Masukan Produk Keamanan Google SecOps di halaman ini.

   • 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).

   Catatan: Armis API menggunakan endpoint /search/ dengan sintaksis ASQ (Armis Standard Query). Kueri in:devices menargetkan data inventaris perangkat secara khusus. Filter after: digunakan untuk pengumpulan data inkremental berdasarkan stempel waktu lastSeen. API menampilkan hasil yang diberi nomor halaman menggunakan parameter from dan length, dengan kursor next dalam respons.

Buat tugas Cloud Scheduler

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

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

3. Berikan detail konfigurasi berikut:

   Setelan	Nilai
   Nama	armis-devices-collector-daily
   Region	Pilih region yang sama dengan fungsi Cloud Run
   Frekuensi	0 2 * * * (setiap hari pukul 02.00)
   Zona Waktu	Pilih zona waktu (UTC direkomendasikan)
   Jenis target	Pub/Sub
   Topik	Pilih topik armis-devices-trigger
   Isi pesan	{} (objek JSON kosong)

4. Klik Create.

Opsi frekuensi jadwal

Pilih frekuensi berdasarkan tingkat pembaruan inventaris perangkat dan persyaratan latensi:

Frekuensi	Ekspresi Cron	Kasus Penggunaan
Setiap 6 jam	0 */6 * * *	Pembaruan inventaris rutin
Harian	0 2 * * *	Standar (direkomendasikan)
Setiap 12 jam	0 */12 * * *	Lingkungan dengan volume lebih rendah

Catatan: Data inventaris perangkat lebih jarang berubah dibandingkan data aktivitas atau pemberitahuan. Jadwal harian atau dua kali sehari biasanya cukup untuk sebagian besar lingkungan. Interval polling dan frekuensi penjadwal harus sama. Jika interval polling lebih besar dari waktu penjadwal, kehilangan data dapat terjadi. Jika interval polling kurang dari waktu penjadwal, duplikasi data dapat terjadi. Armis API mendukung jangka waktu maksimum 100 hari.

Menguji integrasi

1. Di konsol Cloud Scheduler, temukan tugas Anda.
2. Klik Force run untuk memicu tugas secara manual.
3. Tunggu beberapa detik.
4. Buka Cloud Run > Services.
5. Klik nama fungsi armis-devices-collector.
6. Klik tab Logs.

7. Pastikan fungsi berhasil dieksekusi. Cari:

   Fetching device logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
   Successfully obtained Armis access token.
   Page from=0: Retrieved X devices (total: Y)
   Wrote X records to gs://armis-device-logs/armis-devices/logs_YYYYMMDD_HHMMSS.ndjson
   Successfully processed X records
   

8. Buka Cloud Storage > Buckets.

9. Klik nama bucket Anda.

10. Buka folder awalan armis-devices/.

11. Pastikan file .ndjson baru telah dibuat dengan stempel waktu saat ini.

Jika Anda melihat error di log:

• HTTP 400: Pastikan sintaksis kueri AQL sudah benar. Pastikan URL instance Armis tidak memiliki garis miring di akhir.
• HTTP 401: Token akses sudah tidak berlaku atau tidak valid. Fungsi ini otomatis memperbarui token saat terjadi error 401.
• HTTP 429: Pembatasan kapasitas - fungsi akan otomatis mencoba lagi dengan backoff.
• "Token akses tidak ditemukan": Pastikan kunci rahasia Armis API sudah benar.
• Variabel lingkungan tidak ada: Pastikan semua variabel yang diperlukan telah ditetapkan.

Mengonfigurasi feed di Google SecOps untuk menyerap log perangkat Armis

1. Buka Setelan > Pengelolaan Data > Feed. Jika Anda menggunakan platform khusus SIEM, buka Settings > Feeds.
2. Klik Tambahkan Feed Berita Baru.
3. Klik Konfigurasi satu feed.
4. Di kolom Nama feed, masukkan nama untuk feed (misalnya, Armis Devices).
5. Pilih Google Cloud Storage V2 sebagai Source type.
6. Pilih Armis Devices sebagai Log type.

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

   [e-mail]
   

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

   Catatan: Setiap instance Google SecOps memiliki akun layanan yang unik. Jangan gunakan akun layanan dari dokumentasi atau contoh lain.

9. Klik Berikutnya.

10. Tentukan nilai untuk parameter input berikut:

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

      gs://armis-device-logs/armis-devices/
      

      • Ganti:
        • armis-device-logs: Nama bucket GCS Anda.
        • armis-devices: Jalur awalan/folder opsional tempat log disimpan (biarkan kosong untuk root).
    Catatan: Selalu sertakan garis miring (/) di akhir URI.

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

      • Never: Tidak pernah menghapus file apa pun setelah transfer (direkomendasikan untuk pengujian).
      • Delete transferred files: Menghapus file setelah transfer berhasil.
      • Delete transferred files and empty directories: Menghapus file dan direktori kosong setelah transfer berhasil.
      Catatan: Jika Anda memilih opsi penghapusan, akun layanan harus memiliki peran Storage Object Admin, bukan Storage Object Viewer. Perbarui izin IAM sebagaimana mestinya.

    • Usia File Maksimum: Sertakan file yang diubah dalam jumlah hari terakhir (defaultnya adalah 180 hari)

    • Namespace aset: Namespace aset

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

11. Klik Berikutnya.

12. Tinjau konfigurasi feed berita baru Anda di layar Finalize, lalu klik Submit.

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
   • Assign roles: Pilih Storage Object Viewer

6. Klik Simpan.

   Catatan: Jika Anda berencana menggunakan opsi penghapusan "Hapus file yang ditransfer" atau "Hapus file yang ditransfer dan direktori kosong", berikan peran Storage Object Admin, bukan Storage Object Viewer.

Tabel pemetaan UDM

Kolom Log	Pemetaan UDM	Logika
datasource.firstSeen	metadata.event_timestamp	Diurai sebagai yyyy-MM-ddTHH:mm:ssZZ
datasource.lastSeen	metadata.event_timestamp	Diurai sebagai yyyy-MM-ddTHH:mm:ssZZ
firstSeen	metadata.event_timestamp	Diurai sebagai yyyy-MM-ddTHH:mm:ssZZ
lastSeen	metadata.event_timestamp	Diurai sebagai yyyy-MM-ddTHH:mm:ssZZ
time	metadata.event_timestamp	Diurai sebagai yyyy-MM-ddTHH:mm:ss.SSSZZ
id	metadata.product_entity_id	Dipetakan secara langsung
relation	relations	Diganti namanya/dipetakan
T/A	metadata.entity_type	Konstanta: ASSET
T/A	metadata.product_name	Konstanta: ARMIS
T/A	metadata.vendor_name	Konstanta: ARMIS

Log Perubahan

Melihat Log Perubahan untuk parser ini

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