Anonymiser les données sensibles

La protection des données sensibles peut anonymiser les données sensibles dans du contenu textuel, y compris dans du texte stocké dans des structures de conteneurs telles que des tables. L'anonymisation est le processus qui consiste à éliminer les informations personnelles contenues dans les données. L'API détecte les données sensibles telles que les informations personnelles, puis procède à une transformation d'anonymisation pour masquer, supprimer ou dissimuler les données. Voici des exemples de techniques de suppression :

• Masquer les données sensibles en remplaçant partiellement ou entièrement les caractères par un symbole, tel qu'un astérisque (*) ou un dièse (#)
• Remplacer chaque instance de données sensibles par une chaîne de type "jeton" ou de substitution
• Chiffrer et remplacer les données sensibles à l'aide d'une clé générée de manière aléatoire ou prédéterminée

Vous pouvez transmettre des informations à l'API en utilisant le format JSON plutôt que le protocole HTTPS, et également en utilisant l&#CLI ainsi que plusieurs langages de programmation à l'aide des bibliothèques clientes Protection des données sensibles. Pour configurer l'interface de ligne de commande, consultez le guide de démarrage rapide. Pour en savoir plus sur l'envoi d'informations au format JSON, consultez le guide de démarrage rapide JSON.

Présentation de l'API

Pour anonymiser les données sensibles, exécutez la méthode content.deidentify de Sensitive Data Protection.

Un appel d'API d'anonymisation est construit autour de trois éléments :

• Les données à inspecter : Structure de chaîne ou de table (objet ContentItem) que l'API doit inspecter.

• Les éléments à rechercher : informations de configuration de la détection (InspectConfig) telles que les types de données (ou infoTypes) à rechercher, le filtrage des résultats dépassant un certain seuil de probabilité et les limitations éventuelles sur le nombre de résultats à renvoyer.

  Dans votre objet InspectConfig, assurez-vous d'inclure les infoTypes que vous souhaitez analyser. Sinon, Sensitive Data Protection recherche un ensemble d'infoTypes par défaut (ALL_BASIC), dont certains ne vous seront peut-être pas utiles. La recherche d'infoTypes dont vous n'avez pas besoin peut ajouter une latence inutile à votre requête.

  Un objet InspectConfig est requis dans votre demande, à une exception près. Pour en savoir plus, consultez Enregistrer les transformations sur cette page.

• Que faire des résultats de l'inspection : Informations de configuration (DeidentifyConfig) qui définissent la manière dont vous souhaitez anonymiser les données sensibles. Cet argument est abordé plus en détail dans la section suivante.

L'API renvoie des éléments quasiment identiques à ceux que vous lui avez fournis et dans le même format. Cependant, le texte reconnu comme contenant des informations sensibles (selon les critères que vous avez définis) a été anonymisé.

Spécifier les critères de détection

Les détecteurs de type d'informations (ou "infoType") sont les mécanismes que Sensitive Data Protection utilise pour rechercher des données sensibles.

Sensitive Data Protection comprend plusieurs types de détecteurs d'infoTypes résumés ci-dessous :

• Les détecteurs d'infoTypes intégrés font partie intégrante de Sensitive Data Protection. Ils comprennent des détecteurs pour les types de données sensibles spécifiques à un pays ou une région, ainsi que pour les types de données applicables au niveau mondial.
• Les détecteurs d'infoTypes personnalisés sont des détecteurs que vous créez vous-même. Il existe trois types de détecteurs d'infoTypes personnalisés :
  • Les détecteurs de dictionnaires personnalisés standards sont de simples listes de mots dont la protection des données sensibles se sert pour rechercher des correspondances. Utilisez des détecteurs de dictionnaires personnalisés standards lorsque vous avez une liste qui contient au maximum plusieurs dizaines de milliers de mots ou d'expressions. Les détecteurs de dictionnaires personnalisés standards sont recommandés si vous pensez que votre liste de mots ne changera pas de manière significative.
  • Les détecteurs de dictionnaires personnalisés stockés sont générés par la protection des données sensibles à l'aide de listes volumineuses de mots ou d'expressions stockées dans Cloud Storage ou BigQuery. Utilisez des détecteurs de dictionnaires personnalisés stockés lorsque vous avez une longue liste de mots ou d'expressions, pouvant atteindre plusieurs dizaines de millions d'éléments.
  • Les détecteurs d'expressions régulières (regex) permettent à la protection des données sensibles de détecter les correspondances basées sur un motif d'expression régulière.

Pour affiner les résultats d'analyse, vous pouvez créer des règles d'inspection.

Transformations de suppression de l'identification

Lorsque vous définissez la configuration d'anonymisation (DeidentifyConfig), vous devez spécifier une ou plusieurs transformations. Il existe deux catégories de transformations.

• InfoTypeTransformations : transformations qui ne sont appliquées qu'aux valeurs identifiées comme un infoType spécifique au sein du texte envoyé
• RecordTransformations : transformations qui ne sont appliquées qu'aux valeurs identifiées comme un infoType spécifique au sein des données textuelles tabulaires envoyées, ou à une colonne entière de données tabulaires

Transformations d'infoType

Vous pouvez spécifier une ou plusieurs transformations d'infoTypes par requête. Dans chaque objet InfoTypeTransformation, vous spécifiez les deux éléments suivants :

• Un ou plusieurs infoTypes auxquels une transformation doit être appliquée (objet de tableau infoTypes[])
• Une transformation primitive (objet PrimitiveTransformation)

Notez que vous n'êtes pas obligé de spécifier un infoType. Toutefois, si vous ne définissez aucun infoType dans un argument InspectConfig, la transformation s'applique à tous les infoTypes intégrés pour lesquels aucune transformation n'est fournie. Cette pratique n'est pas recommandée, car cela peut entraîner une baisse des performances et une augmentation des coûts.

Transformations primitives

Vous devez spécifier au moins une transformation primitive à appliquer au texte d'entrée, qu'elle soit appliquée à certains infoTypes uniquement ou à l'intégralité de la chaîne de texte. Les sections suivantes décrivent des exemples de méthodes de transformation que vous pouvez utiliser. Pour obtenir la liste de toutes les méthodes de transformation proposées par la protection des données sensibles, consultez la documentation de référence sur les transformations.

replaceConfig

Si vous définissez la valeur de replaceConfig sur un objet ReplaceValueConfig, les valeurs détectées sont remplacées par une valeur que vous spécifiez.

Supposons par exemple que vous ayez défini replaceConfig sur [email-address] pour tous les infoTypes EMAIL_ADDRESS et que la chaîne suivante soit envoyée à Sensitive Data Protection :

My name is Alicia Abernathy, and my email address is aabernathy@example.com.

La chaîne renvoyée sera la suivante :

My name is Alicia Abernathy, and my email address is [email-address].

L'exemple JSON et le code suivants dans plusieurs langages montrent comment former la requête API et ce que renvoie l'API DLP :

from typing import List

import google.cloud.dlp


def deidentify_with_replace(
    project: str,
    input_str: str,
    info_types: List[str],
    replacement_str: str = "REPLACEMENT_STR",
) -> None:
    """Uses the Data Loss Prevention API to deidentify sensitive data in a
    string by replacing matched input values with a value you specify.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        input_str: The string to deidentify (will be treated as text).
        info_types: A list of strings representing info types to look for.
        replacement_str: The string to replace all values that match given
            info types.
    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}/locations/global"

    # Construct inspect configuration dictionary
    inspect_config = {"info_types": [{"name": info_type} for info_type in info_types]}

    # Construct deidentify configuration dictionary
    deidentify_config = {
        "info_type_transformations": {
            "transformations": [
                {
                    "primitive_transformation": {
                        "replace_config": {
                            "new_value": {"string_value": replacement_str}
                        }
                    }
                }
            ]
        }
    }

    # Construct item
    item = {"value": input_str}

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

    # Print out the results.
    print(response.item.value)

import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.ContentItem;
import com.google.privacy.dlp.v2.DeidentifyConfig;
import com.google.privacy.dlp.v2.DeidentifyContentRequest;
import com.google.privacy.dlp.v2.DeidentifyContentResponse;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InfoTypeTransformations;
import com.google.privacy.dlp.v2.InfoTypeTransformations.InfoTypeTransformation;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.LocationName;
import com.google.privacy.dlp.v2.PrimitiveTransformation;
import com.google.privacy.dlp.v2.ReplaceValueConfig;
import com.google.privacy.dlp.v2.Value;

public class DeIdentifyWithReplacement {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String textToInspect =
        "My name is Alicia Abernathy, and my email address is aabernathy@example.com.";
    deIdentifyWithReplacement(projectId, textToInspect);
  }

  // Inspects the provided text.
  public static void deIdentifyWithReplacement(String projectId, String textToRedact) {
    // 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 content to be inspected.
      ContentItem item = ContentItem.newBuilder().setValue(textToRedact).build();

      // Specify the type of info the inspection will look for.
      // See https://cloud.google.com/dlp/docs/infotypes-reference for complete list of info types
      InfoType infoType = InfoType.newBuilder().setName("EMAIL_ADDRESS").build();
      InspectConfig inspectConfig = InspectConfig.newBuilder().addInfoTypes(infoType).build();
      // Specify replacement string to be used for the finding.
      ReplaceValueConfig replaceValueConfig =
          ReplaceValueConfig.newBuilder()
              .setNewValue(Value.newBuilder().setStringValue("[email-address]"