Review and update Redis Learning Path materials

Author: madeline-underwood

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

@@ -1,19 +1,15 @@
 ---
-title: Deploy Redis for data searching on Google Cloud C4A (Arm-based Axion VMs)
-
-draft: true
-cascade:
-    draft: true
+title: Deploy Redis for data searching on Google Cloud C4A 
 
 minutes_to_complete: 30
 
-who_is_this_for: This learning path is intended for software developers deploying and optimizing Redis-based data searching 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 Redis-based data searching 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)
   - Install Redis on a SUSE Arm64 (C4A) instance
   - Verify Redis functionality by running the server and performing baseline data insertion and retrieval tests on the Arm64 VM  
-  - Measure Redis SET (write) and GET (read) performance using the official redis-benchmark tool to evaluate throughput and latency on Arm64 (Aarch64)
+  - Measure Redis SET (write) and GET (read) performance using the official redis-benchmark tool to evaluate throughput and latency on Arm64 (AArch64)
 
 prerequisites:
   - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled

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

@@ -22,4 +22,4 @@ Redis is designed for high performance, low latency, and high throughput, making
 
 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 website](https://redis.io/) and explore the [Reddis documentation](https://redis.io/docs/latest/).
+To learn more, visit the [Redis website](https://redis.io/) and explore the [Redis documentation](https://redis.io/docs/latest/).

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

@@ -1,59 +1,63 @@
 ---
-title: Test Redis on Google Axion C4A
+title: Test Redis 
 weight: 5
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## Redis Baseline Testing on GCP SUSE VMs
+## Perform Redis baseline testing on GCP SUSE VMs
 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:
 
 ```console
 redis-server &
 ```
+
 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
 ```
-
-output:
+The output is similar to:
 
 ```output
 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.
+## Insert sample data
+
+Populate the Redis database with a sample dataset to validate insertion performance and data persistence. You 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:
+
 ```console
 for i in $(seq 1 10000); do
   redis-cli SET key:$i "value-$i" > /dev/null
 done
 ```
 - This command iterates through numbers **1 to 10,000**, setting each as a Redis key in the format `key:<number>` with the corresponding value `"value-<number>"`.
 - The `> /dev/null` part suppresses command output to make the insertion process cleaner and faster.
+- The `> /dev/null` part suppresses command output to make the insertion process cleaner and faster.
 
-**Verify Data Storage Count:**
-
-The `DBSIZE` command returns the total number of keys currently stored in the Redis database.
+Verify data storage count:
 
 ```console
 redis-cli DBSIZE
 ```
 
+The output is similar to:
+
 ```output
 (integer) 10000
 ```
-Seeing `(integer) 10000` confirms that all key-value pairs were inserted successfully.
 
-**Verify Sample Data Retrieval**
+This confirms that all key-value pairs were inserted successfully.
+
+### Verify sample data retrieval
 
 Fetch one of the inserted keys to confirm data correctness:
 
@@ -70,7 +74,7 @@ You should see an output similar to:
 "value-5000"
 ```
 
-### Perform Basic Data Search Tests
+## 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.
 
 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.
@@ -87,17 +91,16 @@ You should see an output similar to:
 ```
 This confirms that Redis is storing and retrieving data correctly from memory.
 
-### Search for Multiple Keys Using Pattern Matching
+## Search for multiple keys using pattern matching
 This test demonstrates how Redis can locate multiple keys that match a pattern, useful for exploratory queries or debugging.
 
 Use the `KEYS` command to search for keys matching a pattern:
 
 ```console
 redis-cli KEYS "key:1*"
 ```
-`KEYS` is fast but **blocks the server** when handling large datasets, so it’s not recommended in production.
 
-You should see an output similar to:
+The output is similar to:
 
 ```output
    1) "key:1392"
@@ -116,7 +119,7 @@ You should see an output similar to:
 `KEYS` is fast but blocks the server when handling large datasets, so it's not recommended in production.
 {{% /notice %}}
 
-### Production-safe searching with SCAN
+## Production-safe searching with SCAN
 
 Use the `SCAN` command for larger datasets — it is non-blocking and iterates safely.
 
@@ -140,9 +143,7 @@ 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
-
-
+## 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.
 

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

@@ -1,44 +1,45 @@
 ---
-title: Redis Benchmarking
+title: Benchmark Redis
 weight: 6
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
+## Benchmark Redis using redis-benchmark
 
-## Redis Benchmarking by redis-benchmark
-The `redis-benchmark` tool is an official performance testing utility for Redis. It helps measure to throughput (requests per second) and latency (response delay) across different workloads.
+The `redis-benchmark` tool is an official performance testing utility for Redis. It measures throughput (requests per second) and latency (response delay) across different workloads.
 
 ### Prerequisites
-Ensure Redis server is running and accessible:
+
+Before running benchmarks, verify that Redis is running and accessible:
 
 ```console
 redis-cli ping
 ```
 
-If you do not see a "PONG" response, please start redis:
+If you don't see a `PONG` response, start Redis:
 
 ```console
 redis-server &
 redis-cli ping
 ```
 
-### Benchmark SET (Write Performance)
-The `SET` benchmark helps validate Redis’s ability to handle high insertion rates efficiently on Arm-based servers.
+### Benchmark SET (write performance)
 
-The following command benchmarks data insertion performance:
+Benchmark data insertion performance:
 
 ```console
 redis-benchmark -t set -n 100000 -c 50
 ```
-**Explanation:**
 
-- `-t set`: Runs the benchmark only for **SET** operations.  
-- `-n 100000`: Performs **100,000 total requests**.  
-- `-c 50`: Simulates **50 concurrent clients**.
+This command:
+
+- Runs the benchmark for SET operations only (`-t set`)
+- Performs 100,000 total requests (`-n 100000`)
+- Simulates 50 concurrent clients (`-c 50`)
 
-You should see an output similar to:
+The output is similar to:
 
 ```output
 ====== SET ======
@@ -85,19 +86,20 @@ Summary:
         0.170     0.056     0.167     0.183     0.191     1.095
 ```
 
-### Benchmark GET (Read/Search Performance)
-Now test data retrieval performance separately.
+### Benchmark GET (read performance)
+
+Test data retrieval performance:
 
 ```console
 redis-benchmark -t get -n 100000 -c 50
-```
-**Explanation:**
 
-- `-t get`: Runs the benchmark only for **GET** operations.  
-- `-n 100000`: Executes **100,000 total requests**.  
-- `-c 50`: Simulates **50 concurrent clients** performing reads.
+Parameters:
+
+- `-t get`: Runs the benchmark only for GET operations.  
+- `-n 100000`: Executes 100,000 total requests.  
+- `-c 50`: Simulates 50 concurrent clients performing reads.
 
-You should see an output similar to:
+The output is similar to:
 
 ```output
 ====== GET ======
@@ -141,26 +143,24 @@ Summary:
         0.169     0.048     0.167     0.183     0.191     0.807
 ```
 
-### Benchmark Metrics Explanation
+## Interpret the benchmark metrics 
 
-- **Throughput:** Number of operations (requests) Redis can process per second.
-- **Latency:** Latency reflects the time it takes for Redis to complete a single request, measured in milliseconds (ms).  
-- **avg:** Average time taken to process a request across the entire test.
-- **min:** Fastest observed response time (best case).
-- **p50:** Median latency — 50% of requests completed faster than this value.
-- **p95:** 95th percentile — 95% of requests completed faster than this value.
-- **p99:** 99th percentile — shows near worst-case latency, key for reliability analysis.
-- **max:** Slowest observed response time (worst case).
-
-### Benchmark summary
-Results from the earlier run on the `c4a-standard-4` (4 vCPU, 16 GB memory) Arm64 VM in GCP (SUSE Enterprise Server):
+The following table summarizes the benchmark results from the earlier run on the `c4a-standard-4` (4 vCPU, 16 GB memory) Arm64 VM in GCP (SUSE Enterprise Server):
 
 | Operation | Total Requests | Concurrent Clients | Avg Latency (ms) | Min (ms) | P50 (ms) | P95 (ms) | P99 (ms) | Max (ms) | Throughput (req/sec) | Description |
 |------------|----------------|--------------------|------------------|-----------|-----------|-----------|-----------|-----------|-----------------------|--------------|
 | SET        | 100,000        | 50                 | 0.170            | 0.056     | 0.167     | 0.183     | 0.191     | 1.095     | 149,700.61            | Measures Redis write performance using SET command |
 | GET        | 100,000        | 50                 | 0.169            | 0.048     | 0.167     | 0.183     | 0.191     | 0.807     | 150,375.94            | Measures Redis read performance using GET command |
 
- - **High Efficiency:** Redis achieved over **150K ops/sec** on both read and write workloads, showcasing strong throughput on **Arm64 (C4A)** architecture.
-- **Low Latency:** Average latency remained around **0.17 ms**, demonstrating consistent response times under concurrency.
-- **Balanced Performance:** Both **SET** and **GET** operations showed nearly identical performance, indicating excellent CPU and memory optimization on **Arm64**.
-- **Energy-Efficient Compute:** The **Arm-based C4A VM** delivers competitive performance-per-watt efficiency, ideal for scalable, sustainable Redis deployments.
+Redis demonstrated excellent performance on the Arm64-based C4A VM, achieving over 150K operations per second for both read and write workloads with an average latency of approximately 0.17 ms. Both SET and GET operations showed nearly identical performance characteristics, indicating efficient CPU and memory optimization on the Arm architecture. The Arm-based C4A VM delivers competitive performance-per-watt efficiency, making it ideal for scalable, sustainable Redis deployments.
+
+## What you've accomplished and what's next
+
+In this section, you:
+- Benchmarked Redis SET operations, achieving over 149K requests per second with 0.170 ms average latency
+- Benchmarked Redis GET operations, achieving over 150K requests per second with 0.169 ms average latency
+- Verified that Redis performs efficiently on Google Axion C4A Arm instances
+
+You've successfully benchmarked Redis on Google Cloud's C4A Arm-based virtual machines, demonstrating strong performance for in-memory data operations.
+
+For next steps, consider exploring Redis Cluster for distributed deployments, implementing persistence strategies for production workloads, or testing more advanced data structures like sorted sets and streams. You can also compare performance across different C4A machine types to optimize cost and performance for your specific use case.

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

@@ -38,7 +38,7 @@ make distclean
 ```
 This removes any residual files from a previous build, ensuring a clean build environment.
 
-**Now build Redis dependencies and compile Redis:**
+Build Redis dependencies and compile Redis:
 
 Redis relies on several third-party libraries (such as hiredis, jemalloc, and lua) to optimize performance and functionality. After building dependencies, the Redis source is compiled with BUILD_TLS=yes, enabling support for encrypted TLS connections.
 
@@ -53,23 +53,23 @@ sudo make BUILD_TLS=yes
 The `BUILD_TLS=yes` flag enables TLS (SSL) support for secure Redis connections.
 {{% /notice %}}
 
-### Verify Redis binary
+## Verify Redis binary
 
-After a successful build, check that the redis-server binary exists:
+After a successful build, check that the `redis-server` binary exists:
 
 ```
 cd src
 ls -l redis-server
 ```
 
-You should see a file similar to:
+The output is similar to:
 
 ```output
 -rwxr-xr-x 1 root root 17869216 Oct 23 11:48 redis-server
 ```
 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
+## 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
@@ -94,7 +94,8 @@ The expected output is:
 
 This confirms that Redis binaries are installed in your system path.
 
-### Verify Installation
+### Verify installation
+
 Check Redis versions:
 
 ```console

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

@@ -14,7 +14,7 @@ In this section, you will learn how to provision a Google Axion C4A Arm virtual
 For support on GCP setup, see the Learning Path [Getting started with Google Cloud Platform](/learning-paths/servers-and-cloud-computing/csp/google/).
 {{% /notice %}}
 
-## Create your Google Axion C4A Arm VM
+## Create your Google Axion C4A Arm virtual machine
 
 To create a virtual machine based on the C4A instance type:
 - Navigate to the [Google Cloud Console](https://console.cloud.google.com/).
@@ -24,7 +24,7 @@ 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")
+   ![Google Cloud Console showing Create Instance form with Machine configuration section displaying C4A series and c4a-standard-4 machine type selected alt-text#center](images/gcp-vm.png "Create a Google Axion C4A Arm virtual machine")
 
 
 - Under **OS and Storage**, select **Change**, then choose an Arm64-based OS image. For this Learning Path, use **SUSE Linux Enterprise Server**. 
@@ -34,10 +34,10 @@ To create a virtual machine based on the C4A instance type:
 - 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:
 
-![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")
+![Google Cloud Console showing VM instances list with SSH button highlighted for connecting to the running C4A instance alt-text#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:
+- A window from your browser opens and you 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")
+   ![Browser-based SSH terminal window showing command prompt connected to the SUSE Linux VM instance alt-text#center](images/gcp-shell.png "Terminal shell in VM instance")
 
-Next, install Redis.
+You're now ready to install Redis.