Administración de grupos de nodos para un clúster (AKS en Azure Stack HCI 23H2)

Artículo
02/21/2024

Se aplica a: Azure Stack HCI, versión 23H2

Nota

Para obtener información sobre cómo administrar grupos de nodos en AKS en Azure Stack HCI 22H2, consulte Administración de grupos de nodos.

En AKS habilitado por Azure Arc, los nodos de la misma configuración se agrupan en grupos de nodos. Estos grupos de nodos contienen las máquinas virtuales subyacentes que ejecutan las aplicaciones. En este artículo se muestra cómo crear y administrar grupos de nodos para un clúster en AKS Arc.

Creación de un clúster de Kubernetes

Para empezar, cree un clúster de Kubernetes con un único grupo de nodos:

az aksarc create -n <cluster name> -g <resource group> --custom-location <custom location Id> --vnet-ids <vnet id> --generate-ssh-keys --load-balancer-count <load balancer count>

Adición de un grupo de nodos

Puede agregar un grupo de nodos a un clúster existente mediante el az aksarc nodepool add comando . Asegúrese de que el nombre del grupo de nodos no es el mismo que un grupo de nodos existente:

az aksarc nodepool add --name <node pool name> -g <resource group> --cluster-name <cluster name> --os-sku <Linux or Windows> --node-count <count> --node-vm-size <vm size>

Obtención de información de configuración para un grupo de nodos

Para ver la configuración de los grupos de nodos, use el az aksarc nodepool show comando :

az aksarc nodepool show --cluster-name <cluster name> -n <node pool name> -g <resource group>

Salida de ejemplo:

{
"availabilityZones": null,
"count": 1,
"extendedLocation": null,
"id":
"/subscriptions/&lt;subscription&gt;/resourceGroups/edgeci-registration-rr1s46r1710&lt;resource
group&gt;/providers/Microsoft.Kubernetes/connectedClusters/&lt;cluster
name&gt;/providers/Microsoft.HybridContainerService/provisionedClusterInstances/default/agentPools/&lt;nodepoolname&gt;",
"location": "westeurope",
"name": "nodepoolname",
"nodeImageVersion": null,
"osSku": "CBLMariner",
"osType": "Linux",
"provisioningState": "Succeeded",
"resourceGroup": "resourcegroup",
"status": {
  "errorMessage": null,
  "operationStatus": null,
  "readyReplicas": [
   {
    "count": 1,
    "vmSize": "Standard\_A4\_v2"
   }
  ]
},
"systemData": {
…
},
"tags": null,
"type":
"microsoft.hybridcontainerservice/provisionedclusterinstances/agentpools",
"vmSize": "Standard\_A4\_v2"
}

Especificación del número máximo de pods implementados en un grupo de nodos

Puede configurar los pods máximos que se pueden implementar en un nodo en el momento de la creación del clúster o al crear nuevos grupos de nodos. Si no especifica maxPods al crear grupos de nodos, el grupo de nodos se implementa con un valor predeterminado de un máximo de 110 pods:

az aksarc nodepool add --cluster-name <cluster name> -n <node pool name> -g <resource group> --max-pods 50 --yes

Escalado de un grupo de nodos

Puede escalar o reducir verticalmente el número de nodos de los grupos de nodos.

Para escalar el número de nodos de un grupo de nodos, use el comando az aksarc nodepool scale. En el ejemplo siguiente se escala el número de nodos a 2 de un grupo de nodos denominado nodepool1:

az aksarc nodepool scale --cluster-name <cluster name> -n nodepool1 -g <resource group> --node-count 2 --yes

Eliminación de un grupo de nodos

Si necesita eliminar un grupo de nodos, use el az aksarc nodepool delete comando :

az aksarc nodepool delete --cluster-name <cluster name> -n <node pool name> -g <resource group> --yes

Especificar un valor taint o una etiqueta para un grupo de nodos

Al crear un grupo de nodos, puede agregar taints o etiquetas a él. Al agregar un valor taint o una etiqueta, todos los nodos de ese grupo de nodos también obtienen esa etiqueta o taint.

Importante

Debe agregar taints o etiquetas a los nodos para todo el grupo de nodos mediante az aksarc nodepool. No se recomienda usar kubectl para aplicar taints o etiquetas a nodos individuales de un grupo de nodos.

Establecimiento de valores taint del grupo de nodos

Cree un grupo de nodos con un valor taint mediante el comando az aksarc nodepool add. Especifique el nombre taintnp y use el --node-taints parámetro para especificar sku=gpu:NoSchedule para el valor taint:
```
az aksarc nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name taintnp \
    --node-count 1 \
    --node-taints sku=gpu:NoSchedule \
    --no-wait
```

Compruebe el estado del grupo de nodos mediante el az aksarc nodepool list comando :

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

En la salida de ejemplo siguiente se muestra que el taintnp grupo de nodos crea nodos con el especificado nodeTaints:

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

La información del valor taint está visible en Kubernetes para controlar las reglas de programación de los nodos. El programador de Kubernetes puede usar taints y tolerations para restringir qué cargas de trabajo se pueden ejecutar en los nodos.

Un valor taint se aplica a un nodo que indica que solo se pueden programar pods específicos en él.
A continuación, se aplica una tolerancia a un pod que les permite "tolerar" el valor taint de un nodo.

Establecimiento de valores toleration de grupo de nodos

En el paso anterior, aplicó el sku=gpu:NoSchedule valor taint al crear el grupo de nodos. El siguiente manifiesto YAML de ejemplo usa una tolerancia para permitir que el programador de Kubernetes ejecute un pod NGINX en un nodo de ese grupo de nodos:

Cree un archivo denominado nginx-toleration.yaml y copie o pegue el ejemplo siguiente de 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"

Programe el pod mediante el comando kubectl apply:
```
kubectl apply -f nginx-toleration.yaml
```
Se tarda unos segundos en programar el pod y extraer la imagen NGINX.

Compruebe el estado mediante el kubectl describe pod comando :

kubectl describe pod mypod

La siguiente salida de ejemplo condensada muestra que se aplica la sku=gpu:NoSchedule tolerancia. En la sección Eventos , el programador asignó el pod al moc-lbeof1gn6x3 nodo:

[...]
Tolerations:     node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                 node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
                 sku=gpu:NoSchedule
Events:
  Type    Reason     Age    From                Message
  ----    ------     ----   ----                -------
  Normal  Scheduled  54s  default-scheduler   Successfully assigned default/mypod to moc-lbeof1gn6x3
  Normal  Pulling    53s  kubelet             Pulling image "mcr.microsoft.com/oss/nginx/nginx:1.15.9-alpine"
  Normal  Pulled     48s  kubelet             Successfully pulled image "mcr.microsoft.com/oss/nginx/nginx:1.15.9-alpine" in 3.025148695s (3.025157609s including waiting)
  Normal  Created    48s  kubelet             Created container
  Normal  Started    48s  kubelet             Started container

Solo los pods que tienen esta tolerancia aplicada se pueden programar en los nodos de taintnp. Cualquier otro pod se programa en el grupo de nodos nodepool1. Si crea grupos de nodos adicionales, puede usar valores taint y toleration para limitar los pods que se pueden programar en esos recursos del nodo.

Establecimiento de etiquetas del grupo de nodos

Para más información, consulte Uso de etiquetas en un clúster de AKS habilitado para Azure Arc. ::: zone-end