Pod-sandboxning i AKS använder Kata Containers för att köra varje sandboxad podd i en lättviktig virtuell maskin (VM) med en egen gästkärna. Den här beräkningsgränsen isolerar arbetsbelastningen från värdkärnan och arbetsbelastningarna på andra virtuella podddatorer. Mer information om arkitektur, fördelar och användningsfall finns i Översikt över poddsandboxning i Azure Kubernetes Service (AKS).
I den här artikeln distribuerar du pod-sandboxning i ett nytt eller befintligt Azure Linux AKS-kluster, distribuerar ett program med Kata-körmiljön och verifierar eventuellt kärnisolering.
För kluster som använder automatisk nodetablering (NAP) använder du Använd poddsandboxning med automatisk nodetablering i stället för stegen för att skapa nodpooler i Azure CLI.
Att driftsätta pod-sandboxning med Kata Containers liknar standardarbetsflödet runc för att driftsätta containrar. Kluster med poddsandboxning aktiverat levereras med en specifik körningsklass som du kan referera till i ett poddmanifest, runtimeClassName: kata-vm-isolation (GA) eller runtimeClassName: kata-vm-isolation-v2 (förhandsversion). Mer information om standardinställningar för RuntimeClass och anpassning finns i Överväganden för podsandboxning.
Limitations
Följande begränsningar gäller för poddsandboxning med kata-vm-isolation:
- Kata-containrar kanske inte når de IOPS-prestandagränser som traditionella containrar kan nå på Azure Files och lokala SSD med höga prestanda.
-
Microsoft Defender for Containers stöder inte utvärdering av Kata Runtime-poddar.
-
Kata-värdnätverksåtkomst stöds inte. Du kan inte komma åt värdnätverkskonfigurationen direkt från den virtuella poddatorn.
- Processor- och minnesallokering skiljer sig från
runc. Varje Kata-podd körs i en pod-VM vars storlek kommer från poddgränser:
- Pod-sandlådor stöds endast på Azure Linux. Ubuntu, Windows och Azure Container Linux stöds inte. Mer information finns i Azure Linux-containervärd för AKS.
- Du kan inte aktivera FIPS (Federal Information Processing Standard) eller Betrodd start på en nodpool som använder poddsandboxning.
- Arm64-arkitekturen stöds inte för en nodpool som använder Pod-sandlådeteknik.
Prerequisites
- Azure CLI version 2.80.0 eller senare. Kör
az --version för att hitta versionen av Azure CLI och kör az upgrade för att uppgradera. Mer information finns i stegen i Installera Azure CLI.
- AKS stöder poddsandboxning på Kubernetes version 1.27.0 och senare. NAP-etablerade noder för poddsandlådor kräver Kubernetes-version 1.32 eller senare och Azure Linux 3.
- Om du vill hantera ett Kubernetes-kluster använder du Kubernetes-kommandoradsklienten
kubectl. Azure Cloud Shell levereras med kubectl. Du kan installera kubectl lokalt med kommandot az aks install-cli .
Limitations
Följande begränsningar gäller för poddsandboxning med kata-vm-isolation-v2:
-
kata-vm-isolation-v2 är i förhandsversion. Du måste registrera funktionsflaggan KataVMIsolationV2Preview och använda Azure Linux-nodbildversion 202610.30.1 eller senare. Regional distribution kan variera beroende på region. För aktuell tillgänglighet, se AKS-versionsspåraren.
- Kata-containrar kanske inte når de IOPS-prestandagränser som traditionella containrar kan nå på Azure Files och lokala SSD med höga prestanda.
-
Microsoft Defender for Containers stöder inte utvärdering av Kata Runtime-poddar.
-
Kata-värdnätverksåtkomst stöds inte. Du kan inte komma åt värdnätverkskonfigurationen direkt från den virtuella poddatorn.
- Migrering av runtime class är en uttrycklig ändring av arbetsbelastningen. Anta inte att beteendet är identiskt med
kata-vm-isolation för alla arbetsbelastnings- och lagringsmönster.
- För
emptyDir volymer anger medium: Memory du uttryckligen och sizeLimit i poddspecifikationen. Mer information finns i Överväganden för poddsandboxning.
- Processor- och minnesstorleksbeteendet kan skilja sig från
kata-vm-isolation och kata-vm-isolation-v2 när du initierar den virtuella malldatorn med DaemonSet i kata-vm-isolation-v2. När mallen har initierats får varje v2-podd en gäst med 2 GiB och 2 vCPU oavsett poddbegränsningar. Mer information om minnesstorlek och information om overhead finns i RuntimeClass-minnesoverhead.
- Pod-sandlådor stöds endast på Azure Linux. Ubuntu, Windows och Azure Container Linux stöds inte. Mer information finns i Azure Linux-containervärd för AKS.
- Du kan inte aktivera FIPS (Federal Information Processing Standard) eller Betrodd start på en nodpool som använder poddsandboxning.
- Arm64-arkitekturen stöds inte för en nodpool som använder Pod-sandlådeteknik.
-
Automatisk etablering av noder (NAP) stöds inte med
kata-vm-isolation-v2.
Använd kata-vm-isolation-v2 (förhandsversion)
Important
AKS-förhandsversionsfunktioner är tillgängliga via självbetjäning och frivillig registrering. Förhandsversioner tillhandahålls "i befintligt skick" och "i mån av tillgång," och de är undantagna från servicenivåavtal och begränsad garanti. AKS-förhandsversioner stöds delvis av kundsupport efter bästa förmåga. Därför är dessa funktioner inte avsedda för produktionsanvändning. Mer information finns i följande supportartiklar:
Körningsklassen kata-vm-isolation-v2 är tillgänglig i förhandsversionen. Information om fördelarna med den och en jämförelse med v1 finns i Förbättringar i Runtime class v2. Mer information om minnesstorlek och overhead-detaljer finns i Minnesoverhead för RuntimeClass.
Important
Nodpoolen använder --workload-runtime KataVmIsolation fortfarande för båda körningsklasserna. V1/v2-valet görs i varje arbetsbelastningsmanifest via runtimeClassName.
Förutsättningar för kata-vm-isolation-v2
Innan du använder kata-vm-isolation-v2, bekräfta att alla följande förutsättningar är uppfyllda:
- Azure CLI version 2.80.0 eller senare.
-
kubectl är installerat och konfigurerat för ditt kluster.
- Funktionen
KataVMIsolationV2Preview är registrerad för din prenumeration.
- Klustret kör Kubernetes version 1.34.0 eller senare.
- Nodpoolen för sandbox-målpodden använder Azure Linux-nodbildversion
202610.30.1 eller senare. Regional distribution kan variera beroende på region. För aktuell tillgänglighet, se AKS-versionsspåraren.
-
kata-vm-isolation-v2 stöder virtuella V6- och v7-SKU:er i dessa familjer: Dasv6, Dadsv6, Dalsv6, Daldsv6, Easv6, Eadsv6, Falsv6, Fasv6 och Famsv6.
Registrera funktionsflaggan KataVMIsolationV2Preview
Registrera funktionsflaggan KataVMIsolationV2Preview med kommandot az feature register.
az feature register \
--namespace "Microsoft.ContainerService" \
--name "KataVMIsolationV2Preview"
Verifiera registreringsstatusen az feature show med hjälp av kommandot .
az feature show \
--namespace "Microsoft.ContainerService" \
--name "KataVMIsolationV2Preview"
När statusen visas Registrerad uppdaterar du registreringen av Microsoft. ContainerService-resursprovider med hjälp az provider register av kommandot .
az provider register --namespace "Microsoft.ContainerService"
Skapa ett kluster med Pod-sandlådeteknik
Utför följande steg för att distribuera ett Azure Linux AKS-kluster med hjälp av Azure CLI.
Skapa ett AKS-kluster genom att az aks create köra kommandot med följande parametrar:
| Parameter |
Obligatoriskt värde |
Noteringar |
--workload-runtime |
KataVmIsolation |
Aktiverar sandboxning av poddar för nodpoolen. |
--os-sku |
AzureLinux |
Pod-sandboxning har endast stöd för Azure Linux OS-SKU:n. |
--node-vm-size |
En vm-storlek av generation 2 som stöder kapslad virtualisering |
Använd till exempel Standard_D4ads_v6. |
--node-count |
3 |
Skapar tre noder för det här exemplet. Justera värdet för din arbetsbelastning. |
| Parameter |
Obligatoriskt värde |
Noteringar |
--workload-runtime |
KataVmIsolation |
Aktiverar sandboxning av poddar för nodpoolen. |
--os-sku |
AzureLinux |
Pod-sandboxning har endast stöd för Azure Linux OS-SKU:n. |
--node-vm-size |
En vm-storlek av generation 2 som stöder kapslad virtualisering |
Använd till exempel Standard_D4ads_v6. |
--node-count |
3 |
Skapar tre noder för det här exemplet. Justera värdet för din arbetsbelastning. |
I följande exempel skapas ett kluster med namnet myAKSCluster med tre noder i myResourceGroup:
az aks create \
--name myAKSCluster \
--resource-group myResourceGroup \
--os-sku AzureLinux \
--workload-runtime KataVmIsolation \
--node-vm-size Standard_D4ads_v6 \
--node-count 3 \
--generate-ssh-keys
Kör följande kommando för att hämta autentiseringsuppgifter för Kubernetes-klustret.
az aks get-credentials Använd kommandot och ersätt värdena för klusternamnet och resursgruppens namn.
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
Visa en lista över alla poddar i alla namnområden genom att kubectl get pods köra kommandot .
kubectl get pods --all-namespaces
Aktivera Pod-sandboxning i ett befintligt kluster
Om du vill använda den här funktionen med ett befintligt AKS-kluster måste följande krav uppfyllas:
Lägg till en nodpool i AKS-klustret med hjälp az aks nodepool add av kommandot med följande parametrar:
| Parameter |
Obligatoriskt värde |
Noteringar |
--resource-group |
Resursgruppen som innehåller det befintliga AKS-klustret |
Använd till exempel myResourceGroup. |
--cluster-name |
Namnet på det befintliga AKS-klustret |
Använd till exempel myAKSCluster. |
--name |
Ett unikt namn på nodpoolen |
Använd till exempel nodepool2. |
--workload-runtime |
KataVmIsolation |
Aktiverar sandboxning av poddar för nodpoolen. |
--os-sku |
AzureLinux |
Pod-sandboxning har endast stöd för Azure Linux OS-SKU:n. |
--node-vm-size |
En vm-storlek av generation 2 som stöder kapslad virtualisering |
Använd till exempel Standard_D4ads_v6. |
--node-count |
1 |
Skapar en nod för det här exemplet. Justera värdet för din arbetsbelastning. |
I följande exempel läggs en nodpool till i myAKSCluster med en nod i nodepool2 i myResourceGroup:
az aks nodepool add --cluster-name myAKSCluster --resource-group myResourceGroup --name nodepool2 --os-sku AzureLinux --workload-runtime KataVmIsolation --node-vm-size Standard_D4ads_v6 --node-count 1
Kontrollera att nodpoolen har lagts till och att nodpoolen för poddsandboxning använder förväntad arbetsbelastningskörning, OS SKU och VM-storlek.
az aks show \
--name myAKSCluster \
--resource-group myResourceGroup \
--query provisioningState \
--output tsv
az aks nodepool show \
--cluster-name myAKSCluster \
--resource-group myResourceGroup \
--name nodepool2 \
--query "{workloadRuntime:workloadRuntime, osSku:osSku, vmSize:vmSize}" \
--output table
Klusteretableringstillståndet ska vara Succeeded. Nodpoolens utdata ska visa KataVmIsolation, AzureLinuxoch den VM-storlek som du har valt.
NAP stöder sandboxning av poddar genom fältet spec.workloadRuntime på en AKSNodeClass. Använd en Karpenter NodePool som refererar till den här klassen för att etablera noder för Kata-arbetsbelastningar i stället för att skapa en Azure CLI hanterad nodpool med az aks nodepool add.
Förutsättningar för NAP
- Aktivera NAP i klustret. Anvisningar för konfigurering finns i Aktivera automatisk nodetablering.
- Använd Kubernetes version 1.32 eller senare. NAP kräver Azure Linux 3 för den Kata-aktiverade avbildningen.
- Ange
imageFamily: AzureLinux och workloadRuntime: KataVmIsolation på AKSNodeClass. Aktivera inte FIPS eller betrodd start.
- Tillåt kompatibla VM-storlekar för AMD64, generation 2 i dina
NodePool behov. Karpenter filtrerar automatiskt fram virtualiseringskompatibla storlekar och väljer den Kata-aktiverade avbildningen. Du behöver inte ange en VM-storlek eller lägga till arkitektur- och genereringskrav för att aktivera den här filtreringen.
Skapa NAP-resurserna och verifiera körningsklassen innan du distribuerar en arbetsbelastning.
Spara följande manifest som kata-nap.yaml.
NodePool refererar till den Kata-aktiverade AKSNodeClass. Etiketten Cilium och starttaint följer konfigurationen av NAP-nodpoolen för kluster som använder Cilium.
apiVersion: karpenter.azure.com/v1beta1
kind: AKSNodeClass
metadata:
name: kata
spec:
imageFamily: AzureLinux
workloadRuntime: KataVmIsolation
---
apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
name: kata
spec:
template:
metadata:
labels:
kubernetes.azure.com/ebpf-dataplane: cilium
spec:
nodeClassRef:
group: karpenter.azure.com
kind: AKSNodeClass
name: kata
startupTaints:
- key: node.cilium.io/agent-not-ready
effect: NoExecute
value: "true"
requirements:
- key: kubernetes.io/os
operator: In
values: ["linux"]
- key: karpenter.sh/capacity-type
operator: In
values: ["on-demand"]
Om klustret inte använder Cilium utelämnar du kubernetes.azure.com/ebpf-dataplane: cilium etiketten och starttainten node.cilium.io/agent-not-ready .
Använd resurserna:
kubectl apply -f kata-nap.yaml
kubectl get aksnodeclass kata
kubectl get nodepool kata
Kontrollera att den AKS-hanterade kata-vm-isolation körningsklassen är tillgänglig:
kubectl get runtimeclass kata-vm-isolation -o yaml
Körningsklassen anger schemaläggningsselektorn kubernetes.azure.com/kata-vm-isolation: "true". När du skapar en podd som refererar till den här körningsklassen lägger Kubernetes till väljaren och omkostnader för körning i podden. Karpenter identifierar selectorn när den tillhandahåller kompatibla noder och tar hänsyn till runtime-overhead vid bin-packning. Du behöver inte lägga till Kata-väljaren manuellt.
Distribuera och verifiera en NAP-hanterad Kata-arbetsbelastning
Distribuera en podd som begär Kata-körningen för att utlösa provisionering.
Spara följande manifest som kata-nap-app.yaml. Ange resursbegäranden och begränsningar för att ta hänsyn till din arbetsbelastning och pod-VM:ens gästkomponenter. Vägledning för dimensionering finns i Överväganden för poddsandboxning.
apiVersion: v1
kind: Pod
metadata:
name: nap-isolated-pod
spec:
runtimeClassName: kata-vm-isolation
containers:
- name: kata
image: mcr.microsoft.com/aks/fundamental/base-ubuntu:v0.0.11
command: ["/bin/sh", "-ec", "while :; do echo '.'; sleep 5; done"]
resources:
requests:
cpu: 100m
memory: 256Mi
limits:
cpu: "1"
memory: 512Mi
runtimeClassName är tillräckligt för att välja Kata-kompatibla noder. Om du vill rikta in dig på den här specifika Karpenter NodePoollägger du till följande i poddspecifikationen:
nodeSelector:
karpenter.sh/nodepool: kata
Tillämpa poddmanifestet och vänta tills podden blir redo:
kubectl apply -f kata-nap-app.yaml
kubectl wait --for=condition=Ready pod/nap-isolated-pod --timeout=10m
Karpenter provisionerar en kompatibel nod om den befintliga kapaciteten inte kan hantera podden. Inställningen workloadRuntime: KataVmIsolation aktiverar ytterligare en runtime. Standardpoddar kan fortfarande köras på samma nod utan VM-isolering.
Kontrollera att podden körs på en Kata-aktiverad, NAP-hanterad nod:
kubectl get nodes -l 'karpenter.sh/nodepool=kata,kubernetes.azure.com/kata-vm-isolation=true'
kubectl get pod nap-isolated-pod -o wide
kubectl exec nap-isolated-pod -- uname -r
kubectl get node "$(kubectl get pod nap-isolated-pod -o jsonpath='{.spec.nodeName}')" \
-o jsonpath='{.status.nodeInfo.kernelVersion}{"\n"}'
Poddens gästkärna skiljer sig från nodens värdkärna. För en annan jämförelse med en standardpodd, se Verifiera kernelisolering.
För fältstandarder, kompatibilitetsbegränsningar och effekten av att ändra körningen på befintliga noder, se Körning av arbetsbelastning och Pod-sandboxning.
Distribuera applikationer med Pod-sandboxning
Genom att använda poddsandboxning kan du driftsätta en blandning av standardpoddar som inte använder Kata-runtime samt Kata-poddar som använder den.
Runtimeklassen väljer Kata-runtime, men du bör också ange schemaläggningsbegränsningar när arbetsbelastningar måste köras i en specifik nodpool för Pod-sandboxning. För en Azure CLI-hanterad nodpool använder du den inbyggda AKS-nodpoolsetiketten i en nodeSelector. Ersätt nodepool2 med namnet på poddens sandbox-nodpool. För en NAP-hanterad nodpool använder du karpenter.sh/nodepool i stället, som du ser i NAP-genomgången.
spec:
runtimeClassName: kata-vm-isolation
nodeSelector:
kubernetes.azure.com/agentpool: nodepool2
För en starkare separation kan du taint nodpoolen för poddsandboxning och lägga till en matchande tolerans i Kata-arbetsbelastningar. En taint utan en matchande toleration förhindrar att andra arbetsbelastningar schemaläggs på den nodpoolen. Mer information finns i Använda nodtaints i ett AKS-kluster.
Distribuera en applikation med Kata runtime
Utför följande steg för att driftsätta en podd med Kata runtime på ditt AKS-kluster.
Skapa en fil med namnet kata-app.yaml för att beskriva din Kata-podd och klistra sedan in följande manifest.
kind: Pod
apiVersion: v1
metadata:
name: isolated-pod
spec:
runtimeClassName: kata-vm-isolation
containers:
- name: kata
image: mcr.microsoft.com/aks/fundamental/base-ubuntu:v0.0.11
command: ["/bin/sh", "-ec", "while :; do echo '.'; sleep 5 ; done"]
Driftsätt podden i Kubernetes genom att köra kommandot kubectl apply och ange filen kata-app.yaml:
kubectl apply -f kata-app.yaml
Kommandots utdata liknar följande exempel:
pod/isolated-pod created
Distribuera applikationer med Pod-sandboxning
Använd följande steg för att köra en ny arbetsbelastning med runtimeClassName: kata-vm-isolation-v2. För en befintlig v1-arbetsbelastning följer du migreringsinstruktionerna i stället.
Distribuera ett program med Kata-körningen (kata-vm-isolation-v2)
Bekräfta att målnodpoolen för poddsandbox-miljön uppfyller kraven (Kubernetes 1.34.0 eller senare och Azure Linux-nodbildversion 202610.30.1 eller senare).
Kontrollera körningsklassen och nodetiketten med hjälp av stegen i Verifiera körningsklassen och nodetiketten.
Skapa en fil med namnet kata-v2-app.yaml med följande manifest.
apiVersion: v1
kind: Pod
metadata:
name: isolated-pod-v2
spec:
runtimeClassName: kata-vm-isolation-v2
containers:
- name: kata
image: mcr.microsoft.com/aks/fundamental/base-ubuntu:v0.0.11
command: ["/bin/sh", "-ec", "while :; do echo '.'; sleep 5 ; done"]
Distribuera podden och kontrollera att den använder förhandsgranskningskörningsklassen:
kubectl apply -f kata-v2-app.yaml
kubectl wait --for=condition=Ready pod/isolated-pod-v2 --timeout=120s
kubectl get pod isolated-pod-v2 -o jsonpath='{.spec.runtimeClassName}'
Det sista kommandot ska returnera kata-vm-isolation-v2.
Important
Om du har skapat ett nytt kluster med en nodpool som stöder --workload-runtime KataVmIsolation bör körningsklassen visas automatiskt. Men om du har lagt till en ny nodpool i ett befintligt kluster kan det ta några minuter att uppdatera klustret och lägga till körningsklassen kata-vm-isolation-v2 .
Skapa sandlådade poddar från en pausad, förinitierad virtuell malldator (kata-vm-isolation-v2 förhandsversion)
kata-vm-isolation-v2 skapar nya sandbox-poddar genom att klona från en pausad, förinitierad virtuell malldator i stället för att kallstarta varje virtuell podddator.
Bekräfta följande begränsningar och krav innan du använder den här sökvägen:
- Arbetsbelastningen använder
runtimeClassName: kata-vm-isolation-v2.
- Målnodpoolen kör Azure Linux-nodbildversion
202610.30.1 eller senare. Regional distribution kan variera beroende på region. För aktuell tillgänglighet, se AKS-versionsspåraren.
- Du initierar den virtuella malldatorn på varje kvalificerad nod.
- I den aktuella förhandsversionen kan mallen efter mallinitiering använda en fast gäst-VM-storlek med 2 GiB minne och 2 vCPU. Håll resursbegäranden och begränsningar för poddar i linje med varandra och verifiera schemaläggningsbeteendet för din arbetsbelastning.
Important
Init-containern kör kata-ctl factory init som rot på noden, granska med ditt säkerhetsteam innan du distribuerar.
Om du vill initiera mall-VM:n på varje nod kan du använda en DaemonSet, till exempel följande:
apiVersion: apps/v1
kind: DaemonSet
metadata:
name: kata-v2-factory-init
namespace: kube-system
spec:
selector:
matchLabels:
app.kubernetes.io/name: kata-v2-factory-init
template:
metadata:
labels:
app.kubernetes.io/name: kata-v2-factory-init
spec:
automountServiceAccountToken: false
hostPID: true
nodeSelector:
kubernetes.io/os: linux
kubernetes.azure.com/kata-vm-isolation-v2: "true"
initContainers:
- name: factory-init
image: mcr.microsoft.com/azurelinux/base/core:3.0
command:
- /bin/bash
- -ec
- |
tdnf install -y util-linux
exec /usr/bin/nsenter "$@"
- kata-v2-factory-bootstrap
- --target=1
- --mount
- --uts
- --ipc
- --net
- --pid
- --root=/proc/1/root
- --wd=/
- --
- /bin/bash
- -ec
- |
config=$1
template=$2
lock=$3
test -r "$config"
command -v kata-ctl >/dev/null
exec 9>"$lock"
flock --exclusive 9
if test -f "$template/memory" &&
test -f "$template/state.json" &&
test -f "$template/config.json"; then
printf 'Factory template already exists at %s\n' "$template"
exit 0
fi
if mountpoint -q "$template" ||
{ test -d "$template" && test -n "$(ls -A "$template")"; }; then
printf 'Incomplete factory at %s; inspect and clean up manually before retrying.\n' "$template" >&2
exit 1
fi
kata-ctl --config "$config" factory init
- kata-v2-factory-init
- /usr/share/defaults/kata-containers/configuration-clh-azure-runtime-rs-v2.toml
- /run/vc/vm/template
- /run/kata-v2-factory-init.lock
securityContext:
privileged: true
runAsUser: 0
resources:
requests:
cpu: 100m
memory: 128Mi
containers:
- name: initialized
image: registry.k8s.io/pause:3.10
securityContext:
allowPrivilegeEscalation: false
readOnlyRootFilesystem: true
runAsNonRoot: true
runAsUser: 65534
capabilities:
drop:
- ALL
seccompProfile:
type: RuntimeDefault
resources:
requests:
cpu: 1m
memory: 4Mi
limits:
memory: 16Mi
Migrera arbetsbelastningar mellan körningsklasser
Innan du migrerar granskar du migreringsöverväganden för körningsklass och v2-begränsningar. Använd de här stegen för att migrera en befintlig arbetsbelastning från kata-vm-isolation (v1) till kata-vm-isolation-v2 (förhandsversion):
- Slutför förhandsversionskraven för v2 och funktionsregistreringen. Om din befintliga nodpool inte använder en vm-storlek och nodavbildning som stöds, och om du skapade den före funktionsregistreringen, kan du behöva återskapa den.
- Kontrollera att körningsklassen finns genom att köra
kubectl get runtimeclass kata-vm-isolation-v2.
- Ändra
runtimeClassName: kata-vm-isolation till runtimeClassName: kata-vm-isolation-v2 i arbetsbelastningsmanifestet. Uppdatera poddmallen för en Deployment eller en annan styrenhetshanterad arbetsbelastning.
- Använd det uppdaterade styrenhetsmanifestet så att styrenheten skapar ersättningspoddar. För en fristående podd tar du bort den befintliga podden och återskapar den från det uppdaterade manifestet. Du kan inte ändra
runtimeClassName på en befintlig podd. Planera för eventuella avbrott i arbetsbelastningen innan du ersätter poddar.
- Kontrollera att ersättningspoddarna är klara och att deras
spec.runtimeClassNamestatus är kata-vm-isolation-v2. Verifiera lagrings- och monteringsbeteende, startlatens och resursanvändning i en förproduktionsmiljö före bred distribution. För minnesbaserade volymer, följ emptyDir.
- Om du hittar kompatibilitetsproblem, återställer du genom att återställa
runtimeClassName: kata-vm-isolation i manifestet och ersätta poddarna genom samma process.
Troubleshooting
Kontrollera körningsklassen och nodetiketten
Kontrollera att v2-körningsklassen finns:
kubectl get runtimeclass kata-vm-isolation-v2
Om körningsklassen saknas kan du kontrollera funktionsregistreringen igen, köra az aks update, vänta tills avstämningen har slutförts och köra kommandot igen.
Kontrollera att noderna i sandbox-målpoolen för poddar har Kata-körningsetiketten. Ersätt nodepool2 med namnet på nodpoolen:
kubectl get nodes \
-l kubernetes.azure.com/agentpool=nodepool2 \
-o 'custom-columns=NAME:.metadata.name,KATA_V2:.metadata.labels.kubernetes.azure.com/kata-vm-isolation-v2'
Om etiketten saknas kontrollerar du att nodpoolen uppfyller kraven för v2 (VM SKU som stöds, nödvändig Kubernetes-version och Azure Linux-nodavbildningsversion 202610.30.1 eller senare). Uppgradera sedan nodbilden (az aks nodepool upgrade --node-image-only) och kontrollera igen. Om etiketten fortfarande saknas återskapa nodpoolen med nödvändiga förutsättningar.
Kontrollera vilken körningsklass dina arbetsbelastningar använder (valfritt)
Om du är osäker på vilken körningsklass som används i dina poddar kan du kontrollera genom att visa en lista över körningsklassen som valts av varje podd i alla namnområden:
kubectl get pods --all-namespaces \
-o 'custom-columns=NAMESPACE:.metadata.namespace,POD:.metadata.name,RUNTIMECLASS:.spec.runtimeClassName'
I kolumnen RUNTIMECLASS identifierar kata-vm-isolation v1-poddar och kata-vm-isolation-v2 identifierar v2-förhandsgranskningspoddar.
<none> Värdet innebär att podden inte anger runtimeClassName och använder nodens standardruntime. En lista över tillgängliga RuntimeClass resurser visar inte vilken körningsklass dina arbetsbelastningar väljer.
Stämma av klusterkonfiguration efter att ha lagt till en nodpool för Pod-sandboxing (valfritt)
I de flesta fall räcker az aks nodepool add och inget extra avstämningssteg krävs. Om körningsklassen eller nodetiketterna inte visas som förväntat när du har lagt till en nodpool för poddsandboxning kör az aks update du och kontrollerar sedan igen.
az aks update --name myAKSCluster --resource-group myResourceGroup
Verifiera kernelisolering (valfritt)
Det här avsnittet använder Kata-podden isolated-pod (runtimeClassName: kata-vm-isolation) som du skapade i Distribuera ett program med Kata-körningen. Om du inte distribuerade podden distribuerar du den nu.
Om du vill jämföra kärnorna i Kata- och icke-Kata-poddar skapar du en fil med namnet normal-app.yaml. Följande manifest definierar en standardpodd utan Kata-körmiljön:
kind: Pod
apiVersion: v1
metadata:
name: normal-pod
spec:
containers:
- name: non-kata
image: mcr.microsoft.com/aks/fundamental/base-ubuntu:v0.0.11
command: ["/bin/sh", "-ec", "while :; do echo '.'; sleep 5 ; done"]
Driftsätt standardpodden med kommandot kubectl apply.
kubectl apply -f normal-app.yaml
Om du vill komma åt en container i AKS-klustret startar du en shell-session genom att kubectl exec köra kommandot . I det här exemplet får du åtkomst till containern i isolated-pod.
kubectl exec -it isolated-pod -- /bin/sh
Kubectl ansluter sig till klustret och kör /bin/sh inuti den första containern i isolated-pod och vidarebefordrar terminalens indata- och utdataströmmar till containerns process. Du kan också starta en shell-session i containern som är värd för den icke-Kata-podden för att se skillnaderna.
När du har startat en shell-session till containern från isolerad podd kör du kommandon för att kontrollera att kata-containern körs i en poddsandlåda. Den har en annan kernelversion än containern som inte är Kata utanför sandbox-miljön.
Om du vill se kernelversionen kör du följande kommando:
uname -r
Följande exempel liknar utdata från poddens sandbox-kernel:
[user]/# uname -r
6.6.96.mshv1
Starta en shell-session till containern från normal-pod för att verifiera kernel-utdata:
kubectl exec -it normal-pod -- /bin/bash
Om du vill se kernelversionen kör du följande kommando:
uname -r
Följande exempel liknar utdata från den virtuella dator som kör normal-podd, vilket är en annan kernel än Kata-podden som körs i poddens sandbox-miljö:
6.6.100.mshv1-1.azl3
Rensa resurser
När du har utvärderat den här funktionen rensar du resurser som du inte längre behöver för att undvika Azure avgifter. Om du har distribuerat ett nytt kluster som en del av utvärderingen kör du följande az aks delete kommando för att ta bort AKS-klustret.
az aks delete --resource-group myResourceGroup --name myAKSCluster
Om du har driftsatt podsandboxning i ett befintligt kluster, kan du ta bort poddar med kommandot kubectl delete pod.
kubectl get pods
kubectl delete pod <kata-pod-name>
Om du har följt NAP-genomgången tar du bort dess arbetsbelastning och NAP-resurser. Om du tar bort Karpenter NodePool avslutas även dess noder, så se först till att inga arbetsbelastningar som du vill behålla körs på dem.
kubectl delete -f kata-nap-app.yaml
kubectl delete nodepool kata
kubectl delete aksnodeclass kata
Om du vill ta bort en Azure CLI-managed nodpool för poddsandboxning använder du kommandot az aks nodepool delete. Innan du tar bort nodpoolen kontrollerar du att inga arbetsbelastningar som du vill behålla körs på den.
az aks nodepool delete \
--cluster-name myAKSCluster \
--resource-group myResourceGroup \
--name nodepool2
Nästa steg
- Läs mer om Azure Dedicated-värdar för noder med ditt AKS-kluster för att använda maskinvaruisolering och kontroll över Azure-plattformsunderhållshändelser.
- Om du vill fördjupa dig ytterligare i isoleringen med poddsandboxning och utforska arbetsbelastningsscenarier kan du prova laborationsövningarna för poddsandboxning.