Mengumpulkan log audit Harness IO

Didukung di:

Google SecOps SIEM

Dokumen ini menjelaskan cara menyerap log audit Harness IO ke Google Security Operations menggunakan Google Cloud Storage. Harness adalah platform continuous delivery dan DevOps yang menyediakan alat untuk pengiriman software, tanda fitur, pengelolaan biaya cloud, dan pengujian keamanan.

Sebelum memulai

Pastikan Anda memiliki prasyarat berikut:

Instance Google SecOps
Project GCP dengan Cloud Storage API 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 Harness dengan izin untuk:
- Membuat kunci API
- Mengakses log audit
- Lihat setelan akun

Kumpulkan kredensial Harness API

Membuat kunci API di Harness

Login ke Harness Platform.
Klik Profil Pengguna Anda.
Buka Kunci API Saya.
Klik + API Key.
Berikan detail konfigurasi berikut:
- Name: Masukkan nama deskriptif (misalnya, Google SecOps Integration).
- Deskripsi: Deskripsi opsional.
Klik Simpan.
Klik + Token untuk membuat token baru.
Berikan detail konfigurasi berikut:
- Nama: Masukkan Chronicle Feed Token.
- Setel Masa Aktif: Pilih waktu habis masa berlaku yang sesuai atau Tidak Ada Masa Aktif (untuk penggunaan produksi).
Klik Generate Token.
Salin dan simpan nilai token dengan aman. Token ini akan digunakan sebagai nilai header x-api-key.

Catatan: Token hanya ditampilkan satu kali. Jika Anda kehilangannya, Anda harus membuat token baru.
Catatan: Token API harus memiliki izin core_audit_view untuk mengakses log audit. Izin ini biasanya diberikan melalui penetapan peran di Harness.

Mendapatkan ID Akun Harness

Di Harness Platform, catat Account ID dari URL.

Contoh URL: https://app.harness.io/ng/account/YOUR_ACCOUNT_ID/.... Bagian YOUR_ACCOUNT_ID adalah ID Akun Anda.

Atau, buka Setelan Akun > Ringkasan untuk melihat ID Akun Anda.

Salin dan simpan ID Akun untuk digunakan di fungsi Cloud Run.

Catatan: ID Akun diperlukan untuk semua permintaan API ke Harness.

Membuat bucket Google Cloud Storage

Buka Google Cloud Console.
Pilih project Anda atau buat project baru.
Di menu navigasi, buka Cloud Storage > Buckets.
Klik Create bucket.

Berikan detail konfigurasi berikut:

Setelan	Nilai
Beri nama bucket Anda	Masukkan nama yang unik secara global (misalnya, `harness-io-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

Klik Buat.

Buat akun layanan untuk Cloud Run Function

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

Membuat akun layanan

Di GCP Console, buka IAM & Admin > Service Accounts.
Klik Create Service Account.
Berikan detail konfigurasi berikut:
- Nama akun layanan: Masukkan harness-audit-collector-sa.
- Deskripsi akun layanan: Masukkan Service account for Cloud Run function to collect Harness IO audit logs.
Klik Create and Continue.
Di bagian Berikan akun layanan ini akses ke 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.
Klik Lanjutkan.
Klik Selesai.

Peran ini diperlukan untuk:

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

Memberikan izin IAM pada bucket GCS

Beri akun layanan izin tulis di bucket GCS:

Buka Cloud Storage > Buckets.
Klik nama bucket Anda.
Buka tab Izin.
Klik Grant access.
Berikan detail konfigurasi berikut:
- Tambahkan prinsipal: Masukkan email akun layanan (misalnya, harness-audit-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
- Tetapkan peran: Pilih Storage Object Admin.
Klik Simpan.

Membuat topik Pub/Sub

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

Di GCP Console, buka Pub/Sub > Topics.
Klik Create topic.
Berikan detail konfigurasi berikut:
- ID Topik: Masukkan harness-audit-trigger.
- Biarkan setelan lainnya tetap default.
Klik Buat.

Membuat fungsi Cloud Run untuk mengumpulkan log

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

Di GCP Console, buka Cloud Run.
Klik Create service.
Pilih Function (gunakan editor inline untuk membuat fungsi).
Di bagian Konfigurasi, berikan detail konfigurasi berikut:

Setelan Nilai

Nama layanan harness-audit-collector

Wilayah Pilih region yang cocok dengan bucket GCS Anda (misalnya, us-central1)

Runtime Pilih Python 3.12 atau yang lebih baru
Di bagian Pemicu (opsional):
1. Klik + Tambahkan pemicu.
2. Pilih Cloud Pub/Sub.
3. Di Select a Cloud Pub/Sub topic, pilih topik Pub/Sub (harness-audit-trigger).
4. Klik Simpan.
Di bagian Authentication:
1. Pilih Wajibkan autentikasi.
2. Periksa Identity and Access Management (IAM).
Catatan: Pub/Sub secara otomatis menangani autentikasi saat memanggil fungsi.
Scroll ke bawah dan luaskan Containers, Networking, Security.
Buka tab Security:
- Akun layanan: Pilih akun layanan (harness-audit-collector-sa).

Setelan	Nilai
Nama layanan	`harness-audit-collector`
Wilayah	Pilih region yang cocok dengan bucket GCS Anda (misalnya, `us-central1`)
Runtime	Pilih Python 3.12 atau yang lebih baru

Buka tab Containers:

Klik Variables & Secrets.
Klik + Tambahkan variabel untuk setiap variabel lingkungan:

Nama Variabel	Nilai Contoh	Deskripsi
`HARNESS_ACCOUNT_ID`	ID Akun Harness Anda	ID akun dari Harness
`HARNESS_API_KEY`	Token kunci API Anda	Token dengan izin audit:read
`GCS_BUCKET`	`harness-io-logs`	Nama bucket GCS
`GCS_PREFIX`	`harness/audit`	Awalan untuk objek GCS
`STATE_KEY`	`harness/audit/state.json`	Jalur file status di GCS

Variabel lingkungan opsional:

Nama Variabel	Nilai Default	Deskripsi
`HARNESS_API_BASE`	`https://app.harness.io`	URL dasar Harness API (penggantian untuk instance yang dihosting sendiri)
`PAGE_SIZE`	`50`	Peristiwa per halaman (maks. 100)
`START_MINUTES_BACK`	`60`	Periode lihat kembali awal dalam menit
`FILTER_MODULES`	Tidak ada	Modul yang dipisahkan koma (misalnya, `CD,CI,CE`)
`FILTER_ACTIONS`	Tidak ada	Tindakan yang dipisahkan koma (misalnya, `CREATE,UPDATE,DELETE`)
`STATIC_FILTER`	Tidak ada	Filter standar: `EXCLUDE_LOGIN_EVENTS` atau `EXCLUDE_SYSTEM_EVENTS`
`MAX_RETRIES`	`3`	Upaya percobaan ulang maksimum untuk pembatasan kapasitas

Scroll ke bawah di tab Variables & Secrets ke Requests:
- Waktu tunggu permintaan: Masukkan 600 detik (10 menit).
Buka tab Setelan di Penampung:
- Di bagian Materi:
  - Memori: Pilih 512 MiB atau yang lebih tinggi.
  - CPU: Pilih 1.
- Klik Selesai.
Scroll ke Lingkungan eksekusi:
- Pilih Default (direkomendasikan).
Di bagian Penskalaan revisi:
- Jumlah minimum instance: Masukkan 0.
- Jumlah maksimum instance: Masukkan 100 (atau sesuaikan berdasarkan perkiraan beban).
Klik Buat.
Tunggu hingga layanan dibuat (1-2 menit).
Setelah layanan dibuat, editor kode inline akan terbuka secara otomatis.

Menambahkan kode fungsi

Masukkan main di Function entry point

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, timedelta, timezone
import time

# Initialize HTTP client
http = urllib3.PoolManager()

# Initialize Storage client
storage_client = storage.Client()

# Configuration from Environment Variables
API_BASE = os.environ.get("HARNESS_API_BASE", "https://app.harness.io").rstrip("/")
ACCOUNT_ID = os.environ["HARNESS_ACCOUNT_ID"]
API_KEY = os.environ["HARNESS_API_KEY"]
BUCKET = os.environ["GCS_BUCKET"]
PREFIX = os.environ.get("GCS_PREFIX", "harness/audit").strip("/")
STATE_KEY = os.environ.get("STATE_KEY", "harness/audit/state.json")
PAGE_SIZE = min(int(os.environ.get("PAGE_SIZE", "50")), 100)
START_MINUTES_BACK = int(os.environ.get("START_MINUTES_BACK", "60"))

# Optional filters
FILTER_MODULES = os.environ.get("FILTER_MODULES", "").split(",") if os.environ.get("FILTER_MODULES") else None
FILTER_ACTIONS = os.environ.get("FILTER_ACTIONS", "").split(",") if os.environ.get("FILTER_ACTIONS") else None
STATIC_FILTER = os.environ.get("STATIC_FILTER")
MAX_RETRIES = int(os.environ.get("MAX_RETRIES", "3"))

# HTTP headers for Harness API
HDRS = {
    "x-api-key": API_KEY,
    "Content-Type": "application/json",
    "Accept": "application/json",
}

def read_state(bucket):
    """Read checkpoint state from GCS."""
    try:
        blob = bucket.blob(STATE_KEY)
        if blob.exists():
            state_data = blob.download_as_text()
            state = json.loads(state_data)
            since_ms = state.get("since")
            page_token = state.get("pageToken")
            print(f"State loaded: since={since_ms}, pageToken={page_token}")
            return since_ms, page_token
    except Exception as e:
        print(f"Warning: Could not load state: {e}")

    print("No state file found, starting fresh collection")
    start_time = datetime.now(timezone.utc) - timedelta(minutes=START_MINUTES_BACK)
    since_ms = int(start_time.timestamp() * 1000)
    print(f"Initial since timestamp: {since_ms} ({start_time.isoformat()})")
    return since_ms, None

def write_state(bucket, since_ms, page_token=None):
    """Write checkpoint state to GCS."""
    state = {
        "since": since_ms,
        "pageToken": page_token,
        "lastRun": int(time.time() * 1000),
        "lastRunISO": datetime.now(timezone.utc).isoformat()
    }
    try:
        blob = bucket.blob(STATE_KEY)
        blob.upload_from_string(
            json.dumps(state, indent=2),
            content_type="application/json"
        )
        print(f"State saved: since={since_ms}, pageToken={page_token}")
    except Exception as e:
        print(f"Error writing state: {e}")
        raise

def fetch_harness_audits(since_ms, page_token=None, retry_count=0):
    """
    Fetch audit logs from Harness API with retry logic.
    API Endpoint: POST /audit/api/audits/listV2
    """
    try:
        # Build URL with query parameters
        url = (
            f"{API_BASE}/audit/api/audits/listV2"
            f"?accountIdentifier={ACCOUNT_ID}"
            f"&pageSize={PAGE_SIZE}"
        )
        if page_token:
            url += f"&pageToken={page_token}"

        print(f"Fetching from: {url[:100]}...")

        # Build request body with time filter and optional filters
        body_data = {
            "startTime": since_ms,
            "endTime": int(time.time() * 1000),
            "filterType": "Audit"
        }

        if FILTER_MODULES:
            body_data["modules"] = [m.strip() for m in FILTER_MODULES if m.strip()]
            print(f"Applying module filter: {body_data['modules']}")

        if FILTER_ACTIONS:
            body_data["actions"] = [a.strip() for a in FILTER_ACTIONS if a.strip()]
            print(f"Applying action filter: {body_data['actions']}")

        if STATIC_FILTER:
            body_data["staticFilter"] = STATIC_FILTER
            print(f"Applying static filter: {STATIC_FILTER}")

        # Make POST request
        response = http.request(
            'POST',
            url,
            body=json.dumps(body_data).encode('utf-8'),
            headers=HDRS,
            timeout=30.0
        )

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

        if "status" not in resp_data:
            print(f"Response missing 'status' field: {response.data[:200]}")

        # Check response status
        if resp_data.get("status") != "SUCCESS":
            error_msg = resp_data.get("message", "Unknown error")
            raise Exception(f"API returned status: {resp_data.get('status')} - {error_msg}")

        # Extract data from response structure
        data_obj = resp_data.get("data", {})
        if not data_obj:
            print("Response 'data' object is empty or missing")

        events = data_obj.get("content", [])
        has_next = data_obj.get("hasNext", False)
        next_token = data_obj.get("pageToken")

        print(f"API response: {len(events)} events, hasNext={has_next}, pageToken={next_token}")

        if not events and data_obj:
            print(f"Empty events but data present. Data keys: {list(data_obj.keys())}")

        return {
            "events": events,
            "hasNext": has_next,
            "pageToken": next_token
        }

    except Exception as e:
        if hasattr(e, 'status') and e.status == 429:
            retry_after = 60
            print(f"Rate limit exceeded. Retry after {retry_after} seconds (attempt {retry_count + 1}/{MAX_RETRIES})")
            if retry_count < MAX_RETRIES:
                print(f"Waiting {retry_after} seconds before retry...")
                time.sleep(retry_after)
                print(f"Retrying request (attempt {retry_count + 2}/{MAX_RETRIES})")
                return fetch_harness_audits(since_ms, page_token, retry_count + 1)
            else:
                raise Exception(f"Max retries ({MAX_RETRIES}) exceeded for rate limiting")
        print(f"Error in fetch_harness_audits: {e}")
        raise

def upload_to_gcs(bucket, events):
    """Upload audit events to GCS in JSONL format."""
    if not events:
        print("No events to upload")
        return None

    try:
        # Create JSONL content (one JSON object per line)
        jsonl_lines = [json.dumps(event) for event in events]
        jsonl_content = "\n".join(jsonl_lines)

        # Generate GCS key with timestamp
        timestamp = datetime.now(timezone.utc)
        key = (
            f"{PREFIX}/"
            f"{timestamp:%Y/%m/%d}/"
            f"harness-audit-{timestamp:%Y%m%d-%H%M%S}.jsonl"
        )

        # Upload to GCS
        blob = bucket.blob(key)
        blob.upload_from_string(
            jsonl_content,
            content_type="application/x-ndjson"
        )
        blob.metadata = {
            "event-count": str(len(events)),
            "source": "harness-audit-function",
            "collection-time": timestamp.isoformat()
        }
        blob.patch()

        print(f"Uploaded {len(events)} events to gs://{BUCKET}/{key}")
        return key

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

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

    Args:
        cloud_event: CloudEvent object containing Pub/Sub message
    """
    print("=== Harness Audit Collection Started ===")
    print(f"Configuration: API_BASE={API_BASE}, ACCOUNT_ID={ACCOUNT_ID[:8]}..., PAGE_SIZE={PAGE_SIZE}")

    if FILTER_MODULES:
        print(f"Module filter enabled: {FILTER_MODULES}")
    if FILTER_ACTIONS:
        print(f"Action filter enabled: {FILTER_ACTIONS}")
    if STATIC_FILTER:
        print(f"Static filter enabled: {STATIC_FILTER}")

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

        # Step 1: Read checkpoint state
        since_ms, page_token = read_state(bucket)

        if page_token:
            print("Resuming pagination from saved pageToken")
        else:
            since_dt = datetime.fromtimestamp(since_ms / 1000, tz=timezone.utc)
            print(f"Starting new collection from: {since_dt.isoformat()}")

        # Step 2: Collect all events with pagination
        all_events = []
        current_page_token = page_token
        page_count = 0
        max_pages = 100
        has_next = True

        while has_next and page_count < max_pages:
            page_count += 1
            print(f"--- Fetching page {page_count} ---")

            # Fetch one page of results
            result = fetch_harness_audits(since_ms, current_page_token)

            # Extract events
            events = result.get("events", [])
            all_events.extend(events)
            print(f"Page {page_count}: {len(events)} events (total: {len(all_events)})")

            # Check pagination status
            has_next = result.get("hasNext", False)
            current_page_token = result.get("pageToken")

            if not has_next:
                print("Pagination complete (hasNext=False)")
                break

            if not current_page_token:
                print("hasNext=True but no pageToken, stopping pagination")
                break

            # Small delay between pages to avoid rate limiting
            time.sleep(0.5)

        if page_count >= max_pages:
            print(f"Reached max pages limit ({max_pages}), stopping")

        # Step 3: Upload collected events to GCS
        if all_events:
            gcs_key = upload_to_gcs(bucket, all_events)
            print(f"Successfully uploaded {len(all_events)} total events")
        else:
            print("No new events to upload")
            gcs_key = None

        # Step 4: Update checkpoint state
        if not has_next:
            # Pagination complete - update since to current time for next run
            new_since = int(time.time() * 1000)
            write_state(bucket, new_since, None)
            print(f"Pagination complete, state updated with new since={new_since}")
        else:
            # Pagination incomplete - save pageToken for continuation
            write_state(bucket, since_ms, current_page_token)
            print("Pagination incomplete, saved pageToken for next run")

        # Step 5: Log result
        result = {
            "status": "Success",
            "eventsCollected": len(all_events),
            "pagesProcessed": page_count,
            "paginationComplete": not has_next,
            "gcsKey": gcs_key,
            "filters": {
                "modules": FILTER_MODULES,
                "actions": FILTER_ACTIONS,
                "staticFilter": STATIC_FILTER
            }
        }
        print(f"Collection completed: {json.dumps(result)}")

    except Exception as e:
        print(f"Collection failed: {e}")
        raise
    finally:
        print("=== Harness Audit Collection Finished ===")

File kedua: requirements.txt:

functions-framework==3.*
google-cloud-storage==2.*
urllib3>=2.0.0

Klik Deploy untuk menyimpan dan men-deploy fungsi.
Tunggu hingga deployment selesai (2-3 menit).

Catatan: Konfigurasi pemicu Pub/Sub akan otomatis membuat langganan dan izin yang diperlukan.

Buat tugas Cloud Scheduler

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

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

Berikan detail konfigurasi berikut:

Setelan	Nilai
Nama	`harness-audit-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 Pub/Sub (`harness-audit-trigger`)
Isi pesan	`{}` (objek JSON kosong)

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 integrasi

Di konsol Cloud Scheduler, temukan tugas Anda.
Klik Force run untuk memicu tugas secara manual.
Tunggu beberapa detik.
Buka Cloud Run > Services.
Klik nama fungsi Anda (harness-audit-collector).
Klik tab Logs.

Pastikan fungsi berhasil dieksekusi. Cari hal berikut:

=== Harness Audit Collection Started ===
State loaded: since=... or No state file found, starting fresh collection
--- Fetching page 1 ---
API response: X events, hasNext=...
Uploaded X events to gs://harness-io-logs/harness/audit/...
Successfully processed X records
=== Harness Audit Collection Finished ===

Buka Cloud Storage > Buckets.
Klik nama bucket Anda.
Buka folder awalan (harness/audit/).
Pastikan file .jsonl baru dibuat dengan stempel waktu saat ini.

Jika Anda melihat error dalam log:

HTTP 401: Periksa kredensial API di variabel lingkungan
HTTP 403: Pastikan akun memiliki izin yang diperlukan
HTTP 429: Pembatasan kecepatan - fungsi akan otomatis mencoba lagi dengan penundaan
Variabel lingkungan tidak ada: Periksa apakah semua variabel yang diperlukan telah ditetapkan

Catatan: Fungsi Cloud Run kini akan dijalankan secara otomatis setiap jam untuk mengumpulkan log audit baru.

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

Buka Setelan SIEM > Feed.
Klik Tambahkan Feed Baru.
Klik Konfigurasi satu feed.
Di kolom Nama feed, masukkan nama untuk feed (misalnya, Harness Audit Logs).
Pilih Google Cloud Storage V2 sebagai Source type.
Pilih Harness IO sebagai Log type.
Klik Get Service Account. Email akun layanan yang unik akan ditampilkan, misalnya:
```
chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com
```
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.

Memberikan izin IAM ke akun layanan Google SecOps

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

Buka Cloud Storage > Buckets.
Klik nama bucket Anda.
Buka tab Izin.
Klik Grant access.
Berikan detail konfigurasi berikut:
- Add principals: Tempel email akun layanan Google SecOps.
- Tetapkan peran: Pilih Storage Object Viewer.
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.

Mengonfigurasi feed di Google SecOps untuk menyerap log Harness IO

Buka Setelan SIEM > Feed.
Klik Tambahkan Feed Baru.
Klik Konfigurasi satu feed.
Di kolom Nama feed, masukkan nama untuk feed (misalnya, Harness Audit Logs).
Pilih Google Cloud Storage V2 sebagai Source type.
Pilih Harness IO sebagai Log type.
Klik Berikutnya.
Tentukan nilai untuk parameter input berikut:
- URL bucket penyimpanan: Masukkan URI bucket GCS dengan jalur awalan:
```
gs://harness-io-logs/harness/audit/
```
  - Ganti:
    - harness-io-logs: Nama bucket GCS Anda.
    - harness/audit: Jalur folder/awalan tempat log disimpan.
  - Contoh:
    - Bucket root: gs://company-logs/
    - Dengan awalan: gs://company-logs/harness-logs/
    - Dengan subfolder: gs://company-logs/harness/audit/
Catatan: Selalu sertakan garis miring (/) di akhir URI.
- 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.
    
    Catatan: Jika Anda memilih opsi penghapusan, akun layanan harus memiliki peran Storage Object Admin, bukan Storage Object Viewer. Perbarui izin IAM yang sesuai.
- Usia File Maksimum: Menyertakan file yang diubah dalam beberapa hari terakhir. Defaultnya adalah 180 hari.
- Namespace aset: Namespace aset. Masukkan harness.audit.
- Label penyerapan: Label yang akan diterapkan ke peristiwa dari feed ini.
Klik Berikutnya.
Tinjau konfigurasi feed baru Anda di layar Selesaikan, lalu klik Kirim.

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