Creazione di modelli di anonimizzazione Sensitive Data Protection

Puoi utilizzare i modelli per creare e mantenere le informazioni di configurazione da utilizzare con Sensitive Data Protection. I modelli sono utili per disaccoppiare la configurazione, ad esempio gli elementi da ispezionare e le modalità di anonimizzazione, dall'implementazione delle richieste. I modelli offrono un modo affidabile per riutilizzare la configurazione e garantire la coerenza tra utenti e set di dati.

Sensitive Data Protection supporta due tipi di modelli:

  • Modelli di anonimizzazione: modelli per salvare le informazioni di configurazione per i job di anonimizzazione, incluse le trasformazioni di infoType e record (set di dati strutturati).
  • Modelli di ispezione: modelli per la persistenza delle informazioni di configurazione per i job di scansione di ispezione, inclusi i rilevatori predefiniti o personalizzati da utilizzare. Per saperne di più sui modelli di ispezione, vedi Creare modelli di ispezione di Sensitive Data Protection.

Per informazioni concettuali sui modelli in Sensitive Data Protection, consulta Modelli.

Il resto di questo argomento spiega come creare modelli di anonimizzazione da utilizzare con Sensitive Data Protection.

Creare un modello di anonimizzazione

Console

Nella console Google Cloud, vai alla pagina Crea modello.

Vai a Crea modello

Le sezioni seguenti descrivono come compilare la pagina Crea modello.

Definisci modello

Nella sezione Definisci modello, compila i campi come segue:

  1. In Tipo di modello, seleziona Anonimizza (rimuovi dati sensibili).

  2. In Tipo di trasformazione dati, seleziona il tipo di trasformazione da applicare:

    • InfoType. Sensitive Data Protection applica ogni trasformazione solo al valore identificato come infoType specifico. Questo tipo di trasformazione è utile per il testo non strutturato.

    • Registra. Sensitive Data Protection prende in considerazione il formato strutturato dei dati quando applica una trasformazione. Questo tipo di trasformazione è utile per i dati tabulari.

    • Immagine. Sensitive Data Protection oscura tutto il testo rilevato in un'immagine o solo il testo che corrisponde a un infoType specifico.

  3. In ID modello, inserisci un identificatore univoco per il modello.

  4. In Nome visualizzato, inserisci un nome per il modello.

  5. In Descrizione, descrivi il modello.

  6. In Località della risorsa, seleziona Globale o la località dei dati che vuoi anonimizzare.

  7. Fai clic su Continua.

Configura anonimizzazione

La selezione dei campi visualizzati in Configura anonimizzazione si basa sul tipo di trasformazione dei dati scelto.

InfoType

Se hai selezionato InfoType come tipo di trasformazione dati, svolgi i seguenti passaggi:

  1. Nel campo Trasformazione, seleziona un metodo di trasformazione da applicare ai risultati.

    Vengono visualizzati altri campi in base alla tua selezione. Compila i campi come necessario. Per ulteriori informazioni, consulta Riferimento per la trasformazione.

  2. Nella sezione InfoType da trasformare, specifica se vuoi applicare la trasformazione a tutti gli infoType rilevati definiti nella configurazione dell'ispezione.

    Se selezioni Specifica infoType, seleziona gli infoType a cui vuoi applicare il metodo di trasformazione.

  3. Se vuoi aggiungere regole di trasformazione per gli infoType non coperti dalla tua regola di trasformazione, fai clic su Aggiungi regola di trasformazione. Poi, compila i campi in base alle tue esigenze. Ripeti questo passaggio finché non hai configurato una regola di trasformazione per tutti gli infoType che vuoi trasformare.

  4. Fai clic su Crea.

Registra

Se hai selezionato Record come tipo di trasformazione dei dati, svolgi i seguenti passaggi:

  1. In Campi o colonne da trasformare, digita il nome della colonna della tabella contenente i dati da trasformare. Premi ENTER. Ripeti questo passaggio per ogni colonna contenente i dati da trasformare.

  2. Specifica il tipo di trasformazione:

    • Corrispondenza in base a infoType. Sensitive Data Protection tratta ogni cella come testo non strutturato e applica la trasformazione solo agli infoType che trova nella cella. Sensitive Data Protection non trasforma alcun dato correlato a un infoType.

      Se selezioni questa opzione, procedi nel seguente modo:

      1. Fai clic su Aggiungi trasformazione. Nel campo Trasformazione, seleziona un metodo di trasformazione da applicare ai risultati.

      2. Specifica se vuoi applicare la trasformazione a tutti gli infoType rilevati definiti nella configurazione dell'ispezione.

        Se selezioni Specifica gli infoType, seleziona gli infoType a cui vuoi applicare la regola di trasformazione.

      Se vuoi assegnare determinate regole di trasformazione a determinati infoType, puoi aggiungere altre trasformazioni in base alle esigenze.

    • Trasformazione dei campi primitivi. Sensitive Data Protection trasforma sempre l'intera cella in base a un metodo di trasformazione scelto da te. Questa opzione è utile se vuoi trasformare intere colonne di dati, indipendentemente dal fatto che nelle celle di queste colonne siano stati rilevati infoType.

      Se selezioni questa opzione, nel campo Trasformazione, seleziona un metodo di trasformazione da applicare alle colonne specificate.

    In entrambi i casi, vengono visualizzati più campi in base al metodo di trasformazione selezionato. Compila i campi in base alle tue esigenze. Per ulteriori informazioni, consulta Riferimento per la trasformazione.

  3. Fai clic su Crea.

Immagine

Se hai selezionato Immagine come tipo di trasformazione dati, svolgi i seguenti passaggi:

  1. (Facoltativo) Per cambiare il colore della casella che copre il testo oscurato, fai clic sulla casella nera nel campo Colore oscuramento e scegli un altro colore.

  2. Nella sezione InfoType da trasformare, specifica cosa vuoi oscurare: tutto il testo rilevato, tutti gli infoType definiti nella configurazione dell'ispezione o solo infoType specifici.

    Se selezioni Specifica gli infoType, seleziona gli infoType a cui vuoi applicare la regola di trasformazione.

  3. Se vuoi aggiungere regole di trasformazione per gli infoType non coperti dalla tua regola di trasformazione, fai clic su Aggiungi regola di trasformazione. Poi, compila i campi in base alle tue esigenze. Ripeti questo passaggio finché non hai configurato una regola di trasformazione per tutti gli infoType che vuoi trasformare.

  4. Fai clic su Crea.

Protocollo

È utile notare che un modello di anonimizzazione è semplicemente una configurazione di anonimizzazione riutilizzabile più alcuni metadati. In termini di API, l'oggetto DeidentifyTemplate è in pratica un oggetto DeidentifyConfig che include alcuni campi di metadati aggiuntivi, come un nome visualizzato e una descrizione. Pertanto, per creare un nuovo modello di anonimizzazione, i passaggi di base sono:

  1. Inizia con un oggetto DeidentifyConfig.
  2. Chiama o invia un POST al metodo create della risorsa projects.deidentifyTemplates , includendo nella richiesta un oggetto DeidentifyTemplate contenente un nome visualizzato, una descrizione e quell'oggetto DeidentifyConfig.

Il valore DeidentifyTemplate restituito sarà utilizzabile immediatamente. Puoi farvi riferimento in altre chiamate o job tramite il relativo name. Puoi elencare i modelli esistenti chiamando il metodo *.deidentifyTemplates.list. Per visualizzare un modello specifico, chiama il metodo *.deidentifyTemplates.get. Tieni presente che il limite per il numero di modelli che puoi creare è 1000.

Se hai già avuto esperienza con l'anonimizzazione dei dati sensibili da testo, immagini o contenuti strutturati utilizzando la protezione dei dati sensibili, hai già creato un oggetto DeidentifyConfig. Un passaggio aggiuntivo lo trasforma in un oggetto DeidentifyTemplate.

Esempio REST

Il seguente JSON è un esempio di ciò che puoi inviare al metodo projects.deidentifyTemplates.create. Questo JSON crea un nuovo modello con il nome visualizzato e la descrizione specificati e cerca corrispondenze per gli infoType EMAIL_ADDRESS e GENERIC_ID. Quando trova contenuti corrispondenti a questi infoType, maschera i primi tre caratteri con un asterisco (*).

Metodo HTTP e URL

POST https://dlp.googleapis.com/v2/projects/PROJECT_ID/deidentifyTemplates

Sostituisci PROJECT_ID con l'ID progetto.

Input JSON

{
  "deidentifyTemplate":{
    "displayName":"Email and id masker",
    "description":"De-identifies emails and ids with a series of asterisks.",
    "deidentifyConfig":{
      "infoTypeTransformations":{
        "transformations":[
          {
            "infoTypes":[
              {
                "name":"GENERIC_ID"
              }
            ],
            "primitiveTransformation":{
              "replaceWithInfoTypeConfig":{

              }
            }
          },
          {
            "infoTypes":[
              {
                "name":"EMAIL_ADDRESS"
              }
            ],
            "primitiveTransformation":{
              "characterMaskConfig":{
                "charactersToIgnore":[
                  {
                    "charactersToSkip":"@"
                  }
                ],
                "maskingCharacter":"*"
              }
            }
          }
        ]
      }
    }
  }
}

Output JSON

    {
      "name":"projects/PROJECT_ID/deidentifyTemplates/JOB-ID",
      "displayName":"Email and id masker",
      "description":"De-identifies emails and ids with a series of asterisks.",
      "createTime":"2018-11-30T07:17:59.536022Z",
      "updateTime":"2018-11-30T07:17:59.536022Z",
      "deidentifyConfig":{
        "infoTypeTransformations":{
          "transformations":[
            {
              "infoTypes":[
                {
                  "name":"GENERIC_ID"
                }
              ],
              "primitiveTransformation":{
                "replaceWithInfoTypeConfig":{

                }
              }
            },
            {
              "infoTypes":[
                {
                  "name":"EMAIL_ADDRESS"
                }
              ],
              "primitiveTransformation":{
                "characterMaskConfig":{
                  "maskingCharacter":"*",
                  "charactersToIgnore":[
                    {
                      "charactersToSkip":"@"
                    }
                  ]
                }
              }
            }
          ]
        }
      }
    }

Per provarlo rapidamente, puoi utilizzare l'Explorer API incorporato di seguito. Per informazioni generali sull'utilizzo di JSON per inviare richieste all'API DLP, consulta la guida introduttiva JSON.

Utilizzo dei modelli di anonimizzazione

Dopo aver creato un nuovo modello, puoi utilizzare il relativo identificatore name ovunque sia accettato name, ad esempio:deidentifyTemplateName

  • projects.content.deidentify: anonimizza i dati potenzialmente sensibili nei contenuti utilizzando il modello come configurazione. Tieni presente che questo metodo può utilizzare un modello di ispezione o un modello di anonimizzazione.

Modelli di anonimizzazione delle schede

Per elencare tutti i modelli di anonimizzazione che sono stati creati, utilizza uno dei metodi*.*.list:

Questa sezione mostra come utilizzare Sensitive Data Protection per elencare i modelli di ispezione. La procedura è identica a quella per l'elenco dei modelli di anonimizzazione.

C#

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

// 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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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
            )
        )

Eliminazione dei modelli di anonimizzazione

Per eliminare un modello di anonimizzazione specifico, utilizza uno dei seguenti metodi:*.*.delete

Con ogni metodo *.*.delete, includi il nome della risorsa del modello da eliminare.

C#

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

// 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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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.")