ms-ai-architect/skills/ms-ai-security/references/performance-scalability/cdn-edge-caching-ai.md

CDN and Edge Caching for AI Workloads

Last updated: 2026-02 Status: GA Category: Performance & Scalability Type: reference

---

Innhold

• Introduksjon
• Azure Front Door for AI-endepunkter
• CDN Caching-regler for AI-responser
• Semantic Caching for AI
• Edge Compute for pre-prosessering
• Geografisk routing og optimalisering
• DDoS-beskyttelse for AI-endepunkter
• Ytelsesgevinster: Oppsummering
• For Cosmo

Introduksjon

Content Delivery Networks (CDN) og edge computing er etablerte teknologier for a akselerere webinnhold, men bruken i AI-kontekst krever en nyansert tilnaerming. AI-responser er dynamiske og ofte personaliserte, noe som gjor tradisjonell caching mer kompleks. Likevel finnes det betydelige muligheter for a redusere latens og kostnader ved a cache AI-relatert innhold pa riktig mate.

For norsk offentlig sektor, der brukere er geografisk spredt over hele landet, kan edge computing og smart caching redusere opplevd responstid betydelig. Azure Front Door med sine 118+ edge-lokasjoner og globale lastbalansering er den primaere tjenesten for dette formalet.

Denne referansen dekker strategier for a bruke Azure Front Door, CDN-caching og edge compute for AI-arbeidslaster, med fokus pa hva som kan og ikke bor caches, samt geografisk routing for optimal ytelse.

Azure Front Door for AI-endepunkter

Oversikt

Azure Front Door er en global CDN med lastbalansering, TLS-terminering og edge caching. For AI-arbeidslaster fungerer den som et intelligent lag mellom brukere og backend-tjenester:

Funksjon	Beskrivelse	Relevans for AI
Global lastbalansering	Ruter trafikk til naermeste/friskeste backend	Multi-region AI-deployments
TLS-terminering	Terminerer SSL pa edge	Reduserer latens med ~50-100 ms
Edge caching	Cacher statisk og semi-statisk innhold	Embeddings, modellmetadata
WAF	Web Application Firewall	Beskytter AI-endepunkter
DDoS-beskyttelse	Layer 3/4/7 beskyttelse	Kritisk for publiserte AI-APIer
Traffic acceleration	Split TCP, anycast	30-40% raskere for dynamisk innhold

Arkitektur: Front Door foran AI-tjenester

Innbygger (Tromso)  -->  Azure Front Door Edge (Oslo/Stockholm)
                              |
                    +---------+---------+
                    |                   |
              Sweden Central       North Europe
              (AI-primaer)        (AI-failover)
                    |                   |
              Azure OpenAI        Azure OpenAI
              Container Apps      Container Apps

Front Door-konfigurasjon for AI

resource frontDoor 'Microsoft.Cdn/profiles@2023-05-01' = {
  name: 'fd-ai-services'
  location: 'global'
  sku: {
    name: 'Premium_AzureFrontDoor'  // Premium for WAF
  }
}

resource aiEndpoint 'Microsoft.Cdn/profiles/afdEndpoints@2023-05-01' = {
  parent: frontDoor
  name: 'ai-api-endpoint'
  location: 'global'
  properties: {
    enabledState: 'Enabled'
  }
}

// Origin group med health probes
resource aiOriginGroup 'Microsoft.Cdn/profiles/originGroups@2023-05-01' = {
  parent: frontDoor
  name: 'ai-backends'
  properties: {
    loadBalancingSettings: {
      sampleSize: 4
      successfulSamplesRequired: 3
      additionalLatencyInMilliseconds: 50
    }
    healthProbeSettings: {
      probePath: '/health'
      probeRequestType: 'HEAD'
      probeProtocol: 'Https'
      probeIntervalInSeconds: 30
    }
    sessionAffinityState: 'Disabled'  // Viktig: Ingen session affinity for AI
  }
}

// Primaer origin: Sweden Central
resource primaryOrigin 'Microsoft.Cdn/profiles/originGroups/origins@2023-05-01' = {
  parent: aiOriginGroup
  name: 'sweden-central'
  properties: {
    hostName: 'ai-service.swedencentral.azurecontainerapps.io'
    httpPort: 80
    httpsPort: 443
    originHostHeader: 'ai-service.swedencentral.azurecontainerapps.io'
    priority: 1
    weight: 1000
  }
}

// Failover origin: North Europe
resource failoverOrigin 'Microsoft.Cdn/profiles/originGroups/origins@2023-05-01' = {
  parent: aiOriginGroup
  name: 'north-europe'
  properties: {
    hostName: 'ai-service.northeurope.azurecontainerapps.io'
    httpPort: 80
    httpsPort: 443
    originHostHeader: 'ai-service.northeurope.azurecontainerapps.io'
    priority: 2
    weight: 1000
  }
}

CDN Caching-regler for AI-responser

Hva kan og bor caches?

Innholdstype	Cachebar?	TTL	Begrunnelse
Statiske assets (JS/CSS/bilder)	Ja	1 dag - 1 uke	Standard CDN-bruk
AI-modellmetadata (tilgjengelige modeller)	Ja	5-15 min	Endres sjelden
Embedding-resultater (identisk input)	Ja, med forsiktighet	1-24 timer	Deterministisk output
Chat completion-responser	Nei	N/A	Dynamisk, personalisert
RAG-soekeresultater	Nei	N/A	Avhenger av kunnskapsbase
Streaming-responser (SSE)	Nei	N/A	Real-time, ikke cachebart
Health check-endepunkter	Nei	N/A	Ma vaere sanntid
Token-telling/estimat	Ja	1-5 min	Stabil beregning

Cache-regler i Front Door

// Route for statisk innhold (caching aktivert)
resource staticRoute 'Microsoft.Cdn/profiles/afdEndpoints/routes@2023-05-01' = {
  parent: aiEndpoint
  name: 'static-content'
  properties: {
    originGroup: { id: aiOriginGroup.id }
    patternsToMatch: ['/static/*', '/assets/*', '/models/metadata']
    supportedProtocols: ['Https']
    cacheConfiguration: {
      queryStringCachingBehavior: 'IgnoreQueryString'
      compressionSettings: {
        isCompressionEnabled: true
        contentTypesToCompress: [
          'application/json'
          'text/javascript'
          'text/css'
        ]
      }
      cacheBehavior: 'OverrideAlways'
      cacheDuration: '01:00:00'  // 1 time
    }
  }
}

// Route for AI API-endepunkter (caching deaktivert)
resource apiRoute 'Microsoft.Cdn/profiles/afdEndpoints/routes@2023-05-01' = {
  parent: aiEndpoint
  name: 'ai-api'
  properties: {
    originGroup: { id: aiOriginGroup.id }
    patternsToMatch: ['/api/chat/*', '/api/completions/*']
    supportedProtocols: ['Https']
    cacheConfiguration: {
      queryStringCachingBehavior: 'UseQueryString'
      cacheBehavior: 'HonorOrigin'  // Respekter Cache-Control fra backend
    }
  }
}

// Route for streaming-endepunkter (ingen caching, ingen buffering)
resource streamRoute 'Microsoft.Cdn/profiles/afdEndpoints/routes@2023-05-01' = {
  parent: aiEndpoint
  name: 'ai-stream'
  properties: {
    originGroup: { id: aiOriginGroup.id }
    patternsToMatch: ['/api/chat/stream/*']
    supportedProtocols: ['Https']
    cacheConfiguration: {
      cacheBehavior: 'Disabled'
    }
  }
}

Backend Cache-Control headers

For korrekt cache-oppforsel ma backend sette riktige headers:

from fastapi import FastAPI, Response
from fastapi.responses import JSONResponse

app = FastAPI()

@app.get("/models/metadata")
async def get_model_metadata():
    """Modellmetadata - kan caches."""
    return JSONResponse(
        content={"models": ["gpt-4o", "gpt-4o-mini"]},
        headers={
            "Cache-Control": "public, max-age=900",  # 15 minutter
            "Vary": "Accept-Encoding"
        }
    )

@app.post("/api/chat/completions")
async def chat_completions():
    """Chat completions - skal IKKE caches."""
    response = await process_chat()
    return JSONResponse(
        content=response,
        headers={
            "Cache-Control": "no-store, no-cache, must-revalidate",
            "Pragma": "no-cache"
        }
    )

@app.post("/api/embeddings")
async def get_embeddings(request: EmbeddingRequest):
    """Embeddings - kan caches for identiske inputs."""
    # Generer cache key basert pa input
    cache_key = hashlib.sha256(request.input.encode()).hexdigest()

    return JSONResponse(
        content=embedding_result,
        headers={
            "Cache-Control": "public, max-age=86400",  # 24 timer
            "ETag": f'"{cache_key}"',
            "Vary": "Content-Type"
        }
    )

Advarsel: Unnga caching av personlig innhold

ADVARSEL: Feilkonfigurert caching kan fore til personvernbrudd!

ALDRI cache:
- Chat-responser som inneholder personopplysninger
- Responser basert pa brukeridentitet
- API-kall med Authorization-header
- Streaming-endepunkter (SSE)

Azure Front Door cacher basert pa URL og query-parametre.
Hvis to brukere sender identisk request til et cachet endepunkt,
vil bruker B se bruker As respons.

For norsk offentlig sektor: Brudd pa personopplysningsloven (GDPR)
kan resultere i bot fra Datatilsynet.

Semantic Caching for AI

Tradisjonell cache vs. semantic cache

Aspekt	Tradisjonell cache	Semantic cache
Match-kriterium	Eksakt URL/key	Semantisk likhet (vector)
Hit rate	Lav for AI (unik input)	Hoy (lignende sporsmaal matcher)
Infrastruktur	Standard CDN/Redis	Redis med RediSearch + embeddings
Kostnad	Lav	Moderat (embedding + Redis)
Latens ved hit	~1 ms	~5-20 ms
Relevans for AI	Begrenset	Hoy

Semantic Caching med Azure API Management

<!-- APIM policy for semantic caching -->
<policies>
    <inbound>
        <base />
        <!-- Sjekk semantic cache for matche -->
        <azure-openai-semantic-cache-lookup
            score-threshold="0.8"
            embeddings-backend-id="embeddings-backend"
            embeddings-backend-auth="system-assigned" />
    </inbound>
    <backend>
        <forward-request buffer-response="false" />
    </backend>
    <outbound>
        <base />
        <!-- Lagre respons i semantic cache -->
        <azure-openai-semantic-cache-store duration="3600" />
    </outbound>
</policies>

Forutsetninger for semantic caching:

1. Azure API Management (alle tiers)
2. Azure Managed Redis med RediSearch-modul
3. Azure OpenAI Embeddings-deployment
4. Managed identity-autentisering

Nar bruke semantic caching

Bruksomrade	Egnet?	Begrunnelse
FAQ-chatbot for innbyggere	Ja	Mange lignende sporsmaal
Intern kunnskapsbase-SOK	Ja	Gjentakende sporsmaal
Dokumentanalyse (unik input)	Nei	Unik input per dokument
Kreativ innholdsgenerering	Nei	Variasjon er onskelig
Klassifisering med fast prompt	Ja	Identisk/lignende input
Ovesettelse	Delvis	Identiske setninger kan caches

Edge Compute for pre-prosessering

Pre-prosessering pa edge

For AI-arbeidslaster kan visse operasjoner kjores naermere brukeren:

Operasjon	Kjor pa edge?	Teknologi
Input-validering	Ja	Azure Functions / Container Apps
Token-telling (estimat)	Ja	tiktoken lokalt
PII-deteksjon (enkel)	Ja	Regex-basert filtrering
Rate limiting	Ja	APIM / Front Door WAF
Request routing	Ja	Front Door Rules Engine
Prompt assembly	Ja	Edge function
AI-inferens	Nei	Krever GPU/TPU i backend
RAG retrieval	Delvis	Embedding pa edge, sok i backend

Azure Functions pa Edge (med Container Apps)

# Edge pre-processing function
import re
from typing import Optional

def pre_process_ai_request(
    user_input: str,
    max_input_length: int = 10000
) -> dict:
    """Pre-prosesser AI-request pa edge for lavere latens og sikkerhet."""

    result = {
        "processed_input": user_input,
        "metadata": {},
        "blocked": False
    }

    # 1. Inputvalidering
    if len(user_input) > max_input_length:
        result["processed_input"] = user_input[:max_input_length]
        result["metadata"]["truncated"] = True

    # 2. Enkel PII-deteksjon (pre-filtering)
    pii_patterns = {
        "fodselsnummer": r'\b\d{6}\s?\d{5}\b',  # Norsk fodselsnummer
        "kontonummer": r'\b\d{4}\.\d{2}\.\d{5}\b',
        "telefonnummer": r'\b(?:\+47)?\s?\d{3}\s?\d{2}\s?\d{3}\b'
    }

    detected_pii = []
    for pii_type, pattern in pii_patterns.items():
        if re.search(pattern, user_input):
            detected_pii.append(pii_type)

    if detected_pii:
        result["metadata"]["detected_pii"] = detected_pii
        # Vurder a blokkere eller varsle basert pa policy

    # 3. Token-estimat (uten full tiktoken)
    estimated_tokens = len(user_input.split()) * 1.3
    result["metadata"]["estimated_tokens"] = int(estimated_tokens)

    return result

Request Routing basert pa innhold

<!-- Front Door Rules Engine: Rut basert pa request-egenskaper -->
<rules>
    <rule name="route-simple-queries">
        <!-- Korte requests -> GPT-4o mini for lavest latens -->
        <conditions>
            <condition>
                <matchVariable>RequestBody</matchVariable>
                <operator>LengthLessThan</operator>
                <matchValues>500</matchValues>
            </condition>
        </conditions>
        <actions>
            <routeConfigurationOverride>
                <originGroup>/originGroups/fast-model-backends</originGroup>
            </routeConfigurationOverride>
        </actions>
    </rule>
    <rule name="route-complex-queries">
        <!-- Lange requests -> GPT-4o for bedre kvalitet -->
        <conditions>
            <condition>
                <matchVariable>RequestBody</matchVariable>
                <operator>LengthGreaterThan</operator>
                <matchValues>2000</matchValues>
            </condition>
        </conditions>
        <actions>
            <routeConfigurationOverride>
                <originGroup>/originGroups/quality-model-backends</originGroup>
            </routeConfigurationOverride>
        </actions>
    </rule>
</rules>

Geografisk routing og optimalisering

Trafikkruting for Norge

For norsk offentlig sektor med brukere over hele landet:

Brukerplassering	Naermeste Edge PoP	Backend-region	Forventet latens
Oslo/Ostlandet	Oslo/Stockholm	Sweden Central	5-15 ms
Bergen/Vestland	Amsterdam/Stockholm	Sweden Central	15-25 ms
Tromso/Nord-Norge	Stockholm	Sweden Central	20-35 ms
Trondheim/Trondelag	Stockholm	Sweden Central	15-25 ms

Multi-region deployment med Azure Front Door

// Geografisk routing-konfigurasjon
resource routePolicy 'Microsoft.Cdn/profiles/afdEndpoints/routes@2023-05-01' = {
  parent: aiEndpoint
  name: 'geo-optimized-route'
  properties: {
    originGroup: { id: aiOriginGroup.id }
    patternsToMatch: ['/api/*']
    supportedProtocols: ['Https']
    // Front Door bruker anycast for automatisk naermeste-edge-routing
    // Backend-valg baseres pa latens + health probes
  }
}

Latensbasert routing

Azure Front Door velger automatisk backend med lavest latens:

1. Bruker i Tromso sender request
2. DNS resolver -> naermeste Front Door PoP (Stockholm)
3. Front Door maler latens til alle backends:
   - Sweden Central: 10 ms
   - North Europe: 35 ms
4. Request rutes til Sweden Central
5. Hvis Sweden Central er nede: automatisk failover til North Europe

Health Probes for AI-backends

# Health endpoint for AI-tjeneste
from fastapi import FastAPI
import time

app = FastAPI()

# Enkel health check
@app.get("/health")
async def health():
    return {"status": "healthy", "timestamp": time.time()}

# Detaljert health check (for intern bruk, ikke via Front Door)
@app.get("/health/detailed")
async def detailed_health():
    checks = {}

    # Sjekk Azure OpenAI-tilgang
    try:
        response = await client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": "ping"}],
            max_tokens=1
        )
        checks["azure_openai"] = "healthy"
    except Exception as e:
        checks["azure_openai"] = f"unhealthy: {str(e)}"

    # Sjekk vector store
    try:
        await search_client.search("test", top=1)
        checks["search_index"] = "healthy"
    except Exception:
        checks["search_index"] = "unhealthy"

    overall = "healthy" if all(v == "healthy" for v in checks.values()) else "degraded"
    return {"status": overall, "checks": checks}

DDoS-beskyttelse for AI-endepunkter

Front Door + WAF for AI-APIer

AI-endepunkter er spesielt sarbare for misbruk pa grunn av hoye kostnader per request:

resource wafPolicy 'Microsoft.Network/FrontDoorWebApplicationFirewallPolicies@2022-05-01' = {
  name: 'waf-ai-protection'
  location: 'global'
  properties: {
    policySettings: {
      enabledState: 'Enabled'
      mode: 'Prevention'
    }
    customRules: {
      rules: [
        {
          name: 'RateLimitAIEndpoints'
          priority: 100
          ruleType: 'RateLimitRule'
          rateLimitDurationInMinutes: 1
          rateLimitThreshold: 100  // Maks 100 requests per minutt per IP
          matchConditions: [
            {
              matchVariable: 'RequestUri'
              operator: 'Contains'
              matchValue: ['/api/chat', '/api/completions']
            }
          ]
          action: 'Block'
        }
        {
          name: 'BlockLargePayloads'
          priority: 200
          ruleType: 'MatchRule'
          matchConditions: [
            {
              matchVariable: 'RequestBody'
              operator: 'GreaterThan'
              matchValue: ['1048576']  // 1 MB maks request body
              transforms: ['Trim']
            }
          ]
          action: 'Block'
        }
      ]
    }
  }
}

Ytelsesgevinster: Oppsummering

Teknikk	Typisk latensreduksjon	Kostnadsreduksjon	Kompleksitet
Front Door TLS-terminering	50-100 ms	Ingen	Lav
Traffic acceleration (split TCP)	30-40% dynamisk	Ingen	Lav
Static asset caching	90%+ for assets	Redusert backend-trafikk	Lav
Semantic caching	80-95% ved hit	Eliminerer AI-kall ved hit	Hoy
Edge pre-processing	10-50 ms	Blokkerer unodvendige kall	Medium
Geographic routing	10-40 ms	Ingen direkte	Lav
DDoS/rate limiting	Indirekte (beskyttelse)	Hindrer misbrukskostnader	Medium

For Cosmo

• Azure Front Door er obligatorisk for alle publiserte AI-endepunkter. Det gir TLS-terminering, DDoS-beskyttelse, geographic routing og traffic acceleration med minimal konfigurasjon.
• Cache ALDRI chat completion-responser. Feilkonfigurert caching kan lekke personopplysninger mellom brukere. Kun statisk innhold, modellmetadata og embeddings kan caches trygt.
• Semantic caching via APIM + Redis er den mest verdifulle cache-teknikken for AI. For FAQ-chatbots kan det eliminere 50-70% av backend-kall og redusere bade latens og kostnad.
• Edge pre-processing (PII-deteksjon, inputvalidering, token-estimat) reduserer unodvendig backend-trafikk og forbedrer sikkerhet. Implementer som en enkel middleware foran AI-endepunktet.
• Rate limiting pa WAF-niva er kritisk for AI-endepunkter fordi hvert kall har hoy kostnad. Sett restriktive grenser (50-200 requests/min per IP) og juster etter behov.