Meerdere knooppuntgroepen maken en beheren voor een cluster in Azure Kubernetes Service (AKS)

In Azure Kubernetes Service (AKS) worden knooppunten van dezelfde configuratie gegroepeerd in knooppuntgroepen. Deze knooppuntgroepen bevatten de onderliggende VM's die uw toepassingen uitvoeren. Het eerste aantal knooppunten en de grootte (SKU) wordt gedefinieerd wanneer u een AKS-cluster maakt, waarmee een systeemknooppuntgroep wordt gemaakt. Als u toepassingen wilt ondersteunen die verschillende reken- of opslageisen hebben, kunt u extra gebruikers-knooppuntgroepen maken. Systeem-knooppuntgroepen dienen het primaire doel van het hosten van essentiële systeempods, zoals CoreDNS en tunnelfront. Gebruikers-knooppuntgroepen dienen het primaire doel van het hosten van uw toepassingspods. Toepassingspods kunnen echter worden gepland op systeemknooppuntgroepen als u slechts één groep in uw AKS-cluster wilt hebben. Gebruikers-knooppuntgroepen zijn de plaatsen waar u uw toepassingsspecifieke pods kunt plaatsen. Gebruik deze extra gebruikers-knooppuntgroepen bijvoorbeeld om GPU's te bieden voor rekenintensieve toepassingen of toegang tot SSD-opslag met hoge prestaties.

In dit artikel wordt beschreven hoe u meerdere knooppuntgroepen in een AKS-cluster maakt en beheert.

Voordat u begint

Azure CLI versie 2.2.0 of hoger moet zijn geïnstalleerd en geconfigureerd. Voer az --version uit om de versie te bekijken. Zie Azure CLI installeren als u de CLI wilt installeren of een upgrade wilt uitvoeren.

Beperkingen

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

• Zie Quota, groottebeperkingen voor virtuele machines en beschikbaarheid in regio's in Azure Kubernetes Service (AKS).
• U kunt systeemknooppuntgroepen verwijderen, mits u een andere systeemknooppuntgroep hebt die in het AKS-cluster moet worden gebruikt.
• Systeemgroepen moeten ten minste één knooppunt bevatten en gebruikersknooppuntgroepen kunnen nul of meer knooppunten bevatten.
• Het AKS-cluster moet de Standard SKU-load balancer om meerdere knooppuntgroepen te gebruiken. De functie wordt niet ondersteund met Basic SKU load balancers.
• Het AKS-cluster moet virtuele-machineschaalsets gebruiken voor de knooppunten.
• U kunt de VM-grootte van een knooppuntgroep niet wijzigen nadat u deze hebt aangeslagen.
• De naam van een knooppuntgroep mag alleen kleine alfanumerieke tekens bevatten en moet beginnen met een kleine letter. Voor Linux-knooppuntgroepen moet de lengte tussen 1 en 12 tekens zijn, voor Windows knooppuntgroepen moet de lengte tussen 1 en 6 tekens zijn.
• Alle knooppuntgroepen moeten zich in hetzelfde virtuele netwerk bevinden.
• Wanneer u meerdere knooppuntgroepen maakt tijdens het maken van het cluster, moeten alle Kubernetes-versies die door knooppuntgroepen worden gebruikt, overeenkomen met de versie die is ingesteld voor het besturingsvlak. Dit kan worden bijgewerkt nadat het cluster is ingericht met behulp van bewerkingen per knooppuntgroep.

Een AKS-cluster maken

Maak om te beginnen een AKS-cluster met één knooppuntgroep. In het volgende voorbeeld wordt de opdracht az group create gebruikt om een resourcegroep met de naam myResourceGroup te maken in de regio eastus. Vervolgens wordt een AKS-cluster met de naam myAKSCluster gemaakt met behulp van de opdracht 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

Het duurt een paar minuten om het cluster te maken.

Wanneer het cluster klaar is, gebruikt u de opdracht az aks get-credentials om de clusterreferenties op te halen voor gebruik met kubectl :

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

Een knooppuntgroep toevoegen

Het cluster dat in de vorige stap is gemaakt, heeft één knooppuntgroep. We gaan een tweede knooppuntgroep toevoegen met behulp van de opdracht az aks nodepool add. In het volgende voorbeeld wordt een knooppuntgroep met de naam mynodepool gemaakt waarin drie knooppunten worden uitgevoerd:

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

Als u de status van uw knooppuntgroepen wilt bekijken, gebruikt u de opdracht az aks node pool list en geeft u de resourcegroep en clusternaam op:

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

In de volgende voorbeelduitvoer ziet u dat mynodepool is gemaakt met drie knooppunten in de knooppuntgroep. Toen het AKS-cluster in de vorige stap werd gemaakt, werd er een standaardknooppuntpool1 gemaakt met het aantal knooppunt 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",
    ...
  }
]

Een knooppuntgroep met een uniek subnet toevoegen (preview)

Voor een workload moeten de knooppunten van een cluster mogelijk worden gesplitst in afzonderlijke pools voor logische isolatie. Deze isolatie kan worden ondersteund met afzonderlijke subnetten die zijn toegewezen aan elke knooppuntgroep in het cluster. Dit kan voldoen aan vereisten zoals het hebben van niet-aaneengesloten adresruimte van een virtueel netwerk die moet worden verdeeld over knooppuntgroepen.

Beperkingen

• Alle subnetten die zijn toegewezen aan knooppuntpools, moeten tot hetzelfde virtuele netwerk behoren.
• Systeempods moeten toegang hebben tot alle knooppunten/pods in het cluster om essentiële functionaliteit te bieden, zoals DNS-resolutie en tunneling van kubectl-logboeken/exec/port-forward proxy.
• Als u uw VNET uitbreidt nadat u het cluster hebt aanmaken, moet u uw cluster bijwerken (alle beheerde clusterbewerkingen uitvoeren, maar knooppuntgroepbewerkingen tellen niet) voordat u een subnet buiten de oorspronkelijke cidr toevoegt. AKS zal nu een foutmelding geven voor de agentgroep, maar dit is toegestaan. Als u niet weet hoe u uw cluster moet afstemmen, kunt u een ondersteuningsticket indienen.
• Het netwerkbeleid van Deco wordt niet ondersteund.
• Azure Network Policy wordt niet ondersteund.
• Kube-proxy verwacht één aaneengesloten cidr en gebruikt deze voor drie optmizations. Zie deze K.E.P. en --cluster-cidr hier voor meer informatie. In Azure cni wordt het subnet van uw eerste knooppuntgroep aan kube-proxy gegeven.

Als u een knooppuntgroep met een toegewezen subnet wilt maken, geeft u de resource-id van het subnet door als een extra parameter bij het maken van een knooppuntgroep.

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

Een knooppuntgroep upgraden

In de opdrachten in deze sectie wordt uitgelegd hoe u een upgrade van één specifieke knooppuntgroep kunt uitvoeren. De relatie tussen het upgraden van de Kubernetes-versie van het besturingsvlak en de knooppuntgroep wordt uitgelegd in de sectie hieronder.

Omdat er in dit voorbeeld twee knooppuntgroepen zijn, moeten we az aks nodepool upgrade gebruiken om een knooppuntgroep bij te werken. Gebruik az aks get-upgrades om de beschikbare upgrades te bekijken

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

We gaan de mynodepool upgraden. Gebruik de opdracht az aks nodepool upgrade om de knooppuntgroep bij te upgraden, zoals wordt weergegeven in het volgende voorbeeld:

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

Gebruik de opdracht az aks node pool list om de status van uw knooppuntgroepen opnieuw weer te geven. In het volgende voorbeeld ziet u dat mynodepool de status Upgrade naar 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",
    ...
  }
]

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

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

Een clusterbesturingsvlak upgraden met meerdere knooppuntgroepen

Aan een AKS-cluster zijn twee clusterresourceobjecten gekoppeld met Kubernetes-versies.

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

Een besturingsvlak wordt aan een of meer knooppuntgroepen weergegeven. Het gedrag van een upgradebewerking is afhankelijk van welke Azure CLI-opdracht wordt gebruikt.

Voor het upgraden van een AKS-besturingsvlak is het gebruik van az aks upgrade vereist. Met deze opdracht worden de versie van het besturingsvlak en alle knooppuntgroepen in het cluster geupgraded.

Als u de opdracht az aks upgrade met de vlag uit --control-plane-only geeft, wordt alleen het clusterbesturingsvlak geupgraded. Geen van de gekoppelde knooppuntgroepen in het cluster wordt gewijzigd.

Voor het upgraden van afzonderlijke knooppuntgroepen is het gebruik van az aks nodepool upgrade vereist. Met deze opdracht wordt alleen de doel-knooppuntgroep met de opgegeven Kubernetes-versie geupgraded

Validatieregels voor upgrades

De geldige Kubernetes-upgrades voor het besturingsvlak van een cluster en knooppuntgroepen worden gevalideerd door de volgende regelsets.

• Regels voor geldige versies voor het upgraden van knooppuntgroepen:

  • De versie van de knooppuntgroep moet dezelfde hoofdversie hebben als het besturingsvlak.
  • De secundaire versie van de knooppuntgroep moet binnen twee secundaire versies van de versie van het besturingsvlak zijn.
  • De versie van de knooppuntgroep mag niet groter zijn dan de versie van het major.minor.patch besturingselement.

• Regels voor het verzenden van een upgradebewerking:

  • U kunt de kubernetes-versie van het besturingsvlak of een knooppuntgroep niet downgraden.
  • Als er geen Kubernetes-versie van een knooppuntgroep is opgegeven, is het gedrag afhankelijk van de gebruikte client. Declaratie in Resource Manager-sjablonen valt terug naar de bestaande versie die is gedefinieerd voor de knooppuntgroep als deze wordt gebruikt. Als er geen is ingesteld, wordt de versie van het besturingsvlak gebruikt om op terug te vallen.
  • U kunt een besturingsvlak of een knooppuntgroep op een bepaald moment upgraden of schalen. U kunt niet meerdere bewerkingen tegelijk verzenden op één besturingsvlak of knooppuntgroep.

Een knooppuntgroep handmatig schalen

Als 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.

Gebruik de opdracht az aks node pool scale om het aantal knooppunten in een knooppuntgroep te schalen. In het volgende voorbeeld wordt het aantal knooppunten in mynodepool geschaald naar 5:

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

Gebruik de opdracht az aks node pool list om de status van uw knooppuntgroepen opnieuw weer te geven. In het volgende voorbeeld ziet u dat mynodepool de status Schalen heeft met een nieuw aantal van 5 knooppunten:

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

Het duurt enkele minuten voordat de schaalbewerking is voltooid.

Een specifieke knooppuntgroep automatisch schalen door automatische schaalvergroting van clusters in teschakelen

AKS biedt een afzonderlijke functie voor het automatisch schalen van knooppuntgroepen met een functie die de automatische schaalvergroting van clusters wordt genoemd. Deze functie kan worden ingeschakeld per knooppuntgroep met unieke minimale en maximale schaalaantal per knooppuntgroep. Meer informatie over het gebruik van de automatische schaalverdedering van clusters per knooppuntgroep.

Een knooppuntgroep verwijderen

Als u een pool niet meer nodig hebt, kunt u deze verwijderen en de onderliggende VM-knooppunten verwijderen. Als u een knooppuntgroep wilt verwijderen, gebruikt u de opdracht az aks node pool delete en geeft u de naam van de knooppuntgroep op. In het volgende voorbeeld wordt de mynoodepool verwijderd die in de vorige stappen is gemaakt:

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

De volgende voorbeelduitvoer van de opdracht az aks node pool list laat zien dat mynodepool de status Verwijderen heeft:

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

Het duurt enkele minuten om de knooppunten en de knooppuntgroep te verwijderen.

Een VM-grootte voor een knooppuntgroep opgeven

In de vorige voorbeelden voor het maken van een knooppuntgroep is een standaard-VM-grootte gebruikt voor de knooppunten die in het cluster zijn gemaakt. Een veelvoorkomende situatie is dat u knooppuntgroepen met verschillende VM-grootten en -mogelijkheden maakt. 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 stap gebruikt u taints en toleraties om de Kubernetes-scheduler te laten weten hoe de toegang kan worden beperkt tot pods die op deze knooppunten kunnen worden uitgevoerd.

In het volgende voorbeeld maakt u een op GPU gebaseerde knooppuntgroep die gebruikmaakt van Standard_NC6 VM-grootte. Deze VM's powered by de NVIDIA Tesla K80-kaart. Zie Grootten voor virtuele Linux-machines in Azure voor meer informatie over beschikbare VM-grootten.

Maak opnieuw een knooppuntgroep met behulp van de opdracht az aks node pool add. Geef deze keer de naam gpunodepool op en gebruik de parameter om de grootte --node-vm-size Standard_NC6 opgeven:

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

De volgende voorbeelduitvoer van de opdracht az aks node pool list laat zien dat gpunodepool Knooppunten maken is met de opgegeven 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",
    ...
  }
]

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 taints, labels of tags toevoegen aan die knooppuntgroep. Wanneer u een taint, label of tag toevoegt, krijgen alle knooppunten in die knooppuntgroep ook die taint, het label of de tag.

Taints voor knooppuntpool instellen

Gebruik az aks nodepool addom een knooppuntgroep met een taint te maken. Geef de naam taintnp op en gebruik de --node-taints parameter om sku=gpu:NoSchedule voor de taint op te geven.

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

De volgende voorbeelduitvoer van de opdracht az aks nodepool list laat zien dat taintnp Knooppunten maken is met de opgegeven nodeTaints:

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

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

De taint-informatie is zichtbaar in Kubernetes voor het verwerken van planningsregels voor knooppunten. De Kubernetes-scheduler kan taints en toleraties gebruiken om te beperken welke workloads op knooppunten kunnen worden uitgevoerd.

• Een taint wordt toegepast op een knooppunt dat aangeeft dat alleen specifieke pods erop kunnen worden gepland.
• Een toleratie wordt vervolgens toegepast op een pod waarmee ze de taint van een knooppunt kunnen tolereren.

Zie Best practices for advanced scheduler features in AKS (Best practices voor geavanceerde scheduler-functies in AKS) voor meer informatie over het gebruik van geavanceerde geplande Kubernetes-functies

In de vorige stap hebt u de taint sku=gpu:NoSchedule toegepast toen u de knooppuntgroep maakte. In het volgende yaml-basismanifest wordt een toleratie gebruikt om de Kubernetes-scheduler in staat te stellen een NGINX-pod uit te voeren op een knooppunt in die knooppuntgroep.

Maak een bestand met de nginx-toleration.yaml naam en kopieer het in het volgende yaml-voorbeeld:

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"

Plan de pod met behulp van de kubectl apply -f nginx-toleration.yaml opdracht :

kubectl apply -f nginx-toleration.yaml

Het duurt een paar seconden om de pod te plannen en de NGINX-afbeelding op te halen. Gebruik de opdracht kubectl describe pod om de podstatus weer te geven. In de volgende verkorte voorbeelduitvoer ziet u dat de toleratie sku=gpu:NoSchedule is toegepast. In de sectie gebeurtenissen heeft de scheduler de pod toegewezen aan het knooppunt 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

Alleen pods waarin deze toleratie is toegepast, kunnen worden gepland op knooppunten in taintnp. Alle andere pods worden gepland in de knooppuntgroep nodepool1. Als u extra knooppuntgroepen maakt, kunt u extra taints en toleraties gebruiken om te beperken welke pods kunnen worden gepland voor deze knooppuntbronnen.

Labels voor knooppuntpool instellen

U kunt ook labels toevoegen aan een knooppuntgroep tijdens het maken van de knooppuntgroep. Labels die zijn ingesteld in de knooppuntgroep worden toegevoegd aan elk knooppunt in de knooppuntgroep. Deze labels zijn zichtbaar in Kubernetes voor het verwerken van planningsregels voor knooppunten.

Gebruik az aks nodepool addom een knooppuntgroep met een label te maken. Geef de naam labelnp op en gebruik de --labels parameter om dept=IT en costcenter=9999 voor labels op te geven.

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

In de volgende voorbeelduitvoer van de opdracht az aks nodepool list ziet u dat labelnp Knooppunten maken is met de opgegeven 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"
    },
    ...
  },
 ...
]

Azure-tags voor knooppuntpool instellen

U kunt een Azure-tag toepassen op knooppuntgroepen in uw AKS-cluster. Tags die worden toegepast op een knooppuntgroep worden toegepast op elk knooppunt in de knooppuntgroep en blijven bestaan via upgrades. Tags worden ook toegepast op nieuwe knooppunten die zijn toegevoegd aan een knooppuntgroep tijdens uitschaalbewerkingen. Het toevoegen van een tag kan helpen bij taken zoals het bijhouden van beleid of kostenraming.

Azure-tags hebben sleutels die niet hoofd- en hoofd- en hoofdincidentief zijn voor bewerkingen, zoals bij het ophalen van een tag door in de sleutel te zoeken. In dit geval wordt een tag met de opgegeven sleutel bijgewerkt of opgehaald, ongeacht de hoofdingscode. Tagwaarden zijn casegevoelig.

Als in AKS meerdere tags zijn ingesteld met identieke sleutels, maar verschillende letters bevatten, is de gebruikte tag de eerste in alfabetische volgorde. Resulteert bijvoorbeeld {"Key1": "val1", "kEy1": "val2", "key1": "val3"} in en wordt Key1 val1 ingesteld.

Maak een knooppuntgroep met behulp van de az aks nodepool add. Geef de naam tagnodepool op en gebruik de --tag parameter om dept=IT en costcenter=9999 op te geven voor tags.

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

In de volgende voorbeelduitvoer van de opdracht az aks nodepool list ziet u dat tagnodepool Knooppunten maken is met de opgegeven 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"
    },
    ...
  },
 ...
]

Een voor FIPS ingeschakelde knooppuntgroep toevoegen (preview)

De Federal Information Processing Standard (FIPS) 140-2 is een Amerikaanse overheidsstandaard die minimale beveiligingsvereisten definieert voor cryptografische modules in producten en systemen voor informatietechnologie. Met AKS kunt u op Linux gebaseerde knooppuntgroepen maken met FIPS 140-2 ingeschakeld. Implementaties die worden uitgevoerd op FIPS-knooppuntgroepen kunnen deze cryptografische modules gebruiken om betere beveiliging te bieden en te voldoen aan beveiligingscontroles als onderdeel van FedRAMP-naleving. Zie voor meer informatie over FIPS 140-2 Federal Information Processing Standard (FIPS) 140-2.

Voor FIPS ingeschakelde knooppuntgroepen zijn momenteel beschikbaar als preview-versie.

U hebt de Azure CLI-extensie aks-preview versie 0.5.11 of hoger nodig. Installeer de Azure CLI-extensie aks-preview met behulp van de opdracht az extension add. U kunt ook beschikbare updates installeren met behulp van de opdracht 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

Als u de functie wilt gebruiken, moet u ook de FIPSPreview functievlag inschakelen voor uw abonnement.

Registreer de FIPSPreview functievlag met behulp van de opdracht az feature register, zoals wordt weergegeven in het volgende voorbeeld:

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

Het duurt enkele minuten voordat de status Geregistreerd we weergeven. Controleer de registratiestatus met behulp van de opdracht az feature list:

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

Wanneer u klaar bent, vernieuwt u de registratie van de resourceprovider Microsoft.ContainerService met behulp van de opdracht az provider register:

az provider register --namespace Microsoft.ContainerService

Voor FIPS ingeschakelde knooppuntgroepen gelden de volgende beperkingen:

• Op dit moment kunt u op Ubuntu 18.04 alleen OP FIPS gebaseerde op Linux gebaseerde knooppuntgroepen uitvoeren.
• Voor FIPS-knooppuntgroepen is Kubernetes versie 1.19 en hoger vereist.
• Als u de onderliggende pakketten of modules wilt bijwerken die worden gebruikt voor FIPS, moet u Node Image Upgrade gebruiken.

Als u een knooppuntgroep met FIPS wilt maken, gebruikt u az aks nodepool add met de parameter --enable-fips-image bij het maken van een knooppuntgroep.

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

Als u wilt controleren of uw knooppuntgroep FIPS is ingeschakeld, gebruikt u az aks show om de enableFIPS-waarde in agentPoolProfiles te controleren.

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

In de volgende voorbeelduitvoer ziet u dat de fipsnp-knooppuntgroep FIPS is ingeschakeld en nodepool1 niet.

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

U kunt ook controleren of implementaties toegang hebben tot de cryptografische FIPS-bibliotheken met behulp van op een knooppunt in de kubectl debug knooppuntgroep met FIPS-ondersteuning. Gebruik kubectl get nodes om de knooppunten weer te maken:

$ 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

In het bovenstaande voorbeeld maken de knooppunten die beginnen met aks-fipsnp deel uit van de fips-knooppuntgroep. Gebruik om een implementatie uit te voeren met een interactieve sessie op een van deze knooppunten in de kubectl debug knooppuntgroep met FIPS-functie.

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

In de interactieve sessie kunt u controleren of de cryptografische FIPS-bibliotheken zijn ingeschakeld:

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

Voor FIPS ingeschakelde knooppuntgroepen hebben ook een kubernetes.azure.com/fips_enabled=true-label, dat door implementaties kan worden gebruikt om deze knooppuntgroepen te targeten.

Knooppuntgroepen beheren met een Resource Manager sjabloon

Wanneer u een Azure Resource Manager gebruikt om resources te maken en te beheren, kunt u doorgaans de instellingen in uw sjabloon bijwerken en opnieuw toepassen om de resource bij te werken. Met knooppuntgroepen in AKS kan het profiel van de initiële knooppuntgroep niet worden bijgewerkt zodra het AKS-cluster is gemaakt. Dit gedrag betekent dat u geen bestaande Resource Manager kunt bijwerken, de knooppuntgroepen niet kunt wijzigen en opnieuw kunt toepassen. In plaats daarvan moet u een afzonderlijke Resource Manager maken die alleen de knooppuntgroepen voor een bestaand AKS-cluster bij werkt.

Maak een sjabloon zoals aks-agentpools.json en plak het volgende voorbeeldmanifest. 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.
• Definieert de knooppuntgrootte als Standard_DS2_v2.

Bewerk deze waarden zo nodig om knooppuntgroepen bij te werken, toe te voegen of te verwijderen:

{
    "$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"
            }
        }
    ]
}

Implementeer deze sjabloon met behulp van de opdracht az deployment group create, zoals wordt weergegeven in het volgende voorbeeld. U wordt gevraagd om de naam en locatie van het bestaande AKS-cluster:

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

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

Het kan enkele minuten duren om uw AKS-cluster bij te werken, afhankelijk van de instellingen en bewerkingen van de knooppuntgroep die u in de sjabloon Resource Manager definiëren.

Een openbaar IP-adres per knooppunt toewijzen voor uw knooppuntgroepen

AKS-knooppunten hebben geen eigen openbare IP-adressen nodig voor communicatie. In scenario's kunnen knooppunten in een knooppuntgroep echter hun eigen toegewezen openbare IP-adressen ontvangen. Een veelvoorkomende situatie is voor gamingworkloads, waarbij een console een directe verbinding moet maken met een virtuele machine in de cloud om hops te minimaliseren. Dit scenario kan worden bereikt in AKS met behulp van openbaar IP-adres van knooppunt.

Maak eerst een nieuwe resourcegroep.

az group create --name myResourceGroup2 --location eastus

Maak een nieuw AKS-cluster en koppel een openbaar IP-adres voor uw knooppunten. Elk van de knooppunten in de knooppuntgroep ontvangt een uniek openbaar IP-adres. U kunt dit controleren door te kijken naar de exemplaren van de virtuele-machineschaalset.

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

Voor bestaande AKS-clusters kunt u ook een nieuwe knooppuntgroep toevoegen en een openbaar IP-adres voor uw knooppunten koppelen.

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

Een openbaar IP-voorvoegsel gebruiken

Het gebruik van een openbaar IP-voorvoegselheeft een aantal voordelen. AKS ondersteunt het gebruik van adressen van een bestaand openbaar IP-voorvoegsel voor uw knooppunten door de resource-id met de vlag door te geven bij het maken van een nieuw cluster of het toevoegen van een node-public-ip-prefix knooppuntgroep.

Maak eerst een openbaar IP-voorvoegsel met az network public-ip prefix create:

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

Bekijk de uitvoer en noteer de id voor het voorvoegsel:

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

Gebruik ten slotte bij het maken van een nieuw cluster of het toevoegen van een nieuwe knooppuntgroep de vlag en geef de resource-id van het node-public-ip-prefix voorvoegsel door:

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

Openbare IP's voor knooppunten zoeken

U kunt de openbare IP's voor uw knooppunten op verschillende manieren vinden:

• Gebruik de Azure CLI-opdracht az vmss list-instance-public-ips.
• Gebruik PowerShell- of Bash-opdrachten.
• U kunt ook de openbare IP's in de Azure Portal door de exemplaren in de virtuele-machineschaalset te bekijken.

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

Resources opschonen

In dit artikel hebt u een AKS-cluster gemaakt dat gpu-knooppunten bevat. Om onnodige kosten te verminderen, kunt u de gpunodepool of het hele AKS-cluster verwijderen.

Als u de op GPU gebaseerde knooppuntgroep wilt verwijderen, gebruikt u de opdracht az aks nodepool delete, zoals wordt weergegeven in het volgende voorbeeld:

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

Als u het cluster zelf wilt verwijderen, gebruikt u de opdracht az group delete om de AKS-resourcegroep te verwijderen:

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

U kunt ook het extra cluster verwijderen dat u hebt gemaakt voor het openbare IP-adres voor knooppuntgroepen.

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

Volgende stappen

Meer informatie over systeem-knooppuntgroepen.

In dit artikel hebt u geleerd hoe u meerdere knooppuntgroepen in een AKS-cluster maakt en beheert. Zie Best practices for advanced scheduler features in AKS (Best practicesvoor geavanceerde scheduler-functies in AKS) voor meer informatie over het beheer van pods in knooppuntgroepen.

Zie Create a Windows Server container in AKS (Een Windows Server-container maken in AKS) voor informatie over het maken en gebruiken van Windows servercontainer-knooppuntgroepen.

Gebruik nabijheidsplaatsingsgroepen om de latentie voor uw AKS-toepassingen te verminderen.