Cloud Data Loss Prevention（Cloud DLP）は機密データの保護の一部になりました。API 名は Cloud Data Loss Prevention API（DLP API）のままです。機密データの保護を構成するサービスについては、機密データの保護の概要をご覧ください。

このページは Cloud Translation API によって翻訳されました。

ハイブリッドジョブを使用して外部ソースのデータを検査する

このトピックでは、ハイブリッドジョブとハイブリッドジョブトリガーを使用して極秘データ用の外部データを検査する方法について説明します。ハイブリッドジョブとハイブリッドジョブトリガー（ハイブリッドな環境の例を含む）の詳細については、ハイブリッドジョブとハイブリッドジョブトリガーをご覧ください。

ハイブリッドジョブとハイブリッドジョブトリガーの概要

ハイブリッドジョブとハイブリッドジョブトリガーを使用すると、シンプルなコンテンツ検査リクエストや Google Cloud Storage リポジトリのスキャン以外にも、機密データの保護が提供する保護の範囲を広げることができます。ハイブリッドジョブとハイブリッドジョブトリガーを使用すると、Google Cloud の外部を含めた、ほぼすべてのソースからデータを機密データの保護に直接ストリーミングして、機密情報に関するデータを機密データの保護で検査できます。機密データの保護は自動的にスキャン結果を保存し、集計して詳細な分析を行います。

ハイブリッドジョブとハイブリッドジョブトリガーの比較

ハイブリッドジョブを作成すると、ユーザーが停止するまでジョブは動作します。データが適切に転送され、フォーマットされている限り、受信データをすべて受け入れます。

ハイブリッドジョブトリガーはハイブリッドジョブと同様に機能しますが、ハイブリッドジョブトリガー内でユーザーがジョブを明示的に停止する必要はありません。機密データの保護は、1 日の終わりにハイブリッドジョブトリガー内のジョブを自動的に停止します。

さらに、ハイブリッドジョブトリガーを使用すると、hybridInspect リクエストを再構成しなくても、トリガー内で新しいジョブの停止と壊死ができます。たとえば、ハイブリッドジョブトリガーにデータを送信してから、アクティブなジョブを停止し、構成を変更して、そのトリガー内で新しいジョブを開始した後、同じトリガーへのデータ送信を継続できます。

ユースケースに適したオプションのガイダンスについては、このページの一般的なハイブリッド検査シナリオをご覧ください。

用語の定義

このトピックでは、次の用語を使用します。

外部データ: Google Cloud の外部に保存されているデータ、または機密データの保護がネイティブではサポートしていないデータ。
ハイブリッドジョブ: ほぼすべてのソースからのデータをスキャンするように構成された検査ジョブ。
ハイブリッドジョブトリガー: ほぼすべてのソースからのデータをスキャンするように構成されたジョブトリガー。
hybridInspect リクエスト: 検査する外部データを含むリクエスト。このリクエストを送信するときに、リクエストを送信するハイブリッドジョブまたはハイブリッドジョブトリガーを指定します。

ジョブとジョブトリガーの一般的な情報については、ジョブとジョブトリガーをご覧ください。

ハイブリッド検査プロセス

ハイブリッド検査プロセスは 3 つのステップで行います。

機密データの保護に送信するデータを選択します。

データは、Google Cloud 内またはその外部で生成できます。たとえば、カスタムスクリプトまたはアプリケーションを構成して機密データの保護にデータを送信でき、別のクラウドサービス、オンプレミスのデータリポジトリ、または事実上あらゆるデータソースから転送中のデータが検査可能になります。
機密データの保護で、ハイブリッドジョブまたはハイブリッドジョブトリガーをゼロから、または検査テンプレートを使用して設定します。

ハイブリッドジョブまたはハイブリッドジョブトリガーを設定すると、機密データの保護は送信されたデータを能動的にリッスンします。カスタムスクリプトまたはカスタムアプリケーションでデータをこのハイブリッドジョブまたはハイブリッドジョブトリガーに送信すると、構成に従ってデータは検査され、その結果が保存されます。

ハイブリッドジョブまたはハイブリッドジョブトリガーを設定する際に、検出結果を保存または公開する場所を指定できます。オプションとしては、BigQuery への保存と、Pub/Sub、Cloud Monitoring、メールのいずれかへの通知の公開があります。
ハイブリッドジョブまたはハイブリッドジョブトリガーに hybridInspect リクエストを送信します。

hybridInspect リクエストには、スキャンされるデータが含まれます。リクエストには、コンテンツを説明するメタデータ（ラベルやテーブル ID とも呼ばれる）を含めて、追跡する情報を機密データの保護で識別できるようにします。たとえば、複数のリクエストで関連するデータ（同じデータベーステーブル内の行など）をスキャンする場合は、それらの関連するリクエストで同じメタデータを使用できます。そして、そのデータベーステーブルの検出結果を収集、集計、分析できます。

ハイブリッドジョブがリクエストを実行して検査すると、機密データの保護が検査結果を生成したときに検査結果を利用できます。一方、Pub/Sub 通知などのアクションは、アプリケーションがハイブリッドジョブを終了するまで起こりません。

考慮事項

ハイブリッドジョブとハイブリッドジョブトリガーを操作する場合は、次の点を考慮してください。

ハイブリッドジョブとハイブリッドジョブトリガーは、フィルタリングとサンプリングをサポートしていません。
ジョブとジョブトリガーはサービスレベル目標（SLO）の対象ではありませんが、レイテンシを短縮するために実施可能な手順があります。詳細については、ジョブのレイテンシをご覧ください。

始める前に

ハイブリッドジョブまたはハイブリッドジョブトリガーを設定して使用する前に、確実に次の作業を行ってください。

新しいプロジェクトの作成、課金の有効化、機密データの保護の有効化

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Sensitive Data Protection API.
Enable the API

データソースを構成する

機密データの保護でデータを検査するには、そのデータを機密データの保護に送信する必要があります。どのような方法でハイブリッドジョブまたはハイブリッドジョブトリガーを構成しても、外部ソースを設定して、DLP API にデータを送信する必要があります。

ハイブリッド検査リクエストに必要な形式については、ハイブリッドコンテンツアイテムのフォーマットをご覧ください。リクエストのデータに含めることができるメタデータの種類については、指定できるメタデータの種類をご覧ください。

ハイブリッドジョブまたはハイブリッドジョブトリガーを作成する

機密データの保護に送信したデータを機密データの保護で検査できるようにするには、まずハイブリッドジョブまたはハイブリッドジョブトリガーを設定する必要があります。どちらを作成するかについての詳細は、このページの一般的なハイブリッド検査シナリオをご覧ください。

Console

Google Cloud コンソールで、[ジョブまたはジョブトリガーの作成] ページに移動します。

[ジョブまたはジョブトリガーを作成] に移動

以下のセクションでは、ハイブリッド検査オペレーションに関連する [ジョブまたはジョブトリガーを作成] ページのセクションに入力する方法について説明します。

入力データを選択

このセクションでは、検査する機密データの保護の入力データを指定します。

省略可: [名前] で、[ジョブ ID] フィールドに値を入力して、ジョブに名前を付けます。このフィールドを空白のままにすると、機密データの保護によって識別子が自動生成されます。
省略可: [リソースロケーション] メニューから、ハイブリッドジョブまたはハイブリッドジョブトリガーを保存するリージョンを選択します。詳細については、処理を行うロケーションの指定をご覧ください。
[ストレージのタイプ] で、[ハイブリッド] を選択します。
省略可: [説明] に、作成するハイブリッドジョブまたはハイブリッドジョブトリガーの説明を入力します。たとえば、検査するデータのソースに関する情報を含めることができます。
省略可: [必要なラベル] で [ラベルを追加] をクリックし、hybridInspect リクエストから必要なラベルを入力します。このラベルが指定されていない hybridInspect リクエストは、このハイブリッドジョブまたはハイブリッドジョブトリガーによっては処理されません。最大 10 個まで必要なラベルを追加できます。詳細については、このページの hybridInspect リクエストのラベルを必要とするをご覧ください。
省略可: [任意ラベル] に、このジョブまたはジョブトリガーに送信されたすべての hybridInspect リクエストの結果に関連付ける Key-Value ペアを入力します。最大 10 個まで任意ラベルを追加できます。詳細については、任意ラベルをご覧ください。
省略可: hybridInspect リクエスト内で表形式のデータを送信する場合は、[表形式のデータオプション] で主キー列のフィールド名を入力します。詳しくは、表形式のデータのオプションをご覧ください。
[続行] をクリックします。

検出を構成する

このセクションでは、機密データの保護が入力データを検査する機密データの種類を指定します。次の設定を選択できます。

テンプレート: 現在のプロジェクトでテンプレートを作成済みで、機密データの保護の検出パラメータの定義にそれを使用する場合は、[テンプレート名] フィールドをクリックして、表示されたリストからテンプレートを選択します。
infoType: 機密データの保護は、検査で最も一般的な組み込みの infoType を選択します。infoType の変更や、使用するカスタム infoType の選択には、[infoType を管理] をクリックします。[検査ルールセット] と [信頼度のしきい値] で、検出基準を微調整することもできます。詳細については、検出の構成をご覧ください。

検出パラメータを設定したら、[続行] をクリックします。

アクションの追加

このセクションでは、各検査スキャンの検出結果を保存する場所を指定し、スキャンが完了したときにメールまたは Pub/Sub 通知メッセージのどちらで通知を行うかどうかを指定します。検出結果を BigQuery に保存しない場合、スキャン結果には検出結果の数と infoType に関する統計情報のみが含まれます。

BigQuery に保存: スキャンが実行されるたびに、機密データの保護によりここで指定した BigQuery テーブルにスキャンの検出結果が保存されます。テーブル ID を指定しなければ、スキャンの最初の実行時に BigQuery によってデフォルトの名前が新しいテーブルに割り当てられます。既存のテーブルを指定した場合、機密データの保護によりスキャンの検出結果がテーブルに追加されます。
Pub/Sub に公開: ジョブが完了すると、Pub/Sub メッセージが生成されます。

注: Pub/Sub トピックの構成または権限に問題がある場合、Sensitive Data Protection は Pub/Sub 通知の送信を最大 2 週間再試行します。2 週間が経過すると、通知は破棄されます。
メールで通知: ジョブが完了すると、メッセージがメールで送信されます。
Cloud Monitoring に公開: ジョブが完了すると、検出結果が Monitoring に公開されます。

アクションを選択したら、[続行] をクリックします。

スケジュール

このセクションでは、即座に実行される単一ジョブと、正しくルーティングされフォーマットされたデータが機密データの保護で受信されるたびに実行されるジョブトリガーのどちらを作成するかを指定します。

次のいずれかを行います。

ハイブリッドジョブをすぐに実行するには、[なし（作成時に 1 回限りのジョブを実行する）] を選択します。
ソースから受信したデータがジョブをトリガーするようにジョブを構成するには、[定期的にジョブを実行するトリガーを作成] を選択します。

ハイブリッドジョブトリガーは API 呼び出しを集約し、検出結果と傾向を時系列で確認できます。

詳細については、ハイブリッドジョブとハイブリッドジョブトリガーの比較をご覧ください。

まとめ

ここで、スキャンの JSON サマリーを確認できます。ハイブリッドジョブまたはハイブリッドジョブトリガーの名前を必ずメモしてください。この情報は、検査のために機密データの保護にデータを送信する際に必要になります。

JSON の概要を確認したら、[作成] をクリックします。

機密データの保護によって、ハイブリッドジョブまたはハイブリッドジョブトリガーが直ちに開始されます。このハイブリッドジョブまたはハイブリッドジョブトリガーに hybridInspect リクエストを送信すると、検査スキャンが開始されます。

API

ジョブは、DLP API で DlpJobs リソースによって表現されます。ハイブリッドジョブを作成するには、projects.locations.dlpJobs.create メソッドを呼び出します。

ジョブトリガーは、DLP API で JobTrigger リソースによって表現されます。ハイブリッドジョブトリガーを作成するには、projects.locations.jobTriggers.create メソッドを呼び出します。

作成する DlpJobs オブジェクトまたは JobTrigger オブジェクトには、次の設定が必要です。

inspectJob フィールドで、InspectJobConfig オブジェクトを設定します。
InspectJobConfig オブジェクトの storageConfig フィールドで、StorageConfig オブジェクトを設定します。
StorageConfig オブジェクトの hybridOptions フィールドで、HybridOptions オブジェクトを設定します。このオブジェクトには、検査するデータに関するメタデータが含まれています。
InspectJobConfig オブジェクトの actions フィールドに、機密データの保護に実行させるアクション（Action）を各ジョブの各末尾に追加します。

publishSummaryToCscc アクションと publishFindingsToCloudDataCatalog アクションは、このオペレーションではサポートされていません。アクションの詳細については、アクションをご覧ください。
次のいずれかまたは両方を行って、スキャンの対象とスキャン方法を指定します。
- inspectTemplateName フィールドを、使用する検査テンプレートの完全なリソース名にします（利用可能な場合）。
- inspectConfig フィールドを設定します。
inspectTemplateName フィールドと inspectConfig フィールドの両方を設定すると、設定が結合されます。

JSON の例について

次のタブには、機密データの保護に送信してハイブリッドジョブまたはハイブリッドジョブトリガーを作成できる JSON の例が含まれています。これらのハイブリッドジョブとハイブリッドジョブトリガーの例は、次のことを行うように構成されています。

リクエストにラベル appointment-bookings-comments が付いている場合は、hybridInspect リクエストを処理します。
メールアドレスについて、hybridInspect リクエストの内容をスキャンします。
"env": "prod" ラベルを検出結果に貼り付けます。
表形式のデータの場合は、機密データが見つかったセルと同じ行にある booking_id 列（主キー）のセル値を取得します。機密データの保護によりこの ID が検出結果に貼り付けられるため、検出結果をその元になる特定の行まで追跡できます。
ジョブの停止時にメールを送信します。メールは IAM プロジェクトオーナーと技術的な重要な連絡先の技術担当者に送信されます。
ジョブが停止したときに、検出結果を Cloud Monitoring に送信します。

JSON の例を表示するには、次のタブをご覧ください。

ハイブリッドジョブ

このタブには、ハイブリッドジョブの作成に使用できる JSON の例が含まれます。

ハイブリッドジョブを作成するには、次のエンドポイントに POST リクエストを送信します。

HTTP メソッドと URL

POST https://dlp.googleapis.com/v2/projects/PROJECT_ID/locations/REGION/dlpJobs

次のように置き換えます。

PROJECT_ID: ハイブリッドジョブを保存するプロジェクトの ID。
REGION: ハイブリッドジョブを保存する地理的なリージョン。

JSON 入力

{
  "jobId": "postgresql-table-comments",
  "inspectJob": {
    "actions": [
      {
        "jobNotificationEmails": {}
      },
      {
        "publishToStackdriver": {}
      }
    ],
    "inspectConfig": {
      "infoTypes": [
        {
          "name": "EMAIL_ADDRESS"
        }
      ],
      "minLikelihood": "POSSIBLE",
      "includeQuote": true
    },
    "storageConfig": {
      "hybridOptions": {
        "description": "Hybrid job for data from the comments field of a table that contains customer appointment bookings",
        "requiredFindingLabelKeys": [
          "appointment-bookings-comments"
        ],
        "labels": {
          "env": "prod"
        },
        "tableOptions": {
          "identifyingFields": [
            {
              "name": "booking_id"
            }
          ]
        }
      }
    }
  }
}

JSON 出力

{
"name": "projects/PROJECT_ID/locations/REGION/dlpJobs/i-postgresql-table-comments",
"type": "INSPECT_JOB",
"state": "ACTIVE",
"inspectDetails": {
  "requestedOptions": {
    "snapshotInspectTemplate": {},
    "jobConfig": {
      "storageConfig": {
        "hybridOptions": {
          "description": "Hybrid job for data from the comments field of a table that contains customer appointment bookings",
          "requiredFindingLabelKeys": [
            "appointment-bookings-comments"
          ],
          "labels": {
            "env": "prod"
          },
          "tableOptions": {
            "identifyingFields": [
              {
                "name": "booking_id"
              }
            ]
          }
        }
      },
      "inspectConfig": {
        "infoTypes": [
          {
            "name": "EMAIL_ADDRESS"
          }
        ],
        "minLikelihood": "POSSIBLE",
        "limits": {},
        "includeQuote": true
      },
      "actions": [
        {
          "jobNotificationEmails": {}
        },
        {
          "publishToStackdriver": {}
        }
      ]
    }
  },
  "result": {
    "hybridStats": {}
  }
},
"createTime": "JOB_CREATION_DATETIME",
"startTime": "JOB_START_DATETIME"
}

機密データの保護によってハイブリッドジョブが作成され、ジョブ ID が生成されます。この例では、ジョブ ID は i-postgresql-table-comments です。ジョブ ID をメモしておきます。これは hybridInspect リクエストで必要になります。

ハイブリッドジョブを停止するには、projects.locations.dlpJobs.finish メソッドを明示的に呼び出す必要があります。DLP API は、ハイブリッドジョブを自動的には停止しません。一方、DLP API は、1 日の終わりにハイブリッドジョブトリガー内のジョブを自動的に停止します。

ハイブリッドジョブトリガー

このタブには、ハイブリッドジョブトリガーの作成に使用できる JSON の例が含まれます。

ハイブリッドジョブトリガーを作成するには、次のエンドポイントに POST リクエストを送信します。

HTTP メソッドと URL

POST https://dlp.googleapis.com/v2/projects/PROJECT_ID/locations/REGION/jobTriggers

次のように置き換えます。

PROJECT_ID: ハイブリッドジョブトリガーを保存するプロジェクトの ID。
REGION: ハイブリッドジョブトリガーを保存する地理的なリージョン。

JSON 入力

{
    "triggerId": "postgresql-table-comments",
    "jobTrigger": {
      "triggers": [
        {
          "manual": {}
        }
      ],
      "inspectJob": {
        "actions": [
          {
            "jobNotificationEmails": {}
          },
          {
            "publishToStackdriver": {}
          }
        ],
        "inspectConfig": {
          "infoTypes": [
              {
                "name": "EMAIL_ADDRESS"
              }
          ],
          "minLikelihood": "POSSIBLE",
          "limits": {},
          "includeQuote": true
        },
        "storageConfig": {
          "hybridOptions": {
            "description": "Hybrid job trigger for data from the comments field of a table that contains customer appointment bookings",
            "requiredFindingLabelKeys": [
                "appointment-bookings-comments"
              ],
            "labels": {
              "env": "prod"
            },
            "tableOptions": {
              "identifyingFields": [
                {
                  "name": "booking_id"
                }
              ]
            }
          }
        }
      }
    }
  }

JSON 出力

{
"name": "projects/PROJECT_ID/locations/REGION/jobTriggers/postgresql-table-comments",
"inspectJob": {
  "storageConfig": {
    "hybridOptions": {
      "description": "Hybrid job trigger for data from the comments field of a table that contains customer appointment bookings",
      "requiredFindingLabelKeys": [
        "appointment-bookings-comments"
      ],
      "labels": {
        "env": "prod"
      },
      "tableOptions": {
        "identifyingFields": [
          {
            "name": "booking_id"
          }
        ]
      }
    }
  },
  "inspectConfig": {
    "infoTypes": [
      {
        "name": "EMAIL_ADDRESS"
      }
    ],
    "minLikelihood": "POSSIBLE",
    "limits": {},
    "includeQuote": true
  },
  "actions": [
    {
      "jobNotificationEmails": {}
    },
    {
      "publishToStackdriver": {}
    }
  ]
},
"triggers": [
  {
    "manual": {}
  }
],
"createTime": ""JOB_CREATION_DATETIME",
"updateTime": "TRIGGER_UPDATE_DATETIME",
"status": "HEALTHY"
}

機密データの保護により、ハイブリッドジョブトリガーが作成されます。出力には、ハイブリッドジョブトリガーの名前が含まれます。この例では、postgresql-table-comments です。名前をメモしておきます。これは hybridInspect リクエストで必要になります。

ハイブリッドジョブとは異なり、DLP API は、1 日の終わりにハイブリッドジョブトリガー内のジョブを自動的に停止します。したがって、projects.locations.dlpJobs.finish メソッドを明示的に呼び出す必要はありません。

ハイブリッドジョブまたはハイブリッドジョブトリガーを作成する場合は、次の API リファレンスページでそれぞれ API Explorer を使用できます。

[リクエストパラメータ] フィールドに「projects/PROJECT_ID/locations/REGION」と入力します。次に、[リクエスト本文] フィールドに、作成するオブジェクトのサンプル JSON を貼り付けます。

リクエストが API Explorer で作成した場合でも、成功したリクエストでは、ハイブリッドジョブまたはハイブリッドジョブトリガーが作成されます。

JSON を使用して DLP API にリクエストを送信する方法については、JSON クイックスタートをご覧ください。

ハイブリッドジョブまたはハイブリッドジョブトリガーにデータを送信する

データを検査するには、ハイブリッドジョブまたはハイブリッドジョブトリガーのいずれかに hybridInspect リクエストを正しい形式で送信する必要があります。

ハイブリッドコンテンツアイテムのフォーマット

ハイブリッドジョブまたはハイブリッドジョブトリガーで処理するために機密データの保護に送信される hybridInspect リクエストの簡単な例を次に示します。hybridItem フィールドを含む JSON オブジェクトの構造に注意してください。このフィールドには次のフィールドが含まれています。

item: 検査する実際のコンテンツが含まれます。
findingDetails: コンテンツに関連付けるメタデータが含まれます。

{
  "hybridItem": {
    "item": {
      "value": "My email is test@example.org"
    },
    "findingDetails": {
      "containerDetails": {
        "fullPath": "10.0.0.2:logs1:app1",
        "relativePath": "app1",
        "rootPath": "10.0.0.2:logs1",
        "type": "logging_sys",
        "version": "1.2"
      },
      "labels": {
        "env": "prod",
        "appointment-bookings-comments": ""
      }
    }
  }
}

ハイブリッド検査項目の内容について詳しくは、HybridContentItem オブジェクトの API リファレンスコンテンツをご覧ください。

ハイブリッド検査エンドポイント

ハイブリッドジョブまたはハイブリッドジョブトリガーを使用してデータを検査するには、正しいエンドポイントに hybridInspect リクエストを送信する必要があります。

ハイブリッドジョブの HTTP メソッドと URL

POST https://dlp.googleapis.com/v2/projects/PROJECT_ID/locations/REGION/dlpJobs/JOB_ID:hybridInspect

このエンドポイントの詳細については、projects.locations.dlpJobs.hybridInspect メソッドの API リファレンスページをご覧ください。

ハイブリッドジョブトリガーの HTTP メソッドと URL

https://dlp.googleapis.com/v2/projects/PROJECT_ID/locations/REGION/jobTriggers/TRIGGER_NAME:hybridInspect

このエンドポイントの詳細については、projects.locations.jobTriggers.hybridInspect メソッドの API リファレンスページをご覧ください。

次のように置き換えます。

PROJECT_ID: プロジェクト ID。
REGION: hybridInspect リクエストを保存する地理的なリージョン。このリージョンは、ハイブリッドジョブのリージョンと同じである必要があります。
JOB_ID: ハイブリッドジョブに割り当てた ID で、i- の接頭辞が付けられます。

ジョブ ID を検索するには、[機密データの保護] で [検査] > [検査ジョブ] をクリックします。
TRIGGER_NAME: ハイブリッドジョブトリガーに指定した名前。

ジョブトリガーの名前を検索するには、[機密データの保護] で、[検査] > [ジョブトリガー] をクリックします。

`hybridInspect` リクエストのラベルを必要とする

ハイブリッドジョブまたはハイブリッドジョブトリガーで処理可能な hybridInspect リクエストを制御する場合は、必要なラベルを設定できます。これらの必要なラベルが含まれていないハイブリッドジョブまたはハイブリッドジョブトリガーのあらゆるhybridInspectリクエストは拒否されます。

必須ラベルを設定するには、次の操作を行います。

ハイブリッドジョブまたはハイブリッドジョブトリガーを作成するときに、requiredFindingLabelKeys フィールドを必要なラベルのリストに設定します。

次の例では、appointment-bookings-comments をハイブリッドジョブまたはハイブリッドジョブトリガーの必要なラベルとして設定します。
```
"hybridOptions": {
  ...
  "requiredFindingLabelKeys": [
    "appointment-bookings-comments"
  ],
  "labels": {
    "env": "prod"
  },
  ...
}
```
hybridInspect リクエストの labels フィールドに、必要なラベルを Key-Value ペアのキーとして追加します。対応する値は、空の文字列にできます。

次の例では、hybridInspect リクエストで必要なラベル appointment-bookings-comments を設定します。
```
{
  "hybridItem": {
    "item": {
      "value": "My email is test@example.org"
    },
    "findingDetails": {
      "containerDetails": {...},
      "labels": {
        "appointment-bookings-comments": ""
      }
    }
  }
}
```

hybridInspect リクエストに必要なラベルを含めないと、次のようなエラーが発生します。

{
  "error": {
    "code": 400,
    "message": "Trigger required labels that were not included: [appointment-bookings-comments]",
    "status": "INVALID_ARGUMENT"
  }
}

コードサンプル: ハイブリッドジョブトリガーを作成してデータを送信する

C#

機密データの保護用のクライアントライブラリをインストールして使用する方法については、機密データの保護のクライアントライブラリをご覧ください。

機密データの保護のために認証するには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の認証の設定をご覧ください。


using System;
using Google.Api.Gax.ResourceNames;
using Google.Api.Gax;
using Google.Cloud.Dlp.V2;
using Grpc.Core;

public class SendDataToTheHybridJobTrigger
{
    public static DlpJob SendToHybridJobTrigger(
       string projectId,
       string jobTriggerId,
       string text = null)
    {
        // Instantiate the dlp client.
        var dlp = DlpServiceClient.Create();

        // Construct the hybrid finding details which will be used as metadata with the content.
        // Refer to this for more information: https://cloud.google.com/dlp/docs/reference/rpc/google.privacy.dlp.v2#google.privacy.dlp.v2.Container
        var findingDetails = new HybridFindingDetails
        {
            ContainerDetails = new Container
            {
                FullPath = "10.0.0.2:logs1:aap1",
                RelativePath = "app1",
                RootPath = "10.0.0.2:logs1",
                Type = "System Logs"
            }
        };

        // Construct the hybrid content item using the finding details and text to be inspected.
        var hybridContentItem = new HybridContentItem
        {
            Item = new ContentItem { Value = text ?? "My email is ariel@example.org and name is Ariel." },
            FindingDetails = findingDetails
        };

        var jobTriggerName = new JobTriggerName(projectId, jobTriggerId);

        // Construct the request to activate the Job Trigger.
        var activate = new ActivateJobTriggerRequest
        {
            JobTriggerName = jobTriggerName
        };

        DlpJob triggerJob = null;

        try
        {
            // Call the API to activate the trigger.
            triggerJob = dlp.ActivateJobTrigger(activate);
        }
        catch (RpcException)
        {
            ListDlpJobsRequest listJobsRequest = new ListDlpJobsRequest
            {
                ParentAsLocationName = new LocationName(projectId, "global"),
                Filter = $"trigger_name={jobTriggerName}"
            };

            PagedEnumerable<ListDlpJobsResponse, DlpJob> res = dlp.ListDlpJobs(listJobsRequest);
            foreach (DlpJob j in res)
            {
                triggerJob = j;
            }
        }

        // Construct the request using hybrid content item.
        var request = new HybridInspectJobTriggerRequest
        {
            HybridItem = hybridContentItem,
            JobTriggerName = jobTriggerName
        };

        // Call the API.
        HybridInspectResponse _ = dlp.HybridInspectJobTrigger(request);

        Console.WriteLine($"Hybrid job created successfully. Job name: {triggerJob.Name}");

        return triggerJob;
    }
}

Go

import (
	"context"
	"fmt"
	"io"
	"log"
	"time"

	dlp "cloud.google.com/go/dlp/apiv2"
	"cloud.google.com/go/dlp/apiv2/dlppb"
)

// inspectDataToHybridJobTrigger uses the Data Loss Prevention API to inspect sensitive
// information using Hybrid jobs trigger that scans payloads of data sent from
// virtually any source and stores findings in Google Cloud.
func inspectDataToHybridJobTrigger(w io.Writer, projectID, textToDeIdentify, jobTriggerName string) error {
	// projectId := "your-project-id"
	// jobTriggerName := "your-job-trigger-name"
	// textToDeIdentify := "My email is test@example.org"

	ctx := context.Background()

	// Initialize a client once and reuse it to send multiple requests. Clients
	// are safe to use across goroutines. When the client is no longer needed,
	// call the Close method to cleanup its resources.
	client, err := dlp.NewClient(ctx)
	if err != nil {
		return err
	}

	// Closing the client safely cleans up background resources.
	defer client.Close()

	// Specify the content to be inspected.
	contentItem := &dlppb.ContentItem{
		DataItem: &dlppb.ContentItem_Value{
			Value: textToDeIdentify,
		},
	}

	// Contains metadata to associate with the content.
	// Refer to https://cloud.google.com/dlp/docs/reference/rpc/google.privacy.dlp.v2#container for specifying the paths in container object.
	container := &dlppb.Container{
		Type:         "logging_sys",
		FullPath:     "10.0.0.2:logs1:app1",
		RelativePath: "app1",
		RootPath:     "10.0.0.2:logs1",
		Version:      "1.2",
	}

	// Set the required label.
	labels := map[string]string{
		"env":                           "prod",
		"appointment-bookings-comments": "",
	}

	hybridFindingDetails := &dlppb.HybridFindingDetails{
		ContainerDetails: container,
		Labels:           labels,
	}

	hybridContentItem := &dlppb.HybridContentItem{
		Item:           contentItem,
		FindingDetails: hybridFindingDetails,
	}

	// Activate the job trigger.
	activateJobreq := &dlppb.ActivateJobTriggerRequest{
		Name: jobTriggerName,
	}

	dlpJob, err := client.ActivateJobTrigger(ctx, activateJobreq)
	if err != nil {
		log.Printf("Error from return part %v", err)
		return err
	}
	// Build the hybrid inspect request.
	req := &dlppb.HybridInspectJobTriggerRequest{
		Name:       jobTriggerName,
		HybridItem: hybridContentItem,
	}

	// Send the hybrid inspect request.
	_, err = client.HybridInspectJobTrigger(ctx, req)
	if err != nil {
		return err
	}

	getDlpJobReq := &dlppb.GetDlpJobRequest{
		Name: dlpJob.Name,
	}

	var result *dlppb.DlpJob
	for i := 0; i < 5; i++ {
		// Get DLP job
		result, err = client.GetDlpJob(ctx, getDlpJobReq)
		if err != nil {
			fmt.Printf("Error getting DLP job: %v\n", err)
			return err
		}

		// Check if processed bytes is greater than 0
		if result.GetInspectDetails().GetResult().GetProcessedBytes() > 0 {
			break
		}

		// Wait for 5 seconds before checking again
		time.Sleep(5 * time.Second)
		i++
	}

	fmt.Fprintf(w, "Job Name: %v\n", result.Name)
	fmt.Fprintf(w, "Job State: %v\n", result.State)

	inspectionResult := result.GetInspectDetails().GetResult()
	fmt.Fprint(w, "Findings: \n")
	for _, v := range inspectionResult.GetInfoTypeStats() {
		fmt.Fprintf(w, "Infotype: %v\n", v.InfoType.Name)
		fmt.Fprintf(w, "Likelihood: %v\n", v.GetCount())
	}

	fmt.Fprint(w, "successfully inspected data using hybrid job trigger ")
	return nil
}

Java


import com.google.api.gax.rpc.InvalidArgumentException;
import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.ActivateJobTriggerRequest;
import com.google.privacy.dlp.v2.Container;
import com.google.privacy.dlp.v2.ContentItem;
import com.google.privacy.dlp.v2.DlpJob;
import com.google.privacy.dlp.v2.GetDlpJobRequest;
import com.google.privacy.dlp.v2.HybridContentItem;
import com.google.privacy.dlp.v2.HybridFindingDetails;
import com.google.privacy.dlp.v2.HybridInspectJobTriggerRequest;
import com.google.privacy.dlp.v2.InfoTypeStats;
import com.google.privacy.dlp.v2.InspectDataSourceDetails;
import com.google.privacy.dlp.v2.JobTriggerName;
import com.google.privacy.dlp.v2.ListDlpJobsRequest;

public class InspectDataToHybridJobTrigger {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    // The Google Cloud project id to use as a parent resource.
    String projectId = "your-project-id";
    // The job trigger id used to for processing a hybrid job trigger.
    String jobTriggerId = "your-job-trigger-id";
    // The string to de-identify.
    String textToDeIdentify = "My email is test@example.org and my name is Gary.";
    inspectDataToHybridJobTrigger(textToDeIdentify, projectId, jobTriggerId);
  }

  // Inspects data using a hybrid job trigger.
  // Hybrid jobs trigger allows to scan payloads of data sent from virtually any source for
  // sensitive information and then store the findings in Google Cloud.
  public static void inspectDataToHybridJobTrigger(
      String textToDeIdentify, String projectId, String jobTriggerId) throws Exception {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (DlpServiceClient dlpClient = DlpServiceClient.create()) {
      // Specify the content to be inspected.
      ContentItem contentItem = ContentItem.newBuilder().setValue(textToDeIdentify).build();

      // Contains metadata to associate with the content.
      // Refer to https://cloud.google.com/dlp/docs/reference/rest/v2/Container for specifying the
      // paths in container object.
      Container container =
          Container.newBuilder()
              .setFullPath("10.0.0.2:logs1:app1")
              .setRelativePath("app1")
              .setRootPath("10.0.0.2:logs1")
              .setType("logging_sys")
              .setVersion("1.2")
              .build();

      HybridFindingDetails hybridFindingDetails =
          HybridFindingDetails.newBuilder().setContainerDetails(container).build();

      HybridContentItem hybridContentItem =
          HybridContentItem.newBuilder()
              .setItem(contentItem)
              .setFindingDetails(hybridFindingDetails)
              .build();

      // Activate the job trigger.
      ActivateJobTriggerRequest activateJobTriggerRequest =
          ActivateJobTriggerRequest.newBuilder()
              .setName(JobTriggerName.of(projectId, jobTriggerId).toString())
              .build();

      DlpJob dlpJob;

      try {
        dlpJob = dlpClient.activateJobTrigger(activateJobTriggerRequest);
      } catch (InvalidArgumentException e) {
        ListDlpJobsRequest request =
            ListDlpJobsRequest.newBuilder()
                .setParent(JobTriggerName.of(projectId, jobTriggerId).toString())
                .setFilter("trigger_name=" + JobTriggerName.of(projectId, jobTriggerId).toString())
                .build();

        // Retrieve the DLP jobs triggered by the job trigger
        DlpServiceClient.ListDlpJobsPagedResponse response = dlpClient.listDlpJobs(request);
        dlpJob = response.getPage().getResponse().getJobs(0);
      }

      // Build the hybrid inspect request.
      HybridInspectJobTriggerRequest request =
          HybridInspectJobTriggerRequest.newBuilder()
              .setName(JobTriggerName.of(projectId, jobTriggerId).toString())
              .setHybridItem(hybridContentItem)
              .build();

      // Send the hybrid inspect request.
      dlpClient.hybridInspectJobTrigger(request);

      // Build a request to get the completed job
      GetDlpJobRequest getDlpJobRequest =
          GetDlpJobRequest.newBuilder().setName(dlpJob.getName()).build();

      DlpJob result = null;

      do {
        result = dlpClient.getDlpJob(getDlpJobRequest);
        Thread.sleep(5000);
      } while (result.getInspectDetails().getResult().getProcessedBytes() <= 0);

      System.out.println("Job status: " + result.getState());
      System.out.println("Job name: " + result.getName());
      // Parse the response and process results.
      InspectDataSourceDetails.Result inspectionResult = result.getInspectDetails().getResult();
      System.out.println("Findings: ");
      for (InfoTypeStats infoTypeStat : inspectionResult.getInfoTypeStatsList()) {
        System.out.println("\tInfoType: " + infoTypeStat.getInfoType().getName());
        System.out.println("\tCount: " + infoTypeStat.getCount() + "\n");
      }
    }
  }
}

Node.js

// Imports the Google Cloud Data Loss Prevention library
const DLP = require('@google-cloud/dlp');

// Instantiates a client
const dlpClient = new DLP.DlpServiceClient();

// The project ID to run the API call under.
// const projectId = "your-project-id";

// The string to de-identify
// const string = 'My email is test@example.org';

// Job Trigger ID
// const jobTriggerId = 'your-job-trigger-id';

async function inspectDataToHybridJobTrigger() {
  // Contains metadata to associate with the content.
  const container = {
    full_path: '10.0.0.2:logs1:app1',
    relative_path: 'app1',
    root_path: '10.0.0.2:logs1',
    type: 'logging_sys',
    version: '1.2',
  };

  const labels = {env: 'prod', 'appointment-bookings-comments': ''};

  // Build the hybrid content item.
  const hybridContentItem = {
    item: {value: string},
    findingDetails: {
      containerDetails: container,
      labels,
    },
  };
  let jobName;
  const fullTriggerName = `projects/${projectId}/jobTriggers/${jobTriggerId}`;
  // Activate the job trigger.
  try {
    const response = await dlpClient.activateJobTrigger({
      name: fullTriggerName,
    });
    jobName = response[0].name;
  } catch (err) {
    console.log(err);
    if (err.code === 3) {
      const response = await dlpClient.listDlpJobs({
        parent: fullTriggerName,
        filter: `trigger_name=${fullTriggerName}`,
      });
      jobName = response[0][0].name;
    }
    // Ignore error related to job trigger already active
    if (err.code !== 3) {
      console.log(err.message);
      return;
    }
  }
  // Build the hybrid inspect request.
  const request = {
    name: `projects/${projectId}/jobTriggers/${jobTriggerId}`,
    hybridItem: hybridContentItem,
  };
  // Send the hybrid inspect request.
  await dlpClient.hybridInspectJobTrigger(request);
  // Waiting for a maximum of 15 minutes for the job to get complete.
  let job;
  let numOfAttempts = 30;
  while (numOfAttempts > 0) {
    // Fetch DLP Job status
    [job] = await dlpClient.getDlpJob({name: jobName});

    if (job.state === 'FAILED') {
      console.log('Job Failed, Please check the configuration.');
      return;
    }
    // Check if the job has completed.
    if (job.inspectDetails.result.processedBytes > 0) {
      break;
    }
    // Sleep for a short duration before checking the job status again.
    await new Promise(resolve => {
      setTimeout(() => resolve(), 30000);
    });
    numOfAttempts -= 1;
  }
  // Finish the job once the inspection is complete.
  await dlpClient.finishDlpJob({name: jobName});

  // Print out the results.
  const infoTypeStats = job.inspectDetails.result.infoTypeStats;
  if (infoTypeStats.length > 0) {
    infoTypeStats.forEach(infoTypeStat => {
      console.log(
        `  Found ${infoTypeStat.count} instance(s) of infoType ${infoTypeStat.infoType.name}.`
      );
    });
  } else {
    console.log('No findings.');
  }
}
await inspectDataToHybridJobTrigger();

PHP


use Google\ApiCore\ApiException;
use Google\Cloud\Dlp\V2\Container;
use Google\Cloud\Dlp\V2\DlpServiceClient;
use Google\Cloud\Dlp\V2\ContentItem;
use Google\Cloud\Dlp\V2\DlpJob\JobState;
use Google\Cloud\Dlp\V2\HybridContentItem;
use Google\Cloud\Dlp\V2\HybridFindingDetails;

/**
 * Inspect data hybrid job trigger.
 * Send data to the hybrid job or hybrid job trigger.
 *
 * @param string $callingProjectId  The Google Cloud project id to use as a parent resource.
 * @param string $string            The string to inspect (will be treated as text).
 */

function inspect_send_data_to_hybrid_job_trigger(
    // TODO(developer): Replace sample parameters before running the code.
    string $callingProjectId,
    string $jobTriggerId,
    string $string
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    $content = (new ContentItem())
        ->setValue($string);

    $container = (new Container())
        ->setFullPath('10.0.0.2:logs1:app1')
        ->setRelativePath('app1')
        ->setRootPath('10.0.0.2:logs1')
        ->setType('logging_sys')
        ->setVersion('1.2');

    $findingDetails = (new HybridFindingDetails())
        ->setContainerDetails($container)
        ->setLabels([
            'env' => 'prod',
            'appointment-bookings-comments' => ''
        ]);

    $hybridItem = (new HybridContentItem())
        ->setItem($content)
        ->setFindingDetails($findingDetails);

    $parent = "projects/$callingProjectId/locations/global";
    $name = "projects/$callingProjectId/locations/global/jobTriggers/" . $jobTriggerId;

    $triggerJob = null;
    try {
        $triggerJob = $dlp->activateJobTrigger($name);
    } catch (ApiException $e) {
        $result = $dlp->listDlpJobs($parent, ['filter' => 'trigger_name=' . $name]);
        foreach ($result as $job) {
            $triggerJob = $job;
        }
    }

    $dlp->hybridInspectJobTrigger($name, [
        'hybridItem' => $hybridItem,
    ]);

    $numOfAttempts = 10;
    do {
        printf('Waiting for job to complete' . PHP_EOL);
        sleep(10);
        $job = $dlp->getDlpJob($triggerJob->getName());
        if ($job->getState() != JobState::RUNNING) {
            break;
        }
        $numOfAttempts--;
    } while ($numOfAttempts > 0);

    // Print finding counts.
    printf('Job %s status: %s' . PHP_EOL, $job->getName(), JobState::name($job->getState()));
    switch ($job->getState()) {
        case JobState::DONE:
            $infoTypeStats = $job->getInspectDetails()->getResult()->getInfoTypeStats();
            if (count($infoTypeStats) === 0) {
                printf('No findings.' . PHP_EOL);
            } else {
                foreach ($infoTypeStats as $infoTypeStat) {
                    printf(
                        '  Found %s instance(s) of infoType %s' . PHP_EOL,
                        $infoTypeStat->getCount(),
                        $infoTypeStat->getInfoType()->getName()
                    );
                }
            }
            break;
        case JobState::FAILED:
            printf('Job %s had errors:' . PHP_EOL, $job->getName());
            $errors = $job->getErrors();
            foreach ($errors as $error) {
                var_dump($error->getDetails());
            }
            break;
        case JobState::PENDING:
            printf('Job has not completed. Consider a longer timeout or an asynchronous execution model' . PHP_EOL);
            break;
        default:
            printf('Unexpected job state. Most likely, the job is either running or has not yet started.');
    }
}

Python

import time

import google.cloud.dlp


def inspect_data_to_hybrid_job_trigger(
    project: str,
    trigger_id: str,
    content_string: str,
) -> None:
    """
    Uses the Data Loss Prevention API to inspect sensitive information
    using Hybrid jobs trigger that scans payloads of data sent from
    virtually any source and stores findings in Google Cloud.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        trigger_id: The job trigger identifier for hybrid job trigger.
        content_string: The string to inspect.
    """

    # Instantiate a client.
    dlp = google.cloud.dlp_v2.DlpServiceClient()

    # Construct the `item` to inspect.
    item = {"value": content_string}

    # Construct the container details that contains metadata to be
    # associated with the content. For more details, please refer to
    # https://cloud.google.com/dlp/docs/reference/rest/v2/Container
    container_details = {
        "full_path": "10.0.0.2:logs1:app1",
        "relative_path": "app1",
        "root_path": "10.0.0.2:logs1",
        "type_": "logging_sys",
        "version": "1.2",
    }

    # Construct hybrid inspection configuration.
    hybrid_config = {
        "item": item,
        "finding_details": {
            "container_details": container_details,
            "labels": {
                "env": "prod",
                "appointment-bookings-comments": "",
            },
        },
    }

    # Convert the trigger id into a full resource id.
    trigger_id = f"projects/{project}/jobTriggers/{trigger_id}"

    # Activate the job trigger.
    dlp_job = dlp.activate_job_trigger(request={"name": trigger_id})

    # Call the API.
    dlp.hybrid_inspect_job_trigger(
        request={
            "name": trigger_id,
            "hybrid_item": hybrid_config,
        }
    )

    # Get inspection job details.
    job = dlp.get_dlp_job(request={"name": dlp_job.name})

    # Wait for dlp job to get finished.
    while job.inspect_details.result.processed_bytes <= 0:
        time.sleep(5)
        job = dlp.get_dlp_job(request={"name": dlp_job.name})

    # Print the results.
    print(f"Job name: {dlp_job.name}")
    if job.inspect_details.result.info_type_stats:
        for finding in job.inspect_details.result.info_type_stats:
            print(f"Info type: {finding.info_type.name}; Count: {finding.count}")
    else:
        print("No findings.")

一般的なハイブリッド検査シナリオ

次のセクションでは、ハイブリッド検査の一般的な用途と、それに対応するワークフローについて説明します。

1 回限りのスキャンを実行する

データベースの四半期ごとのスポットチェックの一環として、Google Cloud の外部にあるデータベースの 1 回限りのスキャンを実行する。

Google Cloud コンソールまたは DLP API を使用してハイブリッドジョブを作成します。
projects.locations.dlpJobs.hybridInspect を呼び出してジョブにデータを送信します。より多くのデータを検査する場合は、この手順を必要な回数繰り返します。
検査用にデータを送信したら、projects.locations.dlpJobs.finish メソッドを呼び出します。

機密データの保護では、projects.locations.dlpJobs.create リクエストで指定されたアクションが実行されます。

継続的なモニタリングを構成する

機密データの保護でネイティブでサポートされていないデータベースに対して、新しく追加されたすべてのコンテンツを毎日モニタリングする。

Google Cloud コンソールまたは DLP API を使用して、ハイブリッドジョブトリガーを作成します。
projects.locations.jobTriggers.activate メソッドを呼び出してジョブトリガーを有効にします。
projects.locations.jobTriggers.hybridInspect を呼び出して、ジョブトリガーにデータを送信します。より多くのデータを検査する場合は、この手順を必要な回数繰り返します。

このケースでは、projects.locations.dlpJobs.finish メソッドを呼び出す必要はありません。機密データの保護では送信したデータが自動的にパーティショニングされます。ジョブトリガーがアクティブである限り、機密データの保護は 1 日の終わりに、ハイブリッドジョブトリガーの作成時に指定したアクションを実行します。

データベースに到着したデータをスキャンする

データの分割方法を制御しながら、データベースに到着したデータをスキャンします。ジョブトリガー内の各ジョブは単一のパーティションです。

Google Cloud コンソールまたは DLP API を使用して、ハイブリッドジョブトリガーを作成します。
projects.locations.jobTriggers.activate メソッドを呼び出してジョブトリガーを有効にします。

システムは、単一ジョブのジョブ ID を返します。このジョブ ID は次の手順で必要になります。
projects.locations.dlpJobs.hybridInspect を呼び出してジョブにデータを送信します。

この場合、ジョブトリガーではなくジョブにデータを送信します。この方法では、検査用に送信するデータのパーティショニング方法を制御できます。現在のパーティションに検査用データを追加する場合は、この手順を繰り返します。
ジョブにデータを送信したら、projects.locations.dlpJobs.finish メソッドを呼び出します。

機密データの保護では、projects.locations.jobTriggers.create リクエストで指定されたアクションが実行されます。
次のパーティション用の別のジョブを作成する場合は、ジョブトリガーを再度アクティブにして、その結果のジョブにデータを送信します。

プロキシからのトラフィックをモニタリングする

2 つのカスタムアプリケーションの間にインストールされたプロキシからのトラフィックをモニタリングする。

Google Cloud コンソールまたは DLP API を使用して、ハイブリッドジョブトリガーを作成します。
projects.locations.jobTriggers.activate メソッドを呼び出してジョブトリガーを有効にします。
projects.locations.jobTriggers.hybridInspect を呼び出して、ジョブトリガーにデータを送信します。より多くのデータを検査する場合は、この手順を必要な回数繰り返します。

このリクエストは、すべてのネットワークトラフィックで無期限に呼び出すことができます。各リクエストに必ずメタデータを含めてください。

次のステップ

ハイブリッドジョブとジョブトリガーの仕組みについて詳しく学習します。

ハイブリッド ジョブを使用して外部ソースのデータを検査する

ハイブリッド ジョブとハイブリッド ジョブトリガーの概要

ハイブリッド ジョブとハイブリッド ジョブトリガーの比較

用語の定義

ハイブリッド検査プロセス

考慮事項

始める前に

新しいプロジェクトの作成、課金の有効化、機密データの保護の有効化

データソースを構成する

ハイブリッド ジョブまたはハイブリッド ジョブトリガーを作成する

Console

入力データを選択

検出を構成する

アクションの追加

スケジュール

まとめ

API

JSON の例について

ハイブリッド ジョブ

ハイブリッド ジョブトリガー

ハイブリッド ジョブまたはハイブリッド ジョブトリガーにデータを送信する

ハイブリッド コンテンツ アイテムのフォーマット

ハイブリッド検査エンドポイント

hybridInspect リクエストのラベルを必要とする

コードサンプル: ハイブリッド ジョブトリガーを作成してデータを送信する

C#

Go

Java

Node.js

PHP

Python

一般的なハイブリッド検査シナリオ

1 回限りのスキャンを実行する

継続的なモニタリングを構成する

データベースに到着したデータをスキャンする

プロキシからのトラフィックをモニタリングする

次のステップ

ハイブリッドジョブを使用して外部ソースのデータを検査する

ハイブリッドジョブとハイブリッドジョブトリガーの概要

ハイブリッドジョブとハイブリッドジョブトリガーの比較

ハイブリッドジョブまたはハイブリッドジョブトリガーを作成する

ハイブリッドジョブ

ハイブリッドジョブトリガー

ハイブリッドジョブまたはハイブリッドジョブトリガーにデータを送信する

ハイブリッドコンテンツアイテムのフォーマット

`hybridInspect` リクエストのラベルを必要とする

コードサンプル: ハイブリッドジョブトリガーを作成してデータを送信する