Sensible Daten de-identifizieren

Mit Sensitive Data Protection lassen sich sensible Daten in Textinhalten de-identifizieren, einschließlich Text, der in Containerstrukturen wie Tabellen gespeichert ist. De-Identifikation ist der Prozess des Entfernens von personenidentifizierbaren Informationen aus Daten. Die API erkennt vertrauliche Daten wie personenidentifizierbare Informationen (PII) und verwendet dann eine De-Identifikationstransformation, um die Daten zu maskieren, zu löschen oder anderweitig zu verschleiern. Zu den De-Identifikationstechniken gehören zum Beispiel:

• "Maskieren" sensibler Daten durch teilweises oder vollständiges Ersetzen von Zeichen durch ein Symbol, etwa ein Sternchen (*) oder Rautezeichen (#)
• Ersetzen jedes Vorkommens sensibler Daten durch ein "Token" oder einen Ersatzstring
• Verschlüsseln und Ersetzen von sensiblen Daten mit einem zufällig generierten oder vordefinierten Schlüssel

Sie können der API mithilfe von JSON über HTTPS sowie anhand der Befehlszeile und mehrerer Programmiersprachen unter Verwendung der Clientbibliotheken für Sensitive Data Protection Informationen zuführen. Informationen zur Verwendung der Befehlszeile finden Sie in der Kurzanleitung. Näheres zum Übergeben von Informationen im JSON-Format finden Sie in der JSON-Kurzanleitung.

API-Übersicht

Verwenden Sie zum De-Identifizieren sensibler Daten die Methode content.deidentify von Sensitive Data Protection.

Ein API-Aufruf zur De-Identifizierung besteht aus drei Teilen:

• Zu überprüfende Daten: Ein String oder eine Tabellenstruktur (ContentItem-Objekt), der bzw. die von der API überprüft werden soll.

• Wonach zu suchen ist:Informationen zur Erkennungskonfiguration (InspectConfig), z. B. welche Datentypen (oder infoTypes) gesucht werden sollen, ob Ergebnisse über einem bestimmten Wahrscheinlichkeitsschwellenwert gefiltert werden sollen und ob nicht mehr als eine bestimmte Anzahl von Ergebnissen zurückgegeben werden soll.

  Achten Sie darauf, dass Sie in Ihrem InspectConfig-Objekt die infoTypes angeben, nach denen Sie suchen möchten. Andernfalls scannt Sensitive Data Protection nach einem Standardsatz von infoTypes (ALL_BASIC), von denen Sie einige möglicherweise nicht benötigen. Das Scannen nach infoTypes, die Sie nicht benötigen, kann die Latenz Ihrer Anfrage unnötig erhöhen.

  In Ihrer Anfrage ist ein InspectConfig-Objekt erforderlich, mit einer Ausnahme. Weitere Informationen finden Sie auf dieser Seite unter Datensatztransformationen.

• Was mit den Inspektionsergebnissen geschehen soll: Konfigurationsinformationen (DeidentifyConfig), die festlegen, wie die sensiblen Daten de-identifiziert werden sollen. Dieser Aspekt wird im folgenden Abschnitt ausführlicher behandelt.

Die API gibt dieselben Elemente, die Sie angegeben haben, im selben Format zurück. Aber Text, der gemäß Ihren Kriterien als vertrauliche Informationen erkannt wurde, ist jetzt de-identifiziert.

Erkennungskriterien angeben

Informationstyp- bzw. infoType-Detektoren sind die Mechanismen, mit deren Hilfe Sensitive Data Protection nach sensiblen Daten sucht.

Sensitive Data Protection umfasst mehrere Arten von infoType-Detektoren, die hier zusammengefasst sind:

• Integrierte infoType-Detektoren sind in Sensitive Data Protection integriert. Dazu gehören Detektoren für länder- oder regionsspezifische sensible Datentypen sowie global anwendbare Datentypen.
• Benutzerdefinierte infoType-Detektoren sind Detektoren, die Sie selbst erstellen. Es gibt drei Arten von benutzerdefinierten infoType-Detektoren:
  • Reguläre benutzerdefinierte Wörterbuchdetektoren sind einfache Wortlisten, in denen Sensitive Data Protection nach Übereinstimmungen sucht. Verwenden Sie reguläre benutzerdefinierte Wörterbuchdetektoren, wenn Sie eine Liste von einigen Zehntausend Wörtern oder Wortgruppen haben. Reguläre benutzerdefinierte Wörterbuchdetektoren werden bevorzugt verwendet, wenn davon auszugehen ist, dass sich die Wortliste nicht wesentlich ändern wird.
  • Gespeicherte benutzerdefinierte Wörterbuchdetektoren werden von Sensitive Data Protection unter Verwendung umfangreicher Listen von Wörtern oder Wortgruppen generiert, die entweder in Cloud Storage oder BigQuery gespeichert sind. Verwenden Sie gespeicherte benutzerdefinierte Wörterbuchdetektoren, wenn Sie eine umfangreiche Liste von Wörtern oder Wortgruppen haben (bis zu mehreren zehn Millionen).
  • Detektoren regulärer Ausdrücke (Regex-Detektoren) ermöglichen es Sensitive Data Protection, Übereinstimmungen anhand eines regulären Ausdrucksmusters zu erkennen.

Um Scanergebnisse zu verfeinern, können Sie Prüfregeln erstellen.

Transformationen zur De-Identifikation

Sie müssen eine oder mehrere Transformationen angeben, wenn Sie die De-Identifikationskonfiguration (DeidentifyConfig) festlegen. Es gibt zwei Transformationskategorien:

• InfoTypeTransformations: Transformationen, die nur auf Werte innerhalb von gesendetem Text angewendet werden, die als spezifischer infoType gekennzeichnet sind.
• RecordTransformations: Transformationen, die nur auf Werte innerhalb gesendeter Tabellentextdaten angewendet werden, die als spezifischer infoType gekennzeichnet sind, oder auf eine ganze Spalte von Tabellendaten.

InfoType-Transformationen

Sie können eine oder mehrere infoType-Transformationen pro Anfrage angeben. In jedem InfoTypeTransformation-Objekt geben Sie Folgendes an:

• Einen oder mehrere infoTypes, auf die eine Transformation angewendet werden soll (das Array-Objekt infoTypes[]).
• Eine primitive Transformation (das Objekt PrimitiveTransformation).

Die Angabe eines infoTypes ist optional, doch ein InspectConfig-Argument, in dem nicht mindestens ein infoType angegeben ist, bewirkt die Anwendung der Transformation auf alle eingebundenen infoTypes, für die keine Transformation angegeben wurde. Dies wird nicht empfohlen, da es zu verminderter Leistung und höheren Kosten führen kann.

Primitive Transformationen

Sie müssen mindestens eine einfache Transformation angeben, die auf die Eingabe angewendet werden soll. Dabei spielt es keine Rolle, ob sie nur auf bestimmte infoTypes oder auf den gesamten Textstring angewendet werden soll. In den folgenden Abschnitten werden Beispiele für Transformationsmethoden beschrieben, die Sie verwenden können. Eine Liste aller Transformationsmethoden, die Sensitive Data Protection bietet, finden Sie in der Transformationsreferenz.

replaceConfig

Wenn Sie replaceConfig für ein ReplaceValueConfig-Objekt festlegen, werden übereinstimmende Eingabewerte durch einen von Ihnen angegebenen Wert ersetzt.

Angenommen, Sie haben replaceConfig für alle infoTypes EMAIL_ADDRESS auf [email-address] festgelegt und der folgende String wird an Sensitive Data Protection gesendet:

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

Der zurückgegebene String sieht so aus:

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

Das folgende JSON-Beispiel und die Codes in mehreren Sprachen zeigen, wie die API-Anfrage formuliert wird und was die DLP API zurückgibt:

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