Creazione di modelli di anonimizzazione di Cloud DLP

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Puoi utilizzare i modelli per creare e mantenere le informazioni di configurazione da utilizzare con Cloud Data Loss Prevention. I modelli sono utili per disaccoppiare la configurazione, ad esempio per cosa ispezioni e per il modo per anonimizzarli dall'implementazione delle richieste. I modelli forniscono un modo efficace per riutilizzare la configurazione e abilitare la coerenza tra utenti e set di dati.

Cloud DLP supporta due tipi di modelli:

  • Modelli di anonimizzazione: modelli per il salvataggio delle informazioni di configurazione per i job di anonimizzazione, incluse le trasformazioni di infoType e record (set di dati strutturati).
  • Modelli di ispezione: modelli per le 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, vedi Creare modelli di ispezione di Cloud DLP.

Per informazioni concettuali sui modelli di Cloud DLP, consulta Modelli.

La parte restante di questo argomento illustra come creare modelli di anonimizzazione da utilizzare con Cloud DLP.

Creare un modello di anonimizzazione

Console

In Google Cloud Console, 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 i dati sensibili).
  2. Per Tipo di trasformazione dei dati, seleziona il tipo di trasformazione da applicare:

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

    • Registra. Cloud DLP considera il formato strutturato dei dati quando applica una trasformazione. Questo tipo di trasformazione è utile per i dati tabulari.

    • Immagine. Cloud DLP 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. Per Località della risorsa, seleziona Globale o la località dei dati da anonimizzare.

  7. Fai clic su Continua.

Configura anonimizzazione

La selezione dei campi che vengono 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, procedi nel seguente modo:

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

    Altri campi vengono visualizzati in base alla selezione. Compila i campi in base alle necessità. Per ulteriori informazioni, consulta il riferimento per la trasformazione.

  2. Nella sezione InfoType da trasformare, specifica se vuoi applicare la trasformazione a tutti gli infoType rilevati e 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 a cui non è applicata la regola di trasformazione, fai clic su Aggiungi regola di trasformazione. Compila i campi in base alle necessità. 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 dati, procedi nel seguente modo:

  1. Per Campi o colonne da trasformare, digita il nome della colonna della tabella contenente i dati che vuoi trasformare. Quindi, premi ENTER. Ripeti questo passaggio per ogni colonna contenente i dati che vuoi trasformare.
  2. Specifica il tipo di trasformazione:

    • Corrispondenza su infoType. Cloud DLP considera ogni cella come testo non strutturato e applica la trasformazione solo agli infoType trovati nella cella. Cloud DLP non trasforma alcun dato relativo 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 e definiti nella configurazione dell'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 a seconda delle esigenze.

    • Trasformazione dei campi primitivi. Cloud DLP 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 in tali colonne abbiano rilevato 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 necessità. Per ulteriori informazioni, consulta il riferimento per la trasformazione.

  3. Fai clic su Crea.

Immagine

Se hai selezionato Image come tipo di trasformazione di dati, procedi nel seguente modo:

  1. Facoltativo: per modificare 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 dell'ispezione o solo specifici infoType.

    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 a cui non è applicata la regola di trasformazione, fai clic su Aggiungi regola di trasformazione. Compila i campi in base alle necessità. 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, oltre ad alcuni metadati. In termini di API, l'oggetto DeidentifyTemplate è in effetti un oggetto DeidentifyConfig che include alcuni altri campi di metadati, come un nome visualizzato e una descrizione. Di conseguenza, per creare un nuovo modello di anonimizzazione, è necessario seguire questi passaggi:

  1. Inizia con un oggetto DeidentifyConfig.
  2. Chiama o pubblica il metodo create della risorsa projects.deidentifyTemplates, includendo nella richiesta un oggetto DeidentifyTemplate che contiene un nome visualizzato, una descrizione e tale oggetto DeidentifyConfig.

Il DeidentifyTemplate restituito sarà utilizzabile immediatamente. Puoi utilizzarlo come riferimento in altre chiamate o altre offerte di lavoro tramite il rispettivo 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 numero massimo di modelli che puoi creare è 1000.

Se hai già verificato l'anonimizzazione dei dati sensibili da testo, immagini o contenuti strutturati utilizzando Cloud DLP, 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 le corrispondenze negli infoType EMAIL_ADDRESS e GENERIC_ID. Quando trova contenuti corrispondenti a questi infoType, maschera i primi tre caratteri con un asterisco (*).

Metodo e URL HTTP

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 provarla rapidamente, puoi utilizzare l'Explorer API integrato 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

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

  • projects.content.deidentify: ID dei 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 creati, utilizza uno dei metodi *.*.list:

Esempi di codice

Di seguito è riportato un esempio di codice in diverse lingue che dimostra come utilizzare Cloud DLP per elencare i modelli di ispezione. La procedura è identica a quella per elencare i modelli di anonimizzazione.

Java

Per scoprire come installare e utilizzare la libreria client per Cloud DLP, consulta Librerie client di Cloud DLP.


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 Cloud DLP, consulta Librerie client di Cloud DLP.

// 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();

Python

Per scoprire come installare e utilizzare la libreria client per Cloud DLP, consulta Librerie client di Cloud DLP.

def list_inspect_templates(project):
    """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.
    """

    # Import the client library
    import google.cloud.dlp

    # 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("Template {}:".format(template.name))
        if template.display_name:
            print("  Display Name: {}".format(template.display_name))
        print("  Created: {}".format(template.create_time))
        print("  Updated: {}".format(template.update_time))

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

Go

Per scoprire come installare e utilizzare la libreria client per Cloud DLP, consulta Librerie client di Cloud DLP.

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

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

// 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: %v", 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: %v", err)
		}
		fmt.Fprintf(w, "Inspect template %v\n", t.GetName())
		c, err := ptypes.Timestamp(t.GetCreateTime())
		if err != nil {
			return fmt.Errorf("CreateTime Timestamp: %v", 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: %v", 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
}

PHP

Per scoprire come installare e utilizzare la libreria client per Cloud DLP, consulta Librerie client di Cloud DLP.

use Google\Cloud\Dlp\V2\DlpServiceClient;

/**
 * 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
    $response = $dlp->listInspectTemplates($parent);

    // 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());
        }
    }
}

C#

Per scoprire come installare e utilizzare la libreria client per Cloud DLP, consulta Librerie client di Cloud DLP.


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}");
        }
    }
}

Eliminazione dei modelli di anonimizzazione

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

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

Esempi di codice

Di seguito è riportato un codice di esempio in vari linguaggi che dimostra come utilizzare Cloud DLP per eliminare un modello di ispezione. La procedura è identica a quella per la creazione dei modelli di anonimizzazione.

Java

Per scoprire come installare e utilizzare la libreria client per Cloud DLP, consulta Librerie client di Cloud DLP.


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 Cloud DLP, consulta Librerie client di Cloud DLP.

// 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();

Python

Per scoprire come installare e utilizzare la libreria client per Cloud DLP, consulta Librerie client di Cloud DLP.

def delete_inspect_template(project, template_id):
    """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.
    """

    # Import the client library
    import google.cloud.dlp

    # 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 = "{}/inspectTemplates/{}".format(parent, template_id)

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

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

Go

Per scoprire come installare e utilizzare la libreria client per Cloud DLP, consulta Librerie client di Cloud DLP.

import (
	"context"
	"fmt"
	"io"

	dlp "cloud.google.com/go/dlp/apiv2"
	dlppb "google.golang.org/genproto/googleapis/privacy/dlp/v2"
)

// 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: %v", err)
	}
	defer client.Close()

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

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

PHP

Per scoprire come installare e utilizzare la libreria client per Cloud DLP, consulta Librerie client di Cloud DLP.

use Google\Cloud\Dlp\V2\DlpServiceClient;

/**
 * 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";
    $dlp->deleteInspectTemplate($templateName);

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

C#

Per scoprire come installare e utilizzare la libreria client per Cloud DLP, consulta Librerie client di Cloud DLP.


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;
    }
}