Zum Inhalt springen
Search the hub

Series

End-to-End Data Governance

5 Parts · 53 min

End-to-End Data Governance

Teil 1

End-to-End-Governance-Architektur

End-to-End-Governance-Architektur

Die Serie End-to-End Data Governance gibt dir den Einstieg und den roten Faden für die folgenden Teile.

Begriffe vor dem Lesen

  • Governance — Gemeinsame Regeln, Rollen und Nachweise, damit Daten verantwortbar genutzt werden.
  • verantwortliche Person — Fachlich verantwortliche Person oder Rolle, die Zweck, Bedeutung und Freigabe klärt.
  • technischer Betreiber — Technische Rolle, die Plattform, Zugriff, Betrieb oder Umsetzung betreut.
  • Nachweis — Nachvollziehbarer Nachweis zu Entscheidung, Prüfung, Umsetzung oder Ausnahme.

Ausgangslage

End-to-End Governance — Richtlinien, Metadaten, dbt, Schutz und governte BI.

Was diese Serie klärt

  • Orientierung: End-to-End-Governance-Architektur
  • Vertiefung: Metadatengetriebene Governance mit dbt meta
  • Abschluss mit betreibbaren Next Steps über Snowflake Masking Richtlinien + Qlik Section Access

Begriffe und Kürzel vor dem Lesen

  • personenbezogene Daten — Personenbeziehbare Daten: Informationen, die allein oder kombiniert eine Person identifizieren können.
  • dbt — data build tool: SQL-nahe Transformationsschicht; Modelle brauchen verantwortliche Person, Tests und Verträge wie jedes Datenprodukt.
  • BI — Business Intelligence: Reporting- und Analyseflächen, die governte Kennzahlen und Datenprodukte nutzen.
  • verantwortliche Person — Person oder Rolle mit der Pflicht, Bedeutung, Nutzung, Risiko und Freigabe für ein Datenprodukt oder eine Kennzahl zu entscheiden.
  • Metadata — Daten über Daten: Definition, verantwortliche Person, Quelle, Aktualität, Qualität, Klassifikation, Lineage, Status.
  • Data Catalog — Auffindbarkeitsschicht für Assets, Begriffe, Owner und Richtlinien — eine Anwendung von Metadata, nicht Metadata selbst.

Lesepfad

  1. End-to-End-Governance-Architektur
  2. Metadatengetriebene Governance mit dbt meta
  3. Automatische RAW-Generierung mit dbt-Macros
  4. PII-Metadaten durch Data Warehouses propagieren
  5. Snowflake Masking Policies + Qlik Section Access

Die Beispiele sind Lehrfälle (keine Kundendaten). Ersetzt Tabellen-, Report-, Pfad- und Toolnamen durch eure Catalog-, BI-, Ticket- und Prozessquellen.

Governance ist eine Architektur — kein Katalog neben der Plattform

KMU/SMB — ein Produktpfad von Owner-Metadata über Transform, Protection und BI-Evidenz. Mid-Market — explizites führendes System je Metadata-Typ über zwei Plattformen. Enterprise — verbundene Data-/Metadata-/Control-Planes mit Incident-Feedback-Loop.

Ein Katalog und eine Richtlinien-PDF erzeugen noch keine End-to-End-Governance. Merke die Trennung: Metadata beschreibt und steuert; ein Katalog macht Metadata auffindbar und bearbeitbar; ein Dashboard konsumiert trusted Ergebnisse — es ist nicht der Katalog. Operativ wird es erst, wenn eine fachliche Regel in Metadaten, Transformation, Schutz und BI nachvollziehbar ankommt.

Katalog, Klassifikation und Richtlinie sind nützlich. Keines davon erzeugt allein die durchgängige Kette.

Governance wird erst operativ, wenn eine fachliche Entscheidung durch die technische Plattform verfolgt werden kann:

Fachliche Richtlinie
→ freigegebene Metadaten
→ implementierte Transformation
→ Laufzeitkontrolle
→ operativer Nachweis
→ Governance-Review

Endet die Kette nach der Dokumentation, kann die Plattform wissen, dass eine Spalte personenbezogene Daten enthält, ohne diese tatsächlich zu schützen.

Beginnt die Kette erst bei der Laufzeitsicherheit, kann eine Spalte maskiert sein, ohne den fachlichen Grund, die Verantwortung oder den Freigabestatus hinter dieser Kontrolle zu erhalten.

End-to-End-Governance verbindet Entscheidungen, Metadaten, Code, Schutz, Zugriff und Nachweise zu einem kontrollierten System.

Dieser Artikel definiert dieses System. Die folgenden Parts vertiefen einzelne Mechanismen.

Mit einer klaren Verantwortungsgrenze beginnen

Die erste Architekturentscheidung ist einfach, aber wichtig:

Die Ingestion lädt Daten in die Plattform. dbt transformiert Daten, die bereits dort vorhanden sind.

Ein typischer Ablauf lautet:

Quellsysteme
→ Ingestion oder Replikation
→ Landing-Tabellen
→ dbt-Transformation
→ governte Warehouse-Layer
→ governte Nutzung

Der Ingestion-Mechanismus kann ein Managed Connector, ein CDC-Service, eine Orchestrierungspipeline, ein File Loader oder ein eigener Prozess sein.

Zu seinen Verantwortlichkeiten gehören:

  • Verbindung zu Quellsystemen;
  • Extraktion und Laden von Datensätzen;
  • Erhalt technischer Liefermetadaten;
  • Wiederholungen und Checkpoints;
  • Erkennung fehlgeschlagener oder verspäteter Loads;
  • Erstellung oder Aktualisierung physischer Landing-Objekte.

dbt beginnt, nachdem diese physischen Landing-Objekte existieren.

Zu den dbt-Verantwortlichkeiten gehören:

  • Deklaration von Sources;
  • Transformation quellsystemnaher Daten;
  • Tests und Vereinbarungen;
  • Lineage;
  • Dokumentation und Artefakte;
  • Materialisierung governter Modelle;
  • Bereitstellung von Metadaten für nachgelagerte Automatisierung.

Werden beide Themen in einer gemeinsamen Prozessbox zusammengefasst, werden Verantwortung und Fehleranalyse unnötig unklar.

End-to-End-Governance-Architektur mit getrennter Ingestion, governten dbt-Warehouse-Layern, Qlik-Anwendungen und einem durchgehenden Governance-Band für Verantwortung, Metadaten, Qualität, Schutz und Nachweise
Die Daten bewegen sich durch die Plattform. Governance-Entscheidungen werden an mehreren expliziten Kontrollpunkten umgesetzt. Ingestion und dbt bleiben getrennte Verantwortlichkeiten.

Die Architektur besteht aus drei verbundenen Ebenen

Eine governte Plattform wird verständlicher, wenn sie in drei Ebenen aufgeteilt wird.

1. Data Plane

Die Data Plane enthält die physischen und logischen Datenprodukte:

Landing
→ RAW
→ Conform
→ Analytics
→ Anwendungen

Jeder Layer besitzt eine andere Verantwortung.

Layer Primäre Verantwortung
Landing Gelieferte Quellstruktur und Ingestion-Metadaten erhalten
RAW Quellsystemnahe Daten als kontrollierte Transformationsressourcen bereitstellen
Conform Gemeinsame Entitäten standardisieren, harmonisieren und integrieren
Analytics Kuratierte Fakten, Dimensionen, Kennzahlen und Use-Case-Modelle bereitstellen
Anwendungen Governte Daten für Nutzer und operative Prozesse verfügbar machen

Die Bezeichnungen können je Plattform abweichen. Entscheidend ist die Trennung der Verantwortlichkeiten.

2. Metadata Plane

Die Metadata Plane beschreibt die Data Plane.

Sie enthält unter anderem:

  • physische Schemas und Datentypen;
  • Source- und Modellbeschreibungen;
  • Verantwortung und Domäne;
  • Spaltenklassifikation;
  • Sensitivität und Aufbewahrung;
  • Lineage und Abhängigkeiten;
  • Data-Quality-Ergebnisse;
  • Freshness und Betriebsstatus;
  • generierte Dokumentation;
  • Warehouse-Tags und Richtlinie-Referenzen.

Metadaten können über dbt-YAML, dbt-Artefakte, Warehouse-Tags, Kataloge, Berechtigungstabellen und operative Systeme verteilt sein.

Die Architektur benötigt deshalb einen expliziten Vertrag, der festlegt, welches System für welche Metadatenart führend ist.

3. Control Plane

Die Control Plane überführt Entscheidungen in erzwungenes Verhalten.

Sie umfasst:

  • Richtlinien und Standards;
  • Freigabeprozesse;
  • CI-Validierung;
  • Datentests und Vereinbarungen;
  • Deployment-Kontrollen;
  • Masking Richtlinien;
  • Row Access Richtlinien;
  • Rollen und Berechtigungs;
  • Qlik Section Access;
  • Audit- und Incident-Prozesse.

Ein Katalog kann eine Kontrolle beschreiben. Die Control Plane setzt sie um und überprüft sie.

Drei ausgerichtete Architekturebenen für Data Plane, Metadata Plane und Control Plane mit vertikalen Verbindungen zwischen Modellen, Metadaten und Governance-Kontrollen
Daten, Metadaten und Kontrollen folgen unterschiedlichen Pfaden. Governance funktioniert, wenn diese Pfade an definierten Kontrollpunkten verbunden werden, ohne sie zu einem gemeinsamen Prozess zu vermischen.

Governance-Entscheidungen benötigen einen technischen Vertrag

Eine Richtlinie wie „Die E-Mail-Adresse des Kunden ist vertrauliche personenbezogene Information“ ist für Automatisierung zu abstrakt.

Die Plattform benötigt eine maschinenlesbare Darstellung:

columns:
  - name: email
    config:
      meta:
        pii: true
        pii_category: email
        sensitivity: confidential
        classification_status: approved
        masking_policy: email_mask
        data_owner: customer_operations
        steward: data_governance

Diese Metadaten schützen die Spalte nicht selbstständig.

Sie bilden einen technischen Vertrag, der:

  • in Git geprüft;
  • in CI validiert;
  • in dbt-Artefakte kompiliert;
  • in der Dokumentation angezeigt;
  • durch Generierungs- und Propagierungslogik verwendet;
  • auf Warehouse-Tags und Richtlinien abgebildet;
  • mit der Laufzeitimplementierung verglichen;
  • als Review-Nachweis genutzt werden kann.

Part 2 definiert diesen Vertrag im Detail.

Klassifikation und Durchsetzung sind unterschiedliche Verantwortlichkeiten

Eine Klassifikation beantwortet:

Welche Art von Daten ist das?
Wie sensibel sind sie?
Wer verantwortet die Entscheidung?
Welche Behandlung wurde freigegeben?

Die Durchsetzung beantwortet:

Was darf die aktuelle Identität sehen?
Welche Zeilen sind erlaubt?
Welche Werte müssen maskiert werden?
Welche Anwendung darf die Daten nutzen?

Beides muss verbunden werden, darf aber nicht verwechselt werden.

Eine belastbare Architektur trennt mindestens zwei Schutzdimensionen.

Spaltenschutz

Der Spaltenschutz steuert die Darstellung sensibler Werte.

Beispiele:

  • vollständige Maskierung;
  • Teilmaskierung;
  • Hashing;
  • Tokenisierung;
  • Ersetzung durch null;
  • rollenabhängiger Klartext.

Snowflake Dynamic Data Masking wendet Masking Policies zur Abfragezeit auf Spalten an. Tag-basiertes Masking kann Object Tags und Masking Policies verbinden, sodass markierte Spalten entsprechend der gültigen Policy und des Datentyps geschützt werden.

Zeilenbasierter Zugriff

Zeilenbasierter Zugriff entscheidet, welche Datensätze sichtbar sind.

Beispiele:

  • Region;
  • Gesellschaft;
  • Abteilung;
  • Kundenportfolio;
  • Mandant;
  • Vertragsbereich.

Snowflake Row Access Policies können diese Filterung zentral im Warehouse erzwingen.

Qlik Section Access kann innerhalb einer Anwendung eine dynamische Datenreduktion anwenden, indem Benutzerberechtigungen mit Reduktionsfeldern im Datenmodell verbunden werden.

Beide Kontrollen können sich ergänzen:

Warehouse Policy
→ schützt das governte Datenprodukt zentral

Qlik Section Access
→ begrenzt die Anwendungszeilen für Nutzer und Use Case

Qlik darf nicht der einzige Ort sein, an dem sensible Daten geschützt werden. Ein Nutzer oder Service mit direktem Warehouse-Zugriff würde eine rein anwendungsseitige Kontrolle umgehen.

Kontrollierter Ablauf von fachlicher Klassifikation und Steward-Freigabe über dbt-Metadaten und Validierung bis zu Warehouse-Masking, Row Access, Qlik Section Access und Audit-Nachweisen
Eine Klassifikation wird erst wirksam, wenn freigegebene Metadaten in technische Kontrollen übersetzt werden. Spaltenmaskierung und zeilenbasierter Zugriff bleiben getrennte Schutzdimensionen.

Governance-Verantwortlichkeiten nach Rolle

Governance scheitert, wenn jedes Team davon ausgeht, dass ein anderes Team die endgültige Entscheidung trifft.

Ein praktikables Verantwortung-Modell unterscheidet folgende Rollen.

Data Owner

Der Data Owner genehmigt die fachliche Nutzung der Daten.

Typische Entscheidungen:

  • erlaubte Zwecke;
  • Domänenverantwortung;
  • Sensitivität;
  • Aufbewahrung;
  • externe Weitergabe;
  • akzeptables fachliches Risiko.

Data Steward

Der Steward pflegt die Klassifikation und stellt die konsistente Verwendung des Governance-Vokabulars sicher.

Typische Verantwortlichkeiten:

  • Beschreibungen und Glossar-Abgleich;
  • personenbezogene Daten-Kategorie;
  • Klassifikationsstatus;
  • Review-Datum;
  • Koordination von Issues;
  • Freigabenachweise.

Data Engineering oder Platform Engineering

Engineering implementiert das governte Datenprodukt.

Typische Verantwortlichkeiten:

  • Source-Deklarationen;
  • Transformationen;
  • Tests und Vereinbarungen;
  • Metadatenintegration;
  • Deployment;
  • Lineage;
  • technische Richtlinie-Anbindung;
  • Drift-Erkennung.

Engineering kann eine wahrscheinliche PII-Spalte erkennen, darf die Klassifikation aber nicht stillschweigend freigeben.

Security und Privacy

Security und Privacy definieren Schutzstandards und genehmigen risikoreiche Kontrollen.

Typische Verantwortlichkeiten:

  • Maskierungsmuster;
  • Richtlinie-Administration;
  • Rollendesign;
  • Funktionstrennung;
  • Datenschutzanforderungen;
  • Access Reviews;
  • Incident Handling.

BI- oder Application Owner

Der Application Owner implementiert nutzungsspezifische Zugriffskontrollen.

Typische Verantwortlichkeiten:

  • App-Zugriff;
  • Section Access;
  • Reduktionsfelder;
  • freigegebene Exporte;
  • Visualisierungsverhalten;
  • Nutzerkommunikation;
  • Anwendungsmonitoring.

Die Übergaben zwischen diesen Rollen müssen sichtbar sein. Ein Feld kann gleichzeitig einen Business Owner, einen Custodian und einen Application Owner besitzen.

Qualität ist Teil der Governance

Governance beschränkt sich nicht auf PII und Berechtigungen.

Ein Datenprodukt ist nicht vertrauenswürdig, wenn seine Verantwortung dokumentiert ist, seine Werte aber verspätet, unvollständig oder strukturell ungültig sind.

Die Architektur sollte Governance-Metadaten deshalb verbinden mit:

  • Source Freshness;
  • Not-null- und Unique-Erwartungen;
  • referenzieller Integrität;
  • erlaubten Werten;
  • Volumenanomalien;
  • Vereinbarung-Prüfungen;
  • Abstimmungen;
  • fachlicher Regelvalidierung;
  • Incident-Schweregrad;
  • Quality Verantwortung.

Nicht jeder Test ist gleich wichtig.

Ein praktikables Modell weist Quality Tier oder Kritikalität zu:

config:
  meta:
    quality_tier: critical
    criticality: tier_1
    custodian: data_platform

CI und Orchestrierung können für kritische Modelle strengere Gates anwenden als für explorative Modelle.

Lineage liefert Impact — aber keine automatische Verantwortlichkeit

Lineage beantwortet Fragen wie:

  • Welche Quelle speist diese Kennzahl?
  • Welche Modelle hängen von dieser Spalte ab?
  • Welche Anwendungen könnten von einer Änderung betroffen sein?
  • Wohin muss eine Klassifikation propagiert werden?
  • Welche Kontrollen sollten downstream vorhanden sein?

Lineage entscheidet nicht, ob eine nachgelagerte Transformation die Klassifikation erhält oder verändert.

Beispiel:

email
→ lower(email)

bleibt üblicherweise personenbezogen.

Dagegen kann:

email
→ count(distinct email)

ein nicht personenbezogenes Aggregat erzeugen — abhängig von Granularität, Filtern und Offenlegungsrisiko.

Part 4 behandelt genau dieses Propagierungs- und Auflösungsproblem.

Nachweise schließen den Governance-Regelkreis

Eine Policy-Implementierung muss Nachweise erzeugen.

Nützliche Nachweise sind:

  • freigegebene Pull Requests;
  • Ergebnisse der Metadatenvalidierung;
  • dbt-Testergebnisse;
  • Manifest- und Katalog-Artefakte;
  • Lineage-Snapshots;
  • Richtlinie-Referenzen;
  • Access Reviews;
  • Query- und Zugriffslogs;
  • Schema-Drift-Ereignisse;
  • Incidents und Ausnahmen;
  • Review-Daten.

Die Nachweise sollten drei Fragen beantworten:

Was wurde freigegeben?
Was wurde implementiert?
Was ist zur Laufzeit geschehen?

Können diese Antworten nicht verbunden werden, existiert Dokumentation, aber keine auditierbare Governance.

Geschlossener Governance-Regelkreis von der Definition über Implementierung, Validierung, Durchsetzung und Beobachtung zurück zur Verbesserung
Governance wird als Regelkreis betrieben. Laufzeitnachweise und Incidents müssen Richtlinien, Metadaten, Modelle und Kontrollen verbessern.

Eine minimal tragfähige Governance-Architektur

Eine erste Umsetzung benötigt nicht jede Enterprise-Funktion.

Sie benötigt einen vollständigen Kontrollpfad.

Eine minimal tragfähige Architektur kann enthalten:

  1. Definiertes Governance-Vokabular

    • Owner;
    • Domäne;
    • PII;
    • Sensitivität;
    • Klassifikationsstatus;
    • Aufbewahrungsklasse;
    • Schutz-Policy.
  2. Versionierte Metadaten

    • dbt-YAML;
    • Code Review;
    • explizite Freigabeverantwortliche.
  3. Automatisierte Validierung

    • Pflichtfelder;
    • erlaubte Werte;
    • PII-Policy-Prüfungen;
    • Prüfung ungeprüfter Spalten.
  4. Governte Transformationen

    • Source-Deklarationen;
    • Tests;
    • Lineage;
    • klare Layer-Verantwortlichkeiten.
  5. Laufzeitkontrollen

    • Warehouse-Rollen;
    • Masking;
    • zeilenbasierter Zugriff;
    • Anwendungsberechtigungen.
  6. Operative Nachweise

    • Build-Ergebnisse;
    • Policy-Referenzen;
    • Access Review;
    • Incident-Prozess.

Das ist stärker als ein großer Katalog ohne Verbindung zu Delivery und Durchsetzung.

Häufige Architekturfehler

Governance-Metadaten existieren nur im Katalog

Code und Laufzeitplattform können sie nicht zuverlässig konsumieren.

Metadaten existieren nur in dbt

Fachbereiche und Stewards können sie nicht wirksam prüfen und steuern.

PII wird automatisch erkannt und als freigegeben behandelt

Erkennung ist ein Hinweis für das Review, keine Governance-Entscheidung.

Zugriff wird ausschließlich in Qlik umgesetzt

Warehouse-Zugriffe außerhalb der Anwendung bleiben unzureichend geschützt.

Jede Regel ist direkt in SQL eingebettet

Policy-Pflege wird dupliziert und schwer auditierbar.

Metadaten werden ohne Transformationsverständnis kopiert

Abgeleitete Spalten übernehmen falsche Klassifikationen oder verlieren sensible Lineage.

Ingestion, Transformation und Governance werden als eine Tool-Verantwortung betrachtet

Fehler, Verantwortung und Kontrollgrenzen werden unklar.

Die zentrale Erkenntnis

Eine governte Datenplattform ist keine Abfolge von Tools. Sie ist ein verbundenes System aus Entscheidungen, Metadatenverträgen, Transformationen, Laufzeitkontrollen und Nachweisen.

Part 2, Metadatengetriebene Governance mit dbt meta, überführt den Architekturvertrag in ein konkretes, versioniertes Metadatenmodell in dbt.

Quellen und weiterführende Dokumentation

Teil 2

Metadatengetriebene Governance mit dbt meta

Metadatengetriebene Governance mit dbt meta

Governance-Entscheidungen benötigen einen maschinenlesbaren Vertrag

Part 1, End-to-End-Governance-Architektur, hat Governance als verbundenes System definiert:

Richtlinie
→ Metadaten
→ Code
→ Durchsetzung
→ Nachweis

Die Architektur benötigt nun einen technischen Vertrag, der Development, Review und Automatisierung durchlaufen kann.

dbt meta bietet dafür einen praktikablen Ort.

Die meta-Konfiguration akzeptiert eigene Key-Value-Paare auf dbt-Ressourcen. Die Werte werden in manifest.json aufgenommen und können in der generierten Dokumentation erscheinen.

Damit eignet sich meta unter anderem für:

  • Verantwortung;
  • Domäne;
  • personenbezogene Daten-Klassifikation;
  • Sensitivität;
  • Aufbewahrung;
  • Schutz-Richtlinie;
  • Quality Tier;
  • Review-Status;
  • Generierungsstatus.

Ein frei verwendbares Dictionary ist jedoch noch keine Governance.

dbt meta wird erst dann zu einem Governance-Vertrag, wenn Vokabular, Geltungsbereich, Validierung, Freigabe und nachgelagerte Verwendung explizit definiert sind.

meta speichert Kontext — erzwingt aber nicht jede Regel

Ein Metadateneintrag wie:

config:
  meta:
    sensitivity: confidential
    masking_policy: email_mask

bindet nicht automatisch eine Masking Policy im Warehouse an.

Er verhindert nicht automatisch ein unberechtigtes Deployment.

Er beweist nicht, dass ein Steward die Klassifikation genehmigt hat.

Er garantiert nicht, dass eine abgeleitete Downstream-Spalte dieselbe Bedeutung besitzt.

Der Wert des Vertrags entsteht durch die Systeme um ihn herum:

dbt-YAML oder SQL-Config
→ Code Review
→ dbt parse
→ Manifest-Validierung
→ Generierungs- oder Propagierungslogik
→ Warehouse-Implementierung
→ Laufzeitprüfung
dbt meta als Governance-Vertrag zwischen kontrolliertem Governance-Vokabular, Ressourcenmetadaten, Manifest-Artefakten, Validierung, Automatisierung und Laufzeitkontrollen
dbt speichert den technischen Vertrag. Review, Validierung und nachgelagerte Automatisierung machen daraus operative Governance.

Das Vokabular vor den Keys definieren

Ein häufiger Fehler besteht darin, dass jeder Entwickler neue Keys einführt, sobald eine neue Anforderung entsteht.

Das Ergebnis ist gültiges YAML, aber semantisch inkonsistente Metadaten:

pii: yes
personal_data: true
contains_pii: Y
data_class: personal
sensitive: email

Alle fünf Einträge können ein ähnliches Konzept beschreiben. Automatisierung kann sie nicht sicher als gleichwertig behandeln.

Ein kontrolliertes Vokabular sollte definieren:

  • exakten Key;
  • Zweck;
  • erlaubte Werte;
  • Geltungsbereich;
  • verantwortliche Person;
  • Default;
  • Freigaberegel;
  • Propagierungsverhalten;
  • Durchsetzung-Mapping.

Ein kompaktes Governance-Dictionary kann so beginnen:

Key Geltungsbereich Beispiel Zweck
domain Source, Modell customer Fachliche Domäne
data_owner Source, Modell sales_operations Fachliche Verantwortung
steward Source, Modell, Spalte data_governance Metadaten-Stewardship
custodian Modell data_platform Technische Verantwortung
pii Spalte true Personenbezogene Daten
pii_category Spalte email Kontrollierte PII-Kategorie
sensitivity Modell, Spalte confidential Schutzklassifikation
classification_status Modell, Spalte approved Review-Status
masking_policy Spalte email_mask Freigegebenes Schutz-Mapping
retention_class Source, Modell operational_7y Lifecycle-Regel
quality_tier Modell critical Validierungspriorität
generated Modell, Spalte true Generierungsherkunft

Dieses Dictionary sollte wie Code versioniert werden.

Explizite Review-Status verwenden

Ein Boolean wie pii: true beschreibt eine Klassifikation, aber nicht deren Freigabestatus.

Eine erkannte oder neu generierte Spalte darf nicht wie eine durch einen Steward genehmigte Klassifikation aussehen.

Verwende einen expliziten Workflow:

unreviewed
→ proposed
→ approved
→ rejected
→ deprecated

Die genauen Status können abweichen. Die Unterscheidung muss jedoch sichtbar bleiben.

Beispiel:

columns:
  - name: email
    config:
      meta:
        pii: true
        pii_category: email
        sensitivity: confidential
        classification_status: approved

  - name: contact_channel
    config:
      meta:
        pii: null
        classification_status: unreviewed

unreviewed sollte normalerweise verhindern, dass ein neues oder potenziell sensibles Feld in governte Downstream-Nutzung überführt wird.

Metadaten am richtigen Scope ablegen

dbt unterstützt Metadaten auf mehreren Ressourcentypen und Ebenen.

Für diese Serie sind besonders wichtig:

  • Source;
  • Source-Tabelle;
  • Modell;
  • Spalte.

Metadaten auf Source-Ebene

Source-Metadaten beschreiben das Quellsystem oder den Ingestion-Kontext.

version: 2

sources:
  - name: crm_landing
    database: LANDING
    schema: CRM

    config:
      meta:
        source_system: crm
        ingestion_owner: data_platform
        data_owner: sales_operations
        retention_class: source_delivery_30d

Metadaten auf Source-Tabellenebene

Metadaten auf Tabellenebene beschreiben ein einzelnes geliefertes Objekt.

    tables:
      - name: customer
        config:
          meta:
            domain: customer
            source_of_record: true
            classification_status: approved

Metadaten auf Modellebene

Modellmetadaten beschreiben das governte Datenprodukt oder den Transformationsknoten.

models:
  - name: raw_crm_customer
    description: Source-aligned customer data.

    config:
      meta:
        domain: customer
        data_owner: sales_operations
        steward: data_governance
        custodian: data_platform
        quality_tier: critical
        generated: true

Metadaten auf Spaltenebene

Spaltenmetadaten beschreiben Bedeutung und Behandlung eines einzelnen Feldes.

    columns:
      - name: email
        description: Customer email address.

        config:
          meta:
            pii: true
            pii_category: email
            sensitivity: confidential
            classification_status: approved
            masking_policy: email_mask
Metadatenhierarchie über Source, Source-Tabelle, Modell und Spalte mit beispielhaften Governance-Keys und dem Hinweis, dass Spaltenmetadaten nicht vom Modell erben
Jede Entscheidung gehört auf die Ebene, für die sie gilt. Governance auf Spaltenebene bleibt explizit und darf nicht aus Modellmetadaten abgeleitet werden.

Spaltenmetadaten erben nicht vom Modell

Dieser Punkt ist für das Governance-Design entscheidend.

Spalten sind keine eigenständigen dbt-Ressourcen. Ihre meta-Werte erben nicht die meta-Werte der übergeordneten Ressource.

Ein Modell kann als vertraulich klassifiziert sein:

config:
  meta:
    sensitivity: confidential

Das bedeutet nicht, dass jede Spalte automatisch Folgendes enthält:

config:
  meta:
    sensitivity: confidential

Eigene Validierungs- oder Propagierungslogik kann einen organisatorischen Fallback definieren. Das ist jedoch eine eigene Regel und keine implizite dbt-Vererbung.

Ein sinnvolles Muster lautet:

Modellmetadaten
→ Default-Kontext für das Review

Spaltenmetadaten
→ explizite Klassifikations- und Schutzentscheidung

Verantwortung, Klassifikation, Schutz und Lifecycle trennen

Eine flache Liste von Keys wird schwer steuerbar, wenn voneinander unabhängige Konzepte vermischt werden.

Gruppiere die Metadaten logisch.

Verantwortung

data_owner: sales_operations
steward: data_governance
custodian: data_platform
domain: customer

Klassifikation

pii: true
pii_category: email
sensitivity: confidential
classification_status: approved

Schutz

masking_policy: email_mask
row_access_domain: legal_entity
allowed_usage:
  - customer_service
  - finance_reporting

Lifecycle

retention_class: operational_7y
deletion_rule: source_contract
source_of_record: true

Betrieb

quality_tier: critical
criticality: tier_1
review_date: 2027-01-31
generated: true
Praktisches dbt-Governance-Metadatenschema mit Gruppen für Verantwortung, Klassifikation, Schutz, Lifecycle und Betrieb
Ein kontrolliertes Schema macht Metadaten für Menschen verständlich und für Automatisierung vorhersehbar.

Ein vollständiges Modellbeispiel

Eine praktische Properties-Datei kann so aussehen:

version: 2

models:
  - name: raw_crm_customer
    description: Source-aligned customer data from the CRM landing table.

    config:
      materialized: view
      tags:
        - raw
        - customer
      meta:
        domain: customer
        data_owner: sales_operations
        steward: data_governance
        custodian: data_platform
        retention_class: operational_7y
        quality_tier: critical
        classification_status: approved
        generated: true

    columns:
      - name: customer_id
        description: Source customer identifier.
        data_tests:
          - not_null
          - unique
        config:
          meta:
            pii: false
            sensitivity: internal
            classification_status: approved

      - name: email
        description: Customer email address.
        config:
          meta:
            pii: true
            pii_category: email
            sensitivity: confidential
            classification_status: approved
            masking_policy: email_mask

      - name: phone
        description: Customer phone number.
        config:
          meta:
            pii: true
            pii_category: phone
            sensitivity: confidential
            classification_status: proposed
            masking_policy: phone_mask

      - name: preferred_contact_time
        description: Newly delivered source field.
        config:
          meta:
            classification_status: unreviewed

Das Beispiel trennt bewusst:

  • Modell-Verantwortung;
  • Spaltenklassifikation;
  • Schutz-Mapping;
  • Review-Status;
  • Quality Tests.

Stabile Policy-Referenzen in meta ablegen — keine Betriebs-Secrets

Gute meta-Werte sind:

  • deterministisch;
  • reviewbar;
  • ausreichend stabil für Versionierung;
  • außerhalb einer einzelnen Ausführung verständlich;
  • sicher in Artefakten und Dokumentation.

Geeignete Beispiele:

domain: customer
sensitivity: confidential
masking_policy: email_mask
retention_class: operational_7y

Nicht geeignet sind:

  • Passwörter;
  • Tokens;
  • Secret Keys;
  • persönliche Zugangsdaten;
  • aktuelle Benutzerberechtigungen;
  • große Access-Kontrollregel-Listen;
  • volatile Laufzeitwerte;
  • unstrukturierte rechtliche Bewertungen.

Die Metadaten sollten eine Policy oder Berechtigung-Domäne referenzieren und nicht das gesamte Laufzeit-Security-System einbetten.

Das Manifest macht den Vertrag konsumierbar

dbt nimmt Ressourcenmetadaten in manifest.json auf.

Damit wird das Manifest zu einem nützlichen Integrationsartefakt für:

  • CI-Validierung;
  • Dokumentation;
  • Kataloge;
  • Impact-Analyse;
  • Codegenerierung;
  • Metadatenpropagierung;
  • Warehouse-Richtlinie-Mapping;
  • Governance-Reporting.

Die Manifest-Version ist an das dbt-Artefaktschema gebunden. Konsumenten sollten das korrekte Schema für die eingesetzte dbt-Version verwenden und nicht davon ausgehen, dass die JSON-Struktur unverändert bleibt.

Ein vereinfachter Validierungsprozess lautet:

dbt parse
→ target/manifest.json lesen
→ Modell- und Spaltenmetadaten prüfen
→ Organisationsregeln anwenden
→ Pull Request stoppen oder freigeben

Den Vertrag vor dem Build validieren

YAML-Syntaxprüfung reicht nicht aus.

Die folgende Datei ist gültiges YAML:

config:
  meta:
    pii: perhaps
    sensitivity: very_secret
    classification_status: done

Sie enthält jedoch keine gültigen Governance-Metadaten, wenn die freigegebenen Werte lauten:

pii: true | false | null
sensitivity: public | internal | confidential | restricted
classification_status: unreviewed | proposed | approved | rejected | deprecated

Ein CI-Validator sollte mindestens prüfen:

  • Pflicht-Verantwortung auf governten Modellen;
  • erlaubte Enum-Werte;
  • personenbezogene Daten-Spalten besitzen eine Kategorie;
  • freigegebene personenbezogene Daten-Spalten besitzen ein freigegebenes Schutz-Mapping;
  • ungeprüfte Spalten gelangen nicht in geschützte Downstream-Layer;
  • kritische Modelle benennen einen technischer Betreiber;
  • Retention Classes existieren im Richtlinie-Katalog;
  • generierte Metadaten überschreiben keine freigegebenen manuellen Entscheidungen.

Ein vereinfachter Python-Validator kann das Manifest untersuchen:

for node in manifest["nodes"].values():
    if node.get("resource_type") != "model":
        continue

    model_meta = node.get("config", {}).get("meta", {})

    require(model_meta, "data_owner")
    require(model_meta, "custodian")
    validate_enum(model_meta, "quality_tier", QUALITY_TIERS)

    for column_name, column in node.get("columns", {}).items():
        column_meta = column.get("meta", {})

        validate_enum(
            column_meta,
            "classification_status",
            CLASSIFICATION_STATES,
        )

        if column_meta.get("pii") is True:
            require(column_meta, "pii_category")

            if column_meta.get("classification_status") == "approved":
                require(column_meta, "masking_policy")

Die konkrete Manifest-Struktur muss zum dbt-Artefaktschema des Projekts passen.

Pull-Request-Validierung von Änderungen an dbt-YAML oder SQL über dbt parse, Manifest-Prüfung, Governance-Regeln, Review und kontrollierten Build
Metadaten werden zu einem Vertrag, wenn ungültige oder unvollständige Entscheidungen den Delivery-Prozess vor dem Deployment stoppen.

Automatisierte Validierung ersetzt keine Freigabe

Automatisierung kann prüfen:

  • ein Wert ist vorhanden;
  • ein Wert gehört zu einer erlaubten Menge;
  • zusammengehörige Felder sind konsistent;
  • eine freigegebene personenbezogene Daten-Spalte referenziert eine Masking Richtlinie;
  • eine neue Spalte bleibt ungeprüft;
  • ein Modell besitzt einen verantwortliche Person.

Automatisierung kann nicht zuverlässig entscheiden:

  • ob ein Feld im konkreten Kontext rechtlich personenbezogen ist;
  • ob ein fachlicher Zweck erlaubt ist;
  • ob eine Aggregation ausreichend anonym ist;
  • ob eine Retention-Ausnahme gerechtfertigt ist;
  • ob eine Downstream-Nutzung akzeptabel ist.

Der Workflow benötigt deshalb beides:

Automatisierte Validierung
+
menschliche Governance-Freigabe

Ein grünes CI-Ergebnis beweist die strukturelle Einhaltung des Vertrags. Es beweist nicht, dass jede Klassifikation fachlich korrekt ist.

Das Business-Glossar verbinden — nicht duplizieren

dbt meta eignet sich für technische Governance-Attribute in der Nähe des Codes.

Es sollte nicht zum einzigen Enterprise-Glossar werden.

Eine sinnvolle Aufteilung ist:

Information Bevorzugtes führendes System
Technische Modell- und Spaltenmetadaten dbt
Freigegebene Glossardefinition Katalog- oder Glossarsystem
Richtlinientext Policy Repository
Laufzeitrollen und Berechtigungs Identity- und Access-Systeme
Warehouse-Policy-Implementierung Warehouse
Anwendungsbezogene Reduktionszuordnung Qlik-Security-Daten
Systemübergreifende Nachweise Governance-Reporting oder Audit Store

dbt kann Referenzen speichern:

glossary_term: customer_email
policy_id: privacy_pii_001
retention_class: operational_7y

Dadurch bleibt der Code mit Governance verbunden, ohne vollständige Richtliniendokumente zu duplizieren.

Für Generierung und Propagierung entwerfen

Der Vertrag sollte die nächsten beiden Parts der Serie unterstützen.

Part 3: kontrollierte RAW-Generierung

Ein Generator kann Folgendes kombinieren:

Physische Warehouse-Metadaten
+
freigegebene Governance-Metadaten
+
Generierungskonventionen

und daraus Source-YAML, RAW-SQL und Model Properties erzeugen.

Neue Spalten sollten mit folgendem Status generiert werden:

classification_status: unreviewed

Part 4: Metadatenpropagierung

Ein Propagierungsprozess kann Lineage und Transformationssemantik untersuchen und entscheiden, ob Metadaten:

  • kopiert;
  • zusammengeführt;
  • herabgestuft;
  • hochgestuft;
  • entfernt;
  • zur Prüfung vorgelegt werden.

Dieser Prozess benötigt stabile und explizite Metadaten-Keys. Freie Notizen reichen dafür nicht aus.

Häufige Metadaten-Anti-Patterns

Ein Boolean für jede Sensitivität

pii: true definiert weder Kategorie, Sensitivität, Status noch Schutz.

Freie Werte

high, very high, secret, sensitive und restricted lassen sich nicht konsistent automatisieren.

Kein Freigabestatus

Erkannte und genehmigte Klassifikationen sind nicht unterscheidbar.

Metadaten nur auf Modellebene

Sensible Spalten bleiben technisch uneindeutig.

Angenommene Vererbung

Spaltenverhalten hängt von nicht dokumentierter Fallback-Logik ab.

Eingebettete Laufzeitberechtigungen

Versionierte Projektdateien werden zu einem zweiten Identity-Management-System.

Generierung überschreibt freigegebene Metadaten

Ein Schema-Refresh zerstört stillschweigend Steward-Entscheidungen.

Metadaten ohne Durchsetzung-Mapping

Die Plattform dokumentiert ein Risiko, reduziert es aber nicht.

Die zentrale Erkenntnis

dbt meta ist der versionierte technische Vertrag zwischen Governance-Entscheidungen und Plattformautomatisierung.

Der Vertrag muss:

  • kontrolliert;
  • explizit;
  • validiert;
  • reviewbar;
  • maschinenlesbar;
  • mit führenden Richtlinien verbunden;
  • von Betriebs-Secrets getrennt;
  • für Generierung und Propagierung vorbereitet sein.

Part 3, Automatische RAW-Generierung mit dbt-Macros, verwendet diesen Vertrag, um wiederkehrendes RAW-Grundgerüst zu erzeugen, ohne Git-Review, Lineage oder Governance-Kontrolle zu verlieren.

Quellen und weiterführende Dokumentation

Teil 3

Automatische RAW-Generierung mit dbt-Macros

Automatische RAW-Generierung mit dbt-Macros

RAW-Modelle sind einfach — die Pflege von Hunderten ist es nicht

Ein quellsystemnahes RAW-Modell ist fachlich meistens nicht komplex.

Es wählt häufig nur die Spalten einer Landing-Tabelle aus, erhält die Quellwerte, übernimmt Ingestion-Metadaten und stellt das Ergebnis unter einem kontrollierten Namen bereit.

Schwierig wird es, wenn dieselbe Arbeit für Dutzende oder Hunderte Tabellen wiederholt werden muss:

  • Source-Deklarationen werden manuell kopiert;
  • SQL-Modelle weichen vom physischen Quellschema ab;
  • Spaltenlisten sind nicht mehr aktuell;
  • Namenskonventionen werden uneinheitlich angewendet;
  • Beschreibungen und Governance-Metadaten bleiben unvollständig;
  • neue Spalten erreichen nachgelagerte Nutzer ohne Prüfung;
  • personenbezogene Daten-Klassifikationen werden getrennt vom generierten Code gepflegt;
  • Entwickler verbringen Zeit mit vorhersehbarem Grundgerüst.

Das ist ein geeigneter Automatisierungsfall.

Es ist jedoch kein Grund, ein Macro beliebige Warehouse-Objekte außerhalb des dbt-Projekts erzeugen zu lassen.

Das Ziel ist nicht, Code abzuschaffen. Das Ziel ist, deterministischen, prüfbaren und governten Code aus kontrollierten Metadaten zu erzeugen.

Part 1, End-to-End Governance Architecture, hat den vollständigen Governance-Fluss definiert. Part 2, Metadata-driven Governance with dbt meta, hat dbt-Metadaten als technischen Governance-Vertrag etabliert.

Dieser Part wendet diesen Vertrag auf den repetitiven Anfang der Transformationsschicht an: die quellsystemnahen RAW-Modelle.

Die Grenze: Ingestion findet vor der RAW-Generierung statt

dbt transformiert Daten, die bereits in der angebundenen Plattform vorhanden sind.

Ein Ingestion-Service, ein Replikationsprozess, eine Pipeline, ein File Loader oder ein plattformnativer Mechanismus erzeugt zuerst die Landing-Objekte.

Beispiele:

Quellsystem
→ Fivetran / Airbyte / Data Factory / eigene Ingestion
→ Landing-Tabelle
→ dbt-RAW-Modell

Die Generierung beginnt erst, nachdem die Landing-Relation existiert und untersucht werden kann.

Abgrenzung zwischen Ingestion und automatischer RAW-Generierung: Quellsysteme werden zuerst in Landing-Tabellen geladen, danach erkennt dbt Schemas und erzeugt Source-Deklarationen, RAW-Modelle und Governance-YAML
Die Ingestion erzeugt die Landing-Objekte. Der Generator liest deren Struktur und produziert governte dbt-Artefakte. dbt bleibt für Transformation, Dokumentation, Lineage und kontrolliertes Deployment verantwortlich — nicht für die Extraktion aus dem Quellsystem.

Diese Trennung hält die Verantwortlichkeiten eindeutig:

Verantwortung Zuständigkeit
Quelldaten extrahieren und laden Ingestion-Prozess
Liefermetadaten der Quelle erhalten Landing Layer
Relationen und Spalten erkennen Generator
dbt-Source-Deklarationen erzeugen Generator plus Review
Quellsystemnahes RAW-SQL erzeugen Generator plus Review
Governance-Metadaten ergänzen Freigegebene Metadaten plus Generator
RAW-Modelle bauen und testen dbt
Schemaänderungen und Klassifikationen freigeben Data Owner / Steward / Engineering

Was sollte generiert werden?

Ein sinnvoller RAW-Generator erzeugt drei zusammengehörige Artefakttypen.

1. Source-Deklarationen

Der Generator kann folgende Datei erzeugen oder aktualisieren:

models/raw/crm/_crm__sources.yml

Sie deklariert Landing-Datenbank, Schema, Tabellen, Spalten, Freshness-Konfiguration und Metadaten der Quelle.

2. SQL für RAW-Modelle

Der Generator kann pro Landing-Tabelle ein kontrolliertes Modell erzeugen:

models/raw/crm/raw_crm_customer.sql
models/raw/crm/raw_crm_order.sql
models/raw/crm/raw_crm_contact.sql

Jedes Modell bleibt quellsystemnah und verwendet eine explizite, deterministische Spaltenliste.

3. Properties der RAW-Modelle

Der Generator kann folgende Datei erzeugen:

models/raw/crm/_crm__raw_models.yml

Sie enthält Modellbeschreibungen, Tags, Verantwortung, Domäne, Generierungsmetadaten und Governance-Attribute auf Spaltenebene.

Alle drei Artefakte müssen dieselbe Objektmenge beschreiben. Nur SQL zu generieren und YAML manuell zu pflegen erzeugt eine neue Form von Drift.

Drei Umsetzungsmuster

Es gibt drei häufige Wege, diese Arbeit zu automatisieren. Sie sind nicht gleich stark.

Vergleich von drei Mustern zur RAW-Automatisierung: Macro-gesteuerte Modellvorlagen, Codegenerierung in versionierte Dateien und direkte DDL-Ausführung außerhalb des dbt-Modellgraphen
Macro-gesteuerte Modelle und generierte Dateien bleiben im dbt-Projekt sichtbar. Direkte DDL-Generierung kann Objekte schnell erzeugen, schwächt jedoch Lineage, Selektion, Tests und Deployment-Kontrolle, wenn sie normale dbt-Ressourcen umgeht.

Muster A — Ein kleines Modell ruft ein wiederverwendbares RAW-Macro auf

Jede Modelldatei enthält nur einen Macro-Aufruf:

{{ raw_select(
    source_name = 'crm_landing',
    table_name = 'customer'
) }}

Das Macro erkennt die Spalten und erzeugt das endgültige select.

Vorteile:

  • das Modell bleibt eine normale dbt-Ressource;
  • source() erzeugt explizite Lineage;
  • normale Selektion, Tests, Dokumentation und Deployment funktionieren weiterhin;
  • wiederkehrende SQL-Muster sind zentralisiert;
  • Adapterlogik kann wiederverwendet werden.

Grenzen:

  • pro Tabelle ist weiterhin eine kleine Modelldatei erforderlich;
  • Source-YAML muss bereits existieren;
  • Schemaerkennung findet beim Kompilieren mit Live-Verbindung statt;
  • eine Änderung des Quellschemas kann kompiliertes SQL verändern, ohne dass sich die Modelldatei ändert;
  • im Code Review ist die vollständige Spaltenänderung nur sichtbar, wenn kompilierter Output oder ein Schema-Diff geprüft wird.

Dieses Muster eignet sich für kontrollierte Projekte mit einer mittleren Anzahl von Tabellen.

Muster B — Ein Macro rendert Dateien, ein Wrapper schreibt sie

Eine Generierungsoperation untersucht das Landing-Schema und rendert SQL sowie YAML. Ein kleines Skript oder ein CI-Schritt schreibt den ausgegebenen Inhalt in das Projekt.

dbt run-operation
→ gerendertes SQL / YAML
→ Wrapper schreibt Dateien
→ Git-Diff
→ Review
→ dbt parse / build

Vorteile:

  • das vollständige generierte SQL und YAML ist in Git sichtbar;
  • Schemaänderungen werden zu expliziten Pull-Request-Diffs;
  • der generierte Output ist deterministisch;
  • CI kann unerwartete Änderungen ablehnen;
  • manuelle Metadaten können über kontrollierte Merge-Regeln erhalten bleiben;
  • die erzeugten Ressourcen bleiben normale dbt-Modelle.

Grenzen:

  • ein Wrapper oder Generierungstool ist erforderlich, weil ein normales dbt-Macro Projektdateien nicht eigenständig verwaltet;
  • Regenerierungsregeln müssen stabil sein;
  • das Merge-Verhalten zwischen generierten und manuell freigegebenen Metadaten muss entworfen werden;
  • das Team muss festlegen, wann die Generierung läuft.

Für ein größeres governtes Projekt ist dies normalerweise das stärkste Muster.

Das Package dbt-labs/codegen kann hilfreiche Bausteine für Source- und Modellgerüste bereitstellen. Ein eigener Governance-Generator kann dieses Prinzip um organisationsspezifische Benennung, Metadaten, Klassifikationen und Review-Regeln erweitern.

Muster C — Ein Macro führt DDL aus und erzeugt RAW-Objekte direkt

Eine Operation kann generiertes DDL gegen das Warehouse ausführen.

Das kann technisch möglich sein, sollte aber eine Ausnahme bleiben.

Risiken:

  • Objekte sind nicht als normale dbt-Modelle repräsentiert;
  • Lineage kann unvollständig sein;
  • Node Selection verwaltet die Objekte nicht;
  • Tests und Dokumentation benötigen eine separate Behandlung;
  • State Comparison und CI werden schwieriger;
  • Deployment-Verhalten hängt von Seiteneffekten ab;
  • run_query kann in Compile-bezogenen Abläufen ausgeführt werden, wenn es nicht sorgfältig begrenzt ist.

Direkte DDL-Operationen eignen sich für administrative Aktionen oder streng kontrollierte Plattformautomatisierung. Für einen governten RAW Layer sind sie normalerweise schwächer als generierte dbt-Ressourcen.

Ein dbt-natives Macro für die RAW-Auswahl

Ein minimales Macro kann die Spalten einer deklarierten Source-Relation aufzählen.

{% macro raw_select(source_name, table_name) %}

    {% set relation = source(source_name, table_name) %}

    {% if execute %}
        {% set columns = adapter.get_columns_in_relation(relation) %}
    {% else %}
        {% set columns = [] %}
    {% endif %}

    select
    {% if columns | length > 0 %}
        {% for column in columns %}
            {{ adapter.quote(column.name) }}{% if not loop.last %},{% endif %}
        {% endfor %}
    {% else %}
        *
    {% endif %}
    from {{ relation }}

{% endmacro %}

Ein Modell wird dadurch sehr klein:

{{ config(
    materialized = 'view',
    tags = ['raw', 'generated', 'crm']
) }}

{{ raw_select(
    source_name = 'crm_landing',
    table_name = 'customer'
) }}

Mehrere Details sind bewusst gewählt.

source() statt einer fest codierten Relation verwenden

source() verbindet das Modell mit einem deklarierten Source-Node. Dadurch entstehen eine explizite Abhängigkeit und Lineage.

Nach Möglichkeit Adaptermethoden verwenden

adapter.get_columns_in_relation() bietet eine dbt-Abstraktion über den plattformspezifischen Metadatenzugriff.

Für speziellere Erkennung kann ein Macro information_schema über run_query abfragen. Dann müssen jedoch SQL-Dialekt, Berechtigungen und Ausführungskontext explizit behandelt werden.

Ausführung während reinem Parsing absichern

Während des Parsings kann execute den Wert false haben. Der Fallback hält das Jinja-Rendering gültig, ohne eine Live-Metadatenabfrage zu benötigen.

Explizite Spalten im kompilierten oder generierten SQL bevorzugen

Eine explizite Liste macht Spaltenreihenfolge, Quoting und Schemaänderungen sichtbar.

Ein dauerhaftes select * ist bequem, veröffentlicht aber jede neue Quellspalte automatisch. Das ist besonders gefährlich, wenn eine neue PII-Spalte hinzukommt.

Beispiel: CRM-Landing-Source

Angenommen, der Ingestion-Prozess erzeugt:

LANDING_DB.CRM.CUSTOMER

mit folgenden Spalten:

CUSTOMER_ID
CUSTOMER_NAME
EMAIL
PHONE
COUNTRY_CODE
UPDATED_AT
_FIVETRAN_SYNCED
_FIVETRAN_DELETED

Die Source-Deklaration kann so generiert werden:

version: 2

sources:
  - name: crm_landing
    database: LANDING_DB
    schema: CRM

    config:
      meta:
        source_system: crm
        owner: data_platform

    tables:
      - name: customer
        description: Landing-Tabelle, die aus dem CRM-System repliziert wird.

        config:
          loaded_at_field: _FIVETRAN_SYNCED
          freshness:
            warn_after:
              count: 2
              period: hour
            error_after:
              count: 6
              period: hour
          meta:
            ingestion_method: fivetran
            raw_generation: enabled

        columns:
          - name: CUSTOMER_ID
            description: Kundenidentifier des Quellsystems.

          - name: EMAIL
            description: E-Mail-Adresse des Kunden.
            config:
              meta:
                pii: true
                pii_category: email
                sensitivity: confidential
                classification_status: approved

Die Properties des RAW-Modells können so generiert werden:

version: 2

models:
  - name: raw_crm_customer
    description: Quellsystemnahes RAW-Modell für die CRM-Kundentabelle.

    config:
      materialized: view
      tags:
        - raw
        - generated
        - crm
      meta:
        generated: true
        generation_rule: raw_v1
        source_system: crm
        owner: data_platform
        domain: customer

    columns:
      - name: CUSTOMER_ID
        description: Kundenidentifier des Quellsystems.
        data_tests:
          - not_null
        config:
          meta:
            pii: false
            classification_status: approved

      - name: EMAIL
        description: E-Mail-Adresse des Kunden.
        config:
          meta:
            pii: true
            pii_category: email
            sensitivity: confidential
            masking_policy: email_mask
            classification_status: approved

      - name: PHONE
        description: Telefonnummer des Kunden.
        config:
          meta:
            pii: true
            pii_category: phone
            sensitivity: confidential
            masking_policy: phone_mask
            classification_status: approved

Das SQL bleibt absichtlich einfach:

{{ config(
    materialized = 'view',
    tags = ['raw', 'generated', 'crm'],
    meta = {
        'generated': true,
        'generation_rule': 'raw_v1',
        'source_system': 'crm',
        'owner': 'data_platform',
        'domain': 'customer'
    }
) }}

{{ raw_select(
    source_name = 'crm_landing',
    table_name = 'customer'
) }}

Das RAW-Modell standardisiert keine Ländercodes, führt keine Kunden zusammen und berechnet keine fachlichen Attribute. Diese Verantwortlichkeiten gehören in spätere Schichten.

Der Generator benötigt mehr als das Information Schema

Das physische Schema kann Fragen beantworten wie:

  • Welche Tabellen existieren?
  • Welche Spalten existieren?
  • Welche physischen Datentypen besitzen sie?
  • Welche Position haben sie?
  • Müssen Identifier gequotet werden?
  • Hat sich das Schema verändert?

Es kann nicht zuverlässig beantworten:

  • Ist eine Spalte personenbezogene Daten?
  • Welche Fachdomäne ist verantwortlich?
  • Welche Retention Richtlinie gilt?
  • Welche Masking Richtlinie ist freigegeben?
  • Darf eine neue Spalte nachgelagert verwendet werden?
  • Ist ein technisch wirkendes Feld tatsächlich vertraulich?
  • Welche Beschreibung ist fachlich sinnvoll?

Ein governter Generator kombiniert deshalb mehrere Eingaben.

Generierungsprozess, der physische Warehouse-Metadaten, freigegebene Governance-Metadaten und Generierungskonventionen kombiniert, um dbt-Source-YAML, RAW-Modell-SQL und Modell-Properties-YAML zu erzeugen
Physische Metadaten beschreiben, was existiert. Governance-Metadaten beschreiben, wie es behandelt werden muss. Generierungskonventionen bestimmen, wie beides in reproduzierbare dbt-Ressourcen überführt wird.

Eine praktische Prioritätsreihenfolge lautet:

Freigegebene Governance-Metadaten
→ vorhandener manueller Override
→ Metadaten des Quellsystems
→ Standardwert des Generators

Für eine neu erkannte Spalte darf der Generator keine freigegebene Klassifikation erfinden.

Ein sicherer Standard ist:

config:
  meta:
    classification_status: unreviewed
    downstream_publication: blocked

Dadurch entsteht eine kontrollierte Ausnahme, die geprüft werden muss.

Deterministische Generierung ist zwingend

Wird der Generator zweimal mit denselben Eingaben ausgeführt, müssen identische Dateien entstehen.

Dafür braucht es stabile Regeln für:

  • Dateinamen;
  • Modellnamen;
  • Source-Namen;
  • Spaltenreihenfolge;
  • Quoting;
  • Groß- und Kleinschreibung;
  • Reihenfolge der YAML-Keys;
  • Whitespace;
  • Beschreibungen;
  • Standard-Tags;
  • generierte Metadaten;
  • Kommentare und Header.

Nicht deterministischer Output erzeugt unnötige Git-Diffs und schwächt das Vertrauen in die Automatisierung.

Eine generierte Datei kann einen kontrollierten Header enthalten:

Generated by: raw_generator
Generation rule: raw_v1
Source relation: LANDING_DB.CRM.CUSTOMER
Do not edit generated sections manually.
Manual governance overrides are stored in: governance/crm.yml

Der Generator sollte entweder die gesamte Datei besitzen oder generierte und manuell gepflegte Abschnitte eindeutig trennen. Verdeckte Merge-Logik ist schwer zu betreiben.

Schema Drift muss zu einem Review-Workflow werden

Automatische Generierung ist besonders wertvoll, wenn sich eine Quelle ändert.

Ein sicherer Schema-Drift-Prozess lautet:

Kontrollierter Schema-Drift-Workflow vom Vergleich des Landing-Schemas über Klassifikation, generierten Pull Request, Governance-Review und dbt-Validierung bis zum Deployment
Schema Drift soll einen sichtbaren Änderungsvorschlag erzeugen und keine unsichtbare Produktionsänderung. Neue Spalten können automatisch erkannt werden, während Veröffentlichung und Klassifikation kontrollierte Entscheidungen bleiben.

Sinnvolle Änderungskategorien sind:

Änderung Typische Aktion
Neue Tabelle Deaktivierte oder Draft-Ressourcen bis zur Freigabe erzeugen
Neue Spalte Als unreviewed ergänzen; nachgelagerte Weitergabe bei Bedarf blockieren
Entfernte Spalte CI fehlschlagen lassen, wenn nachgelagerte Abhängigkeiten bestehen
Datentypänderung Kompatibilitätsprüfung und gezielte Tests verlangen
Umbenannte Spalte Als Entfernen plus Hinzufügen behandeln, wenn kein explizites Mapping existiert
Geänderte Spaltenreihenfolge Normalerweise ohne semantische Auswirkung regenerieren
Neue PII-Klassifikation Sicherheitsänderung vor breiterer Veröffentlichung propagieren
Fehlende Source-Relation Generierung fehlschlagen lassen oder Quelle gemäß Policy deaktivieren

Der Generator darf manuell gepflegte Governance-Entscheidungen nicht still löschen, weil eine physische Quellspalte vorübergehend fehlt.

PII-Erkennung kann unterstützen — nicht freigeben

Spaltennamen können nützliche Hinweise liefern:

EMAIL
PHONE
IBAN
BIRTH_DATE
SOCIAL_SECURITY_NUMBER

Pattern Matching, Catalog-Klassifikationen oder ML-basierte Discovery können Metadaten vorschlagen.

Der Output muss ein Vorschlag bleiben:

config:
  meta:
    pii_candidate: true
    suggested_pii_category: email
    classification_status: unreviewed

Der freigegebene Wert muss davon unterscheidbar sein:

config:
  meta:
    pii: true
    pii_category: email
    classification_status: approved
    approved_by: data_steward_customer

Diese Trennung verhindert, dass eine Namensheuristik als verbindliche Governance-Entscheidung erscheint.

Empfohlene Projektstruktur

Eine skalierbare Struktur kann so aussehen:

macros/
  raw/
    raw_select.sql
    discover_relations.sql
    discover_columns.sql
    render_source_yaml.sql
    render_raw_model.sql
    render_model_yaml.sql

models/
  raw/
    crm/
      _crm__sources.yml
      _crm__raw_models.yml
      raw_crm_customer.sql
      raw_crm_contact.sql
    erp/
      _erp__sources.yml
      _erp__raw_models.yml
      raw_erp_customer.sql
      raw_erp_sales_order.sql

governance/
  crm.yml
  erp.yml

scripts/
  generate_raw.py

tests/
  generator/
    expected_output/

Die Dateien unter governance enthalten freigegebene Klassifikationen und manuelle Overrides. Generierte Dateien bleiben reproduzierbare Outputs.

CI/CD-Prüfungen für generierte RAW-Ressourcen

Der Generator sollte Teil des Delivery-Prozesses sein und kein undokumentierter Entwicklerbefehl.

Eine praktische CI-Sequenz lautet:

dbt-Packages installieren
Generator-Konfiguration validieren
Mit Read-only-Metadatenrolle verbinden
Landing-Schema erkennen
RAW-Artefakte regenerieren
Bei nicht leerem Git-Diff fehlschlagen
dbt parse ausführen
dbt compile ausführen
Gezielte Source- und RAW-Tests ausführen
Unreviewed-Klassifikationen prüfen
Namens- und Metadatenanforderungen prüfen
Pull-Request-Diff veröffentlichen

Die Prüfung „bei nicht leerem Git-Diff fehlschlagen“ erkennt, wenn committed generierte Dateien nicht mehr zum Quellschema oder zu den Generatorregeln passen.

Getrennte Credentials sind sinnvoll:

Aktivität Berechtigung
Metadaten erkennen Metadaten und Source-Definitionen lesen
RAW-Modelle in Entwicklung bauen Objekte im Entwicklungsschema erstellen
CI Parse / Render Keine Schreibrechte in Produktion
Produktionsdeployment Kontrollierte Deployment-Rolle
Governance-Freigabe Repository-Freigabe, nicht standardmäßig Warehouse-Admin

Häufige Anti-Patterns

Mit select * jede neue Spalte veröffentlichen

Dadurch wird Source Schema Drift zu einem unkontrollierten Veröffentlichungsmechanismus.

DDL außerhalb des dbt-DAG erzeugen

Die Objekte existieren, dbt kann sie aber nicht als First-Class-Ressourcen verwalten.

Freigegebene PII-Metadaten überschreiben

Physische Schemaerkennung darf Governance-Entscheidungen nicht ersetzen.

Generierten Code als nicht prüfbar behandeln

Generierter Code kann weiterhin Sicherheits-, Kosten- und Kompatibilitätsprobleme erzeugen. Er benötigt Tests und Review.

Transformation in den RAW-Generator mischen

Fachliche Umbenennung, Standardisierung von Werten und KPI-Logik machen das RAW-Muster quellspezifisch und semantisch überladen.

Seiteneffektbehaftete run_query-Logik im normalen Compile ausführen

Metadaten lesen ist das eine. DDL, DML oder destruktive Aktionen benötigen explizite Command-Begrenzung und kontrollierte Operations.

Dateien mit instabiler Formatierung regenerieren

Unruhiger Output versteckt fachlich relevante Änderungen.

Den Generator zur einzigen Source of Truth machen

Das Quellschema beschreibt die Struktur. Governance-Metadaten und freigegebene Ausnahmen bleiben eigenständige autoritative Eingaben.

Entscheidungshilfe

Situation Empfohlenes Muster
Wenige Quellen und geringe Änderungsrate Manuelle Modelle mit gemeinsamen Konventionen können ausreichen
Mittlere Anzahl repetitiver RAW-Modelle Macro-gesteuerte Modellvorlagen
Viele Quellen mit häufigem Schema Drift Dateigenerierung plus Git-Review
Nur initiales Grundgerüst erforderlich Codegen-Package oder einmaliger Generator
Governter Metadaten-Merge erforderlich Eigener Generator mit freigegebenem Override-Register
Administratives Warehouse-DDL erforderlich Explizites run-operation, getrennt von der Modellgenerierung
Vollständig dynamische Objekte ohne committed Code erforderlich Prüfen, ob dbt-Modelle die richtige Abstraktion sind

Automatisierung ist gerechtfertigt, wenn sie wiederkehrende Arbeit reduziert, ohne Kontrolle zu reduzieren.

Die zentrale Erkenntnis

Generiere das repetitive RAW-Grundgerüst automatisch, halte aber jedes resultierende Modell, jede Source-Deklaration und jede Governance-Entscheidung sichtbar, testbar und reviewbar.

dbt-Macros können Relationen untersuchen, SQL erzeugen und wiederverwendbare Muster rendern.

run-operation kann Generierungslogik aufrufen.

Adaptermethoden und run_query können Warehouse-Metadaten lesen.

Ein Wrapper oder ein Codegenerierungstool kann den gerenderten Output in versionierte Projektdateien überführen.

Das stärkste Betriebsmodell lautet daher:

Part 4, Propagating PII Metadata across Data Warehouses, setzt an diesem Punkt fort. Sobald der RAW Layer freigegebene Metadaten enthält, besteht die nächste Herausforderung darin, diese Metadaten durch Conform-, Core- und Analytics-Modelle zu erhalten und aufzulösen.

Quellen und weiterführende Dokumentation

Stand der Funktionsbeschreibung: Juli 2026. dbt-Syntax und Ausführungsverhalten können sich zwischen dbt Core, Fusion Engine und dbt-Plattform unterscheiden. Für die konkrete Implementierung sollte die Dokumentation der eingesetzten Engine und Version geprüft werden.

Teil 4

PII-Metadaten durch Data Warehouses propagieren

PII-Metadaten durch Data Warehouses propagieren

PII-Metadaten müssen den Daten folgen

Part 3, Automatische RAW-Generierung mit dbt-Macros, hat kontrollierte RAW-Modelle aus physischen Warehouse-Metadaten und freigegebenen Governance-Metadaten erzeugt.

Der RAW Layer ist nun explizit, reviewbar und versioniert.

Das nächste Problem beginnt, sobald ein nachgelagertes Modell diese Spalten auswählt, umbenennt, kombiniert oder transformiert.

select
    customer_id,
    lower(trim(email)) as normalized_email,
    concat(first_name, ' ', last_name) as customer_name
from {{ ref('raw_crm_customer') }}

Die Quellspalten können bereits freigegebene Metadaten besitzen:

email:
  pii: true
  pii_category: email
  sensitivity: confidential
  classification_status: approved

first_name:
  pii: true
  pii_category: name
  sensitivity: confidential
  classification_status: approved

last_name:
  pii: true
  pii_category: name
  sensitivity: confidential
  classification_status: approved

Auch die nachgelagerten Spalten bleiben sensibel.

dbt leitet das korrekte Governance-Ergebnis jedoch nicht automatisch aus der SQL-Semantik ab.

Data Lineage zeigt, woher eine Spalte stammt. Eine Propagierungsregel bestimmt, welche Metadaten daraus entstehen.

Modell-Lineage reicht nicht aus

Modell-Lineage beantwortet:

Welches Modell hängt von welchem Upstream-Modell ab?

Das ist für Deployment, Impact-Analyse und Verantwortung wichtig.

PII-Propagierung benötigt eine präzisere Frage:

Welche Upstream-Spalten tragen zu dieser Zielspalte bei?

Dafür ist Column-Level Lineage oder ein explizites Column Mapping erforderlich.

Ein Modell kann von einem sensiblen Upstream-Modell abhängen, ohne sensible Spalten auszuwählen.

Umgekehrt kann eine einzige abgeleitete Spalte mehrere sensible Quellspalten kombinieren.

Ein Propagierungssystem benötigt deshalb mindestens:

  • Modellabhängigkeiten;
  • Namen der Zielspalten;
  • referenzierte Quellspalten;
  • Transformationstyp;
  • freigegebene Quellmetadaten;
  • explizite Ziel-Overrides;
  • Konfliktregeln.

Das dbt-Manifest stellt Ressourcenmetadaten und direkte Ressourcenbeziehungen bereit. Column-Level Lineage benötigt SQL-Parsing oder einen anderen Lineage-Mechanismus und kann bei mehrdeutigem SQL, komplexen Lateral-Konstrukten oder Python-Modellen unvollständig sein.

Die Architektur muss Unsicherheit verarbeiten, statt vollständige automatische Auflösung vorzutäuschen.

PII-Metadaten bewegen sich durch RAW-, Conform-, Core-, Analytics- und Consumption-Layer mit einem getrennten kontrollierten Pfad für Lineage, Propagierungsregeln, Validierung und Freigabe
Lineage liefert die Grundlage. Propagierungsregeln und Governance-Review bestimmen die freigegebenen Downstream-Metadaten.

Metadaten nicht blind kopieren

Die einfachste denkbare Umsetzung kopiert alle Quellmetadaten auf jede nachgelagerte Spalte.

Das scheitert schnell.

Betrachte folgende Transformationen:

email as email
lower(email) as normalized_email
split_part(email, '@', 2) as email_domain
sha2(email) as email_hash
count(distinct email) as customer_count
'CRM' as source_system

Alle sechs Spalten referenzieren dieselbe Quellspalte oder stehen neben ihr. Sie besitzen dennoch nicht dieselbe Bedeutung.

Blindes Kopieren erzeugt zwei Fehlerarten.

Unterklassifikation

Ein transformiertes Feld identifiziert oder beschreibt weiterhin eine Person, verliert aber seine Metadaten.

Beispiele:

  • umbenannte E-Mail-Adresse;
  • normalisierte Telefonnummer;
  • zusammengesetzter vollständiger Name;
  • deterministischer Kunden-Hash;
  • extrahierte Account-ID.

Überklassifikation

Ein technisches oder ausreichend aggregiertes Ergebnis übernimmt eine Klassifikation, die nicht mehr gilt.

Beispiele:

  • konstante Quellsystembezeichnung;
  • freigegebenes hoch aggregiertes Ergebnis;
  • boolesches Quality Flag;
  • Datensatzanzahl;
  • technischer Ladezeitstempel.

Die Propagation Engine muss deshalb die Transformation klassifizieren und darf nicht nur eine Abhängigkeit erkennen.

Propagierungsregeln nach Transformationstyp definieren

Ein praktikables Regelwerk kann mit sieben Transformationsklassen beginnen.

1. Direkte Weitergabe

email

Empfohlene Regel:

Freigegebene Spaltenmetadaten kopieren.

Dies ist der stärkste Kandidat für automatische Propagierung.

2. Umbenennung

email as customer_email

Empfohlene Regel:

Freigegebene Metadaten kopieren und die Quellspalte dokumentieren.

Ein neuer Name verändert nicht die Bedeutung der Daten.

3. Cast oder Formatierung

lower(trim(email)) as normalized_email
cast(customer_id as varchar) as customer_id_text

Empfohlene Regel:

Quellklassifikation erhalten, sofern keine freigegebene Regel etwas anderes festlegt.

Case Conversion, Trimming, Formatierung und Typkonvertierung verändern üblicherweise die Darstellung, nicht die Sensitivität.

4. Kombination

concat(first_name, ' ', last_name) as full_name
coalesce(mobile_phone, landline_phone) as preferred_phone

Empfohlene Regel:

Klassifikationen aller beitragenden Quellen zusammenführen.

Das Ergebnis sollte normalerweise die strengste Sensitivität und die kontrollierte Vereinigung relevanter PII-Kategorien erhalten.

Beispiel:

pii: true
pii_category:
  - name
sensitivity: confidential
classification_status: proposed
propagated_from:
  - raw_crm_customer.first_name
  - raw_crm_customer.last_name

Der Status darf nur dann approved bleiben, wenn eine freigegebene Transformationsregel diese Kombination abdeckt. Andernfalls ist proposed zu verwenden.

5. Hashing, Tokenisierung oder Pseudonymisierung

sha2(email) as customer_token

Empfohlene Regel:

Sensitivität erhalten, sofern keine freigegebene Governance-Regel sie explizit ändert.

Ein deterministischer Hash kann weiterhin Matching, Verknüpfung oder Re-Identifikation ermöglichen. Er darf nicht allein deshalb als anonym gelten, weil der Klartext nicht mehr sichtbar ist.

Die Kategorie kann sich ändern:

pii: true
pii_category: pseudonymous_identifier
sensitivity: confidential
classification_status: proposed

6. Aggregation

count(distinct customer_id) as customer_count

Empfohlene Regel:

Nicht automatisch herabstufen.
Das Ergebnis durch eine Aggregationsprüfung führen.

Das korrekte Ergebnis hängt ab von:

  • Aggregationsgranularität;
  • Mindestgruppengröße;
  • Filtern;
  • dünn besetzten Dimensionen;
  • Suppression Rules;
  • Differencing-Risiken;
  • erlaubter Nutzung.

Eine monatliche Anzahl je Land kann in einem Kontext nicht personenbezogen sein. Eine Anzahl nach seltener Erkrankung und Postleitzahl kann weiterhin hochsensibel sein.

7. Konstante oder technische Spalte

'CRM' as source_system
current_timestamp as loaded_at

Empfohlene Regel:

Keine Klassifikation von benachbarten Quellspalten übernehmen.

Technische Spalten benötigen eigene Metadaten, aber nicht die PII-Metadaten unabhängiger Inputs.

Sieben Propagierungsregeln für direkte Weitergabe, Umbenennung, Formatierung, Kombination, Hashing, Aggregation und technische Spalten mit automatischen, regelbasierten und reviewpflichtigen Ergebnissen
Unterschiedliche Transformationstypen erfordern unterschiedliches Propagierungsverhalten. Nur semantisch sichere Fälle sollten vollständig automatisiert werden.

Explizite Metadatenergebnisse verwenden

Ein propagiertes Ergebnis sollte zeigen, wie es entstanden ist.

Beispiel:

columns:
  - name: normalized_email
    config:
      meta:
        pii: true
        pii_category: email
        sensitivity: confidential
        classification_status: approved
        propagation_method: approved_rule
        propagated_from:
          - raw_crm_customer.email
        propagation_rule: retain_on_normalization

Ein generierter Vorschlag kann so aussehen:

columns:
  - name: full_name
    config:
      meta:
        pii: true
        pii_category:
          - name
        sensitivity: confidential
        classification_status: proposed
        propagation_method: inferred
        propagated_from:
          - raw_crm_customer.first_name
          - raw_crm_customer.last_name
        review_reason: multiple_sensitive_inputs

Eine nicht auflösbare Transformation bleibt explizit:

columns:
  - name: customer_segment_code
    config:
      meta:
        classification_status: unreviewed
        propagation_method: unresolved
        review_reason: unsupported_sql_expression

Das System darf Unsicherheit niemals in eine stillschweigende Freigabe umwandeln.

Mehrere Inputs deterministisch auflösen

Eine abgeleitete Spalte kann mehrere Upstream-Inputs mit unterschiedlichen Klassifikationen besitzen.

Beispiel:

concat(customer_id, ':', email) as contact_key

Input-Metadaten:

Input PII Sensitivität Status
customer_id true internal approved
email true confidential approved

Ein konservativer Default lautet:

PII = true, wenn mindestens eine beitragende Quelle PII ist
Sensitivität = strengster Wert der beitragenden Quellen
PII-Kategorie = kontrollierte Zusammenführung oder neue abgeleitete Kategorie
Status = proposed, sofern keine freigegebene Regel die Kombination auflöst

Der Metadata Resolver benötigt eine explizite Rangfolge:

public
< internal
< confidential
< restricted

Zusätzlich braucht er kontrollierte Category Mappings.

Die Vereinigung von email und customer_identifier darf nicht zu einem freien String werden:

email + customer id

Stattdessen wird eine freigegebene abgeleitete Kategorie verwendet:

pii_category: contact_identifier

Priorität von Overrides und Vorschlägen definieren

Nicht jedes Ergebnis sollte generiert werden.

Die stärkste Source of Truth muss gewinnen.

Ein praktikables Prioritätsmodell lautet:

Freigegebener Target Override
> freigegebene Transformationsregel
> propagierte freigegebene Quellmetadaten
> Inference- oder Detection-Vorschlag

Freigegebener Target Override

Ein Steward klassifiziert die Zielspalte explizit.

classification_status: approved
classification_source: steward_override

Der Propagierungsprozess muss diese Entscheidung erhalten.

Freigegebene Transformationsregel

Eine wiederverwendbare Regel wurde geprüft.

Beispiel:

lower(trim(email))
→ E-Mail-Klassifikation erhalten

Die Engine darf diese Regel automatisch anwenden.

Propagierte Quellmetadaten

Direkte Weitergabe oder Umbenennung kann freigegebene Upstream-Metadaten übernehmen.

Detection-Vorschlag

Namens- oder inhaltsbasierte Erkennung kann eine Klassifikation vorschlagen.

Sie darf niemals eine freigegebene Entscheidung überschreiben.

Mehrere klassifizierte Quellspalten werden über Column Lineage, Transformationsregeln, Target Overrides und Konfliktregeln in freigegebene, vorgeschlagene oder ungelöste Zielmetadaten überführt
Konflikte benötigen eine deterministische Priorität. Freigegebene Zielentscheidungen bleiben stärker als generierte Propagierungsergebnisse.

Auch zeilenbasierte Governance muss propagiert werden

Spaltenklassifikation ist nur ein Teil der Governance.

Ein Modell kann neue zeilenbasierte Dimensionen hinzufügen oder entfernen:

  • Gesellschaft;
  • Region;
  • Mandant;
  • Abteilung;
  • Kundenportfolio;
  • Vertragsbereich.

Ein Join kann eine neue Access Domain hinzufügen, obwohl sich keine PII-Spalte verändert.

Beispiel:

select
    o.order_id,
    o.customer_id,
    c.legal_entity,
    o.amount
from {{ ref('conform_orders') }} o
join {{ ref('conform_customer') }} c
  on o.customer_id = c.customer_id

Das Modell enthält jetzt legal_entity, das für Row-Level Durchsetzung erforderlich sein kann.

Column Lineage allein definiert nicht die richtige Zugriffsregel für das gesamte Modell.

Verwende Modellmetadaten:

config:
  meta:
    row_access_domain: legal_entity
    row_access_status: proposed

Der Propagierungsprozess kann mögliche Access Dimensions erkennen. Das finale Policy Mapping benötigt jedoch ein Review.

Technische Lineage und Governance Lineage trennen

Technische Lineage beantwortet:

Welcher SQL-Ausdruck hat diese Spalte erzeugt?

Governance Lineage ergänzt:

Welche Klassifikationsentscheidung wurde übernommen?
Welche Regel hat sie verändert?
Wer hat das Ergebnis genehmigt?
Welche Schutz-Policy soll gelten?

Ein Governance-Lineage-Datensatz kann enthalten:

target: analytics_customer.customer_contact
sources:
  - conform_customer.normalized_email
rule: retain_on_formatting
previous_status: approved
result_status: approved
approved_by: data_governance
policy_mapping: email_mask

Damit entsteht ein Nachweis, der über einen visuellen Dependency Graph hinausgeht.

Einen Diff erzeugen — keine versteckte Metadatenänderung

Propagierung sollte wie Codegenerierung funktionieren.

Empfohlener Workflow:

dbt-Projekt parsen
→ Modelle kompilieren oder parsen
→ Column Mappings erzeugen
→ freigegebene Metadaten lesen
→ Propagierungsregeln anwenden
→ Zielmetadaten vergleichen
→ deterministischen Diff erzeugen
→ Governance-Validierung ausführen
→ Review anfordern

Der generierte Diff kann:

  • Metadaten für eine neue Zielspalte ergänzen;
  • propagated_from aktualisieren;
  • einen Konflikt als ungelöst markieren;
  • eine strengere Sensitivität vorschlagen;
  • eine fehlende Masking Richtlinie melden;
  • einen verwaisten Override erkennen;
  • veraltete generierte Metadaten nach Review entfernen.

Er darf den Produktionskatalog oder das Warehouse nicht stillschweigend verändern.

Pull-Request-Workflow, der Modelle parst, Column Lineage erzeugt, Propagierungsregeln anwendet, Metadaten-Diffs erzeugt, Konflikte validiert und vor dem Deployment eine Steward-Freigabe verlangt
Propagierte Metadaten verändern governten Code. Git-Review hält Inferences, Konflikte und Overrides sichtbar.

Das Downstream-Ergebnis validieren

Ein Governance Validator sollte die finalen Zielmetadaten prüfen und nicht nur den Propagierungsprozess.

Sinnvolle Regeln sind:

  • jede freigegebene personenbezogene Daten-Spalte besitzt eine personenbezogene Daten-Kategorie;
  • jede freigegebene vertrauliche oder eingeschränkte personenbezogene Daten-Spalte besitzt ein Protection Mapping;
  • keine unreviewed-Spalte gelangt in ein geschütztes Analytics-Modell;
  • propagierte Metadaten referenzieren gültige Upstream-Spalten;
  • freigegebene Overrides enthalten einen verantwortliche Person oder Review-Verweis;
  • Sensitivität darf ohne freigegebene Regel nicht herabgestuft werden;
  • gelöschte Quellspalten hinterlassen keine veralteten Propagierungsverweise;
  • Row Access Domains existieren im Berechtigung-Modell;
  • ein Modell mit sensiblen Spalten besitzt einen verantwortlichen verantwortliche Person.

Beispielregel:

Wenn pii = true
und classification_status = approved
und sensitivity in [confidential, restricted]
dann muss masking_policy vorhanden sein.

Damit werden die Metadaten für das Betrieb Durchsetzung in Part 5 vorbereitet.

Unvollständige Lineage sicher behandeln

SQL-Lineage kann unvollständig sein.

Typische schwierige Fälle:

  • dynamisches SQL;
  • Macros mit komplex erzeugten Ausdrücken;
  • JSON-Extraktion;
  • Lateral Joins;
  • Wildcard Selection;
  • Python-Modelle;
  • adapterspezifische Syntax;
  • User-Defined Functions;
  • Stored Procedures.

Die sichere Reaktion besteht nicht im Raten.

Verwende vier mögliche Ergebnisse:

Automatisch aufgelöst
Durch freigegebene Regel aufgelöst
Durch expliziten Override aufgelöst
Ungelöst — Review erforderlich

Eine ungelöste Spalte sollte die Promotion blockieren, wenn sie sensible Daten offenlegen könnte.

Empfohlene Implementierungsarchitektur

Eine praktische Umsetzung kann aus folgenden Komponenten bestehen.

1. Metadata Registry

Speichert freigegebene Governance-Werte und Target Overrides.

Diese können als code-nahe technische Metadaten in dbt-YAML verbleiben und auf externe Policy- oder Glossarsysteme verweisen.

2. Lineage Extractor

Liest:

  • dbt-Ressourcen und Abhängigkeiten;
  • kompiliertes SQL;
  • Column Mappings aus Parser oder Katalog;
  • explizite Mappings für nicht unterstützte Fälle.

3. Propagation Engine

Wendet an:

  • Transformationsklassen;
  • Sensitivity Ordering;
  • Category Mappings;
  • Prioritätsregeln;
  • Exception Rules.

4. Diff Generator

Erzeugt stabile YAML-Änderungen oder einen Review-Bericht.

5. CI Validator

Verhindert, dass ungelöste oder ungültige Metadaten governte Layer erreichen.

6. Governance Review

Genehmigt Ausnahmen, Aggregate Downgrades und neue Transformationsregeln.

Das System kann klein beginnen. Direkte Weitergabe, Umbenennung und einfache Normalisierungsregeln reduzieren bereits große Mengen wiederkehrender Arbeit.

Häufige Propagierungs-Anti-Patterns

Alle Modellmetadaten auf jede Spalte kopieren

Modellkontext ist keine gültige Spaltenklassifikation.

Jedes Upstream-PII-Flag auf jede Zielspalte kopieren

Konstanten und unabhängige abgeleitete Felder werden überklassifiziert.

PII nach Hashing entfernen

Pseudonyme Identifikatoren können weiterhin verknüpfbar und sensibel sein.

Jedes Aggregat automatisch herabstufen

Kleine Gruppen und Filter können weiterhin Personen offenlegen.

Spaltennamen als Lineage behandeln

Ein gleicher Name beweist keine gemeinsame Herkunft.

Detection darf freigegebene Metadaten überschreiben

Eine Heuristik wird stärker als eine Governance-Entscheidung.

Propagierung in einem Catalog Sync verstecken

Änderungen werden schwer reviewbar, reproduzierbar und auditierbar.

Row-Access-Dimensionen ignorieren

Column Masking kann funktionieren, während Nutzer weiterhin unzulässige Zeilen erhalten.

Entscheidungshilfe

Transformation Standardentscheidung
Direkte Weitergabe Freigegebene Metadaten kopieren
Umbenennung Freigegebene Metadaten kopieren
Cast, Trim, Case Conversion Klassifikation erhalten
Kombination von Spalten Zusammenführen und prüfen, sofern keine Regel freigegeben ist
Hash oder Token Sensitivität erhalten; abgeleitete PII-Kategorie prüfen
Aggregat Vor Herabstufung prüfen
Konstante oder technisches Feld Nicht erben
Nicht unterstützter oder mehrdeutiger Ausdruck Als ungelöst markieren
Expliziter freigegebener Target Override Override erhalten
Reines Detection-Ergebnis Nur als Vorschlag speichern

Die zentrale Erkenntnis

PII-Metadaten sollen den Daten durch das Warehouse folgen. Jedes Propagierungsergebnis muss jedoch durch Lineage, eine kontrollierte Regel oder einen expliziten freigegebenen Override erklärbar sein.

Das stärkste Muster lautet:

Column Lineage
+ freigegebene Metadaten
+ Transformationsregeln
+ deterministische Priorität
→ reviewbarer Metadaten-Diff
→ Governance-Validierung
→ freigegebener Downstream-Vertrag

Part 5, Snowflake Masking Policies + Qlik Section Access, überführt diesen freigegebenen Downstream-Vertrag in ergänzende Warehouse- und Anwendungskontrollen.

Quellen und weiterführende Dokumentation

Funktionsstand: Juli 2026. Column-Lineage-Funktionen unterscheiden sich zwischen dbt-Produkten und externen Parsern. SQL-Parsing kann bei mehrdeutigen oder nicht unterstützten Transformationen unvollständig sein. Ungelöste Lineage muss deshalb reviewbar bleiben.

Teil 5

Snowflake Masking Policies + Qlik Section Access

Snowflake Masking Policies + Qlik Section Access

Governance-Metadaten werden wertvoll, wenn sie das Laufzeitergebnis verändern

Parts 1–4 haben einen kontrollierten Pfad aufgebaut:

Governance-Richtlinie
→ dbt-Metadatenvertrag
→ generierte RAW-Modelle
→ propagierte Downstream-Metadaten

Der letzte Schritt ist das Betrieb Durchsetzung.

Eine freigegebene Spalte kann enthalten:

pii: true
pii_category: email
sensitivity: confidential
classification_status: approved
masking_policy: email_mask

Ein governtes Modell kann enthalten:

row_access_domain: legal_entity
row_access_status: approved

Diese Werte schützen die Daten noch nicht selbstständig.

Sie müssen in technische Kontrollen überführt werden.

Dieser Artikel verbindet zwei ergänzende Ebenen:

Snowflake
→ zentrales Warehouse Durchsetzung

Qlik
→ Anwendungszugriff und anwendungsbezogene Datenreduktion

Snowflake schützt das governte Datenprodukt zur Abfragezeit. Qlik Section Access kontrolliert, was ein Nutzer in einer bestimmten Anwendung öffnen und sehen darf.

Keine der beiden Ebenen ersetzt automatisch die andere.

Eine Entscheidung kann mehrere Kontrollen erfordern

Betrachte einen Customer-Service-Datensatz.

Governance-Entscheidungen:

E-Mail ist vertrauliche PII.
Agents dürfen nur Kunden ihrer Gesellschaft sehen.
Supervisors dürfen alle Kunden ihrer Region sehen.
Data Stewards dürfen E-Mail-Werte im Klartext prüfen.

Die Umsetzung kann benötigen:

  • Snowflake Masking Richtlinie für email;
  • Snowflake Role- oder Berechtigung-Mapping;
  • Snowflake Row Access Richtlinie für legal_entity;
  • Qlik App Authorization;
  • Qlik Section Access Reduktion nach LEGAL_ENTITY;
  • optionales Qlik Field Omission für anwendungsspezifische Felder;
  • Persona Tests und Audit-Nachweise.

Die Kontrollen überschneiden sich im Zweck, greifen aber an unterschiedlichen Stellen.

Freigegebene Governance-Metadaten verzweigen in zentrales Snowflake Masking und Row Access sowie Qlik-Anwendungszugriff und Section-Access-Datenreduktion, bevor die effektive Benutzersicht entsteht
Eine Governance-Entscheidung kann Warehouse- und Anwendungskontrollen erfordern. Der zentrale Schutz bleibt auch außerhalb von Qlik wirksam.

Snowflake Dynamic Data Masking schützt Spaltenwerte

Snowflake Dynamic Data Masking ist eine Column-Level-Security-Funktion.

Eine Masking Policy wird zur Abfragezeit ausgewertet und kann abhängig von Ausführungskontext und Berechtigung unterschiedliche Darstellungen zurückgeben.

Mögliche Ergebnisse:

Berechtigte Rolle
→ Klartext

Eingeschränkte Rolle
→ teilweise maskierter Wert

Nicht berechtigte Rolle
→ vollständig maskierter Wert oder null

Eine vereinfachte Masking Policy kann so aussehen:

create or replace masking policy governance.email_mask
as (value string) returns string ->
    case
        when is_role_in_session('PII_CLEAR_ROLE') then value
        when is_role_in_session('PII_PARTIAL_ROLE')
            then regexp_replace(value, '(^.).*(@.*$)', '\\1***\\2')
        else null
    end;

Der konkrete Policy Body muss zum Role- und Berechtigung-Modell der Organisation passen.

Masking sollte nicht von anwendungsspezifischen Annahmen abhängen, wenn dasselbe Datenprodukt durch Qlik, Notebooks, APIs oder andere Werkzeuge verwendet wird.

Direkte Zuweisung oder Tag-basiertes Masking

Snowflake unterstützt zwei grundlegende Mapping-Muster.

Direkte Policy-Zuweisung

Die Policy wird an eine konkrete Spalte gebunden.

alter table analytics.customer
    modify column email
    set masking policy governance.email_mask;

Vorteile:

  • explizit;
  • für Ausnahmen leicht verständlich;
  • direkte Beziehung zwischen Spalte und Richtlinie.

Nachteile:

  • bei großer Anzahl repetitiv;
  • mehr Attachment Operations;
  • schwerer über viele Schemas und Modelle zu verwalten.

Tag-basiertes Masking

Ein Governance Tag wird einer Spalte zugewiesen. Eine Masking Policy wird mit dem Tag verbunden.

Konzeptionell:

dbt-Metadaten
→ Snowflake Tag Value
→ Tag-basierte Masking Policy
→ geschützte Spalte

Damit entsteht ein skalierbares Mapping von:

pii_category: email
masking_policy: email_mask

zu:

Tag: PII_CATEGORY = EMAIL
Policy: EMAIL_MASK

Neue Spalten mit dem governten Tag können über die Tag-Policy-Beziehung geschützt werden.

Tag-basiertes Masking eignet sich besonders, wenn:

  • viele Spalten dieselbe Richtlinie teilen;
  • Tags konsistent verwaltet werden;
  • Datentypen kontrolliert sind;
  • Richtlinie Verantwortung vom Model Verantwortung getrennt ist;
  • Richtlinie-Referenzen zentral auditiert werden.

Direkte Zuweisung bleibt für explizite Ausnahmen sinnvoll.

Policy Administration und Model Verantwortung trennen

Ein Data Engineer kann ein Modell besitzen, ohne entscheiden zu dürfen, wer PII im Klartext sieht.

Eine sinnvolle Funktionstrennung ist:

Verantwortung Typischer Owner
dbt-Modell und Metadatenreferenz Data Engineering
Freigabe der PII-Klassifikation Data Steward oder Privacy
Definition der Masking Policy Security oder Privacy Engineering
Tag-Policy-Mapping Governance Security Administration
Rollen- und Berechtigung-Mapping Identity and Access Management
Anwendungsreduktion BI- oder Application Owner
Validierung des effektiven Zugriffs Governance, Security und Application Owner

Dadurch kann ein Model Owner nicht stillschweigend eine Schutz-Policy abschwächen.

Metadaten-Mappings kontrolliert deployen

Das dbt-Modell kann das freigegebene Mapping enthalten:

columns:
  - name: email
    config:
      meta:
        pii: true
        pii_category: email
        sensitivity: confidential
        classification_status: approved
        masking_policy: email_mask

Ein Deployment-Schritt kann:

  1. den kompilierten Metadatenvertrag lesen;
  2. email_mask zu einer freigegebenen Snowflake Policy auflösen;
  3. Tag- oder Policy-DDL erzeugen;
  4. Soll- und Ist-Zustand vergleichen;
  5. die genehmigte Änderung anwenden;
  6. Policy References abfragen;
  7. Persona Tests ausführen;
  8. Nachweise speichern.

Diese Logik kann mit kontrollierten Macros, Operations, Infrastructure Code oder einem Governance Deployment Service umgesetzt werden.

Entscheidend ist, dass das Policy Attachment:

  • deterministisch;
  • reviewt;
  • idempotent;
  • auditierbar;
  • von gewöhnlicher Query-Logik getrennt bleibt.
Ablauf von dbt-Governance-Metadaten über Policy Mapping und Snowflake Tag oder direkte Policy-Zuweisung zu maskierten Abfrageergebnissen für berechtigte, eingeschränkte und nicht berechtigte Rollen
Freigegebene Metadaten wählen ein kontrolliertes Policy Mapping. Snowflake wertet die Masking Policy aus, wenn die Spalte abgefragt wird.

Row Access ist von Masking getrennt

Masking steuert den zurückgegebenen Wert einer Spalte.

Row Access steuert, welche Datensätze zurückgegeben werden.

Ein Nutzer darf möglicherweise Folgendes sehen:

alle Spalten
aber nur Zeilen für legal_entity = DE

Ein anderer Nutzer sieht:

alle Gesellschaften
aber maskierte E-Mail-Werte

Das sind unterschiedliche Berechtigungsdimensionen.

Eine vereinfachte Snowflake Row Access Policy kann ein Berechtigung Mapping verwenden:

create or replace row access policy governance.legal_entity_access
as (legal_entity string) returns boolean ->
    exists (
        select 1
        from governance.user_legal_entity_access a
        where a.role_name = current_role()
          and a.legal_entity = legal_entity
    );

Sie kann an eine Tabelle oder View gebunden werden:

alter table analytics.customer
    add row access policy governance.legal_entity_access
    on (legal_entity);

Besitzt ein Objekt sowohl eine Row Access Policy als auch Masking Policies, wertet Snowflake den Row Access vor dem Masking aus.

Dieses zentrale Durchsetzung schützt Warehouse-Zugriffe außerhalb von Qlik.

Qlik Section Access kontrolliert eine Anwendung

Section Access ist Teil des Qlik Load Scripts.

Es definiert:

  • wer die Anwendung öffnen darf;
  • welche Zeilen dem authentifizierten Nutzer zur Verfügung stehen;
  • optional, welche Felder ausgelassen werden.

Das Script besitzt zwei Bereiche:

Section Access;

LOAD
    ACCESS,
    USERID,
    LEGAL_ENTITY,
    OMIT
FROM ...;

Section Application;

Customer:
LOAD
    CUSTOMER_ID,
    LEGAL_ENTITY,
    EMAIL,
    CUSTOMER_NAME
FROM ...;

Abhängig von der Qlik-Umgebung kann die Identität durch USERID oder USER.EMAIL dargestellt werden.

Das Reduktionsfeld muss in Section Access und Section Application mit exakt demselben Namen existieren. Qlik behandelt Feldnamen und Werte im Access-Bereich in Großbuchstaben. Das Reduktionsdesign muss sie deshalb konsistent normalisieren.

Beim Öffnen der App gleicht Qlik die Security Rows des Nutzers mit den Anwendungsdaten ab und blendet ausgeschlossene Daten aus.

Section Access hat drei unterschiedliche Aufgaben

1. Application Authorization

Besitzt der Nutzer keine gültige Security Row, wird die App unter Strict Exclusion verweigert.

Das unterscheidet sich von der Plattformberechtigung, das App-Objekt in einem Space oder Stream zu sehen.

Sowohl Plattformberechtigung als auch Section Access können relevant sein.

2. Row Reduktion

Ein Reduktionsfeld verbindet Security Rows mit Application Rows.

Beispiel:

ACCESS | USERID             | LEGAL_ENTITY
USER   | DOMAIN\ANALYST_A   | DE
USER   | DOMAIN\ANALYST_B   | NL
ADMIN  | DOMAIN\STEWARD     | *

Ein normaler Nutzer sieht nur passende Daten.

Der Wildcard muss kontrolliert werden. In Reduktionsfeldern repräsentiert sie Werte, die in der Section-Access-Tabelle vorhanden sind, nicht beliebige zukünftige Werte, die ausschließlich in den Anwendungsdaten existieren.

3. Field Omission

Das optionale Feld OMIT kann benannte Anwendungsfelder für bestimmte Nutzer ausblenden.

Das kann anwendungsspezifische Anforderungen unterstützen, sollte Snowflake Masking für zentral sensible Spalten aber nicht ersetzen.

Die Qlik-Dokumentation empfiehlt, OMIT nicht auf Key Fields anzuwenden, da dies zu verwirrendem oder unvollständigem Anwendungsverhalten führen kann.

Qlik-Section-Access-Ablauf vom authentifizierten Nutzer und der Security Table über übereinstimmende Reduktionsfelder in Großbuchstaben zu einer governten Anwendung mit verweigertem, reduziertem oder erweitert freigegebenem Datenzugriff
Section Access schützt eine Qlik-Anwendung durch Authorization und Datenreduktion. Es schützt keinen direkten Zugriff auf das zugrunde liegende Warehouse.

Berechtigungs nicht unabhängig in jeder App pflegen

Eine häufige Umsetzung bettet Nutzer direkt in das Script ein:

Section Access;

LOAD * INLINE [
ACCESS, USERID, LEGAL_ENTITY
USER, DOMAIN\USER_A, DE
USER, DOMAIN\USER_B, NL
];

Für einen Prototyp kann das funktionieren.

Als Enterprise Access Model skaliert es nicht.

Ein stärkeres Muster nutzt eine governte Berechtigung Source:

Identität oder Rolle
→ Berechtigung-Tabelle
→ Warehouse Access Policy
→ Qlik Section Access Extract

Beispiel:

Principal Access Domain Wert Application Scope Gültig ab Gültig bis
Regional Analyst DE legal_entity DE customer_app 2026-01-01 null
Regional Analyst NL legal_entity NL customer_app 2026-01-01 null
Data Steward legal_entity * customer_app 2026-01-01 null

Dieselbe führende Quelle kann speisen:

  • Snowflake Row Access Logic;
  • Qlik Section Access Tables;
  • Access-Review-Berichte;
  • Ablaufprüfungen;
  • Audit-Nachweise.

Die generierte Qlik Security Table darf weiterhin anwendungsspezifisch sein. Die Berechtigung-Entscheidung sollte jedoch nicht in jeder App manuell neu aufgebaut werden.

Warehouse Roles und Qlik Users sauber ausrichten

Snowflake kann eine Service Role sehen, die von der Qlik-Verbindung genutzt wird. Qlik wendet innerhalb der App die Reduktion für den Endnutzer an.

Damit entsteht eine wichtige Trennung.

Snowflake Query Identity
→ Qlik Connection oder Service Role

Qlik Application Identity
→ authentifizierter Endnutzer

Kann die Qlik Connection Role breite Daten laden, ist Section Access für die nutzerbezogene Reduktion des App-Ergebnisses verantwortlich.

Das Warehouse muss sensible Spalten gegenüber dieser Connection Role weiterhin entsprechend der Zielarchitektur schützen.

Mögliche Muster:

Breite governte Service Role

Die Qlik Service Role kann alle für die App erforderlichen Zeilen laden. Snowflake Masking schützt Werte, die die App niemals erhalten soll.

Qlik Section Access reduziert anschließend die Zeilen je Endnutzer.

Mehrere Application Roles oder Datenprodukte

Unterschiedliche Apps oder Domänen verwenden engere Snowflake Roles oder governte Views.

Dadurch wird die Datenmenge begrenzt, die jede App-Verbindung erhalten kann.

Endnutzerbezogene Query Patterns

Soweit die gewählte Architektur dies unterstützt, erhält das Warehouse einen Endnutzer- oder Berechtigung-Kontext.

Das kann zentrales Durchsetzung verstärken, erhöht aber Komplexität bei Identity Passing und Query Design.

Das richtige Design hängt von Qlik Deployment Mode, Connection Model, Latenz und Security-Anforderungen ab.

Unverzichtbar ist:

Dokumentiere, welche Identität Snowflake und welche Identität Qlik auswertet.

Änderungen an Section Access benötigen Reload und Validierung

Section Access wird in die Anwendung geladen.

Änderungen an Security Table oder Script benötigen einen App Reload, bevor sie wirksam werden.

Auch die Reload Identity muss berücksichtigt werden. In Qlik Sense on Windows können Scheduler- oder Service-Identitäten expliziten administrativen Zugriff oder ein freigegebenes Impersonation Setup benötigen.

Ein fehlerhaftes Service-Account-Design kann verursachen:

  • fehlgeschlagene Reloads;
  • unbeabsichtigt breiten Zugriff;
  • Aussperrung aus der Anwendung;
  • veraltete Berechtigungs.

Service Accounts gehören in die Testmatrix und dürfen kein nachträglicher Sonderfall sein.

Effektiven Zugriff testen — nicht nur Konfiguration

Eine Policy kann existieren und dennoch das falsche Ergebnis erzeugen.

Die Validierung benötigt konkrete Personas.

Beispiel:

Persona Snowflake Role Erwartete E-Mail Erwartete Zeilen Qlik App
Data Steward PII_CLEAR_ROLE Klartext freigegebener breiter Scope breiter governter Zugriff
Regional Analyst DE ANALYST_ROLE maskiert nur DE nur DE
Customer Service User SERVICE_ROLE teilweise maskiert nur zugewiesene Gesellschaft nur zugewiesene Gesellschaft
Qlik Reload Service QLIK_LOAD_ROLE gemäß App Contract App Load Scope Reload erfolgreich
Nicht berechtigter Nutzer keine kein Zugriff keine App verweigert

Tests sollten prüfen:

  • Klartext, teilweise und vollständig maskierte Werte;
  • Gesellschafts- oder Regions-Umfang;
  • verweigerten Zugriff;
  • Verhalten bei fehlendem Berechtigung;
  • Wildcard-Verhalten;
  • nicht passende Reduktionswerte;
  • App Reload;
  • direkte Snowflake-Abfrage außerhalb von Qlik;
  • Verhalten kopierter oder neu publizierter Apps;
  • Nachweise nach Richtlinie-Änderungen.
Personabasierte Validierungsmatrix mit Snowflake Role, maskiertem Spaltenergebnis, Warehouse-Zeilenscope und Qlik-Anwendungsergebnis sowie anschließender Nachweiserfassung und Freigabe
Tests des effektiven Zugriffs validieren den gesamten Pfad. Reine Konfigurationsprüfungen beweisen nicht, dass jede Persona das vorgesehene Ergebnis erhält.

Konfigurierte und effektive Kontrollen auditieren

Snowflake stellt Metadatenansichten und Funktionen zur Prüfung der Policy-Konfiguration bereit.

Nützliche Nachweise:

  • Definitionen der Masking Richtlinien;
  • Richtlinie References;
  • Tag References;
  • Definitionen der Row Access Richtlinien;
  • Role Grants;
  • Änderungen an Berechtigung Tables;
  • Ergebnisse von Query Tests.

Qlik-Nachweise können enthalten:

  • Version der Section-Access-Quelle;
  • App Reload Status;
  • Ergebnisse effektiver User Tests;
  • veröffentlichte App-Version;
  • fehlgeschlagene Zugriffsversuche;
  • Berechtigung Extracts;
  • Application Verantwortung.

Ein sinnvoller Nachweis verbindet:

Governance-Entscheidung
→ dbt-Metadatenreferenz
→ Snowflake Policy Attachment
→ Qlik Security Mapping
→ Persona Test
→ Review-Freigabe

Die Deployment-Reihenfolge ist relevant

Eine sichere Reihenfolge verhindert temporäre Offenlegung.

Beispiel:

Freigegebene Policy erstellen oder aktualisieren
→ Policy oder governten Tag anbinden
→ Policy Reference prüfen
→ Warehouse Personas testen
→ Qlik-Anwendung reloaden
→ Qlik Personas testen
→ Deployment freigeben

Beim Ersetzen von Policies darf kein unkontrolliertes Zeitfenster entstehen, in dem das Objekt ungeschützt ist.

Änderungen an Tag, Masking Policy, Row Policy, Rolle oder Section Access Table sind Security Changes und keine gewöhnlichen kosmetischen Konfigurationen.

Tag-basierter Row Access ist für diese Architektur nicht erforderlich

Snowflake hat im Juli 2026 Tag-basierte Unterstützung für weitere Policy-Typen einschließlich Row Access als Public Preview eingeführt.

Dieser Artikel setzt diese Preview-Funktion nicht voraus.

Die stabile Kernarchitektur kann verwenden:

  • Tag-basiertes Masking für Spaltenschutz;
  • direkt zugewiesene Snowflake Row Access Richtlinien;
  • Qlik Section Access für anwendungsbezogene Reduktion.

Preview-Funktionen können getrennt im Feature-Adoption-Prozess der Organisation bewertet werden.

Häufige Durchsetzung-Anti-Patterns

Nur den Masking-Policy-Namen in dbt speichern

Der Metadatenvertrag existiert, aber keine Laufzeit-Policy ist angebunden.

PII ausschließlich in Qlik schützen

Direkter Snowflake-Zugriff kann die Anwendungskontrolle umgehen.

Masking für Row Security verwenden

Maskierte Werte verhindern nicht, dass unzulässige Zeilen zurückgegeben werden.

Section Access als Enterprise Identity System verwenden

Nutzer- und Berechtigung-Logik wird über Apps dupliziert.

Breite Wildcard ohne Tests für neue Werte verwenden

Neue Gesellschaften oder Bereiche können sich anders verhalten als erwartet.

Key Fields auslassen

Die Anwendung kann unverständlich oder unvollständig werden.

Nur mit Administratoren testen

Normale Nutzer, verweigerte Nutzer und Service Accounts bleiben ungeprüft.

Annehmen, dass Qlik User und Snowflake User identisch sind

Das Warehouse kann eine gemeinsame Connection Role auswerten.

Policy-Austausch ohne kontrollierte Reihenfolge deployen

Ein temporär ungeschützter Zustand kann entstehen.

Entscheidungshilfe

Anforderung Primäre Kontrolle
Sensible Spaltenwerte zentral maskieren Snowflake Masking Policy
Dieselbe Masking-Regel auf viele Spalten anwenden Snowflake Tag-basiertes Masking
Warehouse-Zeilen beschränken Snowflake Row Access Policy
Zugriff auf eine Qlik-App beschränken Qlik Section Access plus Plattformberechtigung
App-Zeilen je Nutzer reduzieren Qlik Section Access Reduktion Field
Anwendungsspezifisches Feld ausblenden Qlik OMIT, vorsichtig eingesetzt
Wiederverwendbare Berechtigung-Entscheidungen pflegen Governte Berechtigung Source
Effektiven Zugriff nachweisen Personabasierte Warehouse- und Qlik-Tests
Zugriff außerhalb von Qlik schützen Snowflake-Kontrollen
Anwendungsspezifische Reduktion umsetzen Qlik Section Access

Die zentrale Erkenntnis

Governance Durchsetzung ist am stärksten, wenn Snowflake das gemeinsame Datenprodukt zentral schützt und Qlik eine kontrollierte anwendungsspezifische Authorization und Reduktion ergänzt.

Das vollständige Betriebsmodell lautet:

Freigegebene Metadaten
→ kontrolliertes Policy Mapping
→ Snowflake Masking und Row Access
→ governter Qlik Load
→ Section Access Reduktion
→ Persona Tests
→ Audit-Nachweise

Damit ist die Serie abgeschlossen:

  1. Architektur;
  2. Metadatenvertrag;
  3. kontrollierte RAW-Generierung;
  4. Metadatenpropagierung;
  5. Betrieb Durchsetzung.

Quellen und weiterführende Dokumentation

Funktionsstand: Juli 2026. Snowflake Dynamic Data Masking benötigt Enterprise Edition oder höher. Tag-basierte Unterstützung für Row Access und mehrere weitere Policy-Typen wurde am 21. Juli 2026 als Public Preview eingeführt. Die Kernempfehlung dieses Artikels hängt nicht von dieser Preview ab.

Tour