ktg-plugin-marketplace/plugins/ms-ai-architect/skills/ms-ai-security/references/ai-security-engineering/zero-trust-ai-services.md

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:

# 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):

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:

# 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:

# 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:

# 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:

// 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:

# 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:

# 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:

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

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

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:

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

# ❌ 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:

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

# ❌ 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:

// 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 — 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
• Azure AI security baseline — Reflekterer Microsoft Cloud Security Benchmark (MCSB) v1.0; sjekk om nyere versjon er tilgjengelig (Verified MCP 2026-04)
• Secure Future Initiative (SFI) — 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
• AKS with 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 — Offisiell Zero Trust nettverksguide
2. How to configure Azure OpenAI with managed identities — Managed Identity-konfigurasjon for Azure OpenAI
3. Managed identities: role-based access control (RBAC) — RBAC-implementering for AI Services
4. Azure security baseline for Azure OpenAI — Sikkerhetsbaseline med Identity Management-krav
5. Build a strong security posture for AI — Zero Trust-prinsipper for AI-sikkerhet
6. Network isolation in Azure AI Bot Service — Private Endpoint-konsepter for AI-tjenester
7. Plan for network isolation in Azure Machine Learning — Managed Network Isolation for Azure AI Foundry
8. Managed identity best practice recommendations — Token caching-begrensninger og workarounds
9. Azure AI services authentication and authorization using .NET — Autentiseringsmønstre for AI Services
10. Continuous Access Evaluation (CAE) — 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?"