updated openjdk pacbti tester LP: updated tester script, moved to GC

content/learning-paths/servers-and-cloud-computing/openjdk-pacbti-azure/_index.md → content/learning-paths/servers-and-cloud-computing/openjdk-pacbti-gcp/_index.md

@@ -1,34 +1,31 @@
 ---
-title: Build OpenJDK with PAC/BTI support on Azure Cobalt 100
+title: Verify OpenJDK PAC/BTI using a Google Cloud C4A VM
 
-description: Learn how to compile OpenJDK with branch protection on an Azure Cobalt 100 Arm VM and verify PAC/BTI support in the resulting JVM.
+description: Learn how to verify PAC/BTI support in OpenJDK on a Google Cloud C4A Arm-based VM and interpret the JVM readiness result.
 
 draft: true
 cascade:
     draft: true
 
-minutes_to_complete: 60
+minutes_to_complete: 30
 
-who_is_this_for: This is an introductory topic for Java developers who want to compile OpenJDK from source with PAC/BTI branch protection enabled and verify the resulting JVM on an Azure Cobalt 100 Arm-based virtual machine.
+who_is_this_for: This Learning Path is for developers who want to validate OpenJDK PAC/BTI support on Google Cloud C4A Arm-based virtual machines.
 
 learning_objectives: 
-    - Provision an Azure Cobalt 100 Arm-based virtual machine with Ubuntu Pro 24.04 LTS.
-    - Build OpenJDK on Arm with branch protection support enabled.
+    - Provision a Google Cloud C4A Arm-based virtual machine with SUSE Linux Enterprise Server.
+    - Install OpenJDK on the Arm-based VM.
     - Verify PAC/BTI readiness in the installed JVM runtime.
 
 prerequisites:
-    - A [Microsoft Azure](https://azure.microsoft.com/) account with access to Cobalt 100 based instances (Dpsv6)
-    - Familiarity with the Linux command line and SSH
-    - Basic familiarity with Java and the JDK toolchain
-
+    - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled
 
 author: Doug Anson
 
 ### Tags
 skilllevels: Introductory
 subjects: Performance and Architecture
 cloud_service_providers:
-  - Microsoft Azure
+  - Google Cloud
 
 armips:
     - Neoverse
@@ -43,8 +40,8 @@ operatingsystems:
 
 further_reading:
   - resource:
-      title: Azure Virtual Machines documentation
-      link: https://learn.microsoft.com/en-us/azure/virtual-machines/
+      title: Google Cloud documentation
+      link: https://cloud.google.com/docs
       type: documentation
   - resource:
       title: OpenJDK build documentation
@@ -55,8 +52,8 @@ further_reading:
       link: https://github.com/openjdk/jdk
       type: documentation
   - resource:
-      title: Learn the architecture - Providing protection for complex software
-      link: https://developer.arm.com/documentation/102433/latest/
+      title: Arm "Arm64" machine instruction reference
+      link: https://developer.arm.com/documentation/100076/latest/
       type: documentation
 
 
@@ -65,4 +62,4 @@ further_reading:
 weight: 1                       # _index.md always has weight of 1 to order correctly
 layout: "learningpathall"       # All files under learning paths have this same wrapper
 learning_path_main_page: "yes"  # This should be surfaced when looking for related content. Only set for _index.md of learning path content.
----
+---

content/learning-paths/servers-and-cloud-computing/openjdk-pacbti-gcp/background.md

@@ -0,0 +1,27 @@
+---
+title: Understand Google Cloud C4A Axion processors, OpenJDK, and Armv9 PAC/BTI
+
+weight: 2
+
+layout: "learningpathall"
+---
+
+## Explore Google Cloud C4A instances
+
+Google Axion C4A is a family of Arm-based VMs built on Google's custom Axion processors, which use Arm Neoverse-V2 cores. These VMs deliver high performance with improved energy efficiency for modern cloud workloads such as CI/CD pipelines, microservices, media processing, and general-purpose applications.
+
+The C4A series provides an Arm-based alternative to x86 VMs, enabling developers to evaluate cost, performance, and efficiency trade-offs in Google Cloud. For Kubernetes users, C4A instances provide a practical way to run Arm-native clusters and validate tooling such as Helm on modern cloud infrastructure.
+
+To learn more about Google Axion, 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).
+
+## OpenJDK and the PAC/BTI Arm v9 instructions
+
+OpenJDK is the open-source reference implementation of Java Platform, Standard Edition (Java SE). It provides the core compiler, runtime, and class libraries you use to build and run Java applications across operating systems and hardware platforms. OpenJDK forms the basis for most modern Java distributions, while different vendors package and support their own builds.
+
+Armv9 Pointer Authentication (PAC) and Branch Target Identification (BTI) are security features designed to make control-flow attacks harder. PAC helps protect return addresses and pointers by adding a cryptographic signature that is checked before the pointer is used, which can detect tampering such as return-oriented programming attempts. BTI complements this by restricting where indirect branches are allowed to land, helping prevent attackers from jumping into unintended instruction sequences. Together, PAC and BTI strengthen software defenses at the instruction-set level, especially for modern operating systems, hypervisors, and applications that need improved resistance to memory-corruption exploits.
+
+## What you've learned and what's next
+
+You now have the background on Google Cloud C4A, OpenJDK, and Armv9 PAC/BTI features.
+
+Next, you'll create an Arm-based Google Cloud VM, install OpenJDK, and validate PAC/BTI readiness in the installed JVM.

content/learning-paths/servers-and-cloud-computing/openjdk-pacbti-gcp/instance.md

@@ -0,0 +1,47 @@
+---
+title: Create a Google Axion C4A virtual machine on Google Cloud
+weight: 3
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+## Overview
+
+In this section, you provision a Google Axion C4A VM on Google Cloud Platform (GCP) using the `c4a-standard-4` machine type, which provides 4 vCPUs and 16 GB of memory.
+
+{{% notice Note %}}
+For general guidance on setting up a Google Cloud account and project, see the Learning Path [Getting started with Google Cloud Platform](/learning-paths/servers-and-cloud-computing/csp/google/).
+{{% /notice %}}
+
+## Provision a Google Axion C4A VM in the Google Cloud Console
+
+To create a VM using the C4A instance type:
+
+- Open the [Google Cloud Console](https://console.cloud.google.com/).
+- Go to **Compute Engine** > **VM instances**, and then select **Create instance**.
+- Under **Machine configuration**:
+  - Specify an **Instance name**, **Region**, and **Zone**.
+  - Set **Series** to **C4A**.
+  - Select **c4a-standard-4** as the machine type.
+
+![Google Cloud Console VM creation page showing the C4A series and c4a-standard-4 machine type selection. Use this screen to confirm you are creating an Arm-based C4A instance.#center](images/gcp-vm.png "Creating a Google Axion C4A VM in the Google Cloud Console")
+
+- Under **OS and storage**, select **Change**, and then choose an Arm64-based operating system image.
+  - For this Learning Path, select **SUSE Linux Enterprise Server**.
+  - For the license type, choose **Pay as you go**.
+  - Select **Select** to apply the changes.
+- Under **Networking**, enable **Allow HTTP traffic** and **Allow HTTPS traffic**.
+- Select **Create** to launch the virtual machine.
+
+After the instance starts, click **SSH** next to the VM in the instance list to open a browser-based terminal session.
+
+![Google Cloud Console VM instances list showing the SSH button for a running C4A instance. Use SSH to open a terminal session on the new VM.#center](images/gcp-ssh.png "Connecting to a running C4A VM using SSH")
+
+A new browser window opens with a terminal connected to your VM.
+
+![Browser-based terminal window showing a command prompt on a SUSE Linux VM running on Google Axion C4A. Use this terminal to install OpenJDK and run the PAC/BTI validation script.#center](images/gcp-shell.png "Terminal session connected to the VM")
+
+## What you've learned and what's next
+
+In this section, you created a Google Cloud C4A virtual machine and opened an SSH session to the VM. Next, you will install OpenJDK and prepare the PAC/BTI validation script. Next, install the OpenJDK JVM on your VM.