Cisco CloudLock CASB のログを収集する

以下でサポートされています。

Google SecOps SIEM

このドキュメントでは、Google Cloud Storage を使用して Cisco CloudLock CASB ログを Google Security Operations に取り込む方法について説明します。パーサーは JSON ログからフィールドを抽出し、変換して統合データモデル（UDM）にマッピングします。日付の解析を処理し、特定のフィールドを文字列に変換し、フィールドを UDM エンティティ（メタデータ、ターゲット、セキュリティ結果、概要）にマッピングし、一致を反復処理して検出フィールドを抽出し、最終的に抽出されたすべてのデータを @output フィールドに統合します。

Cisco CloudLock は、クラウドアプリケーションの可視性と制御を提供するクラウドネイティブのクラウドアクセスセキュリティブローカー（CASB）です。組織は、シャドー IT の検出、データ損失防止ポリシーの適用、脅威の検出、SaaS アプリケーション全体でのコンプライアンスの維持に役立てることができます。

始める前に

次の前提条件を満たしていることを確認します。

Google SecOps インスタンス
Cloud Storage API が有効になっている GCP プロジェクト
GCS バケットを作成および管理する権限
GCS バケットの IAM ポリシーを管理する権限
Cloud Run サービス、Pub/Sub トピック、Cloud Scheduler ジョブを作成する権限
Cisco CloudLock 管理コンソールへの特権アクセス

Cisco CloudLock API の前提条件を取得する

開始するには、Cloudlock サポートに連絡して Cloudlock API URL を取得します。Cloudlock アプリケーションでアクセストークンを生成するには、[設定] ページの [認証と API] タブを選択して [生成] をクリックします。

Cisco CloudLock 管理コンソールにログインします。
[設定> 認証と API] に移動します。
[API] で [生成] をクリックして、アクセストークンを作成します。
次の詳細をコピーして安全な場所に保存します。
- API アクセストークン
- API ベース URL（Cisco CloudLock サポート（[email protected]）から提供）

Google Cloud Storage バケットを作成する

Google Cloud コンソールに移動します。
プロジェクトを選択するか、新しいプロジェクトを作成します。
ナビゲーションメニューで、[Cloud Storage > バケット] に移動します。
[バケットを作成] をクリックします。

次の構成情報を提供してください。

設定	値
バケットに名前を付ける	グローバルに一意の名前（`cisco-cloudlock-logs` など）を入力します。
ロケーションタイプ	ニーズに基づいて選択します（リージョン、デュアルリージョン、マルチリージョン）。
ロケーション	ロケーションを選択します（例: `us-central1`）。
ストレージクラス	Standard（頻繁にアクセスされるログにおすすめ）
アクセス制御	均一（推奨）
保護ツール	省略可: オブジェクトのバージョニングまたは保持ポリシーを有効にする

[作成] をクリックします。

Cloud Run functions のサービスアカウントを作成する

Cloud Run 関数には、GCS バケットに書き込む権限を持つサービスアカウントが必要です。

サービスアカウントの作成

GCP Console で、[IAM と管理>サービスアカウント] に移動します。
[サービスアカウントを作成] をクリックします。
次の構成の詳細を指定します。
- サービスアカウント名: 「cloudlock-data-export-sa」と入力します。
- サービスアカウントの説明: 「Service account for Cloud Run function to collect Cisco CloudLock logs」と入力します。
[作成して続行] をクリックします。
[このサービスアカウントにプロジェクトへのアクセスを許可する] セクションで、次の操作を行います。
1. [ロールを選択] をクリックします。
2. [ストレージオブジェクト管理者] を検索して選択します。
3. [+ 別のロールを追加] をクリックします。
4. [Cloud Run 起動元] を検索して選択します。
5. [+ 別のロールを追加] をクリックします。
6. [Cloud Functions 起動元] を検索して選択します。
[続行] をクリックします。
[完了] をクリックします。

GCS バケットに対する IAM 権限を付与する

GCS バケットに対する書き込み権限をサービスアカウントに付与します。

[Cloud Storage] > [バケット] に移動します。
バケット名をクリックします。
[権限] タブに移動します。
[アクセス権を付与] をクリックします。
次の構成の詳細を指定します。
- プリンシパルを追加: サービスアカウントのメールアドレス（例: cloudlock-data-export-sa@PROJECT_ID.iam.gserviceaccount.com）を入力します。
- ロールを割り当てる: [Storage オブジェクト管理者] を選択します。
[保存] をクリックします。

Pub/Sub トピックの作成

Cloud Scheduler がパブリッシュし、Cloud Run functions がサブスクライブする Pub/Sub トピックを作成します。

GCP Console で、[Pub/Sub> トピック] に移動します。
[トピックを作成] をクリックします。
次の構成の詳細を指定します。
- トピック ID: 「cloudlock-data-export-trigger」と入力します。
- その他の設定はデフォルトのままにします。
[作成] をクリックします。

ログを収集する Cloud Run 関数を作成する

Cloud Run 関数は、Cloud Scheduler からの Pub/Sub メッセージによってトリガーされ、Cisco CloudLock API からログを取得して GCS に書き込みます。

GCP Console で、[Cloud Run] に移動します。
[サービスを作成] をクリックします。
[関数] を選択します（インラインエディタを使用して関数を作成します）。

[構成] セクションで、次の構成の詳細を指定します。

設定	値
サービス名	`cloudlock-data-export`
リージョン	GCS バケットと一致するリージョンを選択します（例: `us-central1`）。
ランタイム	[Python 3.12] 以降を選択します。

[トリガー（省略可）] セクションで、次の操作を行います。
- [+ トリガーを追加] をクリックします。
- [Cloud Pub/Sub] を選択します。
- [Cloud Pub/Sub トピックを選択してください] で、トピック（cloudlock-data-export-trigger）を選択します。
- [保存] をクリックします。
[認証] セクションで、次の操作を行います。
- [認証が必要] を選択します。
- Identity and Access Management（IAM）を確認します。
注: Pub/Sub は、関数を呼び出すときに認証を自動的に処理します。
[コンテナ、ネットワーキング、セキュリティ] までスクロールして開きます。
[セキュリティ] タブに移動します。
- サービスアカウント: サービスアカウントを選択します（cloudlock-data-export-sa）。

[コンテナ] タブに移動します。

[変数とシークレット] をクリックします。

環境変数ごとに [+ 変数を追加] をクリックします。

変数名	値の例
`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`

[変数とシークレット] タブで [リクエスト] まで下にスクロールします。
- リクエストのタイムアウト: 600 秒（10 分）を入力します。
[コンテナ] の [設定] タブに移動します。
- [リソース] セクションで次の操作を行います。
  - メモリ: 512 MiB 以上を選択します。
  - CPU: [1] を選択します。
- [完了] をクリックします。
[実行環境] までスクロールします。
- [デフォルト]（推奨）を選択します。
[リビジョンスケーリング] セクションで、次の操作を行います。
- [インスタンスの最小数] に「0」と入力します。
- インスタンスの最大数: 100 と入力します（または、予想される負荷に基づいて調整します）。
[作成] をクリックします。
サービスが作成されるまで待ちます（1 ～ 2 分）。
サービスが作成されると、インラインコードエディタが自動的に開きます。

関数コードを追加する

[関数のエントリポイント] に「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 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

2 つ目のファイル: requirements.txt:

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

[デプロイ] をクリックして、関数を保存してデプロイします。
デプロイが完了するまで待ちます（2 ～ 3 分）。

Cloud Scheduler ジョブの作成

Cloud Scheduler は、定期的に Pub/Sub トピックにメッセージをパブリッシュし、Cloud Run functions の関数をトリガーします。

GCP Console で、[Cloud Scheduler] に移動します。
[ジョブを作成] をクリックします。

次の構成情報を提供してください。

設定	値
名前	`cloudlock-data-export-hourly`
リージョン	Cloud Run functions と同じリージョンを選択する
周波数	`0 * * * *`（1 時間ごとに正時）
タイムゾーン	タイムゾーンを選択します（UTC を推奨）。
ターゲットタイプ	Pub/Sub
トピック	トピックを選択する（`cloudlock-data-export-trigger`）
メッセージ本文	`{}`（空の JSON オブジェクト）

[作成] をクリックします。

スケジュールの頻度のオプション

ログの量とレイテンシの要件に基づいて頻度を選択します。

頻度	CRON 式	ユースケース
5 分毎	`/5 * * *`	大容量、低レイテンシ
15 分ごと	`/15 * * *`	検索量が普通
1 時間ごと	`0 * * * *`	標準（推奨）
6 時間ごと	`0 /6 * *`	少量、バッチ処理
毎日	`0 0 * * *`	履歴データの収集

スケジューラジョブをテストする

Cloud Scheduler コンソールで、ジョブを見つけます。
[強制実行] をクリックして手動でトリガーします。
数秒待ってから、[Cloud Run] > [サービス] > [cloudlock-data-export] > [ログ] に移動します。
関数が正常に実行されたことを確認します。
GCS バケットをチェックして、ログが書き込まれたことを確認します。

Google SecOps サービスアカウントを取得する

Google SecOps は、一意のサービスアカウントを使用して GCS バケットからデータを読み取ります。このサービスアカウントにバケットへのアクセス権を付与する必要があります。

サービスアカウントのメールアドレスを取得する

[SIEM 設定] > [フィード] に移動します。
[Add New Feed] をクリックします。
[単一フィードを設定] をクリックします。
[フィード名] フィールドに、フィードの名前を入力します（例: Cisco CloudLock logs）。
[ソースタイプ] として [Google Cloud Storage V2] を選択します。
[Log type] として [Cisco CloudLock] を選択します。
[サービスアカウントを取得する] をクリックします。一意のサービスアカウントメールアドレスが表示されます（例:）。
```
chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com
```
このメールアドレスをコピーして、次のステップで使用します。

Google SecOps サービスアカウントに IAM 権限を付与する

Google SecOps サービスアカウントには、GCS バケットに対する Storage オブジェクト閲覧者ロールが必要です。

[Cloud Storage] > [バケット] に移動します。
バケット名をクリックします。
[権限] タブに移動します。
[アクセス権を付与] をクリックします。
次の構成の詳細を指定します。
- プリンシパルを追加: Google SecOps サービスアカウントのメールアドレスを貼り付けます。
- ロールを割り当てる: [ストレージオブジェクト閲覧者] を選択します。
[保存] をクリックします。

Cisco CloudLock のログを取り込むように Google SecOps でフィードを構成する

[SIEM 設定] > [フィード] に移動します。
[Add New Feed] をクリックします。
[単一フィードを設定] をクリックします。
[フィード名] フィールドに、フィードの名前を入力します（例: Cisco CloudLock logs）。
[ソースタイプ] として [Google Cloud Storage V2] を選択します。
[Log type] として [Cisco CloudLock] を選択します。
[次へ] をクリックします。
次の入力パラメータの値を指定します。
- ストレージバケットの URL: 接頭辞パスを含む GCS バケット URI を入力します。
```
gs://cisco-cloudlock-logs/cloudlock/
```
  - 次のように置き換えます。
    - cisco-cloudlock-logs: GCS バケット名。
    - cloudlock/: ログが保存されるオプションの接頭辞/フォルダパス（ルートの場合は空のままにします）。
  - 例:
    - ルートバケット: gs://cisco-cloudlock-logs/
    - 接頭辞あり: gs://cisco-cloudlock-logs/cloudlock/
    - サブフォルダあり: gs://cisco-cloudlock-logs/cloudlock/incidents/
注: URI の末尾には常にスラッシュ（/）を付けてください。
- Source deletion option: 必要に応じて削除オプションを選択します。
  - なし: 転送後にファイルを削除しません（テストにおすすめ）。
  - 転送されたファイルを削除する: 転送が完了した後にファイルを削除します。
  - 転送されたファイルと空のディレクトリを削除する: 転送が完了した後にファイルと空のディレクトリを削除します。
    
    注: 削除オプションを選択する場合は、サービスアカウントに Storage オブジェクト閲覧者ではなく、Storage オブジェクト管理者のロールが必要です。必要に応じて IAM 権限を更新します。
- ファイルの最大経過日数: 指定した日数以内に変更されたファイルを含めます。デフォルトは 180 日です。
- アセットの名前空間: アセットの名前空間。
- Ingestion labels: このフィードのイベントに適用されるラベル。
[次へ] をクリックします。
[Finalize] 画面で新しいフィードの設定を確認し、[送信] をクリックします。

UDM マッピングテーブル

ログフィールド	UDM マッピング	論理
created_at	about.resource.attribute.labels.key	created_at フィールドの値が labels キーに割り当てられます。
created_at	about.resource.attribute.labels.value	created_at フィールドの値がラベルの値に割り当てられます。
created_at	about.resource.attribute.creation_time	created_at フィールドはタイムスタンプとして解析され、マッピングされます。
entity.id	target.asset.product_object_id	entity.id フィールドの名前が変更されました。
entity.ip	target.ip	entity.ip フィールドはターゲット IP フィールドに統合されます。
entity.mime_type	target.file.mime_type	entity.origin_type が「document」の場合、entity.mime_type フィールドの名前が変更されます。
entity.name	target.application	entity.origin_type が「app」の場合、entity.name フィールドの名前が変更されます。
entity.name	target.file.full_path	entity.origin_type が「document」の場合、entity.name フィールドの名前が変更されます。
entity.origin_id	target.resource.product_object_id	entity.origin_id フィールドの名前が変更されました。
entity.origin_type	target.resource.resource_subtype	entity.origin_type フィールドの名前が変更されました。
entity.owner_email	target.user.email_addresses	entity.owner_email フィールドがメールの正規表現と一致する場合、そのフィールドはターゲットユーザーのメールフィールドに統合されます。
entity.owner_email	target.user.user_display_name	entity.owner_email フィールドがメールの正規表現と一致しない場合、名前が変更されます。
entity.owner_name	target.user.user_display_name	entity.owner_email がメールの正規表現と一致する場合、entity.owner_name フィールドの名前が変更されます。
entity.vendor.name	target.platform_version	entity.vendor.name フィールドの名前が変更されました。
id	metadata.product_log_id	id フィールドの名前が変更されます。
incident_status	metadata.product_event_type	incident_status フィールドの名前が変更されます。
	metadata.event_timestamp	値は「updated_at」にハードコードされています。値は updated_at フィールドから取得されます。updated_at フィールドはタイムスタンプとして解析され、マッピングされます。
	security_result.detection_fields.key	重大度が「ALERT」で、incident_status が「NEW」の場合は「true」に設定します。ブール値に変換されます。
	security_result.detection_fields.value	重大度が「ALERT」で、incident_status が「NEW」の場合は「true」に設定します。ブール値に変換されます。
	metadata.event_type	値は「GENERIC_EVENT」にハードコードされています。
	metadata.product_name	値は「CISCO_CLOUDLOCK_CASB」にハードコードされています。
	metadata.vendor_name	値は「CloudLock」にハードコードされます。
	metadata.product_version	値は「Cisco」にハードコードされます。
	security_result.alert_state	重大度が「ALERT」で、incident_status が「RESOLVED」または「DISMISSED」でない場合は、「ALERTING」に設定します。重大度が「ALERT」で、incident_status が「RESOLVED」または「DISMISSED」の場合は、「NOT_ALERTING」に設定します。
	security_result.detection_fields.key	matches 配列（具体的には各 match オブジェクトのキー）から派生します。
	security_result.detection_fields.value	matches 配列（特に各 match オブジェクトの値）から派生します。
	security_result.rule_id	policy.id から取得されます。
	security_result.rule_name	policy.name から派生します。
	security_result.severity	重大度が「INFO」の場合は「INFORMATIONAL」に設定します。重大度が「CRITICAL」の場合は「CRITICAL」に設定します。重大度から派生します。
	security_result.summary	値は、「一致数: 」と match_count の値を連結した文字列に設定されます。
	target.resource.resource_type	entity.origin_type が「document」の場合は、「STORAGE_OBJECT」に設定します。
	target.url	entity.origin_type が「document」の場合、entity.direct_url から派生します。
policy.id	security_result.rule_id	policy.id フィールドの名前が変更されました。
policy.name	security_result.rule_name	policy.name フィールドの名前が変更されました。
重要度	security_result.severity_details	重大度フィールドの名前が変更されました。
updated_at	about.resource.attribute.labels.key	updated_at フィールドの値が labels キーに割り当てられます。
updated_at	about.resource.attribute.labels.value	updated_at フィールドの値がラベルの値に割り当てられます。
updated_at	about.resource.attribute.last_update_time	updated_at フィールドはタイムスタンプとして解析され、マッピングされます。

ご不明な点がございましたら、コミュニティメンバーや Google SecOps のプロフェッショナルから回答を得ることができます。