# Zero Trust Architecture Applied to AI Services

**Kategori:** AI Security Engineering
**Sist oppdatert:** 2026-05
**Målgruppe:** Arkitekter som skal sikre AI-tjenester med Zero Trust-prinsipper

## Introduksjon

Zero Trust (ZT) er en sikkerhetsmodell som ikke gir implisitt tillit til noe som helst, uavhengig av hvor forespørselen kommer fra. For AI-tjenester betyr dette kontinuerlig verifisering av hver tilgang, streng segmentering av nettverk, og "assume breach"-mentalitet. Denne guiden viser hvordan du implementerer Zero Trust-arkitektur for Azure AI Services, Azure OpenAI, Copilot Studio og andre Microsoft AI-plattformer.

Zero Trust for AI handler ikke bare om å beskytte modellene – det handler om å sikre hele verdikjeden: identiteter som får tilgang til AI-tjenester, data som flyter gjennom dem, og infrastrukturen som leverer dem. I en verden der AI-tjenester håndterer sensitiv forretningslogikk og personopplysninger, er Zero Trust ikke et valg – det er et krav.

### De tre Zero Trust-prinsippene

1. **Verify explicitly** – Autentiser og autoriser basert på alle tilgjengelige datapunkter (identitet, lokasjon, device health, service/workload, risiko)
2. **Use least-privileged access** – Begrens brukertilgang med Just-In-Time/Just-Enough-Access (JIT/JEA)
3. **Assume breach** – Minimer eksplosjonradiusen ved å segmentere nettverk, verifisere ende-til-ende-kryptering, og bruke analyse for synlighet og trusseldeteksjon

## Kjernekomponenter

### 1. AI Service Network Isolation

**Private endpoints** erstatter offentlig eksponering av AI-tjenester. I stedet for å eksponere Azure OpenAI eller Document Intelligence direkte på Internett, projiseres tjenesten inn i ditt private nettverk via Azure Private Link.

**Hvordan det fungerer:**
- Opprett en Private Endpoint i ditt VNet
- Azure oppretter en bot-spesifikk DNS-record (f.eks. `your-service.privatelink.openai.azure.com`)
- DNS-recorden mapper til en lokal IP i ditt VNet
- All trafikk forblir innenfor Microsofts backbone-nettverk

**Implementering:**

```bash
# Opprett private endpoint for Azure OpenAI
az network private-endpoint create \
  --resource-group myRG \
  --name myOpenAI-PE \
  --vnet-name myVNet \
  --subnet mySubnet \
  --private-connection-resource-id /subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.CognitiveServices/accounts/{name} \
  --group-id account \
  --connection-name myConnection
```

**Network Security Groups (NSG):** Definerer tillatte inbound/outbound-regler for AI-tjenester. Best practice er å deny-all som default, deretter allowlist spesifikke sources.

**Azure Firewall / Application Gateway:** Inspiserer trafikk mot AI-tjenester på Layer 7. Kan blokkere mistenkelige payloads, rate-limit requests, eller logge all aktivitet for audit.

**Konfigurasjon:**
- Aktiver **public network access: Disabled** på AI-ressursen
- Konfigurer NSG-regler: `AllowAzureCognitiveServices`, `DenyAllOutbound`
- Bruk **Network Security Perimeter** for PaaS-tjenester som trenger sikker kommunikasjon

### 2. Managed Identity and RBAC

**Managed Identity** eliminerer behovet for API-nøkler i kode. Tjenesten får automatisk en Microsoft Entra ID-identitet som kan brukes for autentisering.

**To typer:**
- **System-assigned:** Livsløpet er knyttet til ressursen. Slettes automatisk når ressursen slettes.
- **User-assigned:** Standalone-ressurs som kan deles mellom flere ressurser. Anbefalt for produksjon.

**RBAC-roller for AI Services:**

| Rolle | Rolle-ID | Tilgang | Bruksområde |
|-------|----------|---------|-------------|
| `Cognitive Services OpenAI User` | `5e0bd9bd-7b93-4f28-af87-19fc36ad61bd` | Inference API (chat, embeddings) | Applikasjoner som bruker AI-modeller |
| `Cognitive Services OpenAI Contributor` | `a001fd3d-188f-4b5d-821b-7da978bf7442` | Inference + modell-deployment | DevOps/Platform teams |
| `Cognitive Services User` | `a97b65f3-24c7-4388-baec-2e87135dc908` | Data plane access (alle AI Services) | Generell app-tilgang |
| `Cognitive Services Contributor` | `25fbc0a9-bd7c-42a3-aa1a-3b75d497ee68` | Full kontroll (inkl. nøkler) | Admin-oppgaver |

*(Verified MCP 2026-04)*

**Implementering (Python):**

```python
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from openai import AzureOpenAI

# DefaultAzureCredential prøver automatisk:
# 1. Environment variables
# 2. Managed Identity
# 3. Visual Studio Code credentials
# 4. Azure CLI credentials
# 5. Azure PowerShell credentials

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(),
    "https://cognitiveservices.azure.com/.default"
)

client = AzureOpenAI(
    azure_endpoint="https://your-resource.openai.azure.com",
    api_version="2024-02-01",
    azure_ad_token_provider=token_provider
)

# Ingen API-nøkler i koden!
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello!"}]
)
```

**Assign RBAC role via Azure CLI:**

```bash
# Tildel Cognitive Services OpenAI User til en managed identity
az role assignment create \
  --role "5e0bd9bd-7b93-4f28-af87-19fc36ad61bd" \
  --assignee-object-id <managed-identity-object-id> \
  --scope /subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.CognitiveServices/accounts/{ai-service-name}
```

**Viktig begrensning:** Managed Identity-tokens caches i opptil 24 timer. Hvis du endrer gruppetilhørighet eller roller, kan det ta flere timer før endringene trer i kraft. Bruk **App Roles** i stedet for grupper for raskere propagering.

**Nøkkelbasert autentisering frarådes:** Microsoft anbefaler nå eksplisitt å **unngå API-nøkler** for Azure AI Services i produksjon. Bruk alltid `DefaultAzureCredential` / Managed Identity. Azure AI Foundry (Foundry Tools) bruker samme `DefaultAzureCredential`-mønster på tvers av alle AI-tjenester. *(Verified MCP 2026-04)*

### 3. Endpoint Verification for AI

**Problem:** Selv med Managed Identity kan ondsinnet kode sende forespørsler til AI-tjenester hvis den har network-tilgang.

**Løsning:** Kombiner Managed Identity med **Conditional Access** og **Continuous Access Evaluation (CAE)**.

**Conditional Access-policyer:**
- Krev MFA for interactive sign-in (ikke relevant for service-to-service)
- Krev compliant device (via Microsoft Defender for Endpoint)
- Krev spesifikke network locations (IP-ranges)
- Bloker access fra risky sign-ins

**Continuous Access Evaluation (CAE):**
- Revokerer access tokens i nær-realtime hvis:
  - Bruker fjernes fra rolle
  - Device går ut av compliance
  - Risiko detekteres (malware, unusual location)
- Token lifetime med CAE: opptil **28 timer** (vs. standard 1 time) — klienten oppdaterer kun ved kritiske hendelser
- Reduserer reaktionstid på kritiske hendelser fra 1 time til sekunder

**CAE konfigureres via Conditional Access:** Fra 2025 er CAE flyttet til Conditional Access-policyer i stedet for en separat toggle. CAE-session controls er nå et alternativ under "Session controls" i CA-policyen. *(Verified MCP 2026-04)*

**Strict Location Enforcement (Preview):** Videreutvikling av Universal CAE. Aktiveres per CA-policy. Blokkerer tokens som brukes utenfor godkjente nettverkslokasjoner i nær-realtime, i stedet for ved neste token-refresh. Støtter nå også **Azure Government**-skyer. *(Verified MCP 2026-04)*

**Konfigurasjon:**

```bash
# CAE konfigureres i Conditional Access-policyer (ikke lenger en separat toggle)
# Gå til: Entra admin center → Protection → Conditional Access
# Opprett eller rediger policy → Session controls → Customize continuous access evaluation
# Velg "Disabled" (off), "Basic" (default: kritiske hendelser), eller "Strict" (location enforcement)
```

**Global Secure Access:** For end-user-scenarioer (ikke service-to-service) kan du bruke Microsoft Entra Private Access som ZTNA-løsning. Dette erstatter tradisjonelle VPN-er med app-spesifikke, identitetsdrevne tilkoblinger.

### 4. Audit Logging for AI

**Azure Monitor + Log Analytics:** Samler inn diagnostikklogger fra AI-tjenester. Inkluderer:
- Request ID, timestamp, caller identity
- Prompt/completion (hvis aktivert – vær obs på personvern!)
- Token usage, latency, HTTP status

**Aktivering:**

```bash
# Opprett Log Analytics workspace
az monitor log-analytics workspace create \
  --resource-group myRG \
  --workspace-name myAILogs

# Aktiver diagnostics på Azure OpenAI
az monitor diagnostic-settings create \
  --resource /subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.CognitiveServices/accounts/{name} \
  --name myDiagnostics \
  --workspace /subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.OperationalInsights/workspaces/myAILogs \
  --logs '[{"category": "Audit", "enabled": true}, {"category": "RequestResponse", "enabled": true}]' \
  --metrics '[{"category": "AllMetrics", "enabled": true}]'
```

**Microsoft Sentinel:** SIEM/SOAR-løsning for AI-trusseldeteksjon.

**Bruksscenarioer:**
- **Prompt injection detection:** Analyser RequestResponse-logger for mistenkelige mønstre (jailbreak-forsøk, "ignore previous instructions")
- **Data exfiltration:** Detekter unormalt store completion-responses eller høy frekvens av forespørsler
- **Anomaly detection:** Bruk ML-baserte deteksjonsregler for å finne avvikende bruksmønstre

**Eksempel Sentinel-regel:**

```kql
// Detekter prompt injection-forsøk
AzureDiagnostics
| where ResourceProvider == "MICROSOFT.COGNITIVESERVICES"
| where Category == "RequestResponse"
| extend Prompt = tostring(parse_json(properties_s).prompt)
| where Prompt contains "ignore previous instructions"
    or Prompt contains "DAN mode"
    or Prompt contains "jailbreak"
| project TimeGenerated, CallerIpAddress, identity_claim_upn_s, Prompt
```

**Microsoft Defender XDR:** Korrelerer AI-logger med identity, endpoint og email-signaler for helhetlig trusselrespons.

**Eksempel:** Defender for Endpoint detekterer malware på en VM → XDR isolerer VM → Sentinel-playbook revokerer AI Service Managed Identity → Blokkerer all AI-tilgang fra kompromittert ressurs.

## Arkitekturmønstre

### Mønster 1: Hub-Spoke med Private Endpoints

**Beskrivelse:** AI-tjenester eksponeres kun via private endpoints i en hub-VNet. Spoke-VNets (per applikasjon) kobler seg til hub via VNet peering.

```
                    ┌─────────────────────┐
                    │    Hub VNet         │
                    │  ┌──────────────┐   │
                    │  │ Azure FW     │   │
                    │  └──────────────┘   │
                    │  ┌──────────────┐   │
                    │  │ Private EP   │   │
                    │  │ (OpenAI)     │   │
                    │  └──────────────┘   │
                    └─────────────────────┘
                         ▲           ▲
                         │           │
                ┌────────┴──┐   ┌────┴────────┐
                │ Spoke 1   │   │  Spoke 2    │
                │ (App A)   │   │  (App B)    │
                └───────────┘   └─────────────┘
```

**Fordeler:**
- Sentralisert sikkerhetskontroll i hub
- Enkel inspeksjon av all AI-trafikk via Azure Firewall
- Spoke-applikasjoner trenger ikke direkte Internet-tilgang

**Konfigurasjon:**
1. Opprett hub-VNet med Azure Firewall
2. Opprett private endpoint for Azure OpenAI i hub
3. Peer spoke-VNets til hub (allow forwarded traffic)
4. Konfigurer UDR (User Defined Routes) for spoke-trafikk via hub

### Mønster 2: App Service med VNet Integration

**Beskrivelse:** App Service integreres direkte i VNet, bruker Managed Identity for AI-tilgang, og har ingen public endpoint.

```
┌─────────────────────────────────────┐
│  VNet                               │
│  ┌────────────────────────────────┐ │
│  │  App Service Subnet            │ │
│  │  (VNet Integration)            │ │
│  │  ┌──────────────────────────┐  │ │
│  │  │ App Service              │  │ │
│  │  │ (System Assigned MI)     │  │ │
│  │  └──────────────────────────┘  │ │
│  └────────────────────────────────┘ │
│                                     │
│  ┌────────────────────────────────┐ │
│  │  Private Endpoint Subnet       │ │
│  │  ┌──────────────────────────┐  │ │
│  │  │ PE: Azure OpenAI         │  │ │
│  │  └──────────────────────────┘  │ │
│  └────────────────────────────────┘ │
└─────────────────────────────────────┘
```

**Fordeler:**
- App Service får automatisk Managed Identity
- Ingen API-nøkler i App Configuration
- Trafikk forblir i VNet (ikke via Internet)

**Konfigurasjon:**

```bash
# Aktiver VNet Integration for App Service
az webapp vnet-integration add \
  --resource-group myRG \
  --name myApp \
  --vnet myVNet \
  --subnet appSubnet

# Aktiver system-assigned managed identity
az webapp identity assign \
  --resource-group myRG \
  --name myApp

# Tildel rolle til App Service MI
az role assignment create \
  --role "Cognitive Services OpenAI User" \
  --assignee <app-service-principal-id> \
  --scope /subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.CognitiveServices/accounts/{openai-name}
```

### Mønster 3: Azure Kubernetes Service (AKS) med Workload Identity

**Beskrivelse:** AKS pods får Managed Identity via Workload Identity (erstatter AAD Pod Identity). Pods kommuniserer med AI-tjenester via private endpoints uten service keys.

```
┌──────────────────────────────────────────┐
│  AKS Cluster                             │
│  ┌────────────────────────────────────┐  │
│  │  Namespace: ai-app                 │  │
│  │  ┌──────────────────────────────┐  │  │
│  │  │ Pod (with Service Account)   │  │  │
│  │  │ → Workload Identity          │  │  │
│  │  │ → Managed Identity (federated)│  │  │
│  │  └──────────────────────────────┘  │  │
│  └────────────────────────────────────┘  │
│                                          │
│  Connected to VNet with Private Endpoint │
└──────────────────────────────────────────┘
```

**Fordeler:**
- Granular identity per pod/service account
- Native Kubernetes RBAC + Azure RBAC
- Ingen secrets i container images

**Konfigurasjon:**

```bash
# Aktiver Workload Identity på AKS
az aks update \
  --resource-group myRG \
  --name myCluster \
  --enable-workload-identity \
  --enable-oidc-issuer

# Opprett user-assigned managed identity
az identity create \
  --resource-group myRG \
  --name myAIPodIdentity

# Federer Kubernetes service account med managed identity
az identity federated-credential create \
  --name myFedCred \
  --identity-name myAIPodIdentity \
  --resource-group myRG \
  --issuer $(az aks show -n myCluster -g myRG --query "oidcIssuerProfile.issuerUrl" -o tsv) \
  --subject system:serviceaccount:ai-app:default

# Tildel RBAC-rolle til identity
az role assignment create \
  --role "Cognitive Services OpenAI User" \
  --assignee <identity-client-id> \
  --scope /subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.CognitiveServices/accounts/{openai-name}
```

**Kubernetes manifest:**

```yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: default
  namespace: ai-app
  annotations:
    azure.workload.identity/client-id: <managed-identity-client-id>
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ai-app
  namespace: ai-app
spec:
  template:
    metadata:
      labels:
        azure.workload.identity/use: "true"
    spec:
      serviceAccountName: default
      containers:
      - name: app
        image: myapp:latest
        env:
        - name: AZURE_CLIENT_ID
          value: <managed-identity-client-id>
```

### Mønster 4: Defender for Cloud Apps + Private Access (for End-User AI)

**Beskrivelse:** For AI Copilots som brukes av sluttbrukere (f.eks. M365 Copilot, custom copilots via Copilot Studio), kombiner Microsoft Entra Private Access (ZTNA) med Defender for Cloud Apps (CASB).

```
┌──────────────────────────────────────────────┐
│  End User (Managed Device)                   │
└────────────┬─────────────────────────────────┘
             │
             ▼
┌─────────────────────────────────────────────┐
│  Microsoft Entra Private Access (ZTNA)      │
│  • Conditional Access (MFA, device health)  │
│  • Continuous Access Evaluation             │
└────────────┬────────────────────────────────┘
             │
             ▼
┌─────────────────────────────────────────────┐
│  Defender for Cloud Apps (CASB)             │
│  • Session control (block download/upload)  │
│  • DLP (data loss prevention)               │
│  • Threat detection (anomalous prompts)     │
└────────────┬────────────────────────────────┘
             │
             ▼
┌─────────────────────────────────────────────┐
│  AI Service (Copilot Studio, Azure OpenAI) │
│  • Private Endpoint                         │
│  • Managed Identity                         │
└─────────────────────────────────────────────┘
```

**Konfigurasjon:**

1. **Conditional Access:**
   - Require MFA for Copilot Studio app
   - Require compliant device (Intune)
   - Require approved location
   - Enable session control: "Use Conditional Access App Control"

2. **Defender for Cloud Apps:**
   - Opprett session policy for Copilot Studio
   - Block download of sensitive content (DLP labels)
   - Monitor for prompt injection patterns
   - Log all user interactions for audit

## Beslutningsveiledning

### Når bruke System-Assigned vs User-Assigned Managed Identity?

| Kriterium | System-Assigned | User-Assigned |
|-----------|-----------------|---------------|
| **Livsløp** | Knyttet til ressurs | Uavhengig av ressurs |
| **Deling** | Nei | Ja (flere ressurser kan dele) |
| **Bruksområde** | Enkle 1:1-scenarioer | Komplekse multi-service-scenarioer |
| **Anbefaling** | Dev/test | Produksjon |

**Eksempel:** Hvis du har 10 App Services som alle trenger samme tilgang til Azure OpenAI, bruk én User-Assigned Identity i stedet for 10 System-Assigned. Dette forenkler RBAC-administrasjon.

### Private Endpoint vs Service Endpoints?

| Aspekt | Private Endpoint | Service Endpoint |
|--------|------------------|------------------|
| **Sikkerhet** | ✅ Høy (privat IP i VNet) | ⚠️ Medium (public IP, men restricted) |
| **Cost** | 💰 Dyrere (per endpoint) | 💰 Gratis |
| **DNS** | ✅ Automatisk (Private DNS Zone) | ❌ Krever manuell konfigurasjon |
| **Cross-Region** | ✅ Ja | ❌ Nei |
| **Bruksområde** | Produksjon, compliance | Dev/test, kostnadsoptimalisering |

**Anbefaling:** Bruk **Private Endpoint** for produksjon og compliance-scenarioer. Service Endpoints er legacy og bør unngås for nye deployments.

### Når bruke Azure Firewall vs NSG?

| Bruksområde | NSG | Azure Firewall |
|-------------|-----|----------------|
| **Layer 3/4 filtering** | ✅ | ✅ |
| **Layer 7 (HTTPS, SQL)** | ❌ | ✅ |
| **FQDN-based rules** | ❌ | ✅ |
| **Threat intelligence** | ❌ | ✅ |
| **IDPS** | ❌ | ✅ (Premium SKU) |
| **TLS inspection** | ❌ | ✅ (Premium SKU) |
| **Cost** | 💰 Gratis | 💰 Dyrere |

**Anbefaling:** Bruk **NSG** som basis-segmentering. Legg til **Azure Firewall** hvis du trenger:
- FQDN-baserte regler (f.eks. "allow *.openai.azure.com")
- Threat intelligence feed
- TLS inspection (dekrypter HTTPS-trafikk for inspeksjon)

### CAE: Når trer det i kraft?

**Standard token lifetime:**
- Access token: 1 time
- Refresh token: 24 timer (Managed Identity)

**Med CAE:**
- Kritiske hendelser (user disabled, password change): **Sekunder**
- IP location change (Strict mode): **Nær-realtime** (ikke 5-10 min som med Basic)
- Role/group membership change: **Opptil 24 timer** (pga Managed Identity caching)
- Token lifetime i CAE-session: **opptil 28 timer** (klienten håndterer refresh ved behov)

**Workaround:** Hvis du trenger raskere propagering, bruk **App Roles** i stedet for Entra ID Groups. App Roles har kortere cache-lifetime.

**Azure Government:** CAE med Strict Location Enforcement støttes nå også i Azure Government-skyer. *(Verified MCP 2026-04)*

## Integrasjon med Microsoft AI-plattformer

### Azure OpenAI + Zero Trust

```python
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from openai import AzureOpenAI

# Kobler til Azure OpenAI via private endpoint
token_provider = get_bearer_token_provider(
    DefaultAzureCredential(),
    "https://cognitiveservices.azure.com/.default"
)

client = AzureOpenAI(
    azure_endpoint="https://your-resource.privatelink.openai.azure.com",  # Private endpoint FQDN
    api_version="2024-02-01",
    azure_ad_token_provider=token_provider
)
```

**Sjekkliste:**
- ✅ Private endpoint opprettet
- ✅ Public network access: Disabled
- ✅ Managed Identity assigned med `Cognitive Services OpenAI User` rolle
- ✅ Diagnostic logging til Log Analytics aktivert
- ✅ Microsoft Sentinel-regler for prompt injection konfigurert

### Copilot Studio + Zero Trust

**Utfordring:** Copilot Studio kjører i Microsoft-managed environment, men må aksessere dine on-premises eller Azure-ressurser.

**Løsning:** Kombiner **On-Premises Data Gateway** (for on-prem) eller **Virtual Network Data Gateway** (for Azure VNet) med **Managed Identity**.

**Arkitektur:**

```
Copilot Studio (Microsoft-managed)
    ↓ (via Managed Identity)
Virtual Network Data Gateway (ditt VNet)
    ↓ (via Private Endpoint)
Azure OpenAI / Custom APIs (ditt VNet)
```

**Konfigurasjon:**

1. Opprett Virtual Network Data Gateway i ditt VNet
2. Gi Copilot Studio managed identity tilgang til Gateway
3. Opprett connection i Copilot Studio via Gateway
4. Gateway bruker sin egen Managed Identity for å aksessere Azure OpenAI

**Dokumentasjon:** [Use Virtual Network Data Gateway](https://learn.microsoft.com/en-us/power-platform/admin/vnet-data-gateway)

### Azure AI Foundry + Zero Trust

**Azure AI Foundry-prosjekt** har innebygd støtte for Managed Network Isolation:

**Modes:**
- **Allow Internet Outbound:** Tillater all utgående trafikk (default)
- **Allow Only Approved Outbound:** Blokkerer all utgående trafikk unntatt eksplisitt godkjente destinations

**Konfigurasjon:**

```python
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

ml_client = MLClient(
    credential=DefaultAzureCredential(),
    subscription_id="<sub-id>",
    resource_group_name="<rg>",
    workspace_name="<workspace>"
)

# Konfigurer managed network med allow only approved outbound
from azure.ai.ml.entities import ManagedNetwork, PrivateEndpointDestination

managed_network = ManagedNetwork(
    isolation_mode="allow_only_approved",
    outbound_rules=[
        PrivateEndpointDestination(
            name="openai-pe",
            service_resource_id="/subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.CognitiveServices/accounts/{openai}",
            subresource_target="account"
        )
    ]
)

ml_client.workspaces.begin_update(
    workspace_name="<workspace>",
    managed_network=managed_network
).result()
```

**Benefit:** Foundry oppretter automatisk private endpoints for deg. Du trenger ikke manuell DNS-konfigurasjon.

### Power Platform AI Builder + Zero Trust

**Utfordring:** AI Builder-modeller kjører i Microsoft-managed environment og kan ikke direkte nå private endpoints.

**Løsning:** Bruk **Dataverse connection** med **Virtual Network Integration** (Preview).

**Arkitektur:**

```
Power Automate (with AI Builder)
    ↓
Dataverse (with VNet Integration)
    ↓
Azure OpenAI (via Private Endpoint)
```

**Status:** Virtual Network Integration for Dataverse er i Private Preview (Q1 2026). Kontakt Microsoft for early access.

**Workaround (current):** Deploy en **Azure Function** i ditt VNet som wrapper Azure OpenAI, og call denne fra Power Automate via HTTP connector.

## Offentlig sektor-hensyn

### Digdir sine "Veileder om sikkerhet i sky"

**Prinsipp 1.4: Nettverkssegmentering**
> "Ulike sikkerhetsnivåer skal skilles ved hjelp av nettverkssegmentering."

**Implementering for AI:**
- AI-tjenester som behandler gradert informasjon må ha dedikert VNet
- Kryss-netts trafikk må inspiseres av Azure Firewall
- Logging av all nettverkstrafikk til og fra AI-tjenester

**Prinsipp 2.3: Tilgangskontroll**
> "Tilgang til data og tjenester skal styres av identitet, ikke IP-adresse."

**Implementering for AI:**
- Bruk Managed Identity + RBAC (ikke IP allowlisting)
- Conditional Access for alle AI-tilganger
- Just-In-Time access for administrative oppgaver

### NSM Grunnprinsipper for IKT-sikkerhet

**Prinsipp 5: Loggføring og overvåkning**
> "Sikre tilstrekkelig loggføring for å kunne oppdage, analysere og etterforske hendelser."

**Implementering for AI:**
- Alle AI-forespørsler logges til Log Analytics (min. 90 dager retention)
- Sentinel-regler for anomaly detection (prompt injection, data exfiltration)
- Integration med Defender XDR for korrelert trusselrespons

**Prinsipp 8: Nettverk skal deles inn i soner**
> "Nettverk skal deles inn i soner basert på tillitsnivå og behov for beskyttelse."

**Implementering for AI:**
- Zone 1 (Internet-facing): Azure Front Door + WAF
- Zone 2 (App Services): VNet-integrert med private endpoints
- Zone 3 (AI Services): Kun tilgjengelig via private endpoints
- Zone 4 (Data): Azure Storage med private endpoints + Managed Identity

### EIF (European Interoperability Framework) for AI

**Security and Privacy:**
> "Information systems must ensure that data is accessible only to authorised users and protected against unauthorised access."

**Implementering:**
- Zero Trust eliminerer implisitt tillit (ingen "trusted network")
- Managed Identity sikrer at kun autoriserte applikasjoner får tilgang
- CAE revokerer access i nær-realtime ved brudd på policy

## Kostnad og ressursbruk

### Kostnadskomponenter for Zero Trust AI

| Komponent | Kostnad (NOK/mnd estimat) | Skalering |
|-----------|---------------------------|-----------|
| **Private Endpoint** | ~40 kr/endpoint/mnd + ~0.08 kr/GB egress | Per AI-ressurs |
| **Azure Firewall** | ~8 000 kr/mnd (Standard) eller ~15 000 kr/mnd (Premium) | Per region |
| **Log Analytics** | ~20 kr/GB ingested + ~5 kr/GB retention | Basert på log-volum |
| **Microsoft Sentinel** | ~260 kr/GB/mnd | Basert på log-volum |
| **Managed Identity** | Gratis | ✅ |
| **Defender for Cloud Apps** | ~60 kr/bruker/mnd | Per end-user |

**Eksempel (medium-sized deployment):**
- 5 private endpoints: 200 kr/mnd
- Azure Firewall Standard: 8 000 kr/mnd
- Log Analytics (100 GB/mnd): 2 000 kr/mnd
- Sentinel (100 GB/mnd): 26 000 kr/mnd
- **Total:** ~36 000 kr/mnd (~430 000 kr/år)

**Optimalisering:**
- Bruk **Network Security Groups** i stedet for Azure Firewall hvis du ikke trenger Layer 7-inspeksjon (spar 8 000 kr/mnd)
- Filtrer logging (ikke logg RequestResponse hvis du ikke trenger prompt/completion data) (spar opptil 50% på Log Analytics)
- Bruk **Sentinel Data Collection Rules** for å redusere ingested data (f.eks. kun logg failed requests eller high-risk operations)

### Ressursbruk (latency impact)

| Komponent | Latency overhead |
|-----------|------------------|
| Private Endpoint | +1-2 ms |
| Azure Firewall | +5-10 ms |
| TLS inspection (Firewall Premium) | +10-20 ms |
| Managed Identity token acquisition | +50-100 ms (første request, deretter cached) |
| CAE token refresh | +50-100 ms (kun ved kritiske hendelser) |

**Best practice:** For latency-kritiske AI-applikasjoner:
- Bruk Private Endpoint (minimalt overhead)
- Skip Azure Firewall hvis mulig (bruk NSG + Private Endpoint)
- Cache Managed Identity tokens i app-layer (default: 24 timer)

## For arkitekten

### Sjekkliste for Zero Trust AI-implementering

**Fase 1: Network Isolation (Uke 1-2)**
- [ ] Opprett VNet med dedikerte subnets (app, private endpoints, AzFW)
- [ ] Opprett private endpoints for alle AI-tjenester
- [ ] Konfigurer Private DNS Zones for automatisk DNS-resolusjon
- [ ] Deaktiver public network access på alle AI-ressurser
- [ ] Test connectivity fra app-subnet til AI-tjenester via private IP

**Fase 2: Identity & Access (Uke 2-3)**
- [ ] Opprett managed identities (system-assigned for enkle scenarioer, user-assigned for produksjon)
- [ ] Tildel RBAC-roller (minste privilegium-prinsippet)
- [ ] Fjern alle API-nøkler fra kode/config (bruk DefaultAzureCredential)
- [ ] Konfigurer Conditional Access-policies for interactive scenarios
- [ ] Aktiver CAE på AI-ressurser

**Fase 3: Monitoring & Response (Uke 3-4)**
- [ ] Aktiver diagnostic settings på alle AI-ressurser (send til Log Analytics)
- [ ] Opprett Microsoft Sentinel workspace og koble til Log Analytics
- [ ] Implementer Sentinel-regler for prompt injection, data exfiltration, anomaly detection
- [ ] Konfigurer Sentinel playbooks for automated response (block IP, revoke MI, alert SOC)
- [ ] Integrer med Defender XDR for korrelert trusselrespons

**Fase 4: Validation & Hardening (Uke 4-5)**
- [ ] Kjør penetration testing (test om AI-tjenester er tilgjengelige fra Internet)
- [ ] Valider at alle AI-forespørsler logger til Sentinel
- [ ] Test CAE-revokasjon (disable user/device og verifiser at access blokkeres innen sekunder)
- [ ] Review RBAC-tildelinger (ingen over-privileged identities?)
- [ ] Dokumenter arkitektur i ADR (Architecture Decision Record)

### Vanlige feil og unngåelser

**Feil 1: Bruke API-nøkler selv med Managed Identity aktivert**

```python
# ❌ IKKE GJØR DETTE
client = AzureOpenAI(
    azure_endpoint="https://my-resource.openai.azure.com",
    api_key="abc123..."  # Hardkodet API key
)

# ✅ GJØR DETTE
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
token_provider = get_bearer_token_provider(
    DefaultAzureCredential(),
    "https://cognitiveservices.azure.com/.default"
)
client = AzureOpenAI(
    azure_endpoint="https://my-resource.openai.azure.com",
    azure_ad_token_provider=token_provider
)
```

**Feil 2: Glemme å oppdatere DNS for private endpoints**

Symptom: `getaddrinfo failed` eller connection timeouts

Løsning: Opprett Private DNS Zone og link til VNet:

```bash
az network private-dns zone create \
  --resource-group myRG \
  --name privatelink.openai.azure.com

az network private-dns link vnet create \
  --resource-group myRG \
  --zone-name privatelink.openai.azure.com \
  --name myDNSLink \
  --virtual-network myVNet \
  --registration-enabled false
```

**Feil 3: For brede RBAC-tildelinger**

```bash
# ❌ IKKE gi Contributor på subscription-nivå
az role assignment create \
  --role "Cognitive Services Contributor" \
  --assignee <identity> \
  --scope /subscriptions/{sub-id}

# ✅ Gi kun User-rolle på specific AI-ressurs
az role assignment create \
  --role "Cognitive Services OpenAI User" \
  --assignee <identity> \
  --scope /subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.CognitiveServices/accounts/{ai-name}
```

**Feil 4: Ikke logge RequestResponse pga personvern-bekymringer**

Problem: Du mister mulighet til å detektere prompt injection.

Løsning: Bruk **Log Analytics Data Collection Rules** for å filtrere sensitive felter:

```kql
// Fjern PII fra logger før lagring
AzureDiagnostics
| where Category == "RequestResponse"
| extend Prompt = tostring(parse_json(properties_s).prompt)
| extend CleanedPrompt = replace_regex(Prompt, @"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b", "[EMAIL]")
| extend CleanedPrompt = replace_regex(CleanedPrompt, @"\b\d{11}\b", "[SSN]")
| project TimeGenerated, CallerIpAddress, identity_claim_upn_s, CleanedPrompt
```

### Referansearkitektur: Produksjonsklart Zero Trust AI

```
┌──────────────────────────────────────────────────────────────┐
│                      Internet                                 │
└────────────────┬─────────────────────────────────────────────┘
                 │
                 ▼
┌─────────────────────────────────────────────────────────────┐
│  Azure Front Door + WAF                                      │
│  • DDoS Protection Standard                                  │
│  • WAF rules (OWASP Top 10)                                  │
│  • Rate limiting                                             │
└────────────────┬────────────────────────────────────────────┘
                 │
                 ▼
┌─────────────────────────────────────────────────────────────┐
│  Hub VNet (10.0.0.0/16)                                      │
│  ┌────────────────────────────────────────────────────────┐ │
│  │  Azure Firewall Subnet (10.0.1.0/24)                   │ │
│  │  • Azure Firewall Premium                              │ │
│  │  • TLS inspection enabled                              │ │
│  │  • IDPS mode: Alert and Deny                           │ │
│  │  • Threat intelligence: Microsoft feed                 │ │
│  └────────────────────────────────────────────────────────┘ │
│  ┌────────────────────────────────────────────────────────┐ │
│  │  Private Endpoint Subnet (10.0.2.0/24)                 │ │
│  │  ┌──────────────────────────────────────────────────┐  │ │
│  │  │ PE: Azure OpenAI                                  │  │ │
│  │  │ PE: Document Intelligence                         │  │ │
│  │  │ PE: Azure AI Search                               │  │ │
│  │  │ PE: Storage Account                               │  │ │
│  │  └──────────────────────────────────────────────────┘  │ │
│  └────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
         ▲                          ▲
         │ VNet Peering             │ VNet Peering
         │                          │
┌────────┴──────────┐      ┌────────┴──────────────┐
│ Spoke 1 VNet      │      │ Spoke 2 VNet          │
│ (10.1.0.0/16)     │      │ (10.2.0.0/16)         │
│ ┌───────────────┐ │      │ ┌────────────────┐   │
│ │ App Service   │ │      │ │ AKS Cluster    │   │
│ │ (VNet Int)    │ │      │ │ (CNI)          │   │
│ │ System MI     │ │      │ │ Workload ID    │   │
│ └───────────────┘ │      │ └────────────────┘   │
└───────────────────┘      └──────────────────────┘

Logging & Monitoring:
┌─────────────────────────────────────────────────────────────┐
│  Log Analytics Workspace                                     │
│  • Retention: 90 days                                        │
│  • Data Collection Rules: Filter PII                         │
└────────────────┬────────────────────────────────────────────┘
                 │
                 ▼
┌─────────────────────────────────────────────────────────────┐
│  Microsoft Sentinel                                          │
│  • Analytics rules: Prompt injection, data exfiltration     │
│  • Playbooks: Auto-block IP, revoke MI, alert SOC           │
│  • UEBA: Anomaly detection for AI usage                     │
└────────────────┬────────────────────────────────────────────┘
                 │
                 ▼
┌─────────────────────────────────────────────────────────────┐
│  Microsoft Defender XDR                                      │
│  • Correlation: Identity + Endpoint + AI logs                │
│  • Automated response: Isolate device, revoke session        │
└─────────────────────────────────────────────────────────────┘
```

**Nøkkelkomponenter:**

1. **Internet-facing layer:**
   - Azure Front Door med WAF (block OWASP Top 10)
   - DDoS Protection Standard (inkludert med AFD)

2. **Hub VNet:**
   - Azure Firewall Premium (TLS inspection, IDPS)
   - Private Endpoints for alle AI-tjenester
   - Private DNS Zones (auto-registrering)

3. **Spoke VNets:**
   - App Service med VNet Integration + System MI
   - AKS med CNI + Workload Identity
   - NSG på alle subnets (deny-by-default)

4. **Identity & Access:**
   - Managed Identities (system/user-assigned)
   - RBAC på resource-nivå (minste privilegium)
   - Conditional Access + CAE for interactive scenarios

5. **Monitoring:**
   - Log Analytics (90 days retention, PII-filtered)
   - Microsoft Sentinel (analytics rules, playbooks)
   - Defender XDR (korrelert trusselrespons)

### Videre lesning

**Microsoft Learn:**
- [Zero Trust deployment plan with Microsoft 365](https://learn.microsoft.com/en-us/security/zero-trust/) — Inkluderer nå dedikert **Copilots**-seksjon med Zero Trust-veiledning for M365 Copilot og Copilot Studio *(Verified MCP 2026-04)*
- [Apply Zero Trust principles to Azure services](https://learn.microsoft.com/en-us/security/zero-trust/apply-zero-trust-azure-services-overview)
- [Azure AI security baseline](https://learn.microsoft.com/en-us/security/benchmark/azure/baselines/azure-openai-security-baseline) — Reflekterer Microsoft Cloud Security Benchmark (MCSB) v1.0; sjekk om nyere versjon er tilgjengelig *(Verified MCP 2026-04)*
- [Secure Future Initiative (SFI)](https://learn.microsoft.com/en-us/security/zero-trust/) — Microsofts SFI integrert i Zero Trust-hubben; gir kontekst for Microsofts sikkerhetsinvesteringer

**Whitepapers:**
- "Zero Trust Architecture" (NIST SP 800-207)
- "Zero Trust Maturity Model" (CISA)
- "AI Security Best Practices" (Microsoft Security Response Center)

**GitHub samples:**
- [Azure OpenAI with Managed Identity](https://github.com/Azure-Samples/openai-python-enterprise-logging)
- [AKS with Workload Identity](https://github.com/Azure-Samples/aks-workload-identity)

## Kilder

Denne guiden er basert på følgende Microsoft Learn-dokumentasjon (sist verifisert 2026-04):

1. [Secure networks with SASE, Zero Trust, and AI](https://learn.microsoft.com/en-us/security/zero-trust/deploy/networks) — Offisiell Zero Trust nettverksguide
2. [How to configure Azure OpenAI with managed identities](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/how-to/managed-identity) — Managed Identity-konfigurasjon for Azure OpenAI
3. [Managed identities: role-based access control (RBAC)](https://learn.microsoft.com/en-us/azure/ai-services/translator/document-translation/how-to-guides/create-use-managed-identities) — RBAC-implementering for AI Services
4. [Azure security baseline for Azure OpenAI](https://learn.microsoft.com/en-us/security/benchmark/azure/baselines/azure-openai-security-baseline) — Sikkerhetsbaseline med Identity Management-krav
5. [Build a strong security posture for AI](https://learn.microsoft.com/en-us/security/security-for-ai/posture) — Zero Trust-prinsipper for AI-sikkerhet
6. [Network isolation in Azure AI Bot Service](https://learn.microsoft.com/en-us/azure/bot-service/dl-network-isolation-concept) — Private Endpoint-konsepter for AI-tjenester
7. [Plan for network isolation in Azure Machine Learning](https://learn.microsoft.com/en-us/azure/machine-learning/how-to-network-isolation-planning) — Managed Network Isolation for Azure AI Foundry
8. [Managed identity best practice recommendations](https://learn.microsoft.com/en-us/entra/identity/managed-identities-azure-resources/managed-identity-best-practice-recommendations) — Token caching-begrensninger og workarounds
9. [Azure AI services authentication and authorization using .NET](https://learn.microsoft.com/en-us/dotnet/ai/azure-ai-services-authentication) — Autentiseringsmønstre for AI Services
10. [Continuous Access Evaluation (CAE)](https://learn.microsoft.com/en-us/entra/identity/conditional-access/concept-continuous-access-evaluation) — Realtime token revokasjon
11. Microsoft Learn Code Samples — Managed Identity-implementeringseksempler (Python, .NET)

---

**For Cosmo:**

Når en kunde spør om "Hvordan sikrer jeg AI-tjenester?", nevn denne guiden og gi konkrete anbefalinger basert på deres scenario:
- Er det service-to-service kommunikasjon? → Managed Identity + Private Endpoint
- Er det sluttbrukere som aksesserer AI? → Conditional Access + Private Access + Defender for Cloud Apps
- Er de offentlig sektor? → Legg vekt på Digdir/NSM-krav og logg-retensjon
- Er kostnad en bekymring? → Foreslå NSG + Private Endpoint (skip Azure Firewall hvis ikke nødvendig)

**Trigger-spørsmål:**
- "Hvordan sikrer jeg Azure OpenAI i produksjon?"
- "Hvordan eliminerer jeg API-nøkler fra koden?"
- "Hva er forskjellen mellom system-assigned og user-assigned managed identity?"
- "Hvordan detekterer jeg prompt injection?"
- "Hvordan oppfyller jeg NSM Grunnprinsipper med AI-tjenester?"
