Create an ARM node pool and schedule workloads to ARM nodes

Prerequisites

• An ACK managed cluster that runs Kubernetes 1.20 or later on Alibaba Cloud Linux 3. For more information, 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. For more information, 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

For more information about the ECS instance types that use the ARM architecture and their pricing, see the following topics:

• Instance family

• Pricing of ECS instance types

• Instance Types Available for Each Region

Create an ARM cluster or node pool

You can add ARM nodes when you create a new ACK cluster, or add a new ARM node pool to an existing cluster.

Schedule ARM-only workloads to ARM nodes

If your cluster contains both ARM and x86 nodes, you must ensure that applications that support only the ARM architecture are scheduled to ARM nodes. This prevents their pods from failing to start on incompatible nodes. By default, all ARM nodes have the label kubernetes.io/arch=arm64. You can use nodeSelector or nodeAffinity to deploy applications to ARM nodes.

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 all workloads to x86 nodes. If x86 nodes have insufficient resources, pods remain in a pending state instead of being scheduled to available ARM nodes. If your application uses a multi-arch image that supports both the x86 and ARM architectures, you should configure scheduling preferences to utilize nodes of different architectures.

For example, you can configure node affinity to prefer ARM or x86 nodes, and then fall back to nodes of the other architecture when the preferred nodes do not have enough 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. For usage details, see Use preemptible instances.

Limitations of ARM nodes

References

• You can also create ARM virtual nodes and configure workloads to be preferentially scheduled to them. For more information, see Schedule workloads to ARM virtual nodes.

• You can use Container Registry Enterprise Edition (ACR EE) to build multi-arch container images. For more information, see Build multi-arch container images.

• If you run big data jobs and want to avoid managing underlying cluster resources, you can run Spark jobs on ARM virtual nodes.