Deploy Redis for data searching on Google Cloud C4A (Arm-based Axion VMs)

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

@@ -0,0 +1,57 @@
+---
+title: Deploy Redis for data searching on Google Cloud C4A (Arm-based Axion VMs)
+
+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.
+
+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)
+
+prerequisites:
+  - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled
+  - Basic familiarity with [Redis](https://redis.io/) 
+
+author: Pareena Verma
+
+##### Tags
+skilllevels: Introductory
+subjects: Databases
+cloud_service_providers: Google Cloud
+
+armips:
+  - Neoverse
+
+tools_software_languages:
+  - Redis
+  - redis-benchmark
+
+operatingsystems:
+  - Linux
+
+# ================================================================================
+#       FIXED, DO NOT MODIFY
+# ================================================================================
+further_reading:
+  - resource:
+      title: Google Cloud documentation
+      link: https://cloud.google.com/docs
+      type: documentation
+
+  - resource:
+      title: Redis documentation
+      link: https://redis.io/docs/
+      type: documentation
+
+  - resource:
+      title: Redis benchmark documentation
+      link: https://redis.io/docs/latest/operate/oss_and_stack/management/optimization/benchmarks/
+      type: documentation
+
+weight: 1
+layout: "learningpathall"
+learning_path_main_page: "yes"
+---

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

@@ -0,0 +1,8 @@
+---
+# ================================================================================
+#       FIXED, DO NOT MODIFY THIS FILE
+# ================================================================================
+weight: 21                  # Set to always be larger than the content in this path to be at the end of the navigation.
+title: "Next Steps"         # Always the same, html page title.
+layout: "learningpathall"   # All files under learning paths have this same wrapper for Hugo processing.
+---

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

@@ -0,0 +1,25 @@
+---
+title: Getting started with Redis on Google Axion C4A (Arm Neoverse-V2)
+
+weight: 2
+
+layout: "learningpathall"
+---
+
+## 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.
+
+## 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 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**.
+
+To learn more, visit the [Redis official website](https://redis.io/) and explore the [documentation](https://redis.io/docs/latest/).

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

@@ -0,0 +1,164 @@
+---
+title: Redis Baseline Testing on Google Axion C4A Arm Virtual Machine
+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.
+
+### 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:
+
+```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:
+
+```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.
+
+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.
+
+**Verify Data Storage Count:**
+
+The `DBSIZE` command returns the total number of keys currently stored in the Redis database.
+
+```console
+redis-cli DBSIZE
+```
+
+```output
+(integer) 10000
+```
+Seeing `(integer) 10000` confirms that all key-value pairs were inserted successfully.
+
+**Verify Sample Data Retrieval**
+
+Fetch one of the inserted keys to confirm data correctness:
+
+```console
+redis-cli GET key:5000
+```
+- The `GET` command retrieves the value of a given key.  
+- If Redis returns `"value-5000"`, it confirms that data insertion worked properly and the database is responding as expected.
+
+You should see an output similar to:
+
+```output
+"value-5000"
+```
+
+### 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:
+
+```console
+redis-cli GET key:1234
+```
+
+You should see an output similar to:
+
+```output
+"value-1234"
+```
+This confirms that Redis is storing and retrieving data correctly from memory.
+
+### 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:
+
+```output
+   1) "key:1392"
+   2) "key:1076"
+   3) "key:1683"
+   4) "key:1490"
+   5) "key:117"
+   6) "key:1293"
+   7) "key:1791"
+   8) "key:1891"
+   9) "key:1543"
+..........
+```
+
+### Production-Safe Searching with SCAN
+This step introduces a production-friendly method for iterating through keys without blocking Redis operations.
+
+Use the `SCAN` command for larger datasets — it is non-blocking and iterates safely.
+
+```console
+redis-cli SCAN 0 MATCH "key:1*" COUNT 100
+```
+
+You should see an output similar to:
+
+```output
+1) "9792"
+2) 1) "key:151"
+   2) "key:1845"
+   3) "key:1397"
+   4) "key:1501"
+   5) "key:1994"
+   6) "key:1475"
+   7) "key:1522"
+   8) "key:1884"
+```
+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.
+
+**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`.
+
+```console
+(time redis-cli GET key:9000) 2>&1
+```
+
+This command measures three time metrics:
+
+- **real** – Total elapsed time (wall-clock time)  
+- **user** – Time spent in user mode  
+- **sys** – Time spent in kernel mode
+
+You should see an output similar to:
+
+```output
+"value-9000"
+
+real    0m0.002s
+user    0m0.002s
+sys     0m0.000s
+```
+These results show that Redis retrieves data almost instantly (in milliseconds or microseconds), confirming that the instance is performing efficiently under baseline conditions.