יצירת תבניות לבדיקת Sensitive Data Protection

במאמר הזה מוסבר בפירוט איך ליצור תבנית בדיקה חדשה. במאמר התחלה מהירה: יצירת תבנית בדיקה של Sensitive Data Protection מוסבר בקצרה איך יוצרים תבנית בדיקה חדשה באמצעות מסוףGoogle Cloud .

מידע על התבניות

אתם יכולים להשתמש בתבניות כדי ליצור ולשמור פרטי הגדרות לשימוש ב-Sensitive Data Protection. התבניות שימושיות להפרדה בין פרטי ההגדרות – כמו מה שאתם בודקים ואיך אתם מסירים את פרטי הזיהוי – לבין הטמעת הבקשות. תבניות מאפשרות לעשות שימוש חוזר בהגדרות וליצור עקביות בין משתמשים וקבוצות נתונים. בנוסף, בכל פעם שמעדכנים תבנית, היא מתעדכנת בכל טריגר של משימה שמשתמש בה.

ב-Sensitive Data Protection יש תמיכה בתבניות לבדיקה, שמוסברות בנושא הזה, ובתבניות להסרת פרטי הזיהוי, שמוסברות במאמר יצירת תבניות להסרת פרטי הזיהוי ב-Sensitive Data Protection.

למידע על תבניות ב-Sensitive Data Protection, קראו את המאמר תבניות.

בחומר העזר בנושא גילוי Infotype אפשר למצוא פרטים נוספים על סוגי המידע (infoTypes) שאפשר לציין בתבניות הבדיקה.

יצירת תבנית בדיקה חדשה

המסוף

נכנסים לדף Create template במסוף Google Cloud .

מעבר אל "יצירת תבנית"

הדף Create template מכיל את הקטעים הבאים:

הגדרת תבנית

בקטע Define template, מזינים מזהה לתבנית הבדיקה. כך תתייחסו לתבנית כשאתם מריצים משימה, יוצרים טריגר למשימה וכו'. אפשר להשתמש באותיות, במספרים ובמקפים. אם רוצים, אפשר גם להזין שם תצוגה שיהיה קל יותר לזכור, וגם תיאור שיעזור לכם לזכור מה התבנית עושה.

בשדה Resource location, בוחרים את האזור שבו מאוחסנים הנתונים שרוצים לבדוק. גם תבנית הבדיקה שתיצרו תישמר באזור הזה. אם רוצים להשתמש בתבנית הבדיקה החדשה בכל אזור, בוחרים באפשרות Global (any region)‎.

הגדרת הזיהוי

בשלב הבא, בוחרים infoType ואפשרויות נוספות כדי להגדיר מה Sensitive Data Protection יזהה בתוכן.

גלאי InfoType מוצאים מידע אישי רגיש מסוג מסוים. לדוגמה, גלאי ה-infoType‏ US_SOCIAL_SECURITY_NUMBER של Sensitive Data Protection מוצא מספרי תעודות זהות בארה"ב. בנוסף למזהי ה-infoType המובנים, אתם יכולים ליצור מזהי infoType בהתאמה אישית.

בקטע InfoTypes, בוחרים את גלאי ה-infoType שתואם לסוג הנתונים שרוצים לסרוק. לא מומלץ להשאיר את הקטע הזה ריק. אם תעשו את זה, Sensitive Data Protection יסרוק את הנתונים שלכם עם קבוצת ברירת מחדל של infoTypes, שעשויה לכלול infoTypes שאתם לא צריכים. מידע נוסף על כל גלאי מופיע בחומר העזר בנושא גלאי InfoType.

למידע נוסף על ניהול של סוגי מידע מובנים ומותאמים אישית בקטע הזה, קראו את המאמר ניהול של סוגי מידע באמצעות מסוף Google Cloud .

קבוצות כללים לבדיקה

קבוצות כללי הבדיקה מאפשרות לכם להתאים אישית את הגלאים המובנים והמותאמים אישית של נתוני infoType באמצעות כללי הקשר. סוגי כללי הבדיקה הם:

כדי להוסיף קבוצת כללים חדשה, קודם צריך לציין לפחות מזהה אחד מובנה או מותאם אישית של סוגי מידע בקטע InfoTypes. בוחרים את כל הגלאים של סוגי המידע שקבוצות הכללים משנות (סוגי המידע לחיפוש) או משתמשות בהם להערכה (סוגי המידע בהקשר). לאחר מכן, מבצעים את הפעולות הבאות:

  1. לוחצים על הוספת קבוצת כללים.
  2. בשדה Choose target infoTypes, בוחרים את סוגי המידע שקבוצת הכללים משנה אם הכללים מתקיימים.
  3. לוחצים על Add a rule כדי לפתוח תפריט עם אפשרויות, כולל כלל הרחבה (Hotword),‏ כלל להחרגה ו-Adjustment rule.

כדי ליצור כלל הרחבה (Hotword), בוחרים באפשרות כלל הרחבה (Hotword). לאחר מכן, מבצעים את הפעולות הבאות:

  1. בשדה Hotword, מזינים ביטוי רגולרי ש-Sensitive Data Protection יחפש.
  2. בתפריט Hotword proximity, בוחרים אם מילת ההפעלה שהזנתם נמצאת לפני או אחרי ה-infoType שנבחר.
  3. בשדה Hotword distance from infoType, מזינים את מספר התווים המשוער בין מילת ההפעלה לבין ה-infoType שנבחר.
  4. בקטע Confidence level adjustment, בוחרים אם להקצות להתאמות רמת סבירות קבועה, או להגדיל או להקטין את רמת הסבירות שמוגדרת כברירת מחדל בסכום מסוים.

כדי ליצור כלל החרגה, בוחרים באפשרות Exclusion rule ובסוג כלל ההחרגה שרוצים ליצור, למשל ביטוי רגולרי. לאחר מכן, מבצעים את הפעולות הבאות:

  1. בהתאם לסוג הכלל להחרגה שבחרתם, מזינים את הביטוי הרגולרי, הביטוי, מילת ההפעלה או סוג המידע לפי הקשר שצריך למצוא כדי שהכלל יחול.
  2. בהתאם לסוג הכלל להחרגה שבחרתם, מגדירים את סוג ההתאמה או את סוג ההכלה של התמונה:
    • אם בחרתם כלל החרגה שמבוסס על טקסט, בחרו אחד מסוגי ההתאמה הבאים:
      • התאמה מלאה: הממצא חייב להתאים באופן מלא לטקסט או ל-infoType של ההקשר שסיפקתם.
      • התאמה חלקית: מחרוזת משנה של הממצא צריכה להתאים לטקסט או ל-infoType של ההקשר שסיפקתם.
      • התאמה הפוכה: הממצא לא יכול להתאים לטקסט או ל-infoType של ההקשר שסיפקתם.
    • אם בחרתם כלל החרגה שמבוסס על תמונה, בחרו את היחס המרחבי הנדרש בין סוגי המידע הרגיש של היעד וההקשר. לדוגמה, אם בוחרים באפשרות Encloses, הממצא בהקשר חייב להכיל את ממצא היעד כדי שהכלל יחול.

כדי ליצור כלל התאמה, בוחרים באפשרות כלל התאמה ובסוג כלל ההתאמה, לדוגמה, התאמה לפי ממצאים בתמונות. לאחר מכן, מבצעים את הפעולות הבאות:

  1. בשדה Context infoTypes, בוחרים את הגלאים של סוגי המידע שמספקים הקשר לממצא היעד. ‫Sensitive Data Protection משתמש ב-infoTypes של הקשר כדי להעריך אם צריך לשנות את ה-infoType של היעד.
  2. בשדה Minimum likelihood, בוחרים את רמת הסבירות הנמוכה ביותר שיכולה להיות לסוגי המידע בהקשר, ועדיין להפעיל את כלל ההתאמה. אם ערך הסבירות של ממצא הקשר שזוהה נמוך מהערך הזה, Sensitive Data Protection לא משנה את הסבירות של ממצא היעד.
  3. בממצאים של תמונות, בשדה Image containment type בוחרים את הקשר המרחבי הנדרש בין סוגי המידע הרגיש של היעד וההקשר. לדוגמה, אם בוחרים באפשרות Encloses, הממצא של ההקשר חייב להכיל את ממצא היעד כדי שהכלל יחול.
  4. בשדה Likelihood, בוחרים את רמת הסבירות החדשה שרוצים להקצות לממצא היעד.

אתם יכולים להוסיף עוד קבוצות כללים כדי לשפר את תוצאות הסריקה.

סף ביטחון

בכל פעם ש-Sensitive Data Protection מזהה התאמה פוטנציאלית למידע אישי רגיש, הוא מקצה לה ערך סבירות בסולם שנע בין "סבירות נמוכה מאוד" ל "סבירות גבוהה מאוד". כשמגדירים כאן ערך סבירות, מנחים את Sensitive Data Protection להתאים רק נתונים שתואמים לערך הסבירות הזה או לערך גבוה יותר.

ערך ברירת המחדל Possible מספיק לרוב המטרות. אם אתם מקבלים באופן קבוע התאמות רחבות מדי, הזיזו את פס ההזזה למעלה. אם אתם מקבלים מעט מדי התאמות, הזיזו את פס ההזזה למטה.

כשמסיימים, לוחצים על יצירה כדי ליצור את התבנית. מופיע דף סיכום המידע של התבנית.

כדי לחזור לדף הראשי של Sensitive Data Protection, לוחצים על החץ Back במסוף Google Cloud .

C#

במאמר ספריות הלקוח של Sensitive Data Protection מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Sensitive Data Protection.

כדי לבצע אימות ב-Sensitive Data Protection, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 


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

public class InspectTemplateCreate
{
    public static InspectTemplate Create(
        string projectId,
        string templateId,
        string displayName,
        string description,
        Likelihood likelihood,
        int maxFindings,
        bool includeQuote)
    {
        var client = DlpServiceClient.Create();

        var request = new CreateInspectTemplateRequest
        {
            Parent = new LocationName(projectId, "global").ToString(),
            InspectTemplate = new InspectTemplate
            {
                DisplayName = displayName,
                Description = description,
                InspectConfig = new InspectConfig
                {
                    MinLikelihood = likelihood,
                    Limits = new InspectConfig.Types.FindingLimits
                    {
                        MaxFindingsPerRequest = maxFindings
                    },
                    IncludeQuote = includeQuote
                },
            },
            TemplateId = templateId
        };

        var response = client.CreateInspectTemplate(request);

        Console.WriteLine($"Successfully created template {response.Name}.");

        return response;
    }
}

Go

במאמר ספריות הלקוח של Sensitive Data Protection מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Sensitive Data Protection.

כדי לבצע אימות ב-Sensitive Data Protection, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 

import (
	"context"
	"fmt"
	"io"

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

// createInspectTemplate creates a template with the given configuration.
func createInspectTemplate(w io.Writer, projectID string, templateID, displayName, description string, infoTypeNames []string) error {
	// projectID := "my-project-id"
	// templateID := "my-template"
	// displayName := "My Template"
	// description := "My template description"
	// infoTypeNames := []string{"US_SOCIAL_SECURITY_NUMBER"}

	ctx := context.Background()

	client, err := dlp.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("dlp.NewClient: %w", err)
	}
	defer client.Close()

	// Convert the info type strings to a list of InfoTypes.
	var infoTypes []*dlppb.InfoType
	for _, it := range infoTypeNames {
		infoTypes = append(infoTypes, &dlppb.InfoType{Name: it})
	}

	// Create a configured request.
	req := &dlppb.CreateInspectTemplateRequest{
		Parent:     fmt.Sprintf("projects/%s/locations/global", projectID),
		TemplateId: templateID,
		InspectTemplate: &dlppb.InspectTemplate{
			DisplayName: displayName,
			Description: description,
			InspectConfig: &dlppb.InspectConfig{
				InfoTypes:     infoTypes,
				MinLikelihood: dlppb.Likelihood_POSSIBLE,
				Limits: &dlppb.InspectConfig_FindingLimits{
					MaxFindingsPerRequest: 10,
				},
			},
		},
	}
	// Send the request.
	resp, err := client.CreateInspectTemplate(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateInspectTemplate: %w", err)
	}
	// Print the result.
	fmt.Fprintf(w, "Successfully created inspect template: %v", resp.GetName())
	return nil
}

Java

במאמר ספריות הלקוח של Sensitive Data Protection מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Sensitive Data Protection.

כדי לבצע אימות ב-Sensitive Data Protection, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.CreateInspectTemplateRequest;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectTemplate;
import com.google.privacy.dlp.v2.LocationName;
import java.io.IOException;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

class TemplatesCreate {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    createInspectTemplate(projectId);
  }

  // Creates a template to persist configuration information
  public static void createInspectTemplate(String projectId) 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 dlpServiceClient = DlpServiceClient.create()) {
      // Specify the type of info the inspection will look for.
      // See https://cloud.google.com/dlp/docs/infotypes-reference for complete list of info types
      List<InfoType> infoTypes =
          Stream.of("PHONE_NUMBER", "EMAIL_ADDRESS", "CREDIT_CARD_NUMBER")
              .map(it -> InfoType.newBuilder().setName(it).build())
              .collect(Collectors.toList());

      // Construct the inspection configuration for the template
      InspectConfig inspectConfig = InspectConfig.newBuilder().addAllInfoTypes(infoTypes).build();

      // Optionally set a display name and a description for the template
      String displayName = "Inspection Config Template";
      String description = "Save configuration for future inspection jobs";

      // Build the template
      InspectTemplate inspectTemplate =
          InspectTemplate.newBuilder()
              .setInspectConfig(inspectConfig)
              .setDisplayName(displayName)
              .setDescription(description)
              .build();

      // Create the request to be sent by the client
      CreateInspectTemplateRequest createInspectTemplateRequest =
          CreateInspectTemplateRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setInspectTemplate(inspectTemplate)
              .build();

      // Send the request to the API and process the response
      InspectTemplate response =
          dlpServiceClient.createInspectTemplate(createInspectTemplateRequest);
      System.out.printf("Template created: %s", response.getName());
    }
  }
}

Node.js

במאמר ספריות הלקוח של Sensitive Data Protection מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Sensitive Data Protection.

כדי לבצע אימות ב-Sensitive Data Protection, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 

// 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 = 'my-project';

// The minimum likelihood required before returning a match
// const minLikelihood = 'LIKELIHOOD_UNSPECIFIED';

// The maximum number of findings to report per request (0 = server maximum)
// const maxFindings = 0;

// The infoTypes of information to match
// const infoTypes = [{ name: 'PHONE_NUMBER' }, { name: 'EMAIL_ADDRESS' }, { name: 'CREDIT_CARD_NUMBER' }];

// Whether to include the matching string
// const includeQuote = true;

// (Optional) The name of the template to be created.
// const templateId = 'my-template';

// (Optional) The human-readable name to give the template
// const displayName = 'My template';

async function createInspectTemplate() {
  // Construct the inspection configuration for the template
  const inspectConfig = {
    infoTypes: infoTypes,
    minLikelihood: minLikelihood,
    includeQuote: includeQuote,
    limits: {
      maxFindingsPerRequest: maxFindings,
    },
  };

  // Construct template-creation request
  const request = {
    parent: `projects/${projectId}/locations/global`,
    inspectTemplate: {
      inspectConfig: inspectConfig,
      displayName: displayName,
    },
    templateId: templateId,
  };

  const [response] = await dlp.createInspectTemplate(request);
  const templateName = response.name;
  console.log(`Successfully created template ${templateName}.`);
}
createInspectTemplate();

PHP

במאמר ספריות הלקוח של Sensitive Data Protection מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Sensitive Data Protection.

כדי לבצע אימות ב-Sensitive Data Protection, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 

use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\CreateInspectTemplateRequest;
use Google\Cloud\Dlp\V2\InfoType;
use Google\Cloud\Dlp\V2\InspectConfig;
use Google\Cloud\Dlp\V2\InspectConfig\FindingLimits;
use Google\Cloud\Dlp\V2\InspectTemplate;
use Google\Cloud\Dlp\V2\Likelihood;

/**
 * Create a new DLP inspection configuration template.
 *
 * @param string $callingProjectId project ID to run the API call under
 * @param string $templateId       name of the template to be created
 * @param string $displayName      (Optional) The human-readable name to give the template
 * @param string $description      (Optional) A description for the trigger to be created
 * @param int    $maxFindings      (Optional) The maximum number of findings to report per request (0 = server maximum)
 */
function create_inspect_template(
    string $callingProjectId,
    string $templateId,
    string $displayName = '',
    string $description = '',
    int $maxFindings = 0
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // ----- Construct inspection config -----
    // The infoTypes of information to match
    $personNameInfoType = (new InfoType())
        ->setName('PERSON_NAME');
    $phoneNumberInfoType = (new InfoType())
        ->setName('PHONE_NUMBER');
    $infoTypes = [$personNameInfoType, $phoneNumberInfoType];

    // Whether to include the matching string in the response
    $includeQuote = true;

    // The minimum likelihood required before returning a match
    $minLikelihood = likelihood::LIKELIHOOD_UNSPECIFIED;

    // Specify finding limits
    $limits = (new FindingLimits())
        ->setMaxFindingsPerRequest($maxFindings);

    // Create the configuration object
    $inspectConfig = (new InspectConfig())
        ->setMinLikelihood($minLikelihood)
        ->setLimits($limits)
        ->setInfoTypes($infoTypes)
        ->setIncludeQuote($includeQuote);

    // Construct inspection template
    $inspectTemplate = (new InspectTemplate())
        ->setInspectConfig($inspectConfig)
        ->setDisplayName($displayName)
        ->setDescription($description);

    // Run request
    $parent = "projects/$callingProjectId/locations/global";
    $createInspectTemplateRequest = (new CreateInspectTemplateRequest())
        ->setParent($parent)
        ->setInspectTemplate($inspectTemplate)
        ->setTemplateId($templateId);
    $template = $dlp->createInspectTemplate($createInspectTemplateRequest);

    // Print results
    printf('Successfully created template %s' . PHP_EOL, $template->getName());
}

Python

במאמר ספריות הלקוח של Sensitive Data Protection מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Sensitive Data Protection.

כדי לבצע אימות ב-Sensitive Data Protection, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 

from typing import List
from typing import Optional

import google.cloud.dlp


def create_inspect_template(
    project: str,
    info_types: List[str],
    template_id: Optional[str] = None,
    display_name: Optional[str] = None,
    min_likelihood: Optional[int] = None,
    max_findings: Optional[int] = None,
    include_quote: Optional[bool] = None,
) -> None:
    """Creates a Data Loss Prevention API inspect template.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        info_types: A list of strings representing info types to look for.
            A full list of info type categories can be fetched from the API.
        template_id: The id of the template. If omitted, an id will be randomly
            generated.
        display_name: The optional display name of the template.
        min_likelihood: A string representing the minimum likelihood threshold
            that constitutes a match. One of: 'LIKELIHOOD_UNSPECIFIED',
            'VERY_UNLIKELY', 'UNLIKELY', 'POSSIBLE', 'LIKELY', 'VERY_LIKELY'.
        max_findings: The maximum number of findings to report; 0 = no maximum.
        include_quote: Boolean for whether to display a quote of the detected
            information in the results.
    Returns:
        None; the response from the API is printed to the terminal.
    """

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

    # Prepare info_types by converting the list of strings into a list of
    # dictionaries (protos are also accepted).
    info_types = [{"name": info_type} for info_type in info_types]

    # Construct the configuration dictionary. Keys which are None may
    # optionally be omitted entirely.
    inspect_config = {
        "info_types": info_types,
        "min_likelihood": min_likelihood,
        "include_quote": include_quote,
        "limits": {"max_findings_per_request": max_findings},
    }

    inspect_template = {
        "inspect_config": inspect_config,
        "display_name": display_name,
    }

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

    # Call the API.
    response = dlp.create_inspect_template(
        request={
            "parent": parent,
            "inspect_template": inspect_template,
            "template_id": template_id,
        }
    )

    print(f"Successfully created template {response.name}")

REST

תבנית בדיקה היא הגדרת בדיקה שאפשר לעשות בה שימוש חוזר, בתוספת מטא-נתונים. במונחי API, האובייקט InspectTemplate הוא למעשה אובייקט InspectConfig שכולל עוד כמה שדות של מטא-נתונים, כמו שם לתצוגה ותיאור. לכן, כדי ליצור תבנית בדיקה חדשה, השלבים הבסיסיים הם:

  1. מתחילים עם אובייקט InspectConfig.
  2. שולחים בקשה מסוג POST או קוראים ל-method‏ create של המשאב projects.inspectTemplates או organizations.inspectTemplates. הבקשה צריכה לכלול אובייקט InspectTemplate שמכיל שם לתצוגה, תיאור ואת האובייקט InspectConfig.

ה-InspectTemplate שהוחזר יהיה מוכן לשימוש באופן מיידי. אפשר להפנות אליו בקריאות או במשימות אחרות באמצעות ה-name שלו. כדי להציג את התבניות הקיימות, אפשר להפעיל את ה-method‏ *.inspectTemplates.list. כדי לראות תבנית ספציפית, מפעילים את ה-method‏ *.inspectTemplates.get. שימו לב: אפשר ליצור עד 1,000 תבניות.

אם כבר יש לכם ניסיון בבדיקת טקסט, תמונות או תוכן מובנה כדי לאתר מידע רגיש באמצעות Sensitive Data Protection, כבר יצרתם אובייקט InspectConfig. שלב אחד נוסף הופך אותו לאובייקט InspectTemplate.

קובץ ה-JSON הבא הוא דוגמה למה שאפשר לשלוח ל-method‏ projects.inspectTemplates.create. קובץ ה-JSON הזה יוצר תבנית חדשה עם השם המוצג והתיאור שצוינו, וסורק התאמות ל-infoTypes‏ PHONE_NUMBER ו-US_TOLLFREE_PHONE_NUMBER. הוא כולל בממצאים שלו עד 100 התאמות שהסבירות שלהן היא לפחות POSSIBLE, וכולל קטע הקשר לכל אחת מהן. בחומר העזר בנושא גילוי InfoType אפשר למצוא פרטים נוספים על סוגי המידע (infoTypes) שאפשר לציין בתבניות הבדיקה.

קלט JSON:

POST https://dlp.googleapis.com/v2/projects/[PROJECT_ID]/inspectTemplates?key={YOUR_API_KEY}

{
  "inspectTemplate":{
    "displayName":"Phone number inspection",
    "description":"Scans for phone numbers",
    "inspectConfig":{
      "infoTypes":[
        {
          "name":"PHONE_NUMBER"
        },
        {
          "name":"US_TOLLFREE_PHONE_NUMBER"
        }
      ],
      "minLikelihood":"POSSIBLE",
      "limits":{
        "maxFindingsPerRequest":100
      },
      "includeQuote":true
    }
  }
}

פלט מסוג JSON:

התגובה ב-JSON נראית כך:

{
  "name":"projects/[PROJECT_ID]/inspectTemplates/[JOB_ID]",
  "displayName":"Phone number inspection",
  "description":"Scans for phone numbers",
  "createTime":"2018-11-30T07:26:28.164136Z",
  "updateTime":"2018-11-30T07:26:28.164136Z",
  "inspectConfig":{
    "infoTypes":[
      {
        "name":"PHONE_NUMBER"
      },
      {
        "name":"US_TOLLFREE_PHONE_NUMBER"
      }
    ],
    "minLikelihood":"POSSIBLE",
    "limits":{
      "maxFindingsPerRequest":100
    },
    "includeQuote":true
  }
}

כדי לנסות את זה במהירות, אתם יכולים להשתמש ב-APIs Explorer שמוטמע בהמשך. מידע כללי על השימוש ב-JSON לשליחת בקשות ל-DLP API מופיע במדריך למתחילים בנושא JSON.

שימוש בתבניות בדיקה

אחרי שיוצרים תבנית בדיקה חדשה, אפשר להשתמש בה כשיוצרים משימת בדיקה חדשה או טריגר חדש להפעלה של משימה. בכל פעם שמעדכנים את התבנית, היא מתעדכנת בכל טריגר של משימה שמשתמש בה. למידע נוסף, כולל דוגמאות קוד, תוכלו לקרוא את המאמרים הבאים:

המסוף

כדי להתחיל להשתמש במהירות בתבנית החדשה, פועלים לפי ההוראות במאמר התחלה מהירה: יצירת תבנית לבדיקה של Sensitive Data Protection, עם השינוי הבא:

  • בקטע Configure detection > Templates, לוחצים על השדה Template name ובוחרים את התבנית שיצרתם.

במאמר יצירה ותזמון של משימות בדיקה ב-Sensitive Data Protection מוסבר בהרחבה איך לסרוק את התוכן. שימו לב במיוחד לקטע הגדרת הזיהוי.

REST

אפשר להשתמש במזהה התבנית שציינתם כשיצרתם את התבנית בכל מקום שבו אפשר להשתמש ב-inspectTemplateName, למשל:

  • ‫projects.content.inspect: חיפוש מידע אישי רגיש בתוכן באמצעות התבנית כהגדרה.
  • ‫projects.content.deidentify: מאתרת ומסירה את פרטי הזיהוי של נתונים שעלולים להיות רגישים בתוכן, באמצעות התבנית כהגדרה שלה. חשוב לדעת שבשיטה הזו משתמשים גם בתבנית בדיקה וגם בתבנית להסרת פרטים מזהים.
  • ‫projects.dlpJobs.create, באובייקט InspectJobConfig: יוצרת משימת בדיקה שכוללת את התבנית כהגדרה שלה.

רשימת תבניות בדיקה

כדי להציג רשימה של כל תבניות הבדיקה שנוצרו בפרויקט או בארגון הנוכחיים:

המסוף

  1. נכנסים לדף Configuration של Sensitive Data Protection במסוף Google Cloud .

    מעבר להגדרות

  2. בוחרים את הפרויקט שמכיל את תבניות הבדיקה.

  3. לוחצים על הכרטיסייה תבניות.

במסוף תוצג רשימה של כל תבניות הבדיקה בפרויקט הנוכחי.

C#

במאמר ספריות הלקוח של Sensitive Data Protection מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Sensitive Data Protection.

כדי לבצע אימות ב-Sensitive Data Protection, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 


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

public class InspectTemplateList
{
    public static PagedEnumerable<ListInspectTemplatesResponse, InspectTemplate> List(string projectId)
    {
        var client = DlpServiceClient.Create();

        var response = client.ListInspectTemplates(
            new ListInspectTemplatesRequest
            {
                Parent = new LocationName(projectId, "global").ToString(),
            }
        );

        // Uncomment to list templates
        //PrintTemplates(response);

        return response;
    }

    public static void PrintTemplates(PagedEnumerable<ListInspectTemplatesResponse, InspectTemplate> response)
    {
        foreach (var template in response)
        {
            Console.WriteLine($"Template {template.Name}:");
            Console.WriteLine($"\tDisplay Name: {template.DisplayName}");
            Console.WriteLine($"\tDescription: {template.Description}");
            Console.WriteLine($"\tCreated: {template.CreateTime}");
            Console.WriteLine($"\tUpdated: {template.UpdateTime}");
            Console.WriteLine("Configuration:");
            Console.WriteLine($"\tMin Likelihood: {template.InspectConfig?.MinLikelihood}");
            Console.WriteLine($"\tInclude quotes: {template.InspectConfig?.IncludeQuote}");
            Console.WriteLine($"\tMax findings per request: {template.InspectConfig?.Limits.MaxFindingsPerRequest}");
        }
    }
}

Go

במאמר ספריות הלקוח של Sensitive Data Protection מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Sensitive Data Protection.

כדי לבצע אימות ב-Sensitive Data Protection, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 

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

	dlp "cloud.google.com/go/dlp/apiv2"
	"cloud.google.com/go/dlp/apiv2/dlppb"
	"github.com/golang/protobuf/ptypes"
	"google.golang.org/api/iterator"
)

// listInspectTemplates lists the inspect templates in the project.
func listInspectTemplates(w io.Writer, projectID string) error {
	// projectID := "my-project-id"

	ctx := context.Background()

	client, err := dlp.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("dlp.NewClient: %w", err)
	}
	defer client.Close()

	// Create a configured request.
	req := &dlppb.ListInspectTemplatesRequest{
		Parent: fmt.Sprintf("projects/%s/locations/global", projectID),
	}

	// Send the request and iterate over the results.
	it := client.ListInspectTemplates(ctx, req)
	for {
		t, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("Next: %w", err)
		}
		fmt.Fprintf(w, "Inspect template %v\n", t.GetName())
		c, err := ptypes.Timestamp(t.GetCreateTime())
		if err != nil {
			return fmt.Errorf("CreateTime Timestamp: %w", err)
		}
		fmt.Fprintf(w, "  Created: %v\n", c.Format(time.RFC1123))
		u, err := ptypes.Timestamp(t.GetUpdateTime())
		if err != nil {
			return fmt.Errorf("UpdateTime Timestamp: %w", err)
		}
		fmt.Fprintf(w, "  Updated: %v\n", u.Format(time.RFC1123))
		fmt.Fprintf(w, "  Display Name: %q\n", t.GetDisplayName())
		fmt.Fprintf(w, "  Description: %q\n", t.GetDescription())
	}

	return nil
}

Java

במאמר ספריות הלקוח של Sensitive Data Protection מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Sensitive Data Protection.

כדי לבצע אימות ב-Sensitive Data Protection, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.cloud.dlp.v2.DlpServiceClient.ListInspectTemplatesPagedResponse;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectTemplate;
import com.google.privacy.dlp.v2.ListInspectTemplatesRequest;
import com.google.privacy.dlp.v2.LocationName;
import java.io.IOException;

class TemplatesList {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    listInspectTemplates(projectId);
  }

  // Lists all templates associated with a given project
  public static void listInspectTemplates(String projectId) 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 dlpServiceClient = DlpServiceClient.create()) {

      // Create the request to be sent by the client
      ListInspectTemplatesRequest request =
          ListInspectTemplatesRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setPageSize(1)
              .build();

      // Send the request
      ListInspectTemplatesPagedResponse response = dlpServiceClient.listInspectTemplates(request);

      // Parse through and process the response
      System.out.println("Templates found:");
      for (InspectTemplate template : response.getPage().getResponse().getInspectTemplatesList()) {
        System.out.printf("Template name: %s\n", template.getName());
        if (template.getDisplayName() != null) {
          System.out.printf("\tDisplay name: %s \n", template.getDisplayName());
          System.out.printf("\tCreate time: %s \n", template.getCreateTime());
          System.out.printf("\tUpdate time: %s \n", template.getUpdateTime());

          // print inspection config
          InspectConfig inspectConfig = template.getInspectConfig();
          for (InfoType infoType : inspectConfig.getInfoTypesList()) {
            System.out.printf("\tInfoType: %s\n", infoType.getName());
          }
          System.out.printf("\tMin likelihood: %s\n", inspectConfig.getMinLikelihood());
          System.out.printf("\tLimits: %s\n", inspectConfig.getLimits().getMaxFindingsPerRequest());
        }
      }
    }
  }
}

Node.js

במאמר ספריות הלקוח של Sensitive Data Protection מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Sensitive Data Protection.

כדי לבצע אימות ב-Sensitive Data Protection, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 

// 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 = 'my-project';

// Helper function to pretty-print dates
const formatDate = date => {
  const msSinceEpoch = parseInt(date.seconds, 10) * 1000;
  return new Date(msSinceEpoch).toLocaleString('en-US');
};

async function listInspectTemplates() {
  // Construct template-listing request
  const request = {
    parent: `projects/${projectId}/locations/global`,
  };

  // Run template-deletion request
  const [templates] = await dlp.listInspectTemplates(request);

  templates.forEach(template => {
    console.log(`Template ${template.name}`);
    if (template.displayName) {
      console.log(`  Display name: ${template.displayName}`);
    }

    console.log(`  Created: ${formatDate(template.createTime)}`);
    console.log(`  Updated: ${formatDate(template.updateTime)}`);

    const inspectConfig = template.inspectConfig;
    const infoTypes = inspectConfig.infoTypes.map(x => x.name);
    console.log('  InfoTypes:', infoTypes.join(' '));
    console.log('  Minimum likelihood:', inspectConfig.minLikelihood);
    console.log('  Include quotes:', inspectConfig.includeQuote);

    const limits = inspectConfig.limits;
    console.log('  Max findings per request:', limits.maxFindingsPerRequest);
  });
}

listInspectTemplates();

PHP

במאמר ספריות הלקוח של Sensitive Data Protection מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Sensitive Data Protection.

כדי לבצע אימות ב-Sensitive Data Protection, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 

use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\ListInspectTemplatesRequest;

/**
 * List DLP inspection configuration templates.
 *
 * @param string $callingProjectId  The project ID to run the API call under
 */
function list_inspect_templates(string $callingProjectId): void
{
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    $parent = "projects/$callingProjectId/locations/global";

    // Run request
    $listInspectTemplatesRequest = (new ListInspectTemplatesRequest())
        ->setParent($parent);
    $response = $dlp->listInspectTemplates($listInspectTemplatesRequest);

    // Print results
    $templates = $response->iterateAllElements();

    foreach ($templates as $template) {
        printf('Template %s' . PHP_EOL, $template->getName());
        printf('  Created: %s' . PHP_EOL, $template->getCreateTime()->getSeconds());
        printf('  Updated: %s' . PHP_EOL, $template->getUpdateTime()->getSeconds());
        printf('  Display Name: %s' . PHP_EOL, $template->getDisplayName());
        printf('  Description: %s' . PHP_EOL, $template->getDescription());

        $inspectConfig = $template->getInspectConfig();
        if ($inspectConfig === null) {
            print('  No inspect config.' . PHP_EOL);
        } else {
            printf('  Minimum likelihood: %s' . PHP_EOL, $inspectConfig->getMinLikelihood());
            printf('  Include quotes: %s' . PHP_EOL, $inspectConfig->getIncludeQuote());
            $limits = $inspectConfig->getLimits();
            printf('  Max findings per request: %s' . PHP_EOL, $limits->getMaxFindingsPerRequest());
        }
    }
}

Python

במאמר ספריות הלקוח של Sensitive Data Protection מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Sensitive Data Protection.

כדי לבצע אימות ב-Sensitive Data Protection, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 

import google.cloud.dlp


def list_inspect_templates(project: str) -> None:
    """Lists all Data Loss Prevention API inspect templates.
    Args:
        project: The Google Cloud project id to use as a parent resource.
    Returns:
        None; the response from the API is printed to the terminal.
    """

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

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

    # Call the API.
    response = dlp.list_inspect_templates(request={"parent": parent})

    for template in response:
        print(f"Template {template.name}:")
        if template.display_name:
            print(f"  Display Name: {template.display_name}")
        print(f"  Created: {template.create_time}")
        print(f"  Updated: {template.update_time}")

        config = template.inspect_config
        print(
            "  InfoTypes: {}".format(", ".join([it.name for it in config.info_types]))
        )
        print(f"  Minimum likelihood: {config.min_likelihood}")
        print(f"  Include quotes: {config.include_quote}")
        print(
            "  Max findings per request: {}".format(
                config.limits.max_findings_per_request
            )
        )

REST

משתמשים באחת מהשיטות של *.*.list:

העתקת תבנית בדיקה לאזור global

  1. נכנסים לדף Configuration של Sensitive Data Protection במסוף Google Cloud .

    מעבר להגדרות

  2. בסרגל הכלים, לוחצים על בורר הפרויקטים ובוחרים את הפרויקט שמכיל את תבנית הבדיקה שבה רוצים להשתמש.

  3. לוחצים על הכרטיסייה תבניות ואז על כרטיסיית המשנה בדיקה.

  4. לוחצים על המזהה של התבנית שבה רוצים להשתמש.

  5. בדף Inspection template details, לוחצים על Copy.

  6. בדף Create template, ברשימה Resource location בוחרים באפשרות Global (any region).

  7. לוחצים על יצירה.

התבנית מועתקת לאזור global.

העתקת תבנית בדיקה לפרויקט אחר

  1. נכנסים לדף Configuration של Sensitive Data Protection במסוף Google Cloud .

    מעבר להגדרות

  2. בסרגל הכלים, לוחצים על בורר הפרויקטים ובוחרים את הפרויקט שמכיל את תבנית הבדיקה שבה רוצים להשתמש.

  3. לוחצים על הכרטיסייה תבניות ואז על כרטיסיית המשנה בדיקה.

  4. לוחצים על המזהה של התבנית שבה רוצים להשתמש.

  5. בדף Inspection template details, לוחצים על Copy.

  6. בוחרים את הפרויקט שאליו רוצים להעתיק את תבנית הבדיקה.

    הדף Create template נטען מחדש בפרויקט שבחרתם.

  7. לוחצים על יצירה.

התבנית נוצרת בפרויקט שבחרתם.

מחיקת תבניות בדיקה

כדי למחוק תבנית בדיקה:

המסוף

  1. נכנסים לדף Configuration של Sensitive Data Protection במסוף Google Cloud .

    מעבר להגדרות

  2. בוחרים את הפרויקט שמכיל את תבנית הבדיקה שרוצים למחוק.

  3. לוחצים על הכרטיסייה תבניות. במסוף תוצג רשימה של כל התבניות בפרויקט הנוכחי.

  4. בעמודה Actions של התבנית שרוצים למחוק, לוחצים על סמל האפשרויות הנוספות (שלוש נקודות אנכיות) ואז על Delete.

אפשר גם ללחוץ על שם התבנית שרוצים למחוק ברשימת התבניות. בדף הפרטים של התבנית, לוחצים על מחיקה.

C#

במאמר ספריות הלקוח של Sensitive Data Protection מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Sensitive Data Protection.

כדי לבצע אימות ב-Sensitive Data Protection, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 


using Google.Cloud.Dlp.V2;
using System;

public class InspectTemplateDelete
{
    public static object Delete(string projectId, string templateName)
    {
        var client = DlpServiceClient.Create();

        var request = new DeleteInspectTemplateRequest
        {
            Name = templateName
        };

        client.DeleteInspectTemplate(request);
        Console.WriteLine($"Successfully deleted template {templateName}.");

        return templateName;
    }
}

Go

במאמר ספריות הלקוח של Sensitive Data Protection מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Sensitive Data Protection.

כדי לבצע אימות ב-Sensitive Data Protection, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 

import (
	"context"
	"fmt"
	"io"

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

// deleteInspectTemplate deletes the given template.
func deleteInspectTemplate(w io.Writer, templateID string) error {
	// projectID := "my-project-id"
	// templateID := "my-template"

	ctx := context.Background()

	client, err := dlp.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("dlp.NewClient: %w", err)
	}
	defer client.Close()

	req := &dlppb.DeleteInspectTemplateRequest{
		Name: templateID,
	}

	if err := client.DeleteInspectTemplate(ctx, req); err != nil {
		return fmt.Errorf("DeleteInspectTemplate: %w", err)
	}
	fmt.Fprintf(w, "Successfully deleted inspect template %v", templateID)
	return nil
}

Java

במאמר ספריות הלקוח של Sensitive Data Protection מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Sensitive Data Protection.

כדי לבצע אימות ב-Sensitive Data Protection, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.DeleteInspectTemplateRequest;
import java.io.IOException;

class TemplatesDelete {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String templateId = "your-template-id";
    deleteInspectTemplate(projectId, templateId);
  }

  // Delete an existing template
  public static void deleteInspectTemplate(String projectId, String templateId) throws IOException {
    // Construct the template name to be deleted
    String templateName = String.format("projects/%s/inspectTemplates/%s", projectId, templateId);

    // 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 dlpServiceClient = DlpServiceClient.create()) {

      // Create delete template request to be sent by the client
      DeleteInspectTemplateRequest request =
          DeleteInspectTemplateRequest.newBuilder().setName(templateName).build();

      // Send the request with the client
      dlpServiceClient.deleteInspectTemplate(request);
      System.out.printf("Deleted template: %s\n", templateName);
    }
  }
}

Node.js

במאמר ספריות הלקוח של Sensitive Data Protection מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Sensitive Data Protection.

כדי לבצע אימות ב-Sensitive Data Protection, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 

// 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 = 'my-project';

// The name of the template to delete
// Parent project ID is automatically extracted from this parameter
// const templateName = 'projects/YOUR_PROJECT_ID/inspectTemplates/#####'
async function deleteInspectTemplate() {
  // Construct template-deletion request
  const request = {
    name: templateName,
  };

  // Run template-deletion request
  await dlp.deleteInspectTemplate(request);
  console.log(`Successfully deleted template ${templateName}.`);
}

deleteInspectTemplate();

PHP

במאמר ספריות הלקוח של Sensitive Data Protection מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Sensitive Data Protection.

כדי לבצע אימות ב-Sensitive Data Protection, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 

use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\DeleteInspectTemplateRequest;

/**
 * Delete a DLP inspection configuration template.
 *
 * @param string $callingProjectId  The project ID to run the API call under
 * @param string $templateId        The name of the template to delete
 */
function delete_inspect_template(
    string $callingProjectId,
    string $templateId
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // Run template deletion request
    $templateName = "projects/$callingProjectId/locations/global/inspectTemplates/$templateId";
    $deleteInspectTemplateRequest = (new DeleteInspectTemplateRequest())
        ->setName($templateName);
    $dlp->deleteInspectTemplate($deleteInspectTemplateRequest);

    // Print results
    printf('Successfully deleted template %s' . PHP_EOL, $templateName);
}

Python

במאמר ספריות הלקוח של Sensitive Data Protection מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Sensitive Data Protection.

כדי לבצע אימות ב-Sensitive Data Protection, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 

import google.cloud.dlp


def delete_inspect_template(project: str, template_id: str) -> None:
    """Deletes a Data Loss Prevention API template.
    Args:
        project: The id of the Google Cloud project which owns the template.
        template_id: The id of the template to delete.
    Returns:
        None; the response from the API is printed to the terminal.
    """

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

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

    # Combine the template id with the parent id.
    template_resource = f"{parent}/inspectTemplates/{template_id}"

    # Call the API.
    dlp.delete_inspect_template(request={"name": template_resource})

    print(f"Template {template_resource} successfully deleted.")

REST

משתמשים באחת מהשיטות של *.*.delete:

בכל שיטת *.*.delete, אתם כוללים את שם המשאב של התבנית שאתם רוצים למחוק.

המאמרים הבאים