# Arm on Autopilot


[Arm was made available in Preview on Google Cloud](https://cloud.google.com/blog/products/compute/tau-t2a-is-first-compute-engine-vm-on-an-arm-chip), and [GKE Autopilot](https://cloud.google.com/blog/products/containers-kubernetes/gke-supports-new-arm-based-tau-t2a-vms) today! As this is an early stage Preview, there’s a few details to pay attention to if you want to try it out, like the version, regions and quota. I put together this quickstart for trying out Arm in Autopilot today.

Arm nodes are available in 3 regions, so be sure to use one from this list:

- us-central
- europe-west4
- asia-southeast1

You’ll also need to create a cluster with a version greater than `1.24.1-gke.1400`. This version isn’t the default today, even in the Rapid channel, so you’ll need to create a cluster at a specific version. The following command works at the time of writing, but in the future (once the patch version has been retired), you’ll need to [specify a currently valid version](/k8s/creating-an-autopilot-cluster-at-a-specific-version/) newer than that one.

```shell
CLUSTER_NAME=autopilot-arm
REGION=us-central1
VERSION=1.24
gcloud container clusters create-auto $CLUSTER_NAME \
    --release-channel "rapid" --region $REGION \
    --cluster-version $VERSION
```

During the preview, the price is discounted by 100% (meaning it’s currently free), so it’s a great time to try it out and explore. Just don’t go [mining crypto](https://support.google.com/cloud/answer/7002354?hl=en#zippy=%2Cwhy-was-my-project-flagged-for-cryptocurrency-mining).

With your Arm-capable cluster created, deploy an Arm workload like this example from the [Autopilot docs](https://cloud.google.com/kubernetes-engine/docs/how-to/autopilot-arm-workloads#example-arm-request). You need to specify 2 node selectors, the compute class (an Autopilot-specific label), and the architecture (a well-known label).

```yaml {hl_lines=[15, 16, 17]}
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-arm
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx-arm
  template:
    metadata:
      labels:
        app: nginx-arm
    spec:
      nodeSelector:
        cloud.google.com/compute-class: Scale-Out
        kubernetes.io/arch: arm64
      containers:
      - name: nginx-arm
        image: nginx
        resources:
          requests:
            cpu: 2000m
            memory: 2Gi
```

[arm.yaml](https://github.com/WilliamDenniss/autopilot-examples/blob/master/arm/arm.yaml)

Be aware that Arm nodes today have fairly limited quota compared to other machine families (I was able to provision 18 node cores in us-central1 on the default quota), but it should be enough to give it a try and to start developing some Arm workloads. For now, the best advice on GCP would be to build [multi-arch images](https://cloud.google.com/kubernetes-engine/docs/how-to/build-multi-arch-for-arm) so you can fall back to x86 when needed.

If you run into problems, like Pending Arm Pods that never schedule, review the [troubleshooting guide](https://cloud.google.com/kubernetes-engine/docs/troubleshooting/troubleshooting-arm-workloads). In brief, check your event log for clues (`kubectl get events -w`), and verify that you have the right a) region (from the list of 3), b) GKE version (it must be equal to or higher than `1.24.1-gke.1400` precisely!), and c) enough [quota](https://console.cloud.google.com/iam-admin/quotas) (look for any that are close to 100% used).

Next up: [building your own Arm images using Cloud Build](/k8s/building-arm-images-with-cloud-build/).