Créer un détecteur d'expression régulière personnalisé

Un détecteur d'infoType d'expression régulière personnalisé vous permet de créer vos propres détecteurs, qui aident Cloud DLP à identifier des correspondances basées sur un modèle d'expression régulière. Supposons par exemple que vous ayez des numéros de dossiers médicaux au format ###-#-#####. Vous pouvez définir un modèle d'expression régulière comme suit :

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

Cloud DLP trouve alors les éléments comme ceux-ci :

012-4-56789

Anatomie d'un détecteur d'infoType d'expression régulière personnalisé

Comme résumé sur la page Présentation de l'API, pour créer un détecteur d'infoType d'expression régulière personnalisé, vous devez définir un objet CustomInfoType comportant les éléments suivants :

  • Le nom que vous souhaitez attribuer au détecteur d'infoType personnalisé, dans un objet InfoType.
  • Une valeur Likelihood facultative. Si vous omettez cette valeur, les correspondances avec les expressions régulières renvoient la probabilité par défaut de VERY_LIKELY (Très probable). Si vous remarquez qu'un détecteur d'infoType d'expression régulière personnalisé renvoie trop de faux positifs, réduisez la probabilité de base et utilisez des règles de détection afin d'améliorer la probabilité grâce aux informations contextuelles. Pour en savoir plus, consultez la page Personnaliser la probabilité de correspondance.
  • Un objet facultatif DetectionRule ou des règles relatives aux mots clés. Ces règles permettent d'ajuster la probabilité des résultats dans un espace de proximité donné avec certains mots clés spécifiés. Pour en savoir plus sur les règles relatives aux mots clés, consultez la page Personnaliser la probabilité de correspondance.
  • Un objet Regex constitué d'un seul modèle définissant l'expression régulière.

En tant qu'objet JSON, un détecteur d'infoType d'expression régulière personnalisé incluant tous les composants facultatifs se présente comme suit :

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

Exemple d'expression régulière : identifier des numéros de dossiers médicaux

L'extrait de code JSON et le code suivants dans plusieurs langages ci-dessous montrent un détecteur d'infoType d'expression régulière personnalisé qui indique à Cloud DLP de trouver un numéro de dossier médical (MRN, Medical Record Number) dans le texte d'entrée "Patient's MRN 444-5-22222", puis d'attribuer à chaque correspondance une probabilité de POSSIBLE.

Protocole

Pour en savoir plus sur l'utilisation de Cloud DLP avec JSON, consultez le démarrage rapide JSON.

Entrée 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"
      }
    ]
  }
}

Sortie 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'aide du détecteur d'infoType personnalisé que nous avons appelé C_MRN et de son expression régulière personnalisée, Cloud DLP a correctement identifié le numéro du dossier médical et lui a attribué la probabilité POSSIBLE comme nous l'avons spécifié.

La page Personnaliser la probabilité de correspondance s'appuie sur cet exemple pour inclure des mots de contexte.

Java


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

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

    # 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:
            try:
                if finding.quote:
                    print(f"Quote: {finding.quote}")
            except AttributeError:
                pass
            print(f"Info type: {finding.info_type.name}")
            print(f"Likelihood: {finding.likelihood}")
    else:
        print("No findings.")