Verwenden von kundenspezifischen Klassifikatoren zur Implementierung kundenspezifischer semantischer Kategorien

Mit der Klasse CUSTOM_CLASSIFIER können Data Engineers ihre Fähigkeiten zur Klassifizierung sensibler Daten auf der Grundlage ihres eigenen Wissens über ihre Daten erweitern. Um sensible Daten in benutzerdefinierte semantische Kategorien zu klassifizieren, erstellen Sie eine Instanz der CUSTOM_CLASSIFIER-Klasse in einem Schema und rufen Instanzmethoden auf, um reguläre Ausdrücke hinzuzufügen, die mit der Instanz verbunden sind.

Ein End-to-End-Beispiel für die Verwendung einer CUSTOM_CLASSIFIER-Instanz, um eine kundenspezifische semantische Kategorie zu erstellen, finden Sie unter Beispiel.

Befehle und Methoden

Die folgenden Methoden und SQL-Befehle werden unterstützt:

Zugriffssteuerung

Diese Abschnitte fassen die Rollen und Berechtigungen für verschiedene Objekte zusammen, die Sie für die Verwendung einer Instanz benötigen.

Rollen

Sie können die folgenden Rollen mit einer benutzerdefinierten Klassifizierung verwenden:

  • SNOWFLAKE.CLASSIFICATION_ADMIN: Datenbankrolle, mit der Sie eine kundenspezifische Klassifikatorinstanz erstellen können.

  • custom_classifier !PRIVACY_USER: Instanzrolle, mit der Sie die folgenden Methoden auf der Instanz aufrufen können:

    • ADD_REGEX

    • LIST

    • DELETE_CATEGORY

  • Die Kontorolle mit OWNERSHIP-Berechtigung für die Instanz ermöglicht das Ausführen folgender Befehle:

    • DROP CUSTOM_CLASSIFIER

    • SHOW CUSTOM_CLASSIFIER

Zuweisungen

Um Instanzen zu erstellen und zu verwalten, können Sie entweder einer Rolle die CREATE SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER-Berechtigung erteilen oder einer Rolle die Instanzrolle PRIVACY_USER zuweisen.

Sie können die Instanzrollen an Kontorollen und Datenbankrollen vergeben, damit andere Benutzer mit kundenspezifischen Klassifikatorinstanz arbeiten können.

GRANT SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER ROLE <name>!PRIVACY_USER
  TO ROLE <role_name>

REVOKE SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER ROLE <name>!PRIVACY_USER
  FROM ROLE <role_name>

GRANT SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER ROLE <name>!PRIVACY_USER
  TO DATABASE ROLE <database_role_name>

REVOKE SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER ROLE <name>!PRIVACY_USER
  FROM DATABASE ROLE <database_role_name>

Wobei:

name

Gibt den Namen der kundenspezifischen Klassifikatorinstanz an.

role_name

Gibt den Namen einer Kontorolle an.

database_role_name

Gibt den Namen eine Datenbankrolle an.

Sie müssen ein Warehouse verwenden, um Methoden für die Instanz aufzurufen.

Um der kundenspezifischen Rolle my_classification_role die erforderliche Instanzrolle und die Berechtigung zur Erstellung und Verwendung einer Instanz der Klasse CUSTOM_CLASSIFIER zu erteilen, führen Sie die folgenden Anweisungen aus:

USE ROLE ACCOUNTADMIN;
GRANT DATABASE ROLE SNOWFLAKE.CLASSIFICATION_ADMIN
  TO ROLE my_classification_role;
GRANT USAGE ON DATABASE mydb TO ROLE my_classification_role;
GRANT USAGE ON SCHEMA mydb.instances TO ROLE my_classification_role;
GRANT USAGE ON WAREHOUSE wh_classification TO ROLE my_classification_role;

Wenn Sie einer bestimmten Rolle, z. B. data_analyst, die Nutzung einer bestimmten Instanz ermöglichen möchten, gehen Sie wie folgt vor:

GRANT SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER ROLE
  mydb.sch.my_instance!PRIVACY_USER TO ROLE data_analyst;

Beispiel

Der allgemeine Ansatz zum Klassifizieren von Daten mit kundenspezifischen Klassifikatoren ist wie folgt:

  1. Identifizieren Sie eine Tabelle zur Klassifizierung.

  2. Verwenden Sie SQL, um Folgendes zu tun:

    1. Erstellen Sie eine kundenspezifische Klassifikatorinstanz.

    2. Fügen Sie die benutzerdefinierte semantische Kategorie und die regulären Ausdrücke zur Instanz hinzu.

    3. Klassifizieren Sie die Tabelle.

Führen Sie die folgenden Schritte aus, um einen kundenspezifischen Klassifikator zum Klassifizieren einer Tabelle zu erstellen:

  1. Angenommen, wir haben eine Tabelle data.tables.patient_diagnosis, in der eine der Spalten Diagnosecodes enthält, z. B. ICD-10-Codes.

    +-------------+----------------------------------------------------------+
| ICD_10_CODE | DESCRIPTION                                              |
+-------------+----------------------------------------------------------+
| G30.9       | Alzheimer's disease, unspecified                         |
| G80.8       | Other cerebral palsy                                     |
| S13.4XXA    | Sprain of ligaments of cervical spine, initial encounter |
+-------------+----------------------------------------------------------+

    Diese Tabelle kann auch Spalten enthalten, über die Patienten, die in einer medizinischen Einrichtung behandelt wurden, identifiziert werden können, z. B. Vor- und Nachname, eindeutige Krankenversicherungsnummer und Geburtsdatum. Der Dateneigentümer kann die Tabelle klassifizieren, um sicherzustellen, dass die Spalten korrekt getaggt sind, sodass die Tabelle überwacht werden kann.

    In diesem Beispiel verfügt der Dateneigentümer bereits über diese Berechtigungen, die seiner Rolle zugewiesen sind:

    • OWNERSHIP für die zu klassifizierende Tabelle

    • OWNERSHIP für das Schema, das die Tabelle enthält

    • USAGE für die Datenbank, die das Schema und die Tabelle enthält

  2. Erlauben Sie dem Dateneigentümer das Klassifizieren der Tabelle, indem Sie der Dateneigentümerrolle die Datenbankrolle SNOWFLAKE.CLASSIFICATION_ADMIN zuweisen:

    USE ROLE ACCOUNTADMIN;
GRANT DATABASE ROLE SNOWFLAKE.CLASSIFICATION_ADMIN
  TO ROLE data_owner;

  3. Erstellen Sie als Dateneigentümer ein Schema zum Speichern Ihrer kundenspezifischen Klassifikatorinstanzen:

    USE ROLE data_owner;
CREATE SCHEMA data.classifiers;

  4. Verwenden Sie den Befehl CREATE CUSTOM_CLASSIFIER, um eine kundenspezifische Klassifikatorinstanz im Schema data.classifiers zu erstellen:

    CREATE OR REPLACE SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER medical_codes();

    Optional können Sie Ihren Suchpfad wie folgt aktualisieren:

    • Fügen Sie SNOWFLAKE.DATA_PRIVACY hinzu, damit Sie bei der Erstellung einer neuen Instanz der Klasse nicht den voll qualifizierten Namen der Klasse angeben müssen.

    • Fügen Sie DATA.CLASSIFIERS hinzu, damit Sie nicht den voll qualifizierten Namen der Instanz angeben müssen, wenn Sie eine Methode auf der Instanz aufrufen oder einen Befehl mit der Instanz verwenden.

  5. Verwenden Sie den Befehl SHOW CUSTOM_CLASSIFIER-Befehl, um jede von Ihnen erstellte Instanz aufzulisten. Beispiel:

    SHOW SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER;

    Rückgabewerte:

    +----------------------------------+---------------+---------------+-------------+-----------------+---------+-------------+
| created_on                       | name          | database_name | schema_name | current_version | comment | owner       |
+----------------------------------+---------------+---------------+-------------+-----------------+---------+-------------+
| 2023-09-08 07:00:00.123000+00:00 | MEDICAL_CODES | DATA          | CLASSIFIERS | 1.0             | None    | DATA_OWNER  |
+----------------------------------+---------------+---------------+-------------+-----------------+---------+-------------+

  6. Rufen Sie die Methode custom_classifier !ADD_REGEX auf der Instanz auf, um die System-Tags und den regulären Ausdruck zum Identifizieren von ICD-10-Codes in einer Spalte anzugeben. Der reguläre Ausdruck in diesem Beispiel entspricht allen möglichen ICD-10-Codes. Der reguläre Ausdruck für den Abgleich von Spaltenname, ICD.* und Kommentar ist optional:

    CALL medical_codes!ADD_REGEX(
  SEMANTIC_CATEGORY => 'ICD_10_CODES',
  PRIVACY_CATEGORY => 'IDENTIFIER',
  VALUE_REGEX => '[A-TV-Z][0-9][0-9AB]\.?[0-9A-TV-Z]{0,4}',
  COL_NAME_REGEX => 'ICD.*',
  DESCRIPTION => 'Add a regex to identify ICD-10 medical codes in a column',
  THRESHOLD => 0.8
);

    Rückgabewerte:

    +---------------+
|   ADD_REGEX   |
+---------------+
| ICD_10_CODES  |
+---------------+

    Tipp

    Testen Sie den regulären Ausdruck, bevor Sie der kundenspezifischen Klassifikatorinstanz einen regulären Ausdruck hinzufügen. Beispiel:

    SELECT icd_10_code
FROM medical_codes
WHERE icd_10_code REGEXP('[A-TV-Z][0-9][0-9AB]\.?[0-9A-TV-Z]{0,4}');

    +-------------+
| ICD-10-CODE |
+-------------+
| G30.9       |
| G80.8       |
| S13.4XXA    |
+-------------+

    Bei dieser Abfrage werden nur gültige Werte zurückgegeben, die mit dem regulären Ausdruck übereinstimmen. Die Abfrage gibt keine ungültigen Werte wie xyz zurück.

    Weitere Details dazu finden Sie unter Zeichenfolgenfunktionen (reguläre Ausdrücke).

  7. Rufen Sie die Methode custom_classifier !LIST auf der Instanz auf, um den regulären Ausdruck zu überprüfen, den Sie der Instanz hinzugefügt haben:

    SELECT medical_codes!LIST();

    Rückgabewerte:

    +--------------------------------------------------------------------------------+
| MEDICAL_CODES!LIST()                                                           |
+--------------------------------------------------------------------------------+
| {                                                                              |
|   "ICD-10-CODES": {                                                            |
|     "col_name_regex": "ICD.*",                                                 |
|     "description": "Add a regex to identify ICD-10 medical codes in a column", |
|     "privacy_category": "IDENTIFIER",                                          |
|     "threshold": 0.8,                                                          |
|     "value_regex": "[A-TV-Z][0-9][0-9AB]\.?[0-9A-TV-Z]{0,4}"                   |
|   }                                                                            |
| }                                                                              |
+--------------------------------------------------------------------------------+

    Um eine Kategorie zu entfernen, rufen Sie die Methode custom_classifier !DELETE_CATEGORY auf der Instanz auf.

  8. Rufen Sie die gespeicherte Prozedur SYSTEM$CLASSIFY_SCHEMA zum Klassifizieren der Tabelle auf.

  9. Wenn die Instanz nicht mehr benötigt wird, verwenden Sie den Befehl DROP CUSTOM_CLASSIFIER, um eine kundenspezifische Klassifikatorinstanz aus dem System zu entfernen:

    DROP SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER data.classifiers.medical_codes;

Auditing von kundenspezifischen Klassifikatoren

Mit den folgenden Abfragen können Sie die Erstellung von kundenspezifischen Klassifikatorinstanzen, das Hinzufügen regulärer Ausdrücke zu Instanzen und das Löschen der Instanz überprüfen.

  • Um die Erstellung von kundenspezifischen Klassifikatorinstanzen zu überprüfen, verwenden Sie die folgende Abfrage:

    SELECT * FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY
WHERE query_text ILIKE 'create % snowflake.data_privacy.custom_classifier%';

  • Um das Hinzufügen regulärer Ausdrücke zu einer bestimmten Instanz zu überprüfen, verwenden Sie die folgende Abfrage und ersetzen sie DB.SCH.MY_INSTANCE durch den Namen der Instanz, die Sie überprüfen möchten:

    SELECT
    QUERY_HISTORY.user_name,
    QUERY_HISTORY.role_name,
    QUERY_HISTORY.query_text,
    QUERY_HISTORY.query_id
  FROM
    SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY query_history,
    SNOWFLAKE.ACCOUNT_USAGE.ACCESS_HISTORY access_history,
      TABLE(FLATTEN(input => access_history.direct_objects_accessed)) flattened_value
WHERE flattened_value.value:"objectName" = 'DB.SCH.MY_INSTANCE!ADD_REGEX'
AND QUERY_HISTORY.query_id = ACCESS_HISTORY.query_id;

  • Um das Löschen einer kundenspezifischen Klassifikatorinstanz zu überprüfen, verwenden Sie die folgende Abfrage:

    SELECT * FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY
WHERE query_text ILIKE 'drop % snowflake.data_privacy.custom_classifier%';