Iceberg REST Catalog: De Nieuwe Standaard voor Data Mesh

Wat is de Iceberg REST Catalog — en waarom is het in 2026 onmisbaar?

De datawereld beweegt razendsnel. Waar organisaties een paar jaar geleden nog genoegen namen met één centrale data warehouse, zien we nu een breed landschap van engines, clouds en teams die elk hun eigen stukje data beheren. Data Mesh is daarbij geen hype meer: het is een architectuurparadigma dat in 2026 bij veel Nederlandse enterprise-organisaties in productie draait. Maar data mesh brengt een hardnekkig probleem mee — hoe zorg je dat al die gedecentraliseerde dataproducten elkaar kunnen vinden en vertrouwen?

Hier komt de Iceberg REST Catalog om de hoek kijken. Apache Iceberg is al jaren de de-facto standaard voor open table formats in het data lakehouse. De REST Catalog specificatie — officieel onderdeel van de Apache Iceberg community — definieert een vendor-neutrale HTTP API waarmee elke engine (Spark, Trino, Flink, DuckDB, Snowflake, ...) tabellen kan registreren, opzoeken en beheren zonder vendor lock-in.

In 2026 zijn er meerdere volwassen implementaties beschikbaar: Apache Polaris (open source, gedoneerd door Snowflake), Unity Catalog (Databricks, recent open-source gegaan), Gravitino (Apache incubator), en cloud-native opties als AWS Glue REST endpoint en Azure Purview REST bridge. De strijd om de "open catalog standaard" is actueler dan ooit — en Nederlandse data engineers staan voor concrete keuzes.

Hoe werkt de Iceberg REST Catalog?

Laten we de architectuur stap voor stap doorlopen. De REST Catalog volgt een client-server model waarbij de catalogusserver de bron van waarheid is voor tabel-metadata, en engines enkel nog via HTTP praten in plaats van rechtstreeks naar een metastore.

Architectuur in één oogopslag

Praktische Codevoorbeelden

3.1 Apache Spark verbinden met een REST Catalog (Polaris)

Onderstaand voorbeeld configureert PySpark om via de REST Catalog te praten met een lokale Polaris-instantie. Dit werkt identiek tegen Unity Catalog of elke andere compliant server — enkel de uri en credentials veranderen.

from pyspark.sql import SparkSession

spark = (
    SparkSession.builder
    .appName("iceberg-rest-demo")
    # Iceberg Spark runtime (pas versie aan op je cluster)
    .config("spark.jars.packages",
            "org.apache.iceberg:iceberg-spark-runtime-3.5_2.12:1.6.1,"
            "org.apache.iceberg:iceberg-aws-bundle:1.6.1")
    # Catalogus configuratie
    .config("spark.sql.catalog.prod", "org.apache.iceberg.spark.SparkCatalog")
    .config("spark.sql.catalog.prod.type", "rest")
    .config("spark.sql.catalog.prod.uri", "https://catalog.mijnbedrijf.nl/iceberg")
    .config("spark.sql.catalog.prod.credential",
            "client_id:super_geheim_secret")
    .config("spark.sql.catalog.prod.scope", "PRINCIPAL_ROLE:data_engineer")
    # Warehouse locatie op S3
    .config("spark.sql.catalog.prod.warehouse", "s3://mijn-lakehouse/warehouse")
    .config("spark.sql.catalog.prod.s3.region", "eu-west-1")
    # Credential vending inschakelen (Polaris feature)
    .config("spark.sql.catalog.prod.header.X-Iceberg-Access-Delegation",
            "vended-credentials")
    .getOrCreate()
)

# Namespace aanmaken
spark.sql("CREATE NAMESPACE IF NOT EXISTS prod.verkoop")

# Tabel aanmaken met partitionering
spark.sql("""
    CREATE TABLE IF NOT EXISTS prod.verkoop.orders (
        order_id     BIGINT,
        klant_id     BIGINT,
        bedrag       DECIMAL(10, 2),
        valuta       STRING,
        bestel_datum DATE,
        status       STRING
    )
    USING iceberg
    PARTITIONED BY (months(bestel_datum), status)
    TBLPROPERTIES (
        'write.format.default'          = 'parquet',
        'write.parquet.compression-codec' = 'zstd',
        'write.metadata.metrics.default'  = 'full'
    )
""")

print("Tabel succesvol aangemaakt via REST Catalog!")

3.2 Directe REST API aanroepen met Python (requests)

Soms wil je buiten Spark om de catalog bevragen — voor monitoring, governance tooling of een custom data mesh control plane. Onderstaand script laat zien hoe dat werkt met de standaard REST API.

import requests
from datetime import datetime, timedelta

CATALOG_URL  = "https://catalog.mijnbedrijf.nl/iceberg"
TOKEN_URL    = "https://catalog.mijnbedrijf.nl/oauth/tokens"
CLIENT_ID    = "data-platform-service"
CLIENT_SECRET = "super_geheim_secret"

# Stap 1: OAuth 2.0 token ophalen
def get_access_token() -> str:
    resp = requests.post(TOKEN_URL, data={
        "grant_type"   : "client_credentials",
        "client_id"    : CLIENT_ID,
        "client_secret": CLIENT_SECRET,
        "scope"        : "PRINCIPAL_ROLE:data_engineer",
    })
    resp.raise_for_status()
    return resp.json()["access_token"]

token = get_access_token()
headers = {
    "Authorization": f"Bearer {token}",
    "Content-Type" : "application/json",
}

# Stap 2: Alle namespaces ophalen
namespaces = requests.get(
    f"{CATALOG_URL}/v1/namespaces",
    headers=headers,
).json()
print("Beschikbare namespaces:", namespaces["namespaces"])

# Stap 3: Tabellen in een namespace ophalen
tabellen = requests.get(
    f"{CATALOG_URL}/v1/namespaces/verkoop/tables",
    headers=headers,
).json()
print("Tabellen in 'verkoop':", [t["name"] for t in tabellen["identifiers"]])

# Stap 4: Tabel metadata ophalen
meta = requests.get(
    f"{CATALOG_URL}/v1/namespaces/verkoop/tables/orders",
    headers=headers,
).json()

schema    = meta["metadata"]["current-schema-id"]
snapshots = len(meta["metadata"].get("snapshots", []))
locatie   = meta["metadata-location"]

print(f"Schema ID  : {schema}")
print(f"Snapshots  : {snapshots}")
print(f"Metadata   : {locatie}")

3.3 DuckDB als lichtgewicht query engine op dezelfde catalogus

Een van de grootste voordelen van de REST Catalog is dat elke compatibele engine direct toegang heeft. Hier laten we zien hoe een data analist met DuckDB de prod.verkoop.orders tabel kan bevragen zonder Spark of speciale infrastractuur.

-- DuckDB (v1.1+) ondersteunt de Iceberg REST Catalog natively
-- via de iceberg extensie

INSTALL iceberg;
LOAD iceberg;

-- REST Catalog configureren
CREATE SECRET catalog_secret (
    TYPE        ICEBERG,
    ENDPOINT    'https://catalog.mijnbedrijf.nl/iceberg',
    CLIENT_ID   'duckdb-analyst',
    SECRET      'analyst_secret',
    TOKEN_ENDPOINT 'https://catalog.mijnbedrijf.nl/oauth/tokens'
);

-- Attach de catalogus
ATTACH '' AS prod (
    TYPE    ICEBERG,
    SECRET  catalog_secret,
    CATALOG 'prod'
);

-- Gewoon SQL draaien op Iceberg tabellen
SELECT
    date_trunc('month', bestel_datum) AS maand,
    valuta,
    COUNT(*)                          AS aantal_orders,
    SUM(bedrag)                       AS totaal_bedrag
FROM prod.verkoop.orders
WHERE status = 'VOLTOOID'
  AND bestel_datum >= CURRENT_DATE - INTERVAL 6 MONTH
GROUP BY 1, 2
ORDER BY 1 DESC, 4 DESC;

Vergelijking: REST Catalog implementaties in 2026

De keuze van de catalogus-server is strategisch. Hieronder een eerlijke vergelijking van de drie meest gebruikte opties in de Nederlandse markt.

Best Practices & Production Tips

Tip 1: Namespace Strategie voor Data Mesh

In een data mesh architectuur is de namespace-hiërarchie de basis van je governance model. Gebruik een drielagen aanpak:

-- Aanbevolen namespace structuur
-- Laag 1: Domein
-- Laag 2: Zone (bronze/silver/gold of raw/curated/serving)
-- Laag 3: Dataset naam

-- Voorbeeld namespaces
inkoop.bronze.leverancier_orders
inkoop.silver.leverancier_orders_cleaned
inkoop.gold.leverancier_kpi_dashboard

logistiek.bronze.zendingen_raw
logistiek.silver.zendingen_verrijkt
logistiek.gold.levertijd_analyse

-- PRINCIPAL_ROLE per domein + zone
-- inkoop_bronze_reader  → alleen lezen op inkoop.bronze.*
-- inkoop_silver_writer  → schrijven op inkoop.silver.*
-- data_platform_admin   → alles

Tip 2: Automatiseer table properties voor compliance

-- Standaard tabel-template voor AVG-compliance
-- Gebruik een dbt macro of Terraform provider om dit consistent toe te passen

CREATE TABLE prod.marketing.klant_segmenten (
    klant_id      BIGINT        COMMENT 'Gepseudonimiseerd klant ID',
    segment       STRING        COMMENT 'Marketing segment label',
    score         DOUBLE        COMMENT 'Propensity score 0-1',
    berekend_op   TIMESTAMP     COMMENT 'Berekeningsmoment'
)
USING iceberg
TBLPROPERTIES (
    -- Data governance
    'comment'                    = 'Klant segmentatie voor marketing campagnes',
    'data_owner'                 = 'marketing-domein@mijnbedrijf.nl',
    'data_classification'        = 'CONFIDENTIAL',
    'gdpr_basis'                 = 'gerechtvaardigd_belang',
    'gdpr_retention_days'        = '365',
    -- Write optimalisaties
    'write.target-file-size-bytes' = '134217728',  -- 128 MB
    'write.parquet.compression-codec' = 'zstd',
    -- Maintenance
    'write.metadata.delete-after-commit.enabled' = 'true',
    'write.metadata.previous-versions-max'       = '5'
);

Tip 3: Health monitoring van je catalogus

import requests
import time
from prometheus_client import Gauge, start_http_server

# Prometheus metrics voor catalog monitoring
catalog_tables_total = Gauge(
    'iceberg_catalog_tables_total',
    'Totaal aantal tabellen per namespace',
    ['namespace']
)
catalog_response_ms = Gauge(
    'iceberg_catalog_response_ms',
    'REST Catalog response tijd in milliseconden'
)

def poll_catalog_health(catalog_url: str, headers: dict):
    """Poll de REST Catalog en exporteer metrics naar Prometheus."""
    start = time.time()

    namespaces_resp = requests.get(
        f"{catalog_url}/v1/namespaces",
        headers=headers,
        timeout=10,
    )
    elapsed_ms = (time.time() - start) * 1000
    catalog_response_ms.set(elapsed_ms)

    for ns in namespaces_resp.json().get("namespaces", []):
        ns_name = ".".join(ns)
        tables_resp = requests.get(
            f"{catalog_url}/v1/namespaces/{ns_name}/tables",
            headers=headers,
            timeout=10,
        )
        count = len(tables_resp.json().get("identifiers", []))
        catalog_tables_total.labels(namespace=ns_name).set(count)

if __name__ == "__main__":
    start_http_server(8000)  # Prometheus scrape endpoint
    token   = get_access_token()          # zie eerdere snippet
    headers = {"Authorization": f"Bearer {token}"}

    while True:
        poll_catalog_health("https://catalog.mijnbedrijf.nl/iceberg", headers)
        time.sleep(60)

Conclusie: Wanneer wel (en niet) overstappen?

De Iceberg REST Catalog is geen silver bullet, maar in 2026 is het de dichtstbijzijnde standaard die de datawereld heeft voor interoperabele, engine-onafhankelijke metadata. De spec is stabiel, de implementaties zijn productie-rijp en de adoptie door zowel cloud vendors als open-source communities geeft vertrouwen dat dit geen tijdelijke trend is.