Specify that Arm or multi-architecture workloads are scheduled to Arm virtual nodes - Container Service for Kubernetes: Central de Documentação do Alibaba Cloud

Cluster ACK Serverless agenda todos os workloads para nós virtuais x86 por padrão. Se o seu cluster possuir nós virtuais Arm e não Arm, como nós virtuais x86, utilize as configurações nativas de agendamento do Kubernetes. Essas configurações garantem que workloads exclusivos para Arm sejam agendados em nós virtuais Arm, ou que imagens multiarquitetura tenham preferência de agendamento em nós virtuais Arm.

Pré-requisitos

Cluster:

Crie um cluster ACK Serverless que execute a versão 1.20 ou posterior. Para mais informações, consulte Create an ACK Serverless cluster e Manually upgrade a cluster.

Nota
As instâncias ECS baseadas em Arm estão disponíveis apenas em regiões e zonas específicas. Certifique-se de que seu cluster esteja em uma região suportada. Para visualizar as regiões e zonas onde as instâncias ECS baseadas em Arm estão disponíveis, consulte Visão geral das regiões e zonas onde os tipos de instância ECS estão disponíveis para compra.
Add-on: Instale o add-on ack-virtual-node v2.9.0 ou posterior. Para mais informações, consulte ACK Virtual Node.

Observações de uso

Se o seu cluster executar uma versão anterior à 1,24 e você utilizar nodeSelector ou nodeAffinity para agendar uma aplicação em um nó Arm, declare também uma tolerância para o taint kubernetes.io/arch=arm64:NoSchedule em tolerations. Caso o cluster execute a versão 1.24 ou posterior, o agendador identifica automaticamente o taint kubernetes.io/arch=arm64:NoSchedule nos nós Arm, eliminando a necessidade de declarar tolerations adicionais.

Faturamento

apiVersion: apps/v1
kind: Deployment
metadata:
  name: amd-prefer
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      tolerations:
      # Tolerate the virtual node taint.
      - key: virtual-kubelet.io/provider
        operator: Exists
        effect: NoSchedule
      # Tolerate the taint on the Arm virtual node.
      - key: kubernetes.io/arch
        operator: Equal
        value: arm64
        effect: NoSchedule     
      # Prefer scheduling to a node that uses the x86 architecture.
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: kubernetes.io/arch
                operator: In
                values:
                - amd64
      containers:
      - name: my-container
        image: nginx

Tipos de instância ECS baseados em ARM e preços:

Etapa 1: Adicione nós virtuais Arm

Antes de implantar workloads Arm em um cluster, crie nós virtuais Arm. Configure o Elastic Container Instance (ECI) Profile para gerar nós virtuais compatíveis com a arquitetura Arm. Edite o ConfigMap eci-profile de uma das duas maneiras a seguir. Para mais detalhes sobre o ECI Profile, consulte Configure an eci-profile.

Console

Faça login no console do ACK. No painel de navegação à esquerda, clique em Clusters.
Na página Clusters, clique no nome do seu cluster. No painel de navegação à esquerda, clique em Configurations > ConfigMaps.
Defina o Namespace como kube-system. Localize o eci-profile e clique em Edit. Altere o valor da chave enableLinuxArm64Node para true e clique em OK.

Nota
Caso nenhuma das zonas que contenham os vSwitches existentes do seu cluster suporte instâncias ECS baseadas em Arm, crie primeiro um vSwitch em uma zona suportada. Após a criação, adicione o ID dele em vSwitchIds. Para instruções, consulte Create and manage vSwitches.

kubectl

Pré-requisitos

Connect to an ACK cluster using kubectl.

Procedimento

Execute o comando a seguir para editar o ConfigMap.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: amd-prefer
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      tolerations:
      # Tolerate the virtual node taint.
      - key: virtual-kubelet.io/provider
        operator: Exists
        effect: NoSchedule
      # Tolerate the taint on the Arm virtual node.
      - key: kubernetes.io/arch
        operator: Equal
        value: arm64
        effect: NoSchedule     
      # Prefer scheduling to a node that uses the x86 architecture.
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: kubernetes.io/arch
                operator: In
                values:
                - amd64
      containers:
      - name: my-container
        image: nginx

Adicione o parâmetro enableLinuxArm64Node ou modifique seu valor para true.
Configure vSwitchIds e garanta que os vSwitchIds do cluster atual incluam pelo menos um vSwitch em uma zona compatível com instâncias ECS baseadas em Arm.

Nota
Caso nenhuma das zonas que contenham os vSwitches existentes do seu cluster suporte instâncias ECS baseadas em Arm, crie primeiro um vSwitch em uma zona suportada. Após a criação, adicione o ID dele em vSwitchIds. Para instruções, consulte Create and manage vSwitches.

Etapa 2: Agende workloads para nós virtuais Arm

Agende workloads Arm para nós virtuais Arm

Se o seu cluster tiver nós Arm e não Arm, e sua aplicação suportar apenas a arquitetura Arm, especifique que a aplicação deve rodar em nós Arm. Isso evita que os pods da aplicação sejam agendados em nós não Arm e falhem ao iniciar. Por padrão, todos os nós Arm possuem o rótulo kubernetes.io/arch=arm64. Utilize nodeSelector ou nodeAffinity para implantar a aplicação em nós Arm.

nodeSelector

Adicione a restrição a seguir a um pod e use nodeSelector para agendá-lo em um nó virtual Arm. O nodeSelector agenda esse workload apenas em nós que possuem o rótulo arm64. Todos os nós virtuais Arm em cluster ACK Serverless têm esse rótulo.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: amd-prefer
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      tolerations:
      # Tolerate the virtual node taint.
      - key: virtual-kubelet.io/provider
        operator: Exists
        effect: NoSchedule
      # Tolerate the taint on the Arm virtual node.
      - key: kubernetes.io/arch
        operator: Equal
        value: arm64
        effect: NoSchedule     
      # Prefer scheduling to a node that uses the x86 architecture.
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: kubernetes.io/arch
                operator: In
                values:
                - amd64
      containers:
      - name: my-container
        image: nginx

Utilize o código de exemplo a seguir para implantar uma aplicação stateless em um nó virtual Arm.

Expanda para visualizar o arquivo YAML

Nota

O arquivo YAML a seguir adiciona uma tolerância para o taint kubernetes.io/arch=arm64:NoSchedule. Se o seu cluster for um cluster ACK gerenciado Pro que execute a versão 1.24 ou posterior, o agendador do ACK identifica automaticamente esse taint, eliminando a necessidade de declarar uma tolerância adicional.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: amd-prefer
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      tolerations:
      # Tolerate the virtual node taint.
      - key: virtual-kubelet.io/provider
        operator: Exists
        effect: NoSchedule
      # Tolerate the taint on the Arm virtual node.
      - key: kubernetes.io/arch
        operator: Equal
        value: arm64
        effect: NoSchedule     
      # Prefer scheduling to a node that uses the x86 architecture.
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: kubernetes.io/arch
                operator: In
                values:
                - amd64
      containers:
      - name: my-container
        image: nginx

nodeAffinity

Pré-requisitos

Conclua as operações descritas em Enable pod scheduling policies on virtual nodes, e verifique se a versão do cluster e a versão do add-on atendem aos requisitos.

Exemplo

Adicione a restrição a seguir a um pod e utilize a afinidade de nó para implantar a aplicação em nós Arm. Essa restrição especifica que o pod só pode ser agendado em nós com o rótulo kubernetes.io/arm=arm64.

Quando a especificação do pod contém essa restrição, o agendador tolera automaticamente o taint kubernetes.io/arch=arm64:NoSchedule no nó.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: amd-prefer
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      tolerations:
      # Tolerate the virtual node taint.
      - key: virtual-kubelet.io/provider
        operator: Exists
        effect: NoSchedule
      # Tolerate the taint on the Arm virtual node.
      - key: kubernetes.io/arch
        operator: Equal
        value: arm64
        effect: NoSchedule     
      # Prefer scheduling to a node that uses the x86 architecture.
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: kubernetes.io/arch
                operator: In
                values:
                - amd64
      containers:
      - name: my-container
        image: nginx

Utilize o código de exemplo a seguir para implantar uma aplicação stateless em um nó virtual Arm.

Expanda para visualizar o arquivo YAML

Nota

apiVersion: apps/v1
kind: Deployment
metadata:
  name: amd-prefer
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      tolerations:
      # Tolerate the virtual node taint.
      - key: virtual-kubelet.io/provider
        operator: Exists
        effect: NoSchedule
      # Tolerate the taint on the Arm virtual node.
      - key: kubernetes.io/arch
        operator: Equal
        value: arm64
        effect: NoSchedule     
      # Prefer scheduling to a node that uses the x86 architecture.
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: kubernetes.io/arch
                operator: In
                values:
                - amd64
      containers:
      - name: my-container
        image: nginx

Agende imagens multiarquitetura para nós virtuais Arm

Pré-requisitos

Conclua as operações descritas em Enable pod scheduling policies on virtual nodes, e verifique se a versão do cluster e a versão do add-on atendem aos requisitos.

Exemplo

Cluster ACK Serverless agenda todos os workloads para nós virtuais x86 por padrão. Quando os recursos dos nós x86 forem insuficientes, o cluster continuará aguardando por eles. Se a imagem da sua aplicação for multiarquitetura, como uma que suporte tanto x86 quanto Arm, configure o agendamento de nós entre as duas arquiteturas.

Por exemplo, configure a afinidade de nó para agendar preferencialmente um workload em nós virtuais Arm ou x86, tentando agendá-lo em um nó virtual da outra arquitetura quando os recursos do tipo alvo forem insuficientes.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: amd-prefer
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      tolerations:
      # Tolerate the virtual node taint.
      - key: virtual-kubelet.io/provider
        operator: Exists
        effect: NoSchedule
      # Tolerate the taint on the Arm virtual node.
      - key: kubernetes.io/arch
        operator: Equal
        value: arm64
        effect: NoSchedule     
      # Prefer scheduling to a node that uses the x86 architecture.
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: kubernetes.io/arch
                operator: In
                values:
                - amd64
      containers:
      - name: my-container
        image: nginx

Preferir arquitetura Arm

O exemplo a seguir declara uma preferência para agendar workloads em nós virtuais Arm.

Expanda para visualizar o arquivo YAML

Nota

apiVersion: apps/v1
kind: Deployment
metadata:
  name: amd-prefer
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      tolerations:
      # Tolerate the virtual node taint.
      - key: virtual-kubelet.io/provider
        operator: Exists
        effect: NoSchedule
      # Tolerate the taint on the Arm virtual node.
      - key: kubernetes.io/arch
        operator: Equal
        value: arm64
        effect: NoSchedule     
      # Prefer scheduling to a node that uses the x86 architecture.
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: kubernetes.io/arch
                operator: In
                values:
                - amd64
      containers:
      - name: my-container
        image: nginx

Preferir arquitetura x86

Expanda para visualizar o arquivo YAML

Nota

apiVersion: apps/v1
kind: Deployment
metadata:
  name: amd-prefer
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      tolerations:
      # Tolerate the virtual node taint.
      - key: virtual-kubelet.io/provider
        operator: Exists
        effect: NoSchedule
      # Tolerate the taint on the Arm virtual node.
      - key: kubernetes.io/arch
        operator: Equal
        value: arm64
        effect: NoSchedule     
      # Prefer scheduling to a node that uses the x86 architecture.
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: kubernetes.io/arch
                operator: In
                values:
                - amd64
      containers:
      - name: my-container
        image: nginx

Perguntas frequentes

Por que os pods são agendados em nós ECS x86 quando configuro nodeAffinity para agendá-los preferencialmente em nós Arm?

Por padrão, o agendador do cluster prioriza nós ECS e agenda workloads em nós virtuais quando os recursos dos nós ECS são insuficientes. Se você não alterar os pesos dos plugins de pontuação do agendador, os pods podem ser agendados em nós ECS x86 que tenham recursos suficientes, mesmo quando o nodeAffinity estiver configurado para agendá-los preferencialmente em nós Arm. Portanto, a configuração de nodeAffinity neste tópico garante prioridade apenas entre nós virtuais de diferentes arquiteturas (Arm e x86), e não garante prioridade entre nós virtuais e nós ECS.

Posso usar instâncias spot baseadas em Arm?

Instâncias spot baseadas em Arm estão disponíveis. Para instruções, consulte Use preemptible instances.

Após criar um cluster em uma região suportada, como configuro a rede para criar nós virtuais em zonas que suportam instâncias ECS baseadas em Arm?

Depois de criar cluster ACK Serverless na zona correspondente, configure o campo vSwitchIds no eci-profile para selecionar vSwitches em zonas que suportem instâncias ECS baseadas em Arm. Isso garante que os nós virtuais criados suportem a arquitetura Arm.

Quais são as limitações de uso de nós Arm em cluster ACK Serverless?

Os add-ons do App Marketplace não são suportados na arquitetura Arm. O Component Center suporta add-ons apenas nas seguintes categorias:

Componentes principais
Logs e monitoramento
Armazenamento
Rede

Referências

Use o Alibaba Cloud Container Registry Enterprise Edition (ACR EE) para construir imagens de contêiner multiarquitetura. Para instruções, consulte Build multi-architecture container images.
Para criar e gerenciar nós ECS Arm padrão, consulte Schedule workloads to ARM nodes.
Se você tiver jobs de big data para executar e não quiser lidar com O&M dos recursos subjacentes do cluster, utilize Run Spark jobs on ARM-based virtual nodes.