Dela via

Hantera nodpooler för ett kluster i Azure Kubernetes Service (AKS)

  • Artikel

I Azure Kubernetes Service (AKS) grupperas noder med samma konfiguration i nodpooler. Dessa nodpooler innehåller de underliggande virtuella datorer som kör dina program. När du skapar ett AKS-kluster definierar du det inledande antalet noder och deras storlek (SKU). När programmets krav ändras kan du behöva ändra inställningarna i nodpoolerna. Du kan till exempel behöva skala antalet noder i en nodpool eller uppgradera Kubernetes-versionen av en nodpool.

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

Innan du börjar

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 regiontillgänglighet i Azure Kubernetes Service (AKS).
  • Systempooler måste innehålla minst en nod och användarnodpooler kan innehålla noll eller fler noder.
  • Du kan inte ändra storleken på den virtuella datorn för en nodpool när du har skapat den.
  • När du skapar flera nodpooler när klustret skapas måste alla Kubernetes-versioner som används av nodpooler matcha versionuppsättningen för kontrollplanet. Du kan göra uppdateringar när du har etablerat klustret med hjälp av åtgärder per nodpool.
  • Du kan inte köra uppgraderings- och skalningsåtgärder samtidigt i ett kluster eller en nodpool. Om du försöker köra dem samtidigt får du ett fel. Varje åtgärdstyp måste slutföras på målresursen före nästa begäran för samma resurs. Mer information finns i felsökningsguiden.

Uppgradera en enskild nodpool

Kommentar

Avbildningsversionen av nodpoolens operativsystem är kopplad till Kubernetes-versionen av klustret. Du får bara os-avbildningsuppgraderingar efter en klusteruppgradering.

I det här exemplet uppgraderar vi nodpoolen mynodepool . Eftersom det finns två nodpooler måste vi använda az aks nodepool upgrade kommandot för att uppgradera.

  1. Kontrollera om det finns några tillgängliga uppgraderingar med kommandot az aks get-upgrades .

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

  2. Uppgradera nodpoolen mynodepool med kommandot az aks nodepool upgrade .

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

  3. Visa status för dina nodpooler med kommandot az aks nodepool list .

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

    Följande exempelutdata visar att mynodepool är i uppgraderingstillståndet:

    [
  {
    ...
    "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.

Vi rekommenderar att du uppgraderar alla nodpooler i ett AKS-kluster till samma Kubernetes-version. Standardbeteendet az aks upgrade för ä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

Kommentar

Kubernetes använder standardschemat för semantisk versionshantering . Versionsnumret uttrycks som x.y.z, där x är huvudversionen, y är delversionen och z är korrigeringsversionen. I version 1.12.6 är till exempel 1 huvudversionen, 12 är delversionen och 6 är korrigeringsversionen. Kubernetes-versionen av kontrollplanet och den första nodpoolen anges när klustret skapas. Andra nodpooler har sin Kubernetes-version inställd när de läggs till i klustret. Kubernetes-versionerna kan skilja sig mellan nodpooler och mellan en nodpool och kontrollplanet.

Ett AKS-kluster har två klusterresursobjekt med Kubernetes-versioner associerade till sig:

  1. Klusterkontrollplanets Kubernetes-version och
  2. En nodpool med en Kubernetes-version.

Kontrollplanet mappar till en eller flera nodpooler. Hur en uppgraderingsåtgärd fungerar beror på vilket Azure CLI-kommando du använder.

  • az aks upgrade uppgraderar kontrollplanet och alla nodpooler i klustret till samma Kubernetes-version.
  • az aks upgrade--control-plane-only med flaggan uppgraderar endast klusterkontrollplanet och lämnar alla nodpooler oförändrade.
  • az aks nodepool upgrade uppgraderar endast målnodpoolen med den angivna Kubernetes-versionen.

Verifieringsregler för uppgraderingar

Kubernetes-uppgraderingar för ett klusterkontrollplan och nodpooler verifieras med hjälp av följande uppsättningar regler:

  • Regler för giltiga versioner för att uppgradera nodpooler:

    • Nodpoolversionen måste ha samma huvudversion som kontrollplanet.
    • Delversionen av nodpoolen måste ligga inom två delversioner av kontrollplanets version.
    • Nodpoolversionen får inte vara större än kontrollversionen major.minor.patch .

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

    • Du kan inte nedgradera kontrollplanet eller en kubernetes-version för nodpoolen.
    • Om en kubernetes-version för nodpoolen inte har angetts beror beteendet på klienten. I Resource Manager-mallar återgår deklarationen till den befintliga version som definierats för nodpoolen. Om inget har angetts använder den kontrollplanets version för att återgå till det.
    • Du kan inte skicka flera åtgärder samtidigt på ett enda kontrollplan eller en nodpoolresurs. Du kan antingen uppgradera eller skala ett kontrollplan eller en nodpool vid en viss tidpunkt.

Skala en nodpool manuellt

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

  1. Skala antalet noder i en nodpool med kommandot az aks node pool scale .

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

  2. Visa status för dina nodpooler med kommandot az aks node pool list .

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

    Följande exempelutdata visar att mynodepool är i skalningstillståndet med ett nytt antal på fem noder:

    [
  {
    ...
    "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 innan skalningsåtgärden slutförs.

Skala en specifik nodpool automatiskt med hjälp av autoskalning av kluster

AKS erbjuder en separat funktion för att automatiskt skala nodpooler med en funktion som kallas autoskalning av kluster. Du kan aktivera den här funktionen med unika minsta och högsta skalningsantal per nodpool.

Mer information finns i använda autoskalning av kluster.

Ta bort specifika virtuella datorer i den befintliga nodpoolen

Kommentar

När du tar bort en virtuell dator med det här kommandot utför AKS inte avspärrning och tömning. Utför en avspärrning och tömning på den virtuella datorn innan du tar bort för att minimera avbrotten i de omplanerade poddar som körs på den virtuella datorn som du planerar att ta bort. Du kan lära dig mer om hur du spärrar och tömmer med hjälp av exempelscenariot i självstudien ändra storlek på nodpooler.

  1. Visa en lista över befintliga noder med kommandot kubectl get nodes .

    kubectl get nodes

    Dina utdata bör se ut ungefär som följande exempelutdata:

    NAME                                 STATUS   ROLES   AGE   VERSION
aks-mynodepool-20823458-vmss000000   Ready    agent   63m   v1.21.9
aks-mynodepool-20823458-vmss000001   Ready    agent   63m   v1.21.9
aks-mynodepool-20823458-vmss000002   Ready    agent   63m   v1.21.9

  2. Ta bort de angivna virtuella datorerna az aks nodepool delete-machines med kommandot . Ersätt platshållarna med dina egna värden.

    az aks nodepool delete-machines \
    --resource-group <resource-group-name> \
    --cluster-name <cluster-name> \
    --name <node-pool-name>
    --machine-names <vm-name-1> <vm-name-2>

  3. Kontrollera att de virtuella datorerna har tagits bort med kommandot kubectl get nodes .

    kubectl get nodes

    Dina utdata bör inte längre innehålla de virtuella datorer som du angav i az aks nodepool delete-machines kommandot.

Associera kapacitetsreservationsgrupper med nodpooler

När arbetsbelastningens krav ändras kan du associera befintliga kapacitetsreservationsgrupper med nodpooler för att garantera allokerad kapacitet för dina nodpooler.

Förutsättningar för att använda kapacitetsreservationsgrupper med AKS

  • Använd CLI version 2.56 eller senare och API-version 2023-10-01 eller senare.

  • Kapacitetsreservationsgruppen bör redan finnas och bör innehålla minst en kapacitetsreservation, annars läggs nodpoolen till i klustret med en varning och ingen kapacitetsreservationsgrupp associeras. Mer information finns i kapacitetsreservationsgrupper.

  • Du måste skapa en användartilldelad hanterad identitet för resursgruppen som innehåller kapacitetsreservationsgruppen (CRG). Systemtilldelade hanterade identiteter fungerar inte för den här funktionen. I följande exempel ersätter du miljövariablerna med dina egna värden.

    IDENTITY_NAME=myID
RG_NAME=myResourceGroup
CLUSTER_NAME=myAKSCluster
VM_SKU=Standard_D4s_v3
NODE_COUNT=2
LOCATION=westus2
az identity create --name $IDENTITY_NAME --resource-group $RG_NAME  
IDENTITY_ID=$(az identity show --name $IDENTITY_NAME --resource-group $RG_NAME --query identity.id -o tsv)

  • Du måste tilldela Contributor rollen till den användartilldelade identiteten som skapades ovan. Mer information finns i Steg för att tilldela en Azure-roll.

  • Skapa ett nytt kluster och tilldela den nyligen skapade identiteten.

      az aks create \
      --resource-group $RG_NAME \
      --name $CLUSTER_NAME \
      --location $LOCATION \
      --node-vm-size $VM_SKU --node-count $NODE_COUNT \
      --assign-identity $IDENTITY_ID \
      --generate-ssh-keys

  • Du kan också tilldela den användarhanterade identiteten i ett befintligt hanterat kluster med uppdateringskommandot.

    az aks update \
    --resource-group $RG_NAME \
    --name $CLUSTER_NAME \
    --location $LOCATION \
    --node-vm-size $VM_SKU \
    --node-count $NODE_COUNT \
    --enable-managed-identity \
    --assign-identity $IDENTITY_ID

Associera en befintlig kapacitetsreservationsgrupp med en nodpool

Associera en befintlig kapacitetsreservationsgrupp med en nodpool med kommandot az aks nodepool add och ange en kapacitetsreservationsgrupp med --crg-id flaggan . I följande exempel förutsätter vi att du har en CRG med namnet "myCRG".

RG_NAME=myResourceGroup
CLUSTER_NAME=myAKSCluster
NODEPOOL_NAME=myNodepool
CRG_NAME=myCRG
CRG_ID=$(az capacity reservation group show --capacity-reservation-group $CRG_NAME --resource-group $RG_NAME --query id -o tsv)
az aks nodepool add --resource-group $RG_NAME --cluster-name $CLUSTER_NAME --name $NODEPOOL_NAME --crg-id $CRG_ID

Associera en befintlig kapacitetsreservationsgrupp med en systemnodpool

Om du vill associera en befintlig kapacitetsreservationsgrupp med en systemnodpool associerar du klustret med den användartilldelade identiteten med rollen Deltagare i din CRG och själva CRG:en när klustret skapas. az aks create Använd kommandot med flaggorna --assign-identity och --crg-id .

IDENTITY_NAME=myID
RG_NAME=myResourceGroup
CLUSTER_NAME=myAKSCluster
NODEPOOL_NAME=myNodepool
CRG_NAME=myCRG
CRG_ID=$(az capacity reservation group show --capacity-reservation-group $CRG_NAME --resource-group $RG_NAME --query id -o tsv)
IDENTITY_ID=$(az identity show --name $IDENTITY_NAME --resource-group $RG_NAME --query identity.id -o tsv)

az aks create \
    --resource-group $RG_NAME \
    --cluster-name $CLUSTER_NAME \
    --crg-id $CRG_ID \
    --assign-identity $IDENTITY_ID \
    --generate-ssh-keys

Kommentar

Om du tar bort en nodpool kopplas den nodpoolen från en associerad kapacitetsreservationsgrupp innan nodpoolen tas bort. Om du tar bort ett kluster kopplas alla nodpooler i klustret från deras associerade kapacitetsreservationsgrupper implicit.

Kommentar

Du kan inte uppdatera en befintlig nodpool med en kapacitetsreservationsgrupp. Den rekommenderade metoden är att associera en kapacitetsreservationsgrupp när nodpoolen skapas.

Ange en VM-storlek för en nodpool

Du kan behöva skapa 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 avsnitt använder du taints och toleranser för att berätta för Kubernetes-schemaläggaren hur du begränsar åtkomsten till poddar som kan köras på dessa noder.

I följande exempel skapar vi en GPU-baserad nodpool som använder Standard_NC6s_v3 VM-storlek. Dessa virtuella datorer drivs av NVIDIA Tesla K80-kortet. Mer information finns i Tillgängliga storlekar för virtuella Linux-datorer i Azure.

  1. Skapa en nodpool med kommandot az aks node pool add . Ange namnet gpunodepool och använd parametern --node-vm-size 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_NC6s_v3 \
    --no-wait

  2. Kontrollera statusen för nodpoolen az aks nodepool list med kommandot .

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

    Följande exempelutdata visar att nodpoolen gpunodepool är Skapa noder med den angivna VmSize:

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

    Det tar några minuter innan gpunodepoolen har skapats.

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 i den. När du lägger till en taint, etikett eller tagg får alla noder i nodpoolen även den tainten, etiketten eller taggen.

Viktigt!

Du bör lägga till taints, etiketter eller taggar i noder för hela nodpoolen med hjälp av az aks nodepool. Vi rekommenderar inte att du använder kubectl för att tillämpa taints, etiketter eller taggar på enskilda noder i en nodpool.

Ange taints för nodpool

AKS stöder två typer av nodtaints: nodtaints och taints för nodinitiering (förhandsversion). Mer information finns i Använda nodtaints i ett AKS-kluster (Azure Kubernetes Service).

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

Ange tolerationer för nodpooler

I föregående steg använde du tainten sku=gpu:NoSchedule när du skapade nodpoolen. I följande exempel använder YAML-manifestet en tolerans som gör att Kubernetes-schemaläggaren kan köra en NGINX-podd på en nod i nodpoolen.

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

    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"

  2. Schemalägg podden med kommandot kubectl apply .

    kubectl apply -f nginx-toleration.yaml

    Det tar några sekunder att schemalägga podden och hämta NGINX-avbildningen.

  3. Kontrollera statusen med kommandot kubectl describe pod .

    kubectl describe pod mypod

    Följande komprimerade exempelutdata visar att sku=gpu:NoSchedule-tolerans tillämpas. I avsnittet händelser tilldelade schemaläggaren podden till noden aks-taintnp-28993262-vmss000000 :

    [...]
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. Andra poddar schemaläggs i nodepool1-nodpoolen. Om du skapar fler nodpooler kan du använda taints och toleranser för att begränsa vilka poddar som kan schemaläggas på dessa nodresurser.

Ange nodpooletiketter

Mer information finns i Använda etiketter i ett AKS-kluster (Azure Kubernetes Service).

Ange Azure-taggar för nodpool

Mer information finns i Använda Azure-taggar i Azure Kubernetes Service (AKS).

Hantera nodpooler med hjälp av en Resource Manager-mall

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

  1. Skapa en mall, till exempel aks-agentpools.json, och klistra in i följande exempelmanifest. Se till att redigera värdena efter behov. Den här exempelmallen konfigurerar följande inställningar:

    • Uppdaterar Linux-nodpoolen med namnet myagentpool för att köra tre noder.
    • Anger att noderna i nodpoolen ska köra Kubernetes version 1.15.7.
    • Definierar nodstorleken som Standard_DS2_v2.
    {
    "$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]",
                "type": "VirtualMachineScaleSets",
                "vnetSubnetID": "[variables('agentPoolProfiles').vnetSubnetId]",
                "orchestratorVersion": "1.15.7"
            }
        }
    ]
}

  2. Distribuera mallen med kommandot az deployment group create .

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

    Dricks

    Du kan lägga till en tagg i nodpoolen genom att lägga till taggegenskapen i mallen, enligt följande exempel:

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

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

Nästa steg