Datenklassifizierung verwenden

Unter diesem Thema finden Sie Beispiele für die Verwendung des Klassifizierungsprozesses in Snowflake.

Unter diesem Thema:

Übersicht

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

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: Führt den Klassifizierungsprozess aus.

    • 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.

Schritt 1: Tabellenspalten klassifizieren

In diesem Schritt führt der data_engineer den Klassifizierungsprozess aus, und der policy_admin schützt die Spaltendaten mit einer Maskierungsrichtlinie.

  1. Analysieren: Rufen Sie mit der kundenspezifischen Rolle data_engineer die Funktion EXTRACT_SEMANTIC_CATEGORIES auf, um die Spalten in der Tabelle mit dem Namen my_db.my_schema.hr_data zu klassifizieren:

    USE ROLE data_engineer;
    
    SELECT EXTRACT_SEMANTIC_CATEGORIES('my_db.my_schema.hr_data');
    
    Copy
  2. Überprüfen: Der Data Engineer überprüft die Ergebnisse, um sicherzustellen, dass sie sinnvoll sind. Weitere Informationen dazu finden Sie unter Interpretation der Ausgabe.

  3. Anwenden: Der Data Engineer weist den Spalten ein Klassifizierungs-System-Tag zu.

    Der Data Engineer hat zwei Optionen: automatische Zuweisung oder manuelle Zuweisung.

    Für die automatische Zuweisung der System-Tags wird die gespeicherte Prozedur ASSOCIATE_SEMANTIC_CATEGORY_TAGS aufgerufen. Hinweis:

    • Der vollqualifizierte Namen von Tabelle und Funktion aus dem ersten Schritt sind Argumente für die gespeicherte Prozedur.

    • Die gespeicherte Prozedur führt die Funktion EXTRACT_SEMANTIC_CATEGORIES erneut aus. Wenn Sie die Ergebnisse des ersten Schritts aufbewahren möchten, speichern Sie erst die Ergebnisse in einer Tabelle und rufen dann die gespeicherte Prozedur auf.

      CALL ASSOCIATE_SEMANTIC_CATEGORY_TAGS(
         'my_db.my_schema.hr_data',
          EXTRACT_SEMANTIC_CATEGORIES('my_db.my_schema.hr_data')
      );
      
      Copy

      Wenn die gespeicherte Prozedur erfolgreich ausgeführt wurde, gibt sie eine Meldung ähnlich der folgenden zurück: Applied tag semantic_category to <n> columns. Applied tag privacy_category to <n> columns.

    Wenn die gespeicherte Prozedur nicht ausgeführt wird oder wenn die Entscheidung darin besteht, das Klassifizierungs-System-Tag jeder Spalte nach Bedarf manuell zuzuweisen, verwenden Sie eine ALTER TABLE … ALTER COLUMN-Anweisung. Weisen Sie zum Beispiel der Spalte FNAME (d. h. dem Vornamen) eines der beiden System-Tags zu.

    USE ROLE data_engineer;
    
    ALTER TABLE my_db.my_schema.hr_data
      MODIFY COLUMN fname
      SET TAG SNOWFLAKE.CORE.SEMANTIC_CATEGORY='NAME';
    
    Copy

    oder

    ALTER TABLE my_db.my_schema.hr_data
      MODIFY COLUMN fname
      SET TAG SNOWFLAKE.CORE.PRIVACY_CATEGORY='IDENTIFIER';
    
    Copy

Schritt 2: Tabellenspalten schützen

In diesem Schritt wird davon ausgegangen, dass mehreren Spalten in der Tabelle my_db.my_schema.hr_data das Tag PRIVACY_CATEGORY = 'IDENTIFIER' zugewiesen ist und dass diese Spalten mit einer Maskierungsrichtlinie geschützt werden müssen.

So schützen Sie diese Spalten:

  1. Verwenden Sie die Ansicht policy_admin, um die Spalten zu finden, auf die das Datenschutz-Tag IDENTIFIER angewendet wurde.

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

    Die Latenz der Ansicht TAG_REFERENCES kann bis zu 120 Minuten betragen. Wenn Sie die Ergebnisse schneller benötigen und den Namen der Spalte kennen, für die Sie die Klassifizierungs-Tags abfragen, können Sie stattdessen die Tabellenfunktionen TAG_REFERENCES oder TAG_REFERENCES_ALL_COLUMNS verwenden.

  2. Verwenden Sie die Rolle policy_admin, um Maskierungsrichtlinien auf die entsprechenden Spalten anzuwenden. Mit der folgenden Anweisung wird beispielsweise die Maskierungsrichtlinie identifier_mask auf die Spalte fname angewendet:

    ALTER TABLE my_db.my_schema.hr_data
      MODIFY COLUMN fname
      SET MASKING POLICY governance.policies.identifier_mask;
    
    Copy

Schritt 3: Klassifizierungs-Tags zum Entziehen des Zugriffs verwenden

Abschließend führt der Sicherheitsadministrator (d. h. ein Benutzer mit der Rolle SECURITYADMIN) Folgendes aus:

  • Abfragen der Ansicht TAG_REFERENCES, um alle Spalten mit dem Datenschutz-Tag IDENTIFIER zu ermitteln.

  • Entziehen der SELECT-Berechtigung auf Tabellen, für die das PRIVACY_CATEGORY = 'IDENTIFIER'-Tag auf eine Spalte gesetzt ist, für die kundenspezifischen Rolle analyst:

Tipp

Sie müssen nicht die Systemrolle SECURITYADMIN verwenden, um diese Aufgaben auszuführen. Sie können jede beliebige kundenspezifische Rolle verwenden, die über die erforderlichen Berechtigungen verfügt.

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

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.

Wichtig

Die gespeicherte Prozedur mit dem Namen classify_schema erstellt eine temporäre Tabelle zum Speichern der Ergebnisse. Die temporäre Tabelle existiert für die Dauer der Benutzersitzung des Benutzers, der diese gespeicherte Prozedur aufruft. Wenn die Benutzersitzung abläuft, löscht Snowflake die temporäre Tabelle, und der Benutzer muss die gespeicherte Prozedur erneut aufrufen, um die temporäre Tabelle neu zu erstellen.

Wenn die temporäre Tabelle erhalten bleiben soll, entfernen Sie beim Erstellen der Tabelle das Schlüsselwort temp aus dem sqlText-Befehl.

Weitere Informationen dazu finden Sie unter der Option TEMP[ORARY] des Befehls CREATE TABLE.

  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. Weitere Informationen dazu finden Sie unter Interpretation der Ausgabe.

  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