initial changes to django TR

Author: DougAnsonAustinTX

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

@@ -148,7 +148,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.

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

@@ -17,7 +17,9 @@ This step sets up a clean Python virtual environment and installs all runtime de
 mkdir ~/django_api && cd ~/django_api
 python3 -m venv venv
 source venv/bin/activate
-pip install django djangorestframework psycopg2-binary django-redis gunicorn
+sudo zypper install postgresql-devel libpq5 postgresql15-server-devel gcc make python3-devel
+which pg_config
+pip install psycopg2-binary django djangorestframework psycopg2-binary django-redis gunicorn
 ```
 
 ```console
@@ -28,7 +30,7 @@ You now have a Django project skeleton with all required libraries installed for
 
 ### Enable Django Apps
 Django must be told which components are active. We enable the REST framework and the API app so that Django can expose HTTP endpoints.
-Edit `django_api/settings.py`
+Edit `django_api/settings.py` and add 'rest_framework' and 'api' to INSTALLED_APPS. Set DEBUG to False. Finally add '*' to ALLOWED_HOSTS. 
 
 ```python
 INSTALLED_APPS = [
@@ -52,6 +54,8 @@ Your Django project is now configured to run as an API server instead of a devel
 
 This step connects Django to external managed services instead of local SQLite. This mirrors how real production systems operate.
 
+Edit `django_api/settings.py` and replace the DATABASES configuration with this:  
+
 ```python
 DATABASES = {
  'default': {
@@ -63,14 +67,19 @@ DATABASES = {
    'PORT': '5432',
  }
 }
+```
+
+Additionally, add the CACHES configuration per below to the same file and save:
 
+```python
 CACHES = {
  "default": {
    "BACKEND": "django_redis.cache.RedisCache",
    "LOCATION": "redis://REDIS_IP:6379/1",
  }
 }
 ```
+
 Your application is now wired to a real database and cache, making it production-grade.
 
 ### Migrate Database

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

@@ -29,15 +29,15 @@ Navigate to the Google Cloud Console and create a new firewall rule:
 
 Fill in the rule details to allow traffic on port 8000:
 
-- Set **Name** to `allow-django-8000`.
+- Set **Name** to `allow-tcp-8000`.
 - Select your network (the default is `default`; your organization may use a different network).
 - Set **Direction of traffic** to **Ingress**.
 - Set **Action on match** to **Allow**.
 - Set **Targets** to **Specified target tags**.
-- Enter `django-server` in the **Target tags** field.
+- Enter `allow-tcp-8000` in the **Target tags** field.
 - Set **Source IPv4 ranges** to `0.0.0.0/0` (allows traffic from any IP address; restrict this in production).
 
-![Screenshot showing the firewall rule configuration form. The Name field shows allow-django-8000, Direction is set to Ingress, and Targets is set to Specified target tags. alt-text#center](images/network-rule.png "Firewall rule configuration")
+![Screenshot showing the firewall rule configuration form. The Name field shows allow-tcp-8000, Direction is set to Ingress, and Targets is set to Specified target tags. alt-text#center](images/network-rule.png "Firewall rule configuration")
 
 ## Specify the port and protocol
 

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

@@ -10,80 +10,86 @@ layout: learningpathall
 
 After connecting to your SUSE Linux Enterprise Server (SLES) VM using SSH, you'll install the Google Cloud CLI, update your system, install Python 3.11, and set up a virtual environment for your Django project.
 
-## Install Google Cloud CLI (gcloud)
-
-The Google Cloud CLI is required to authenticate with GCP and allow your Django application VM to interact with Google Cloud services such as GKE, Cloud SQL, Artifact Registry, Memorystore, and to build, deploy, and operate the Django platform.
+## Prepare the system
 
-### Download gcloud SDK (Arm64)
+Update the system packages and install dependencies:
 
 ```console
-curl -O https://dl.google.com/dl/cloudsdk/channels/rapid/downloads/google-cloud-cli-linux-arm.tar.gz
+sudo zypper refresh
+sudo zypper update -y
+sudo zypper install -y curl git tar gzip
 ```
 
-### Extract and install gcloud
+### Install Python 3.11
 
-```console
-tar -xzf google-cloud-cli-linux-arm.tar.gz
-cd google-cloud-sdk
-./install.sh
+Install Python 3.11:
+
+```bash
+sudo zypper install -y python311
+which python3.11
 ```
 
-Accept the default options during installation.
+Verify that Python and pip are installed correctly:
 
-### Initialize gcloud
+```bash
+python3.11 --version
+pip3.11 --version
+```
+The output should be similar to:
 
-```console
-source ~/.bashrc
-gcloud init
+```output
+Python 3.11.10
+pip 22.3.1 from /usr/lib/python3.11/site-packages/pip (python 3.11)
 ```
 
-During initialization:
+## Install Google Cloud CLI (gcloud)
 
-- Select the correct project (for example: imperial-time-xxxxxx)
-- Choose the default region (for example: us-central1)
+The Google Cloud CLI is required to authenticate with GCP and allow your Django application VM to interact with Google Cloud services such as GKE, Cloud SQL, Artifact Registry, Memorystore, and to build, deploy, and operate the Django platform.
 
-### Verify authentication
+### Install Google Cloud SDK (gcloud)
+
+The Google Cloud SDK is required to create and manage GKE clusters.
+
+Download and extract:
 
 ```console
-gcloud auth list
+wget https://dl.google.com/dl/cloudsdk/channels/rapid/downloads/google-cloud-sdk-460.0.0-linux-arm.tar.gz
+tar -xvf google-cloud-sdk-460.0.0-linux-arm.tar.gz
 ```
 
-You should see an output similar to:
-```output
-Credentialed Accounts
-ACTIVE  ACCOUNT
-*       <PROJECT_NUMBER>-compute@developer.gserviceaccount.com
-```
+Install gcloud:
 
-## Update your system
+```console
+./google-cloud-sdk/install.sh
+```
 
-Begin by refreshing your package list and upgrading installed software to ensure you have the latest versions and security patches:
+After installation completes, exit and reconnect to apply the PATH changes:
 
 ```console
-sudo zypper refresh
-sudo zypper update -y
+exit
 ```
 
-## Install Python 3.11 and development tools
+### Initialize gcloud
 
-Django requires Python 3.10 or later. You'll install Python 3.11 along with pip (Python's package manager) and essential build tools needed for compiling Python packages:
+Authenticate and configure the Google Cloud CLI:
 
 ```console
-sudo zypper install -y python311 python311-pip python311-devel git gcc make
+gcloud init
 ```
 
-Verify that Python and pip are installed correctly:
+During initialization, select **Login with a new account**. You'll be prompted to authenticate using your browser and receive an auth code to copy back. Select the project you want to use and choose default settings when unsure.
 
-```bash
-python3.11 --version
-pip3.11 --version
-```
+### Verify authentication
 
-The output is similar to:
+```console
+gcloud auth list
+```
 
+You should see an output similar to:
 ```output
-Python 3.11.10
-pip 22.3.1 from /usr/lib/python3.11/site-packages/pip (python 3.11)
+Credentialed Accounts
+ACTIVE  ACCOUNT
+*       <PROJECT_NUMBER>-compute@developer.gserviceaccount.com
 ```
 
 ## Create a project directory and virtual environment
@@ -127,7 +133,7 @@ django-admin --version
 The output is similar to:
 
 ```output
-5.2.8
+5.2.10
 ```
 
 ## Summary and what's next

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

@@ -35,59 +35,96 @@ GKE (Axion Arm64)
 ```
 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.
 
-### Install Docker (Container Runtime)
-Docker is required to build, run, and test container images locally before pushing them to Artifact Registry.
+## Enable the SUSE Containers module
 
-**Update system packages and install prerequisites:**
+Enable the SUSE Containers Module to ensure that Docker and container-related tools are fully supported.
+``` console
+sudo SUSEConnect -p sle-module-containers/15.5/arm64
+sudo SUSEConnect --list-extensions | grep Containers
+```
+
+Verify that the output shows the Containers module as **Activated**. 
+
+## Install Docker
+
+Docker is required to run KinD and the Kubernetes control plane components. Install Docker, start the service, and add your user to the docker group:
 
 ```console
-sudo zypper update
-sudo zypper install -y ca-certificates curl gnupg
+sudo zypper refresh
+sudo zypper install -y docker
+sudo systemctl enable --now docker
+sudo usermod -aG docker $USER
+exit
 ```
 
-**Install Docker using the official installation script:**
+Exit the current shell and reconnect to the virtual machine so that the group membership change takes effect. Then verify that Docker is running:
 
 ```console
-curl -fsSL https://get.docker.com | sudo sh
+docker ps
+```
+
+Output similar to the following indicates that Docker is installed and accessible:
+
+```output
+CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
 ```
 
-**Allow the current user to run Docker without sudo:**
+## Install kubectl (Kubernetes CLI)
+
+Install the kubectl command-line tool for interacting with Kubernetes clusters:
 
 ```console
-sudo usermod -aG docker $USER
-newgrp docker
+curl -LO https://dl.k8s.io/release/v1.30.1/bin/linux/arm64/kubectl
+chmod +x kubectl
+sudo mv kubectl /usr/local/bin/
 ```
 
-**Verify Docker installation:**
+## Verify kubectl
+
+Confirm that kubectl is installed and accessible from the command line:
 
 ```console
-docker run hello-world
+kubectl version --client
 ```
 
-A successful message confirms that Docker is installed and working correctly.
+Output similar to the following indicates that kubectl is installed correctly:
+```output
+Client Version: v1.30.1
+Kustomize Version: v5.0.4-0.20230601165947-6ce0bf390ce3
+```
 
-### Install kubectl (Kubernetes CLI)
-kubectl is the command-line tool used to interact with Kubernetes clusters, deploy workloads, and manage resources.
+### Get the list of Google project IDs
 
-Download the latest stable Arm64 binary:
+Retrieve the list of project IDs:
 
 ```console
-curl -LO https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/arm64/kubectl
+gcloud projects list
+```
+
+The output is similar to:
+
+```output
+PROJECT_ID              NAME             PROJECT_NUMBER
+arm-lp-test             arm-lp-test      834184475014
 ```
 
-**Make the binary executable and move it to PATH:**
+Note the **PROJECT_ID** for use in the next step.
+
+### Set the active project
+
+Ensure the correct GCP project is selected:
 
 ```console
-chmod +x kubectl
-sudo mv kubectl /usr/local/bin/
+gcloud config set project <YOUR_PROJECT_ID>
 ```
 
-**Verify kubectl installation:**
+Replace `<YOUR_PROJECT_ID>` with your actual project ID from the previous step.
+
+### Install the auth plugin for gcloud
 
 ```console
-kubectl version --client
+gcloud components install gke-gcloud-auth-plugin
 ```
-This confirms that the Kubernetes client is correctly installed on the VM.
 
 ### Create Artifact Registry
 Artifact Registry is used to store and distribute the Docker images for your Django application. This ensures that all Kubernetes nodes pull trusted, versioned images from a private Google-managed repository.
@@ -99,6 +136,7 @@ gcloud artifacts repositories create django-arm \
 ```
 
 ```console
+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.
@@ -110,12 +148,54 @@ We initially create it with a small x86 pool so the cluster can bootstrap.
 ```console
 gcloud container clusters create django-axion-cluster \
   --zone us-central1-a \
+  --machine-type c4a-standard-4 \
   --num-nodes 1 \
-  --machine-type e2-medium \
   --enable-ip-alias
   ```
+
 You now have a running GKE cluster ready to accept custom node pools and workloads.
 
+### Configure kubectl access to GKE
+
+Fetch cluster credentials:
+
+```console
+gcloud container clusters get-credentials django-axion-cluster \
+  --zone us-central1-a
+```
+
+### Verify cluster access
+
+Confirm Kubernetes access:
+
+```console
+kubectl get nodes
+```
+
+You should see an output similar to:
+```output
+NAME                                                  STATUS   ROLES    AGE   VERSION
+gke-django-axion-cluster-default-pool-156e91c3-wdsb   Ready    <none>   34m   v1.33.5-gke.2072000
+```
+
+All nodes should be in **Ready** state and the Kubernetes control plane should be accessible.
+
+### Taint the cluster nodes for arm64 support
+
+Taint the nodes to ensure proper scheduling on arm64 VMs. For each node starting with **gke**, run the following taint command. 
+
+{{% notice Note %}}
+Note the required "-" at the end... its needed!
+{{% /notice %}}
+
+For example using the node IDs in the output above: 
+
+```console
+kubectl taint nodes gke-django-axion-cluster-default-pool-156e91c3-wdsb kubernetes.io/arch=arm64:NoSchedule-
+```
+
+Replace the node names with your actual node names from the previous command output.
+
 ### Add Axion (Arm64) Node Pool
 Axion (Arm64) nodes provide high performance per watt and cost-efficient compute.
 This pool will run all Django application workloads.