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 modelli sono utili per disaccoppiare la configurazione, ad esempio ciò che controlli e come anonimizzarlo dall'implementazione delle richieste. I modelli offrono un modo efficace 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 infoType e record (set di dati strutturati).
• Modelli di ispezione: modelli per informazioni di configurazione persistenti per i job di scansione di ispezione, inclusi i rilevatori predefiniti o personalizzati da utilizzare. Per ulteriori informazioni sui modelli di ispezione, consulta Creazione di modelli di ispezione di Sensitive Data Protection.

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

Nella parte restante di questo argomento viene spiegato come creare modelli di anonimizzazione da utilizzare con Sensitive Data Protection.

Crea un modello di anonimizzazione

Console

Nella console Google Cloud, vai alla pagina Crea modello.

Vai a Crea modello

Le seguenti sezioni 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. Per 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 considera 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à delle risorse, seleziona Globale o la località dei dati che vuoi anonimizzare.

7. Fai clic su Continua.

Configura anonimizzazione

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

InfoType

Se hai selezionato InfoType come tipo di trasformazione dei dati:

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

   Vengono visualizzati altri campi in base alla selezione. Compila i campi secondo necessità. Per ulteriori informazioni, consulta la sezione Informazioni di riferimento sulla trasformazione.

2. Nella sezione InfoType da trasformare, specifica se vuoi applicare la trasformazione a tutti gli infoType rilevati che sono 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 infoType che non sono coperte dalla regola di trasformazione, fai clic su Aggiungi regola di trasformazione. Poi, compila i campi come necessario. Ripeti questo passaggio finché 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:

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

2. Specifica il tipo di trasformazione:

   • Utilizza una corrispondenza per infoType. Sensitive Data Protection tratta ogni cella come testo non strutturato e applica la trasformazione solo agli infoType trovati nella cella. Sensitive Data Protection non trasforma i dati intorno 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 che sono 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 aggiungerne altre, se necessario.

   • Trasformazione primitiva dei campi. Sensitive Data Protection trasforma sempre l'intera cella in base al metodo di trasformazione che scegli. Questa opzione è utile se vuoi trasformare intere colonne di dati, indipendentemente dal fatto che le celle di tali colonne abbiano rilevato o meno 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 come necessario. Per ulteriori informazioni, consulta la sezione Informazioni di riferimento sulla trasformazione.

3. Fai clic su Crea.

Image

Se hai selezionato Immagine come tipo di trasformazione dei dati:

1. (Facoltativo) Per modificare il colore della casella che copre il testo oscurato, fai clic sulla casella nera nel campo Colore di 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 gli 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 infoType che non sono coperte dalla regola di trasformazione, fai clic su Aggiungi regola di trasformazione. Poi, compila i campi come necessario. Ripeti questo passaggio finché non avrai 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 insieme ad alcuni metadati. In termini API, l'oggetto DeidentifyTemplate è di fatto un oggetto DeidentifyConfig che include alcuni altri campi di metadati, come un nome visualizzato e una descrizione. Pertanto, per creare un nuovo modello di anonimizzazione, segui questi passaggi di base:

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

Il metodo di pagamento DeidentifyTemplate restituito potrà essere utilizzato immediatamente. Puoi fare riferimento a questa voce in altre chiamate o job tramite il suo 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 di testi, 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 potresti inviare al metodo projects.deidentifyTemplates.create. Questo JSON crea un nuovo modello con il nome visualizzato e la descrizione specificati e cerca corrispondenze negli infoType EMAIL_ADDRESS e GENERIC_ID. Quando trova contenuti corrispondenti a questi infoType, i primi tre caratteri vengono mascherati con un asterisco (*).

Nota: l'esempio seguente richiede un token di accesso OAuth 2.0.

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 provare rapidamente questa funzionalità, puoi utilizzare Explorer API incorporato di seguito. Per informazioni generali sull'utilizzo di JSON per inviare richieste all'API DLP, consulta la guida rapida di JSON.

Utilizzo dei modelli di anonimizzazione

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

• 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 di anonimizzazione.

Elenco dei modelli di anonimizzazione

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

• projects.deidentifyTemplates.list

Questa sezione illustra come utilizzare Sensitive Data Protection per elencare i modelli di ispezione. Il processo è identico a quello per elencare i modelli di anonimizzazione.

Importante: il codice in questa pagina richiede prima la configurazione di un client Sensitive Data Protection. Per saperne di più sull'installazione e sulla creazione di un client Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection. (L'invio di JSON a endpoint REST di Sensitive Data Protection non richiede una libreria client.)

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 Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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 Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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 Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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 Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

// 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 Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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 Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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 *.*.delete metodi:

• projects.deidentifyTemplates.delete

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

Importante: il codice in questa pagina richiede prima la configurazione di un client Sensitive Data Protection. Per saperne di più sull'installazione e sulla creazione di un client Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection. (L'invio di JSON a endpoint REST di Sensitive Data Protection non richiede una libreria client.)

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 Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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 Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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 Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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 Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

// 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 Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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 Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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