Zarządzanie pulami węzłów dla klastra w usłudze Azure Kubernetes Service (AKS)

W usłudze Azure Kubernetes Service (AKS) węzły tej samej konfiguracji są grupowane razem w pule węzłów. Te pule węzłów zawierają bazowe maszyny wirtualne, na których są uruchamiane aplikacje. Podczas tworzenia klastra usługi AKS należy zdefiniować początkową liczbę węzłów i ich rozmiar (SKU). W miarę zmiany wymagań aplikacji może być konieczne zmianę ustawień w pulach węzłów. Na przykład może być konieczne skalowanie liczby węzłów w puli węzłów lub uaktualnienie wersji kubernetes puli węzłów.

W tym artykule pokazano, jak zarządzać co najmniej jedną pulą węzłów w klastrze usługi AKS.

Zanim rozpoczniesz

• Zapoznaj się z artykułem Tworzenie pul węzłów dla klastra w usłudze Azure Kubernetes Service (AKS), aby dowiedzieć się, jak tworzyć pule węzłów dla klastrów usługi AKS.
• Potrzebny jest interfejs wiersza polecenia platformy Azure w wersji 2.2.0 lub nowszej zainstalowany i skonfigurowany. Uruchom polecenie az --version, aby dowiedzieć się, jaka wersja jest używana. Jeśli konieczna będzie instalacja lub uaktualnienie, zobacz Instalowanie interfejsu wiersza polecenia platformy Azure.
• Przejrzyj opcje magazynu dla aplikacji w usłudze Azure Kubernetes Service , aby zaplanować konfigurację magazynu.

Ograniczenia

Podczas tworzenia klastrów usługi AKS obsługujących wiele pul węzłów i zarządzania nimi obowiązują następujące ograniczenia:

• Zobacz Limity przydziału, ograniczenia rozmiaru maszyny wirtualnej i dostępność regionów w usłudze Azure Kubernetes Service (AKS).
• Pule systemu muszą zawierać co najmniej jeden węzeł, a pule węzłów użytkownika mogą zawierać zero lub więcej węzłów.
• Nie można zmienić rozmiaru maszyny wirtualnej puli węzłów po jej utworzeniu.
• Podczas tworzenia wielu pul węzłów w czasie tworzenia klastra wszystkie wersje platformy Kubernetes używane przez pule węzłów muszą być zgodne z wersją ustawioną dla płaszczyzny sterowania. Aktualizacje można wprowadzać po aprowizacji klastra przy użyciu operacji puli węzłów.
• Nie można jednocześnie uruchamiać operacji uaktualniania i skalowania w klastrze lub puli węzłów. Jeśli próbujesz uruchomić je w tym samym czasie, zostanie wyświetlony błąd. Każdy typ operacji musi zostać ukończony w zasobie docelowym przed następnym żądaniem dla tego samego zasobu. Aby uzyskać więcej informacji, zobacz przewodnik rozwiązywania problemów.

Uaktualnianie pojedynczej puli węzłów

Uwaga

Wersja obrazu systemu operacyjnego puli węzłów jest powiązana z wersją klastra Kubernetes. Uaktualnienia obrazu systemu operacyjnego są uzyskiwane tylko po uaktualnieniu klastra.

W tym przykładzie uaktualniamy pulę węzłów mynodepool . Ponieważ istnieją dwie pule węzłów, musimy użyć az aks nodepool upgrade polecenia w celu uaktualnienia.

1. Sprawdź dostępność dostępnych uaktualnień przy użyciu az aks get-upgrades polecenia .

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

2. Uaktualnij pulę węzłów mynodepool przy użyciu az aks nodepool upgrade polecenia .

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

3. Wyświetl stan pul węzłów przy użyciu az aks nodepool list polecenia .

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

   Następujące przykładowe dane wyjściowe pokazują, że pula mynodepool jest w stanie Uaktualnianie :

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

   Uaktualnienie węzłów do określonej wersji może potrwać kilka minut.

Najlepszym rozwiązaniem jest uaktualnienie wszystkich pul węzłów w klastrze usługi AKS do tej samej wersji rozwiązania Kubernetes. Domyślne zachowanie polega az aks upgrade na uaktualnieniu wszystkich pul węzłów razem z płaszczyzną sterowania w celu osiągnięcia tego wyrównania. Możliwość uaktualniania poszczególnych pul węzłów umożliwia przeprowadzenie uaktualnienia stopniowego i zaplanowanie zasobników między pulami węzłów w celu zachowania czasu działania aplikacji w ramach powyższych ograniczeń.

Uaktualnianie płaszczyzny sterowania klastra przy użyciu wielu pul węzłów

Uwaga

Platforma Kubernetes używa standardowego schematu przechowywania wersji semantycznych. Numer wersji jest wyrażony jako x.y.z, gdzie x jest wersją główną, y jest wersją pomocniczą, a z jest wersją poprawki. Na przykład w wersji 1.12.6 1 jest wersją główną, 12 jest wersją pomocniczą, a 6 jest wersją poprawki. Wersja platformy Kubernetes płaszczyzny sterowania i początkowa pula węzłów są ustawiane podczas tworzenia klastra. Inne pule węzłów mają ustawioną wersję platformy Kubernetes po dodaniu ich do klastra. Wersje platformy Kubernetes mogą się różnić między pulami węzłów i między pulą węzłów a płaszczyzną sterowania.

Klaster usługi AKS ma dwa obiekty zasobów klastra z skojarzonymi wersjami platformy Kubernetes:

1. Wersja platformy Kubernetes płaszczyzny sterowania klastra i
2. Pula węzłów z wersją platformy Kubernetes.

Płaszczyzna sterowania mapuje na jedną lub wiele pul węzłów. Zachowanie operacji uaktualniania zależy od używanego polecenia interfejsu wiersza polecenia platformy Azure.

• az aks upgrade uaktualnia płaszczyznę sterowania i wszystkie pule węzłów w klastrze do tej samej wersji platformy Kubernetes.
• az aks upgrade flaga --control-plane-only uaktualnia tylko płaszczyznę sterowania klastra i pozostawia wszystkie pule węzłów bez zmian.
• az aks nodepool upgrade uaktualnia tylko docelową pulę węzłów z określoną wersją platformy Kubernetes.

Reguły walidacji uaktualnień

Uaktualnienia platformy Kubernetes dla płaszczyzny sterowania klastra i pul węzłów są weryfikowane przy użyciu następujących zestawów reguł:

• Reguły dotyczące prawidłowych wersji uaktualniania pul węzłów:

  • Wersja puli węzłów musi mieć taką samą wersję główną jak płaszczyzna sterowania.
  • Wersja pomocnicza puli węzłów musi należeć do dwóch wersji pomocniczych wersji płaszczyzny sterowania.
  • Wersja puli węzłów nie może być większa niż wersja kontroli major.minor.patch .

• Reguły przesyłania operacji uaktualniania:

  • Nie można obniżyć poziomu płaszczyzny sterowania ani wersji kubernetes puli węzłów.
  • Jeśli nie określono wersji platformy Kubernetes puli węzłów, zachowanie zależy od klienta. W szablonach usługi Resource Manager deklaracja powraca do istniejącej wersji zdefiniowanej dla puli węzłów. Jeśli nic nie jest ustawione, używa wersji płaszczyzny sterowania, aby wrócić.
  • Nie można jednocześnie przesyłać wielu operacji na jednej płaszczyźnie sterowania lub zasobie puli węzłów. Możesz uaktualnić lub skalować płaszczyznę sterowania lub pulę węzłów w danym momencie.

Ręczne skalowanie puli węzłów

W miarę zmiany zapotrzebowania na obciążenie aplikacji może być konieczne skalowanie liczby węzłów w puli węzłów. Liczbę węzłów można skalować w górę lub w dół.

1. Skaluj liczbę węzłów w puli węzłów przy użyciu az aks node pool scale polecenia .

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

2. Wyświetl stan pul węzłów przy użyciu az aks node pool list polecenia .

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

   Następujące przykładowe dane wyjściowe pokazują, że pula mynodepool znajduje się w stanie Skalowanie z nową liczbą pięciu węzłów:

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

   Ukończenie operacji skalowania trwa kilka minut.

Automatyczne skalowanie określonej puli węzłów przy użyciu narzędzia do automatycznego skalowania klastra

Usługa AKS oferuje oddzielną funkcję umożliwiającą automatyczne skalowanie pul węzłów za pomocą funkcji nazywanej funkcją automatycznego skalowania klastra. Tę funkcję można włączyć z unikatowymi minimalnymi i maksymalnymi liczbami skalowania na pulę węzłów.

Aby uzyskać więcej informacji, zobacz Używanie narzędzia do automatycznego skalowania klastra.

Usuwanie określonych maszyn wirtualnych w istniejącej puli węzłów

Uwaga

Po usunięciu maszyny wirtualnej za pomocą tego polecenia usługa AKS nie wykonuje kordonu i opróżniania. Aby zminimalizować zakłócenia ponownego uruchamiania zasobników aktualnie uruchomionych na maszynie wirtualnej, którą planujesz usunąć, przed usunięciem wykonaj kordon i opróżnij je. Więcej informacji na temat sposobu kordonu i opróżniania można dowiedzieć się, korzystając z przykładowego scenariusza przedstawionego w samouczku dotyczącym zmiany rozmiaru pul węzłów.

1. Wyświetl listę istniejących węzłów przy użyciu kubectl get nodes polecenia .

   kubectl get nodes
   

   Dane wyjściowe powinny wyglądać podobnie do następujących przykładowych danych wyjściowych:

   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. Usuń określone maszyny wirtualne przy użyciu az aks nodepool delete-machines polecenia . Pamiętaj, aby zastąpić symbole zastępcze własnymi wartościami.

   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. Sprawdź, czy maszyny wirtualne zostały pomyślnie usunięte przy użyciu kubectl get nodes polecenia .

   kubectl get nodes
   

   Dane wyjściowe nie powinny już zawierać maszyn wirtualnych określonych w poleceniu az aks nodepool delete-machines .

Kojarzenie grup rezerwacji pojemności z pulami węzłów

W miarę zmiany zapotrzebowania na obciążenie można skojarzyć istniejące grupy rezerwacji pojemności z pulami węzłów, aby zagwarantować przydzieloną pojemność dla pul węzłów.

Wymagania wstępne dotyczące używania grup rezerwacji pojemności w usłudze AKS

• Użyj interfejsu wiersza polecenia w wersji 2.56 lub nowszej i interfejsu API w wersji 2023-10-01 lub nowszej.

• Grupa rezerwacji pojemności powinna już istnieć i powinna zawierać minimalną jedną rezerwację pojemności. W przeciwnym razie pula węzłów zostanie dodana do klastra z ostrzeżeniem i nie zostanie skojarzona żadna grupa rezerwacji pojemności. Aby uzyskać więcej informacji, zobacz grupy rezerwacji pojemności.

• Musisz utworzyć tożsamość zarządzaną przypisaną przez użytkownika dla grupy zasobów zawierającej grupę rezerwacji pojemności (CRG). Tożsamości zarządzane przypisane przez system nie będą działać w przypadku tej funkcji. W poniższym przykładzie zastąp zmienne środowiskowe własnymi wartościami.

  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)
  

• Musisz przypisać Contributor rolę do tożsamości przypisanej przez użytkownika utworzonej powyżej. Aby uzyskać więcej informacji, zobacz Kroki przypisywania roli platformy Azure.

• Utwórz nowy klaster i przypisz nowo utworzoną tożsamość.

    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 
  

• Tożsamość zarządzana przez użytkownika można również przypisać do istniejącego klastra zarządzanego za pomocą polecenia 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         
  

Kojarzenie istniejącej grupy rezerwacji pojemności z pulą węzłów

Skojarz istniejącą grupę rezerwacji pojemności z pulą węzłów przy użyciu az aks nodepool add polecenia i określ grupę rezerwacji pojemności z flagą --crg-id . W poniższym przykładzie przyjęto założenie, że masz grupę CRG o nazwie "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

Kojarzenie istniejącej grupy rezerwacji pojemności z pulą węzłów systemowych

Aby skojarzyć istniejącą grupę rezerwacji pojemności z pulą węzłów systemowych, skojarz klaster z tożsamością przypisaną przez użytkownika z rolą Współautor w grupie CRG i samą grupą CRG podczas tworzenia klastra. az aks create Użyj polecenia z flagami --assign-identity i --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

Uwaga

Usunięcie puli węzłów niejawnie powoduje skojarzenie tej puli węzłów z dowolnej skojarzonej grupy rezerwacji pojemności przed usunięciem puli węzłów. Usunięcie klastra niejawnie powoduje skojarzenie wszystkich pul węzłów w tym klastrze ze skojarzonych grup rezerwacji pojemności.

Uwaga

Nie można zaktualizować istniejącej puli węzłów za pomocą grupy rezerwacji pojemności. Zalecaną metodą jest skojarzenie grupy rezerwacji pojemności podczas tworzenia puli węzłów.

Określanie rozmiaru maszyny wirtualnej dla puli węzłów

Może być konieczne utworzenie pul węzłów o różnych rozmiarach i możliwościach maszyn wirtualnych. Można na przykład utworzyć pulę węzłów zawierającą węzły z dużą ilością procesora CPU lub pamięci lub puli węzłów, która zapewnia obsługę procesora GPU. W następnej sekcji użyjesz defektów i tolerancji , aby poinformować harmonogram platformy Kubernetes, jak ograniczyć dostęp do zasobników, które mogą być uruchamiane w tych węzłach.

W poniższym przykładzie utworzymy pulę węzłów opartą na procesorze GPU, która używa rozmiaru maszyny wirtualnej Standard_NC6s_v3. Te maszyny wirtualne są obsługiwane przez kartę NVIDIA Tesla K80. Aby uzyskać informacje, zobacz Dostępne rozmiary maszyn wirtualnych z systemem Linux na platformie Azure.

1. Utwórz pulę węzłów przy użyciu az aks node pool add polecenia . Określ nazwę gpunodepool i użyj parametru --node-vm-size , aby określić rozmiar Standard_NC6 .

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

2. Sprawdź stan puli węzłów przy użyciu az aks nodepool list polecenia .

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

   Poniższe przykładowe dane wyjściowe pokazują, że pula węzłów gpunodepool to Tworzenie węzłów o określonym rozmiarze maszyny wirtualnej:

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

   Pomyślne utworzenie puli gpunodepool trwa kilka minut.

Określanie defektu, etykiety lub tagu dla puli węzłów

Podczas tworzenia puli węzłów można do niej dodawać znaki, etykiety lub tagi. Po dodaniu defektu, etykiety lub tagu wszystkie węzły w tej puli węzłów również uzyskają ten znak, etykietę lub tag.

Ważne

Dodawanie etykiet, etykiet lub tagów do węzłów powinno odbywać się dla całej puli węzłów przy użyciu polecenia az aks nodepool. Nie zalecamy stosowania kubectl defektów, etykiet ani tagów do poszczególnych węzłów w puli węzłów.

Ustawianie parametrów puli węzłów

Usługa AKS obsługuje dwa rodzaje defektów węzłów: defekty węzłów i inicjacje węzłów (wersja zapoznawcza). Aby uzyskać więcej informacji, zobacz Use node taints in an Azure Kubernetes Service (AKS) cluster (Używanie defektów węzłów w klastrze usługi Azure Kubernetes Service (AKS).

Aby uzyskać więcej informacji na temat korzystania z zaawansowanych funkcji zaplanowanych na platformie Kubernetes, zobacz Najlepsze rozwiązania dotyczące zaawansowanych funkcji harmonogramu w usłudze AKS

Ustawianie tolerancji puli węzłów

W poprzednim kroku zastosowano metodę sku=gpu:NoSchedule taint podczas tworzenia puli węzłów. Poniższy przykładowy manifest YAML używa tolerancji, aby umożliwić harmonogramowi Kubernetes uruchamianie zasobnika NGINX w węźle w tej puli węzłów.

1. Utwórz plik o nazwie nginx-toleration.yaml i skopiuj go w poniższym przykładzie 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. Zaplanuj zasobnik przy użyciu kubectl apply polecenia .

   kubectl apply -f nginx-toleration.yaml
   

   Zaplanowanie zasobnika i ściągnięcie obrazu NGINX zajmuje kilka sekund.

3. Sprawdź stan przy użyciu kubectl describe pod polecenia .

   kubectl describe pod mypod
   

   Następujące skrócone przykładowe dane wyjściowe pokazują, że zastosowano tolerancję sku=gpu:NoSchedule . W sekcji zdarzeń harmonogram przypisał zasobnik do węzła 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
   

   Tylko zasobniki, które mają tę tolerancję, można zaplanować na węzłach w narzędziu taintnp. Wszystkie inne zasobniki są zaplanowane w puli węzłów nodepool1 . Jeśli tworzysz więcej pul węzłów, możesz użyć defektów i tolerancji, aby ograniczyć harmonogram zasobników w tych zasobach węzłów.

Ustawianie etykiet puli węzłów

Aby uzyskać więcej informacji, zobacz Używanie etykiet w klastrze usługi Azure Kubernetes Service (AKS).

Ustawianie tagów platformy Azure puli węzłów

Aby uzyskać więcej informacji, zobacz Używanie tagów platformy Azure w usłudze Azure Kubernetes Service (AKS).

Zarządzanie pulami węzłów przy użyciu szablonu usługi Resource Manager

Gdy używasz szablonu usługi Azure Resource Manager do tworzenia zasobów i zarządzania nimi, możesz zmienić ustawienia w szablonie i wdrożyć je ponownie, aby zaktualizować zasoby. W przypadku pul węzłów usługi AKS nie można zaktualizować początkowego profilu puli węzłów po utworzeniu klastra usługi AKS. To zachowanie oznacza, że nie można zaktualizować istniejącego szablonu usługi Resource Manager, wprowadzić zmianę w pulach węzłów, a następnie ponownie wdrożyć szablon. Zamiast tego należy utworzyć oddzielny szablon usługi Resource Manager, który aktualizuje pule węzłów dla istniejącego klastra usługi AKS.

1. Utwórz szablon, taki jak aks-agentpools.json, i wklej następujący przykładowy manifest. Pamiętaj, aby edytować wartości zgodnie z potrzebami. Ten przykładowy szablon konfiguruje następujące ustawienia:

   • Aktualizuje pulę węzłów systemu Linux o nazwie myagentpool , aby uruchomić trzy węzły.
   • Ustawia węzły w puli węzłów, aby uruchomić platformę Kubernetes w wersji 1.15.7.
   • Definiuje rozmiar węzła jako 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. Wdróż szablon przy użyciu az deployment group create polecenia .

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

   Napiwek

   Tag można dodać do puli węzłów, dodając właściwość tagu w szablonie, jak pokazano w poniższym przykładzie:

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

   Zaktualizowanie klastra usługi AKS w zależności od ustawień puli węzłów i operacji zdefiniowanych w szablonie usługi Resource Manager może potrwać kilka minut.

Następne kroki

• Aby uzyskać więcej informacji na temat kontrolowania zasobników w pulach węzłów, zobacz Najlepsze rozwiązania dotyczące zaawansowanych funkcji harmonogramu w usłudze AKS.
• Użyj grup umieszczania w pobliżu, aby zmniejszyć opóźnienie aplikacji usługi AKS.
• Użyj publicznych adresów IP na poziomie wystąpienia, aby umożliwić węzłom bezpośrednie obsługiwanie ruchu.