Agende pods em nós virtuais baseados em ARM - Elastic Container Instance: Central de Documentação do Alibaba Cloud

Ao agendar um Pod para execução em um nó virtual como uma Elastic Container Instance (ECI), os clusters ACK e ACK Serverless direcionam o Pod, por padrão, para um nó virtual baseado em x86. Se sua aplicação usar a arquitetura ARM, adicione um nodeSelector para especificar um nó virtual baseado em ARM.

Pré-requisitos

O cluster deve atender aos seguintes requisitos:

A região de implantação do cluster oferece suporte a instâncias baseadas em ARM.

O ECI oferece suporte às famílias de tipos de instância ECS g8y, c8y e r8y na arquitetura ARM. Para obter mais informações sobre as regiões compatíveis, consulte Tipos de instância ECS disponíveis por região.
O cluster executa o Kubernetes 1.20 ou versão posterior.
A versão do componente ACK Virtual Node no cluster é compatível com nós baseados em ARM.
A versão do componente kube-scheduler no cluster é compatível com nós baseados em ARM.

Precauções

A cobrança considera o tipo de instância ECS baseada em ARM efetivamente provisionada, e não os recursos de vCPU e memória especificados.

Nota

Após criar um Pod ECI, execute kubectl describe pod <pod name> e verifique a anotação k8s.aliyun.com/eci-instance-spec para confirmar o tipo real da instância ECS.

Adicione um nó virtual baseado em ARM

Siga estas etapas para modificar o eci-profile e adicionar um nó virtual baseado em ARM ao cluster.

Modifique o eci-profile.

kubectl edit configmap eci-profile -n kube-system

Na seção data do eci-profile, defina enableLinuxArm64Node como true. Certifique-se de que pelo menos uma das zonas configuradas ofereça suporte a tipos de instância baseados em ARM.

data:
  enableClusterIp: "true"
  enableHybridMode: "false"
  enableLinuxArm64Node: "true"    # Enable ARM-based nodes.
  enableLogController: "false"
  enablePVCController: "false"
  enablePrivateZone: "false"
  enableReuseSSLKey: "false"
  featureGates: MetricsVpcNet=true,ProtectionFinalizers=false,WaitForFirstConsumer=false
  resourceGroupId: ""
  securityGroupId: sg-2zeg1fci0oq1hljo6h0a
  selectors: ""
  slsMachineGroup: ""
  vSwitchIds: vsw-2zewa5mb19wr45g63****,vsw-2zevanrscmoiaxryx****,vsw-2ze94pjtfuj9vaymf****   # The configured zones must include a zone that supports ARM-based instance types.
  vpcId: vpc-2zeghwzptn5zii0w7****

Visualize o nó virtual baseado em ARM gerado no cluster.

Após definir enableLinuxArm64Node como true, execute o comando kubectl get node para visualizar as informações dos nós. O sistema adiciona automaticamente um nó virtual baseado em ARM ao cluster.

kubectl get node
NAME                                      STATUS    ROLES    AGE    VERSION
virtual-kubelet-cn-beijing-h              Ready     agent    169m   v1.24.6-aliyun.1
virtual-kubelet-cn-beijing-i              Ready     agent    169m   v1.24.6-aliyun.1
virtual-kubelet-cn-beijing-i-linux-arm64  Ready     agent    75s    v1.24.6-aliyun.1
virtual-kubelet-cn-beijing-k              Ready     agent    169m   v1.24.6-aliyun.1

Agende pods em um nó virtual baseado em ARM

Configure o campo nodeSelector

Os nós virtuais baseados em ARM nos clusters ACK e ACK Serverless possuem o rótulo kubernetes.io/arch: arm64. Use esse rótulo em um nodeSelector para agendar um Pod ECI em um nó virtual baseado em ARM.

nodeSelector:
  kubernetes.io/arch: arm64

Exemplo de arquivo YAML de um pod:

Nenhuma especificação definida para o pod.

Se nenhum tipo de instância ECS for especificado, o sistema usará ecs.c8y.large por padrão, um tipo de instância baseada em ARM com 2 vCPUs e 4 GiB de memória.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test
  labels:
    app: test
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      name: nginx-test
      labels:
        app: nginx
        alibabacloud.com/eci: "true"    # Schedule the Pod to a virtual node.
    spec:
      containers:
      - name: nginx
        image: arm64v8/centos:7.9.2009   # Use an image based on the ARM architecture.
        command: ["sleep"]
        args: ["999999"]
      nodeSelector:
        kubernetes.io/arch: arm64  # Specify an ARM-based node.

Especificações de vCPU e memória definidas.

Ao especificar recursos de vCPU e memória, o sistema seleciona automaticamente um tipo de instância ECS baseada em ARM correspondente entre os tipos compatíveis com o ECI.

Nota

É possível especificar vCPU e memória definindo os campos limits ou requests do contêiner (recomenda-se o uso de limits) ou adicionando a anotação k8s.aliyun.com/eci-use-specs.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test
  labels:
    app: test
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      name: nginx-test
      labels:
        app: nginx
        alibabacloud.com/eci: "true"    # Schedule the Pod to a virtual node.
    spec:
      containers:
      - name: nginx
        image: arm64v8/centos:7.9.2009   # Use an image based on the ARM architecture.
        command: ["sleep"]
        args: ["999999"]
        resources:
          limits:
            cpu: "1000m"      # Specify 1 vCPU.
            memory: "4096Mi"   # Specify 4 GiB of memory for the nginx container.
      nodeSelector:
        kubernetes.io/arch: arm64  # Specify an ARM-based node.

Especifique um tipo de instância ECS baseada em ARM

Caso tenha requisitos específicos, use a anotação k8s.aliyun.com/eci-use-specs para definir especificações ARM. Para obter informações sobre as especificações ARM compatíveis com o ECI, consulte Especificar especificações Arm para criar um pod.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test
  labels:
    app: test
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      name: nginx-test
      labels:
        app: nginx
        alibabacloud.com/eci: "true" 
      annotations:
        k8s.aliyun.com/eci-use-specs: "ecs.c8y.large,ecs.g8y.large"   # Specify the supported ARM-based ECS instance types. You can specify up to five types.
    spec:
      containers:
      - name: nginx
        image: arm64v8/centos:7.9.2009   # Use an image based on the ARM architecture.
        command: ["sleep"]
        args: ["999999"]
      nodeSelector:
        kubernetes.io/arch: arm64  # Schedule the Pod to an ARM-based node.

Configure tolerations e nodeAffinity para agendar imagens multiarquitetura

Se você usar uma imagem multiarquitetura e precisar agendar Pods nas arquiteturas x86 e ARM, use tolerations e nodeAffinity para definir uma preferência de agendamento para nós virtuais baseados em ARM ou em x86.

Importante

Antes de usar nodeAffinity para configurar a afinidade de nó conforme o arquivo YAML abaixo, certifique-se de que o recurso de agendamento de pods baseado em nó virtual esteja ativado para o cluster. Para mais detalhes, consulte Ativar a política de agendamento de pods baseada em nó virtual para um cluster ACK.

Exemplo de arquivo YAML de um pod:

Preferência por nós baseados em ARM

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test
  labels:
    app: test
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      name: nginx-test
      labels:
        app: nginx
        alibabacloud.com/eci: "true"    # Schedule the Pod to a virtual node.
    spec:
      tolerations:                 # Tolerate the taint on ARM-based nodes.
      - key: kubernetes.io/arch
        operator: Equal
        value: arm64
        effect: NoSchedule
      affinity:                 
        nodeAffinity:     
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: kubernetes.io/arch
                operator: In
                values:
                - arm64       # Prefer ARM-based nodes.
      containers:
      - name: nginx
        image: nginx                          # Use a multi-architecture image.
        command: ["sleep"]
        args: ["999999"]

Agendamento preferencial do pod em um nó virtual baseado em x86

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test
  labels:
    app: test
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      name: nginx-test
      labels:
        app: nginx
        alibabacloud.com/eci: "true"    # Schedule the Pod to a virtual node.
    spec:
      tolerations:                 # Tolerate the taint on ARM-based nodes.
      - key: kubernetes.io/arch
        operator: Equal
        value: arm64
        effect: NoSchedule
      affinity:                 
        nodeAffinity:     
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: kubernetes.io/arch
                operator: In
                values:
                - amd64         # Prefer x86-based nodes.
      containers:
      - name: nginx
        image: nginx                          # Use a multi-architecture image.
        command: ["sleep"]
        args: ["999999"]

Referências

Clusters ACK: Agendar cargas de trabalho em nós baseados em ARM
Clusters ACK Serverless: Agendar cargas de trabalho em nós virtuais baseados em ARM