Delen via

Knooppuntgroepen beheren voor een cluster in Azure Kubernetes Service (AKS)

  • Artikel

In Azure Kubernetes Service (AKS) worden knooppunten van dezelfde configuratie gegroepeerd in knooppuntgroepen. Deze knooppuntgroepen bevatten de onderliggende VM's waarop uw toepassingen worden uitgevoerd. Wanneer u een AKS-cluster maakt, definieert u het eerste aantal knooppunten en de bijbehorende grootte (SKU). Naarmate de toepassing vraagt, moet u mogelijk de instellingen voor uw knooppuntgroepen wijzigen. U moet bijvoorbeeld het aantal knooppunten in een knooppuntgroep schalen of de Kubernetes-versie van een knooppuntgroep upgraden.

In dit artikel leest u hoe u een of meer knooppuntgroepen in een AKS-cluster beheert.

Voordat u begint

Beperkingen

De volgende beperkingen gelden wanneer u AKS-clusters maakt en beheert die ondersteuning bieden voor meerdere knooppuntgroepen:

  • Zie Quota, beperkingen voor grootte van virtuele machines en beschikbaarheid van regio's in Azure Kubernetes Service (AKS).
  • Systeemgroepen moeten ten minste één knooppunt bevatten en gebruikersknooppuntgroepen kunnen nul of meer knooppunten bevatten.
  • U kunt de VM-grootte van een knooppuntgroep niet wijzigen nadat u deze hebt gemaakt.
  • Wanneer u tijdens het maken van clusters meerdere knooppuntgroepen maakt, moeten alle Kubernetes-versies die worden gebruikt door knooppuntgroepen overeenkomen met de versie die is ingesteld voor het besturingsvlak. U kunt updates aanbrengen na het inrichten van het cluster met behulp van bewerkingen per knooppuntgroep.
  • U kunt geen upgrade- en schaalbewerkingen tegelijkertijd uitvoeren op een cluster of knooppuntgroep. Als u probeert ze tegelijkertijd uit te voeren, wordt er een fout weergegeven. Elk bewerkingstype moet worden voltooid voor de doelresource voordat de volgende aanvraag voor diezelfde resource wordt uitgevoerd. Zie de gids voor probleemoplossing voor meer informatie.

Een upgrade uitvoeren van één knooppuntgroep

Notitie

De versie van de installatiekopieën van het besturingssysteem van de knooppuntgroep is gekoppeld aan de Kubernetes-versie van het cluster. U krijgt alleen upgrades van installatiekopieën van het besturingssysteem, na een clusterupgrade.

In dit voorbeeld wordt de mynodepool-knooppuntgroep bijgewerkt. Omdat er twee knooppuntgroepen zijn, moeten we de az aks nodepool upgrade opdracht gebruiken om een upgrade uit te voeren.

  1. Controleer op beschikbare upgrades met behulp van de az aks get-upgrades opdracht.

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

  2. Voer een upgrade uit van de mynodepool-knooppuntgroep met behulp van de az aks nodepool upgrade opdracht.

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

  3. Geef de status van uw knooppuntgroepen weer met behulp van de az aks nodepool list opdracht.

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

    In de volgende voorbeelduitvoer ziet u dat mynodepool de status Upgrade heeft:

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

    Het duurt enkele minuten om de knooppunten bij te werken naar de opgegeven versie.

Als best practice moet u alle knooppuntgroepen in een AKS-cluster upgraden naar dezelfde Kubernetes-versie. Het standaardgedrag van is het bijwerken van az aks upgrade alle knooppuntgroepen samen met het besturingsvlak om deze uitlijning te bereiken. Met de mogelijkheid om afzonderlijke knooppuntgroepen te upgraden, kunt u een rolling upgrade uitvoeren en pods tussen knooppuntgroepen plannen om de uptime van toepassingen te behouden binnen de bovenstaande beperkingen.

Een clusterbesturingsvlak upgraden met meerdere knooppuntgroepen

Notitie

Kubernetes maakt gebruik van het standaard semantische versiebeheerschema . Het versienummer wordt uitgedrukt als x.y.z, waarbij x de primaire versie is, y de secundaire versie is en z de patchversie. In versie 1.12.6 is 1 bijvoorbeeld de primaire versie, 12 is de secundaire versie en 6 de patchversie. De Kubernetes-versie van het besturingsvlak en de eerste knooppuntgroep worden ingesteld tijdens het maken van het cluster. Andere knooppuntgroepen hebben hun Kubernetes-versie ingesteld wanneer ze worden toegevoegd aan het cluster. De Kubernetes-versies kunnen verschillen tussen knooppuntgroepen en tussen een knooppuntgroep en het besturingsvlak.

Een AKS-cluster heeft twee clusterresourceobjecten waaraan Kubernetes-versies zijn gekoppeld:

  1. De Kubernetes-versie van het clusterbesturingsvlak en
  2. Een knooppuntgroep met een Kubernetes-versie.

Het besturingsvlak wordt toegewezen aan een of meer knooppuntgroepen. Het gedrag van een upgradebewerking is afhankelijk van de Azure CLI-opdracht die u gebruikt.

  • az aks upgrade werkt het besturingsvlak en alle knooppuntgroepen in het cluster bij naar dezelfde Kubernetes-versie.
  • az aks upgrade met de --control-plane-only vlag wordt alleen het clusterbesturingsvlak bijgewerkt en blijven alle knooppuntgroepen ongewijzigd.
  • az aks nodepool upgrade werkt alleen de doelknooppuntgroep bij met de opgegeven Kubernetes-versie.

Validatieregels voor upgrades

Kubernetes-upgrades voor een clusterbesturingsvlak en knooppuntgroepen worden gevalideerd met behulp van de volgende regelsets:

  • Regels voor geldige versies voor het upgraden van knooppuntgroepen:

    • De versie van de knooppuntgroep moet dezelfde primaire versie hebben als het besturingsvlak.
    • De secundaire versie van de knooppuntgroep moet zich in twee secundaire versies van de versie van het besturingsvlak bevindt.
    • De versie van de knooppuntgroep kan niet groter zijn dan de versie van het besturingselement major.minor.patch .

  • Regels voor het verzenden van een upgradebewerking:

    • U kunt het besturingsvlak of een Kubernetes-versie van een knooppuntgroep niet downgraden.
    • Als een Kubernetes-versie van een knooppuntgroep niet is opgegeven, is het gedrag afhankelijk van de client. In Resource Manager-sjablonen valt de declaratie terug op de bestaande versie die is gedefinieerd voor de knooppuntgroep. Als er niets is ingesteld, wordt de versie van het besturingsvlak gebruikt om terug te vallen.
    • U kunt niet tegelijkertijd meerdere bewerkingen verzenden op één besturingsvlak of knooppuntgroepresource. U kunt een besturingsvlak of een knooppuntgroep op een bepaald moment upgraden of schalen.

Een knooppuntgroep handmatig schalen

Naarmate de workload van uw toepassing verandert, moet u mogelijk het aantal knooppunten in een knooppuntgroep schalen. Het aantal knooppunten kan omhoog of omlaag worden geschaald.

  1. Schaal het aantal knooppunten in een knooppuntgroep met behulp van de az aks node pool scale opdracht.

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

  2. Geef de status van uw knooppuntgroepen weer met behulp van de az aks node pool list opdracht.

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

    In de volgende voorbeelduitvoer ziet u dat mynodepool de status Schalen heeft met een nieuw aantal van vijf knooppunten:

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

    Het duurt enkele minuten voordat de schaalbewerking is voltooid.

Een specifieke knooppuntgroep automatisch schalen met behulp van de automatische schaalaanpassing van clusters

AKS biedt een afzonderlijke functie voor het automatisch schalen van knooppuntgroepen met een functie die de automatische schaalaanpassing van clusters wordt genoemd. U kunt deze functie inschakelen met unieke minimum- en maximumaantallen per knooppuntgroep.

Zie de automatische schaalaanpassing van clusters voor meer informatie.

Specifieke VM's verwijderen in de bestaande knooppuntgroep (preview)

Belangrijk

AKS preview-functies zijn beschikbaar op selfservice, opt-in basis. Previews worden geleverd 'zoals is' en 'als beschikbaar' en ze worden uitgesloten van de serviceovereenkomsten en beperkte garantie. AKS-previews worden gedeeltelijk gedekt door klantondersteuning op basis van best effort. Daarom zijn deze functies niet bedoeld voor productiegebruik. Zie de volgende ondersteuningsartikelen voor meer informatie:

  1. Registreer of werk de aks-preview extensie bij met behulp van de az extension add of az extension update opdracht.

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

# Update the aks-preview extension
az extension update --name aks-preview

  2. Geef de bestaande knooppunten weer met behulp van de kubectl get nodes opdracht.

    kubectl get nodes

    De uitvoer moet er ongeveer uitzien als in de volgende voorbeelduitvoer:

    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

  3. Verwijder de opgegeven VM's met behulp van de az aks nodepool delete-machines opdracht. Zorg ervoor dat u de tijdelijke aanduidingen vervangt door uw eigen waarden.

    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>

  4. Controleer of de VM's zijn verwijderd met behulp van de kubectl get nodes opdracht.

    kubectl get nodes

    De uitvoer mag niet langer de virtuele machines bevatten die u in de az aks nodepool delete-machines opdracht hebt opgegeven.

Capaciteitsreserveringsgroepen koppelen aan knooppuntgroepen

Naarmate uw workload vraagt, kunt u bestaande capaciteitsreserveringsgroepen koppelen aan knooppuntgroepen om toegewezen capaciteit voor uw knooppuntgroepen te garanderen.

Vereisten voor het gebruik van capaciteitsreserveringsgroepen met AKS

  • Gebruik CLI-versie 2.56 of hoger en API-versie 2023-10-01 of hoger.

  • De capaciteitsreserveringsgroep moet al bestaan en moet minimaal één capaciteitsreservering bevatten, anders wordt de knooppuntgroep aan het cluster toegevoegd met een waarschuwing en wordt er geen capaciteitsreserveringsgroep gekoppeld. Zie capaciteitsreserveringsgroepen voor meer informatie.

  • U moet een door de gebruiker toegewezen beheerde identiteit maken voor de resourcegroep die de CRG (Capaciteitsreserveringsgroep) bevat. Door het systeem toegewezen beheerde identiteiten werken niet voor deze functie. Vervang in het volgende voorbeeld de omgevingsvariabelen door uw eigen waarden.

    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)

  • U moet de rol toewijzen aan de door de Contributor gebruiker toegewezen identiteit die hierboven is gemaakt. Zie Stappen voor het toewijzen van een Azure-rol voor meer informatie.

  • Maak een nieuw cluster en wijs de zojuist gemaakte identiteit toe.

      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

  • U kunt ook de door de gebruiker beheerde identiteit toewijzen aan een bestaand beheerd cluster met de opdracht Update.

    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

Een bestaande capaciteitsreserveringsgroep koppelen aan een knooppuntgroep

Koppel een bestaande capaciteitsreserveringsgroep aan een knooppuntgroep met behulp van de az aks nodepool add opdracht en geef een capaciteitsreserveringsgroep op met de --crg-id vlag. In het volgende voorbeeld wordt ervan uitgegaan dat u een CRG met de naam 'myCRG' hebt.

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

Een bestaande capaciteitsreserveringsgroep koppelen aan een systeemknooppuntgroep

Als u een bestaande capaciteitsreserveringsgroep wilt koppelen aan een systeemknooppuntgroep, koppelt u het cluster aan de door de gebruiker toegewezen identiteit met de rol Inzender op uw CRG en de CRG zelf tijdens het maken van het cluster. Gebruik de az aks create opdracht met de --assign-identity en --crg-id vlaggen.

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

Notitie

Als u een knooppuntgroep verwijdert, wordt die knooppuntgroep impliciet losgekoppeld van een gekoppelde capaciteitsreserveringsgroep voordat de knooppuntgroep wordt verwijderd. Als u een cluster verwijdert, worden alle knooppuntgroepen in dat cluster impliciet losgekoppeld van de bijbehorende capaciteitsreserveringsgroepen.

Notitie

U kunt een bestaande knooppuntgroep niet bijwerken met een capaciteitsreserveringsgroep. De aanbevolen methode is om een capaciteitsreserveringsgroep te koppelen tijdens het maken van de knooppuntgroep.

Een VM-grootte opgeven voor een knooppuntgroep

Mogelijk moet u knooppuntgroepen maken met verschillende VM-grootten en -mogelijkheden. U kunt bijvoorbeeld een knooppuntgroep maken die knooppunten bevat met grote hoeveelheden CPU of geheugen of een knooppuntgroep die GPU-ondersteuning biedt. In de volgende sectie gebruikt u taints en toleranties om de Kubernetes-planner te laten weten hoe u de toegang tot pods beperkt die op deze knooppunten kunnen worden uitgevoerd.

In het volgende voorbeeld maken we een op GPU gebaseerde knooppuntgroep die gebruikmaakt van de Standard_NC6s_v3 VM-grootte. Deze VM's worden aangedreven door de NVIDIA Tesla K80-kaart. Zie Beschikbare grootten voor virtuele Linux-machines in Azure voor meer informatie.

  1. Maak een knooppuntgroep met behulp van de az aks node pool add opdracht. Geef de naam gpunodepool op en gebruik de --node-vm-size parameter om de Standard_NC6 grootte op te geven.

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

  2. Controleer de status van de knooppuntgroep met behulp van de az aks nodepool list opdracht.

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

    In de volgende voorbeelduitvoer ziet u dat de gpunodepoolknooppuntgroep knooppunten maakt met de opgegeven 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",
    ...
  }
]

    Het duurt enkele minuten voordat de gpunodepool is gemaakt.

Een taint, label of tag opgeven voor een knooppuntgroep

Wanneer u een knooppuntgroep maakt, kunt u er taints, labels of tags aan toevoegen. Wanneer u een taint, label of tag toevoegt, krijgen alle knooppunten in die knooppuntgroep ook die taint, label of tag.

Belangrijk

Het toevoegen van taints, labels of tags aan knooppunten moet worden uitgevoerd voor de hele knooppuntgroep met behulp van az aks nodepool. U wordt afgeraden kubectl taints, labels of tags toe te passen op afzonderlijke knooppunten in een knooppuntgroep.

Taints van knooppuntgroep instellen

AKS ondersteunt twee soorten knooppunttaints: taints van knooppunten en initialisatie-taints voor knooppunten (preview). Zie Knooppunt-taints gebruiken in een AKS-cluster (Azure Kubernetes Service) voor meer informatie.

Zie Aanbevolen procedures voor geavanceerde scheduler-functies in AKS voor meer informatie over het gebruik van geavanceerde kubernetes-functies

Toleranties voor knooppuntgroepen instellen

In de vorige stap hebt u de sku=gpu:NoSchedule taint toegepast bij het maken van de knooppuntgroep. In het volgende voorbeeld van het YAML-manifest wordt een tolerantie gebruikt om de Kubernetes-scheduler toe te staan een NGINX-pod uit te voeren op een knooppunt in die knooppuntgroep.

  1. Maak een bestand met de naam nginx-toleration.yaml en kopieer in het volgende voorbeeld 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. Plan de pod met behulp van de kubectl apply opdracht.

    kubectl apply -f nginx-toleration.yaml

    Het duurt enkele seconden om de pod te plannen en de NGINX-installatiekopie op te halen.

  3. Controleer de status met behulp van de kubectl describe pod opdracht.

    kubectl describe pod mypod

    In de volgende verkorte voorbeelduitvoer ziet u dat de sku=gpu:NoSchedule-tolerantie wordt toegepast. In de sectie gebeurtenissen heeft de scheduler de pod toegewezen aan het knooppunt 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

    Alleen pods waarop deze tolerantie is toegepast, kunnen worden gepland op knooppunten in taintnp. Alle andere pods worden gepland in de knooppuntgroep nodepool1 . Als u meer knooppuntgroepen maakt, kunt u taints en toleranties gebruiken om te beperken welke pods op deze knooppuntresources kunnen worden gepland.

Labels voor knooppuntgroepen instellen

Zie Labels gebruiken in een AKS-cluster (Azure Kubernetes Service) voor meer informatie.

Azure-tags instellen voor knooppuntgroepen

Zie Azure-tags gebruiken in Azure Kubernetes Service (AKS) voor meer informatie.

Knooppuntgroepen beheren met behulp van een Resource Manager-sjabloon

Wanneer u een Azure Resource Manager-sjabloon gebruikt om resources te maken en beheren, kunt u instellingen in uw sjabloon wijzigen en opnieuw implementeren om resources bij te werken. Met AKS-knooppuntgroepen kunt u het oorspronkelijke knooppuntgroepprofiel niet bijwerken nadat het AKS-cluster is gemaakt. Dit gedrag betekent dat u een bestaande Resource Manager-sjabloon niet kunt bijwerken, een wijziging kunt aanbrengen in de knooppuntgroepen en de sjabloon vervolgens opnieuw kunt implementeren. In plaats daarvan moet u een afzonderlijke Resource Manager-sjabloon maken waarmee de knooppuntgroepen voor het bestaande AKS-cluster worden bijgewerkt.

  1. Maak een sjabloon, zoals aks-agentpools.jsonen plak het volgende voorbeeldmanifest. Zorg ervoor dat u de waarden indien nodig bewerkt. Met deze voorbeeldsjabloon worden de volgende instellingen geconfigureerd:

    • Werkt de Linux-knooppuntgroep met de naam myagentpool bij om drie knooppunten uit te voeren.
    • Hiermee stelt u de knooppunten in de knooppuntgroep in om Kubernetes versie 1.15.7 uit te voeren.
    • Hiermee definieert u de knooppuntgrootte als 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. Implementeer de sjabloon met behulp van de az deployment group create opdracht.

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

    Tip

    U kunt een tag toevoegen aan uw knooppuntgroep door de tag-eigenschap toe te voegen aan de sjabloon, zoals wordt weergegeven in het volgende voorbeeld:

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

    Het kan enkele minuten duren voordat uw AKS-cluster is bijgewerkt, afhankelijk van de instellingen en bewerkingen van de knooppuntgroep die u in uw Resource Manager-sjabloon definieert.

Volgende stappen