Creazione di modelli di anonimizzazione Sensitive Data Protection

Puoi utilizzare i modelli per creare e rendere persistenti le informazioni di configurazione da utilizzare con Sensitive Data Protection. I template sono utili per disaccoppiare la configurazione, ad esempio cosa ispezionare e come anonimizzare, dall'implementazione delle richieste. I modelli forniscono un modo efficace per riutilizzare la configurazione e garantire la coerenza tra utenti e set di dati.

Sensitive Data Protection supporta due tipi di template:

  • 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, consulta Creazione di modelli di ispezione di Sensitive Data Protection.

Per informazioni concettuali sui template in Sensitive Data Protection, consulta Template.

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

Crea un template di anonimizzazione

Console

Nella console Google Cloud , vai alla pagina Crea template.

Vai a Crea template

Le sezioni seguenti descrivono come compilare la pagina Crea template.

Definisci template

Nella sezione Definisci modello, compila i campi come segue:

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

  2. In Tipo di trasformazione dei 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 tiene conto del formato strutturato dei dati quando applica una trasformazione. Questo tipo di trasformazione è utile per i dati tabulari.

    • Image. 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 template.

  5. In Descrizione, descrivi il template.

  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 dei dati, segui questi passaggi:

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

    Vengono visualizzati altri campi in base alla selezione. Compila i campi in base alle tue esigenze. Per saperne di più, consulta il riferimento per la trasformazione.

  2. Nella sezione InfoType da trasformare, specifica se vuoi applicare la trasformazione a tutti gli infoType rilevati definiti nella configurazione di 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 regola di trasformazione, fai clic su Aggiungi regola di trasformazione. Poi, compila i campi in base alle tue esigenze. Ripeti questo passaggio fino a quando non avrai 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, segui questi passaggi:

  1. In Campi o colonne da trasformare, digita il nome della colonna della tabella contenente i dati che vuoi trasformare. Poi premi ENTER. Ripeti questo passaggio per ogni colonna contenente i dati che vuoi 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 i dati che circondano 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 di ispezione.

        Se selezioni Specifica 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 tue 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 le celle di queste colonne abbiano infoType rilevati.

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

    In entrambi i casi, vengono visualizzati altri campi in base al metodo di trasformazione selezionato. Compila i campi in base alle necessità. Per saperne di più, consulta il riferimento per la trasformazione.

  3. Fai clic su Crea.

Immagine

Se hai selezionato Immagine come tipo di trasformazione dei dati, segui questi 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 colore diverso.

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

    Se selezioni Specifica 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 regola di trasformazione, fai clic su Aggiungi regola di trasformazione. Poi, compila i campi in base alle tue esigenze. Ripeti questo passaggio fino a quando non avrai configurato una regola di trasformazione per tutti gli infoType che vuoi trasformare.

  4. Fai clic su Crea.

Protocollo

È utile notare che un template di anonimizzazione è semplicemente una configurazione di anonimizzazione riutilizzabile con alcuni metadati. In termini di API, l'oggetto DeidentifyTemplate è effettivamente 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 una richiesta POST al metodo create della risorsa projects.deidentifyTemplates, includendo nella richiesta un oggetto DeidentifyTemplate che contiene un nome visualizzato, una descrizione e l'oggetto DeidentifyConfig.

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

Se hai già esperienza con l'anonimizzazione dei dati sensibili da testo, immagini o contenuti strutturati utilizzando Sensitive Data Protection, hai già creato un oggetto DeidentifyConfig. Un ulteriore passaggio lo trasforma in un oggetto DeidentifyTemplate.

Esempio di REST

Il seguente JSON è un esempio di ciò che potresti inviare al metodo projects.deidentifyTemplates.create. Questo JSON crea un nuovo template con il nome visualizzato e la descrizione forniti ed esegue la scansione per trovare corrispondenze con 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 Explorer API incorporato di seguito. Per informazioni generali sull'utilizzo di JSON per inviare richieste all'API DLP, consulta la guida rapida a JSON.

Utilizzo dei template di anonimizzazione

Una volta creato un nuovo template, puoi utilizzare il suo identificatore name ovunque sia accettato deidentifyTemplateName, ad esempio:

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

Elenco dei template di anonimizzazione

Per elencare tutti i template di anonimizzazione creati, utilizza uno dei metodi *.*.list:

Questa sezione mostra come utilizzare Sensitive Data Protection per elencare i template di ispezione. La procedura è identica a quella per elencare i template di anonimizzazione.

C#

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

Per eseguire l'autenticazione in Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 eseguire l'autenticazione in Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 eseguire l'autenticazione in Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 eseguire l'autenticazione in Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 eseguire l'autenticazione in Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 eseguire l'autenticazione in Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 template di anonimizzazione

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

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

C#

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

Per eseguire l'autenticazione in Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 eseguire l'autenticazione in Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 eseguire l'autenticazione in Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 eseguire l'autenticazione in Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 eseguire l'autenticazione in Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 eseguire l'autenticazione in Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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.")