Merge pull request #2838 from madeline-underwood/review_django

Review django

Author: jasonrandrews

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

@@ -1,19 +1,25 @@
 ---
-title: Deploy Django on Google Cloud C4A (Arm-based Axion VMs)
+title: Deploy Django on Arm-based Google Cloud C4A 
 
-minutes_to_complete: 30
+minutes_to_complete: 60
 
-who_is_this_for: This Learning Path is for software developers deploying and optimizing Django-based web applications on Arm64 Linux environments, specifically using Google Cloud C4A virtual machines powered by Axion processors.
+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)
-  - Install Django on a SUSE Arm64 (C4A) instance
-  - Verify Django functionality by running the development server and accessing the default welcome page on the Arm64 VM  
-  - Measure Django application performance by benchmarking request handling throughput and latency using the official ApacheBench (ab) tool with Gunicorn on Arm64 (aarch64)
+  - 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)
+  - Integrate Django with Cloud SQL (PostgreSQL) over private IP
+  - Integrate Django with Memorystore (Redis) for caching and sessions
+  - Expose Django using a Kubernetes LoadBalancer
+  - Validate application connectivity to PostgreSQL and Redis
+  - Measure throughput and p95 latency using ApacheBench against Gunicorn on Arm
 
 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
 
@@ -27,9 +33,11 @@ armips:
 
 tools_software_languages:
   - Django
-  - Python
-  - Gunicorn
-  - Apache Bench
+  - Docker
+  - Kubernetes
+  - Google Artifact Registry
+  - Cloud SQL (PostgreSQL)
+  - Memorystore (Redis)
 
 operatingsystems:
   - Linux
@@ -47,13 +55,22 @@ further_reading:
       title: Django documentation
       link: https://docs.djangoproject.com/
       type: documentation
+  - resource:
+      title: Cloud SQL for PostgreSQL
+      link: https://cloud.google.com/sql/docs/postgres
+      type: documentation
+
+  - resource:
+      title: Memorystore for Redis
+      link: https://cloud.google.com/memorystore/docs/redis
+      type: documentation
 
   - resource:
-      title: Apache-bench documentation
+      title: Apache Bench documentation
       link: https://httpd.apache.org/docs/2.4/programs/ab.html 
       type: documentation
 
 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

@@ -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 
 
 weight: 2
 
@@ -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. You're ready to start building!
+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

@@ -6,24 +6,13 @@ weight: 6
 layout: learningpathall
 ---
 
-## Verify Django is working on your Arm-based VM
+## Verify Django installation
 
-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,30 +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
-  edit myproject/settings.py
-  ```
-  
-- Locate the `ALLOWED_HOSTS` Line
-  Inside the file, find the following line:
+```bash
+edit myproject/settings.py
+```
+
+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 = ['*']
-  ```
+To make your Django app accessible from your VM's external IP address, update it to:
+
+```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 %}}
@@ -92,7 +80,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 +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. 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 alt-txt#center](images/django-welcome-page.png "Django welcome page")
 
 ## Build a simple Django app with custom routing
 
@@ -124,7 +112,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
 ```
 
@@ -148,7 +136,7 @@ Edit `hello/views.py` and replace the entire file with:
 from django.http import HttpResponse
 
 def home(request):
-    return HttpResponse("<h1>Hello, Django on Arm!</h1>")
+    return HttpResponse("<h1>Hello, Django on GCP SUSE ARM64!</h1>")
 ```
 
 This simple view function returns a basic HTML message as an HTTP response.
@@ -220,7 +208,7 @@ INSTALLED_APPS = [
 
 Restart the Django development server:
 
-```console
+```bash
 python3 manage.py runserver 0.0.0.0:8000
 ```
 
@@ -232,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 alt-txt#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. alt-text#center](images/django-app.png "Django custom app")
+## What you've accomplished and what's next
 
-## Summary and what's next
+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
 
-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!
+Next, you'll set up the complete GKE infrastructure with Cloud SQL and Memorystore for production deployment.