此示例使用指定的存储的 infoType 检测器扫描给定文本。
深入探索
如需查看包含此代码示例的详细文档，请参阅以下内容：
代码示例
C#
如需了解如何安装和使用用于敏感数据保护的客户端库，请参阅敏感数据保护客户端库。
如需向敏感数据保护服务进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。
using System;
using Google.Api.Gax.ResourceNames;
using Google.Cloud.Dlp.V2;
public class InspectDataWithStoredInfotypes
{
public static InspectContentResponse Inspect(
string projectId,
string storedInfotypePath,
string text,
InfoType infoType = null)
{
// Instantiate the dlp client.
var dlp = DlpServiceClient.Create();
// Construct the infotype if null.
var infotype = infoType ?? new InfoType { Name = "GITHUB_LOGINS" };
// Construct the inspect config using stored infotype.
var inspectConfig = new InspectConfig
{
CustomInfoTypes =
{
new CustomInfoType
{
InfoType = infotype,
StoredType = new StoredType { Name = storedInfotypePath }
}
},
IncludeQuote = true
};
// Construct the request using inspect config.
var request = new InspectContentRequest
{
ParentAsLocationName = new LocationName(projectId, "global"),
InspectConfig = inspectConfig,
Item = new ContentItem { Value = text }
};
// Call the API.
InspectContentResponse response = dlp.InspectContent(request);
// Inspect the results.
var findings = response.Result.Findings;
Console.WriteLine($"Findings: {findings.Count}");
foreach (var f in findings)
{
Console.WriteLine("\tQuote: " + f.Quote);
Console.WriteLine("\tInfo type: " + f.InfoType.Name);
Console.WriteLine("\tLikelihood: " + f.Likelihood);
}
return response;
}
}
Go
如需了解如何安装和使用用于敏感数据保护的客户端库，请参阅敏感数据保护客户端库。
如需向敏感数据保护服务进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。
import (
"context"
"fmt"
"io"
dlp "cloud.google.com/go/dlp/apiv2"
"cloud.google.com/go/dlp/apiv2/dlppb"
)
// inspectWithStoredInfotype inspects the given text using the specified stored infoType detector.
func inspectWithStoredInfotype(w io.Writer, projectID, infoTypeId, textToDeidentify string) error {
// projectId := "your-project-id"
// infoTypeId := "your-info-type-id"
// textToDeidentify := "This commit was made by kewin2010"
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,
},
}
// Specify the info type the inspection will look for.
infoType := &dlppb.InfoType{
Name: "GITHUB_LOGINS",
}
// Specify the stored info type the inspection will look for.
storedType := &dlppb.StoredType{
Name: infoTypeId,
}
customInfoType := &dlppb.CustomInfoType{
InfoType: infoType,
Type: &dlppb.CustomInfoType_StoredType{
StoredType: storedType,
},
}
// Specify how the content should be inspected.
inspectConfig := &dlppb.InspectConfig{
CustomInfoTypes: []*dlppb.CustomInfoType{
customInfoType,
},
IncludeQuote: true,
}
// Construct the Inspect request to be sent by the client.
req := &dlppb.InspectContentRequest{
Parent: fmt.Sprintf("projects/%s/locations/global", projectID),
InspectConfig: inspectConfig,
Item: contentItem,
}
// Use the client to send the API request.
resp, err := client.InspectContent(ctx, req)
if err != nil {
return err
}
// Process the results.
fmt.Fprintf(w, "Findings: %d\n", len(resp.Result.Findings))
for _, f := range resp.Result.Findings {
fmt.Fprintf(w, "\tQuote: %s\n", f.Quote)
fmt.Fprintf(w, "\tInfo type: %s\n", f.InfoType.Name)
fmt.Fprintf(w, "\tLikelihood: %s\n", f.Likelihood)
}
return nil
}
Java
如需了解如何安装和使用用于敏感数据保护的客户端库，请参阅敏感数据保护客户端库。
如需向敏感数据保护服务进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。
import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.ContentItem;
import com.google.privacy.dlp.v2.CustomInfoType;
import com.google.privacy.dlp.v2.Finding;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectContentRequest;
import com.google.privacy.dlp.v2.InspectContentResponse;
import com.google.privacy.dlp.v2.LocationName;
import com.google.privacy.dlp.v2.ProjectStoredInfoTypeName;
import com.google.privacy.dlp.v2.StoredType;
import java.io.IOException;
public class InspectWithStoredInfotype {
public static void main(String[] args) throws IOException {
// 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 sample assumes that you have an existing stored infoType.
// To create a stored InfoType refer:
// https://cloud.google.com/dlp/docs/creating-stored-infotypes#create-storedinfotye
String storedInfoTypeId = "your-info-type-id";
// The string to de-identify.
String textToInspect =
"My phone number is (223) 456-7890 and my email address is gary@example.com.";
inspectWithStoredInfotype(projectId, storedInfoTypeId, textToInspect);
}
// Inspects the given text using the specified stored infoType detector.
public static void inspectWithStoredInfotype(
String projectId, String storedInfoTypeId, String textToInspect) throws IOException {
// 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 dlp = DlpServiceClient.create()) {
// Specify the content to be inspected.
ContentItem contentItem = ContentItem.newBuilder().setValue(textToInspect).build();
InfoType infoType = InfoType.newBuilder().setName("STORED_TYPE").build();
// Reference to the existing StoredInfoType to inspect the data.
StoredType storedType = StoredType.newBuilder()
.setName(ProjectStoredInfoTypeName.of(projectId, storedInfoTypeId).toString())
.build();
CustomInfoType customInfoType =
CustomInfoType.newBuilder().setInfoType(infoType).setStoredType(storedType).build();
// Construct the configuration for the Inspect request.
InspectConfig inspectConfig =
InspectConfig.newBuilder()
.addCustomInfoTypes(customInfoType)
.setIncludeQuote(true)
.build();
// Construct the Inspect request to be sent by the client.
InspectContentRequest inspectContentRequest =
InspectContentRequest.newBuilder()
.setParent(LocationName.of(projectId, "global").toString())
.setInspectConfig(inspectConfig)
.setItem(contentItem)
.build();
// Use the client to send the API request.
InspectContentResponse response = dlp.inspectContent(inspectContentRequest);
// Parse the response and process results.
System.out.println("Findings: " + "" + response.getResult().getFindingsCount());
for (Finding f : response.getResult().getFindingsList()) {
System.out.println("\tQuote: " + f.getQuote());
System.out.println("\tInfoType: " + f.getInfoType().getName());
System.out.println("\tLikelihood: " + f.getLikelihood() + "\n");
}
}
}
}Node.js
如需了解如何安装和使用用于敏感数据保护的客户端库，请参阅敏感数据保护客户端库。
如需向敏感数据保护服务进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。
// Imports the Google Cloud Data Loss Prevention library
const DLP = require('@google-cloud/dlp');
// Instantiates a client
const dlp = new DLP.DlpServiceClient();
// The project ID to run the API call under.
// const projectId = 'your-project-id';
// The custom info-type id created and stored in the bucket.
// const infoTypeId = 'your-info-type-id';
// The string to inspect.
// const string = 'My phone number is (223) 456-7890 and my email address is gary@example.com.';
async function inspectWithStoredInfotype() {
// Reference to the existing StoredInfoType to inspect the data.
const customInfoType = {
infoType: {
name: 'GITHUB_LOGINS',
},
storedType: {
name: infoTypeId,
},
};
// Construct the configuration for the Inspect request.
const inspectConfig = {
customInfoTypes: [customInfoType],
includeQuote: true,
};
// Construct the Inspect request to be sent by the client.
const request = {
parent: `projects/${projectId}/locations/global`,
inspectConfig: inspectConfig,
item: {
value: string,
},
};
// Run request
const [response] = await dlp.inspectContent(request);
// Print Findings
const findings = response.result.findings;
if (findings.length > 0) {
console.log(`Findings: ${findings.length}\n`);
findings.forEach(finding => {
console.log(`InfoType: ${finding.infoType.name}`);
console.log(`\tQuote: ${finding.quote}`);
console.log(`\tLikelihood: ${finding.likelihood} \n`);
});
} else {
console.log('No findings.');
}
}
await inspectWithStoredInfotype();PHP
如需了解如何安装和使用用于敏感数据保护的客户端库，请参阅敏感数据保护客户端库。
如需向敏感数据保护服务进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。
use Google\Cloud\Dlp\V2\DlpServiceClient;
use Google\Cloud\Dlp\V2\ContentItem;
use Google\Cloud\Dlp\V2\CustomInfoType;
use Google\Cloud\Dlp\V2\InfoType;
use Google\Cloud\Dlp\V2\InspectConfig;
use Google\Cloud\Dlp\V2\Likelihood;
use Google\Cloud\Dlp\V2\StoredType;
/**
* Inspect with stored infoType.
* Scan content using a large custom dictionary detector.
*
* @param string $projectId The Google Cloud Project ID to run the API call under.
* @param string $storedInfoTypeName The name of the stored infotype whose This value must be in the format
* projects/projectName/(locations/locationId)/storedInfoTypes/storedInfoTypeName.
* @param string $textToInspect The string to inspect.
*/
function inspect_with_stored_infotype(
string $projectId,
string $storedInfoTypeName,
string $textToInspect
): void {
// Instantiate a client.
$dlp = new DlpServiceClient();
$parent = "projects/$projectId/locations/global";
// Specify the content to be inspected.
$item = (new ContentItem())
->setValue($textToInspect);
// Reference to the existing StoredInfoType to inspect the data.
$customInfoType = (new CustomInfoType())
->setInfoType((new InfoType())
->setName('STORED_TYPE'))
->setStoredType((new StoredType())
->setName($storedInfoTypeName));
// Construct the configuration for the Inspect request.
$inspectConfig = (new InspectConfig())
->setCustomInfoTypes([$customInfoType])
->setIncludeQuote(true);
// Run request.
$response = $dlp->inspectContent([
'parent' => $parent,
'inspectConfig' => $inspectConfig,
'item' => $item
]);
// Print the results.
$findings = $response->getResult()->getFindings();
if (count($findings) == 0) {
printf('No findings.' . PHP_EOL);
} else {
printf('Findings:' . PHP_EOL);
foreach ($findings as $finding) {
printf(' Quote: %s' . PHP_EOL, $finding->getQuote());
printf(' Info type: %s' . PHP_EOL, $finding->getInfoType()->getName());
printf(' Likelihood: %s' . PHP_EOL, Likelihood::name($finding->getLikelihood()));
}
}
}Python
如需了解如何安装和使用用于敏感数据保护的客户端库，请参阅敏感数据保护客户端库。
如需向敏感数据保护服务进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。
import google.cloud.dlp
def inspect_with_stored_infotype(
project: str,
stored_info_type_id: str,
content_string: str,
) -> None:
"""Uses the Data Loss Prevention API to inspect/scan content using stored
infoType.
Args:
project: The Google Cloud project id to use as a parent resource.
content_string: The string to inspect.
stored_info_type_id: The identifier of stored infoType used to inspect.
"""
# Instantiate a client.
dlp = google.cloud.dlp_v2.DlpServiceClient()
# Convert stored infoType id into full resource id
stored_type_name = f"projects/{project}/storedInfoTypes/{stored_info_type_id}"
# Construct a custom info type dictionary using stored infoType.
custom_info_types = [
{
"info_type": {"name": "STORED_TYPE"},
"stored_type": {
"name": stored_type_name,
},
}
]
# Construct the inspection configuration dictionary.
inspect_config = {
"custom_info_types": custom_info_types,
"include_quote": True,
}
# Construct the `item` to be inspected using stored infoType.
item = {"value": content_string}
# Convert the project id into a full resource id.
parent = f"projects/{project}/locations/global"
# Call the API.
response = dlp.inspect_content(
request={
"parent": parent,
"inspect_config": inspect_config,
"item": item,
}
)
# Print out the results.
if response.result.findings:
for finding in response.result.findings:
print(f"Quote: {finding.quote}")
print(f"Info type: {finding.info_type.name}")
print(f"Likelihood: {finding.likelihood}")
else:
print("No findings.")
后续步骤
如需搜索和过滤其他 Google Cloud 产品的代码示例，请参阅 Google Cloud 示例浏览器。