ms-ai-architect/skills/ms-ai-engineering/references/data-engineering/dataverse-ai-integration.md

# Dataverse and AI Integration

**Last updated:** 2026-02
**Status:** GA
**Category:** Data Engineering for AI
**Type:** reference
**Source:** https://learn.microsoft.com/fabric/data-factory/connector-dataverse-overview

---

## Innhold

- [Introduksjon](#introduksjon)
- [Dataverse Connectors in Data Factory](#dataverse-connectors-in-data-factory)
- [Entity Relationship Mapping to Delta Tables](#entity-relationship-mapping-to-delta-tables)
- [Real-Time Dataverse Data Sync](#real-time-dataverse-data-sync)
- [Power Platform Data Integration](#power-platform-data-integration)
- [RLS Propagation from Dataverse to Fabric](#rls-propagation-from-dataverse-to-fabric)
- [Referanser](#referanser)
- [For arkitekten](#for-arkitekten)

## Introduksjon

Microsoft Dataverse er den sentrale dataplattformen for Power Platform og Dynamics 365, og inneholder forretningskritisk data fra CRM, ERP, og egendefinerte applikasjoner. Integrering av Dataverse-data med AI-losninger via Microsoft Fabric og Data Factory gjor det mulig a utnytte forretningsdata for prediktiv analyse, maskinlaring og intelligent automatisering uten komplekse ETL-pipelines.

For norsk offentlig sektor er Dataverse ofte kjernen i saksbehandlingssystemer, innbyggertjenester og Power Apps-baserte fagsystemer. Evnen til a koble disse dataene til AI-modeller -- for eksempel for prediktiv vedlikeholdsplanlegging, chatbot-trening, eller automatisert dokumentklassifisering -- representerer en viktig mulighetsdimensjon som krever god arkitekturforstaaelse.

Denne referansen dekker alle integrasjonsmonstre mellom Dataverse og AI-okosystemet, fra den direkte "Link to Fabric"-funksjonen til Data Factory-konnektorer, sanntidssynkronisering, og sikkerhetspropagering.

---

## Dataverse Connectors in Data Factory

### Dataverse Connector i Fabric Data Factory

Fabric Data Factory tilbyr en dedikert Dataverse-konnektor med flere integrasjonsmonstre:

| Kapabilitet | Gateway | Autentisering |
|---|---|---|
| **Dataflow Gen2** (kilde) | Ingen, On-prem, VNet | Org-konto, Service Principal, Workspace Identity |
| **Pipeline Copy Activity** (kilde/dest) | Ingen, On-prem, VNet | Org-konto, Service Principal, Workspace Identity |
| **Copy Job** (kilde/dest) | Ingen, On-prem, VNet | Org-konto, Service Principal, Workspace Identity |

### Copy Job modus

| Modus | Beskrivelse | Bruksomraade |
|---|---|---|
| **Full load** | Komplett kopi av alle rader | Forste gangs lasting |
| **Append** | Legg til nye rader | Inkrementell lasting |
| **Upsert** | Sett inn eller oppdater basert pa nokkel | Synkronisering |

### Pipeline-eksempel: Dataverse til Lakehouse

```json
{
    "name": "DataverseToLakehouse",
    "properties": {
        "activities": [
            {
                "name": "CopyDataverseAccounts",
                "type": "Copy",
                "inputs": [{
                    "type": "DataverseEntity",
                    "entity": "account",
                    "filter": "modifiedon ge 2024-01-01"
                }],
                "outputs": [{
                    "type": "LakehouseTable",
                    "table": "bronze.crm_accounts"
                }],
                "typeProperties": {
                    "source": {
                        "type": "DataverseSource",
                        "query": "?$select=name,revenue,industry&$filter=statecode eq 0"
                    },
                    "sink": {
                        "type": "LakehouseSink",
                        "writeBehavior": "Upsert",
                        "upsertKeyColumns": ["accountid"]
                    }
                }
            }
        ]
    }
}
```

---

## Entity Relationship Mapping to Delta Tables

### Dataverse-tabeller til Medallion Architecture

Dataverse bruker en relasjonell modell med entiteter, relasjoner og lookups. Ved overforig til Lakehouse bor dette mappes til Delta-tabeller i en medallion-arkitektur:

```
Dataverse                          Lakehouse
┌──────────────────┐              ┌──────────────────────┐
│ account          │  ────────>   │ bronze.crm_accounts  │
│ contact          │  ────────>   │ bronze.crm_contacts  │
│ opportunity      │  ────────>   │ bronze.crm_opps      │
│ incident (case)  │  ────────>   │ bronze.crm_cases     │
└──────────────────┘              └──────────┬───────────┘
                                             │
                                   Silver Layer (denormalisert)
                                             │
                                  ┌──────────▼───────────┐
                                  │ silver.customer_360   │
                                  │ (account + contact +  │
                                  │  opportunity joined)  │
                                  └──────────┬───────────┘
                                             │
                                   Gold Layer (AI-klar)
                                             │
                                  ┌──────────▼───────────┐
                                  │ gold.churn_features   │
                                  │ gold.revenue_predict  │
                                  └──────────────────────┘
```

### Handtering av Dataverse-spesifikke datatyper

| Dataverse-type | Delta Lake-mapping | Merknad |
|---|---|---|
| **Lookup** | String (GUID) | Maa joines for visningsnavn |
| **OptionSet** | Integer + String label | Lagre baade verdi og label |
| **Money** | Decimal(38,4) | Inkluder valutareferanse |
| **DateTime** | Timestamp | Vurder tidssone (UTC vs lokal) |
| **Customer** | String (polymorf) | Kan peke til account eller contact |
| **PartyList** | Array of GUIDs | Flatten til separate rader |

### PySpark for entity-mapping

```python
from pyspark.sql.functions import col, when, lit

# Les Dataverse-data fra bronze
accounts = spark.read.format("delta").table("bronze.crm_accounts")
contacts = spark.read.format("delta").table("bronze.crm_contacts")
opportunities = spark.read.format("delta").table("bronze.crm_opps")

# Denormalisering: Customer 360 view
customer_360 = (
    accounts
    .join(
        contacts,
        accounts["accountid"] == contacts["parentcustomerid"],
        "left"
    )
    .join(
        opportunities
        .groupBy("parentaccountid")
        .agg(
            F.sum("estimatedvalue").alias("total_pipeline"),
            F.count("*").alias("opp_count"),
            F.max("estimatedclosedate").alias("latest_opp_date")
        ),
        accounts["accountid"] == col("parentaccountid"),
        "left"
    )
    .select(
        accounts["accountid"],
        accounts["name"].alias("company_name"),
        accounts["revenue"].alias("annual_revenue"),
        accounts["industrycode"],
        col("total_pipeline"),
        col("opp_count"),
        col("latest_opp_date")
    )
)

# Skriv til silver layer
customer_360.write.format("delta").mode("overwrite").saveAsTable("silver.customer_360")
```

---

## Real-Time Dataverse Data Sync

### Link to Microsoft Fabric (Direct Link)

Den mest effektive metoden for Dataverse-Fabric-integrasjon er den innebygde "Link to Microsoft Fabric"-funksjonen:

```
Power Apps ──> "Analyze > Link to Microsoft Fabric"
                     │
                     ▼
              ┌──────────────────────────────┐
              │  Fabric Workspace            │
              │  ├── Lakehouse               │
              │  │   ├── Shortcut: accounts  │
              │  │   ├── Shortcut: contacts  │
              │  │   └── Shortcut: cases     │
              │  ├── SQL Analytics Endpoint   │
              │  └── Default Semantic Model   │
              └──────────────────────────────┘
```

**Egenskaper:**

| Egenskap | Verdi |
|---|---|
| **Kopieringsmetode** | OneLake shortcuts (ingen dataduplisering) |
| **Format** | Delta Parquet |
| **Synkroniserings-latens** | Opptil 60 minutter |
| **Tabellvalg** | Alle tabeller med Track Changes, eller manuelt valg |
| **Autentisering** | Org-konto, Service Principal, Workspace Identity |
| **Read/Write** | Kun lesetilgang (shortcuts er read-only) |

### Dataverse Shortcuts via Fabric

Alternativt kan du opprette shortcuts direkte fra Fabric:

1. Apen Lakehouse i Fabric
2. Velg "New Table Shortcut" > "Dataverse"
3. Oppgi environment-URL
4. Bla gjennom og velg tabeller

```python
# Etter at shortcut er opprettet, les direkte i Notebook
df = spark.read.format("delta").table("accounts")
display(df.limit(10))
```

### Synkroniseringsmekanisme

Fabric Spark compute handterer synkronisering:
- **Initial load**: Full kopi av valgte tabeller
- **Inkrementell oppdatering**: Poller hvert 2. minutt for endringer
- **Endringssporing**: Basert pa Dataverse Track Changes-funksjonen
- **Sletting**: Fjerner rader nar kildedata slettes

---

## Power Platform Data Integration

### Arkitektur for AI-drevet Power Platform

```
┌──────────────────────────────────────────────────────────────────┐
│                    Power Platform                                 │
│  ┌──────────┐  ┌──────────────┐  ┌────────────────────────────┐ │
│  │ Power    │  │ Power        │  │ Copilot Studio             │ │
│  │ Apps     │  │ Automate     │  │ (AI chatbot)               │ │
│  └────┬─────┘  └──────┬───────┘  └──────────┬─────────────────┘ │
│       │               │                      │                    │
│       └───────────────┼──────────────────────┘                    │
│                       │                                           │
│              ┌────────▼────────┐                                  │
│              │   Dataverse     │                                  │
│              └────────┬────────┘                                  │
└───────────────────────┼──────────────────────────────────────────┘
                        │  Link to Fabric
               ┌────────▼────────────────────────────┐
               │        Microsoft Fabric              │
               │  ┌──────────┐  ┌──────────────────┐ │
               │  │ Lakehouse│  │ ML Models         │ │
               │  │ (Delta)  │  │ (Spark/AzureML)   │ │
               │  └──────────┘  └──────────────────┘ │
               │                       │              │
               │              ┌────────▼────────┐    │
               │              │ Predictions     │    │
               │              │ (write back)    │    │
               │              └────────┬────────┘    │
               └───────────────────────┼─────────────┘
                                       │
                         Virtual Tables / Dataverse API
                                       │
               ┌───────────────────────▼─────────────┐
               │  Power Apps: vis AI-prediksjoner     │
               │  Power Automate: trigger pa insights │
               └─────────────────────────────────────┘
```

### AI Builder-integrasjon

AI Builder-modeller lagrer resultater direkte i Dataverse:

| AI Builder-modell | Dataverse-lagring | Fabric-bruk |
|---|---|---|
| Prediction | Prediction-kolonne pa entitet | Feature for ML |
| Document Processing | Extracted fields | Treningsdata |
| Object Detection | Detection results | Analyse |
| Text Classification | Category labels | NLP-pipeline |

### Skrive AI-resultater tilbake til Dataverse

```python
# Via Dataverse Web API fra Fabric Notebook
import requests

def write_prediction_to_dataverse(env_url, access_token, entity, record_id, prediction):
    """Skriv AI-prediksjon tilbake til Dataverse-entitet."""
    url = f"{env_url}/api/data/v9.2/{entity}({record_id})"
    headers = {
        "Authorization": f"Bearer {access_token}",
        "Content-Type": "application/json",
        "OData-MaxVersion": "4.0"
    }
    payload = {
        "cr_churn_prediction": prediction["score"],
        "cr_prediction_date": prediction["timestamp"],
        "cr_risk_category": prediction["category"]
    }
    response = requests.patch(url, json=payload, headers=headers)
    return response.status_code
```

---

## RLS Propagation from Dataverse to Fabric

### Sikkerhetsmodell

Dataverse har et avansert sikkerhetssystem med Business Units, Security Roles, og Row-Level Security (RLS). Ved integrasjon med Fabric maa dette haandteres eksplisitt.

| Dataverse-sikkerhet | Fabric-ekvivalent | Automatisk propagering |
|---|---|---|
| **Business Units** | Workspace-tilgang | Nei -- manuell mapping |
| **Security Roles** | OneLake Security | Nei -- manuell mapping |
| **Row-Level Security** | RLS i SQL Endpoint / Semantic Model | Delvis |
| **Field-Level Security** | Column-level security | Nei |
| **Team-based access** | Workspace roles | Nei |

### Implementere RLS i Fabric

```sql
-- SQL Analytics Endpoint: Definer RLS
CREATE FUNCTION dbo.fn_security_predicate(@business_unit_id AS NVARCHAR(50))
RETURNS TABLE
WITH SCHEMABINDING
AS
RETURN SELECT 1 AS result
WHERE @business_unit_id = SESSION_CONTEXT(N'business_unit_id');

-- Opprett sikkerhetspolicy
CREATE SECURITY POLICY crm_security
ADD FILTER PREDICATE dbo.fn_security_predicate(business_unit_id)
ON silver.customer_360
WITH (STATE = ON);
```

### Power BI Semantic Model RLS

```dax
// DAX-filter for RLS i Power BI
[BusinessUnitId] = USERPRINCIPALNAME()
// Eller via lookup-tabell:
CONTAINS(
    FILTER(SecurityMapping, SecurityMapping[UserEmail] = USERPRINCIPALNAME()),
    SecurityMapping[BusinessUnitId], [BusinessUnitId]
)
```

### Anbefalinger for sikkerhetspropagering

1. **Dokumenter mapping**: Opprett eksplisitt mapping mellom Dataverse Security Roles og Fabric Workspace Roles
2. **Automatiser med Power Automate**: Synkroniser rolletilordninger ved endringer
3. **Minimer direkte datatilgang**: Bruk Semantic Models med RLS som primaertilgang
4. **Auditing**: Aktiver Microsoft Purview for sporbarhet

---

## Referanser

- [Link your Dataverse environment to Microsoft Fabric](https://learn.microsoft.com/en-us/power-apps/maker/data-platform/azure-synapse-link-view-in-fabric) -- Offisiell guide for Dataverse-Fabric-kobling
- [Dataverse connector overview (Fabric Data Factory)](https://learn.microsoft.com/en-us/fabric/data-factory/connector-dataverse-overview) -- Konnektorkapabiliteter
- [Create a Dataverse shortcut](https://learn.microsoft.com/en-us/fabric/onelake/create-dataverse-shortcut) -- Shortcut-oppretting fra Fabric
- [Fabric Link for Dataverse FAQ](https://learn.microsoft.com/en-us/power-apps/maker/data-platform/fabric-link-faq) -- Vanlige sporsmal og begrensninger
- [Link to Microsoft Fabric](https://learn.microsoft.com/en-us/power-apps/maker/data-platform/fabric-link-to-data-platform) -- Administrasjon av Fabric-kobling
- [Predictive data analysis using Dataverse, Fabric, and Azure AI services](https://learn.microsoft.com/en-us/power-platform/architecture/reference-architectures/ai-predictive-data-analysis) -- Referansearkitektur
- [Automation-centric data analytics with Fabric](https://learn.microsoft.com/en-us/power-automate/automation-analytics-with-fabric-introduction) -- Power Automate + Fabric

---

## For arkitekten

- **Bruk denne referansen** naar brukeren har Dynamics 365, Power Apps, eller Power Platform-data som skal brukes i AI-losninger, eller naar de trenger a skrive AI-prediksjoner tilbake til forretningsapplikasjoner.
- Anbefal **Link to Fabric** som forstevalg for enkel integrasjon -- ingen ETL, ingen ekstra infrastruktur, data forblir i Dataverse med shortcuts.
- Vaar oppmerksom pa **latens**: Link to Fabric har opptil 60 minutters forsinkelse. For sanntidsbehov, bruk Dataverse Web API eller Power Automate-triggers i stedet.
- For **sikkerhet**: Dataverse RLS propageres IKKE automatisk til Fabric. Dette maa alltid adresseres eksplisitt i arkitekturforslaget, spesielt for offentlig sektor med strenge tilgangskrav.
- Anbefal **medallion architecture** for Dataverse-data: Bronze (raa shortcut), Silver (denormalisert Customer 360), Gold (ML-features) for a unnga at AI-modeller trener pa denormaliserte Dataverse-strukturer.