Partilhar via

Usar manchas de nó em um AKS habilitado pelo cluster do Azure Arc

  • Artigo

Aplica-se a: Azure Local, versão 23H2

Este artigo descreve como usar manchas de nó em um cluster AKS.

Descrição geral

O mecanismo de agendamento AKS é responsável por colocar pods em nós e é baseado no agendador Kubernetes upstream, kube-scheduler. Você pode restringir um pod a ser executado em nós específicos instruindo o nó a rejeitar um conjunto de pods usando manchas de nó, que interagem com o agendador AKS.

As manchas de nó funcionam marcando um nó para que o agendador evite colocar certos pods nos nós marcados. Você pode colocar tolerações em um pod para permitir que o agendador programe esse pod em um nó com uma mancha correspondente. Manchas e tolerâncias trabalham juntas para ajudá-lo a controlar como o agendador coloca pods em nós. Para obter mais informações, consulte exemplos de casos de uso de manchas e tolerâncias.

Taints são pares chave-valor com um efeito. Há três valores para o campo de efeito ao usar manchas de nó: NoExecute, NoSchedulee PreferNoSchedule.

  • NoExecute: Os pods que já estão em execução no nó são imediatamente removidos se não tiverem uma tolerância correspondente. Se um pod tiver uma tolerância correspondente, ele pode ser removido se tolerationSeconds for especificado.
  • NoSchedule: Apenas pods com uma tolerância correspondente são colocados neste nó. Os pods existentes não são removidos.
  • PreferNoSchedule: O agendador evita colocar cápsulas que não tenham uma tolerância correspondente.

Antes de começar

  • Este artigo pressupõe que você tenha um cluster AKS existente. Se precisar de um cluster AKS, você pode criar um usando a CLI do Azure, o Azure PowerShell ou o portal do Azure.
  • Ao criar um pool de nós, você pode adicionar manchas a ele. Quando você adiciona uma mancha, todos os nós dentro desse pool de nós também recebem essa mancha.

Importante

Você deve adicionar manchas ou rótulos aos nós de todo o pool de nós usando az aksarc nodepoolo . Não recomendamos o uso kubectl para aplicar manchas ou rótulos a nós individuais em um pool de nós.

Definir manchas do pool de nós

Crie um pool de nós com uma mancha usando o az aksarc nodepool add comando. Especifique o nome taintnp e use o --node-taints parâmetro para especificar sku=gpu:NoSchedule para a mancha:

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

Verifique o status do pool de nós usando o az aksarc nodepool list comando:

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

A saída de exemplo a seguir mostra que o taintnp pool de nós cria nós com o especificado nodeTaints:

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

As informações de contaminação são visíveis no Kubernetes para lidar com regras de agendamento para nós. O agendador do Kubernetes pode usar manchas e tolerâncias para restringir quais cargas de trabalho podem ser executadas em nós.

  • Uma mancha é aplicada a um nó que indica que apenas pods específicos podem ser programados neles.
  • Uma tolerância é então aplicada a um pod que lhes permite "tolerar" a mancha de um nó.

Definir tolerações do pool de nós

Na etapa anterior, você aplicou a sku=gpu:NoSchedule mancha quando criou o pool de nós. O exemplo de manifesto YAML a seguir usa uma tolerância para permitir que o agendador do Kubernetes execute um pod NGINX em um nó nesse pool de nós:

Crie um arquivo chamado nginx-toleration.yaml e copie/cole o seguinte exemplo 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"

Agende o pod usando o kubectl apply comando:

kubectl apply -f nginx-toleration.yaml

Leva alguns segundos para agendar o pod e puxar a imagem NGINX.

Verifique o status usando o kubectl describe pod comando:

kubectl describe pod mypod

A saída de exemplo condensado a seguir mostra que a sku=gpu:NoSchedule tolerância é aplicada. Na seção Eventos, o agendador atribuiu o pod ao moc-lbeof1gn6x3 nó:

[...]
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

Somente pods que têm essa tolerância aplicada podem ser programados em nós em taintnp. Quaisquer outros pods são agendados no pool de nós nodepool1 . Se você criar mais pools de nós, poderá usar taints e tolerações para limitar quais pods podem ser agendados nesses recursos de nó.

Atualizar um pool de nós de cluster para adicionar uma mancha de nó

Atualize um cluster para adicionar uma mancha de nó usando o az aksarc update comando e o --node-taints parâmetro a ser especificado sku=gpu:NoSchedule para a mancha. Todas as manchas existentes são substituídas pelos novos valores. As manchas antigas são suprimidas:

az aksarc update -g myResourceGroup --cluster-name myAKSCluster --name taintnp --node-taints "sku=gpu:NoSchedule"

Próximos passos