Afficher et suivre les résultats de la classification des données sensibles

Cette rubrique décrit les moyens par lesquels vous pouvez afficher et suivre les résultats de la classification des données sensibles et la manière dont vous pouvez suivre les balises de classification pour surveiller les données sensibles.

Utiliser le Centre de confiance pour afficher les résultats de la classification

Pour voir les résultats de la classification des données sensibles dans le Centre de confiance, procédez comme suit :

  1. Connectez-vous à l”Snowsight en tant qu’utilisateur ayant les privilèges requis.

  2. Dans le menu de navigation, sélectionnez Governance & security » Trust Center.

  3. Sélectionnez l’onglet Data Security.

  4. Effectuez au choix :

    • Si vous souhaitez obtenir des informations de haut niveau sur la sécurité de vos données sensibles, sélectionnez l’onglet Dashboard. Pour plus d’informations, voir Examiner la page Tableau de bord.

    • Si vous souhaitez dresser la liste de toutes les tables et vues qui ont été classées comme contenant des données sensibles, sélectionnez l’onglet Sensitive objects.

      Lorsque la page s’ouvre, sélectionnez une table pour voir quelles colonnes contiennent des données sensibles, la catégorie sémantique de ces colonnes, et si des balises ont été appliquées aux colonnes.

Examiner la page Tableau de bord

La page Dashboard fournit des informations de haut niveau sur la sécurité de vos données sensibles, notamment le nombre de bases de données et de tables qui ont été classées. La page contient les vignettes suivantes :

Vignette

Description

Objects by compliance category

Identifie le nombre d’objets contenant des données susceptibles d’être soumises à une réglementation ou à une autre norme de conformité, en fonction du type d’informations contenues dans l’objet.

Note

Le mappage entre une catégorie de conformité et des catégories sémantiques n’est pas exhaustif. Seules les catégories sémantiques natives prises en charge par Snowflake sont mappées à une catégorie de conformité. Pour le mappage complet, consultez Catégories de conformité et leurs catégories sémantiques.

Vous êtes uniquement responsable de la détermination des réglementations ou des lois qui s’appliquent à vos données et de la garantie de la conformité avec les réglementations ou les lois applicables.

Objects by semantic category

Identifie les catégories sémantiques les plus courantes et le nombre d’objets contenant des données appartenant à ces catégories.

Databases monitored by auto-classification

Identifie les bases de données actuellement surveillées par la classification des données sensibles. Une base de données est partiellement surveillée si un utilisateur a utilisé SQL pour définir un profil de classification directement sur un schéma dans la base de données plutôt que de définir le profil au niveau de la base de données.

Classification status

Identifie si toutes les bases de données actuellement surveillées pour les données sensibles ont été classées.

Sensitive data masking status

Identifie si les données sensibles sont protégées par une politique de masquage. La politique de masquage peut être une politique basée sur des balises ou une politique qui a été appliquée manuellement à la colonne.

Une table est entièrement masquée si chaque colonne contenant des données sensibles est associée à une politique de masquage. Une table est partiellement masquée si seules certaines colonnes contenant des données sensibles sont associées à une politique de masquage.

Catégories de conformité et leurs catégories sémantiques

Note

Vous êtes uniquement responsable de la détermination des réglementations ou des lois qui s’appliquent à vos données et de la garantie de la conformité avec les réglementations ou les lois applicables. Les catégories de conformité au sein de la classification des données sensibles sont conçues pour vous fournir un ensemble d’outils prêts à l’emploi pour faciliter vos efforts, mais elles ne sont pas exhaustives. Seules les catégories sémantiques natives prises en charge par Snowflake sont mappées à une catégorie de conformité.

Avertissement

Les exigences HIPAA en matière de données imposent aux entités et aux partenaires commerciaux concernés de protéger la confidentialité, l’intégrité et la disponibilité des informations médicales protégées (PHI) au moyen de mesures de sécurité administratives, physiques et techniques strictes. La non-conformité à l’HIPAA peut entraîner des sanctions importantes. Les catégories sémantiques liées aux PHI sont incluses dans Informations sensibles.

Utilisez le tableau suivant pour comprendre la Objects by compliance category vignette sur la page Tableau de bord.

Catégorie de conformité

Catégorie sémantique native

Paramètre régional

Loi sur la protection des données personnelles numériques (DPDPA)

DATE_OF_BIRTH

s/o

DRIVERS_LICENSE

Inde (IN)

EMAIL

s/o

NAME

s/o

NATIONAL_IDENTIFIER

Inde (IN)

PHONE_NUMBER

s/o

STREET_ADDRESS

s/o

TAX_IDENTIFIER

Inde (IN)

Règlement général sur la protection des données (GDPR)

AGE

s/o

DRIVERS_LICENSE

Allemagne (DE), Autriche (AT), Belgique (BE), Bulgarie (BG), Chypre (CY), Croatie (HR), Danemark (DK), Espagne (ES), Estonie (EE), Finlande (FI), France (FR), Grèce (GR), Hongrie (HU), Irlande (IE), Italie (IT), Lettonie (LV), Lituanie (LT), Luxembourg (LU), Malte (MT), Pays-Bas (NL), Pologne (PL), Portugal (PT), République tchèque (CZ), Roumanie (RO), Slovaquie (SK), Slovénie (SI), Suède (SE)

EMAIL

s/o

ETHNICITY

s/o

GENDER

s/o

IBAN

s/o

IMEI

s/o

IP_ADDRESS

s/o

NAME

s/o

NATIONAL_IDENTIFIER

Allemagne (DE), Autriche (AT), Belgique (BE), Bulgarie (BG), Chypre (CY), Croatie (HR), Danemark (DK), Espagne (ES), Estonie (EE), Finlande (FI), France (FR), Grèce (GR), Hongrie (HU), Irlande (IE), Lettonie (LV), Lituanie (LT), Luxembourg (LU), Malte (MT), Pays-Bas (NL), Pologne (PL), Portugal (PT), République tchèque (CZ), Roumanie (RO), Royaume-Uni (UK), Slovaquie (SK), Slovénie (SI), Suède (SE)

PASSPORT

Allemagne (DE), Autriche (AT), Belgique (BE), Bulgarie (BG), Chypre (CY), Croatie (HR), Danemark (DK), Espagne (ES), Estonie (EE), Finlande (FI), France (FR), Grèce (GR), Hongrie (HU), Irlande (IE), Italie (IT), Lettonie (LV), Lituanie (LT), Luxembourg (LU), Malte (MT), Pays-Bas (NL), Pologne (PL), Portugal (PT), République tchèque (CZ), Roumanie (RO), Slovaquie (SK), Slovénie (SI), Suède (SE)

PAYMENT_CARD

s/o

PHONE_NUMBER

s/o

SALARY

s/o

TAX_IDENTIFIER

Allemagne (DE), Autriche (AT), Chypre (CY), Espagne (ES), France (FR), Grèce (GR), Hongrie (HU), Italie (IT), Malte (MT), Pays-Bas (NL), Pologne (PL), Portugal (PT), Slovaquie (SI), Suède (SE)

VIN

s/o

Loi américaine sur la modernisation des services financiers (GLBA)

BANK_ACCOUNT

États-Unis (US)

DRIVERS_LICENSE

États-Unis (US)

NAME

États-Unis (US)

NATIONAL_IDENTIFIER

États-Unis (US)

PASSPORT

États-Unis (US)

PAYMENT_CARD

s/o

STREET_ADDRESS

États-Unis (US)

TAX_IDENTIFIER

États-Unis (US)

Loi sur la transférabilité et la responsabilité en matière d’assurance maladie (HIPAA)

ADMINISTRATIVE_AREA_1

États-Unis (US)

ADMINISTRATIVE_AREA_2

États-Unis (US)

AGE

s/o

CITY

États-Unis (US)

DATE_OF_BIRTH

s/o

EMAIL

s/o

ETHNICITY

s/o

IMEI

s/o

IP_ADDRESS

s/o

MEDICAL_DATA

s/o

MEDICAL_SPECIALTY

s/o

NAME

s/o

NATIONAL_IDENTIFIER

États-Unis (US)

PHONE_NUMBER

États-Unis (US)

POSTAL_CODE

États-Unis (US)

STREET_ADDRESS

États-Unis (US)

URL

s/o

VIN

s/o

Secteur des cartes de paiement (PCI)

PAYMENT_CARD

s/o

Informations personnelles identifiables (PII)

DATE_OF_BIRTH

s/o

DRIVERS_LICENSE

s/o

EMAIL

s/o

NAME

s/o

NATIONAL_IDENTIFIER

s/o

PHONE_NUMBER

s/o

STREET_ADDRESS

s/o

TAX_IDENTIFIER

s/o

Utiliser SQL pour afficher les résultats de la classification

Vous pouvez utiliser SQL pour afficher les résultats de la classification des données en appelant une fonction système ou en interrogeant une vue d’utilisation du compte.

Récupérer les résultats de la classification pour une table spécifique

Appelez la fonction SYSTEM$GET_CLASSIFICATION_RESULT pour afficher les résultats d’une table spécifique.

CALL SYSTEM$GET_CLASSIFICATION_RESULT('mydb.sch.t1');

Les résultats ne sont pas disponibles tant que le processus de classification n’est pas terminé. Le processus de classification automatique ne démarre qu’une heure après la configuration du profil de classification sur la base de données.

Interroger les derniers résultats de la classification

Pour afficher les derniers résultats de la classification, interrogez la vue DATA_CLASSIFICATION_LATEST. Les résultats de la classification avant les derniers résultats ne sont pas affichés. Par exemple, vous pouvez utiliser un rôle auquel le rôle de base de données SNOWFLAKE.GOVERNANCE_VIEWER a été accordé. D’autres privilèges peuvent également fournir un accès, tels que l’utilisation de ACCOUNTADMIN ou la présence de IMPORTED PRIVILEGES sur la base de données SNOWFLAKE.

SELECT * FROM SNOWFLAKE.ACCOUNT_USAGE.DATA_CLASSIFICATION_LATEST;

Les résultats peuvent ne pas apparaître avant trois heures après la fin de la classification. Pour afficher les résultats de la classification précédente, consultez Interroger l’historique de la classification.

Interroger l’historique de la classification

Pour afficher tous les événements de la classification au cours des 365 derniers jours, interrogez la vue DATA_CLASSIFICATION_HISTORY. Par exemple, vous pouvez utiliser un rôle auquel le rôle de base de données SNOWFLAKE.GOVERNANCE_VIEWER a été accordé. D’autres privilèges peuvent également fournir un accès, tels que l’utilisation de ACCOUNTADMIN ou la présence de IMPORTED PRIVILEGES sur la base de données SNOWFLAKE.

SELECT * FROM SNOWFLAKE.ACCOUNT_USAGE.DATA_CLASSIFICATION_HISTORY;

Utilisez les exemples suivants pour interroger l’historique de la classification :

Filtrer l’historique de la classification par nom de base de données, de schéma et de table

L’exemple suivant renvoie tous les événements de la classification d’une table spécifique en filtrant par nom de base de données, nom de schéma et nom de table, classés du plus récent au plus ancien :

SELECT
    database_id,
    database_name,
    schema_id,
    schema_name,
    table_id,
    table_name,
    trigger_type,
    classified_on,
    table_deleted_on,
    result
  FROM SNOWFLAKE.ACCOUNT_USAGE.DATA_CLASSIFICATION_HISTORY
  WHERE database_name = 'MY_DB'
    AND schema_name = 'MY_SCHEMA'
    AND table_name = 'EMPLOYEES'
  ORDER BY classified_on DESC;

La sortie affiche deux événements de classification pour la même table EMPLOYEES : une classification manuelle de février 2025 qui identifiait la colonne EMAIL et une classification automatique ultérieure de mars 2025 qui identifiait les colonnes EMAIL et SSN. Les résultats sont classés du plus récent au plus ancien, montrant comment les résultats de la classification peuvent évoluer dans le temps.

+-------------+---------------+-----------+-------------+----------+------------+---------------------+---------------------------+----------------+--------------------------------+
| DATABASE_ID | DATABASE_NAME | SCHEMA_ID | SCHEMA_NAME | TABLE_ID | TABLE_NAME | TRIGGER_TYPE        | CLASSIFIED_ON             | TABLE_DELETED_ON | RESULT                         |
+-------------+---------------+-----------+-------------+----------+------------+---------------------+---------------------------+----------------+--------------------------------+
| 10          | MY_DB         | 100       | MY_SCHEMA   | 1234     | EMPLOYEES  | AUTO CLASSIFICATION | 2025-03-01 08:00:00 -0800 | NULL           | {"EMAIL": {...}, "SSN": {...}} |
| 10          | MY_DB         | 100       | MY_SCHEMA   | 1234     | EMPLOYEES  | MANUAL              | 2025-02-15 14:30:00 -0800 | NULL           | {"EMAIL": {...}}               |
+-------------+---------------+-----------+-------------+----------+------------+---------------------+---------------------------+----------------+--------------------------------+

Filtrer par ID de table

L’exemple suivant filtre l’historique de la classification par ID de table pour renvoyer tous les événements de la classification d’une table spécifique, classés par le plus récent en premier :

Note

Le filtrage par ID peut être utile si la table a été renommée après la classification.

SELECT
    database_id,
    database_name,
    schema_id,
    schema_name,
    table_id,
    table_name,
    trigger_type,
    classified_on,
    table_deleted_on,
    result
  FROM SNOWFLAKE.ACCOUNT_USAGE.DATA_CLASSIFICATION_HISTORY
  WHERE table_id = 1234
  ORDER BY classified_on DESC;

La sortie montre deux événements de la classification pour la même table (ID 1234), même si la table a été renommée EMPLOYEES_NEW à la place de EMPLOYEES entre les événements. Étant donné que la requête filtre par ID de table plutôt que par nom, les deux événements sont renvoyés quel que soit le changement de nom.

+-------------+---------------+-----------+-------------+----------+---------------+---------------------+---------------------------+----------------+--------------------------------+
| DATABASE_ID | DATABASE_NAME | SCHEMA_ID | SCHEMA_NAME | TABLE_ID | TABLE_NAME    | TRIGGER_TYPE        | CLASSIFIED_ON             | TABLE_DELETED_ON | RESULT                         |
+-------------+---------------+-----------+-------------+----------+---------------+---------------------+---------------------------+----------------+--------------------------------+
| 10          | MY_DB         | 100       | MY_SCHEMA   | 1234     | EMPLOYEES_NEW | AUTO CLASSIFICATION | 2025-03-01 08:00:00 -0800 | NULL           | {"EMAIL": {...}, "SSN": {...}} |
| 10          | MY_DB         | 100       | MY_SCHEMA   | 1234     | EMPLOYEES     | MANUAL              | 2025-02-15 14:30:00 -0800 | NULL           | {"EMAIL": {...}}               |
+-------------+---------------+-----------+-------------+----------+---------------+---------------------+---------------------------+----------------+--------------------------------+

Compter les événements de la classification au cours des sept derniers jours

L’exemple suivant montre le nombre d’événements de la classification au cours des sept derniers jours :

SELECT
    COUNT(*) AS classification_count
  FROM SNOWFLAKE.ACCOUNT_USAGE.DATA_CLASSIFICATION_HISTORY
  WHERE classified_on >= DATEADD(DAY, -7, CURRENT_TIMESTAMP());

+----------------------+
| CLASSIFICATION_COUNT |
+----------------------+
| 42                   |
+----------------------+

Comparer les exécutions de la classification pour une même table

L’exemple suivant compare les deux exécutions de la classification les plus récentes pour une table et renvoie uniquement les colonnes dont la classification a changé entre les exécutions. Chaque ligne du résultat comprend une colonne change_type avec l’une des valeurs suivantes :

  • ADDED : La colonne n’a pas été classée lors de l’exécution précédente. Les colonnes PREV_* sont NULL.

  • REMOVED : La colonne a été classée lors de l’exécution précédente, mais pas dans l’exécution actuelle. Les colonnes CURR_* sont NULL.

  • CHANGED : La colonne existe dans les deux exécutions, mais sa sémantique ou sa catégorie de confidentialité diffère.

Les colonnes dont la classification était identique dans les deux exécutions sont exclues des résultats.

WITH ranked AS (
    SELECT
        table_id,
        database_id,
        schema_id,
        database_name,
        schema_name,
        table_name,
        classified_on,
        trigger_type,
        result,
        ROW_NUMBER() OVER (PARTITION BY table_id ORDER BY classified_on DESC) AS rn
      FROM SNOWFLAKE.ACCOUNT_USAGE.DATA_CLASSIFICATION_HISTORY
      WHERE table_id = 1234
    ),
  curr_cols AS (
      SELECT r.table_id, r.database_id, r.schema_id,
          r.database_name, r.schema_name, r.table_name,
          r.classified_on, r.trigger_type,
          c.key AS column_name, c.value AS column_result
        FROM ranked r, LATERAL FLATTEN(input => r.result) c
        WHERE r.rn = 1
  ),
  prev_cols AS (
      SELECT r.table_id,
          r.classified_on, r.trigger_type,
          c.key AS column_name, c.value AS column_result
        FROM ranked r, LATERAL FLATTEN(input => r.result) c
        WHERE r.rn = 2
  )
  SELECT
      curr.database_id,
      curr.database_name,
      curr.schema_id,
      curr.schema_name,
      curr.table_id,
      curr.table_name,
      prev.classified_on AS previous_classified_on,
      curr.classified_on AS current_classified_on,
      COALESCE(curr.column_name, prev.column_name) AS column_name,
      CASE
        WHEN prev.column_name IS NULL THEN 'ADDED'
        WHEN curr.column_name IS NULL THEN 'REMOVED'
        ELSE 'CHANGED'
      END AS change_type,
      prev.column_result:recommendation.semantic_category::STRING AS prev_semantic_category,
      curr.column_result:recommendation.semantic_category::STRING AS curr_semantic_category,
      prev.column_result:recommendation.privacy_category::STRING AS prev_privacy_category,
      curr.column_result:recommendation.privacy_category::STRING AS curr_privacy_category
    FROM curr_cols curr
    FULL OUTER JOIN prev_cols prev
      ON curr.table_id = prev.table_id
      AND curr.column_name = prev.column_name
    WHERE prev.column_name IS NULL
      OR curr.column_name IS NULL
      OR curr.column_result:recommendation.semantic_category != prev.column_result:recommendation.semantic_category
      OR curr.column_result:recommendation.privacy_category != prev.column_result:recommendation.privacy_category
    ORDER BY column_name;

La sortie montre trois colonnes dont la classification a changé entre les deux exécutions les plus récentes : DATE_OF_BIRTH et SSN étaient nouvellement identifiées (ADDED) dans l’exécution en cours, tandis que PHONE a été classifiée dans l’exécution précédente mais n’apparaît plus dans l’exécution actuelle (REMOVED). Les colonnes dont la classification est restée la même dans l’ensemble des exécutions, telles que EMAIL, sont exclues des résultats.

+-------+---------+-----------+-------------+----------+------------+---------------------+---------------------+---------------+-------------+---------------+---------------+--------------+------------------+
| DB_ID | DB_NAME | SCHEMA_ID | SCHEMA_NAME | TABLE_ID | TABLE_NAME | PREV_CLASSIFIED_ON  | CURR_CLASSIFIED_ON  | COLUMN_NAME   | CHANGE_TYPE | PREV_SEMANTIC | CURR_SEMANTIC | PREV_PRIVACY | CURR_PRIVACY     |
+-------+---------+-----------+-------------+----------+------------+---------------------+---------------------+---------------+-------------+---------------+---------------+--------------+------------------+
| 10    | MY_DB   | 100       | MY_SCHEMA   | 1234     | EMPLOYEES  | 2025-02-15 14:30:00 | 2025-03-01 08:00:00 | DATE_OF_BIRTH | ADDED       | NULL          | DATE_OF_BIRTH | NULL         | QUASI_IDENTIFIER |
| 10    | MY_DB   | 100       | MY_SCHEMA   | 1234     | EMPLOYEES  | 2025-02-15 14:30:00 | 2025-03-01 08:00:00 | PHONE         | REMOVED     | PHONE_NUMBER  | NULL          | IDENTIFIER   | NULL             |
| 10    | MY_DB   | 100       | MY_SCHEMA   | 1234     | EMPLOYEES  | 2025-02-15 14:30:00 | 2025-03-01 08:00:00 | SSN           | ADDED       | NULL          | US_SSN        | NULL         | IDENTIFIER       |
+-------+---------+-----------+-------------+----------+------------+---------------------+---------------------+---------------+-------------+---------------+---------------+--------------+------------------+

Afficher les résultats de la classification pour les colonnes JSON

Snowflake peut classer les colonnes de type ARRAY, VARIANT ou OBJECT lorsque les données semi-structurées sont au format JSON. Le résultat de cette classification présente les caractéristiques suivantes :

  • L’objet des résultats contient un champ object_path_results. Ce champ répertorie les objets, où chaque objet correspond à un champ dans les données semi-structurées qui a été classé dans une catégorie sémantique native.

  • Si un champ dans les données semi-structurées contient des données sensibles, la catégorie sémantique de la colonne est MULTIPLE. Pour obtenir la catégorie sémantique des champs dans les données semi-structurées, utilisez le champ object_path_results dans les résultats.

À titre d’exemple, supposons que Snowflake classe la table suivante :

+-----------------------------------------------------------+---------------+-----------------------------------------------------+
| ARRAY_COL                                                 | FIRST_NAME    | OBJECT_COL                                          |
+-----------------------------------------------------------+---------------+-----------------------------------------------------+
| [ { "email": "alice@example.com" }, { "email": "b..." } ] | "Joe"         | { "email": "jane@domain.com", "phone": "206-..." }  |
+-----------------------------------------------------------+---------------+-----------------------------------------------------+

Le résultat de la classification peut ressembler à ce qui suit :

{
  "ARRAY_COL": {
    "object_path_results": {
      "ARRAY_COL:[$$].email": {
        "alternates": [],
        "recommendation": {
          "confidence": "HIGH",
          "coverage": 1,
          "details": [],
          "privacy_category": "IDENTIFIER",
          "semantic_category": "EMAIL"
        }
      }
    },
    "recommendation": {
      "confidence": "HIGH",
      "details": [],
      "privacy_category": "IDENTIFIER",
      "semantic_category": "MULTIPLE"
    },
    "valid_value_ratio": 1
  },
  "FIRST_NAME": {
    "alternates": [],
    "recommendation": {
      "confidence": "HIGH",
      "coverage": 1,
      "details": [],
      "privacy_category": "IDENTIFIER",
      "semantic_category": "NAME"
    },
    "valid_value_ratio": 1
  },
  "OBJECT_COL": {
    "object_path_results": {
      "OBJECT_COL:email": {
        "alternates": [],
        "recommendation": {
          "confidence": "HIGH",
          "coverage": 1,
          "details": [],
          "privacy_category": "IDENTIFIER",
          "semantic_category": "EMAIL"
        }
      },
      "OBJECT_COL:phone": {
        "alternates": [],
        "recommendation": {
          "confidence": "HIGH",
          "coverage": 1,
          "details": [
            {
              "coverage": 1,
              "semantic_category": "US_PHONE_NUMBER"
            },
            {
              "coverage": 1,
              "semantic_category": "JP_PHONE_NUMBER"
            }
          ],
          "privacy_category": "IDENTIFIER",
          "semantic_category": "PHONE_NUMBER"
        }
      }
    },
    "recommendation": {
      "confidence": "HIGH",
      "details": [],
      "privacy_category": "IDENTIFIER",
      "semantic_category": "MULTIPLE"
    },
    "valid_value_ratio": 1
  }
}

Utiliser des balises pour suivre les données sensibles

Lorsque Snowflake classe les données sensibles, il suggère ou applique automatiquement des balises définies par le système et définies par l’utilisateur aux colonnes qui contiennent des données sensibles. Étant donné que les colonnes contenant des données sensibles se voient attribuer ces balises, vous pouvez surveiller les données sensibles en exécutant des requêtes et en appelant des fonctions pour suivre les balises.

Par exemple, pour dresser la liste de toutes les colonnes qui ont été classées et qui se sont vues attribuer une catégorie sémantique, vous pouvez exécuter la requête suivante :

SELECT * FROM SNOWFLAKE.ACCOUNT_USAGE.TAG_REFERENCES
  WHERE TAG_NAME = 'SEMANTIC_CATEGORY'
  ORDER BY object_database, object_schema, object_name, column_name;

Si vous voulez déterminer quelle catégorie sémantique a été attribuée à la colonne fname de la table hr_data, vous pouvez exécuter la requête suivante pour obtenir la valeur de la balise SEMANTIC_CATEGORY :

SELECT SYSTEM$GET_TAG(
    'SNOWFLAKE.CORE.SEMANTIC_CATEGORY',
    'hr_data.fname',
    'COLUMN'
    );

Pour plus d’informations sur les différentes manières de suivre les balises, consultez Surveiller les balises d’objet.