Using custom classifiers to implement custom semantic categories¶

The CUSTOM_CLASSIFIER class allows data engineers to extend their sensitive data classification capabilities based on their own knowledge of their data. To classify sensitive data into custom semantic categories, create an instance of the CUSTOM_CLASSIFIER class in a schema and call instance methods to add regular expressions associated with the 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 :

Commandes :
Méthodes :

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: database role that enables you to create a custom classifier instance.
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.

You can grant the instance roles to account roles and database roles to enable other users to work with custom classifier instances:

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>

Copy

Où :

name: Specifies the name of the custom classifier instance.
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;

Copy

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;

Copy

Exemple¶

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

Identifiez une table à classer.
Utilisez SQL pour effectuer les opérations suivantes :
1. Create a custom classifier instance.
2. Add the custom semantic category and regular expressions to the instance.
3. Classer la table.

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

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 | +-------------+----------------------------------------------------------+
Copy
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.
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;
Copy
As the data owner, create a schema to store your custom classifier instances:
USE ROLE data_owner; CREATE SCHEMA data.classifiers;
Copy
Use the CREATE CUSTOM_CLASSIFIER command to create a custom classifier instance in the data.classifiers schema:
```
CREATE OR REPLACE SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER medical_codes();
```
Copy
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.

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

SHOW SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER;

Copy

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

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
);
```
Copy
Renvoie :
```
+---------------+
|   ADD_REGEX   |
+---------------+
| ICD_10_CODES  |
+---------------+
```
Astuce

Test the regular expression before adding a regular expression to the custom classifier instance. For example:
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}');
Copy
```
+-------------+
| 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).

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

Copy

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.

Appelez la procédure stockée SYSTEM$CLASSIFY_SCHEMA pour classer la table.
If the instance is no longer needed, use the DROP CUSTOM_CLASSIFIER command to remove a custom classifier instance from the system:
```
DROP SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER data.classifiers.medical_codes;
```
Copy

Audit des classificateurs personnalisés¶

You can use the following queries to audit the creation of custom classifier instances, adding regular expressions to instances, and dropping the instance.

To audit the creation of custom classifier instances, use the following query:

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

Copy

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;

Copy

To audit dropping a custom classifier instance, use the following query:

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

Copy