Utilisation de classificateurs personnalisés pour mettre en œuvre des catégories sémantiques personnalisées

La classe CUSTOM_CLASSIFIER </sql-reference-classes> permet aux ingénieurs de données d’étendre leurs capacités de classification des données sensibles en se basant sur leur propre connaissance des données. Pour classer les données sensibles en catégories sémantiques personnalisées, créez une instance de la classe CUSTOM_CLASSIFIER dans un schéma et appelez les méthodes de l’instance pour ajouter des expressions régulières associées à l’instance.

Pour un exemple de bout en bout d’utilisation d’une instance CUSTOM_CLASSIFIER pour créer une catégorie sémantique personnalisée, voir Exemple.

Commandes et méthodes

Les méthodes et commandes SQL suivantes sont prises en charge :

Contrôle d’accès

Ces sections résument les rôles et les attributions sur divers objets dont vous avez besoin pour utiliser une instance.

Rôles

Vous pouvez utiliser les rôles suivants avec une classification personnalisée :

  • SNOWFLAKE.CLASSIFICATION_ADMIN : rôle de base de données qui vous permet de créer une instance de classification personnalisée.

  • custom_classifier !PRIVACY_USER : rôle de l’instance qui vous permet d’appeler les méthodes suivantes sur l’instance :

    • ADD_REGEX

    • LIST

    • DELETE_CATEGORY

  • Le rôle de compte titulaire du privilège OWNERSHIP sur l’instance peut exécuter les commandes suivantes :

    • DROP CUSTOM_CLASSIFIER

    • SHOW CUSTOM_CLASSIFIER

Attributions

Pour créer et gérer des instances, vous pouvez choisir d’accorder le privilège CREATE SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER </sql-reference/sql/grant-privilege> à un rôle ou d’accorder le rôle d’instance PRIVACY_USER à un rôle.

Vous pouvez accorder les rôles d’instance à des rôles d’utilisateur et à des rôles de base de données pour permettre à d’autres utilisateurs d’utiliser des instances de classificateur personnalisé :

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>

Où :

name

Spécifie le nom de l’instance de classificateur personnalisé.

role_name

Spécifie le nom d’un rôle de compte.

database_role_name

Spécifie le nom d’un rôle de base de données.

Vous devez utiliser un entrepôt pour appeler des méthodes sur l’instance.

Pour accorder le rôle personnalisé my_classification_role, le rôle d’instance et les privilèges requis pour créer et utiliser une instance de la classe CUSTOM_CLASSIFIER, exécutez les instructions suivantes :

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;

Si vous souhaitez activer un rôle spécifique, tel que data_analyst, pour utiliser une instance spécifique, procédez comme suit :

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

Exemple

L’approche de haut niveau pour classer les données à l’aide de classificateurs personnalisés est la suivante :

  1. Identifiez une table à classer.

  2. Utilisez SQL pour effectuer les opérations suivantes :

    1. Créer l’instance du classificateur personnalisé.

    2. Ajouter la catégorie sémantique personnalisée et les expressions régulières à l’instance.

    3. Classer la table.

Procédez comme suit pour créer un classificateur personnalisé afin de classer une table :

  1. Prenons une table, data.tables.patient_diagnosis, dont l’une des colonnes contient des codes de diagnostic tels que des codes ICD-10.

    +-------------+----------------------------------------------------------+
| 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 |
+-------------+----------------------------------------------------------+

    Cette table peut également comprendre des colonnes permettant d’identifier les patients qui ont été traités dans un établissement médical, comme le prénom et le nom, les identificateurs uniques de l’assurance maladie et la date de naissance. Le propriétaire de données peut classer la table pour s’assurer que les colonnes sont correctement balisées afin que la table puisse être surveillée.

    Dans cet exemple, le propriétaire de données dispose déjà de ces privilèges dans le cadre de son rôle :

    • OWNERSHIP sur la table à classer.

    • OWNERSHIP sur le schéma contenant la table.

    • USAGE sur la base de données contenant le schéma et la table.

  2. Autorisez le propriétaire de données à classer la table en accordant le rôle de base de données SNOWFLAKE.CLASSIFICATION_ADMIN au rôle de propriétaire de données :

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

  3. En tant que propriétaire de données, créez un schéma pour stocker vos instances de classificateur personnalisé :

    USE ROLE data_owner;
CREATE SCHEMA data.classifiers;

  4. Utilisez la commande CREATE CUSTOM_CLASSIFIER pour créer une instance de classificateur personnalisé dans le schéma data.classifiers :

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

    Vous pouvez également mettre à jour votre chemin de recherche comme suit :

    • Ajoutez SNOWFLAKE.DATA_PRIVACY pour ne pas avoir à spécifier le nom complet de la classe lors de la création d’une nouvelle instance de la classe.

    • Ajoutez DATA.CLASSIFIERS pour ne pas avoir à spécifier le nom complet de la classe lors de l’appel d’une méthode sur l’instance ou de l’utilisation d’une commande avec l’instance.

  5. Utilisez une commande SHOW CUSTOM_CLASSIFIER pour répertorier chaque instance que vous créez. Par exemple :

    SHOW SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER;

    Renvoie :

    +----------------------------------+---------------+---------------+-------------+-----------------+---------+-------------+
| 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. Appelez la méthode custom_classifier !ADD_REGEX sur l’instance pour spécifier les balises système et l’expression régulière permettant d’identifier les codes ICD-10 dans une colonne. L’expression régulière de cet exemple correspond à tous les codes ICD-10 possibles. L’expression régulière correspondant au nom de colonne, ICD.*, et le commentaire sont facultatifs :

    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
);

    Renvoie :

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

    Astuce

    Testez l’expression régulière avant d’ajouter une expression régulière à l’instance de classificateur personnalisé. Par exemple :

    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    |
+-------------+

    Dans cette requête, seules les valeurs valides correspondant à l’expression régulière sont renvoyées. La requête ne renvoie pas de valeurs non valides telles que xyz.

    Pour plus de détails, voir Fonctions de chaîne (expressions régulières).

  7. Appelez la méthode custom_classifier !LIST sur l’instance pour vérifier l’expression régulière que vous avez ajoutée à l’instance :

    SELECT medical_codes!LIST();

    Renvoie :

    +--------------------------------------------------------------------------------+
| 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}"                   |
|   }                                                                            |
| }                                                                              |
+--------------------------------------------------------------------------------+

    Pour supprimer une catégorie, appelez la méthode custom_classifier !DELETE_CATEGORY sur l’instance.

  8. Appelez la procédure stockée SYSTEM$CLASSIFY_SCHEMA pour classer la table.

  9. Si l’instance n’est plus nécessaire, utilisez la commande DROP CUSTOM_CLASSIFIER pour supprimer une instance de classificateur personnalisé du système :

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

Audit des classificateurs personnalisés

Vous pouvez utiliser les requêtes suivantes pour auditer la création d’instances de classificateur personnalisé, l’ajout d’expressions régulières aux instances et la suppression de l’instance.

  • Pour auditer la création d’instances de classificateur personnalisé, utilisez la requête suivante :

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

  • Pour auditer l’ajout d’expressions régulières à une instance spécifique, utilisez la requête suivante et remplacez DB.SCH.MY_INSTANCE par le nom de l’instance que vous souhaitez auditer :

    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;

  • Pour auditer la suppression d’une instance de classificateur personnalisé, utilisez la requête suivante :

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