Copilot updates for the techreview

Author: DougAnsonAustinTX

content/learning-paths/servers-and-cloud-computing/django-on-gcp/_index.md

@@ -66,7 +66,7 @@ further_reading:
       type: documentation
 
   - resource:
-      title: Apache-bench documentation
+      title: Apache Bench documentation
       link: https://httpd.apache.org/docs/2.4/programs/ab.html 
       type: documentation
 

content/learning-paths/servers-and-cloud-computing/django-on-gcp/background.md

@@ -31,6 +31,6 @@ To learn more, visit the [Django website](https://www.djangoproject.com/) and ex
 
 You now understand the capabilities of Google Axion C4A Arm-based VMs and why Django is an excellent choice for building web applications on Arm infrastructure. The combination provides a cost-effective, high-performance platform for deploying Python web applications at scale.
 
-In the next sections, you'll provision your own Arm-based VM on Google Cloud, install Django, and benchmark your application's performance. You're ready to start building!
+In the next sections, you'll provision your own Arm-based VM on Google Cloud, install Django, and benchmark your application's performance.
 
 

content/learning-paths/servers-and-cloud-computing/django-on-gcp/baseline.md

@@ -8,22 +8,11 @@ layout: learningpathall
 
 ## Verify Django is working on your Arm-based VM
 
-In this section, you'll confirm that Django is installed correctly and can serve web requests on your Google Cloud C4A VM. You'll create a Django project, run the development server, and access it from your browser. This hands-on verification ensures your environment is ready for development and testing.
-
-By the end of this section, you'll have:
-- Created a Django project with proper directory structure
-- Configured Django to accept requests from your VM's external IP
-- Run the development server and accessed it from your browser
-- Built a simple Django app with custom routing and views
-- Verified that Django can handle HTTP requests and render responses
-
-Let's get started!
-
-## Create and test a basic Django project
+In this section, you'll confirm that Django is installed correctly and can serve web requests on your Google Cloud C4A VM. You'll create a Django project, run the development server, and access it from your browser.
 
 Run the following command to create a new Django project named `myproject`:
 
-```console
+```bash
 django-admin startproject myproject
 cd myproject
 ```
@@ -46,7 +35,7 @@ The `manage.py` file is Django's command-line utility for project management. Th
 
 Set up your project's database by running migrations, which create the required tables for Django's built-in apps:
 
-```console
+```bash
 python3 manage.py migrate
 ```
 
@@ -58,27 +47,29 @@ Before starting the Django development server, you must configure your `ALLOWED_
 
 Navigate to your project settings directory:
 
-```console
+```bash
 cd ~/myproject/myproject/
 ```
 
 Open `settings.py` using a text editor:
 
-  ```console
+  ```bash
   edit myproject/settings.py
   ```
 
-- Locate the `ALLOWED_HOSTS` Line
-  Inside the file, find the following line:
+- Locate the ALLOWED_HOSTS line
+
+Inside the file, find the following line:
 
 ```python
 ALLOWED_HOSTS = []
 ```
 
 Update it to allow your VM's external IP address:
 
-- Allow All Hosts (for Testing Only)
-  To make your Django app accessible from your VM’s external IP address, update it to:
+- Allow all hosts (for testing only)
+
+To make your Django app accessible from your VM's external IP address, update it to:
   ```python
   ALLOWED_HOSTS = ['*']
   ```
@@ -92,7 +83,7 @@ ALLOWED_HOSTS = ['your-external-ip', 'your-domain.com']
 
 Now that you've configured `ALLOWED_HOSTS`, start the development server:
 
-```console
+```bash
 python3 manage.py runserver 0.0.0.0:8000
 ```
 
@@ -110,7 +101,7 @@ Replace `<YOUR_VM_EXTERNAL_IP>` with the public IP address of your GCP VM.
 
 You should see the Django welcome page with the message "The install worked successfully!":
 
-![Screenshot of the Django welcome page displayed in a web browser. The page features a large heading stating The install worked successfully followed by a subheading congratulating the user on successfully installing Django. Below are instructions for the next steps, including editing the settings file and reading the Django documentation. The page has a clean white background with blue highlights. alt-text#center](images/django-welcome-page.png "Django welcome page")
+![Screenshot of the Django welcome page displayed in a web browser. The page features a large heading stating The install worked successfully followed by a subheading congratulating the user on successfully installing Django. Below are instructions for the next steps, including editing the settings file and reading the Django documentation. The page has a clean white background with blue highlights#center](images/django-welcome-page.png "Django welcome page")
 
 ## Build a simple Django app with custom routing
 
@@ -124,7 +115,7 @@ Press **Ctrl + C** in your terminal to stop the Django development server.
 
 Within your Django project directory, create a new app named `hello`:
 
-```console
+```bash
 python3 manage.py startapp hello
 ```
 
@@ -220,7 +211,7 @@ INSTALLED_APPS = [
 
 Restart the Django development server:
 
-```console
+```bash
 python3 manage.py runserver 0.0.0.0:8000
 ```
 
@@ -234,8 +225,8 @@ http://<YOUR_VM_EXTERNAL_IP>:8000
 
 You should now see your custom message displayed:
 
-![Screenshot of a web browser displaying a Django app with a large heading that reads Hello, Django on Arm centered on a clean white background. The page contains no additional content or navigation, creating a straightforward and welcoming tone. alt-text#center](images/django-app.png "Django custom app")
+![Screenshot of a web browser displaying a Django app with a large heading that reads Hello, Django on Arm centered on a clean white background. The page contains no additional content or navigation, creating a straightforward and welcoming tone#center](images/django-app.png "Django custom app")
 
 ## Summary and what's next
 
-You've successfully verified that Django is installed and working on your Arm-based VM. Your application can serve web requests, handle routing, and render custom views. Great job, you're ready to benchmark your Django application!
+You've successfully verified that Django is installed and working on your Arm-based VM. Your application can serve web requests, handle routing, and render custom views.

content/learning-paths/servers-and-cloud-computing/django-on-gcp/benchmarking.md

@@ -16,34 +16,35 @@ To begin, if your Django development server is still running, stop it using `Ctr
 
 ApacheBench (`ab`) is a command-line tool that simulates multiple HTTP requests to measure web server performance. Install it using the following:
 
-```console
+```bash
 sudo zypper install -y apache2-utils
 ```
 
 ### Verify installation
-This command confirms ApacheBench is correctly installed and available system-wide:
 
-```console
+Confirm ApacheBench is correctly installed and available:
+
+```bash
 ab -V
 ```
 
-The output displays the ApacheBench version, confirming successful installation.
+The output displays the ApacheBench version.
 
 ### Install and configure Gunicorn
 
 Before benchmarking your Django application, you need to install Gunicorn, a production-grade WSGI HTTP server. Gunicorn provides better performance characteristics than Django's development server and more accurately represents real-world deployment scenarios.
 
 ### Install both Django and Gunicorn using pip:
 
-```console
+```bash
 python3 -m pip install django gunicorn
 ```
 This command installs two essential packages. Django is the Python web framework you're benchmarking, while Gunicorn serves as a high-performance WSGI HTTP server that handles multiple concurrent requests efficiently. Unlike Django's built-in development server, Gunicorn is designed for production workloads and provides the multi-worker architecture needed for accurate performance testing.
 
 ### Run Django with Gunicorn
 Start your Django application using Gunicorn (already running inside GKE):
 
-Gunicorn is deployed inside your Kubernetes Pods and exposed via a Kubernetes Service and LoadBalancer.
+Gunicorn is deployed inside your Kubernetes Pods and exposed through a Kubernetes Service and LoadBalancer.
 The benchmark is executed against the **external IP of the GKE service**.
 
 {{% notice Note %}}
@@ -54,10 +55,13 @@ Ensure your VM's firewall allows inbound traffic on port 8000. See the firewall
 
 Use ApacheBench to test your Django server with simulated traffic:
 
-```console
+```bash
 ab -n 5000 -c 100 http://<external_IP_of_the_GKE_service>/healthz/
 ```
-This sends 5000 requests using 100 concurrent connections to your Django REST endpoint exposed through the GKE LoadBalancer. After a few minutes, press "CTRL-C" to stop the benchmark and display results similar to:
+
+This sends 5000 requests using 100 concurrent connections to your Django REST endpoint exposed through the GKE LoadBalancer. After a few minutes, press CTRL-C to stop the benchmark.
+
+The output is similar to:
 
 ```output
 Server Software:        gunicorn
@@ -154,7 +158,7 @@ Results from the run on the `Axion (C4A) Arm64 GKE nodes`:
 The benchmark results demonstrate the strength of running Django on Google Axion (Arm64) GKE:
 
 - Extreme Throughput: The cluster sustained 14,000+ requests per second through a public LoadBalancer → GKE → Gunicorn → Django → Cloud SQL → Redis stack.
-- Ultra-Low p95 Latency: Even at 100 concurrent users, 95% of all requests completed within 11 ms, proving excellent tail-latency control.
+- Ultra-Low p95 Latency: Even at 100 concurrent users, 95% of all requests completed within 11 ms.
 - Production Stability: Zero failed requests confirms the platform is resilient under heavy parallel load.
 - Efficient Networking: Over 4.4 MB/sec of data transfer through the GKE LoadBalancer shows Arm-based networking is highly optimized.
 - Cloud-native Scalability: These results validate that Axion Arm64 nodes are well-suited for high-performance, horizontally scalable REST APIs in production.

content/learning-paths/servers-and-cloud-computing/django-on-gcp/containerization-and-deploy.md

@@ -6,11 +6,11 @@ weight: 9
 layout: learningpathall
 ---
 
-## Containerize and Deploy Django on Axion GKE
-This guide converts your Django REST API into a **production-grade Arm64 container** and deploys it on **Axion-powered Google Kubernetes Engine (GKE)**.  
-You will validate that the workload runs **natively on Arm** and is **publicly accessible** via a cloud Load Balancer.
+## Containerize and deploy Django on Axion GKE
 
-### Create Docker Image
+This guide converts your Django REST API into a production-grade Arm64 container and deploys it on Axion-powered Google Kubernetes Engine (GKE). You will validate that the workload runs natively on Arm and is publicly accessible through a cloud Load Balancer.
+
+### Create Docker image
 This step packages your Django API and all its dependencies into a **portable container image** that can run on any Axion Arm64 node.
 
 Create a file called: `requirements.txt` and insert the following:
@@ -35,37 +35,39 @@ CMD ["gunicorn","django_api.wsgi:application","--bind","0.0.0.0:8000","--workers
 
 You now have a container blueprint that can run Django in production using Gunicorn on Arm64.
 
-### Build and Push
-This builds the image on an Arm machine and pushes it to Artifact Registry, ensuring Kubernetes pulls an Arm-native image:
+### Build and push
+
+Build the image on an Arm machine and push it to Artifact Registry, ensuring Kubernetes pulls an Arm-native image.
 
-(Please replace PROJECT_ID with your current project)
+Replace PROJECT_ID with your current project.
 
-Build the docker image first:
+Build the docker image:
 
-```console
+```bash
 docker build -t us-central1-docker.pkg.dev/PROJECT_ID/django-arm/api:1.0 .
 ```
 
-Then, push the built image:
+Push the built image:
 
-```console
+```bash
 docker push us-central1-docker.pkg.dev/PROJECT_ID/django-arm/api:1.0
 ```
 
 Your Django API is now stored in Google’s private container registry and ready for GKE.
 
 ### Deploy to GKE
+
 Kubernetes Deployments define how many containers run and where. The nodeSelector forces pods onto Axion ARM64 nodes.
 
 First, make a directory:
 
-```console
+```bash
 mkdir ./k8s
 ```
 
-Next, let's create `k8s/deployment.yaml` file with the following contents (replace PROJECT_ID with your current project):
+Next, create `k8s/deployment.yaml` file with the following contents (replace PROJECT_ID with your current project):
 
-```python
+```yaml
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -92,15 +94,15 @@ spec:
           value: django_api.settings
 ```
 
-**Apply:**
+Apply the deployment:
 
-```console
+```bash
 kubectl apply -f k8s/deployment.yaml
 ```
 
-**Verify pods are running on Axion Arm nodes:**
+Verify pods are running on Axion Arm nodes:
 
-```console
+```bash
 kubectl get pods -o wide
 ```
 
@@ -112,12 +114,12 @@ django-api-XXXXXX   1/1     Running   0          3h52m   10.0.1.9   gke-django-a
 ```
 Your Django API is now running as replicated containers on Axion Arm64 nodes.
 
-### Create Kubernetes Service (LoadBalancer)
+### Create Kubernetes service (LoadBalancer)
 A Service exposes your pods to the internet using **Google Cloud’s managed load balancer**.
 
 Create `k8s/service.yaml`:
 
-```python
+```yaml
 apiVersion: v1
 kind: Service
 metadata:
@@ -132,13 +134,13 @@ spec:
 ```
 Your Django service is now publicly reachable.
 
-```console
+```bash
 kubectl apply -f k8s/service.yaml
 ```
 
-### Validate Public Access
+### Validate public access
 
-```console
+```bash
 kubectl get svc django-api
 ```
 
@@ -147,7 +149,7 @@ NAME         TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
 django-api   LoadBalancer   34.118.226.245   34.45.23.92   80:31700/TCP   3h57m
 ```
 
-Please wait until the EXTERNAL-IP field gets populated! It will be needed in the next step. 
+Wait until the EXTERNAL-IP field is populated. This is needed in the next step.
 
 ### Validate public access
 
@@ -159,7 +161,7 @@ http://<EXTERNAL-IP>/healthz/
 
 You should see output similar to the following:
 
-![ Django health check alt-text#center](images/django_framework.png "Django Validation")
+![Screenshot showing Django health check endpoint returning a JSON response with status ok, indicating successful deployment and validation of the Django application running on GKE#center](images/django_framework.png "Django health check validation")
 
 Your Arm-based Django API is live on the internet.
 
@@ -171,6 +173,6 @@ You have deployed a fully cloud-native, Arm-optimized application:
 - Exposed through Google Cloud LoadBalancer
 - Backed by Cloud SQL PostgreSQL
 - Accelerated by Memorystore Redis
-- Delivered via Artifact Registry
+- Delivered through Artifact Registry
 
 This is a real production architecture running on Arm in GCP.