Update Django on GCP learning path content

Author: madeline-underwood

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

@@ -1,5 +1,5 @@
 ---
-title: Get started with Django on Google Axion C4A (Arm Neoverse-V2)
+title: Get started with Django on Google Axion C4A (Arm Neoverse V2)
 
 weight: 2
 

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

@@ -53,26 +53,23 @@ cd ~/myproject/myproject/
 
 Open `settings.py` using a text editor:
 
-  ```bash
-  edit myproject/settings.py
-  ```
-  
-- Locate the ALLOWED_HOSTS line
+```bash
+edit myproject/settings.py
+```
 
-Inside the file, find the following line:
+Locate the `ALLOWED_HOSTS` line inside the file:
 
 ```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:
-  ```python
-  ALLOWED_HOSTS = ['*']
-  ```
+
+```python
+ALLOWED_HOSTS = ['*']
+```
 {{% notice Note %}}
 For development and testing only, you can use `ALLOWED_HOSTS = ['*']` to allow all hosts. However, for production deployments, always specify explicit domain names or IP addresses such as `ALLOWED_HOSTS = ['your-external-ip', 'your-domain.com']`.
 {{% /notice %}}

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

@@ -30,7 +30,7 @@ ab -V
 
 The output displays the ApacheBench version.
 
-### Install and configure Gunicorn
+## 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.
 
@@ -39,10 +39,12 @@ Before benchmarking your Django application, you need to install Gunicorn, a pro
 ```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):
+This installs Django and Gunicorn. Gunicorn is 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
+
+Your Django application runs with Gunicorn inside GKE:
 
 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**.
@@ -51,7 +53,7 @@ The benchmark is executed against the **external IP of the GKE service**.
 Ensure your VM's firewall allows inbound traffic on port 8000. See the firewall setup section if you haven't already configured this.
 {{% /notice %}}
 
-### Run the benchmark
+## Run the benchmark
 
 Use ApacheBench to test your Django server with simulated traffic:
 

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

@@ -13,7 +13,7 @@ This guide converts your Django REST API into a production-grade Arm64 container
 ### 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:
+Create a file called `requirements.txt` and insert the following:
 
 ```text
 django
@@ -33,9 +33,9 @@ RUN pip install --no-cache-dir -r requirements.txt
 CMD ["gunicorn","django_api.wsgi:application","--bind","0.0.0.0:8000","--workers","3"]
 ```
 
-You now have a container blueprint that can run Django in production using Gunicorn on Arm64.
+This Dockerfile defines how to build your Django container for production deployment.
 
-### Build and push
+### Build and push the image
 
 Build the image on an Arm machine and push it to Artifact Registry, ensuring Kubernetes pulls an Arm-native image.
 
@@ -53,7 +53,7 @@ Push the built image:
 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.
+The image is now stored in Artifact Registry and ready for deployment.
 
 ### Deploy to GKE
 
@@ -112,9 +112,10 @@ NAME                          READY   STATUS    RESTARTS   AGE     IP         NO
 django-api-XXXXXX   1/1     Running   0          3h52m   10.0.2.9   gke-django-axion-cluster-axion-pool-xxxxxxx   <none>           <none>
 django-api-XXXXXX   1/1     Running   0          3h52m   10.0.1.9   gke-django-axion-cluster-axion-pool-xxxxxxx   <none>           <none>
 ```
-Your Django API is now running as replicated containers on Axion Arm64 nodes.
 
-### Create Kubernetes service (LoadBalancer)
+The Django API is running as replicated containers on Axion Arm64 nodes.
+
+### Create a Kubernetes service (LoadBalancer)
 A Service exposes your pods to the internet using **Google Cloud’s managed load balancer**.
 
 Create `k8s/service.yaml`:
@@ -132,7 +133,8 @@ spec:
   - port: 80
     targetPort: 8000
 ```
-Your Django service is now publicly reachable.
+
+Apply the service configuration:
 
 ```bash
 kubectl apply -f k8s/service.yaml
@@ -149,7 +151,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
 ```
 
-Wait until the EXTERNAL-IP field is populated. This is needed in the next step.
+Wait until the `EXTERNAL-IP` field is populated before proceeding.
 
 ### Validate public access
 
@@ -161,11 +163,11 @@ http://<EXTERNAL-IP>/healthz/
 
 You should see output similar to the following:
 
-![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")
+![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 alt-txt#center](images/django_framework.png "Django health check validation")
 
-Your Arm-based Django API is live on the internet.
+The Arm-based Django API is now accessible over the internet.
 
-### What you’ve accomplished
+## What you've accomplished and what's next
 You have deployed a fully cloud-native, Arm-optimized application:
 
 - Django REST API

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

@@ -34,7 +34,8 @@ Finally, run:
 django-admin startproject django_api .
 django-admin startapp api
 ```
-You now have a Django project skeleton with all required libraries installed for database, cache, and API support.
+
+The Django project structure is ready with all required libraries for database, cache, and API support.
 
 ### Enable Django apps
 
@@ -57,9 +58,9 @@ INSTALLED_APPS = [
 ]
 ```
 
-Your Django project is now configured to run as an API server instead of a development-only web app.
+Django is configured to run as an API server.
 
-Configure PostgreSQL and Redis
+### Configure PostgreSQL and Redis
 
 This step connects Django to external managed services instead of local SQLite. This mirrors how real production systems operate.
 
@@ -91,21 +92,21 @@ CACHES = {
 }
 ```
 
-Edit the above edition and set REDIS_IP to the actual IP address that you saved earlier. 
+Edit the above addition and set `REDIS_IP` to the actual IP address that you saved earlier.
 
-Your application is now wired to a real database and cache, making it production-grade.
+The application is configured to use PostgreSQL and Redis.
 
-### Migrate database
+### Migrate the database
 Django creates tables, metadata, and user models inside PostgreSQL.
 
 ```bash
 python manage.py migrate
 python manage.py createsuperuser
 ```
 
-PostgreSQL instance now contains all Django system tables and is ready to store application data.
+The PostgreSQL instance contains all Django system tables.
 
-### Create health API
+### Create a health API endpoint
 
 A health endpoint allows Kubernetes and load balancers to verify if the service is running.
 
@@ -131,8 +132,7 @@ urlpatterns = [
 ]
 ```
 
-
-You now have a Kubernetes-compatible health endpoint.
+The health endpoint is configured.
 
 ### Validate locally
 Before containerizing or deploying, validate that everything works end-to-end.
@@ -152,15 +152,17 @@ The expected output is:
 ```output
 {"status":"ok"}
 ```
-Your Django API is fully functional with PostgreSQL and Redis connected.
 
-### What you've accomplished
-You now have a cloud-ready Django REST API that:
+The Django API is functional with PostgreSQL and Redis connected.
+
+## What you've accomplished and what's next
+
+In this section, you built a cloud-ready Django REST API that:
 
-- Uses PostgreSQL for durable data
+- Uses PostgreSQL for persistent data storage
 - Uses Redis for caching
-- Exposes a health endpoint for Kubernetes
-- Is ready to be containerized and deployed on GKE Axion (Arm)
+- Exposes a health endpoint for Kubernetes probes
+- Is ready for containerization and deployment on GKE Axion
 
-This is the exact backend you will deploy in the next stage of the learning path.
+Next, you'll containerize this application and deploy it to your Axion-powered GKE cluster.
 

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

@@ -38,18 +38,20 @@ To create a virtual machine based on the C4A instance type:
 ## Create the instance
 
 Click **Create** to launch your VM instance. Google Cloud provisions the instance, which typically takes one to two minutes.
-Once the instance is running, you'll see it listed in the VM instances table with a green checkmark. Note the External IP address displayed in the list—you'll need this to access your Django application later.
+Once the instance is running, you'll see it listed in the VM instances table with a green checkmark. Note the External IP address displayed in the list; you'll need this to access your Django application later.
 
 ## Connect using SSH
 
 Click the **SSH** button next to your running instance to open a browser-based terminal session.
 
-![Screenshot of the VM instances list showing the SSH button next to a running instance. The external IP address is visible in the same row#center](images/gcp-pubip-ssh.png "Launching an SSH session from the VM instances list")
+![Screenshot of the VM instances list showing the SSH button next to a running instance. The external IP address is visible in the same row alt-txt#center](images/gcp-pubip-ssh.png "Launching an SSH session from the VM instances list")
 
 A browser window opens with a terminal shell connected to your VM. You're now ready to install Django.
 
-![Screenshot of a terminal shell in the browser, connected to the running VM instance. The shell displays a command prompt ready for input#center](images/gcp-shell.png "Terminal shell connected to your VM")
+![Screenshot of a terminal shell in the browser, connected to the running VM instance. The shell displays a command prompt ready for input alt-txt#center](images/gcp-shell.png "Terminal shell connected to your VM")
 
-## Summary and what's next
+## What you've accomplished and what's next
 
-You have successfully provisioned an Arm-based VM on Google Cloud. Next, you'll install Django and configure your web application.
+In this section, you provisioned a Google Axion C4A Arm VM and connected to it using SSH.
+
+Next, you'll install Django and the required dependencies on your VM.

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

@@ -1,20 +1,20 @@
 ---
-title: Deploy Django on GKE Axion (Arm) with Managed Data Services
+title: Deploy Django on GKE Axion (Arm) with managed data services
 weight: 7
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## Overview
-This guide deploys a **container-native Django REST API** on **Google Kubernetes Engine (GKE)** running on **Axion (ARM64)** nodes.
+## Deploy Django REST API on GKE Axion with Cloud SQL and Redis
+This guide deploys a container-native Django REST API on Google Kubernetes Engine (GKE) running on Axion (ARM64) nodes.
 
 The application integrates with:
 
-- **Cloud SQL (PostgreSQL – private IP)**
-- **Memorystore (Redis)**
-- **Artifact Registry**
-- **Kubernetes LoadBalancer**
+- Cloud SQL (PostgreSQL – private IP)
+- Memorystore (Redis)
+- Artifact Registry
+- Kubernetes LoadBalancer
 
 Performance is validated using **throughput** and **p95 latency**, allowing you to evaluate how an Arm-based Kubernetes platform behaves under real application load.
 
@@ -33,9 +33,14 @@ GKE (Axion Arm64)
 |
 |---> Memorystore (Redis)
 ```
+
 This architecture represents a production-grade microservice deployment where compute runs on Arm, while data services are provided through fully managed GCP offerings over private networking.
 
-## Enable the SUSE Containers module
+## Set up the infrastructure
+
+The following sections guide you through provisioning all required GCP services.
+
+### Enable the SUSE Containers module
 
 Enable the SUSE Containers Module to ensure that Docker and container-related tools are fully supported.
 ```bash
@@ -139,9 +144,10 @@ gcloud artifacts repositories create django-arm \
 sudo chmod 777 /etc/containers
 gcloud auth configure-docker us-central1-docker.pkg.dev
 ```
-You now have a secure, private Docker registry ready to store Arm-based application images for GKE.
 
-### Create GKE control plane
+Artifact Registry is configured to store your container images.
+
+### Create the GKE control plane
 
 Create the Kubernetes control plane that manages scheduling, networking, and workloads. Initially create it with a small node pool so the cluster can bootstrap.
 
@@ -151,9 +157,9 @@ gcloud container clusters create django-axion-cluster \
   --machine-type c4a-standard-4 \
   --num-nodes 1 \
   --enable-ip-alias
-  ```
+```
 
-You now have a running GKE cluster ready to accept custom node pools and workloads.
+The GKE cluster is running.
 
 ### Configure kubectl access to GKE
 
@@ -216,9 +222,10 @@ gcloud container node-pools delete default-pool \
   --cluster django-axion-cluster \
   --zone us-central1-a
 ```
-Your Kubernetes cluster now runs **exclusively on Axion Arm64 nodes**, ensuring native Arm execution.
 
-### Create Cloud SQL (PostgreSQL – private IP)
+The Kubernetes cluster runs exclusively on Axion Arm64 nodes.
+
+### Create Cloud SQL (PostgreSQL with private IP)
 
 Cloud SQL provides a fully managed PostgreSQL database. Private IP ensures traffic stays inside Google's private network, improving security and performance.
 
@@ -262,9 +269,7 @@ gcloud sql instances describe django-postgres \
   --format="value(ipAddresses[0].ipAddress)"
 ```
 
-Save this value as **CLOUDSQL_IP**.
-
-You now have a private, production-grade PostgreSQL database that can be securely accessed from GKE.
+Save this IP address as **CLOUDSQL_IP** for later use.
 
 ### Create Memorystore (Redis)
 Redis is used for caching, sessions, and background job coordination. Memorystore provides a fully managed Redis service that scales and stays highly available.
@@ -279,17 +284,17 @@ gcloud redis instances describe django-redis \
   --region=us-central1 \
   --format="value(host)"
 ```
-Save this value as **REDIS_IP**.
 
-You now have a **managed Redis cache** available to your Django application over private networking.
+Save this IP address as **REDIS_IP** for later use.
 
-### What you've accomplished
-You have created:
+## What you've accomplished and what's next
 
-- An Axion-based GKE cluster
-- Private PostgreSQL
-- Redis Memorystore
-- Artifact Registry
+In this section, you created the complete infrastructure for your Django deployment:
+
+- Axion-based GKE cluster with Arm64 node pools
+- Private Cloud SQL PostgreSQL instance
+- Memorystore Redis instance
+- Artifact Registry for container images
 
-In the next stage, you will package Django into an **Arm-native container**, push it to Artifact Registry, and deploy it onto this platform.
+Next, you'll build a Django REST API that connects to these services, then containerize and deploy it to your Axion GKE cluster.