Create an ARM node pool and schedule workloads to ARM nodes

Prerequisites

• An ACK managed cluster running Kubernetes 1.20 or later on Alibaba Cloud Linux 3. See Create an ACK managed cluster and Upgrade a cluster.

  Note

  • In Core Components, only components in Core Components, Volumes, Network, and Network are supported in ARM node pools.

  • Marketplace components are not supported in ARM node pools.

• The kube-scheduler component is installed. See Manage components.

Usage notes

If your ACK cluster contains both Arm and x86 nodes, add the kubernetes.io/arch=arm64:NoSchedule taint to your Arm nodes. This prevents applications and components that do not support the Arm architecture from being mistakenly scheduled to them. If your cluster runs a version earlier than Kubernetes v1.24, you must also declare a toleration for the kubernetes.io/arch=arm64:NoSchedule taint when you use nodeSelector or nodeAffinity to schedule applications to Arm nodes. To do this, add the corresponding tolerations key for the kubernetes.io/arch=arm64:NoSchedule taint. For clusters that run Kubernetes v1.24 or later, the scheduler automatically recognizes the kubernetes.io/arch=arm64:NoSchedule taint on Arm nodes, so a toleration is not required.

Billing

ARM-based ECS instance types and pricing:

• Instance family

• Pricing of ECS instance types

• Instance Types Available for Each Region

Create an ARM cluster or node pool

Add ARM nodes during cluster creation or add an ARM node pool to an existing cluster.

Schedule ARM-only workloads to ARM nodes

In mixed-architecture clusters, schedule ARM-only applications to ARM nodes to prevent pod failures on incompatible nodes. All ARM nodes carry the label kubernetes.io/arch=arm64. Use nodeSelector or nodeAffinity to target them.

nodeSelector:
  kubernetes.io/arch: arm64 # Specify an ARM node.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: only-arm
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 1
  template:
    metadata:
      labels:
        app: nginx
    spec:
      nodeSelector:
        kubernetes.io/arch: arm64 # Specify an ARM node.
      containers:
      - name: nginx
        image: nginx

affinity:
  nodeAffinity:
    requiredDuringSchedulingIgnoredDuringExecution:
      nodeSelectorTerms:
      - matchExpressions:
        - key: kubernetes.io/arch
          operator: In
          values:
          - arm64

apiVersion: apps/v1
kind: Deployment
metadata:
  name: only-arm
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 1
  template:
    metadata:
      labels:
        app: nginx
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: kubernetes.io/arch
                operator: In
                values:
                - arm64
      containers:
      - name: nginx
        image: nginx

Schedule multi-arch workloads to ARM nodes

By default, ACK schedules workloads to x86 nodes and keeps waiting for x86 node resources even when ARM nodes are available. For multi-arch images, configure scheduling preferences to utilize both architectures.

For example, configure node affinity to prefer ARM or x86 nodes, then fall back to the other architecture when preferred nodes lack resources.

      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: kubernetes.io/arch
                operator: In
                values:
                - arm64

apiVersion: apps/v1
kind: Deployment
metadata:
  name: arm-prefer
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
# Preferentially schedule the workload to an ARM node.
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: kubernetes.io/arch
                operator: In
                values:
                - arm64
      containers:
      - name: my-container
        image: nginx

apiVersion: apps/v1
kind: Deployment
metadata:
  name: amd-prefer
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
# Preferentially schedule the workload to an x86 node.
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: kubernetes.io/arch
                operator: In
                values:
                - amd64
      containers:
      - name: my-container
        image: nginx

FAQ

Can I use ARM-based preemptible instances?

ARM-based preemptible instances are available. See Use preemptible instances.

Limitations of ARM nodes

References

• You can also schedule workloads to ARM virtual nodes.

• Use Container Registry Enterprise Edition (ACR EE) to build multi-arch container images.

• To run big data jobs without managing cluster resources, run Spark jobs on ARM virtual nodes.