Creazione di un rilevatore regex personalizzato

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

Un rilevatore di infoType personalizzato di espressione regolare (regex) consente di creare rilevatori personalizzati che consentono a Cloud DLP di rilevare corrispondenze in base a un pattern regex. Ad esempio, supponiamo che tu abbia le cartelle cliniche in formato ###-#-#####. Puoi definire un pattern regex come il seguente:

[0-9]{3}-[0-9]{1}-[0-9]{5}

A questo punto, Cloud DLP troverà elementi simili ai seguenti:

012-4-56789

Anatomia di un rilevatore infoType personalizzato regex

Come descritto in Panoramica API, per creare un rilevatore infoType regex personalizzato, puoi definire un oggetto CustomInfoType che contiene:

  • Il nome che vuoi assegnare al rilevatore infoType personalizzato, in un oggetto InfoType.
  • Un valore facoltativo Likelihood. Se ometti questa opzione, le corrispondenze regex restituiscono una probabilità predefinita di VERY_LIKELY. Se noti che un rilevatore di infoType personalizzato regex restituisce troppi falsi positivi, prova a ridurre la probabilità di base e usa regole di rilevamento per aumentare la probabilità usando informazioni contestuali. Per scoprire di più, consulta Personalizzazione della probabilità dei risultati.
  • Regole facoltative di DetectionRule o di hotword. Queste regole modificano la probabilità dei risultati all'interno di una data prossimità di hotword specificate. Scopri di più sulle regole hotword in Personalizzare la probabilità dei risultati.
  • Un oggetto Regex costituito da un singolo pattern che definisce l'espressione regolare.

Come oggetto JSON, un rilevatore infoType personalizzato regex che include tutti i componenti facoltativi ha il seguente aspetto:

{
  "customInfoTypes":[
    {
      "infoType":{
        "name":"[CUSTOM_INFOTYPE_NAME]"
      },
      "likelihood":"[LIKELIHOOD_VALUE]",
      "detectionRules":[
        {
          "hotwordRule":{
            [HOTWORDRULE_OBJECT]
          }
        },
        ...
      ],
      "regex":{
        "pattern":"[REGEX_PATTERN]"
      }
    }
  ],
  ...
}

Esempio di regex: abbina i numeri delle cartelle cliniche

Il seguente codice e snippet JSON in diverse lingue mostra un rilevatore di infoType personalizzato con espressione regolare che indica a Cloud DLP di corrispondere a un numero di cartella medica (MRN) nel testo di input"Paziente". MRN 444-5-22222;

Protocollo

Consulta la guida rapida di JSON per ulteriori informazioni sull'utilizzo dell'API DLP con JSON.

Input JSON:

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

{
  "item":{
    "value":"Patients MRN 444-5-22222"
  },
  "inspectConfig":{
    "customInfoTypes":[
      {
        "infoType":{
          "name":"C_MRN"
        },
        "regex":{
          "pattern":"[1-9]{3}-[1-9]{1}-[1-9]{5}"
        },
        "likelihood":"POSSIBLE"
      }
    ]
  }
}

Output JSON:

{
  "result":{
    "findings":[
      {
        "infoType":{
          "name":"C_MRN"
        },
        "likelihood":"POSSIBLE",
        "location":{
          "byteRange":{
            "start":"13",
            "end":"24"
          },
          "codepointRange":{
            "start":"13",
            "end":"24"
          }
        },
        "createTime":"2018-11-30T01:29:37.799Z"
      }
    ]
  }
}

L'output mostra che, utilizzando il rilevatore di infoType personalizzato, abbiamo assegnato al nome C_MRN e alla relativa regex personalizzata, Cloud DLP ha identificato correttamente il numero della cartella medica e gli ha assegnato una certezza di POSSIBLE, come abbiamo specificato.

La Personalizzazione delle probabilità di corrispondenza si basa su questo esempio per includere parole di contesto.

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.ByteContentItem;
import com.google.privacy.dlp.v2.ByteContentItem.BytesType;
import com.google.privacy.dlp.v2.ContentItem;
import com.google.privacy.dlp.v2.CustomInfoType;
import com.google.privacy.dlp.v2.CustomInfoType.Regex;
import com.google.privacy.dlp.v2.Finding;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectContentRequest;
import com.google.privacy.dlp.v2.InspectContentResponse;
import com.google.privacy.dlp.v2.Likelihood;
import com.google.privacy.dlp.v2.LocationName;
import com.google.protobuf.ByteString;
import java.io.IOException;

public class InspectWithCustomRegex {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String textToInspect = "Patients MRN 444-5-22222";
    String customRegexPattern = "[1-9]{3}-[1-9]{1}-[1-9]{5}";
    inspectWithCustomRegex(projectId, textToInspect, customRegexPattern);
  }

  // Inspects a BigQuery Table
  public static void inspectWithCustomRegex(
      String projectId, String textToInspect, String customRegexPattern) 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 dlp = DlpServiceClient.create()) {
      // Specify the type and content to be inspected.
      ByteContentItem byteItem =
          ByteContentItem.newBuilder()
              .setType(BytesType.TEXT_UTF8)
              .setData(ByteString.copyFromUtf8(textToInspect))
              .build();
      ContentItem item = ContentItem.newBuilder().setByteItem(byteItem).build();

      // Specify the regex pattern the inspection will look for.
      Regex regex = Regex.newBuilder().setPattern(customRegexPattern).build();

      // Construct the custom regex detector.
      InfoType infoType = InfoType.newBuilder().setName("C_MRN").build();
      CustomInfoType customInfoType =
          CustomInfoType.newBuilder().setInfoType(infoType).setRegex(regex).build();

      // Construct the configuration for the Inspect request.
      InspectConfig config =
          InspectConfig.newBuilder()
              .addCustomInfoTypes(customInfoType)
              .setIncludeQuote(true)
              .setMinLikelihood(Likelihood.POSSIBLE)
              .build();

      // Construct the Inspect request to be sent by the client.
      InspectContentRequest request =
          InspectContentRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setItem(item)
              .setInspectConfig(config)
              .build();

      // Use the client to send the API request.
      InspectContentResponse response = dlp.inspectContent(request);

      // Parse the response and process results
      System.out.println("Findings: " + response.getResult().getFindingsCount());
      for (Finding f : response.getResult().getFindingsList()) {
        System.out.println("\tQuote: " + f.getQuote());
        System.out.println("\tInfo type: " + f.getInfoType().getName());
        System.out.println("\tLikelihood: " + f.getLikelihood());
      }
    }
  }
}

Python

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

def inspect_with_medical_record_number_custom_regex_detector(
    project,
    content_string,
):
    """Uses the Data Loss Prevention API to analyze string with medical record
       number custom regex detector

    Args:
        project: The Google Cloud project id to use as a parent resource.
        content_string: The string to inspect.

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

    # Construct a custom regex detector info type called "C_MRN",
    # with ###-#-##### pattern, where each # represents a digit from 1 to 9.
    # The detector has a detection likelihood of POSSIBLE.
    custom_info_types = [
        {
            "info_type": {"name": "C_MRN"},
            "regex": {"pattern": "[1-9]{3}-[1-9]{1}-[1-9]{5}"},
            "likelihood": google.cloud.dlp_v2.Likelihood.POSSIBLE,
        }
    ]

    # Construct the configuration dictionary with the custom regex info type.
    inspect_config = {
        "custom_info_types": custom_info_types,
        "include_quote": True,
    }

    # Construct the `item`.
    item = {"value": content_string}

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

    # Call the API.
    response = dlp.inspect_content(
        request={"parent": parent, "inspect_config": inspect_config, "item": item}
    )

    # Print out the results.
    if response.result.findings:
        for finding in response.result.findings:
            print(f"Quote: {finding.quote}")
            print(f"Info type: {finding.info_type.name}")
            print(f"Likelihood: {finding.likelihood}")
    else:
        print("No findings.")