Skapa och hantera flera nodpooler för ett kluster i Azure Kubernetes Service (AKS)

I Azure Kubernetes Service (AKS) grupperas noder i samma konfiguration tillsammans i nodpooler. Dessa nodpooler innehåller de underliggande virtuella datorer som kör dina program. Det första antalet noder och deras storlek (SKU) definieras när du skapar ett AKS-kluster, vilket skapar en systemnodpool. För att stödja program som har olika beräknings- eller lagringskrav kan du skapa ytterligare användarnodpooler. Systemnodpooler har det primära syftet att vara värd för kritiska systempoddar, till exempel CoreDNS och tunnelfront. Användarnodpooler är det primära syftet med att vara värd för dina programpoddar. Programpoddar kan dock schemaläggas i systemnodpooler om du bara vill ha en pool i ditt AKS-kluster. Användarnodpooler är den plats där du placerar dina programspecifika poddar. Använd till exempel dessa ytterligare användarnodpooler för att tillhandahålla GPU:er för beräkningsintensiva program eller åtkomst till högpresterande SSD-lagring.

Den här artikeln visar hur du skapar och hanterar flera nodpooler i ett AKS-kluster.

Innan du börjar

Azure CLI version 2.2.0 eller senare måste vara installerat och konfigurerat. Kör az --version för att hitta versionen. Om du behöver installera eller uppgradera kan du läsa Installera Azure CLI.

Begränsningar

Följande begränsningar gäller när du skapar och hanterar AKS-kluster som stöder flera nodpooler:

• Se Kvoter, storleksbegränsningar för virtuella datorer och regionstillgänglighet i Azure Kubernetes Service (AKS).
• Du kan ta bort systemnodpooler, förutsatt att du har en annan systemnodpool att ta över i AKS-klustret.
• Systempooler måste innehålla minst en nod och användarnodpooler kan innehålla noll eller flera noder.
• AKS-klustret måste använda standard-SKU-lastbalanserare för att använda flera nodpooler. Funktionen stöds inte med Basic SKU-lastbalanserare.
• AKS-klustret måste använda VM-skalningsuppsättningar för noderna.
• Du kan inte ändra VM-storleken på en nodpool när du har skapat den.
• Namnet på en nodpool får bara innehålla gemener alfanumeriska tecken och måste börja med en gemen. För Linux-nodpooler måste längden vara mellan 1 och 12 tecken, för Windows-nodpooler måste längden vara mellan 1 och 6 tecken.
• Alla nodpooler måste finnas i samma virtuella nätverk.
• När du skapar flera nodpooler när klustret skapas måste alla Kubernetes-versioner som används av nodpooler matcha den version som angetts för kontrollplanet. Detta kan uppdateras när klustret har etablerats med hjälp av åtgärder per nodpool.

Skapa ett AKS-kluster

Kom igång genom att skapa ett AKS-kluster med en enda nodpool. I följande exempel används kommandot az group create för att skapa en resursgrupp med namnet myResourceGroup i regionen eastus. Ett AKS-kluster med namnet myAKSCluster skapas sedan med kommandot az aks create.

# Create a resource group in East US
az group create --name myResourceGroup --location eastus

# Create a basic single-node AKS cluster
az aks create \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --vm-set-type VirtualMachineScaleSets \
    --node-count 2 \
    --generate-ssh-keys \
    --load-balancer-sku standard

Det tar några minuter att skapa klustret.

När klustret är klart använder du kommandot az aks get-credentials för att hämta autentiseringsuppgifterna för klustret för användning med kubectl :

az aks get-credentials --resource-group myResourceGroup --name myAKSCluster

Lägga till en nodpool

Klustret som skapades i föregående steg har en enda nodpool. Nu ska vi lägga till en andra nodpool med kommandot az aks nodepool add. I följande exempel skapas en nodpool med namnet mynodepool som kör 3 noder:

az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name mynodepool \
    --node-count 3

Om du vill se status för dina nodpooler använder du kommandot az aks node pool list och anger resursgruppen och klusternamnet:

az aks nodepool list --resource-group myResourceGroup --cluster-name myAKSCluster

Följande exempelutdata visar att mynodepool har skapats med tre noder i nodpoolen. När AKS-klustret skapades i föregående steg skapades en standardnodpool1 med antalet noder på 2.

[
  {
    ...
    "count": 3,
    ...
    "name": "mynodepool",
    "orchestratorVersion": "1.15.7",
    ...
    "vmSize": "Standard_DS2_v2",
    ...
  },
  {
    ...
    "count": 2,
    ...
    "name": "nodepool1",
    "orchestratorVersion": "1.15.7",
    ...
    "vmSize": "Standard_DS2_v2",
    ...
  }
]

Lägga till en nodpool med ett unikt undernät (förhandsversion)

En arbetsbelastning kan kräva delning av ett klusters noder i separata pooler för logisk isolering. Den här isoleringen kan stödjas med separata undernät som är dedikerade till varje nodpool i klustret. Detta kan hantera krav som att ha ett icke-sammanhängande adressutrymme för virtuella nätverk som ska delas upp mellan nodpooler.

Begränsningar

• Alla undernät som tilldelats till nodepools måste tillhöra samma virtuella nätverk.
• Systempoddar måste ha åtkomst till alla noder/poddar i klustret för att kunna tillhandahålla kritiska funktioner som DNS-upplösning och tunneling av kubectl-loggar/exec/port-forward proxy.
• Om du expanderar ditt virtuella nätverk när du har skapat klustret måste du uppdatera klustret (utföra alla hanterade klusteråtgärder men nodpoolåtgärder räknas inte) innan du lägger till ett undernät utanför den ursprungliga cidr-cidr. AKS kommer att få ett felmeddelande om agentpoolens tillägg nu, även om vi ursprungligen tillät det. Om du inte vet hur du ska stämma av ditt kluster kan du skapa en supportbiljett.
• Det finns inte stöd för Nätverksprincip förCoco.
• Azure Network Policy stöds inte.
• Kube-proxy förväntar sig en enda sammanhängande cidr och använder den för tre optmizations. Se denna K.E.P. och --cluster-cidr här för mer information. I Azure cni ges din första nodpools undernät till kube-proxy.

Om du vill skapa en nodpool med ett dedikerat undernät skickar du undernätets resurs-ID som en extra parameter när du skapar en nodpool.

az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name mynodepool \
    --node-count 3 \
    --vnet-subnet-id <YOUR_SUBNET_RESOURCE_ID>

Uppgradera en nodpool

Kommandona i det här avsnittet förklarar hur du uppgraderar en enskild specifik nodpool. Relationen mellan uppgradering av Kubernetes-versionen av kontrollplanet och nodpoolen beskrivs i avsnittet nedan.

Eftersom det finns två nodpooler i det här exemplet måste vi använda az aks nodepool upgrade för att uppgradera en nodpool. Om du vill se tillgängliga uppgraderingar använder du az aks get-upgrades

az aks get-upgrades --resource-group myResourceGroup --name myAKSCluster

Nu ska vi uppgradera mynodepool. Använd kommandot az aks nodepool upgrade för att uppgradera nodpoolen, som du ser i följande exempel:

az aks nodepool upgrade \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name mynodepool \
    --kubernetes-version KUBERNETES_VERSION \
    --no-wait

Visa status för dina nodpooler igen med kommandot az aks node pool list. I följande exempel visas att mynodepool är i uppgraderingstillstånd för att KUBERNETES_VERSION:

az aks nodepool list -g myResourceGroup --cluster-name myAKSCluster

[
  {
    ...
    "count": 3,
    ...
    "name": "mynodepool",
    "orchestratorVersion": "KUBERNETES_VERSION",
    ...
    "provisioningState": "Upgrading",
    ...
    "vmSize": "Standard_DS2_v2",
    ...
  },
  {
    ...
    "count": 2,
    ...
    "name": "nodepool1",
    "orchestratorVersion": "1.15.7",
    ...
    "provisioningState": "Succeeded",
    ...
    "vmSize": "Standard_DS2_v2",
    ...
  }
]

Det tar några minuter att uppgradera noderna till den angivna versionen.

Som bästa praxis bör du uppgradera alla nodpooler i ett AKS-kluster till samma Kubernetes-version. Standardbeteendet för az aks upgrade är att uppgradera alla nodpooler tillsammans med kontrollplanet för att uppnå den här justeringen. Med möjligheten att uppgradera enskilda nodpooler kan du utföra en löpande uppgradering och schemalägga poddar mellan nodpooler för att upprätthålla programmets drifttid inom ovanstående begränsningar.

Uppgradera ett klusterkontrollplan med flera nodpooler

Ett AKS-kluster har två klusterresursobjekt med associerade Kubernetes-versioner.

1. En Kubernetes-version för klusterkontrollplanet.
2. En nodpool med en Kubernetes-version.

Ett kontrollplan mappar till en eller flera nodpooler. Beteendet för en uppgraderingsåtgärd beror på vilket Azure CLI-kommando som används.

Uppgradering av ett AKS-kontrollplan kräver att du använder az aks upgrade . Det här kommandot uppgraderar kontrollplanets version och alla nodpooler i klustret.

När kommandot az aks upgrade utfärdas med flaggan --control-plane-only uppgraderas endast kontrollplanet för klustret. Ingen av de associerade nodpoolerna i klustret ändras.

Uppgradering av enskilda nodpooler kräver att du använder az aks nodepool upgrade . Det här kommandot uppgraderar endast målnodpoolen med den angivna Kubernetes-versionen

Verifieringsregler för uppgraderingar

Giltiga Kubernetes-uppgraderingar för ett klusters kontrollplan och nodpooler verifieras av följande regeluppsättningar.

• Regler för giltiga versioner för uppgradering av nodpooler:

  • Nodpoolversionen måste ha samma huvudversion som kontrollplanet.
  • Delversionen av nodpoolen måste finnas i två mindre versioner av kontrollplansversionen.
  • Nodpoolversionen får inte vara större än major.minor.patch kontrollversionen.

• Regler för att skicka en uppgraderingsåtgärd:

  • Du kan inte nedgradera kontrollplanet eller en Kubernetes-version för en nodpool.
  • Om ingen Kubernetes-version anges för en nodpool beror beteendet på den klient som används. Deklarationen i Resource Manager-mallarna faller tillbaka på den befintliga version som definierats för nodpoolen om den används, om ingen har angetts används kontrollplansversionen för att användas igen.
  • Du kan antingen uppgradera eller skala ett kontrollplan eller en nodpool vid en viss tidpunkt. Du kan inte skicka flera åtgärder på ett enda kontrollplan eller en nodpoolresurs samtidigt.

Skala en nodpool manuellt

När programmets arbetsbelastningskrav ändras kan du behöva skala antalet noder i en nodpool. Antalet noder kan skalas upp eller ned.

Om du vill skala antalet noder i en nodpool använder du kommandot az aks node pool scale. I följande exempel skalas antalet noder i mynodepool till 5:

az aks nodepool scale \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name mynodepool \
    --node-count 5 \
    --no-wait

Visa status för dina nodpooler igen med kommandot az aks node pool list. I följande exempel visas att mynodepool är i skalningstillstånd med ett nytt antal 5 noder:

az aks nodepool list -g myResourceGroup --cluster-name myAKSCluster

[
  {
    ...
    "count": 5,
    ...
    "name": "mynodepool",
    "orchestratorVersion": "1.15.7",
    ...
    "provisioningState": "Scaling",
    ...
    "vmSize": "Standard_DS2_v2",
    ...
  },
  {
    ...
    "count": 2,
    ...
    "name": "nodepool1",
    "orchestratorVersion": "1.15.7",
    ...
    "provisioningState": "Succeeded",
    ...
    "vmSize": "Standard_DS2_v2",
    ...
  }
]

Det tar några minuter för skalningsåtgärden att slutföras.

Skala en specifik nodpool automatiskt genom att aktivera autoskalning av kluster

AKS erbjuder en separat funktion för automatisk skalning av nodpooler med en funktion som kallas autoskalning av kluster. Den här funktionen kan aktiveras per nodpool med unika minsta och högsta skalningsantal per nodpool. Lär dig hur du använder autoskalning av kluster per nodpool.

Ta bort en nodpool

Om du inte längre behöver en pool kan du ta bort den och ta bort de underliggande VM-noderna. Om du vill ta bort en nodpool använder du kommandot az aks node pool delete och anger namnet på nodpoolen. I följande exempel tas den mynoodepool som skapades i föregående steg bort:

az aks nodepool delete -g myResourceGroup --cluster-name myAKSCluster --name mynodepool --no-wait

Följande exempelutdata från kommandot az aks node pool list visar att mynodepool är i tillståndet Ta bort:

az aks nodepool list -g myResourceGroup --cluster-name myAKSCluster

[
  {
    ...
    "count": 5,
    ...
    "name": "mynodepool",
    "orchestratorVersion": "1.15.7",
    ...
    "provisioningState": "Deleting",
    ...
    "vmSize": "Standard_DS2_v2",
    ...
  },
  {
    ...
    "count": 2,
    ...
    "name": "nodepool1",
    "orchestratorVersion": "1.15.7",
    ...
    "provisioningState": "Succeeded",
    ...
    "vmSize": "Standard_DS2_v2",
    ...
  }
]

Det tar några minuter att ta bort noderna och nodpoolen.

Ange en VM-storlek för en nodpool

I de föregående exemplen för att skapa en nodpool användes en standardstorlek för virtuella datorer för noderna som skapades i klustret. Ett vanligare scenario är att du skapar nodpooler med olika VM-storlekar och funktioner. Du kan till exempel skapa en nodpool som innehåller noder med stora mängder cpu eller minne, eller en nodpool som ger GPU-stöd. I nästa steg använder du taints och toleranser för att berätta för Kubernetes-schemaläggaren hur åtkomsten till poddar som kan köras på dessa noder ska begränsas.

I följande exempel skapar du en GPU-baserad nodpool som använder Standard_NC6 VM-storlek. De här virtuella datorerna drivs av KORTET NVIDIA Tesla K80. Information om tillgängliga VM-storlekar finns i Storlekar för virtuella Linux-datorer i Azure.

Skapa en nodpool med kommandot az aks node pool add igen. Den här gången anger du namnet gpunodepool och använder --node-vm-size parametern för att ange Standard_NC6 storlek:

az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name gpunodepool \
    --node-count 1 \
    --node-vm-size Standard_NC6 \
    --no-wait

Följande exempelutdata från kommandot az aks node pool list visar att gpunodepool är Creating nodes with the specified VmSize:

az aks nodepool list -g myResourceGroup --cluster-name myAKSCluster

[
  {
    ...
    "count": 1,
    ...
    "name": "gpunodepool",
    "orchestratorVersion": "1.15.7",
    ...
    "provisioningState": "Creating",
    ...
    "vmSize": "Standard_NC6",
    ...
  },
  {
    ...
    "count": 2,
    ...
    "name": "nodepool1",
    "orchestratorVersion": "1.15.7",
    ...
    "provisioningState": "Succeeded",
    ...
    "vmSize": "Standard_DS2_v2",
    ...
  }
]

Det tar några minuter för gpunodepoolen att skapas.

Ange en taint, etikett eller tagg för en nodpool

När du skapar en nodpool kan du lägga till taints, etiketter eller taggar till nodpoolen. När du lägger till en taint, etikett eller tagg får alla noder i nodpoolen även den taint-, etikett- eller taggen.

Ange nodepool-taints

Om du vill skapa en nodpool med en taint använder du az aks nodepool add. Ange namnet taintnp och använd --node-taints parametern för att ange sku=gpu:NoSchedule för taint.

az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name taintnp \
    --node-count 1 \
    --node-taints sku=gpu:NoSchedule \
    --no-wait

Följande exempelutdata från kommandot az aks nodepool list visar att taintnp är Creating nodes with the specified nodeTaints:

$ az aks nodepool list -g myResourceGroup --cluster-name myAKSCluster

[
  {
    ...
    "count": 1,
    ...
    "name": "taintnp",
    "orchestratorVersion": "1.15.7",
    ...
    "provisioningState": "Creating",
    ...
    "nodeTaints":  [
      "sku=gpu:NoSchedule"
    ],
    ...
  },
 ...
]

Taint-informationen visas i Kubernetes för hantering av schemaläggningsregler för noder. Kubernetes-schemaläggaren kan använda taints och toleranser för att begränsa vilka arbetsbelastningar som kan köras på noder.

• En taint tillämpas på en nod som anger att endast specifika poddar kan schemaläggas på dem.
• En tolerans tillämpas sedan på en podd som gör att de kan tolerera en nods taint.

Mer information om hur du använder avancerade schemalagda Kubernetes-funktioner finns i Metodtips för avancerade schemaläggningsfunktioner i AKS

I föregående steg tillämpade du sku=gpu:NoSchedule taint när du skapade nodpoolen. I följande grundläggande YAML-exempelmanifest används en tolerans som gör att Kubernetes-schemaläggaren kan köra en NGINX-podd på en nod i nodpoolen.

Skapa en fil med nginx-toleration.yaml namnet och kopiera i följande YAML-exempel:

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  containers:
  - image: mcr.microsoft.com/oss/nginx/nginx:1.15.9-alpine
    name: mypod
    resources:
      requests:
        cpu: 100m
        memory: 128Mi
      limits:
        cpu: 1
        memory: 2G
  tolerations:
  - key: "sku"
    operator: "Equal"
    value: "gpu"
    effect: "NoSchedule"

Schemalägg podden med kubectl apply -f nginx-toleration.yaml kommandot :

kubectl apply -f nginx-toleration.yaml

Det tar några sekunder att schemalägga podden och hämta NGINX-avbildningen. Använd kommandot kubectl describe pod för att visa poddstatusen. Följande komprimerade exempelutdata visar att toleransen sku=gpu:NoSchedule tillämpas. I avsnittet händelser har schemaläggaren tilldelat podden till noden aks-taintnp-28993262-vmss000000:

kubectl describe pod mypod

[...]
Tolerations:     node.kubernetes.io/not-ready:NoExecute for 300s
                 node.kubernetes.io/unreachable:NoExecute for 300s
                 sku=gpu:NoSchedule
Events:
  Type    Reason     Age    From                Message
  ----    ------     ----   ----                -------
  Normal  Scheduled  4m48s  default-scheduler   Successfully assigned default/mypod to aks-taintnp-28993262-vmss000000
  Normal  Pulling    4m47s  kubelet             pulling image "mcr.microsoft.com/oss/nginx/nginx:1.15.9-alpine"
  Normal  Pulled     4m43s  kubelet             Successfully pulled image "mcr.microsoft.com/oss/nginx/nginx:1.15.9-alpine"
  Normal  Created    4m40s  kubelet             Created container
  Normal  Started    4m40s  kubelet             Started container

Endast poddar som har den här toleransen tillämpad kan schemaläggas på noder i taintnp. Alla andra poddar schemaläggs i nodepool1-nodpoolen. Om du skapar ytterligare nodpooler kan du använda ytterligare taint och toleranser för att begränsa vilka poddar som kan schemaläggas för dessa nodresurser.

Ställa in nodepool-etiketter

Du kan också lägga till etiketter i en nodpool när nodpoolen skapas. Etiketter som anges i nodpoolen läggs till i varje nod i nodpoolen. De här etiketterna visas i Kubernetes för hantering av schemaläggningsregler för noder.

Om du vill skapa en nodpool med en etikett använder du az aks nodepool add. Ange namnet labelnp och använd parametern för att ange --labels dept=IT och costcenter=9999 för etiketter.

az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name labelnp \
    --node-count 1 \
    --labels dept=IT costcenter=9999 \
    --no-wait

Följande exempelutdata från kommandot az aks nodepool list visar att labelnp är Creating nodes with the specified nodeLabels:

$ az aks nodepool list -g myResourceGroup --cluster-name myAKSCluster

[
  {
    ...
    "count": 1,
    ...
    "name": "labelnp",
    "orchestratorVersion": "1.15.7",
    ...
    "provisioningState": "Creating",
    ...
    "nodeLabels":  {
      "dept": "IT",
      "costcenter": "9999"
    },
    ...
  },
 ...
]

Ange Azure-taggar för nodepool

Du kan använda en Azure-tagg för nodpooler i ditt AKS-kluster. Taggar som tillämpas på en nodpool tillämpas på varje nod i nodpoolen och bevaras genom uppgraderingar. Taggar tillämpas också på nya noder som läggs till i en nodpool under utskalningsåtgärder. Att lägga till en tagg kan hjälpa till med uppgifter som principspårning eller kostnadsuppskattning.

Azure-taggar har nycklar som är icke-känsliga för åtgärder, till exempel när du hämtar en tagg genom att söka i nyckeln. I det här fallet uppdateras eller hämtas en tagg med den angivna nyckeln oavsett hölje. Taggvärden är fallkänsliga.

Om flera taggar har angetts med identiska nycklar men ett annat hölje i AKS är taggen som används den första i alfabetisk ordning. Till exempel resulterar {"Key1": "val1", "kEy1": "val2", "key1": "val3"} i Key1 och val1 anges.

Skapa en nodpool med hjälp av az aks nodepool add. Ange namnet tagnodepool och använd parametern för att ange --tag dept=IT och costcenter=9999 för taggar.

az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name tagnodepool \
    --node-count 1 \
    --tags dept=IT costcenter=9999 \
    --no-wait

Följande exempelutdata från kommandot az aks nodepool list visar att tagnodepool är Creating nodes with the specified tag:

az aks nodepool list -g myResourceGroup --cluster-name myAKSCluster

[
  {
    ...
    "count": 1,
    ...
    "name": "tagnodepool",
    "orchestratorVersion": "1.15.7",
    ...
    "provisioningState": "Creating",
    ...
    "tags": {
      "dept": "IT",
      "costcenter": "9999"
    },
    ...
  },
 ...
]

Lägga till en FIPS-aktiverad nodpool (förhandsversion)

Den Federal Information Processing Standard (FIPS) 140-2 är en amerikansk myndighetsstandard som definierar minimikraven för säkerhetskrav för kryptografiska moduler i informationsteknikprodukter och system. Med AKS kan du skapa Linux-baserade nodpooler med FIPS 140-2 aktiverat. Distributioner som körs på FIPS-aktiverade nodpooler kan använda dessa kryptografiska moduler för att öka säkerheten och hjälpa till att uppfylla säkerhetskontroller som en del av FedRAMP-efterlevnad. Mer information om FIPS 140-2 finns i Federal Information Processing Standard (FIPS) 140-2.

FIPS-aktiverade nodpooler finns för närvarande i förhandsversion.

Du behöver Azure CLI-tillägget aks-preview version 0.5.11 eller senare. Installera Azure CLI-tillägget aks-preview med hjälp av kommandot az extension add. Eller installera eventuella tillgängliga uppdateringar med hjälp av kommandot az extension update.

# Install the aks-preview extension
az extension add --name aks-preview

# Update the extension to make sure you have the latest version installed
az extension update --name aks-preview

Om du vill använda funktionen måste du också aktivera FIPSPreview funktionsflaggan för din prenumeration.

Registrera FIPSPreview funktionsflaggan med kommandot az feature register, som du ser i följande exempel:

az feature register --namespace "Microsoft.ContainerService" --name "FIPSPreview"

Det tar några minuter för statusen att visa Registrerad. Kontrollera registreringsstatusen med kommandot az feature list:

az feature list -o table --query "[?contains(name, 'Microsoft.ContainerService/FIPSPreview')].{Name:name,State:properties.state}"

När du är klar uppdaterar du registreringen av resursprovidern Microsoft.ContainerService med kommandot az provider register:

az provider register --namespace Microsoft.ContainerService

FIPS-aktiverade nodpooler har följande begränsningar:

• För närvarande kan du bara ha FIPS-aktiverade Linux-baserade nodpooler som körs på Ubuntu 18.04.
• FIPS-aktiverade nodpooler kräver Kubernetes version 1.19 och senare.
• Om du vill uppdatera de underliggande paketen eller modulerna som används för FIPS måste du använda Node Image Upgrade.

Om du vill skapa en FIPS-aktiverad nodpool använder du az aks nodepool add med parametern --enable-fips-image när du skapar en nodpool.

az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name fipsnp \
    --enable-fips-image

Om du vill kontrollera att nodpoolen är FIPS-aktiverad använder du az aks show för att kontrollera enableFIPS-värdet i agentPoolProfiles.

az aks show --resource-group myResourceGroup --cluster-name myAKSCluster --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" -o table

Följande exempelutdata visar att fipsnp-nodpoolen är FIPS-aktiverad och nodepool1 inte är det.

Name       enableFips
---------  ------------
fipsnp     True
nodepool1  False  

Du kan också kontrollera att distributioner har åtkomst till de kryptografiska FIPS-biblioteken med hjälp av på en nod i kubectl debug den FIPS-aktiverade nodpoolen. Använd kubectl get nodes för att visa en lista över noderna:

$ kubectl get nodes
NAME                                STATUS   ROLES   AGE     VERSION
aks-fipsnp-12345678-vmss000000      Ready    agent   6m4s    v1.19.9
aks-fipsnp-12345678-vmss000001      Ready    agent   5m21s   v1.19.9
aks-fipsnp-12345678-vmss000002      Ready    agent   6m8s    v1.19.9
aks-nodepool1-12345678-vmss000000   Ready    agent   34m     v1.19.9

I exemplet ovan är noderna som börjar med aks-fipsnp en del av den FIPS-aktiverade nodpoolen. Använd kubectl debug för att köra en distribution med en interaktiv session på en av dessa noder i den FIPS-aktiverade nodpoolen.

kubectl debug node/aks-fipsnp-12345678-vmss000000 -it --image=mcr.microsoft.com/aks/fundamental/base-ubuntu:v0.0.11

Från den interaktiva sessionen kan du kontrollera att de kryptografiska FIPS-biblioteken är aktiverade:

root@aks-fipsnp-12345678-vmss000000:/# cat /proc/sys/crypto/fips_enabled
1

FIPS-aktiverade nodpooler har också kubernetes.azure.com/fips_enabled=true etikett som kan användas av distributioner för att rikta in sig på dessa nodpooler.

Hantera nodpooler med en Resource Manager mall

När du använder en Azure Resource Manager mall för att skapa och hantera resurser kan du vanligtvis uppdatera inställningarna i mallen och distribuera om för att uppdatera resursen. Med nodpooler i AKS kan den första nodpoolprofilen inte uppdateras när AKS-klustret har skapats. Det här beteendet innebär att du inte kan uppdatera en Resource Manager en mall, göra en ändring i nodpoolerna och distribuera om. I stället måste du skapa en separat Resource Manager som bara uppdaterar nodpoolerna för ett befintligt AKS-kluster.

Skapa en mall som och aks-agentpools.json klistra in följande exempelmanifest. Den här exempelmallen konfigurerar följande inställningar:

• Uppdaterar Linux-nodpoolen med namnet myagentpool för att köra tre noder.
• Anger noderna i nodpoolen för att köra Kubernetes version 1.15.7.
• Definierar nodstorleken som Standard_DS2_v2.

Redigera dessa värden när du behöver uppdatera, lägga till eller ta bort nodpooler efter behov:

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "clusterName": {
            "type": "string",
            "metadata": {
                "description": "The name of your existing AKS cluster."
            }
        },
        "location": {
            "type": "string",
            "metadata": {
                "description": "The location of your existing AKS cluster."
            }
        },
        "agentPoolName": {
            "type": "string",
            "defaultValue": "myagentpool",
            "metadata": {
                "description": "The name of the agent pool to create or update."
            }
        },
        "vnetSubnetId": {
            "type": "string",
            "defaultValue": "",
            "metadata": {
                "description": "The Vnet subnet resource ID for your existing AKS cluster."
            }
        }
    },
    "variables": {
        "apiVersion": {
            "aks": "2020-01-01"
        },
        "agentPoolProfiles": {
            "maxPods": 30,
            "osDiskSizeGB": 0,
            "agentCount": 3,
            "agentVmSize": "Standard_DS2_v2",
            "osType": "Linux",
            "vnetSubnetId": "[parameters('vnetSubnetId')]"
        }
    },
    "resources": [
        {
            "apiVersion": "2020-01-01",
            "type": "Microsoft.ContainerService/managedClusters/agentPools",
            "name": "[concat(parameters('clusterName'),'/', parameters('agentPoolName'))]",
            "location": "[parameters('location')]",
            "properties": {
                "maxPods": "[variables('agentPoolProfiles').maxPods]",
                "osDiskSizeGB": "[variables('agentPoolProfiles').osDiskSizeGB]",
                "count": "[variables('agentPoolProfiles').agentCount]",
                "vmSize": "[variables('agentPoolProfiles').agentVmSize]",
                "osType": "[variables('agentPoolProfiles').osType]",
                "storageProfile": "ManagedDisks",
                "type": "VirtualMachineScaleSets",
                "vnetSubnetID": "[variables('agentPoolProfiles').vnetSubnetId]",
                "orchestratorVersion": "1.15.7"
            }
        }
    ]
}

Distribuera den här mallen med kommandot az deployment group create, som du ser i följande exempel. Du uppmanas att ange det befintliga AKS-klusternamnet och platsen:

az deployment group create \
    --resource-group myResourceGroup \
    --template-file aks-agentpools.json

...
"resources": [
{
  ...
  "properties": {
    ...
    "tags": {
      "name1": "val1"
    },
    ...
  }
}
...

Det kan ta några minuter att uppdatera ditt AKS-kluster beroende på inställningarna och åtgärderna för nodpoolen som du definierar i Resource Manager mallen.

Tilldela en offentlig IP-adress per nod för dina nodpooler

AKS-noder kräver inte sina egna offentliga IP-adresser för kommunikation. Scenarier kan dock kräva att noder i en nodpool tar emot sina egna dedikerade offentliga IP-adresser. Ett vanligt scenario är för spelarbetsbelastningar, där en konsol måste upprätta en direktanslutning till en virtuell dator i molnet för att minimera hopp. Det här scenariot kan uppnås på AKS med hjälp av Node Public IP.

Skapa först en ny resursgrupp.

az group create --name myResourceGroup2 --location eastus

Skapa ett nytt AKS-kluster och koppla en offentlig IP-adress för dina noder. Var och en av noderna i nodpoolen får en unik offentlig IP-adress. Du kan kontrollera detta genom att titta på instanserna för VM-skalningsuppsättningen.

az aks create -g MyResourceGroup2 -n MyManagedCluster -l eastus  --enable-node-public-ip

För befintliga AKS-kluster kan du också lägga till en ny nodpool och koppla en offentlig IP-adress för dina noder.

az aks nodepool add -g MyResourceGroup2 --cluster-name MyManagedCluster -n nodepool2 --enable-node-public-ip

Använda ett offentligt IP-prefix

Det finns ett antal fördelar med att använda ett offentligt IP-prefix. AKS stöder användning av adresser från ett befintligt offentligt IP-prefix för dina noder genom att skicka resurs-ID:t med flaggan när du skapar ett nytt kluster eller lägger node-public-ip-prefix till en nodpool.

Skapa först ett offentligt IP-prefix med az network public-ip prefix create:

az network public-ip prefix create --length 28 --location eastus --name MyPublicIPPrefix --resource-group MyResourceGroup3

Visa utdata och anteckna id för prefixet :

{
  ...
  "id": "/subscriptions/<subscription-id>/resourceGroups/myResourceGroup3/providers/Microsoft.Network/publicIPPrefixes/MyPublicIPPrefix",
  ...
}

När du skapar ett nytt kluster eller lägger till en ny nodpool använder du slutligen flaggan och skickar node-public-ip-prefix prefixets resurs-ID:

az aks create -g MyResourceGroup3 -n MyManagedCluster -l eastus --enable-node-public-ip --node-public-ip-prefix /subscriptions/<subscription-id>/resourcegroups/MyResourceGroup3/providers/Microsoft.Network/publicIPPrefixes/MyPublicIPPrefix

Hitta offentliga IP-adresser för noder

Du kan hitta offentliga IP-adresser för noderna på olika sätt:

• Använd Azure CLI-kommandot az vmss list-instance-public-ips.
• Använd PowerShell- eller Bash-kommandon .
• Du kan också visa offentliga IP-adresser i Azure Portal genom att visa instanserna i VM-skalningsuppsättningen.

az vmss list-instance-public-ips -g MC_MyResourceGroup2_MyManagedCluster_eastus -n YourVirtualMachineScaleSetName

Rensa resurser

I den här artikeln har du skapat ett AKS-kluster som innehåller GPU-baserade noder. För att minska onödiga kostnader kanske du vill ta bort gpunodepoolen, eller hela AKS-klustret.

Om du vill ta bort den GPU-baserade nodpoolen använder du kommandot az aks nodepool delete enligt följande exempel:

az aks nodepool delete -g myResourceGroup --cluster-name myAKSCluster --name gpunodepool

Om du vill ta bort själva klustret använder du kommandot az group delete för att ta bort AKS-resursgruppen:

az group delete --name myResourceGroup --yes --no-wait

Du kan också ta bort det ytterligare kluster som du skapade för scenariot med offentliga IP-adresser för nodpooler.

az group delete --name myResourceGroup2 --yes --no-wait

Nästa steg

Läs mer om systemnodpooler.

I den här artikeln har du lärt dig hur du skapar och hanterar flera nodpooler i ett AKS-kluster. Mer information om hur du styr poddar över nodpooler finns i Metodtips för avancerade schemaläggningsfunktioner i AKS.

Information om hur du skapar Windows servercontainernodpooler finns i Skapa en Windows Server-container i AKS.

Använd närhetsplaceringsgrupper för att minska svarstiden för dina AKS-program.