ms-ai-architect/skills/ms-ai-infrastructure/references/hybrid-edge/kubernetes-edge-aks-edge.md

# Kubernetes-Based AI at the Edge (AKS Edge)

**Last updated:** 2026-02
**Status:** GA
**Category:** Hybrid Cloud & Edge AI

---

## Introduksjon

AKS Edge Essentials er Microsofts lettvekts Kubernetes-distribusjon for edge-scenarier, designet for a kjore containeriserte arbeidsbelastninger pa PC-klasse hardware. I motsetning til AKS i skyen eller AKS pa Azure Local, er AKS Edge Essentials optimalisert for statiske, forhands-definerte konfigurasjoner pa enheter med begrenset kapasitet — fra industrielle PC-er til gateway-enheter.

For AI-arbeidsbelastninger pa edge muliggjor AKS Edge Essentials deployment av ML-modeller, inferensservere, og AI-pipelines som Kubernetes-pods med GPU-akselerasjon (via GPU-PV). Tilkoblet Azure Arc gir sentralisert administrasjon, GitOps-basert deployment, og integrasjon med Azure ML, Azure Monitor og Azure Policy.

For norsk offentlig sektor er AKS Edge Essentials relevant for distribuert AI pa lokale stasjoner (veisensorer, helseutstyr, energimalere) der Kubernetes-basert orkestrering gir standardisert deployment og oppdatering av AI-modeller pa tvers av geografisk spredte enheter.

---

## Kjernekomponenter

| Komponent | Formal | Teknologi |
|-----------|--------|-----------|
| AKS Edge Essentials | Lettvekts Kubernetes pa edge | K8s/K3s |
| CBL-Mariner Linux VM | Managed Linux VM for containere | Microsoft Mariner |
| Azure Arc | Sentralisert administrasjon fra sky | Kubernetes management |
| GitOps (Flux) | Deklarativ applikasjons-deployment | Git-basert CD |
| GPU-PV | GPU-deling mellom host og VM | Paravirtualisering |
| KAITO | AI-modell deployment operator | Kubernetes operator |
| Helm | Pakkehandtering for Kubernetes | Chart-basert |

---

## AKS Edge Essentials Deployment

### Systemkrav

| Komponent | Minimum | Anbefalt for AI |
|-----------|---------|-----------------|
| OS | Windows 10/11 IoT Enterprise | Windows 11 IoT Enterprise |
| CPU | 4 kjerner | 8+ kjerner |
| RAM | 4 GB (K3s) / 8 GB (K8s) | 16+ GB for AI-workloads |
| Disk | 40 GB | 100+ GB SSD |
| GPU | Ikke pakrevd | NVIDIA T4/A2 for inferens |
| Nettverk | 1 Gbps | 10 Gbps for modell-nedlasting |

### Installasjon og klynge-oppsett

```powershell
# Steg 1: Installer AKS Edge Essentials
# Last ned MSI fra Microsoft
Start-BitsTransfer -Source "https://aka.ms/aks-edge/k8s-msi" `
  -Destination "AksEdge-K8s.msi"
msiexec /i AksEdge-K8s.msi /passive

# Steg 2: Importer PowerShell-moduler
Import-Module AksEdge

# Steg 3: Generer konfigurasjonsfil
New-AksEdgeConfig -DeploymentType SingleMachineCluster `
  -NodeType Linux `
  -outFile .\aksedge-config.json
```

```json
// aksedge-config.json — Konfigurert for AI-workloads
{
  "SchemaVersion": "1.14",
  "Version": "1.0",
  "DeploymentType": "SingleMachineCluster",
  "Init": {
    "ServiceIPRangeSize": 10
  },
  "Network": {
    "NetworkPlugin": "flannel",
    "InternetDisabled": false
  },
  "User": {
    "AcceptEula": true,
    "AcceptOptionalTelemetry": false
  },
  "Machines": [
    {
      "LinuxNode": {
        "CpuCount": 8,
        "MemoryInMB": 12288,
        "DataSizeInGB": 40,
        "Mtu": 1500
      }
    }
  ]
}
```

```powershell
# Steg 4: Valider og deploy klynge
Test-AksEdgeNetworkParameters -JsonConfigFilePath .\aksedge-config.json
New-AksEdgeDeployment -JsonConfigFilePath .\aksedge-config.json

# Steg 5: Verifiser deployment
kubectl get nodes -o wide
kubectl get pods --all-namespaces -o wide
```

### Tilkobling til Azure Arc

```powershell
# Koble AKS Edge Essentials til Azure Arc
$arcParams = @{
    ClusterName = "edge-ai-station-01"
    ResourceGroupName = "rg-edge-ai-norway"
    Location = "norwayeast"
    SubscriptionId = "<subscription-id>"
    TenantId = "<tenant-id>"
}

# Installer Arc-agenter pa klyngen
Install-AksEdgeArc @arcParams

# Verifiser Arc-tilkobling
kubectl get pods -n azure-arc
az connectedk8s show --name edge-ai-station-01 --resource-group rg-edge-ai-norway
```

---

## Container Orchestration at Edge

### AI-inferens deployment med Kubernetes

```yaml
# ONNX Runtime inferensserver pa AKS Edge
apiVersion: apps/v1
kind: Deployment
metadata:
  name: onnx-inference-server
  namespace: ai-workloads
spec:
  replicas: 1
  selector:
    matchLabels:
      app: onnx-inference
  template:
    metadata:
      labels:
        app: onnx-inference
    spec:
      containers:
        - name: inference
          image: mcr.microsoft.com/onnxruntime/server:latest
          args:
            - "--model_path"
            - "/models/anomaly_detector.onnx"
            - "--http_port"
            - "8001"
          ports:
            - containerPort: 8001
              name: http
          resources:
            requests:
              memory: "512Mi"
              cpu: "500m"
            limits:
              memory: "2Gi"
              cpu: "2"
          volumeMounts:
            - name: model-storage
              mountPath: /models
          livenessProbe:
            httpGet:
              path: /health
              port: 8001
            initialDelaySeconds: 30
            periodSeconds: 10
          readinessProbe:
            httpGet:
              path: /ready
              port: 8001
            initialDelaySeconds: 10
            periodSeconds: 5
      volumes:
        - name: model-storage
          persistentVolumeClaim:
            claimName: ai-models-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: onnx-inference-svc
  namespace: ai-workloads
spec:
  selector:
    app: onnx-inference
  ports:
    - port: 8001
      targetPort: 8001
  type: ClusterIP
```

### GitOps-basert modelloppdatering med Flux

```yaml
# Flux Kustomization for AI-modell deployment
apiVersion: kustomize.toolkit.fluxcd.io/v1
kind: Kustomization
metadata:
  name: ai-models
  namespace: flux-system
spec:
  interval: 5m
  path: ./edge-ai/models
  prune: true
  sourceRef:
    kind: GitRepository
    name: edge-ai-config
  healthChecks:
    - apiVersion: apps/v1
      kind: Deployment
      name: onnx-inference-server
      namespace: ai-workloads
  timeout: 10m
---
# Git-repository som kilde for konfigurasjon
apiVersion: source.toolkit.fluxcd.io/v1
kind: GitRepository
metadata:
  name: edge-ai-config
  namespace: flux-system
spec:
  interval: 1m
  url: https://dev.azure.com/org/project/_git/edge-ai-config
  branch: main
  secretRef:
    name: git-credentials
```

---

## Multi-Node Edge Clusters

### Skalerbar klynge pa tvers av maskiner

```powershell
# Steg 1: Generer multi-node konfigurasjon
New-AksEdgeConfig -DeploymentType ScalableCluster `
  -NodeType Linux `
  -outFile .\multinode-config.json

# Steg 2: Deploy primaer node
New-AksEdgeDeployment -JsonConfigFilePath .\multinode-config.json

# Steg 3: Hent join-token for ekstra noder
$token = Get-AksEdgeNodeJoinToken

# Steg 4: Pa sekundaer maskin — join klyngen
New-AksEdgeScaleConfig -ScaleType AddNode `
  -NodeType Linux `
  -LinuxNodeIp "192.168.1.102" `
  -outFile .\scale-config.json

Add-AksEdgeNode -JsonConfigFilePath .\scale-config.json
```

### Multi-node arkitektur for AI

```
┌─────────────────────────────────────┐
│         Edge AI Cluster             │
│                                     │
│  ┌───────────┐  ┌───────────┐      │
│  │  Node 1   │  │  Node 2   │      │
│  │ (Control  │  │ (Worker)  │      │
│  │  + Worker) │  │           │      │
│  │            │  │ - AI      │      │
│  │ - API      │  │   inferens│      │
│  │   server   │  │ - GPU     │      │
│  │ - etcd     │  │   workload│      │
│  │ - Scheduler│  │           │      │
│  └───────────┘  └───────────┘      │
│         ↕             ↕             │
│     [Flannel/Calico networking]     │
│                                     │
│  ┌───────────┐                      │
│  │  Node 3   │    Azure Arc ←→ Sky  │
│  │ (Worker)  │                      │
│  │           │                      │
│  │ - Data    │                      │
│  │   pipeline│                      │
│  │ - Storage │                      │
│  └───────────┘                      │
└─────────────────────────────────────┘
```

---

## Service Mesh for Edge

### Lettvekts service mesh pa edge

For AI-arbeidsbelastninger pa edge med flere mikrotjenester (inferens, datainntak, API-gateway) kan en lettvekts service mesh gi observabilitet og trafikkstyring:

```yaml
# Envoy-basert sidecar for AI-inferens (lettvekts alternativ)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ai-inference-with-proxy
  namespace: ai-workloads
spec:
  template:
    spec:
      containers:
        # AI-inferens container
        - name: inference
          image: myregistry/anomaly-model:v2
          ports:
            - containerPort: 8080

        # Envoy sidecar for observabilitet
        - name: envoy-proxy
          image: envoyproxy/envoy:v1.28-latest
          ports:
            - containerPort: 9901  # Admin
            - containerPort: 10000 # Ingress
          volumeMounts:
            - name: envoy-config
              mountPath: /etc/envoy
          resources:
            requests:
              memory: "64Mi"
              cpu: "50m"
            limits:
              memory: "128Mi"
              cpu: "100m"
      volumes:
        - name: envoy-config
          configMap:
            name: envoy-edge-config
```

### Canary deployment for modellversjoner

```yaml
# Canary deployment: Gradvis utrulling av ny AI-modell
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ai-inference-canary
  annotations:
    nginx.ingress.kubernetes.io/canary: "true"
    nginx.ingress.kubernetes.io/canary-weight: "20"  # 20% til ny modell
spec:
  rules:
    - host: inference.edge.local
      http:
        paths:
          - path: /predict
            pathType: Prefix
            backend:
              service:
                name: inference-v2  # Ny modellversjon
                port:
                  number: 8080
```

---

## Norsk offentlig sektor

### Distribusjonsstrategi for norske edge-stasjoner

| Stasjon | Antall | Hardware | AKS Edge-konfig | AI-workload |
|---------|--------|----------|-----------------|-------------|
| Veisensorer | ~200 | Industrial PC | Single-node K3s | Trafikk-analyse |
| Tunnelverkaking | ~50 | Rack-server | Multi-node K8s | Brann/ventilasjon |
| Ferjekaier | ~30 | Rugged PC | Single-node K3s | Bildetelling |
| Ladestajoner | ~500 | IoT gateway | K3s minimal | Energi-prediksjon |

### Sikkerhets- og administrasjonskrav

- Azure Arc for sentralisert forvaltning fra Norway East
- GitOps for sporbar og audit-bar deployment
- Network policies for nettverkssegmentering
- Pod security policies/standards for container-isolasjon
- KMS-plugin for kryptering av secrets i etcd

---

## Beslutningsrammeverk

| Scenario | Anbefaling | Begrunnelse |
|----------|------------|-------------|
| Enkelt-enhet AI | AKS Edge Essentials single-node (K3s) | Lavest ressursbruk |
| Multi-workload edge | AKS Edge Essentials single-node (K8s) | Full K8s-kompatibilitet |
| Redundant edge-klynge | AKS Edge multi-node (K8s) | Hoy tilgjengelighet |
| GPU-akselerert AI | AKS Edge + GPU-PV + NVIDIA plugin | Container-basert GPU-inferens |
| Skalerbar fleet-management | AKS Edge + Azure Arc + GitOps | Sentralisert administrasjon |
| Windows + Linux workloads | AKS Edge med bade Linux og Windows VM | Interop-scenarier |

---

## For Cosmo

- **AKS Edge Essentials er den foretrukne loesningen for container-basert AI pa edge** — det gir Kubernetes-standarder pa PC-klasse hardware med minimal fotavtrykk (4 GB RAM for K3s)
- **Azure Arc + GitOps gir sentralisert forvaltning** — anbefal dette for organisasjoner med mange edge-stasjoner som trenger sporbar, automatisert deployment av AI-modeller
- **K3s vs K8s: Velg K3s for enkle AI-scenarier** med 1-3 containere, og K8s nar du trenger full Kubernetes-funksjonalitet som network policies og Pod security standards
- **GPU-PV muliggjor delt GPU-tilgang** mellom Windows-host og Linux VM — bruk dette for edge-servere med NVIDIA GPU som kjorer bade tradisjonelle Windows-applikasjoner og AI-containere
- **For norsk offentlig sektor: AKS Edge + Arc + GitOps gir en standardisert plattform** for AI-deployment pa tvers av etater og lokasjoner — definer felles Helm charts og Flux-konfigurasjoner for a sikre konsistent og revisjonsvennlig deployment