# Build a multi-architecture Kubernetes cluster running nginx on Azure AKS

## In this learning path

- [Introduction](https://learn.arm.com/learning-paths/servers-and-cloud-computing/multiarch_nginx_on_aks/)
- [Start your journey with Arm and x86 nginx workloads on a single Kubernetes cluster](https://learn.arm.com/learning-paths/servers-and-cloud-computing/multiarch_nginx_on_aks/overview/)
- [Create the AKS cluster](https://learn.arm.com/learning-paths/servers-and-cloud-computing/multiarch_nginx_on_aks/spin_up_aks_cluster/)
- [Create the test utility](https://learn.arm.com/learning-paths/servers-and-cloud-computing/multiarch_nginx_on_aks/create-test-utility/)
- [Deploy nginx on Intel x86](https://learn.arm.com/learning-paths/servers-and-cloud-computing/multiarch_nginx_on_aks/deploy-intel/)
- [Deploy nginx on Arm](https://learn.arm.com/learning-paths/servers-and-cloud-computing/multiarch_nginx_on_aks/deploy-arm/)
- [Deploy nginx multiarch service on AKS](https://learn.arm.com/learning-paths/servers-and-cloud-computing/multiarch_nginx_on_aks/deploy-multiarch/)
- [Monitor performance with wrk and btop](https://learn.arm.com/learning-paths/servers-and-cloud-computing/multiarch_nginx_on_aks/apply-configuration/)
- [Next Steps](https://learn.arm.com/learning-paths/servers-and-cloud-computing/multiarch_nginx_on_aks/_next-steps/)

## About this Learning Path

|  |  |
| --- | --- |
| Skill level: | Introductory |
| Reading time: | 1 hr |
| Last updated: | 05 Oct 2026 |

### Author:
Geremy Cohen, Arm  
[Github](https://github.com/geremyCohen)  
[LinkedIn](https://linkedin.com/in/geremyinanutshell)  

### Arm IP:
[Neoverse](https://support.arm.com/?tab=compute-ip&Product%20Type=Infrastructure%20Processors)

### Tags:
- [Containers and Virtualization](https://learn.arm.com/tag/containers-and-virtualization)
- [Microsoft Azure Cobalt](https://learn.arm.com/tag/microsoft-azure-cobalt)
- [Linux](https://learn.arm.com/tag/linux)
- [nginx](https://learn.arm.com/tag/nginx)
- [Web Server](https://learn.arm.com/tag/web-server)
- [Azure](https://learn.arm.com/tag/azure)
- [Kubernetes](https://learn.arm.com/tag/kubernetes)

### Who is this for?
This is an introductory topic for developers who want to deploy multi-architecture Kubernetes workloads and compare nginx performance between x86 and Arm-based nodes in Azure Kubernetes Service (AKS) clusters.

### What will you learn?
After completing this Learning Path, you'll be able to perform the following tasks:
- Create a hybrid AKS cluster with both x86 and Arm64 nodes
- Deploy nginx using multi-architecture container images across different node types
- Verify nginx deployment and functionality on each architecture
- Compare performance between x86 and Arm64 nginx instances
- Learn techniques for deploying multi-architecture Kubernetes workloads

### Prerequisites
Before starting, you'll need the following prerequisites:
- An [Azure account](https://azure.microsoft.com/en-us/free/)
- A local machine with [jq](https://jqlang.org/download/), [curl](https://curl.se/download.html), [wrk](https://github.com/wg/wrk), [Azure CLI](https://learn.arm.com/install-guides/azure-cli/), and [kubectl](https://learn.arm.com/install-guides/kubectl/) installed

### Summary
You’ll build a hybrid AKS cluster with x86 and Arm nodes, then deploy NGINX workloads to both architectures. First, you’ll create the node pools, connect with `kubectl`, and use a utility script to inspect and test each deployment. Then, you’ll add a multi-architecture service and compare its routing with the architecture-specific services. While you run load tests, you’ll monitor both workloads.

### Frequently asked questions

**How do I know that the AKS cluster is set up for both architectures before deploying NGINX?**

Confirm that the cluster has two node pools, one x86 and one Arm, and that `kubectl` can reach the cluster. Check that nodes report the expected CPU architecture so scheduling can target each pool.

**Which NGINX image should I use to run on both Arm and x86 nodes?**

Use a multi-architecture NGINX image from Docker Hub. The container runtime pulls the correct image variant based on the node’s CPU architecture.

**What result should I expect when the NGINX services become available?**

When you request a service’s external endpoint, you receive JSON with `message`, `timestamp`, `server`, and `request_uri` fields. You see `nginx response` as the message and the serving pod’s name in `server`.

**How do I confirm that each NGINX pod is running on the correct architecture?**

Use `kubectl` to check each pod’s node assignment and labels. The Arm service selects pods with `app: nginx-multiarch` and `arch: arm`. Verify that Arm pods run on the Arm node pool and x86 pods run on the x86 pool.

**What should I check if the Arm deployment doesn't start or the service shows no endpoints?**

Verify that the Arm node pool exists and is ready. Ensure that the deployment and service selectors match, including `app: nginx-multiarch` and `arch: arm`. Also confirm that the namespace and shared ConfigMap were created before applying the deployment.