diff --git a/content/install-guides/dotnet.md b/content/install-guides/dotnet.md index bd2f0e57d9..9925f67f22 100644 --- a/content/install-guides/dotnet.md +++ b/content/install-guides/dotnet.md @@ -20,7 +20,7 @@ weight: 1 The [.NET SDK](https://dotnet.microsoft.com/en-us/) is a free, open-source, cross-platform development environment that provides tools and libraries for building applications. You can use it to create web apps, mobile apps, desktop apps, cloud services, and more. -.NET 10 is the latest Long Term Support (LTS) release. .NET 9 (Standard Term Support) and .NET 8 (LTS) are also available. This guide defaults to .NET 10, with instructions for selecting an alternative version. +.NET 10 is the Long Term Support (LTS) release, and .NET 11 is the Standard Term Support (STS) release. This guide uses .NET 10. For current support dates, see the [.NET support policy](https://dotnet.microsoft.com/en-us/platform/support/policy/dotnet-core). The .NET SDK is available for Linux distributions on Arm-based systems. @@ -62,7 +62,7 @@ Use `dnf` to install the .NET 10 SDK on Fedora: sudo dnf install dotnet-sdk-10.0 ``` -To install a different version, replace `10.0` with the version you need. For example, use `dotnet-sdk-9.0` for .NET 9 or `dotnet-sdk-8.0` for .NET 8. +To install a different version, replace `10.0` with the version you need. For example, use `dotnet-sdk-11.0` for .NET 11. If the .NET SDK is not found in your package manager, you can install it using a script. @@ -86,10 +86,10 @@ To install the latest LTS version (.NET 10), run: bash ./dotnet-install.sh ``` -To install the latest available version (including STS releases), run: +To install the latest STS release, run: ```bash -bash ./dotnet-install.sh --version latest +bash ./dotnet-install.sh --channel STS ``` To install a specific version channel, use the `--channel` flag. For example, to install .NET 10: @@ -98,7 +98,7 @@ To install a specific version channel, use the `--channel` flag. For example, to bash ./dotnet-install.sh --channel 10.0 ``` -You can also use `--channel 9.0` for .NET 9 or `--channel 8.0` for .NET 8. +You can also use `--channel 11.0` for .NET 11. 3. Add the .dotnet folder to the PATH environment variable: diff --git a/content/learning-paths/servers-and-cloud-computing/aks/_images/wordpress-setup.webp b/content/learning-paths/servers-and-cloud-computing/aks/_images/wordpress-setup.webp new file mode 100644 index 0000000000..1b13dc0a47 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/aks/_images/wordpress-setup.webp differ diff --git a/content/learning-paths/servers-and-cloud-computing/aks/_index.md b/content/learning-paths/servers-and-cloud-computing/aks/_index.md index 929f376f2d..8efa3b5d0a 100644 --- a/content/learning-paths/servers-and-cloud-computing/aks/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/aks/_index.md @@ -1,18 +1,18 @@ --- title: Create an Arm-based cluster on Azure Kubernetes Service -description: Learn how to automate the deployment of an Arm-based Kubernetes cluster on Azure AKS using Terraform and deploy a sample WordPress application as a workload. +description: Learn how to automate the deployment of an Arm-based Kubernetes cluster on Azure AKS with Azure Cobalt 200 nodes using Terraform, and deploy a sample WordPress application as a workload. minutes_to_complete: 60 who_is_this_for: This is an advanced topic for software developers who want to deploy an Arm-based Kubernetes cluster using Azure Kubernetes Service (AKS). learning_objectives: - - Automate the deployment of an Arm-based AKS cluster using Terraform - - Install Wordpress on AKS as an example workload + - Automate the deployment of an Arm-based AKS cluster with Azure Cobalt 200 nodes using Terraform + - Install WordPress on AKS as an example workload prerequisites: - - An Azure account + - An Azure account with access to Cobalt 200 (Dpsv7) virtual machines and sufficient vCPU quota - A machine with [Terraform](/install-guides/terraform/), [Azure CLI](/install-guides/azure-cli), and [Kubectl](/install-guides/kubectl/) installed # START generated_summary_faq @@ -32,7 +32,7 @@ generated_summary_faq: summary: >- You'll automate an Arm-based Azure Kubernetes Service (AKS) cluster deployment with Terraform and then deploy a WordPress example workload. First, you'll configure AKS to use Azure - Dpsv5 virtual machines based on Ampere Altra Arm processors by following Terraform-driven + Dpsv7 virtual machines based on Azure Cobalt 200 Arm processors by following Terraform-driven provisioning steps. After the cluster is available, you'll use a concise Kubernetes setup to run WordPress backed by MySQL by creating three manifests: `kustomization.yaml`, `mysql-deployment.yaml`, and `wordpress-deployment.yaml`. The result is a working application on an Arm-based AKS node @@ -49,9 +49,10 @@ generated_summary_faq: can proceed after the cluster is up and reachable with your configured tooling. - question: How do I ensure the AKS node pool is Arm-based? answer: >- - Configure the node pool in Terraform to use an Azure Dpsv5 VM size, which runs on Ampere - Altra Arm-based processors. Confirm that the VM size in your configuration references a - Dpsv5 option. + Configure the node pool in Terraform to use an Azure Dpsv7 VM size, such as `Standard_D2ps_v7`, + which runs on Azure Cobalt 200 Arm-based processors. After the cluster is created, run + `kubectl get nodes -L node.kubernetes.io/instance-type,kubernetes.io/arch` and confirm that the + nodes show `arm64`. - question: Which files do I need to create for the WordPress example? answer: >- Create `kustomization.yaml`, `mysql-deployment.yaml`, and `wordpress-deployment.yaml` exactly @@ -89,8 +90,8 @@ operatingsystems: further_reading: - resource: - title: Azure Kubernetes Service on Arm based Ampere Altra processors - link: https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/aks-on-arm-based-ampere + title: Introducing Azure Cobalt 200 virtual machines + link: https://azure.microsoft.com/en-us/blog/new-azure-cobalt-200-vms-deliver-50-performance-improvement-fully-optimized-for-modern-agentic-ai-workloads/ type: blog - resource: title: AKS documentation diff --git a/content/learning-paths/servers-and-cloud-computing/aks/cluster_deployment.md b/content/learning-paths/servers-and-cloud-computing/aks/cluster_deployment.md index 9bb7ce088c..fe07ed5c5a 100644 --- a/content/learning-paths/servers-and-cloud-computing/aks/cluster_deployment.md +++ b/content/learning-paths/servers-and-cloud-computing/aks/cluster_deployment.md @@ -8,7 +8,9 @@ weight: 2 # 1 is first, 2 is second, etc. layout: "learningpathall" --- -You can run Azure Kubernetes Service (AKS), a fully managed Kubernetes platform, on the Azure Dpsv5 Virtual Machine series featuring Ampere Altra Arm–based processors. Dpsv5 virtual machines offer compelling price-performance. +You can run Azure Kubernetes Service (AKS), a fully managed Kubernetes platform, on Azure Cobalt 200 virtual machines. Azure Cobalt 200 is Microsoft's second-generation Arm-based processor, built on Arm Neoverse Compute Subsystems V3 (CSS V3). In this Learning Path, you use the general-purpose Dpsv7 virtual machine series for the AKS nodes. + +Your subscription and selected region must have access to Dpsv7 sizes and sufficient vCPU quota. This Learning Path was validated in **West US 2**. ## Before you begin @@ -61,7 +63,7 @@ terraform { required_providers { azurerm = { source = "hashicorp/azurerm" - version = "~>3.0" + version = "~>5.0" } random = { source = "hashicorp/random" @@ -87,7 +89,7 @@ variable "dns_prefix" { default = "arm-aks" } variable "resource_group_location" { - default = "eastus2" + default = "westus2" description = "Location of the resource group." } variable "resource_group_name_prefix" { @@ -105,6 +107,9 @@ variable "ssh_public_key" { output "resource_group_name" { value = azurerm_resource_group.rg.name } +output "cluster_name" { + value = azurerm_kubernetes_cluster.k8s.name +} ``` 4. Use a text editor to create the file `main.tf` with the code below: @@ -128,9 +133,12 @@ resource "azurerm_kubernetes_cluster" "k8s" { } default_node_pool { name = "demopool" - vm_size = "Standard_D2ps_v5" + vm_size = "Standard_D2ps_v7" node_count = var.agent_count } + node_provisioning_profile { + mode = "Manual" + } linux_profile { admin_username = "ubuntu" ssh_key { @@ -145,9 +153,11 @@ resource "azurerm_kubernetes_cluster" "k8s" { The block labeled `default_node_pool` is used to select the virtual machine type, size, and the number of nodes. -The nodes are specified to use the `Standard_D2ps_v5` virtual machine type which is a 2 vCPU Altra-based virtual machine with standard SSDs. +The nodes are specified to use the `Standard_D2ps_v7` virtual machine type, which is a 2 vCPU Cobalt 200 virtual machine. -There are various Arm-based virtual machines that can be selected. The [Azure VM series descriptions](https://azure.microsoft.com/en-us/pricing/details/virtual-machines/series/) shows that the Dpsv5, Dpdsv5, Dplsv5, Dpldsv5, Epsv5, Epdsv5 all use Ampere Altra. Any of these virtual machine types can be used to create an Arm-based cluster. +The `node_provisioning_profile` block is required by the current Azure provider for Terraform. Setting `mode` to `Manual` means that you choose the node pool size and VM type yourself. + +There are various Arm-based virtual machines that can be selected. The Cobalt 200 series include Dpsv7, Dpdsv7, Dplsv7, Dpldsv7, Epsv7, and Epdsv7. See the [Azure Cobalt 200 virtual machines overview](https://azure.microsoft.com/en-us/blog/new-azure-cobalt-200-vms-deliver-50-performance-improvement-fully-optimized-for-modern-agentic-ai-workloads/) for details. Any of these virtual machine types can be used to create an Arm-based cluster, provided your subscription and region have access to them. ### Run the Terraform commands @@ -168,11 +178,11 @@ Initializing the backend... Initializing provider plugins... - Finding hashicorp/random versions matching "~> 3.0"... -- Finding hashicorp/azurerm versions matching "~> 3.0"... -- Installing hashicorp/random v3.4.3... -- Installed hashicorp/random v3.4.3 (signed by HashiCorp) -- Installing hashicorp/azurerm v3.48.0... -- Installed hashicorp/azurerm v3.48.0 (signed by HashiCorp) +- Finding hashicorp/azurerm versions matching "~> 5.0"... +- Installing hashicorp/random v3.9.1... +- Installed hashicorp/random v3.9.1 (signed by HashiCorp) +- Installing hashicorp/azurerm v5.14.0... +- Installed hashicorp/azurerm v5.14.0 (signed by HashiCorp) Terraform has created a lock file .terraform.lock.hcl to record the provider selections it made above. Include this file in your version control repository @@ -198,45 +208,38 @@ Run `terraform apply` to create the infrastructure: terraform apply ``` -Answer yes to the prompt to confirm you want to create Google Cloud resources. +Answer `yes` at the prompt to confirm you want to create the Azure resources. -It will take about 5 minutes to create the resources. +It will take about 5 to 10 minutes to create the resources. -When it completes the name of the resource group is printed. +When it completes, the name of the resource group and the cluster are printed. ```output Apply complete! Resources: 3 added, 0 changed, 0 destroyed. Outputs: -resource_group_name = "arm-aks-demo-rg-exact-wombat" +cluster_name = "arm-aks-cluster-demo" +resource_group_name = "arm-aks-demo-rg-possible-mastiff" ``` ### Configure kubectl -1. In a browser, go to the Azure Kubernetes services console, select the cluster, and click on connect. - -![aks1 #center](https://github.com/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/2b50015f-51fb-46f1-8ee1-28fc5db35154) - -Instructions for running `az account` and `az aks get-credentials` will be displayed. +1. Use the Terraform outputs to get the credentials for the new cluster and add them to your `kubectl` configuration: -![aks2 #center](https://github.com/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/45732e69-fe88-4757-98d4-264bf392d10c) - -2. Copy the 2 commands and run them - -Run the `az account` and `az aks get-credentials` commands you copied. - -There is no output from the first command. +```console +az aks get-credentials --resource-group $(terraform output -raw resource_group_name) --name $(terraform output -raw cluster_name) +``` -The output from the second command is similar to: +The output is similar to: ```output Merged "arm-aks-cluster-demo" as current context in /home/ubuntu/.kube/config ``` -You are now ready to use `kubectl` +You are now ready to use `kubectl`. -3. Run the following command to see the status of the nodes. +2. Run the following command to see the status of the nodes. ```console kubectl get nodes @@ -245,71 +248,64 @@ kubectl get nodes Three nodes should be in the `Ready` state: ```output -NAME STATUS ROLES AGE VERSION -aks-demopool-40436376-vmss000000 Ready agent 10m v1.24.9 -aks-demopool-40436376-vmss000001 Ready agent 10m v1.24.9 -aks-demopool-40436376-vmss000002 Ready agent 10m v1.24.9 +NAME STATUS ROLES AGE VERSION +aks-demopool-15110407-vmss000000 Ready 2m5s v1.36.5 +aks-demopool-15110407-vmss000001 Ready 2m5s v1.36.5 +aks-demopool-15110407-vmss000002 Ready 2m4s v1.36.5 ``` -4. Run the following command to see the current pods running on the cluster. +3. Confirm the virtual machine size and architecture of the nodes: ```console -kubectl get pods -A +kubectl get nodes -L node.kubernetes.io/instance-type,kubernetes.io/arch ``` -The output will be similar to: +The output shows that the nodes are Cobalt 200 `Standard_D2ps_v7` virtual machines with the `arm64` architecture: ```output -NAMESPACE NAME READY STATUS RESTARTS AGE -kube-system azure-ip-masq-agent-fw66d 1/1 Running 0 12m -kube-system azure-ip-masq-agent-q7ltm 1/1 Running 0 12m -kube-system azure-ip-masq-agent-qs2rp 1/1 Running 0 12m -kube-system cloud-node-manager-k8fdg 1/1 Running 0 12m -kube-system cloud-node-manager-ml5jq 1/1 Running 0 12m -kube-system cloud-node-manager-phng2 1/1 Running 0 12m -kube-system coredns-59b6bf8b4f-msdzd 1/1 Running 0 13m -kube-system coredns-59b6bf8b4f-wbcgl 1/1 Running 0 11m -kube-system coredns-autoscaler-5655d66f64-g94zj 1/1 Running 0 13m -kube-system csi-azuredisk-node-9njln 3/3 Running 0 12m -kube-system csi-azuredisk-node-mnqnz 3/3 Running 0 12m -kube-system csi-azuredisk-node-rjmq7 3/3 Running 0 12m -kube-system csi-azurefile-node-7qmdn 3/3 Running 0 12m -kube-system csi-azurefile-node-fbpm7 3/3 Running 0 12m -kube-system csi-azurefile-node-j2sf5 3/3 Running 0 12m -kube-system konnectivity-agent-77467c5c84-52zsj 1/1 Running 0 2m19s -kube-system konnectivity-agent-77467c5c84-wdhms 1/1 Running 0 2m15s -kube-system kube-proxy-hnbpp 1/1 Running 0 12m -kube-system kube-proxy-wr6rm 1/1 Running 0 12m -kube-system kube-proxy-zssbf 1/1 Running 0 12m -kube-system metrics-server-5f8d84558d-5rtgs 2/2 Running 0 11m -kube-system metrics-server-5f8d84558d-lh2xk 2/2 Running 0 11m +NAME STATUS ROLES AGE VERSION INSTANCE-TYPE ARCH +aks-demopool-15110407-vmss000000 Ready 2m5s v1.36.5 Standard_D2ps_v7 arm64 +aks-demopool-15110407-vmss000001 Ready 2m5s v1.36.5 Standard_D2ps_v7 arm64 +aks-demopool-15110407-vmss000002 Ready 2m4s v1.36.5 Standard_D2ps_v7 arm64 ``` -5. Run `kubectl` to open a shell on one of the nodes. +4. Run the following command to see the current pods running on the cluster. ```console -kubectl debug node/aks-demopool-40436376-vmss000000 -it --image=ubuntu +kubectl get pods -A ``` -The terminal will open a shell with output similar to: +The output will be similar to: ```output -Creating debugging pod node-debugger-aks-demopool-40436376-vmss000000-b9tj5 with container debugger on node aks-demopool-40436376-vmss000000. -If you don't see a command prompt, try pressing enter. -root@aks-demopool-40436376-vmss000000:/# -``` - -6. At the new shell prompt, run the `uname` command: - -```console -uname -a +NAMESPACE NAME READY STATUS RESTARTS AGE +kube-system azure-cns-9hlcm 2/2 Running 0 4m8s +kube-system azure-cns-9zpvw 2/2 Running 0 4m7s +kube-system azure-cns-m6xqg 2/2 Running 0 4m8s +kube-system azure-ip-masq-agent-g8nr4 1/1 Running 0 4m7s +kube-system azure-ip-masq-agent-wv4zh 1/1 Running 0 4m8s +kube-system azure-ip-masq-agent-zhzq6 1/1 Running 0 4m8s +kube-system cloud-node-manager-8vxcc 1/1 Running 0 4m8s +kube-system cloud-node-manager-dr5m5 1/1 Running 0 4m8s +kube-system cloud-node-manager-vhkz5 1/1 Running 0 4m7s +kube-system coredns-5bf45f87d-95zhw 1/1 Running 0 4m34s +kube-system coredns-5bf45f87d-tgmx7 1/1 Running 0 3m42s +kube-system coredns-autoscaler-7467554f77-b5jvl 1/1 Running 0 4m34s +kube-system csi-azuredisk-node-8nstr 3/3 Running 0 4m7s +kube-system csi-azuredisk-node-jtjxn 3/3 Running 0 4m7s +kube-system csi-azuredisk-node-rwqqz 3/3 Running 0 4m8s +kube-system csi-azurefile-node-7pxf6 4/4 Running 0 4m7s +kube-system csi-azurefile-node-ljgdr 4/4 Running 0 4m7s +kube-system csi-azurefile-node-zgkx5 4/4 Running 0 4m8s +kube-system konnectivity-agent-7d7c8bcd59-8cr8d 1/1 Running 0 3m42s +kube-system konnectivity-agent-7d7c8bcd59-qmc7g 1/1 Running 0 4m21s +kube-system konnectivity-agent-autoscaler-5b658f6697-mhpkl 1/1 Running 0 4m21s +kube-system kube-proxy-4td8b 1/1 Running 0 4m7s +kube-system kube-proxy-p2rxj 1/1 Running 0 4m7s +kube-system kube-proxy-zdhdm 1/1 Running 0 4m8s +kube-system metrics-server-866c8cb87d-5ptrp 2/2 Running 0 3m36s +kube-system metrics-server-866c8cb87d-9jmmb 2/2 Running 0 3m36s ``` -The output confirm the node is an Arm instance: - -```output -Linux aks-demopool-40436376-vmss000000 5.15.0-1034-azure #41-Ubuntu SMP Fri Feb 10 19:59:55 UTC 2023 aarch64 aarch64 aarch64 GNU/Linux -``` - You have successfully created a Kubernetes cluster on AKS using Arm-based instances. diff --git a/content/learning-paths/servers-and-cloud-computing/aks/deploy_wordpress.md b/content/learning-paths/servers-and-cloud-computing/aks/deploy_wordpress.md index 735643d633..e7ff559863 100644 --- a/content/learning-paths/servers-and-cloud-computing/aks/deploy_wordpress.md +++ b/content/learning-paths/servers-and-cloud-computing/aks/deploy_wordpress.md @@ -16,7 +16,7 @@ You can use the cluster to deploy an example application, WordPress. ## Deploy WordPress Example -### Create Terraform files +### Create the Kubernetes manifest files The yaml files below are a modified version of the [Kubernetes WordPress Tutorial](https://kubernetes.io/docs/tutorials/stateful-application/mysql-wordpress-persistent-volume/) in the Kubernetes documentation. @@ -89,7 +89,7 @@ spec: tier: mysql spec: containers: - - image: mysql:8.0.30 + - image: mysql:8.4.13 name: mysql env: - name: MYSQL_DATABASE @@ -170,7 +170,7 @@ spec: tier: frontend spec: containers: - - image: wordpress:6.0.2-apache + - image: wordpress:7.1.5-apache name: wordpress env: - name: WORDPRESS_DB_HOST @@ -196,7 +196,7 @@ spec: claimName: wp-pv-claim ``` -### Apply the Terraform files +### Apply the manifests Run `kubectl apply` to update the configuration: @@ -218,7 +218,7 @@ deployment.apps/wordpress-mysql created ### Confirm WordPress is running -1. Check on volume claims to confirm the 20 Gb of storage has been created for MySQL and WordPress: +1. Check on volume claims to confirm the 20 GiB of storage has been created for MySQL and WordPress: ```console kubectl get pvc @@ -227,9 +227,9 @@ kubectl get pvc The output is similar to: ```output -NAME STATUS VOLUME CAPACITY ACCESS MODES STORAGECLASS AGE -mysql-pv-claim Bound pvc-b5ed7959-9a05-4759-a178-86f7e1393be0 20Gi RWO managed-csi 107s -wp-pv-claim Bound pvc-cb03c97b-adab-4e4f-ad91-fcfaa69b1a30 20Gi RWO managed-csi 107s +NAME STATUS VOLUME CAPACITY ACCESS MODES STORAGECLASS VOLUMEATTRIBUTESCLASS AGE +mysql-pv-claim Bound pvc-c1948fd9-1ba1-49e2-9b8e-734fe28bc03e 20Gi RWO managed-csi 11s +wp-pv-claim Bound pvc-91cf7663-f500-40eb-8011-5c9a27bed3a3 20Gi RWO managed-csi 11s ``` 2. Verify the WordPress and MySQL pods are running: @@ -242,8 +242,8 @@ The output is similar to: ```output NAME READY STATUS RESTARTS AGE -wordpress-6c5db6d5d7-zznww 1/1 Running 0 5m11s -wordpress-mysql-75467487bf-zs5vk 1/1 Running 0 5m11s +wordpress-7b75d8584c-sjt75 1/1 Running 0 61s +wordpress-mysql-585c4786dd-rq74n 1/1 Running 0 61s ``` 3. Verify that the persistent volumes have been attached: @@ -256,8 +256,8 @@ The output is similar to: ```output NAME ATTACHER PV NODE ATTACHED AGE -csi-643e8fc7abcd16d5e98eeffcb0cff690c20aa2fb90a55c38889a570295fa07d2 disk.csi.azure.com pvc-b5ed7959-9a05-4759-a178-86f7e1393be0 aks-demopool-85935132-vmss000001 true 5m52s -csi-eecaead981dd085e638d388afaa2a325019fcda81bfcda91e867b69d41fc4482 disk.csi.azure.com pvc-cb03c97b-adab-4e4f-ad91-fcfaa69b1a30 aks-demopool-85935132-vmss000001 true 5m52s +csi-0637ef93dc59f8511dc360b2ea1e1e27b06b2dc01333d1e9b54a2ebd1c5dbfca disk.csi.azure.com pvc-c1948fd9-1ba1-49e2-9b8e-734fe28bc03e aks-demopool-15110407-vmss000002 true 59s +csi-f2eaeaf495901df3b7c1aeeb21b006581f4a52b52da669417b6a7c876b1f8964 disk.csi.azure.com pvc-91cf7663-f500-40eb-8011-5c9a27bed3a3 aks-demopool-15110407-vmss000000 true 58s ``` 4. Get the external IP address of the WordPress deployment: @@ -269,25 +269,25 @@ kubectl get svc The output is similar to: ```output -NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE -kubernetes ClusterIP 10.0.0.1 443/TCP 21m -wordpress LoadBalancer 10.0.69.21 20.10.212.247 80:31829/TCP 7m23s -wordpress-mysql ClusterIP None 3306/TCP 7m22s +NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE +kubernetes ClusterIP 10.0.0.1 443/TCP 6m50s +wordpress LoadBalancer 10.0.90.248 172.193.248.164 80:32351/TCP 13s +wordpress-mysql ClusterIP None 3306/TCP 13s ``` The IP address in the `EXTERNAL-IP` column is the one to use. 5. Open the external IP in a browser. -The WordPress welcome screen will be displayed. +The WordPress language selection screen is displayed. -![aks3 #center](https://github.com/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/fb2ca43c-59d9-4a1f-8163-7d09759366b6) +![WordPress installation page with a language selection list and a Continue button #center](_images/wordpress-setup.webp "WordPress language selection screen") You have successfully installed WordPress on your Arm-based AKS cluster. ### Clean up resources -Run `terraform destroy` to delete all resources created. +Run `terraform destroy` in the directory that contains your Terraform files to delete the AKS cluster and the resource group. This also deletes the WordPress volumes and the load balancer. ```console terraform destroy diff --git a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/azure-cobalt-vm.webp b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/azure-cobalt-vm.webp deleted file mode 100644 index 6728703cd7..0000000000 Binary files a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/azure-cobalt-vm.webp and /dev/null differ diff --git a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/github-run.webp b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/github-run.webp index 51175892e0..695161e9d6 100644 Binary files a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/github-run.webp and b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/github-run.webp differ diff --git a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/kubernetes-deployment.webp b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/kubernetes-deployment.webp deleted file mode 100644 index 8e9a8ccf13..0000000000 Binary files a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/kubernetes-deployment.webp and /dev/null differ diff --git a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_index.md b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_index.md index 02eed44034..8ff742d7ba 100644 --- a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_index.md @@ -1,14 +1,14 @@ --- -title: Deploy a .NET application on Microsoft Azure Cobalt 100 VMs -description: Learn how to configure a self-hosted GitHub runner on Azure Cobalt 100, create an AKS cluster with Terraform, and deploy a .NET application using GitHub Actions CI/CD. +title: Deploy a .NET application on Microsoft Azure Cobalt 200 VMs +description: Learn how to configure a self-hosted GitHub runner on Azure Cobalt 200, create an AKS cluster with Terraform, and deploy a .NET application using GitHub Actions CI/CD. minutes_to_complete: 60 -who_is_this_for: This is an advanced topic for software developers who want to develop cloud-native applications using GitHub Actions and Azure Kubernetes Service (AKS), and run them on Microsoft Azure Cobalt 100 VMs. +who_is_this_for: This is an advanced topic for software developers who want to develop cloud-native applications using GitHub Actions and Azure Kubernetes Service (AKS), and run them on Microsoft Azure Cobalt 200 VMs. learning_objectives: - - Configure an Azure Cobalt 100 VM as a self-hosted GitHub runner. - - Create an AKS cluster with Arm-based Azure Cobalt 100 nodes using Terraform. + - Configure an Azure Cobalt 200 VM as a self-hosted GitHub runner. + - Create an AKS cluster with Arm-based Azure Cobalt 200 nodes using Terraform. - Deploy a .NET application to AKS with GitHub Actions using the self-hosted Arm64-based runner. prerequisites: @@ -31,19 +31,19 @@ generated_summary_faq: faq_generated_at: '2026-06-26T18:33:18Z' faq_source_hash: b5bd3abde8d9dd3146e0f11f4819ac510417ad7f707b4d0970c02fd63801b358 summary: >- - You'll set up a self-hosted GitHub Actions runner on an Azure Cobalt 100 - VM and use it to build a .NET 8 web application for `arm64`. With Terraform, you'll create an - Azure Kubernetes Service (AKS) cluster backed by Cobalt 100-based nodes, then use a GitHub + You'll set up a self-hosted GitHub Actions runner on an Azure Cobalt 200 + VM and use it to build a .NET 10 web application for `arm64`. With Terraform, you'll create an + Azure Kubernetes Service (AKS) cluster backed by Cobalt 200-based nodes, then use a GitHub Actions workflow to deploy the application to the cluster. Along the way, you'll select an appropriate - Cobalt 100-based VM series for the runner, confirm the runner is available to execute jobs, and + Cobalt 200-based VM series for the runner, confirm the runner is available to execute jobs, and validate that the workload targets the Arm-based AKS nodes. The result is a working CI/CD - path from source to a running application on Azure Cobalt 100 infrastructure. + path from source to a running application on Azure Cobalt 200 infrastructure. faqs: - - question: Which Azure Cobalt 100 VM series should I use for the self-hosted runner? + - question: Which Azure Cobalt 200 VM series should I use for the self-hosted runner? answer: >- - Azure Cobalt 100 offers general-purpose Dpsv6/Dplsv6 and memory-optimized Epsv6 series. - Choose based on your build and deployment needs. The Learning Path doesn't prescribe a specific - size. + Azure Cobalt 200 offers general-purpose Dpsv7 and Dplsv7 series, among others. This + Learning Path uses a Dpsv7 VM. Your subscription and region must have access to Dpsv7 sizes and + sufficient vCPU quota. - question: Do I have to use a self-hosted runner, or can I use GitHub-hosted `arm64` runners? answer: >- GitHub-hosted `arm64` runners are generally available for Team and Enterprise Cloud accounts. @@ -51,11 +51,11 @@ generated_summary_faq: - question: How do I know the self-hosted GitHub Actions runner is ready before triggering the workflow? answer: >- - Confirm the runner is installed on the Azure Cobalt 100 VM and appears online in GitHub. + Confirm the runner is installed on the Azure Cobalt 200 VM and appears online in GitHub. Don't start the workflow until the runner reports an available status. - question: What result should I expect after applying the Terraform configuration? answer: >- - Terraform creates an AKS cluster with node pools based on Azure Cobalt 100. This cluster + Terraform creates an AKS cluster with node pools based on Azure Cobalt 200. This cluster is then targeted by the GitHub Actions workflow that deploys the .NET application. - question: How can I verify the .NET application is running on Arm-based nodes in AKS? answer: >- @@ -89,8 +89,8 @@ operatingsystems: further_reading: - resource: - title: Developing Cloud-native Applications with New Arm Neoverse CSS-based Microsoft Azure Cobalt 100 Virtual Machines - link: https://newsroom.arm.com/blog/microsoft-azure-cobalt-100-vm + title: Introducing Azure Cobalt 200 virtual machines + link: https://azure.microsoft.com/en-us/blog/new-azure-cobalt-200-vms-deliver-50-performance-improvement-fully-optimized-for-modern-agentic-ai-workloads/ type: blog - resource: title: AKS documentation diff --git a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/azure-cobalt.md b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/azure-cobalt.md index 5c2546d34b..77920e1d14 100644 --- a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/azure-cobalt.md +++ b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/azure-cobalt.md @@ -6,7 +6,7 @@ weight: 3 layout: "learningpathall" --- -In this Learning Path, you will build a .NET 8-based web application using a self-hosted GitHub Actions Arm64 runner. You will deploy the application in an Azure Kubernetes Cluster, running on Microsoft Cobalt 100-based VMs. Self-hosted runners offer increased control and flexibility in terms of infrastructure, operating systems, and tools, in comparison to GitHub-hosted runners. +You'll build a .NET 10 web application using a self-hosted GitHub Actions Arm64 runner and deploy it to an Azure Kubernetes Service cluster with Azure Cobalt 200-based VMs. Self-hosted runners offer increased control and flexibility in terms of infrastructure, operating systems, and tools, in comparison to GitHub-hosted runners. {{% notice Note %}} * GitHub-hosted Arm64 runners have now reached General Availability. If your GitHub account is part of a Team or an Enterprise Cloud plan, you can use GitHub-hosted Arm64 runners. @@ -15,13 +15,27 @@ In this Learning Path, you will build a .NET 8-based web application using a sel {{% /notice %}} ## How do I create an Azure Virtual Machine? -Creating a virtual machine based on Azure Cobalt 100 is no different from creating any other VM in Azure. To create an Azure virtual machine, launch the [Azure portal](https://portal.azure.com/) and navigate to Virtual Machines. +Creating a virtual machine based on Azure Cobalt 200 is no different from creating any other VM in Azure. To create an Azure virtual machine, launch the [Azure portal](https://portal.azure.com/) and navigate to Virtual Machines. -Select `Create Azure Virtual Machine`, and fill in the details such as `Name`, and `Region`. +Select **Create Azure Virtual Machine**, and fill in details such as **Name** and **Region**. Select **Ubuntu Server 24.04 LTS** as the image and **Arm64** as the VM architecture. -In the `Size` field, click on `See all sizes` and select the `D-Series v6` family of VMs. Select `D2psv6` from the list and create the VM. +In the **Size** field, select **See all sizes**. The Cobalt 200 sizes might appear under **Other sizes**. Select **D2ps_v7** from the **D-series v7** family, configure SSH public key authentication, and create the VM. -![azure-cobalt-vm #center](_images/azure-cobalt-vm.webp) +Your subscription and selected region must have access to Dpsv7 sizes and sufficient vCPU quota. This Learning Path was validated in **West US 2**. + +After the VM is running, connect with SSH and verify the architecture and CPU model: + +```console +uname -m +lscpu | grep 'Model name' +``` + +The output is similar to: + +```output +aarch64 +Model name: Neoverse-V3 +``` {{% notice Note %}} To learn more about Arm-based VMs in Azure, refer to "Getting Started with Microsoft Azure" in [*Get started with Arm-based cloud instances*](/learning-paths/servers-and-cloud-computing/csp/azure/). @@ -29,44 +43,96 @@ To learn more about Arm-based VMs in Azure, refer to "Getting Started with Micro ## How do I configure the GitHub repository? -The source code for the application and configuration files that you require to follow this Learning Path are hosted in this [msbuild-azure github repository](https://github.com/pbk8s/msbuild-azure). This repository also contains the Dockerfile and Kubernetes deployment manifests that you require to deploy the .NET 8 based application. +The source code and configuration files are hosted in the [msbuild-azure GitHub repository](https://github.com/pbk8s/msbuild-azure). The repository also contains the Dockerfile and Kubernetes deployment manifests. After forking it, you'll update the application to use .NET 10. + +Fork the repository first. Then prepare the VM and configure the runner. + +### Install the tools the workflow needs on the VM + +The workflow builds a container image, runs Azure CLI commands, and deploys with `kubectl` on the runner. Connect to the `D2ps_v7` VM you created in the previous step and install these tools before you configure the runner: + +* Docker Engine. Follow the [Docker Engine install guide](/install-guides/docker/docker-engine/). +* Azure CLI. Follow the [Azure CLI install guide](/install-guides/azure-cli/). +* `kubectl`. Follow the [kubectl install guide](/install-guides/kubectl/). + +Confirm that each tool works: + +```console +docker run --rm hello-world +az version +kubectl version --client +``` + +The `docker` command must work without `sudo`. -Follow these steps: +### Configure the runner -* Start by forking the repository. +1. In your fork, navigate to the **Settings** tab and select **Actions** in the navigation pane. -* Once the GitHub repository is forked, navigate to the `Settings` tab, and click on `Actions` in the left navigation pane. +2. In **Runners**, select **New self-hosted runner** to configure the runner. - * In `Runners`, select `New self-hosted runner`, which opens up a new page to configure the runner. +3. For **Runner image**, select **Linux**, and for **Architecture**, select **ARM64**. -* For `Runner image`, select `Linux`, and for `Architecture`, select `ARM64`. +4. Run the commands shown on the `D2ps_v7` VM to download, extract, and configure the runner. -* Using the commands shown, execute them on the `D2psv6` VM you created in the previous step. +5. After you run `config.sh`, install and start the runner as a service so it keeps running after you close your SSH session. Run these commands from the runner directory: -* Once you have configured the runner successfully, you will see a self-hosted runner appear on the same page in GitHub. + ```console + sudo ./svc.sh install + sudo ./svc.sh start + sudo ./svc.sh status + ``` + + The status output shows `active (running)` and `Listening for Jobs`. + +6. Confirm that the self-hosted runner appears on the same GitHub page with the **Idle** status. {{% notice Note %}} -To learn more about creating an Arm-based self-hosted runner, see this Learning Path [*Use Self-Hosted Arm64-based runners in GitHub Actions for CI/CD*](/learning-paths/laptops-and-desktops/self_hosted_cicd_github/). +To learn more about creating an Arm-based self-hosted runner, see [Use Self-Hosted Arm64-based runners in GitHub Actions for CI/CD](/learning-paths/laptops-and-desktops/self_hosted_cicd_github/). {{% /notice %}} -## How do I create an AKS cluster with Arm-based Azure Cobalt 100 nodes using Terraform? +## How do I create an AKS cluster with Arm-based Azure Cobalt 200 nodes using Terraform? + +To create an Arm-based AKS cluster, follow [Create an Arm-based Kubernetes cluster on Microsoft Azure Kubernetes Service](/learning-paths/servers-and-cloud-computing/aks/cluster_deployment/). The Terraform configuration in that Learning Path uses the Cobalt 200 `Standard_D2ps_v7` VM size for the cluster nodes and **West US 2** as the default region. + +Your subscription and selected region must have access to Dpsv7 sizes and sufficient vCPU quota. -You can create an Arm-based AKS cluster by following the steps in this Learning Path [*Create an Arm-based Kubernetes cluster on Microsoft Azure Kubernetes Service*](/learning-paths/servers-and-cloud-computing/aks/cluster_deployment/). +Note the `resource_group_name` and `cluster_name` values that Terraform prints. You use them later as the `CLUSTER_RESOURCE_GROUP_NAME` and `CLUSTER_NAME` GitHub secrets. -Make sure to update the `main.tf` file with the correct VM as shown below: +After the cluster is created, connect to it and confirm that the nodes use the Cobalt 200 VM size and the `arm64` architecture: ```console -`vm_size` = `Standard_D2ps_v6` +kubectl get nodes -L node.kubernetes.io/instance-type,kubernetes.io/arch ``` + +The output is similar to: + +```output +NAME STATUS ROLES AGE VERSION INSTANCE-TYPE ARCH +aks-demopool-33234337-vmss000000 Ready 2m43s v1.36.5 Standard_D2ps_v7 arm64 +aks-demopool-33234337-vmss000001 Ready 2m45s v1.36.5 Standard_D2ps_v7 arm64 +aks-demopool-33234337-vmss000002 Ready 2m19s v1.36.5 Standard_D2ps_v7 arm64 +``` + Once you have successfully created the cluster, you can proceed to the next section. ## How do I create a container registry with Azure Container Registry (ACR)? -To create a container registry in Azure Container Registry to host the Docker images for your application, use the following command: +To create a container registry in Azure Container Registry to host the Docker images for your application, use the following command. Replace `` and `` with your resource group and a globally unique registry name: ```console -az acr create --resource-group myResourceGroup --name mycontainerregistry +az acr create --resource-group --name --sku Basic ``` + +Use the registry name, without `.azurecr.io`, for the `ACR_Name` GitHub secret in the next section. + +Allow the AKS cluster to pull images from the registry. Replace the placeholders with your cluster resource group, cluster name, and registry name: + +```console +az aks update --resource-group --name --attach-acr +``` + +This command needs permission to create role assignments. For registries using repository-level ABAC permissions, follow the [AKS and ACR authentication guidance](https://learn.microsoft.com/en-us/azure/aks/cluster-container-registry-integration) instead. ## How do I set up GitHub Secrets? The next step allows GitHub Actions to access the Azure Container Registry to push application docker images and Azure Kubernetes Service to deploy application pods. @@ -74,38 +140,62 @@ The next step allows GitHub Actions to access the Azure Container Registry to pu Create the following secrets in your GitHub repository: - Populate `ACR_Name` with the name of your Azure Container Registry. -- Populate `AZURE_CREDENTIALS` with Azure Credentials of a Service Principal. +- Populate `AZURE_CREDENTIALS` with the JSON output of the service principal command in the next section. - Populate `CLUSTER_NAME` with the name of your AKS cluster. - Populate `CLUSTER_RESOURCE_GROUP_NAME` with the name of your resource group. -Refer to this [guide](https://learn.microsoft.com/en-us/azure/developer/github/connect-from-azure-secret) for further information about signing into Azure using GitHub Actions. +### Create a service principal for GitHub Actions -## Deploy a .NET-based application +The `AZURE_CREDENTIALS` secret holds a service principal that GitHub Actions uses to push images to the registry and deploy to the cluster. Get your subscription ID: -.NET added support for Arm64 applications starting with version 6. Several performance enhancements have been made in later versions. The latest version that supports Arm64 targets is .NET 9. In this Learning Path, you will use the .NET 8 SDK for application development. +```console +SUB=$(az account show --query id -o tsv) +echo $SUB +``` -Follow these steps: +Create the service principal with the Contributor role on the resource group that contains your registry. Replace `` with that resource group: + +```console +az ad sp create-for-rbac --name cobalt200-gh-actions --role contributor --scopes /subscriptions/$SUB/resourceGroups/ --json-auth +``` -* In your fork of the GitHub repository, inspect the `aks-ga-demo.csproj` file. +The command prints a JSON document that contains a client secret. Copy the entire JSON output, including the braces, into the `AZURE_CREDENTIALS` secret. You can't view the secret again later. Don't commit it or share it. -* Verify that the `TargetFramework` field has `net8.0` as the value. +{{% notice Note %}} +Some Azure CLI versions print a warning that `--sdk-auth` is deprecated when you use `--json-auth`. The output is the same, and you can ignore the warning. +{{% /notice %}} -The contents of the file are shown below: +Give the service principal the same role on the resource group that contains your AKS cluster. Replace `` with that resource group: ```console +APPID=$(az ad sp list --display-name cobalt200-gh-actions --query "[0].appId" -o tsv) +az role assignment create --assignee $APPID --role contributor --scope /subscriptions/$SUB/resourceGroups/ +``` + +If your registry and cluster are in the same resource group, skip this step. + +Refer to this [guide](https://learn.microsoft.com/en-us/azure/developer/github/connect-from-azure-secret) for further information about signing into Azure using GitHub Actions. + +## Deploy a .NET-based application + +.NET supports Arm64 applications. Update the example application to use the .NET 10 SDK and runtime. + +In your fork of the GitHub repository, edit `aks-ga-demo.csproj` and set `TargetFramework` to `net10.0`: + +```xml - net8.0 + net10.0 aks_ga_demo ``` -You can inspect the contents of the `Dockerfile` within your repository as well. This is a multi-stage Dockerfile with the following stages: +Update the `Dockerfile` in your fork to use .NET 10 in the base and build stages. Set `ASPNETCORE_URLS` so the application listens on port 80, matching the Kubernetes manifests. This is a multi-stage Dockerfile with the following stages: -1. `base` stage - prepares the base environment with the `.NET 8 SDK` and exposes ports 80 and 443. +1. `base` stage - prepares the base environment with the .NET 10 SDK and exposes ports 80 and 443. 2. `build` stage - restores dependencies and builds the application. @@ -113,13 +203,16 @@ You can inspect the contents of the `Dockerfile` within your repository as well. 4. `final` stage - copies the published application into the final image and sets the entry point to run the application. -```console -FROM mcr.microsoft.com/dotnet/sdk:8.0 AS base +Replace the contents of `Dockerfile` with: + +```dockerfile +FROM mcr.microsoft.com/dotnet/sdk:10.0 AS base WORKDIR /app EXPOSE 80 EXPOSE 443 +ENV ASPNETCORE_URLS=http://+:80 -FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build +FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build WORKDIR /src COPY ["aks-ga-demo.csproj", "./"] RUN dotnet restore "./aks-ga-demo.csproj" @@ -136,7 +229,7 @@ COPY --from=publish /app/publish . ENTRYPOINT ["dotnet", "aks-ga-demo.dll"] ``` -Next, navigate to the `k8s` folder and check the Kubernetes yaml files. The `deployment.yml` file defines a deployment for the application. It specifies the container image to use from ACR and exposes port 80 for the application. The deployment ensures that the application runs with the defined resource constraints and is accessible on the specified port. +Next, edit `k8s/deployment.yml` in your fork. Replace `msbuilddemo` in the image name with your own registry name, matching `ACR_Name`. The file defines the application deployment and exposes port 80. The following example uses `` as a placeholder; replace it with your registry name: ```yaml apiVersion: apps/v1 @@ -154,7 +247,7 @@ spec: spec: containers: - name: githubactions-aks-demo - image: msbuilddemo.azurecr.io/githubactions-aks-demo + image: .azurecr.io/githubactions-aks-demo resources: limits: memory: "128Mi" @@ -179,7 +272,7 @@ spec: targetPort: 80 ``` -Finally, have a look at the GitHub Actions file located at `.github/workflows/deploytoAKS.yml` +Finally, replace `.github/workflows/deploytoAKS.yml` in your fork with the following workflow. It uses the `ACR_Name` secret for registry login, image pushes, and deployment: ```yaml name: Deploy .NET app @@ -193,6 +286,8 @@ jobs: deploy: name: Deploy application runs-on: self-hosted + env: + ACR_NAME: ${{ secrets.ACR_Name }} steps: - name: Checkout repo @@ -207,12 +302,12 @@ jobs: creds: '${{ secrets.AZURE_CREDENTIALS }}' - name: ACR login - run: az acr login --name msbuilddemo + run: az acr login --name "$ACR_NAME" - name: Tag and push image run: | - docker tag githubactions-aks-demo:'${{github.sha}}' msbuilddemo.azurecr.io/githubactions-aks-demo:'${{github.sha}}' - docker push msbuilddemo.azurecr.io/githubactions-aks-demo:'${{github.sha}}' + docker tag githubactions-aks-demo:'${{github.sha}}' "$ACR_NAME.azurecr.io/githubactions-aks-demo:${{github.sha}}" + docker push "$ACR_NAME.azurecr.io/githubactions-aks-demo:${{github.sha}}" - name: Get AKS credentials env: @@ -232,9 +327,11 @@ jobs: k8s/deployment.yml k8s/service.yml images: | - msbuilddemo.azurecr.io/githubactions-aks-demo:${{github.sha }} + ${{ secrets.ACR_Name }}.azurecr.io/githubactions-aks-demo:${{ github.sha }} ``` +Commit and push the updated project file, Dockerfile, deployment manifest, and workflow to your fork. A push also triggers the workflow. + This GitHub Actions yaml file defines a workflow to deploy a .NET application to Azure Kubernetes Service (AKS). This workflow runs on the self-hosted GitHub Actions runner that you configured in a previous step. This workflow can be triggered manually, or on a push to the repository. It has the following main steps: @@ -249,14 +346,40 @@ It has the following main steps: ## How do I run the CI/CD pipeline? -The next step is to trigger the pipeline manually by navigating to `Actions` tab in the GitHub repository. Select `Deploy .NET app`, and click on `Run Workflow`. You can also execute the pipeline by making a commit to the repository. Once the pipeline executes successfully, you will see the Actions output in a format similar to what is shown below: +To trigger the pipeline manually, navigate to the **Actions** tab in the GitHub repository. Select **Deploy .NET app**, then select **Run Workflow**. You can also run the pipeline by making a commit to the repository. When the pipeline runs successfully, the Actions output looks similar to this: + +![GitHub Actions log showing the Deploy application step succeeding after kubectl creates the deployment and service #center](_images/github-run.webp "Successful Deploy application step") + +Check your Kubernetes cluster for the new application pod: + +```console +kubectl get pods -o wide +``` + +The output is similar to: + +```output +NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES +githubactions-aks-demo-8667bb85bc-w8tqq 1/1 Running 0 92s 10.244.2.185 aks-demopool-33234337-vmss000002 +``` -![github-run #center](_images/github-run.webp) +The pod runs on one of the `Standard_D2ps_v7` Arm64 nodes you created earlier. Next, check the service: -You can check your kubernetes cluster and see new application pods deployed on the cluster as shown below: +```console +kubectl get service githubactions-aks-demo-service +``` -![kubernetes-deployment #center](_images/kubernetes-deployment.webp) +The output is similar to: +```output +NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE +githubactions-aks-demo-service LoadBalancer 10.0.217.54 48.202.105.207 8080:31431/TCP 102s +``` +Use the `EXTERNAL-IP` value from your own output to test the application: +```console +curl -s -o /dev/null -w "%{http_code}\n" http://:8080/ +``` +The command prints `200`. You can also open `http://:8080/` in a browser. diff --git a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/background.md b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/background.md index 2648ea4c7f..4e41c21c32 100644 --- a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/background.md +++ b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/background.md @@ -6,16 +6,10 @@ weight: 2 layout: "learningpathall" --- -## What is the Azure Cobalt 100 Arm-based processor? +## What is the Azure Cobalt 200 Arm-based processor? -Cobalt 100 is Microsoft's first Arm-based server processor, built using the Armv9 Neoverse-N2 CPU. +Azure Cobalt 200 is Microsoft's second-generation Arm-based server processor, built on Arm Neoverse Compute Subsystems V3 (CSS V3). It is designed for cloud-native, scale-out Linux workloads such as the CI/CD runners and containerized applications in this Learning Path. -The Cobalt 100 processor is optimized for the performance of scale-out cloud-based applications. - -The Azure Cobalt 100 VM instances include two series: - -* The general-purpose `Dpsv6 and Dplsv6` virtual machine series. -* The memory-optimized `Epsv6` virtual machine series. - -To learn more about Azure Cobalt 100, refer to the blog ["Announcing the preview of new Azure VMs based on the Azure Cobalt 100 processor"](https://techcommunity.microsoft.com/t5/azure-compute-blog/announcing-the-preview-of-new-azure-vms-based-on-the-azure/ba-p/4146353). +Azure Cobalt 200 VMs include several series, such as the general-purpose Dpsv7 and Dplsv7 series and the memory-optimized Epsv7 series. In this Learning Path, you use the general-purpose Dpsv7 series. +To learn more about Azure Cobalt 200, see Microsoft's [introduction to Azure Cobalt 200 virtual machines](https://azure.microsoft.com/en-us/blog/new-azure-cobalt-200-vms-deliver-50-performance-improvement-fully-optimized-for-modern-agentic-ai-workloads/). diff --git a/content/migration/_index.md b/content/migration/_index.md index f4dbb20f01..469b131edf 100644 --- a/content/migration/_index.md +++ b/content/migration/_index.md @@ -1,7 +1,7 @@ --- title: "How can I migrate applications to Arm Neoverse?" layout: "migration" # Easier for dynamic content loading, keep the same -description: Software developers are embracing the Arm architecture for its superior price performance and energy efficiency across a wide range of applications, including containerized workloads, cloud managed services, and Linux applications. To achieve higher performance and lower cost, you can migrate your self-managed workloads to Arm virtual machines and make sure to select Arm for managed services. A three step migration process covers the most common scenarios, and provides links to additional resources. +description: Software developers are embracing the Arm architecture for its superior price-performance and energy efficiency across a wide range of applications, including containerized workloads, cloud managed services, and Linux applications. To achieve higher performance and lower cost, you can migrate your self-managed workloads to Arm virtual machines and make sure to select Arm for managed services. A 3-step migration process covers the most common scenarios, and provides links to additional resources. --- ## Learn and explore @@ -16,12 +16,12 @@ Below is a list of Neoverse CPUs, the architecture versions, and the key additio | CPU | Architecture version | Key additions | | ----------- | -------------------- | --------------------------------------------------------- | -| Neoverse-N1 | Armv8.2-A | LSE - Large System Extensions improves multi-threaded performance. | -| Neoverse-V1 | Armv8.4-A | SVE - Scalable Vector Extension adds high performance vector processing for HPC and AI workloads. | -| Neoverse-N2 | Armv9.0-A | SVE2 - Extends SVE for improved data parallelism and wider vectors. | -| Neoverse-V2 | Armv9.0-A | SVE2 - Targets high single threaded performance for HPC and AI workloads. | -| Neoverse-N3 | Armv9.2-A | Balanced performance and power with extended SVE2 and crypto performance. | -| Neoverse-V3 | Armv9.2-A | High performance, confidential compute, and extended SVE2 and crypto performance. | +| Neoverse N1 | Armv8.2-A | LSE - Large System Extensions improves multi-threaded performance. | +| Neoverse V1 | Armv8.4-A | SVE - Scalable Vector Extension adds high-performance vector processing for HPC and AI workloads. | +| Neoverse N2 | Armv9.0-A | SVE2 - Extends SVE for improved data parallelism and wider vectors. | +| Neoverse V2 | Armv9.0-A | SVE2 - Targets high single threaded performance for HPC and AI workloads. | +| Neoverse N3 | Armv9.2-A | Balanced performance and power with extended SVE2 and crypto performance. | +| Neoverse V3 | Armv9.2-A | High performance, confidential compute, and extended SVE2 and crypto performance. | ### What cloud hardware is available today? @@ -30,40 +30,52 @@ Review each cloud service provider below to learn about Arm-based servers. {{< tabpane-normal >}} {{< tab header="AWS">}} -AWS offers more than [150 instance types with Graviton processors](https://aws.amazon.com/ec2/graviton/). The largest instance has 192 vCPUs and 1.5 TB of memory. A wide variety of instance sizes are available, including bare-metal (look for '.metal'). To find instances with Graviton processors look for 'g' in the name (C7g, M7g, and R7g). +AWS offers more than [150 instance types with Graviton processors](https://aws.amazon.com/ec2/graviton/). The largest instance has 192 vCPUs and 1.5 TB of memory. A wide variety of instance sizes are available, including bare-metal (look for '.metal'). To find instances with Graviton processors, look for 'g' in the name (C7g, R8g, M9g). + +The table lists example instance families for each generation. Performance figures are AWS estimates and vary by workload. | Generation | Arm CPU | Instance types | Comments | |---------------|--------------|----------------|-----------------------------------------------------------------------------| -| Graviton | Cortex-A72 | A1 | First Arm-based instance. -| Graviton2 | Neoverse-N1 | C6g, M6g, R6g | 600% performance and efficiency increases. | -| Graviton3 | Neoverse-V1 | C7g, M7g, R7g | 25% performance increase, DDR5 memory added, 50% more memory bandwidth. | -| Graviton4 | Neoverse-V2 | R8g | 75% more memory bandwidth, up to 40% faster for databases and 30% faster for web applications. | -| Graviton5 | Neoverse-V3 | M9g | 25% higher performance and 5X larger L3 cache. | +| Graviton | Cortex-A72 | A1 | First Arm-based EC2 instance. | +| Graviton2 | Neoverse N1 | C6g, M6g, R6g | Up to 7 times the processor performance of the first Graviton generation. | +| Graviton3 | Neoverse V1 | C7g, M7g, R7g | Up to 25% better compute performance than Graviton2; DDR5 memory. | +| Graviton4 | Neoverse V2 | R8g | Up to 30% better compute performance than Graviton3. | +| Graviton5 | Neoverse V3 | C9g, C9gd, M9g, M9gd, R9g, R9gd | Up to 25% better compute performance than Graviton4. | {{< /tab >}} {{< tab header="Google GCP">}} -Google GCP offers a variety of [virtual machine instances with Arm processors](https://cloud.google.com/compute/docs/instances/arm-on-compute). The latest generation of Arm-based VMs are based on Google Axion processor. The largest instance has 72 vCPUs and 576 Gb of RAM. It does not offer bare-metal instances. It offers `highcpu` and `highmem` VM instances for compute and memory intensive workloads respectively. +Google Cloud offers a variety of [instances with Arm processors](https://cloud.google.com/compute/docs/instances/arm-on-compute), including bare-metal options. Its Arm-based instances use Google Axion, Ampere Altra, and NVIDIA processors. The `highcpu` and `highmem` machine types support compute-intensive and memory-intensive workloads, respectively. | Generation | Arm CPU | Instance types | Comments | | --------------|--------------|--------------------|-----------| -| T2A | Neoverse-N1 | t2a-standard | Optimized for general-purpose workloads - web servers, and microservices. | -| Axion C4A | Neoverse-V2 | c4a-standard, c4a-highmem, c4a-highcpu | General-purpose, AI/ML workloads and high performance computing. | -| Axion N4A | Neoverse-N3 | n4a-standard, n4a-highmem, n4a-highcpu | General-purpose, efficient for multi-threaded workloads. | -| A4X | Neoverse-V2 | a4x-highgpu-4g | 140 vCPUs and 884 GB of memory using NVIDIA GB200 Superchips, which have B200 GPUs that offer 186 GB memory per GPU. | -| A4X Max | Neoverse-V2 | a4x-maxgpu-4g-metal | 144 vCPUs and 960 GB of memory using NVIDIA GB300 Superchips, which have B300 GPUs that offer 279 GB memory per GPU. | +| T2A | Neoverse N1 | t2a-standard | Optimized for general-purpose workloads - web servers, and microservices. | +| Axion C4A | Neoverse V2 | c4a-standard, c4a-highmem, c4a-highcpu, c4a-standard-96-metal, c4a-highmem-96-metal | General-purpose, AI/ML workloads and high-performance computing. | +| Axion N4A | Neoverse N3 | n4a-standard, n4a-highmem, n4a-highcpu | General-purpose, efficient for multi-threaded workloads. | +| A4X | Neoverse V2 | a4x-highgpu-4g | 140 vCPUs and 884 GB of memory using NVIDIA GB200 Superchips, which have B200 GPUs that offer 186 GB memory per GPU. | +| A4X Max | Neoverse V2 | a4x-maxgpu-4g-metal | 144 vCPUs and 960 GB of memory using NVIDIA GB300 Superchips, which have B300 GPUs that offer 279 GB memory per GPU. | +| A5X | NVIDIA Vera | a5x-highgpu-4g-metal | Bare-metal instance with 176 vCPUs, 1,440 GB of memory, and four NVIDIA Rubin GPUs. | {{< /tab >}} {{< tab header="Microsoft Azure">}} -Microsoft Azure offers a variety of [virtual machine instances with Arm Neoverse processors](https://learn.microsoft.com/en-us/azure/virtual-machines/sizes/general-purpose/dpsv6-series). The current generation of Arm-based VMs are based on Cobalt 100 CPU. The largest instance has 96 vCPUs and 384 Gb of RAM in the 'D96ps_v6' format. It does not offer bare-metal instances. It offers compute for general-purpose workloads (Dps and Dpls) and memory-optimized workloads (Eps). The next generation VMs are based on [Azure Cobalt 200](https://techcommunity.microsoft.com/blog/azureinfrastructureblog/announcing-cobalt-200-azure’s-next-cloud-native-cpu/4469807). +Microsoft Azure offers a variety of [virtual machine instances with Arm Neoverse processors](https://learn.microsoft.com/en-us/azure/virtual-machines/sizes/cobalt-overview). The latest generation uses the Cobalt 200 processor and offers general-purpose, memory-optimized, and storage-optimized VMs, with up to 128 vCPUs. Availability varies by region. -| Generation | Arm CPU | Instance types | Comments | +| Generation | Arm CPU | Instance types | Comments | | --------------|--------------|--------------------|-----------| -| Dpsv5 | Neoverse-N1 | Dpsv5, Epsv5 | General purpose and memory optimized instances. | -| Dpsv6 | Neoverse-N2 | Dpsv6, Dpls6, Epsv6 | Cobalt 100 processor improves performance, Dpsv6 (general purpose 4:1 mem:cpu ratio), Dplsv6 (general purpose, 2:1 mem:cpu ratio), Epsv6 (memory-optimized, 8:1 mem:cpu ratio). | +| Ampere Altra | Neoverse N1 | Dplsv5, Dpldsv5 | General-purpose instances for workloads with lower memory needs. | +| Ampere Altra | Neoverse N1 | Dpsv5, Dpdsv5 | General-purpose instances. | +| Ampere Altra | Neoverse N1 | Epsv5, Epdsv5 | Memory-optimized instances. | +| Cobalt 100 | Neoverse N2 | Dplsv6, Dpldsv6 | General-purpose instances for workloads with lower memory needs. | +| Cobalt 100 | Neoverse N2 | Dpsv6, Dpdsv6 | General-purpose instances. | +| Cobalt 100 | Neoverse N2 | Epsv6, Epdsv6 | Memory-optimized instances. | +| Cobalt 200 | Neoverse V3 | Dplsv7, Dpldsv7 | General-purpose instances with 2 GiB of memory per vCPU. | +| Cobalt 200 | Neoverse V3 | Dpsv7, Dpdsv7 | General-purpose instances with 4 GiB of memory per vCPU. | +| Cobalt 200 | Neoverse V3 | Epsv7, Epdsv7 | Memory-optimized instances with 8 GiB of memory per vCPU. | +| Cobalt 200 | Neoverse V3 | Mpsv4, Mpdsv4 | High-memory instances with 16 GiB of memory per vCPU. | +| Cobalt 200 | Neoverse V3 | Lpsv5 | Storage-optimized instances with local NVMe storage. | {{< /tab >}} {{< tab header="Oracle OCI">}} -Oracle Cloud Infrastructure (OCI) Ampere [Arm-based compute](https://www.oracle.com/cloud/compute/arm/) provides market-leading price-performance for AI, containers, big data, web services, and related workloads. The largest intsance has 160 vCPUs and 1024 Gb of RAM in the 'BM.Standard.A1' format. It offers bare-metal instances (look for 'BM' as opposed to 'VM'). +Oracle Cloud Infrastructure (OCI) Ampere [Arm-based compute](https://www.oracle.com/cloud/compute/arm/) provides market-leading price-performance for AI, containers, big data, web services, and related workloads. The `BM.Standard.A1.160` bare-metal shape has 160 OCPUs and 1,024 GB of RAM. OCI offers bare-metal instances (look for 'BM' as opposed to 'VM'). | Generation | Arm CPU | Instance types | Comments | | --------------|--------------|--------------------|-----------| @@ -77,7 +89,7 @@ Alibaba Cloud offers [3 instance types](https://www.alibabacloud.com/help/en/ecs | Generation | Arm CPU | Instance types | Comments | | --------------|--------------|--------------------|-----------| -| Yitian710 | Neoverse-N2 | c8y, g8y, r8y | Arm based instance| +| Yitian710 | Neoverse N2 | c8y, g8y, r8y | Arm based instance| {{< /tab >}} {{< /tabpane-normal >}} @@ -85,39 +97,42 @@ Read [Get started with Servers and Cloud Computing](/learning-paths/servers-and- ## STEP 1: Plan your transition -Newer software is generally easier to migrate because Arm support continues to improve and performance optimizations are typically better in newer versions. Interpreted languages and Jit compilers, such as Python, Java, PHP, and Node.js are easiest to migrate. Compiled languages such as C/C++, Go, and Rust are slightly more difficult because they need to be recompiled. The most difficult situations involve a language, runtime, operating system, or something else which is not available on Arm or would be difficult to run on Arm. +Newer software is generally easier to migrate because Arm support continues to improve and performance optimizations are typically better in newer versions. Interpreted languages and JIT compilers, such as Python, Java, PHP, and Node.js are easiest to migrate. Compiled languages such as C/C++, Go, and Rust are slightly more difficult because they need to be recompiled. The most difficult situations involve a language, runtime, operating system, or something else which is not available on Arm or would be difficult to run on Arm. -### 1.1 Survey your software stack +### Survey your software stack Step one in a typical migration journey is understanding the software stack. Make notes about operating system versions, programming languages, development tools, container tools, performance analysis tools, and any other important scripts included in the project. You can reference **Migrating applications to Arm servers** below for tips on how to get started - setting up a development machine, common challenges, and tips to proceed at pace. [Migrating applications to Arm servers](/learning-paths/servers-and-cloud-computing/migration/) -### 1.2 Discover Arm compatibility +### Discover Arm compatibility Step two is to look through your scripts and build files and see if you spot architecture specific files. Software migration typically falls into 3 categories: 1. **Automatic:** The Linux package manager installs software from the main repositories without any changes, totally seamless. 2. **Small modifications:** Software installed using scripts or binary downloads requires minor changes to strings, such as changing “x86_64” and “amd64” to “arm64” or “aarch64”. -3. **Challenging:** A few software projects still don't support Arm Linux, some are well known projects like the Edge browser, and the others are smaller projects that haven't added Arm support, yet. Some could be blockers and others may be easy to compile yourself. +3. **Challenging:** A few software projects still don't support Arm Linux, some are well known projects like the Edge browser, and the others are smaller projects that haven't added Arm support yet. Some could be blockers and others may be easy to compile yourself. You can quickly find out if software dependencies are available for Arm using the **Software Ecosystem Dashboard for Arm** link below - search for your package and find out which versions work on Arm and review the getting started tips. The dashboard is actively growing, and is a good place to understand if your software stack will run on Arm servers. [Software Ecosystem Dashboard for Arm.](https://www.arm.com/developer-hub/ecosystem-dashboard/) -### 1.3 Find resources to help +### Find resources to help The below resources are curated to address migration challenges on specific cloud providers. Look through them for additional context. - [Porting architecture specific intrinsics](/learning-paths/cross-platform/intrinsics/) - perfect for porting intrinsics from another architecture. - [Arm software install guides](/install-guides/) - good for quickly installing common tools and software. - [simd.info](https://simd.info/) - a searchable reference tool for C intrinsics for SIMD engines. - [migrate-ease](https://github.com/migrate-ease/migrate-ease) - scan your source code for suggestions to migrate to Arm Neoverse, get started with [Migrate applications to Arm servers using migrate-ease](/learning-paths/servers-and-cloud-computing/migrate-ease/). +- [Automate x86-to-Arm application migration using Arm MCP Server](/learning-paths/servers-and-cloud-computing/arm-mcp-server/) - use an AI coding assistant to check compatibility and help migrate code and containers. The Learning Path includes [setup guidance for supported assistants](/learning-paths/servers-and-cloud-computing/arm-mcp-server/1-overview/#setting-up-the-arm-mcp-server). - [Arm Infrastructure Solutions blog](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/) - an Arm-specific technical blog. - [Arm Learning Paths for Servers and Cloud](/learning-paths/servers-and-cloud-computing/) - general tutorials for Arm servers. You can search for specific platforms, including [Arm AGI](/learning-paths/servers-and-cloud-computing/?platforms-filter=arm-agi/#), [AWS](/learning-paths/servers-and-cloud-computing/?platforms-filter=aws/#), [Google Cloud](/learning-paths/servers-and-cloud-computing/?platforms-filter=google-cloud/#), [Microsoft Azure](/learning-paths/servers-and-cloud-computing/?platforms-filter=microsoft-azure/#), and [Oracle](/learning-paths/servers-and-cloud-computing/?platforms-filter=oracle/#). - AWS has additional resources such as the [Porting Advisor for Graviton](/install-guides/porting-advisor/) and [AWS Graviton Technical Guide](https://github.com/aws/aws-graviton-getting-started). +To find Learning Paths on other topics, use [Arm Learning Paths search](/search/). + Lastly, below are some specific migration helpers for various types of software: {{< tabpane-normal >}} @@ -134,6 +149,7 @@ Which tools are available for building and running containers on Arm servers? | GitHub Actions (GitHub runners) | [Build multi-architecture container images with GitHub Arm-hosted runners](/learning-paths/cross-platform/github-arm-runners/) | [Arm64 on GitHub Actions: Powering faster, more efficient build systems](https://github.blog/news-insights/product-news/arm64-on-github-actions-powering-faster-more-efficient-build-systems/) | | GitHub Actions (AWS Graviton runners) | [Managed, self-hosted Arm runners for GitHub Actions](/learning-paths/servers-and-cloud-computing/github-actions-runner/) | | GitLab (GitLab runners) | [Build a CI/CD pipeline with GitLab on Google Axion](/learning-paths/cross-platform/gitlab/) | | +| Kubernetes | [Migrate containers to Arm using KubeArchInspect](/learning-paths/servers-and-cloud-computing/kubearchinspect/) | | {{< /tab >}} @@ -151,8 +167,8 @@ Which programming languages work on Arm servers? - Nearly all of them. | | | [Optimizing Java Workloads on Azure General Purpose D-series v5 VMs with Microsoft's Build of OpenJDK](https://techcommunity.microsoft.com/t5/azure-compute-blog/optimizing-java-workloads-on-azure-general-purpose-d-series-v5/ba-p/3827610) | | | | [Improving Java performance on OCI Ampere A1 compute instances](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/performance-of-specjbb2015-on-oci-ampere-a1-compute-instances) | | Go | [Go Install Guide](/install-guides/go/) | [Making your Go workloads up to 20% faster with Go 1.18 and AWS Graviton](https://aws.amazon.com/blogs/compute/making-your-go-workloads-up-to-20-faster-with-go-1-18-and-aws-graviton/)| -| .NET | [.NET Install Guide](/install-guides/dotnet/) | [Arm64 Performance Improvements in .NET 7](https://devblogs.microsoft.com/dotnet/arm64-performance-improvements-in-dotnet-7/) | -| | [Deploy .NET application on Azure Cobalt 100 VMs](/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/) | [Arm64 Performance Improvements in .NET 8](https://devblogs.microsoft.com/dotnet/this-arm64-performance-in-dotnet-8/) | +| .NET | [.NET Install Guide](/install-guides/dotnet/) | [Performance improvements in .NET 10](https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-10/) | +| | [Deploy a .NET application on Microsoft Azure Cobalt 200 VMs](/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/) | [Performance improvements in .NET 11](https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-11/) | | Python | | [Python on Arm](https://community.arm.com/arm-community-blogs/b/tools-software-ides-blog/posts/python-on-arm)| | PHP | | [Improving performance of PHP for Arm64 and impact on AWS Graviton2 based EC2 instances](https://aws.amazon.com/blogs/compute/improving-performance-of-php-for-arm64-and-impact-on-amazon-ec2-m6g-instances/) | @@ -163,11 +179,11 @@ Which key libraries are optimized for Arm servers? | Library/Framework | Learn More | Blogs | |-------------------|------------|-------| -| x264/x265 | [Run x265 (H.265 codec) on Arm servers](/learning-paths/servers-and-cloud-computing/codec/) | [Improve video encoding price/performance by up to 36% with Arm Neoverse based Amazon EC2 C6g instances](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/thirty-six-percent-better-video-encoding-with-aws-graviton2_2d00_based-c6g) | +| x264/x265 | [Run x265 (H.265 codec) on Arm servers](/learning-paths/servers-and-cloud-computing/codec/) | [Improve video encoding price-performance by up to 36% with Arm Neoverse based Amazon EC2 C6g instances](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/thirty-six-percent-better-video-encoding-with-aws-graviton2_2d00_based-c6g) | | | | [Reduce H.265 High-Res Encoding Costs by over 80% with AWS Graviton2](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/reduce-h-265-high-res-encoding-costs-by-over-80-with-aws-graviton2-1207706725) | | | | [Ampere Altra Max Delivers Sustainable High-Resolution H.265 Encoding](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/ampere-altra-max-delivers-sustainable-high-resolution-h-265-video-encoding-without-compromise) | | | | [OCI Ampere A1 Compute instances can significantly reduce video encoding costs versus modern CPUs](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/oracle-cloud-infrastructure-arm-based-a1) | -| ArmPL | [Arm Performance Libraries install guide](/install-guides/armpl/) | [Arm Compiler for Linux and Arm Performance Libraries 24.04](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/arm-compiler-for-linux-and-arm-performance-libraries-24-04) | +| ArmPL | [Arm Performance Libraries install guide](/install-guides/armpl/) | [Arm Toolchain for Linux 22.1 release](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/arm-toolchain-for-linux-22-1-release) | | ArmRAL | [Get started with the Arm 5G RAN Acceleration Library (ArmRAL)](/learning-paths/servers-and-cloud-computing/ran/) | [The next chapter for Arm RAN Acceleration Library: Open-sourcing the code base & accelerating adoption](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/arm-ral-is-now-open-source) | | OpenSSL | | | | VP9 | [Run the AV1 and VP9 codecs on Arm Linux](/learning-paths/servers-and-cloud-computing/codec1/) | [Arm-based cloud instances outperform x86 instances by up to 64% on VP9 encoding](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/arm-outperforms-x86-by-up-to-64-percent-on-vp9) | @@ -176,7 +192,7 @@ Which key libraries are optimized for Arm servers? | AV1 | [Run the AV1 and VP9 codecs on Arm Linux](/learning-paths/servers-and-cloud-computing/codec1/) | | | AES | | [AWS Graviton3 delivers leading AES-GCM encryption performance](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/aes-gcm-optimizations-for-armv8-4-on-neoverse-v1-graviton3) | | Snappy | [Measure performance of compression libraries on Arm servers](/learning-paths/servers-and-cloud-computing/snappy/) | [Comparing data compression algorithm performance on AWS Graviton2](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/comparing-data-compression-algorithm-performance-on-aws-graviton2-342166113) | -| Cloudflare zlib | [Learn how to build and use Cloudflare zlib on Arm servers](/learning-paths/servers-and-cloud-computing/zlib/) | | +| zlib-ng | [Improve data compression performance on Arm servers with zlib-ng](/learning-paths/servers-and-cloud-computing/zlib/) | | {{< /tab >}} @@ -192,13 +208,14 @@ Which databases are available on Arm servers? | MySQL | [Learn how to Tune MySQL](/learning-paths/servers-and-cloud-computing/mysql_tune/) | | | PostgreSQL | [Learn how to deploy PostgreSQL](/learning-paths/servers-and-cloud-computing/postgresql/) | | | Flink | [Benchmark the performance of Flink on Arm servers](/learning-paths/servers-and-cloud-computing/flink/) | -| Clickhouse | [Measure performance of ClickHouse on Arm servers](/learning-paths/servers-and-cloud-computing/clickhouse/) | [Improve ClickHouse Performance up to 26% by using AWS Graviton3](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/improve-clickhouse-performance-up-to-26-by-using-aws-graviton3) | +| ClickHouse | [Measure performance of ClickHouse on Arm servers](/learning-paths/servers-and-cloud-computing/clickhouse/) | [Improve ClickHouse Performance up to 26% by using AWS Graviton3](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/improve-clickhouse-performance-up-to-26-by-using-aws-graviton3) | +| ClickHouse | [Build a ClickHouse analytics pipeline on Google Axion](/learning-paths/servers-and-cloud-computing/clickhouse-gcp/) | | | MongoDB | [Test the performance of MongoDB on Arm servers](/learning-paths/servers-and-cloud-computing/mongodb/) | [MongoDB performance on Arm Neoverse based AWS Graviton2 processors](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/mongodb-performance-on-aws-with-the-arm-graviton2) | | Redis | [Deploy Redis on Arm](/learning-paths/servers-and-cloud-computing/redis/) | [Improve Redis performance up to 36% by deploying on Alibaba Cloud Yitian 710 instances](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/improve-redis-performance-by-deploying-on-alibaba-cloud-yitian-710-instances) | | Spark | [Learn how to deploy Spark on AWS Graviton2](/learning-paths/servers-and-cloud-computing/spark/) | [Spark on AWS Graviton2 best practices: K-Means clustering case study](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/optimize-spark-on-aws-graviton2-best-practices-k-means-clustering) | | MariaDB | [Deploy MariaDB on Arm servers](/learning-paths/servers-and-cloud-computing/mariadb/) | -| Elasticsearch/Opensearch | | -| Spark+Gluten+Velox | | +| Elasticsearch/OpenSearch | [Deploy Elasticsearch on Azure Cobalt 100](/learning-paths/servers-and-cloud-computing/elasticsearch-on-azure/) | | +| Spark + Gluten + Velox | [Run Apache Spark SQL with Gluten and Velox on Azure Cobalt 100](/learning-paths/servers-and-cloud-computing/spark-velox-cobalt/) | | | Pinecone | | {{< /tab >}} @@ -230,6 +247,7 @@ Which AI/ML software stack can I run on Arm servers? | Software | Learning Paths | Other Content (Blogs/Videos) | |-----------|----------------|----------------------------------------| | MLPerf | [Measure Machine Learning Inference Performance on Arm servers](/learning-paths/servers-and-cloud-computing/ml-perf/) | | +| PyTorch | [Measure and accelerate PyTorch inference on Arm servers](/learning-paths/servers-and-cloud-computing/torchbench/) | | | vLLM | [Run vLLM inference with INT4 quantization on Arm servers](/learning-paths/servers-and-cloud-computing/vllm-acceleration/) | | | KleidiAI | [Accelerate Generative AI workloads using KleidiAI](/learning-paths/cross-platform/kleidiai-explainer/) | | | Llama.cpp | [Run distributed inference with llama.cpp on Arm-based AWS Graviton4 instances](/learning-paths/servers-and-cloud-computing/distributed-inference-with-llama-cpp/) | | @@ -241,19 +259,19 @@ Which AI/ML software stack can I run on Arm servers? Based on your initial research, decide how to proceed with trying your software on Arm. In general, you can use a top-down or bottom-up strategy to migrate to Arm. Select a methodology and use the resources above to build and run your application. -### 2.1 Top-down methodology +### Top-down methodology Top-down porting involves moving the complete software stack to an Arm machine and trying to build and run it straightaway. You will almost certainly face errors, which you can address one at a time until the full application runs on Arm. -![Top-down porting methodology](/migration/top-down.png) +![Top-down migration: move the full application from x86 to Arm, then fix library errors one at a time until the application runs.](/migration/top-down.png) This methodology is great for simpler stacks, when breaking down the problem would take more time than fixing errors iteratively. -### 2.2 Bottom-up methodology +### Bottom-up methodology Bottom-up porting is more systematic. Here, you break apart your software stack, starting with the foundations of your app to get those running on an Arm server first. Then add back one or two software packages at a time, and recompile and run to ensure it works on Arm. If errors arise, fix them or replace the incompatible package with an Arm compatible version. Continue building back your stack until it is fully formed on an Arm server. -![Bottom-up porting methodology](/migration/bottom-up.png) +![Bottom-up migration: start with a minimal application stack on Arm, fix errors, and add components until the full application runs.](/migration/bottom-up.png) This methodology is sensible for large stacks, where running the whole app on Arm immediately would cause too many errors to effectively work through. @@ -261,9 +279,9 @@ This methodology is sensible for large stacks, where running the whole app on Ar If you've reached this step, congratulations! Your application is running on Arm. The next action is to ensure it is running optimally. -### 3.1 Measure performance +### Measure performance -Once the application is running you can measure performance. This can be as simple as timing an application or may involve using performance analysis tools. +Once the application is running, you can measure performance. This can be as simple as timing an application or may involve using performance analysis tools. You may have some performance analysis methodologies you already follow, continue to use those. @@ -276,13 +294,13 @@ Below are some additional performance analysis tips and methodologies specific t - [Learn about Large System Extensions (LSE)](/learning-paths/servers-and-cloud-computing/lse/) - [Compare Arm Neoverse and Intel x86 top-down performance analysis with PMU counters](/learning-paths/cross-platform/topdown-compare/) -### 3.2 Ask for help +### Ask for help -Your goal is to understand if the performance you see will translate into the expected price performance advantages. If you are unsure or need additional help you can ask the Arm developer community for help. Join the [Arm Developer Program](https://www.arm.com/resources/developer-program) and talk directly to other developers and Arm Experts on Discord. +Your goal is to understand if the performance you see will translate into the expected price-performance advantages. If you are unsure or need additional help, you can ask the Arm developer community for help. Join the [Arm Developer Program](https://www.arm.com/resources/developer-program) and talk directly to other developers and Arm Experts on Discord. -### DELIVER: Deploy your application to users +### Deploy your application to users -Once the price performance gains are confirmed, you can plan for a larger deployment. +Once the price-performance gains are confirmed, you can plan for a larger deployment. Deployment is outside the scope of this guide, but here are some concepts to keep in mind: - Experiment with different virtual machine sizes and instance types to find the best fit for your application. @@ -294,4 +312,4 @@ Make sure to research the details needed for these tasks by checking any places ## Summary -With this 3 step process and the provided resources, you are well positioned to migrate your applications to Arm. Happy porting! +With this 3-step process and the provided resources, you are well positioned to migrate your applications to Arm. Happy porting! diff --git a/content/migration/arm-migration-overview.png b/content/migration/arm-migration-overview.png index 337519f31d..3d3b846abb 100644 Binary files a/content/migration/arm-migration-overview.png and b/content/migration/arm-migration-overview.png differ diff --git a/themes/arm-design-system-hugo-theme/layouts/migration/migration.html b/themes/arm-design-system-hugo-theme/layouts/migration/migration.html index 1cf297aa60..730be44a28 100644 --- a/themes/arm-design-system-hugo-theme/layouts/migration/migration.html +++ b/themes/arm-design-system-hugo-theme/layouts/migration/migration.html @@ -11,7 +11,7 @@

Migration overview

{{partial "general-formatting/markdown-content-formatting.html" .Params.description}}

- Image Alt Text: Arm migration overview + Migration process: learn about Arm, plan the transition, test the application, optimize its performance, and deploy. @@ -28,4 +28,4 @@

Migration overview

-{{end}} \ No newline at end of file +{{end}}