Update Cassandra learning path content. Renamed files for correct spelling.

madeline-underwood · madeline-underwood · commit 8984a43dad98 · 2025-12-19T06:35:09.000Z
diff --git a/content/learning-paths/servers-and-cloud-computing/cassandra-on-gcp/_index.md b/content/learning-paths/servers-and-cloud-computing/cassandra-on-gcp/_index.md
@@ -1,9 +1,5 @@
 ---
-title:  Deploy Cassandra on a Google Axion C4A virtual machine
-
-draft: true
-cascade:
-    draft: true
+title: Deploy Cassandra on a Google Axion C4A virtual machine
 
 minutes_to_complete: 30
 
@@ -18,7 +14,7 @@ learning_objectives:
 
 prerequisites:
   - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled
-  - Familiarity with Cassandra architecture, replication, and [Cassandra partitioning & event-driven I/O](https://cassandra.apache.org/doc/stable/cassandra/architecture/)
+  - Familiarity with Cassandra architecture, replication, and [Cassandra partitioning and event-driven I/O](https://cassandra.apache.org/doc/stable/cassandra/architecture/)
 
 author: Pareena Verma
 
diff --git a/content/learning-paths/servers-and-cloud-computing/cassandra-on-gcp/backgraound.md b/content/learning-paths/servers-and-cloud-computing/cassandra-on-gcp/backgraound.md
diff --git a/content/learning-paths/servers-and-cloud-computing/cassandra-on-gcp/background.md b/content/learning-paths/servers-and-cloud-computing/cassandra-on-gcp/background.md
@@ -0,0 +1,23 @@
+---
+title: Get started with Cassandra on Google Axion C4A
+
+weight: 2
+
+layout: "learningpathall"
+---
+
+## Explore Google Axion C4A Arm instances
+
+Google Axion C4A is a family of Arm-based virtual machines built on Google's custom Axion CPU, based on Arm Neoverse-V2 cores. These virtual machines deliver 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 Arm architecture in Google Cloud.
+
+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).
+
+## Explore Cassandra
+
+Cassandra is a highly scalable, distributed NoSQL database designed to handle large amounts of data across many commodity servers without a single point of failure.
+
+It provides high availability, fault tolerance, and linear scalability, making it ideal for real-time big data applications and high-throughput workloads.
+
+Cassandra is widely used for time-series data, IoT applications, recommendation engines, and large-scale cloud services. To learn, see the [Cassandra website](https://cassandra.apache.org/) and the [Cassandra documentation](https://cassandra.apache.org/doc/latest/).
diff --git a/content/learning-paths/servers-and-cloud-computing/cassandra-on-gcp/baseline.md b/content/learning-paths/servers-and-cloud-computing/cassandra-on-gcp/baseline.md
@@ -6,6 +6,8 @@ weight: 5
 layout: learningpathall
 ---
 
+## Overview
+
 Now that Cassandra is installed on your GCP C4A Arm virtual machine, verify that it's running and functioning properly.
 
 ## Start Cassandra
@@ -45,7 +47,7 @@ UN  127.0.0.1  162.51 KiB  16      100.0%            78774686-39f3-47e7-87c3-3ab
 
 For a single-node setup, the output should indicate that the node is Up (U) and Normal (N), confirming that your Cassandra instance is running and ready to accept queries.
 
-### Connect with CQLSH
+## Connect with CQLSH
 
 `cqlsh` is the interactive command-line shell for Cassandra that allows you to run Cassandra Query Language (CQL) commands.
 
@@ -55,7 +57,7 @@ cqlsh
 
 You'll enter the CQL (Cassandra Query Language) shell.
 
-### Create a keyspace
+## Create a keyspace
 
 A keyspace in Cassandra is similar to a database in SQL systems. Create a simple keyspace `testks` with a replication factor of 1 (suitable for a single-node setup):
 
@@ -78,7 +80,7 @@ system       system_distributed  system_traces  system_virtual_schema
 system_auth  system_schema       system_views   testks
 ```
 
-### Create a table
+## Create a table
 
 Create a `users` table with three columns:
 
@@ -92,7 +94,7 @@ CREATE TABLE users (
 );
 ```
 
-### Insert data
+## Insert data
 
 Insert two sample rows into the `users` table. The `uuid()` function generates a unique identifier for each row:
 
@@ -101,7 +103,7 @@ INSERT INTO users (id, name, age) VALUES (uuid(), 'Alice', 30);
 INSERT INTO users (id, name, age) VALUES (uuid(), 'Bob', 25);
 ```
 
-### Query data
+## Query data
 
 Retrieve all rows from the `users` table:
 
@@ -122,4 +124,4 @@ The output is similar to:
 
 This baseline test verifies that Cassandra 5.0.5 is installed and running correctly on the VM, confirming node status, CQLSH connectivity, and basic database operations.
 
-Press Ctrl-D to exit the Cassandra Query Shell. 
+Press `Ctrl-D` to exit the Cassandra Query Shell. 
diff --git a/content/learning-paths/servers-and-cloud-computing/cassandra-on-gcp/benchmarking.md b/content/learning-paths/servers-and-cloud-computing/cassandra-on-gcp/benchmarking.md
@@ -1,32 +1,32 @@
 ---
-title: Cassandra Benchmarking
+title: Benchmark Cassandra performance
 weight: 6
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## Cassandra Benchmarking by Cassandra-Stress
-Cassandra benchmarking can be performed using the built-in `cassandra-stress` tool, which helps measure database performance under different workloads such as write, read, and mixed operations.
+## Benchmark Cassandra with cassandra-stress
 
-### Steps for Cassandra Benchmarking with Cassandra-Stress
-**Verify cassandra-stress Installation:**
+You can perform Cassandra benchmarking using the built-in `cassandra-stress` tool, which measures database performance under different workloads such as write, read, and mixed operations.
 
-Cassandra comes with a built-in tool called **cassandra-stress** that is used for testing performance. It is usually located in the `tools/bin/` folder of your Cassandra installation. 
+## Verify cassandra-stress installation
+
+Cassandra comes with a built-in tool called `cassandra-stress` that is used for testing performance. It's located in the `tools/bin/` folder of your Cassandra installation.
 
 ```console
 ls ~/cassandra/tools/bin | grep cassandra-stress
 ```
-If you see cassandra-stress in the list, it means the tool is installed and ready to use.
 
-**Run the version check:**
+If you see `cassandra-stress` in the list, the tool is installed and ready to use.
 
-To make sure the tool works correctly, check its help options.
+Check the tool's help options to verify it works correctly:
 
 ```console
 ~/cassandra/tools/bin/cassandra-stress help
 ```
-You should see output similar to the following:
+
+The output is similar to:
 
 ```output
 Usage:      cassandra-stress <command> [options]
@@ -43,10 +43,10 @@ help                 : Print help for a command or option
 print                : Inspect the output of a distribution definition
 version              : Print the version of cassandra stress
 ```
-If the tool is working, you will see a list of commands and options that you can use to run benchmarks.
-This confirms that your setup is correct and you’re ready to start testing Cassandra’s performance.
 
-### Basic Write Test
+The list of commands and options confirms that your setup is correct and you're ready to start testing Cassandra's performance.
+
+## Run a basic write test
 Insert 10,000 rows with 50 concurrent threads using `cassandra-stress`:
 
 ```console
@@ -56,7 +56,7 @@ Insert 10,000 rows with 50 concurrent threads using `cassandra-stress`:
 - **n=10000** → Specifies the number of rows to insert during the benchmark test.  
 - **-rate threads=50** → Sets the number of concurrent worker threads simulating multiple clients writing to the cluster. 
 
-You should see output similar to the following:
+The output is similar to:
 
 ```output
 ******************** Stress Settings ********************
@@ -186,13 +186,16 @@ Total operation time      : 00:00:00
 END
 ```
 
-### Read Test
-The following command runs a **read benchmark** on your Cassandra database using `cassandra-stress`. It simulates multiple clients reading from the cluster at the same time and records performance metrics such as **throughput** and **latency**.
+## Run a read test
+
+Run a read benchmark on your Cassandra database using `cassandra-stress`. This simulates multiple clients reading from the cluster at the same time and records performance metrics such as throughput and latency.
 
 ```console
 ~/cassandra/tools/bin/cassandra-stress read n=10000 -rate threads=50
 ```
-You should see output similar to the following:
+
+The output is similar to:
+
 ```output
 ******************** Stress Settings ********************
 Command:
@@ -322,21 +325,24 @@ Total operation time      : 00:00:02
 END
 ```
 
-## Benchmark Results Table Explained:
+## Understand benchmark results
+
+The metrics below explain what each value in the `cassandra-stress` output represents:
+
+- Op rate (operations per second): the number of read operations Cassandra successfully executed per second.  
+- Partition rate: the number of partitions read per second. Since this is a read test, the partition rate equals the op rate.  
+- Row rate: the number of rows read per second. Again, for this test it equals the op rate.  
+- Latency mean: the average time taken for each read request to complete.  
+- Latency median: the 50th percentile latency - half of the operations completed faster than this time.  
+- Latency max: the slowest single read request during the test.  
+- Total partitions: the total number of partitions read during the test.  
+- Total errors: the number of failed read operations.  
+- GC metrics (Garbage Collection): shows whether JVM garbage collection paused Cassandra during the test.  
+- Total operation time: the total wall-clock time taken to run the benchmark.  
 
-- **Op rate (operations per second):** The number of read operations Cassandra successfully executed per second.  
-- **Partition rate:** Number of partitions read per second. Since this is a read test, the partition rate equals the op rate.  
-- **Row rate:** Number of rows read per second. Again, for this test it equals the op rate.  
-- **Latency mean:** The average time taken for each read request to complete.  
-- **Latency median:** The 50th percentile latency — half of the operations completed faster than this time.  
-- **Latency max:** The slowest single read request during the test.  
-- **Total partitions:** The total number of partitions read during the test.  
-- **Total errors:** Number of failed read operations.  
-- **GC metrics (Garbage Collection):** Shows whether JVM garbage collection paused Cassandra during the test.  
-- **Total operation time:** The total wall-clock time taken to run the benchmark.  
+## Benchmark summary for Arm64
 
-### Benchmark summary on Arm64
-Results from the earlier run on the `c4a-standard-4` (4 vCPU, 16 GB memory) Arm64 VM in GCP (SuSE shown, Ubuntu results were very similar):
+Results from the run on the `c4a-standard-4` (4 vCPU, 16 GB memory) Arm64 VM in GCP (SUSE shown; Ubuntu results were very similar):
 
 | Metric                     | Write Test             | Read Test              |
 |----------------------------|----------------------|----------------------|
@@ -356,12 +362,12 @@ Results from the earlier run on the `c4a-standard-4` (4 vCPU, 16 GB memory) Arm6
 | Total GC Time               | 0.0 s                | 0.0 s                |
 | Total Operation Time        | 0:00:00              | 0:00:02              |
 
-### Cassandra performance benchmarking notes
-When examining the benchmark results, you will notice that on the Google Axion C4A Arm-based instances:
+## What you've accomplished and what's next
+
+You've successfully deployed Apache Cassandra 5.0.5 on a Google Axion C4A Arm-based virtual machine, validated its functionality, and measured its performance using cassandra-stress. The benchmark results on Google Axion C4A Arm-based instances demonstrate strong performance characteristics. 
+
+Write operations achieved high throughput of 10,690 op/s, while read operations reached 4,962 op/s on the `c4a-standard-4` Arm64 VM. Write latency was notably low with a mean of 3.7 ms compared to reads at 6.3 ms, indicating fast write processing on this Arm64 VM. The 95th and 99th percentile latencies show consistent performance, with writes significantly faster than reads. Zero errors or GC overhead confirm stable and reliable benchmarking results. 
 
-- The write operations achieved a high throughput of **10,690 op/s**, while read operations reached **4,962 op/s** on the `c4a-standard-4` Arm64 VM.  
-- Latency for writes was very low (mean: **3.7 ms**) compared to reads (mean: **6.3 ms**), indicating fast write processing on this Arm64 VM.  
-- The 95th and 99th percentile latencies show consistent performance, with writes significantly faster than reads.  
-- There were no errors or GC overhead, confirming stable and reliable benchmarking results.  
+The Arm64 VM provides efficient and predictable performance, making it suitable for high-throughput Cassandra workloads. The low write latencies and high operation rates demonstrate that Arm-based infrastructure can effectively handle database operations that require both speed and consistency. These results provide a solid baseline for evaluating Cassandra performance on Arm64 architecture and can guide decisions about instance sizing and configuration for production deployments.
 
-Overall, the Arm64 VM provides efficient and predictable performance, making it suitable for high-throughput Cassandra workloads.
+To continue building on this foundation, you can explore advanced Cassandra configurations such as multi-node cluster deployments, replication strategies for high availability, or performance tuning for specific workload patterns. You might also investigate integrating Cassandra with application frameworks or comparing performance across different Arm-based instance types to optimize for your use case.
diff --git a/content/learning-paths/servers-and-cloud-computing/cassandra-on-gcp/installation.md b/content/learning-paths/servers-and-cloud-computing/cassandra-on-gcp/installation.md
@@ -6,11 +6,11 @@ weight: 4
 layout: learningpathall
 ---
 
-## Apache Cassandra Installation on Ubuntu or SuSE VM
-This guide will help you install **Apache Cassandra** on a Ubuntu or SuSE Linux virtual machine. Cassandra is a highly scalable NoSQL database designed for high availability and fault tolerance.
+## Install Apache Cassandra on Ubuntu or SUSE
 
-### Update System Packages
-Updating system packages ensures that your system has the latest security patches and dependencies required for Cassandra.
+This guide shows you how to install Apache Cassandra on an Ubuntu or SUSE Linux virtual machine. Cassandra is a highly scalable NoSQL database designed for high availability and fault tolerance.
+
+## Update system packages
 
 {{< tabpane code=true >}}
   {{< tab header="Ubuntu" language="bash">}}
@@ -22,8 +22,9 @@ sudo zypper update -y
   {{< /tab >}}
 {{< /tabpane >}}
 
-### Install Java
-Cassandra requires a Java runtime environment. You can use either Java 11 or Java 17. This example uses Java 17 for optimal performance and compatibility with Cassandra 5.0.5.
+## Install Java
+
+Cassandra requires a Java runtime environment. This example uses Java 17 for optimal performance and compatibility with Cassandra 5.0.5.
 
 {{< tabpane code=true >}}
   {{< tab header="Ubuntu" language="bash">}}
@@ -34,44 +35,47 @@ sudo zypper install -y java-17-openjdk java-17-openjdk-devel
   {{< /tab >}}
 {{< /tabpane >}}
 
-### Download Cassandra
-Download the latest stable release of Apache Cassandra 5.0.5 from the official Apache repository.
+## Download Cassandra
 
 ```console
 wget https://downloads.apache.org/cassandra/5.0.5/apache-cassandra-5.0.5-bin.tar.gz
 ```
+
 {{% notice Note %}}
-Apache Cassandra 5.0 is a major release introducing significant performance, usability, and scalability enhancements. Key features include Storage Attached Indexes (SAI) for flexible querying, Trie-based memtables/SSTables for better efficiency, and the Unified Compaction Strategy (UCS) for automated data management. It also supports JDK 17 for up to 20% performance gains and adds vector search for AI applications. The release marks the end-of-life for the 3.x series, urging users to upgrade for continued support.
-You can view [this release note](https://cassandra.apache.org/_/blog/Apache-Cassandra-5.0-Announcement.html)
+Apache Cassandra 5.0 is a major release introducing significant performance, usability, and scalability enhancements. Key features include Storage Attached Indexes (SAI) for flexible querying, Trie-based memtables/SSTables for better efficiency, and the Unified Compaction Strategy (UCS) for automated data management. It also supports JDK 17 for up to 20% performance gains and adds vector search for AI applications. The release marks the end-of-life for the 3.x series, urging users to upgrade for continued support. To learn more, see the [Apache Cassandra 5.0 announcement](https://cassandra.apache.org/_/blog/Apache-Cassandra-5.0-Announcement.html).
 
-The [Arm Ecosystem Dashboard](https://developer.arm.com/ecosystem-dashboard/) recommends PHP version 5.0.0 as the minimum recommended on the Arm platforms.
+The [Arm Ecosystem Dashboard](https://developer.arm.com/ecosystem-dashboard/) recommends Cassandra version 5.0.0 as the minimum recommended on Arm platforms.
 {{% /notice %}}
 
-### Extract and Setup Cassandra
-Extract the downloaded archive and move it to a dedicated directory for Cassandra.
+## Extract and set up Cassandra
 
 ```console
 tar -xvzf apache-cassandra-5.0.5-bin.tar.gz
 mv apache-cassandra-5.0.5 ~/cassandra
 ```
 
-### Enable Running Cassandra from Anywhere
+## Add Cassandra to PATH
+
 To run Cassandra commands from any location, add the `bin` directory to your PATH environment variable:
 
 ```console
 echo 'export PATH="$HOME/cassandra/bin:$PATH"' >> ~/.bashrc
 source ~/.bashrc
 ```
-Now you can run `Cassandra` or `cqlsh` from any terminal without specifying the full path.
 
-### Verify Installation
+You can now run `Cassandra` or `cqlsh` from any terminal without specifying the full path.
+
+## Verify installation
 Check the installed Cassandra version to confirm the installation:
 
 ```console
 cassandra -v
 ```
-You should see an output similar to:
+
+The output is similar to:
+
 ```output
 5.0.5
 ```
-Cassandra's installation is complete. You can now proceed with the baseline testing.
+
+Cassandra is now installed and ready for baseline testing.
diff --git a/content/learning-paths/servers-and-cloud-computing/cassandra-on-gcp/instance.md b/content/learning-paths/servers-and-cloud-computing/cassandra-on-gcp/instance.md
