Upda

Upda#	modified:   content/learning-paths/servers-and-cloud-computing/django-on-gcp/_index.md

Author: madeline-underwood

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

@@ -1,13 +1,12 @@
 ---
 title: Deploy Django on Google Cloud C4A (Arm-based Axion VMs)
 
-minutes_to_complete: 30
+minutes_to_complete: 60
 
-who_is_this_for: This is an introductory topic for DevOps engineers and software developers who want to deploy, operate, and benchmark a production-grade Django REST API on Google Kubernetes Engine (GKE) running on Arm64 Axion processors, integrated with managed Google Cloud data services.
+who_is_this_for: This is an introductory topic for DevOps engineers and software developers who want to deploy, operate, and benchmark a production-grade Django REST API on Google Kubernetes Engine (GKE) running on Arm64 Axion processors, integrated with managed Google Cloud data services
 
 learning_objectives:
-  - Provision an Arm-based SUSE Linux Enterprise Server (SLES) virtual machine on Google Cloud (C4A with Axion processors)
-  - Provision Google Axion (Arm64) compute using GKE node pools
+  - Provision Arm-based Axion compute on Google Cloud using virtual machines and GKE node pools
   - Package a Django REST API into an Arm-native Docker container
   - Push container images to Google Artifact Registry
   - Deploy Django on GKE using Kubernetes manifests (Deployment, Service, ConfigMap, Secrets)
@@ -20,6 +19,7 @@ learning_objectives:
 prerequisites:
   - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled  
   - Basic familiarity with [Django](https://www.djangoproject.com/)
+  - Basic understanding of containers and Kubernetes concepts
 
 author: Pareena Verma
 
@@ -72,5 +72,5 @@ further_reading:
 
 weight: 1
 layout: "learningpathall"
-learning_path_main_page: "yes"
+learning_path_main_page: yes
 ---

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

@@ -12,10 +12,10 @@ Google Axion C4A is a family of Arm-based virtual machines built on Google’s c
 
 The C4A series provides a cost-effective alternative to x86 virtual machines while leveraging the scalability and performance benefits of the Arm architecture in Google Cloud.
 
-To learn more about Google Axion, see the [Introducing Google Axion Processors, our new Arm-based CPUs](https://cloud.google.com/blog/products/compute/introducing-googles-new-arm-based-cpu) blog.
+To learn more, see the Google blog [Introducing Google Axion Processors, our new Arm-based CPUs](https://cloud.google.com/blog/products/compute/introducing-googles-new-arm-based-cpu).
 
 
-## Understand Django on Google Axion C4A (Arm Neoverse-V2)
+## Explore Django on Google Axion C4A (Arm Neoverse V2)
 
 Django is a high-level, open-source Python web framework that encourages rapid development and clean, pragmatic design. Developed and maintained by the [Django Software Foundation](https://www.djangoproject.com/foundation/), it simplifies web application development by handling much of the boilerplate and providing powerful built-in features.
 
@@ -27,10 +27,13 @@ Common use cases include web applications, content management systems, APIs, e-c
 
 To learn more, visit the [Django website](https://www.djangoproject.com/) and explore the [Django documentation](https://docs.djangoproject.com/en/stable/).
 
-## Summary and what's next
+## What you've accomplished and what's next
 
-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 this section, you learned about:
+- Google Axion C4A Arm-based VMs and their performance characteristics
+- Django web framework and its suitability for building REST APIs
+- How Arm architecture provides cost-effective, high-performance infrastructure for Python applications
 
-In the next sections, you'll provision your own Arm-based VM on Google Cloud, install Django, and benchmark your application's performance.
+Next, you'll configure firewall rules to allow external access to your Django application.
 
 

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

@@ -98,7 +98,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#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 alt-txt#center](images/django-welcome-page.png "Django welcome page")
 
 ## Build a simple Django app with custom routing
 
@@ -220,10 +220,15 @@ Open your browser and navigate to:
 http://<YOUR_VM_EXTERNAL_IP>:8000
 ```
 
-You should now see your custom message displayed:
+Your browser displays your custom message:
 
-![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")
+![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 alt-txt#center](images/django-app.png "Django custom app")
 
-## Summary and what's next
+## What you've accomplished 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.
+In this section, you:
+- Created a Django project and ran the development server
+- Built a custom Django app with routing and views
+- Verified that Django serves web requests successfully on your Arm VM
+
+Next, you'll set up the complete GKE infrastructure with Cloud SQL and Memorystore for production deployment.

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

@@ -44,14 +44,9 @@ This installs Django and Gunicorn. Gunicorn is a high-performance WSGI HTTP serv
 
 ## Run Django with Gunicorn
 
-Your Django application runs with Gunicorn inside GKE:
+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.
 
-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 %}}
-Ensure your VM's firewall allows inbound traffic on port 8000. See the firewall setup section if you haven't already configured this.
-{{% /notice %}}
+{{% notice note %}}Ensure your GKE cluster and LoadBalancer are properly configured. If you haven't set up the cluster yet, refer to the previous sections for GKE deployment and service configuration. {{% /notice %}}
 
 ## Run the benchmark
 
@@ -104,23 +99,28 @@ Percentage of the requests served within a certain time (ms)
 ```
 ## Interpret your benchmark results
 
-The ApacheBench output provides key performance metrics that help you evaluate your Django application's capabilities on Google Axion (Arm64) GKE. Here's what each metric tells you:
+The ApacheBench output provides key performance metrics for evaluating your Django application on Google Axion (Arm64) GKE:
+
 ### Request handling metrics
+
 - Concurrency Level: number of simultaneous requests the benchmark sent (100 in this test)
 - Complete Requests: total successful requests processed (5000 in this test)
 - Failed Requests: number of errors or timeouts (0, indicating stable production-grade performance)
 
 ### Performance metrics
-- Requests per Second: how many requests your server handles per second — higher values indicate better throughput (14,001.88 req/sec)
+
+- Requests per Second: how many requests your server handles per second; higher values indicate better throughput (14,001.88 req/sec)
 - Time per Request (mean): average time to complete a single request (7.142 ms)
 - Time per Request (across concurrent): average latency when factoring in concurrent processing (0.071 ms), showing excellent parallel execution on Axion Arm cores
 
 ### Data transfer metrics
+
 - Total Transferred: all data sent and received, including HTTP headers (1,650,000 bytes)
 - HTML Transferred: actual response payload size (75,000 bytes)
 - Transfer Rate: network throughput in KB/sec (4512.32 KB/sec), indicating efficient networking through GKE LoadBalancer
 
 ### Timing breakdown
+
 - Time Taken for Tests: total benchmark duration (0.357 seconds)
 - Connection Times: shows minimum, mean, median, and maximum times for connecting, processing, and waiting
 
@@ -145,7 +145,7 @@ Results from the run on the `Axion (C4A) Arm64 GKE nodes`:
 | **Failed Requests** | Number of failed requests | 0 |
 | **Total Transferred** | Total bytes transferred (including headers) | 1,650,000 bytes |
 | **HTML Transferred** | Total response body bytes | 75,000 bytes |
-| **Requests per Second (mean)** | Throughput — higher is better | **14,001.88 req/sec** |
+| **Requests per Second (mean)** | Throughput - higher is better | **14,001.88 req/sec** |
 | **Time per Request (mean)** | Average time for each request | **7.142 ms** |
 | **Time per Request (across all concurrent requests)** | Average latency considering concurrency | **0.071 ms** |
 | **Transfer Rate** | Network throughput rate | **4512.32 KB/sec** |
@@ -163,4 +163,4 @@ The benchmark results demonstrate the strength of running Django on Google Axion
 - 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.
+- 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

@@ -1,5 +1,5 @@
 ---
-title: Containerize and Deploy Django on Axion GKE
+title: Containerize and deploy Django on Axion GKE
 weight: 9
 
 ### FIXED, DO NOT MODIFY
@@ -8,10 +8,10 @@ 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 through a cloud Load Balancer.
+This guide converts your Django REST API into a production-grade Arm64 container and deploys it on Axion-powered GKE.
 
 ### 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.
+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:
 
@@ -106,7 +106,7 @@ Verify pods are running on Axion Arm nodes:
 kubectl get pods -o wide
 ```
 
-Pods must show nodes like:
+The output is similar to:
 ```output
 NAME                          READY   STATUS    RESTARTS   AGE     IP         NODE                                                NOMINATED NODE   READINESS GATES
 django-api-XXXXXX   1/1     Running   0          3h52m   10.0.2.9   gke-django-axion-cluster-axion-pool-xxxxxxx   <none>           <none>
@@ -161,20 +161,19 @@ Open the following URL in browser:
 http://<EXTERNAL-IP>/healthz/
 ```
 
-You should see output similar to the following:
+The output is similar to:
 
 ![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")
 
 The Arm-based Django API is now accessible over the internet.
 
 ## What you've accomplished and what's next
-You have deployed a fully cloud-native, Arm-optimized application:
 
-- Django REST API
-- Running on Axion Arm64
-- Exposed through Google Cloud LoadBalancer
-- Backed by Cloud SQL PostgreSQL
-- Accelerated by Memorystore Redis
-- Delivered through Artifact Registry
+In this section, you:
+- Containerized your Django REST API for Arm64
+- Pushed the image to Artifact Registry
+- Deployed the application to GKE running on Axion nodes
+- Exposed the service through a Kubernetes LoadBalancer
+- Validated public access to your Django API
 
-This is a real production architecture running on Arm in GCP.
+Next, you'll benchmark your Django application to measure performance on Arm infrastructure.

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

@@ -8,7 +8,7 @@ layout: learningpathall
 
 ## Django REST API with PostgreSQL and Redis
 
-This guide walks you through building a production-ready Django REST API that connects to PostgreSQL for data and Redis for caching. You will create a backend that is cloud-deployable and compatible with containerized Kubernetes environments.
+This guide walks you through building a production-ready Django REST API that connects to PostgreSQL for data and Redis for caching.
 
 ### Create Django project
 
@@ -21,14 +21,14 @@ source venv/bin/activate
 sudo zypper install postgresql-devel libpq5 postgresql15-server-devel gcc make python3-devel
 ```
 
-Also, please run:
+Install the required Python packages:
 
 ```bash
 which pg_config
-pip install psycopg2-binary django djangorestframework psycopg2-binary django-redis gunicorn
+pip install psycopg2-binary django djangorestframework django-redis gunicorn
 ```
 
-Finally, run:
+Create the Django project structure:
 
 ```bash
 django-admin startproject django_api .
@@ -39,7 +39,7 @@ The Django project structure is ready with all required libraries for database,
 
 ### Enable Django apps
 
-Django must be told which components are active. Enable the REST framework and the API app so that Django can expose HTTP endpoints. Edit `django_api/settings.py` and add 'rest_framework' and 'api' to INSTALLED_APPS. Set DEBUG to False. Finally add '*' to ALLOWED_HOSTS. 
+Enable the REST framework and API app by editing `django_api/settings.py`. Add 'rest_framework' and 'api' to INSTALLED_APPS, set DEBUG to False, and add '*' to ALLOWED_HOSTS: 
 
 ```python
 DEBUG = False
@@ -79,7 +79,7 @@ DATABASES = {
 }
 ```
 
-Edit the above addition and set "CLOUDSQL_IP" to the actual IP address that you saved from earlier. 
+Replace `CLOUDSQL_IP` with the actual Cloud SQL IP address you saved earlier. 
 
 Additionally, add the CACHES configuration per below to the same file and save:
 

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

@@ -50,6 +50,8 @@ Configure the protocol and port settings:
 
 ![Screenshot of the Protocols and ports section. The TCP checkbox is checked and port 8000 is entered in the Ports field#center](images/network-port.png "Specifying TCP port 8000")
 
-## Summary and what's next
+## What you've accomplished and what's next
 
-Your firewall rule is now created and active. Your Django application running on port 8000 is now accessible from external IP addresses.
+In this section, you configured firewall rules to allow external HTTP traffic on port 8000, making your Django application accessible from the internet.
+
+Next, you'll provision a Google Axion C4A Arm VM to host your Django application.

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

@@ -105,7 +105,7 @@ source venv/bin/activate
 
 The `python3.11 -m venv venv` command creates an isolated Python environment named `venv` inside your project folder. Running `source venv/bin/activate` activates this environment.
 
-Once activated, your command prompt displays `(venv)` at the beginning, indicating you're working inside an isolated Python environment where all packages are isolated from your system Python installation.
+Once activated, your command prompt displays `(venv)` at the beginning, indicating that you're working inside an isolated Python environment.
 
 ## Upgrade pip and install Django
 
@@ -122,8 +122,8 @@ python3 -m pip install django gunicorn
 ```
 
 This installs:
-- **Django** — the web framework for building your application
-- **Gunicorn** — a production-ready WSGI (Web Server Gateway Interface) server for running Django applications
+- **Django** - the web framework for building your application
+- **Gunicorn** - a production-ready WSGI (Web Server Gateway Interface) server for running Django applications
 
 Verify that Django is installed correctly:
 
@@ -137,6 +137,11 @@ The output is similar to:
 5.2.10
 ```
 
-## Summary and what's next
+## What you've accomplished and what's next
 
-You have successfully installed the Google Cloud CLI, Python 3.11, Django, and Gunicorn on your Arm-based VM. Your environment is now fully prepared to build, containerize, and deploy a Django REST API on GKE with Cloud SQL and Memorystore.
+In this section, you installed:
+- Google Cloud CLI for GCP service management
+- Python 3.11 with a virtual environment
+- Django and Gunicorn for web application development
+
+Next, you'll verify Django is working by creating a basic project and running the development server.