Datenklassifizierung mit den klassischen APIs verwenden¶

Übersicht¶

Die folgenden Beispiele für die Klassifizierung von Daten beziehen sich auf verschiedene Anwendungsfälle mit unterschiedlichen Datenumfängen:

• Einzelne Tabelle klassifizieren

• Alle Tabellen eines Schemas klassifizieren

• Alle Tabellen einer Datenbank klassifizieren

Wenn Sie die Klassifizierung erstmals anwenden, beginnen Sie mit der Klassifizierung einer einzelnen Tabelle, und fahren Sie dann mit den beiden anderen Beispielen fort.

Gemeinsame Tabelle und Rollen¶

In den Beispielen unter diesem Thema werden die folgende Tabelle und die folgenden kundenspezifischen Rollen verwendet:

• Tabelle: my_db.my_schema.hr_data, die Daten über Mitarbeiter enthält.

• Rollen:

  • data_engineer: Klassifiziert Tabellen.

  • policy_admin: Schützt personenbezogene Informationen durch eine Maskierungsrichtlinie.

  • analyst: Dient als Beispiel für eine kundenspezifische Rolle, deren Zugriff beschränkt werden soll. In den Beispielen wird davon ausgegangen, dass diese Rolle bereits vorhanden ist.

  • Datenbankrollen:

    • GOVERNANCE_ADMIN: Weist die Klassifizierungs-System-Tags zu.

    • GOVERNANCE_VIEWER: Führt die Abfragen auf Account Usage-Ansichten hinsichtlich Tags und Maskierungsrichtlinien aus.

1. Erstellen Sie die Tabelle:

   CREATE OR REPLACE TABLE hr_data (
       age INTEGER,
       email_address VARCHAR,
       fname VARCHAR,
       lname VARCHAR
       );
   

   Copy

2. Laden Sie die Tabelle (Details nicht gezeigt).

3. Erstellen Sie die kundenspezifischen Rollen, und weisen Sie diesen Rollen die erforderlichen Berechtigungen zu.

4. Die Rolle data_engineer benötigt Zugriff auf die Tabelle, um den Klassifizierungsprozess ausführen zu können. Beachten Sie, dass in diesem Beispiel die Datenbankrolle GOVERNANCE_ADMIN der Rolle data_engineer zugewiesen wird, da Rollen nicht in Datenbankrollen geändert werden können:

   use role accountadmin;
   
   create role data_engineer;
   
   grant usage on database my_db to role data_engineer;
   
   grant usage on schema my_db.my_schema to role data_engineer;
   
   grant select, update on table my_db.my_schema.hr_data to role data_engineer;
   
   grant database role snowflake.governance_admin to role data_engineer;
   

   Copy

5. Die kundenspezifische Rolle policy_admin muss jeder Spalte, die PII-Daten enthält, eine Maskierungsrichtlinie zuweisen:

   use role accountadmin;
   create role policy_admin;
   grant apply masking policy on account to role policy_admin;
   grant database role snowflake.governance_viewer to role policy_admin;
   

   Copy

Einzelne Tabelle klassifizieren¶

Im Beispiel mit einer einzelnen Tabelle wird der dreistufige Klassifizierungsprozess (d. h. Analysieren, Überprüfen und Anwenden) erweitert, um die Ergebnisse so anzuwenden, dass der kundenspezifischen Rolle analyst die Zugriffsberechtigung für die Tabelle entzogen wird.

USE ROLE SECURITYADMIN;

SELECT * FROM SNOWFLAKE.ACCOUNT_USAGE.TAG_REFERENCES
    WHERE TAG_NAME = 'PRIVACY_CATEGORY'
    AND TAG_VALUE= 'IDENTIFIER';

REVOKE SELECT ON TABLE my_db.my_schema.hr_data FROM ROLE analyst;

Alle Tabellen eines Schemas klassifizieren¶

In diesem Beispiel wird gezeigt, wie Sie alle Tabellen eines Schemas mithilfe von zwei von Ihnen erstellten benutzerdefinierten gespeicherten Prozeduren klassifizieren können:

• classify_schema: Listet alle Tabellen im Schema auf, erstellt eine Tabelle zur Speicherung der Klassifizierungsergebnisse und extrahiert dann die Klassifizierungs-Tags aus jeder Tabelle und speichert sie in der Ergebnistabelle.

• associate_tag_batch: Verwendet die Ergebnisse der gespeicherten Prozedur classify_schema, um allen Tabellenspalten im Schema automatisch die Klassifizierungs-System-Tags zuzuweisen, und gibt die Anzahl der jeder Tabelle zugewiesenen Tags zurück.

1. Erstellen Sie die erste Prozedur mit dem Namen classify_schema:

   create or replace procedure classify_schema(schema_name string, result_table string)
   returns object language JavaScript
   as $$
   // 1
   const table_names = snowflake.execute({
     sqlText: `show terse tables in schema identifier(?)`,
     binds: [SCHEMA_NAME],
   });
   
   // helper function for quoted table names
   function quote(name) {
     return '"'+ name.replace(/"/g,'""') + '"';
   }
   
   // create table to store results in. if it already exists, we will add to it rather than overwrite
   snowflake.execute({
       sqlText: `create temp table if not exists identifier(?) (table_name string, result variant)`,
       binds: [RESULT_TABLE],
   })
   // loop through tables
   while (table_names.next()) {
     let name = table_names.getColumnValue('name');
     // add schema to table name
     name = SCHEMA_NAME + "." + quote(name);
     // insert qualified table name and result into result table
     const results = snowflake.execute({
       sqlText: `insert into identifier(?) select ?, extract_semantic_categories(?)`,
       binds: [RESULT_TABLE, name, name],
     });
   }
   // return the number of tables classified
   return {tables_classified: table_names.getRowCount()};
   $$;
   

   Copy

2. Erstellen Sie die zweite Prozedur mit dem Namen associate_tag_batch:

   create or replace procedure associate_tag_batch(result_table string)
   returns Object language JavaScript
   as $$
   // get table names and classification results to loop through
   const tags_to_apply = snowflake.execute({
     sqlText: `select table_name, result from identifier(?)`,
     binds: [RESULT_TABLE],
   });
   
   const out = {};
   while (tags_to_apply.next()) {
     // get table name
     const name = tags_to_apply.getColumnValue('TABLE_NAME');
     // get classification result
     const classification_results = tags_to_apply.getColumnValue('RESULT');
     // call associate semantic category tags with table name and classification result
     const results = snowflake.execute({
       sqlText: `call associate_semantic_category_tags(?, parse_json(?))`,
       binds: [name, JSON.stringify(classification_results)],
     });
     results.next();
     out[name] = results.getColumnValue(1).split('\n');
   }
   // return number of tags applied per table
   return out;
   $$;
   

   Copy

3. Rufen Sie die gespeicherte Prozedur classify_schema mit dem Namen des Schemas auf, das Sie klassifizieren möchten, und mit dem Namen einer temporären Tabelle, die die Ergebnisse von EXTRACT_SEMANTIC_CATEGORY für jede Tabelle enthält:

   call classify_schema('my_db.my_schema','my_temporary_classification_table');
   

   Copy

4. Überprüfen Sie die Ergebnisse in der temporären Tabelle, und ändern Sie diese bei Bedarf.

5. Wenn Sie mit den Ergebnissen zufrieden sind, rufen Sie die gespeicherte Prozedur associate_tag_batch auf, um die Klassifizierungs-System-Tags den Tabellenspalten zuzuweisen:

   call associate_tag_batch('my_temporary_classification_table');
   

   Copy

Alle Tabellen einer Datenbank klassifizieren¶

In diesem Beispiel wird gezeigt, wie Sie alle Tabellen einer Datenbank mithilfe von zwei gespeicherten Prozeduren klassifizieren können:

• classify_database: Klassifiziert alle Tabellen innerhalb eines Schemas für jedes Schema in der Datenbank und gibt die Anzahl der Tabellen und die Anzahl der Schemas zurück, die klassifiziert wurden.

• associate_tag_batch: Führt die gleichen Operationen aus, wie sie in Alle Tabellen eines Schemas klassifizieren (unter diesem Thema) definiert sind.

1. Erstellen Sie die gespeicherte Prozedur classify_database:

   create or replace procedure classify_database(database_name string, result_table string)
   returns Object language JavaScript
   as $$
   // get list of schemas in database
   const schema_names = snowflake.execute({
     sqlText: `show terse schemas in database identifier(?)`,
     binds: [DATABASE_NAME],
   });
   
   // helper function for quoted schema names
   function quote(name) {
     return '"'+ name.replace(/"/g,'""') + '"';
   }
   
   // counter for tables. will use result from classify_schema to increment
   let table_count = 0
   while (schema_names.next()) {
     let name = schema_names.getColumnValue('name');
     // skip the information schema
     if (name == "INFORMATION_SCHEMA") {
       continue;
     }
     // add database name to schema
     name = DATABASE_NAME + "." + quote(name);
     // call classify_schema on each schema. This will loop over tables in schema
     const results = snowflake.execute({
       sqlText: `call classify_schema(?, ?)`,
       binds: [name, RESULT_TABLE],
     });
     results.next();
     // increment total number of tables by the number of tables in the schema
     table_count += results.getColumnValue(1).tables_classified ;
   }
   
   return {
       tables_classified: table_count,
       // subtract one from number of schemas because we skip the information schema
       schemas_classified: schema_names.getRowCount() - 1,
   };
   $$;
   

   Copy

2. Rufen Sie die gespeicherte Prozedur classify_database mit dem Namen der Datenbank auf, die Sie klassifizieren möchten, und mit dem Namen der temporären Tabelle, in der die Ergebnisse jedes Schemas der Datenbank gespeichert werden sollen:

   call classify_database('my_db','my_temporary_classification_table');
   

   Copy

3. Navigieren Sie zu jedem Schema. Überprüfen Sie jeweils die temporäre Tabelle, und überarbeiten Sie diese bei Bedarf.

4. Wenn Sie mit den Ergebnissen zufrieden sind, rufen Sie die gespeicherte Prozedur associate_tag_batch einmal für jedes Schema auf, um die Tags auf die Tabellen in diesem Schema anzuwenden: Wenn die Datenbank beispielsweise drei Schemas enthält, rufen Sie die gespeicherte Prozedur dreimal auf:

   call associate_tag_batch('my_temporary_classification_table');
   

   Copy