final updates for the tech review

Author: DougAnsonAustinTX

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

@@ -57,12 +57,9 @@ Use ApacheBench to test your Django server with simulated traffic:
 ```console
 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.
+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:
 
 ```output
-This is ApacheBench, Version 2.3
-Benchmarking 34.132.110.81 (be patient)
-
 Server Software:        gunicorn
 Server Hostname:        34.132.110.81
 Server Port:            80
@@ -99,16 +96,6 @@ Percentage of the requests served within a certain time (ms)
   99%     28
  100%     34 (longest request)
 ```
-
-## Stop the Gunicorn server
-
-After reviewing the benchmark results, stop the Gunicorn server running in the background:
-
-```bash
-fg
-```
-This brings the background Gunicorn process to the foreground. Then press `Ctrl+C` to stop it.
-
 ## 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:

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

@@ -13,7 +13,7 @@ You will validate that the workload runs **natively on Arm** and is **publicly a
 ### 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.
 
-`requirements.txt`
+Create a file called: `requirements.txt` and insert the following:
 
 ```text
 django
@@ -23,7 +23,7 @@ django-redis
 gunicorn
 ```
 
-`Dockerfile`
+Create a file called `Dockerfile` and insert the following:
 
 ```dockerfile
 FROM python:3.11-slim
@@ -32,23 +32,40 @@ COPY . .
 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.
 
 ### Build and Push
-This builds the image on an Arm machine and pushes it to Artifact Registry, ensuring Kubernetes pulls an Arm-native image instead of x86.
+This builds the image on an Arm machine and pushes it to Artifact Registry, ensuring Kubernetes pulls an Arm-native image:
+
+(Please replace PROJECT_ID with your current project)
+
+Build the docker image first:
 
 ```console
 docker build -t us-central1-docker.pkg.dev/PROJECT_ID/django-arm/api:1.0 .
+```
+
+Then, push the built image:
+
+```console
 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.
 
-create `/k8sdeployment.yaml` file
+First, make a directory:
 
-```pyhton
+```console
+mkdir ./k8s
+```
+
+Next, let's create `k8s/deployment.yaml` file with the following contents (replace PROJECT_ID with your current project):
+
+```python
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -130,14 +147,18 @@ NAME         TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
 django-api   LoadBalancer   34.118.226.245   34.45.23.92   80:31700/TCP   3h57m
 ```
 
-Validate public access
+Please wait until the EXTERNAL-IP field gets populated! It will be needed in the next step. 
+
+### Validate public access
 
-Open in browser:
+Open the following URL in browser:
 
 ```bash
 http://<EXTERNAL-IP>/healthz/
 ```
 
+You should see output similar to the following:
+
 ![ Django health check alt-text#center](images/django_framework.png "Django Validation")
 
 Your Arm-based Django API is live on the internet.

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

@@ -69,6 +69,8 @@ DATABASES = {
 }
 ```
 
+Edit the above addition and set "CLOUDSQL_IP" to the actual IP address that you saved from earlier. 
+
 Additionally, add the CACHES configuration per below to the same file and save:
 
 ```python
@@ -80,6 +82,8 @@ CACHES = {
 }
 ```
 
+Edit the above edition 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.
 
 ### Migrate Database
@@ -122,6 +126,11 @@ Before containerizing or deploying, you validate that everything works end-to-en
 
 ```console
 python manage.py runserver 0.0.0.0:8000
+```
+
+In a separate SSH session, type: 
+
+```console
 curl http://127.0.0.1:8000/healthz/
 ```
 **You must see:**

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

@@ -20,7 +20,7 @@ Performance is validated using **throughput** and **p95 latency**, allowing you
 
 ### Target Architecture
 
-```text
+```output
 Client
 |
 | HTTP (LoadBalancer)