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é dans la section 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 contenant 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 ce champ, les correspondances avec expression régulière renvoient la probabilité par défaut VERY_LIKELY. 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.

• Une valeur SensitivityScore facultative. Si vous omettez ce champ, les correspondances avec l'expression régulière renvoient un niveau de sensibilité par défaut de HIGH.

  Les scores de sensibilité sont utilisés dans les profils de données. Lors du profilage de vos données, Cloud DLP utilise les scores de sensibilité des infoTypes pour calculer le niveau de sensibilité.

• 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_LEVEL",
      "detectionRules":[
        {
          "hotwordRule":{
            HOTWORD_RULE
          }
        },
      "sensitivityScore":{
          "score": "SENSITIVITY_SCORE"
        },
      ],
      "regex":{
        "pattern":"REGULAR_EXPRESSION_PATTERN"
      }
    }
  ],
  ...
}

Remarque :Vous pouvez également créer un détecteur d'expression régulière personnalisé en référençant un StoredInfoType existant dans le champ storedType de l'objet CustomInfoType, au lieu de définir le champ regex. Toutefois, cette approche nécessite de créer un StoredInfoType de type Regex. Dans la plupart des cas, il est plus simple de définir l'objet Regex directement dans le champ regex de l'objet CustomInfoType.

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 découvrir comment utiliser le format JSON avec l'API DLP, 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

Pour savoir comment installer et utiliser la bibliothèque cliente pour Cloud DLP, consultez Bibliothèques clientes Cloud DLP.

Pour vous authentifier auprès de Cloud DLP, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour Cloud DLP, consultez Bibliothèques clientes Cloud DLP.

Pour vous authentifier auprès de Cloud DLP, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

import google.cloud.dlp  # noqa: E402, F811

def inspect_with_medical_record_number_custom_regex_detector(
    project: str,
    content_string: str,
) -> None:
    """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.
    """

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