fix: standardize nginx references and improve documentation clarity across multi-architecture learning path

Author: madeline-underwood

content/learning-paths/servers-and-cloud-computing/multiarch_nginx_on_aks/_index.md

@@ -9,13 +9,13 @@ learning_objectives:
     - 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
+    - Compare performance between x86 and Arm64 nginx instances
     - Learn techniques for deploying multi-architecture Kubernetes workloads
 
 
 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](/install-guides/azure-cli/) and [`kubectl`](/install-guides/kubectl/) installed
+    - A local machine with [`jq`](https://jqlang.org/download/), [`curl`](https://curl.se/download.html), [`wrk`](https://github.com/wg/wrk), [Azure CLI](/install-guides/azure-cli/), and [`kubectl`](/install-guides/kubectl/) installed
 
 author:
     - Geremy Cohen
@@ -40,19 +40,23 @@ tools_software_languages:
 
 further_reading:
   - resource:
-      title: NGINX website
+      title: nginx website
       link: https://nginx.org/
       type: website
   - resource:
-      title: nginx Docker Hub
+      title: nginx on Docker Hub
       link: https://hub.docker.com/_/nginx
       type: documentation
   - resource:
       title: Azure Kubernetes Service (AKS) documentation
       link: https://docs.microsoft.com/en-us/azure/aks/
       type: documentation
   - resource:
-      title: Learn how to tune Nginx
+      title: Learn how to deploy nginx [Arm Learning Path]
+      link: https://learn.arm.com/learning-paths/servers-and-cloud-computing/nginx/
+      type: documentation
+  - resource:
+      title: Learn how to tune nginx [Arm Learning Path]
       link: https://learn.arm.com/learning-paths/servers-and-cloud-computing/nginx_tune/
       type: documentation
 

content/learning-paths/servers-and-cloud-computing/multiarch_nginx_on_aks/_next-steps.md

@@ -0,0 +1,8 @@
+---
+# ================================================================================
+#       FIXED, DO NOT MODIFY THIS FILE
+# ================================================================================
+weight: 21                  # Set to always be larger than the content in this path to be at the end of the navigation.
+title: "Next Steps"         # Always the same, html page title.
+layout: "learningpathall"   # All files under learning paths have this same wrapper for Hugo processing.
+---

content/learning-paths/servers-and-cloud-computing/multiarch_nginx_on_aks/apply-configuration.md

@@ -8,7 +8,7 @@ layout: learningpathall
 
 ## Install btop monitoring tool on nginx pods
 
-Now that you have all your `nginx` deployments running across Intel and Arm architectures, you can monitor performance across each architecture using `wrk` to generate load and `btop` to monitor system performance.
+Now that you have all your nginx deployments running across Intel and Arm architectures, you can monitor performance across each architecture using `wrk` to generate load and `btop` to monitor system performance.
 
 {{% notice Note %}}
 This Learning Path uses [`wrk`](https://github.com/wg/wrk) to generate HTTP load testing. You can easily install `wrk` using `apt` or `brew` package managers. 
@@ -39,7 +39,7 @@ Installing btop on nginx-intel-deployment-6f5bff9667-zdrqc...
 
 The `nginx_util.sh` script includes a `put config` command that:
 
-- Applies a performance-optimized `nginx` configuration to all pods
+- Applies a performance-optimized nginx configuration to all pods
 - Installs `btop` monitoring tool on all pods for system monitoring
 - Restarts pods with the new configuration
 
@@ -60,8 +60,7 @@ Because pods are ephemeral, you need to reinstall `btop` if pods restart or get
 
 
 ## Set up real-time performance monitoring
-
-You can now log in to any pod and use `btop` to monitor system performance. There are many variables that can affect an individual workload's performance, and `btop` (like `top`) is a great first step in understanding those variables.
+You can now log in to any pod and monitor system performance with `btop`. Many factors can affect workload performance, and `btop` (like `top`) is an excellent starting point for understanding these metrics.
 
 {{% notice Note %}}
 Network performance can impact load testing accuracy when running from your local machine. If you experience low request rates (under 70,000 requests/s), consider running the test from an Azure VM in the same region as your cluster.
@@ -73,7 +72,7 @@ Running two btop terminals, one for each pod, is a convenient way to view perfor
 To bring up btop on both Arm and Intel pods, follow these steps:
 
 - Open two new terminal windows
-- In one terminal, run `login arm` from the `nginx` utility script to enter the pod 
+- In one terminal, run `login arm` from the nginx utility script to enter the pod 
 - In the second terminal, run `login intel` from the `nginx` utility script to enter the pod 
 - Once inside each pod, run `btop` to see real-time system monitoring
 
@@ -101,7 +100,7 @@ You should now see something similar to the image below, with one terminal for e
 
 ![Two terminal windows displaying btop system monitoring interface with CPU, memory, and process information for nginx pods running on different architectures in an idle state alt-text#center](images/btop_idle.png)
 
-To visualize performance with `btop` against the Arm and Intel pods via the load balancer service endpoints, you can use the `nginx_util.sh` wrapper to generate load to both simultaneously:
+To visualize performance with btop against the Arm and Intel pods using the load balancer service endpoints, you can use the `nginx_util.sh` wrapper to generate load to both simultaneously:
 
 ```bash
 ./nginx_util.sh wrk both

content/learning-paths/servers-and-cloud-computing/multiarch_nginx_on_aks/create-test-utility.md

@@ -6,21 +6,21 @@ weight: 4
 layout: learningpathall
 ---
 
-## Overview
+## Understand the utility script’s purpose
 
-In this section, you'll create a utility script that simplifies working with your multi-architecture Kubernetes deployment. This script acts as a convenient wrapper around common `kubectl` and testing commands, making it easier to interact with `nginx` pods across different architectures.
+In this section, you'll create a utility script that simplifies working with your multi-architecture Kubernetes deployment. This script acts as a convenient wrapper around common kubectl and testing commands, making it easier to interact with nginx pods across different architectures.
 
-Instead of typing long `kubectl` commands repeatedly, you'll use this utility to quickly test services, monitor performance, and access pods on both Arm and Intel nodes. This approach saves time and reduces errors, especially when comparing behavior across architectures.
+Instead of typing long kubectl commands repeatedly, you'll use this utility to quickly test services, monitor performance, and access pods on both Arm and Intel nodes. This approach saves time and reduces errors, especially when comparing behavior across architectures.
 
 By the end of this section, you'll have a ready-to-use tool that streamlines the testing and monitoring tasks you'll perform throughout the rest of this Learning Path.
 
 ## Get to know the utility script
-The utility script provides three main functions to help you work with your multi-architecture `nginx` deployment. You can use it to test services across different architectures, monitor performance, and access pods directly.
+The utility script provides three main functions to help you work with your multi-architecture nginx deployment. You can use it to test services across different architectures, monitor performance, and access pods directly.
 
-The script provides the following key commands to interact with your `nginx` deployment:
+The script provides the following key commands to interact with your nginx deployment:
 
-- `curl intel|arm|multiarch` tests `nginx` services and show which pod served the request
-- `put btop` installs `btop` monitoring tool on all pods
+- `curl intel|arm|multiarch` tests nginx services and show which pod served the request
+- `put btop` installs btop monitoring tool on all pods
 - `login intel|arm` is an interactive bash access to architecture-specific pods
 
 These commands streamline common tasks you'll perform when working with multi-architecture deployments. The `curl` command helps you verify that requests are being properly distributed across different architectures, while the `login` command gives you direct access to pods for debugging or configuration changes.
@@ -55,4 +55,4 @@ The script displays its usage instructions:
 Invalid first argument. Use 'curl', 'wrk', 'put', or 'login'.
 ```
 
-You're now ready to deploy `nginx` to the Intel nodes in the cluster.
+You're now ready to deploy nginx to the Intel nodes in the cluster.

content/learning-paths/servers-and-cloud-computing/multiarch_nginx_on_aks/deploy-arm.md

@@ -8,11 +8,11 @@ layout: learningpathall
 
 ## Add the Arm deployment and service
 
-In this section, you'll add `nginx` on Arm to your existing cluster, completing your multi-architecture Intel/Arm environment for comprehensive performance comparison.
+In this section, you'll add nginx on Arm to your existing cluster, completing your multi-architecture Intel/Arm environment for comprehensive performance comparison.
 
 When you apply the arm_nginx.yaml file, it creates two Kubernetes objects:
 
-- A deployment named `nginx-arm-deployment` that pulls the multi-architecture `nginx` image from DockerHub, launches a pod on the Arm node, and mounts the shared ConfigMap as `/etc/nginx/nginx.conf`
+- A deployment named `nginx-arm-deployment` that pulls the multi-architecture nginx image from DockerHub, launches a pod on the Arm node, and mounts the shared ConfigMap as `/etc/nginx/nginx.conf`
 - A service called `nginx-arm-svc` that acts as a load balancer, targeting pods with both `app: nginx-multiarch` and `arch: arm` labels
 
 Copy and paste the following commands into a terminal to download and apply the Arm deployment and service:
@@ -33,7 +33,7 @@ service/nginx-arm-svc created
 
 Take a closer look at the `arm_nginx.yaml` deployment file and you'll see settings optimized for the Arm architecture:
 
-The `nodeSelector` value of `kubernetes.io/arch: arm64` ensures that the deployment only runs on Arm nodes, utilizing the `arm64` version of the `nginx` container image.
+The `nodeSelector` value of `kubernetes.io/arch: arm64` ensures that the deployment only runs on Arm nodes, utilizing the `arm64` version of the nginx container image.
 
 ```yaml
     spec:
@@ -85,11 +85,11 @@ NAME               DATA   AGE
 nginx-config       1      10m
 ```
 
-When the pods show `Running` and the service shows a valid `External IP`, you're ready to test the `nginx` Arm service.
+When the pods show `Running` and the service shows a valid `External IP`, you're ready to test the nginx Arm service.
 
 ## Test the nginx web service on Arm
 
-Run the following command to make an HTTP request to the Arm `nginx` service using the script you created earlier:
+Run the following command to make an HTTP request to the Arm nginx service using the script you created earlier:
 
 ```bash
 ./nginx_util.sh curl arm
@@ -108,7 +108,7 @@ Response:
 Served by: nginx-arm-deployment-5bf8df95db-wznff
 ```
 
-If you see similar output, you have successfully added Arm nodes to your cluster running `nginx`.
+If you see similar output, you have successfully added Arm nodes to your cluster running nginx.
 
 ## Compare both architectures
 

content/learning-paths/servers-and-cloud-computing/multiarch_nginx_on_aks/deploy-intel.md

@@ -8,12 +8,12 @@ layout: learningpathall
 
 ## Deployment and service
 
-In this section, you'll add a new namespace, deployment, and service for `nginx` on Intel x86 architecture. The result will be a K8s cluster running `nginx` accessible through the Internet using a load balancer. 
+In this section, you'll add a new namespace, deployment, and service for nginx on Intel x86 architecture. The result will be a K8s cluster running nginx accessible through the Internet using a load balancer. 
 
 The deployment configuration uses three separate files to organize the different components:
 
-- A file called `namespace.yaml` that creates a dedicated `nginx` namespace to contain all your Kubernetes `nginx` objects. 
-- A file called `nginx-configmap.yaml` that contains a shared ConfigMap called `nginx-config` with performance-optimized `nginx` settings that both Intel and Arm deployments will use. 
+- A file called `namespace.yaml` that creates a dedicated nginx namespace to contain all your Kubernetes nginx objects. 
+- A file called `nginx-configmap.yaml` that contains a shared ConfigMap called `nginx-config` with performance-optimized nginx settings that both Intel and Arm deployments will use. 
 - A file called `intel_nginx.yaml` that creates two main Kubernetes objects: 
   - A deployment called `nginx-intel-deployment` that pulls the multi-architecture [nginx image](https://hub.docker.com/_/nginx) from DockerHub and runs it on the Intel node
   - A service called `nginx-intel-svc` that acts as a load balancer for pods labeled with both `app: nginx-multiarch` and `arch: intel`. The deployment automatically mounts the shared ConfigMap as `/etc/nginx/nginx.conf` to apply the optimized configuration.
@@ -72,7 +72,7 @@ The service selector uses both `app: nginx-multiarch` and `arch: intel` labels t
     arch: intel
 ```
 
-Because the final goal is to run `nginx` on multiple architectures, the deployment uses the standard `nginx` image from DockerHub. This image supports multiple architectures, including amd64 (Intel) and arm64 (Arm).
+Because the final goal is to run nginx on multiple architectures, the deployment uses the standard nginx image from DockerHub. This image supports multiple architectures, including amd64 (Intel) and arm64 (Arm).
 
 ```yaml
       containers:
@@ -81,7 +81,7 @@ Because the final goal is to run `nginx` on multiple architectures, the deployme
 ```
 
 {{% notice Note %}}
-You can set `nginx` as your default namespace to avoid typing `-nnginx` in future commands:
+You can set nginx as your default namespace to avoid typing `-nnginx` in future commands:
 ```bash
 kubectl config set-context --current --namespace=nginx
 ```
@@ -123,11 +123,11 @@ NAME               DATA   AGE
 nginx-config       1      51s
 ```
 
-With the pods in a `Ready` state and the service showing a valid `External IP`, you're now ready to test the `nginx` Intel service.
+With the pods in a `Ready` state and the service showing a valid `External IP`, you're now ready to test the nginx Intel service.
 
 ## Test the Intel service
 
-Run the following to make an HTTP request to the Intel `nginx` service:
+Run the following to make an HTTP request to the Intel nginx service:
 
 ```bash
 ./nginx_util.sh curl intel
@@ -147,6 +147,6 @@ Response:
 Served by: nginx-intel-deployment-758584d5c6-2nhnx
 ```
 
-If you see similar output, you've successfully configured your AKS cluster with an Intel node, running an `nginx` deployment and service with the `nginx` multi-architecture container image.
+If you see similar output, you've successfully configured your AKS cluster with an Intel node, running an nginx` deployment and service with the nginx multi-architecture container image.
 
 

content/learning-paths/servers-and-cloud-computing/multiarch_nginx_on_aks/deploy-multiarch.md

@@ -8,11 +8,11 @@ layout: learningpathall
 
 ## Add a multi-architecture service to your cluster
 
-You now have `nginx` running on Intel and Arm nodes with architecture-specific services. In this section, you'll create a multi-architecture service that can route to any available `nginx` pod regardless of architecture, providing load balancing across both architectures.
+You now have nginx running on Intel and Arm nodes with architecture-specific services. In this section, you'll create a multi-architecture service that can route to any available nginx pod regardless of architecture, providing load balancing across both architectures.
 
 ## Create the multiarch service
 
-The multiarch service targets all pods with the `app: nginx-multiarch` label (all `nginx` deployments share this label). It uses `sessionAffinity: None` to ensure requests are distributed across all available pods without stickiness, and can route to Intel or Arm pods based on availability and load balancing algorithms.
+The multiarch service targets all pods with the `app: nginx-multiarch` label (all nginx deployments share this label). It uses `sessionAffinity: None` to ensure requests are distributed across all available pods without stickiness, and can route to Intel or Arm pods based on availability and load balancing algorithms.
 
 Run the following commands to download and apply the multiarch service:
 
@@ -59,7 +59,7 @@ You are ready to test the multiarch service.
 
 ## Test the nginx multiarch service
 
-Run the following to make HTTP requests to the multiarch `nginx` service:
+Run the following to make HTTP requests to the multiarch nginx service:
 
 ```bash
 ./nginx_util.sh curl multiarch

content/learning-paths/servers-and-cloud-computing/multiarch_nginx_on_aks/overview.md

@@ -5,11 +5,11 @@ weight: 2
 layout: learningpathall
 ---
 
-## Project Overview
+## Project overview
 
-Arm processors are transforming cloud infrastructure, offering improved performance per watt and cost efficiency for web server workloads. In this Learning Path, you'll deploy [`nginx`](https://nginx.org/) on both Arm and x86 architectures within a single Kubernetes cluster on Azure AKS.
+Arm processors are transforming cloud infrastructure, offering improved performance per watt and cost efficiency for web server workloads. In this Learning Path, you'll deploy [nginx](https://nginx.org/) on both Arm and x86 architectures within a single Kubernetes cluster on Azure AKS.
 
-You'll create a cluster with both Arm-based and x86 nodes, which lets you deploy the same `nginx` workload on different architectures. This setup allows you to compare how `nginx` performs on each architecture and understand the practical aspects of running mixed workloads in Kubernetes.
+You'll create a cluster with both Arm-based and x86 nodes, which lets you deploy the same nginx workload on different architectures. This setup allows you to compare how nginx performs on each architecture and understand the practical aspects of running mixed workloads in Kubernetes.
 
 ## Why deploy nginx on both Arm and x86 nodes in Kubernetes?
 
@@ -18,7 +18,7 @@ Many developers start their Arm journey by adding Arm-based nodes to existing x8
 This approach offers several advantages:
 
 - Gradual migration: you can leverage your existing Kubernetes expertise to add Arm nodes without disrupting current x86 workloads.
-- Container compatibility: multi-architecture container images allow the same `nginx` deployment to run on both architectures with minimal configuration changes.
+- Container compatibility: multi-architecture container images allow the same nginx deployment to run on both architectures with minimal configuration changes.
 - Performance comparison: running both architectures in the same cluster provides an ideal environment for benchmarking Arm versus x86 performance under identical conditions.
 
-This Learning Path walks you through how to create an initial AKS environment and install `nginx` on x86.  From there, you'll add Arm-based nodes running the same exact workload.  You'll see how to run simple tests to verify functionality, and then run performance testing to better understand the performance characteristics of each architecture.
+This Learning Path walks you through how to create an initial AKS environment and install nginx on x86.  From there, you'll add Arm-based nodes running the same exact workload.  You'll see how to run simple tests to verify functionality, and then run performance testing to better understand the performance characteristics of each architecture.

content/learning-paths/servers-and-cloud-computing/multiarch_nginx_on_aks/spin_up_aks_cluster.md

@@ -6,7 +6,7 @@ weight: 3
 layout: learningpathall
 ---
 
-## Overview
+## Set up a multi-architecture AKS cluster
 
 In this section, you'll create a multi-architecture Azure Kubernetes Service (AKS) cluster that supports both Intel and Arm-based nodes. This setup allows you to deploy and compare workloads across different CPU architectures within the same Kubernetes environment.