Update Redis learning path

Author: madeline-underwood

content/learning-paths/servers-and-cloud-computing/redis-data-searching/background.md

@@ -1,25 +1,25 @@
 ---
-title: Getting started with Redis on Google Axion C4A (Arm Neoverse-V2)
+title: Get started with Redis on Google Axion C4A
 
 weight: 2
 
 layout: "learningpathall"
 ---
 
-## Google Axion C4A Arm instances in Google Cloud
+## Explore Google Axion C4A Arm instances
 
-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.
+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 the Arm architecture in Google Cloud.
+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, 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.
+Learn more about Google Axion from 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).
 
-## Redis
+## Explore Redis
 
-[Redis](https://redis.io/) is an open-source, **in-memory data structure store** developed under the [Redis project](https://redis.io/). It is used as a **database**, **cache**, and **message broker**, supporting a variety of data structures such as **strings**, **hashes**, **lists**, **sets**, and **sorted sets**.
+[Redis](https://redis.io/) is an open-source, in-memory data structure store developed under the [Redis project](https://redis.io/). It is used as a database, cache, and message broker, supporting a variety of data structures such as strings, hashes, lists, sets, and sorted sets.
 
-Redis is designed for **high performance**, **low latency**, and **high throughput**, making it ideal for real-time applications. It supports **persistence**, **replication**, **Lua scripting**, **transactions**, and **high availability** through Redis Sentinel and **automatic partitioning** with Redis Cluster.
+Redis is designed for high performance, low latency, and high throughput, making it ideal for real-time applications. It supports persistence, replication, Lua scripting, transactions, and high availability through Redis Sentinel and automatic partitioning with Redis Cluster.
 
-Redis is widely adopted for **caching**, **session management**, **real-time analytics**, **pub/sub messaging**, and **leaderboards** in gaming and web applications. It integrates seamlessly with programming languages like **Python**, **Java**, **Go**, and **Node.js**.
+Redis is widely adopted for caching, session management, real-time analytics, pub/sub messaging, and leaderboards in gaming and web applications. It integrates seamlessly with programming languages like Python, Java, Go, and Node.js.
 
-To learn more, visit the [Redis official website](https://redis.io/) and explore the [documentation](https://redis.io/docs/latest/).
+To learn more, visit the [Redis website](https://redis.io/) and explore the [Reddis documentation](https://redis.io/docs/latest/).

content/learning-paths/servers-and-cloud-computing/redis-data-searching/baseline.md

@@ -1,24 +1,22 @@
 ---
-title: Redis Baseline Testing on Google Axion C4A Arm Virtual Machine
+title: Test Redis on Google Axion C4A
 weight: 5
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
 ## Redis Baseline Testing on GCP SUSE VMs
-This section performs baseline testing for Redis running on a GCP SUSE Arm64 VM, focusing on data insertion, retrieval, and search performance.
+This section shows you how to perform baseline testing for Redis running on a GCP SUSE Arm64 VM, focusing on data insertion, retrieval, and search performance.
 
 ### Prerequisites
 This command launches the Redis server process in the background. It allows you to run subsequent commands in the same terminal session while Redis continues running.
-Start the Redis service in the background:
+Start the Redis service:
 
 ```console
 redis-server &
 ```
-
-**Check if Redis is active and responding to commands:**
-
+Check if Redis is active and responding to commands:
 The redis-cli ping command sends a simple health check request to the Redis server. A PONG response confirms that the server is running correctly and the client can communicate with it.
 ```console
 redis-cli ping
@@ -33,7 +31,7 @@ PONG
 ### Insert Sample Data
 These steps populate the Redis database with a sample dataset to validate insertion performance and data persistence. You will create 10,000 key-value pairs using a simple shell loop and verify that the data has been successfully stored.
 
-Use `redis-cli` to insert **10,000 sample key-value pairs**:
+Use `redis-cli` to insert 10,000 sample key-value pairs:
 ```console
 for i in $(seq 1 10000); do
   redis-cli SET key:$i "value-$i" > /dev/null
@@ -59,6 +57,7 @@ Seeing `(integer) 10000` confirms that all key-value pairs were inserted success
 
 Fetch one of the inserted keys to confirm data correctness:
 
+Verify sample data retrieval:
 ```console
 redis-cli GET key:5000
 ```
@@ -74,8 +73,9 @@ You should see an output similar to:
 ### Perform Basic Data Search Tests
 This step verifies Redis’s ability to retrieve specific data efficiently using unique keys. The `GET` command fetches the value associated with a given key from Redis.
 
-You can test this by retrieving a known key-value pair:
+Verify Redis's ability to retrieve specific data efficiently using unique keys. The `GET` command fetches the value associated with a given key from Redis.
 
+Test this by retrieving a known key-value pair:
 ```console
 redis-cli GET key:1234
 ```
@@ -112,8 +112,11 @@ You should see an output similar to:
 ..........
 ```
 
-### Production-Safe Searching with SCAN
-This step introduces a production-friendly method for iterating through keys without blocking Redis operations.
+{{% notice Note %}}
+`KEYS` is fast but blocks the server when handling large datasets, so it's not recommended in production.
+{{% /notice %}}
+
+### Production-safe searching with SCAN
 
 Use the `SCAN` command for larger datasets — it is non-blocking and iterates safely.
 
@@ -137,8 +140,11 @@ You should see an output similar to:
 Redis will return a cursor value (for example, `9792`).  
 Continue scanning by reusing the cursor until it returns `0`, meaning the iteration is complete.
 
-### Measure Data Retrieval Performance
-This step measures how quickly Redis can retrieve a single key from memory, helping to establish a baseline for data access latency on the Arm-based VM.
+### Measure data retrieval performance
+
+
+
+Measure how quickly Redis can retrieve a single key from memory, helping to establish a baseline for data access latency on the Arm-based VM.
 
 **Time Single Key Lookup**: Redis operations are extremely fast since data is stored in-memory. To quantify this, the Unix `time` command is used to measure the latency of retrieving a single key using `redis-cli`.
 

content/learning-paths/servers-and-cloud-computing/redis-data-searching/installation.md

@@ -7,31 +7,31 @@ layout: learningpathall
 ---
 
 ## Install Redis on GCP VM
-This section provides a complete guide to installing Redis on a **GCP SUSE virtual machine**. Redis will be built from source to ensure compatibility with the Arm architecture and to enable TLS support for secure connections.
+This section provides a complete guide to installing Redis on a GCP SUSE virtual machine. You will build Redis from source to ensure compatibility with the Arm architecture and to enable TLS support for secure connections.
 
-### Prerequisites
-Before building Redis, update your package repositories and install essential build tools and libraries.
+## Prerequisites
+Before building Redis, update your package repositories and install essential build tools and libraries:
 
 ```console
 sudo zypper refresh
 sudo zypper install -y gcc gcc-c++ make tcl openssl-devel wget
 ```
-### Download and Extract Redis Source Code
-This step downloads the Redis 8.2.2 source archive directly from the official GitHub repository, extracts the contents, and navigates into the extracted directory for compilation.
+## Download and extract Redis source code
+
+Now download the Redis 8.2.2 source archive directly from the official GitHub repository, extract the contents, and navigate into the extracted directory for compilation:
 
 ```console
 wget https://github.com/redis/redis/archive/refs/tags/8.2.2.tar.gz
 tar -xvf 8.2.2.tar.gz
 cd redis-8.2.2
 ```
 {{% notice Note %}}
-In [this](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/improve-redis-performance-by-deploying-on-alibaba-cloud-yitian-710-instances) blog, Redis version 6.0.9 is recommended for deployment on Arm-based Alibaba Yitian 710 instances, which deliver up to 36% higher throughput and 20% lower cost compared to equivalent x86-based ECS instances, making it a more efficient and cost-effective choice for Redis workloads.
+In this blog [Improve Redis performance up to 36% by deploying on Alibaba Cloud Yitian 710 instances](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/improve-redis-performance-by-deploying-on-alibaba-cloud-yitian-710-instances), Redis version 6.0.9 is recommended for deployment on Arm-based Alibaba Yitian 710 instances. These instances deliver up to 36% higher throughput and 20% lower cost compared to equivalent x86-based ECS instances, making it a more efficient and cost-effective choice for Redis workloads.
 
 The [Arm Ecosystem Dashboard](https://developer.arm.com/ecosystem-dashboard/) recommends Redis version 6.0.9, the minimum recommended on the Arm platforms.
 {{% /notice %}}
 
-### Build Redis with TLS Support
-**Clean any previous build artifacts (if any):**
+Clean any previous build artifacts (if any):
 
 ```console
 make distclean
@@ -48,9 +48,13 @@ sudo make hiredis jemalloc linenoise lua fast_float
 cd ..
 sudo make BUILD_TLS=yes
 ```
-Note: The BUILD_TLS=yes flag enables TLS (SSL) support for secure Redis connections.
 
-### Verify Redis Binary
+{{% notice Note %}}
+The `BUILD_TLS=yes` flag enables TLS (SSL) support for secure Redis connections.
+{{% /notice %}}
+
+### Verify Redis binary
+
 After a successful build, check that the redis-server binary exists:
 
 ```
@@ -65,28 +69,30 @@ You should see a file similar to:
 ```
 This confirms that Redis compiled successfully and that the `redis-server` binary is present in the `/src` directory. The file’s permissions indicate it is executable.
 
-### Install Redis System-Wide
-This command installs Redis binaries (`redis-server` and `redis-cli`) into system-wide directories (typically `/usr/local/bin`), allowing you to run Redis commands from any location.
-To make redis-server and redis-cli accessible globally:
+### Install Redis system-wide
+Use the following command to install Redis binaries (`redis-server` and `redis-cli`) globally, making them accessible from any directory:
 
 ```console
 sudo make install
 ```
 
+This places `redis-server` and `redis-cli` into `/usr/local/bin`, allowing you to run Redis commands from anywhere on your system.
+
 Verify installation paths:
 
 ```console
 which redis-server
 which redis-cli
 ```
 
-Expected:
+The expected output is:
 
 ```output
 /usr/local/bin/redis-server
 /usr/local/bin/redis-cli
 ```
-This confirms that Redis binaries are available in your system path, verifying a successful installation.
+
+This confirms that Redis binaries are installed in your system path.
 
 ### Verify Installation
 Check Redis versions:
@@ -96,7 +102,7 @@ redis-server --version
 redis-cli --version
 ```
 
-Output:
+The expected output is:
 
 ```output
 redis-server --version

content/learning-paths/servers-and-cloud-computing/redis-data-searching/instance.md

@@ -1,5 +1,5 @@
 ---
-title: Create a Google Axion C4A Arm virtual machine on GCP 
+title: Create a Compute Engine instance
 weight: 3
 
 ### FIXED, DO NOT MODIFY
@@ -11,10 +11,10 @@ layout: learningpathall
 In this section, you will learn how to provision a Google Axion C4A Arm virtual machine on Google Cloud Platform (GCP) using the `c4a-standard-4` (4 vCPUs, 16 GB memory) machine type in the Google Cloud Console.  
 
 {{% notice Note %}}
-For support on GCP setup, see the Learning Path [Getting started with Google Cloud Platform](https://learn.arm.com/learning-paths/servers-and-cloud-computing/csp/google/).
+For support on GCP setup, see the Learning Path [Getting started with Google Cloud Platform](/learning-paths/servers-and-cloud-computing/csp/google/).
 {{% /notice %}}
 
-## Provision a Google Axion C4A Arm VM in Google Cloud Console
+## Create your Google Axion C4A Arm VM
 
 To create a virtual machine based on the C4A instance type:
 - Navigate to the [Google Cloud Console](https://console.cloud.google.com/).
@@ -28,16 +28,16 @@ To create a virtual machine based on the C4A instance type:
 
 
 - 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**. 
+- If using **SUSE Linux Enterprise Server**, select **Pay As You Go** for the license type. 
+- Once appropriately selected, select **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:
+- Select **Create** to launch the instance.
+- Once created, you should see an **SSH** option to the right in your list of VM instances. Select this to launch an 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")
+![Google Cloud Console showing VM instances list with SSH button highlighted for connecting to the running C4A instance#center](images/gcp-ssh.png "SSH connection to 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")
 
-Next, let's install redis!
+Next, install Redis.