Merge pull request #2679 from madeline-underwood/rust_gcp2

Rust gcp2_JA to sign off

Author: jasonrandrews

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

@@ -1,13 +1,11 @@
 ---
 title: Deploy Rust on Google Cloud C4A (Arm-based Axion VMs)
 
-draft: true
-cascade:
-    draft: true
+description: Learn to deploy and benchmark Rust applications on Google Cloud C4A virtual machines powered by Arm-based Axion processors.
 
 minutes_to_complete: 30
 
-who_is_this_for: This learning path is intended for software developers deploying and optimizing Rust workloads on Linux/Arm64 environments, specifically using Google Cloud C4A virtual machines powered by Axion processors. 
+who_is_this_for: This is an introductory topic for developers deploying and optimizing Rust workloads on Linux/Arm64 environments, specifically using Google Cloud C4A virtual machines powered by Axion processors. 
 
 learning_objectives:
   - Provision an Arm-based SUSE SLES virtual machine on Google Cloud (C4A with Axion processors)

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

@@ -1,24 +1,23 @@
 ---
-title: Getting started with Rust on Google Axion C4A (Arm Neoverse-V2)
+title: Get started with Rust on Google Axion C4A (Arm Neoverse-V2)
 
 weight: 2
 
 layout: "learningpathall"
 ---
 
-## Google Axion C4A Arm instances in Google Cloud
+## Explore Google Axion C4A Arm instances in Google Cloud
 
 Google Axion C4A is a family of Arm-based virtual machines built on Google’s custom Axion CPU, which is based on Arm Neoverse-V2 cores. Designed for high-performance and energy-efficient computing, these virtual machines offer strong performance for modern cloud workloads such as CI/CD pipelines, microservices, media processing, and general-purpose applications.
 
 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, refer to 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 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).
 
-## Rust
+## Explore Rust
 
 [Rust](https://www.rust-lang.org/) is a modern, high-performance systems programming language designed for safety, speed, and concurrency. It provides memory safety without garbage collection, making it ideal for building reliable and efficient software.
 
-Developed by Mozilla, Rust is widely used in system-level programming, web assembly, embedded systems, and performance-critical applications.  
-Its strong type system and ownership model help prevent common bugs like data races and memory leaks.
+Developed by Mozilla, Rust is widely used in system-level programming, web assembly, embedded systems, and performance-critical applications. Its strong type system and ownership model help prevent common bugs like data races and memory leaks.
 
-To learn more, visit the [official Rust website](https://www.rust-lang.org/).
+To learn more, visit the [Rust website](https://www.rust-lang.org/).

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

@@ -1,16 +1,16 @@
 ---
-title: Test Rust baseline performance on Google Axion C4A Arm virtual machines
+title: Perform baseline testing
 weight: 5
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## Perform baseline testing
+## Overview
 
-You can perform baseline testing of Rust on GCP SUSE aarch64 VMs to verify installation, build functionality, and compilation performance on the Arm-based Axion C4A platform.
+Now that Rust is installed, verify the installation, build functionality, and compilation performance on your Arm-based Axion C4A instance.
 
-### Create a sample Rust program
+## Create a sample Rust program
 
 Create and build a simple "Hello, World" application to verify that Rust is working correctly:
 
@@ -33,9 +33,9 @@ The output is similar to:
 Hello, world!
 ```
 
-This confirms that Rust and Cargo are properly configured on your aarch64 VM.
+This confirms that Rust and Cargo are properly configured on your Arm64 VM.
 
-### Measure compilation performance
+## Measure compilation performance
 
 Use the `time` command to measure compilation performance on the Arm64 processor:
 
@@ -59,3 +59,7 @@ sys     0m0.071s
 ```
 
 The timing results show that Rust compilation performs well on the Arm64 architecture, with the "real" time indicating the total elapsed time for the build process.
+
+## What you've accomplished and what's next
+
+You've successfully verified your Rust installation and measured baseline compilation performance on the C4A instance. In the next section, you'll benchmark Rust code execution using Criterion to measure runtime performance and consistency.

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

@@ -6,11 +6,11 @@ weight: 6
 layout: learningpathall
 ---
 
-## Benchmark Rust performance
+## Overview
 
-This section demonstrates how to benchmark Rust performance using `cargo bench` and the Criterion library to measure code execution speed and performance consistency on aarch64 hardware.
+This section demonstrates how to benchmark Rust performance using `cargo bench` and the Criterion library to measure code execution speed and performance consistency on Arm64 hardware.
 
-### Create a benchmark project
+## Create a benchmark project
 
 Create a new Rust project specifically for benchmarking:
 
@@ -19,9 +19,9 @@ cargo new rust-benchmark
 cd rust-benchmark
 ```
 
-### Configure Criterion as a dependency
+## Configure Criterion as a dependency
 
-Criterion is the recommended benchmarking crate for Rust. Edit the `Cargo.toml` file in your project root directory and replace the existing content with:
+Criterion is the recommended benchmarking crate for Rust. Open the `Cargo.toml` file in your project root directory and replace the existing content with:
 
 ```toml
 [dependencies]
@@ -34,21 +34,15 @@ harness = false
 
 This configuration enables Criterion for high-precision benchmarking and disables the default test harness.
 
-### Create the benchmark directory and file
+## Create the benchmark directory and file
 
 Create the benchmark structure that Cargo expects:
 
 ```console
 mkdir benches
 ```
 
-Create a new benchmark file in the `benches/` directory:
-
-```console
-edit benches/my_benchmark.rs
-```
-
-Add the following benchmark code to measure Fibonacci number calculation performance:
+Create a new file named `my_benchmark.rs` in the `benches/` directory and add the following benchmark code to measure Fibonacci number calculation performance:
 
 ```rust
 use criterion::{black_box, Criterion, criterion_group, criterion_main};
@@ -72,7 +66,7 @@ criterion_main!(benches);
 
 This code implements a recursive Fibonacci function and measures how efficiently Rust computes the 20th Fibonacci number. The `black_box` function prevents the compiler from optimizing away the benchmark.
 
-### Run the benchmark
+## Run the benchmark
 
 Execute the benchmark using Cargo:
 
@@ -92,29 +86,13 @@ Found 1 outliers among 100 measurements (1.00%)
   1 (1.00%) low mild
 ```
 
-### Benchmark Metrics Explanation
-
-- **Average Time:** Mean execution time across benchmark runs.  
-- **Outliers:** Represent runs significantly slower or faster than average.  
-- **Plotting Backend:** Used `plotters` since Gnuplot was not found.  
-- The results show **consistent performance** with only slight variation across 100 measurements.
-
-### Understand the results
-
-The benchmark output provides several key metrics:
-
-- **Average time**: Mean execution time across benchmark runs
-- **Outliers**: Runs significantly slower or faster than average  
-- **Plotting backend**: Uses plotters since Gnuplot wasn't found
-
-The results show consistent performance with only slight variation across 100 measurements.
-
-### Performance summary
+## Performance summary
+The benchmark output provides several key metrics: the average time represents the mean execution time across benchmark runs, outliers identify runs that were significantly slower or faster than average, and the plotting backend indicates that plotters is being used since Gnuplot wasn't found on the system.
 
-The following table shows results from running the benchmark on a `c4a-standard-4` (4 vCPU, 16 GB memory) aarch64 VM in GCP using SUSE:
+The following table shows results from running the benchmark on a `c4a-standard-4` (4 vCPU, 16 GB memory) Arm64 VM in GCP using SUSE:
 
 | Benchmark     | Average Time (µs) | Min (µs) | Max (µs) | Outliers (%) | Remarks |
 |---------------|------------------:|---------:|---------:|-------------:|---------|
 | fibonacci 20  | 12.028           | 12.026   | 12.030   | 1.00%        | Stable performance with minimal variation |
 
-The Fibonacci benchmark demonstrates consistent performance on the aarch64 platform. The average execution time of 12.028 µs indicates efficient CPU computation, while only 1% of measurements were outliers. This low variance confirms Rust's reliable execution speed and performance stability on aarch64 architecture.
+The Fibonacci benchmark demonstrates consistent performance on the Arm64 platform. The average execution time of 12.028 µs indicates efficient CPU computation, while only 1% of measurements were outliers. This low variance confirms Rust's reliable execution speed and performance stability on Arm64 architecture.

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

@@ -1,3 +1,4 @@
+
 ---
 title: Install Rust
 weight: 4
@@ -6,11 +7,11 @@ weight: 4
 layout: learningpathall
 ---
 
-## Install Rust
+## Overview
 
-This section explains how to install and configure Rust on a GCP SUSE aarch64 VM, preparing your environment for building and benchmarking Rust applications.
+This section explains how to install and configure Rust on your GCP SUSE Arm64 VM, preparing your environment for building and benchmarking Rust applications.
 
-### Update your system
+## Update your system
 
 Update the system and install essential build tools required for compiling Rust programs:
 
@@ -22,7 +23,7 @@ sudo zypper install -y curl gcc make
 
 This ensures your system has the latest packages and the necessary compilation tools.
 
-### Install Rust using rustup
+## Install Rust using rustup
 
 Rust provides an official installer script via `rustup` that handles the setup automatically:
 
@@ -32,7 +33,7 @@ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
 
 When prompted, select option 1 for the default installation. This installs the latest stable version of Rust along with Cargo, Rust's package manager and build system.
 
-### Configure your environment
+## Configure your environment
 
 Activate Rust's environment variables for your current shell session:
 
@@ -42,7 +43,7 @@ source $HOME/.cargo/env
 
 This command adds the Rust toolchain to your PATH, making the `rustc` compiler and `cargo` commands available.
 
-### Verify the installation
+## Verify the installation
 
 Confirm that Rust and Cargo installed successfully by checking their versions:
 
@@ -58,4 +59,4 @@ rustc 1.91.0 (f8297e351 2025-10-28)
 cargo 1.91.0 (ea2d97820 2025-10-10)
 ```
 
-Your Rust installation is now complete and ready for development on the aarch64 platform.
+Your Rust installation is now complete and ready for development on your Arm64 instance.

content/learning-paths/servers-and-cloud-computing/rust-on-gcp/instance.md

@@ -24,20 +24,20 @@ To create a virtual machine based on the C4A instance type:
    - Set **Series** to `C4A`.
    - Select `c4a-standard-4` for machine type.
 
-   ![Create a Google Axion C4A Arm virtual machine in the Google Cloud Console with c4a-standard-4 selected alt-text#center](images/gcp-vm.png "Creating a Google Axion C4A Arm virtual machine in Google Cloud Console")
+   ![Screenshot of Google Cloud Console showing the machine configuration section with C4A series and c4a-standard-4 machine type selected alt-text#center](images/gcp-vm.png "Creating a Google Axion C4A Arm virtual machine in Google Cloud Console")
 
 
-- Under **OS and Storage**, select **Change**, then choose an Arm64-based OS image. For this Learning Path, use **SUSE Linux Enterprise Server**. 
-- If using use **SUSE Linux Enterprise Server**. Select "Pay As You Go" for the license type. 
-- Once appropriately selected, please Click **Select**. 
+- Under **OS and Storage**, select **Change**, then choose an Arm64-based OS image. For this Learning Path, use **SUSE Linux Enterprise Server**.
+- If using **SUSE Linux Enterprise Server**, select "Pay As You Go" for the license type.
+- Once appropriately selected, click **Select**. 
 - Under **Networking**, enable **Allow HTTP traffic**.
 - Click **Create** to launch the instance.
-- Once created, you should see a "SSH" option to the right in your list of VM instances.  Click on this to launch a SSH shell into your VM instance:
+- Once created, you should see a "SSH" option to the right in your list of VM instances. Click on this to launch a SSH shell into your VM instance:
 
-![Invoke a SSH session via your browser alt-text#center](images/gcp-ssh.png "Invoke a SSH session into your running VM instance")
+![Screenshot of VM instances list showing the SSH button in the Connect columnalt-text#center](images/gcp-ssh.png "Invoke a SSH session into your running VM instance")
 
 - A window from your browser should come up and you should now see a shell into your VM instance:
 
-![Terminal Shell in your VM instance alt-text#center](images/gcp-shell.png "Terminal shell in your VM instance")
+![Screenshot of terminal window showing a command-line shell interface connected to the VM instance#center](images/gcp-shell.png "Terminal shell in your VM instance")
 
-Next, let's install rust!
+You're now ready to install Rust on your C4A instance.