LakeFormation & Unity Catalog: Data Governance 2026

Data Governance in 2026: Waarom het Urgenter Is Dan Ooit

Data governance was lange tijd een onderwerp dat vooral compliance-officers bezighield. In 2026 is dat radicaal veranderd. Met de explosieve groei van data meshes, multi-cloud architecturen en steeds strengere regelgeving (GDPR, AI Act, NIS2) is governance een eerste-klas engineering-onderwerp geworden. Twee platforms domineren het debat: AWS Lake Formation en Databricks Unity Catalog.

Beide tools beloven hetzelfde: centrale controle over wie welke data mag zien, volledige lineage van bron tot dashboard, en fine-grained access control tot op rij- en kolomniveau. Maar ze doen dat op fundamenteel verschillende manieren, vanuit fundamenteel verschillende architectuurfilosofieën. In dit artikel duiken we diep in beide platforms, vergelijken we ze eerlijk, en geven we je concrete code en best practices om morgen mee aan de slag te gaan.

Architectuur: Hoe Werken Ze?

Voordat we code schrijven, is het cruciaal om de onderliggende architectuur te begrijpen. Unity Catalog en Lake Formation zijn gebouwd vanuit verschillende paradigma's.

Unity Catalog: One Catalog to Rule Them All

Unity Catalog introduceert een drielaags naamruimtemodel: catalog.schema.table. Dit klinkt simpel, maar is een fundamentele breuk met het oude Hive Metastore-model waarbij iedere workspace zijn eigen geïsoleerde metastore had.

AWS Lake Formation: Governance als Laag bovenop AWS

Lake Formation werkt anders: het is geen nieuw opslag- of query-systeem, maar een governance-laag die bestaande AWS-diensten met elkaar verbindt. De centrale concepten zijn:

Praktische Codevoorbeelden

Unity Catalog: Tabellen aanmaken en rechten beheren

Het volgende voorbeeld toont een typische setup voor een finance-domein in een data mesh architectuur:

-- Stap 1: Catalog en schema aanmaken (uitgevoerd door Account Admin)
CREATE CATALOG IF NOT EXISTS finance
  COMMENT 'Finance domein catalog - eigenaar: Finance Engineering Team';

CREATE SCHEMA IF NOT EXISTS finance.reporting
  COMMENT 'Gerapporteerde KPIs voor management dashboards'
  MANAGED LOCATION 's3://company-datalake/finance/reporting/';

-- Stap 2: Delta table met kolomgevoeligheid
CREATE TABLE IF NOT EXISTS finance.reporting.transactions (
  transaction_id  STRING    NOT NULL,
  customer_id     STRING,   -- PII kolom
  amount          DECIMAL(18, 2),
  currency        STRING,
  transaction_ts  TIMESTAMP,
  country_code    STRING
)
USING DELTA
TBLPROPERTIES (
  'delta.enableChangeDataFeed' = 'true',
  'sensitivity'                = 'confidential'
);

-- Stap 3: Tag kolom als PII (Column Tags - GA in 2024)
ALTER TABLE finance.reporting.transactions
  ALTER COLUMN customer_id
  SET TAGS ('pii' = 'true', 'gdpr_relevant' = 'true');

-- Stap 4: Fine-grained access - analisten zien geen customer_id
CREATE VIEW finance.reporting.transactions_masked AS
SELECT
  transaction_id,
  CASE
    WHEN is_member('finance_analysts') THEN '***MASKED***'
    ELSE customer_id
  END AS customer_id,
  amount,
  currency,
  transaction_ts,
  country_code
FROM finance.reporting.transactions;

-- Stap 5: Row-level security via dynamic views
CREATE VIEW finance.reporting.transactions_by_country AS
SELECT * FROM finance.reporting.transactions
WHERE country_code IN (
  SELECT allowed_country
  FROM finance.security.user_country_access
  WHERE user_email = current_user()
);

-- Stap 6: Rechten verlenen
GRANT USE CATALOG ON CATALOG finance TO `finance-team@company.com`;
GRANT USE SCHEMA  ON SCHEMA finance.reporting TO `finance-team@company.com`;
GRANT SELECT      ON TABLE finance.reporting.transactions_masked
  TO `finance_analysts`;
GRANT SELECT, MODIFY ON TABLE finance.reporting.transactions
  TO `finance_engineers`;

Unity Catalog: Data Lineage via Python API

Unity Catalog registreert automatisch lineage voor Spark-jobs die draaien op Databricks clusters. Je kunt deze lineage ook programmatisch opvragen:

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.catalog import LineageDirection

w = WorkspaceClient()

# Ophalen van upstream lineage voor een specifieke tabel
lineage = w.table_lineage.list(
    table_name="finance.reporting.transactions",
    direction=LineageDirection.UPSTREAM,
    max_results=50
)

for node in lineage:
    print(f"Type: {node.entity_type}")
    print(f"Naam: {node.entity_name}")
    print(f"Job ID: {node.job_id}")
    print(f"Notebook Path: {node.notebook_path}")
    print("---")

# Kolom-level lineage (Column Lineage)
col_lineage = w.column_lineage.list(
    table_name="finance.reporting.transactions",
    column_name="amount"
)

for link in col_lineage.upstream_cols:
    print(f"  ← {link.table_name}.{link.name} (via {link.transform_type})")

AWS Lake Formation: Tag-Based Access Control

Het volgende Boto3-voorbeeld implementeert TBAC voor een vergelijkbaar finance-scenario:

import boto3

lf_client  = boto3.client('lakeformation', region_name='eu-west-1')
glue_client = boto3.client('glue', region_name='eu-west-1')

# Stap 1: LF-Tags aanmaken
tags_to_create = [
    {'TagKey': 'sensitivity',    'TagValues': ['public', 'internal', 'confidential', 'restricted']},
    {'TagKey': 'gdpr_relevant',  'TagValues': ['true', 'false']},
    {'TagKey': 'data_domain',    'TagValues': ['finance', 'marketing', 'hr', 'ops']},
]

for tag in tags_to_create:
    try:
        lf_client.create_lf_tag(**tag)
        print(f"Tag aangemaakt: {tag['TagKey']}")
    except lf_client.exceptions.AlreadyExistsException:
        print(f"Tag bestaat al: {tag['TagKey']}")

# Stap 2: Tags toewijzen aan tabel en kolommen
lf_client.add_lf_tags_to_resource(
    Resource={
        'Table': {
            'DatabaseName': 'finance_reporting',
            'Name': 'transactions'
        }
    },
    LFTags=[
        {'TagKey': 'sensitivity',   'TagValues': ['confidential']},
        {'TagKey': 'data_domain',   'TagValues': ['finance']},
    ]
)

# PII-tag op kolomniveau
lf_client.add_lf_tags_to_resource(
    Resource={
        'TableWithColumns': {
            'DatabaseName': 'finance_reporting',
            'Name': 'transactions',
            'ColumnNames': ['customer_id', 'iban']
        }
    },
    LFTags=[
        {'TagKey': 'gdpr_relevant', 'TagValues': ['true']},
    ]
)

# Stap 3: Rechten verlenen op basis van tags
# Finance analisten mogen confidential data zien, BEHALVE gdpr_relevant kolommen
lf_client.grant_permissions(
    Principal={'DataLakePrincipalIdentifier': 'arn:aws:iam::123456789:role/FinanceAnalystsRole'},
    Resource={
        'LFTagPolicy': {
            'ResourceType': 'TABLE',
            'Expression': [
                {'TagKey': 'sensitivity',  'TagValues': ['internal', 'confidential']},
                {'TagKey': 'data_domain',  'TagValues': ['finance']},
            ]
        }
    },
    Permissions=['SELECT'],
    PermissionsWithGrantOption=[]
)

# Stap 4: Data Filters voor row-level security
lf_client.create_data_cells_filter(
    TableData={
        'TableCatalogId': '123456789012',
        'DatabaseName': 'finance_reporting',
        'TableName': 'transactions',
        'Name': 'nl_transactions_only',
        'RowFilter': {
            'FilterExpression': "country_code = 'NL'"
        },
        'ColumnWildcard': {
            'ExcludedColumnNames': ['customer_id', 'iban']
        }
    }
)

print("Lake Formation governance configuratie voltooid!")

Vergelijking: Unity Catalog vs Lake Formation vs Alternatieven

Data Mesh Implementatie: Best Practices

Data mesh en governance zijn onlosmakelijk verbonden. Een data mesh zonder governance is anarchie; governance zonder mesh-principes is een bottleneck. Hier zijn de meest kritieke lessen uit productiemplementaties:

Monitoring met Unity Catalog System Tables

-- Unity Catalog System Tables: audit log analyse
-- Beschikbaar via catalog: system.access.audit

-- Top 10 gebruikers op basis van data access volume (afgelopen 30 dagen)
SELECT
    user_identity.email                    AS user_email,
    request_params['full_name_arg']        AS table_accessed,
    COUNT(*)                               AS access_count,
    COUNT(DISTINCT DATE(event_time))       AS active_days,
    MAX(event_time)                        AS last_access
FROM system.access.audit
WHERE
    action_name IN ('commandSubmit', 'selectFromTable')
    AND event_time >= DATEADD(DAY, -30, CURRENT_TIMESTAMP())
    AND response.status_code = 200
GROUP BY 1, 2
ORDER BY access_count DESC
LIMIT 10;

-- Detecteer potentiële data exfiltratie: grote queries buiten kantooruren
SELECT
    user_identity.email                 AS user_email,
    request_params['full_name_arg']     AS table_name,
    response.result['num_rows_affected'] AS rows_returned,
    event_time,
    source_ip_address
FROM system.access.audit
WHERE
    action_name = 'selectFromTable'
    AND HOUR(event_time) NOT BETWEEN 7 AND 19  -- buiten kantooruren
    AND CAST(response.result['num_rows_affected'] AS BIGINT) > 100000
    AND event_time >= DATEADD(DAY, -7, CURRENT_TIMESTAMP())
ORDER BY rows_returned DESC;

-- Kolom-level access tracking voor PII compliance
SELECT
    user_identity.email               AS user_email,
    request_params['table_name']      AS table_name,
    request_params['column_name']     AS column_name,
    COUNT(*)                          AS access_count,
    MIN(event_time)                   AS first_access,
    MAX(event_time)                   AS last_access
FROM system.access.column_access
WHERE
    request_params['column_name'] IN (
        SELECT column_name
        FROM system.information_schema.column_tags
        WHERE tag_name = 'pii' AND tag_value = 'true'
    )
    AND event_time >= DATEADD(MONTH, -3, CURRENT_TIMESTAMP())
GROUP BY 1, 2, 3
ORDER BY access_count DESC;

AI Governance: De Nieuwe Frontier

In 2026 is data governance uitgebreid naar AI governance. Unity Catalog speelt hier een sleutelrol: ML-modellen, feature stores en AI-assets zijn nu first-class citizens in de catalog.

Conclusie: Wanneer Kies Je Wat?

Na deze diepgaande analyse is de keuze eigenlijk verrassend helder, mits je eerlijk bent over je situatie: