Een native Fabric analytics stack met dbt, Airflow, Lakehouse en Direct Lake

De interessante verandering is niet dat dbt verdween. Het is dat Fabric nu een Lakehouse dbt Job kan draaien, die met managed Apache Airflow kan orchestreren en de Delta-output via Direct Lake kan aanbieden zonder externe dbt runner of Warehouse-target.

Jaffle Shop CSV seeds
        |
        v
Fabric dbt Job (dbt-fabricspark)
        |
        v
Fabric Lakehouse / Delta tables
  Raw -> Staging -> Gold
        |
        +----------------------+
        |                      |
        v                      v
Fabric Apache Airflow     Direct Lake semantic model
orchestration             and Power BI

Previewgrens: Lakehouse-support in Fabric dbt Jobs is preview. De geteste runtime gebruikt dbt-fabricspark 1.12.2, dbt Core 1.11 en Python 3.12. dbt-fabric 1.10.0 richt zich op Fabric Warehouse en is niet uitwisselbaar.

Wat de walkthrough maakt

Het Gold-contract:

• dim_customers;
• dim_dates; en
• fct_orders.

Waarom de adapterkeuze belangrijk is

Een Lakehouse SQL analytics endpoint is read-only. De Lakehouse-route gebruikt dbt-fabricspark, Spark SQL en Delta-tabellen die via Fabric Livy worden geschreven.

Er is geen pip install-stap in de managed job. Selecteer het Lakehouse-profile en houd de adapterspecifieke projectsyntax correct.

Vereisten

Je hebt nodig:

1. een Fabric-capacity of trial die de workloads ondersteunt;
2. Contributor- of hogere workspacetoegang;
3. dbt Jobs (preview) ingeschakeld;
4. capacitysupport voor Apache Airflow Jobs;
5. permission om Lakehouse, dbt Job, Airflow Job en semantic model te maken;
6. een identity-backed Fabric connection voor Airflow.

Free- en PPU-workspaces ondersteunen geen Airflow Jobs.

1. Maak de workspace en het Lakehouse

Maak een workspace met capacity met de naam DBTAirflow, en daarna:

jaffle_shop_lakehouse

Gebruik logische schema’s:

raw
staging
gold

Als de tenant alleen het default schema toont, bewaar je die logische grenzen in dbt-folders en tags en materialiseer je ze in het ondersteunde target schema.

2. Maak de dbt Job

In DBTAirflow:

1. maak een dbt Job met de naam jaffle_shop_native_dbt;
2. importeer of maak het project;
3. kies Fabric Lakehouse;
4. selecteer jaffle_shop_lakehouse;
5. selecteer het ondersteunde target schema;
6. schakel seed data in; en
7. gebruik runtime V1.0.

Projectconfiguratie:

name: jaffle_shop
version: 1.0.0
config-version: 2

profile: jaffle_shop

model-paths: ["models"]
seed-paths: ["seeds"]
macro-paths: ["macros"]

models:
  jaffle_shop:
    staging:
      +schema: staging
      +materialized: view
    marts:
      +schema: gold
      +materialized: table

seeds:
  jaffle_shop:
    +schema: raw

Fabric beheert het profile. Commit geen profiles.yml met een password.

3. Seed en modelleer de data

Plaats onder seeds:

raw_customers.csv
raw_orders.csv
raw_payments.csv

Draai dbt seed of schakel seeds in bij dbt build.

Payment amounts zijn cents, dus het stagingmodel converteert ze:

select
    cast(id as bigint) as payment_id,
    cast(order_id as bigint) as order_id,
    cast(payment_method as string) as payment_method,
    cast(amount as decimal(18,2)) / 100 as amount
from {{ ref('raw_payments') }}

De dunne stagingmodellen:

stg_customers
stg_orders
stg_payments

Ze standaardiseren keys, dates, statuses en payment amounts. Aggregatie hoort in Gold.

De dependency graph van het Gold-model:

raw_customers -> stg_customers -> dim_customers
raw_orders    -> stg_orders    -> dim_customers
                              -> dim_dates
                              -> fct_orders
raw_payments  -> stg_payments  -> fct_orders

De customer dimension gebruikt het geteste patroon:

with customer_orders as (
    select
        customer_id,
        min(order_date) as first_order_date,
        max(order_date) as most_recent_order_date,
        count(*) as number_of_orders
    from {{ ref('stg_orders') }}
    group by customer_id
),
customer_payments as (
    select
        o.customer_id,
        sum(p.amount) as lifetime_value
    from {{ ref('stg_orders') }} o
    left join {{ ref('stg_payments') }} p
        on o.order_id = p.order_id
    group by o.customer_id
)

select
    c.customer_id,
    c.first_name,
    c.last_name,
    co.first_order_date,
    co.most_recent_order_date,
    coalesce(co.number_of_orders, 0) as number_of_orders,
    coalesce(cp.lifetime_value, cast(0 as decimal(18,2))) as lifetime_value
from {{ ref('stg_customers') }} c
left join customer_orders co
    on c.customer_id = co.customer_id
left join customer_payments cp
    on c.customer_id = cp.customer_id

De date dimension bevat unieke order dates:

select distinct
    order_date as date_day,
    year(order_date) as calendar_year,
    month(order_date) as month_number,
    day(order_date) as day_of_month
from {{ ref('stg_orders') }}

4. Maak kwaliteit onderdeel van de run

Test unique en non-null keys plus customer- en daterelationships. Gebruik:

dbt build

Voor dit project:

5. Orchestreer met Airflow

Voeg Airflow toe wanneer dbt één stap in een bredere workflow is: ingestion, semantic-modelprocessing, notifications, SLA’s of cross-item dependencies. Als dbt de hele workflow is, is de eigen scheduler eenvoudiger.

Maak:

jaffle_shop_airflow_orchestrator

Schakel triggerers in en koppel de Fabric connection met workspace identity. De operator verwacht de connection GUID, niet de display name:

from datetime import datetime, timedelta

from airflow import DAG
from airflow.providers.microsoft.fabric.operators.run_item import (
    MSFabricRunJobOperator,
)

FABRIC_CONN_ID = "<Fabric connection GUID>"
WORKSPACE_ID = "<DBTAirflow workspace ID>"
DBT_JOB_ID = "<jaffle_shop_native_dbt item ID>"

with DAG(
    dag_id="orchestrate_jaffle_shop_dbt",
    schedule=None,
    start_date=datetime(2026, 1, 1),
    catchup=False,
    default_args={
        "owner": "fabric",
        "retries": 1,
        "retry_delay": timedelta(minutes=5),
    },
) as dag:
    run_dbt_build = MSFabricRunJobOperator(
        task_id="run_jaffle_shop_dbt",
        fabric_conn_id=FABRIC_CONN_ID,
        workspace_id=WORKSPACE_ID,
        item_id=DBT_JOB_ID,
        job_type="DataBuildToolJob",
        wait_for_termination=True,
        deferrable=True,
    )

job_type="Execute" is hier fout. Execute is de naam van de control-planeoperation, niet de waarde voor de Airflow-provider. Gebruik DataBuildToolJob of DBT.

6. Maak het Direct Lake-model

Maak jaffle_shop_direct_lake vanuit het Lakehouse en selecteer alleen:

• dim_customers;
• dim_dates; en
• fct_orders.

Relationships:

Measures:

Total Orders =
DISTINCTCOUNT(fct_orders[order_id])

Total Revenue =
SUM(fct_orders[amount])

Average Order Value =
DIVIDE([Total Revenue], [Total Orders])

Direct Lake leest Delta-data uit OneLake. Schemawijzigingen vereisen nog steeds modelmanagement.

7. Valideer ieder contract

Lakehouse-controles:

select count(*) as order_count
from gold.fct_orders;

select
    sum(amount) as total_revenue,
    min(order_date) as first_order_date,
    max(order_date) as last_order_date
from gold.fct_orders;

select count(*) as orphan_customers
from gold.fct_orders f
left join gold.dim_customers c
    on f.customer_id = c.customer_id
where c.customer_id is null;

DAX smoke test:

EVALUATE
ROW(
    "Orders", [Total Orders],
    "Revenue", [Total Revenue],
    "Average Order Value", [Average Order Value],
    "Customers", COUNTROWS('dim_customers')
)

De gevalideerde deployment gaf:

Het Airflow-item, de workspace-identity connection, het Direct Lake-model, enhanced refresh, framing en de DAX smoke test zijn ook gevalideerd. Er staat geen secret in DAG- of projectbestanden.

Beperkingen

1. Lakehouse-support voor dbt is preview.
2. De managed runtime is curated en heeft geen build cache.
3. Spark SQL is geen T-SQL.
4. Adaptersupport voor packages, hooks, snapshots en incremental models vereist eigen validatie.
5. Het SQL analytics endpoint is read-only.
6. Airflow heeft capacity-, networking- en authenticationbeperkingen.
7. Direct Lake behandelt Gold-schema’s als contracten.

Eindarchitectuur

• OneLake en Lakehouse slaan Delta op.
• Fabric dbt Job beheert modellen, tests, dependencies en lineage.
• dbt-fabricspark voert Spark SQL uit en materialiseert Delta.
• Fabric Apache Airflow beheert cross-item orchestration.
• Direct Lake beheert business relationships en DAX measures.

Gebruik de volledige stack wanneer iedere laag waarde toevoegt. Als dbt de enige stap is, sla Airflow over. Is de workload SQL-first, kies dan een Warehouse. Native betekent niet dat iedere workload in hetzelfde pad hoort.

Referenties

• dbt job in Microsoft Fabric
• Veelvoorkomende dbt job-patronen in Microsoft Fabric
• Een dbt job configureren
• Een Fabric-item draaien met Apache Airflow DAGs
• Direct Lake semantic models ontwikkelen
• Lakehouse-tutorial: een semantic model maken
• Originele Microsoft Fabric-guide van dbt