Merge pull request #3122 from odidev/redis_cobalt

Deploy Redis on Azure Cobalt 100 Arm64 virtual machines for real-time messaging and event processing

Author: pareenaverma

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

@@ -0,0 +1,65 @@
+---
+title: Deploy Redis on Azure Cobalt 100 Arm64 virtual machines for real-time messaging and event processing
+
+draft: true
+cascade:
+    draft: true
+    
+minutes_to_complete: 30
+
+who_is_this_for: This is an introductory topic for developers, DevOps engineers, and platform engineers who want to build real-time messaging systems and event-driven applications using Redis on Arm-based cloud environments.
+
+learning_objectives:
+    - Install and configure Redis on Azure Cobalt 100 Arm64 virtual machines
+    - Implement real-time messaging using Redis Pub/Sub
+    - Build event-driven pipelines using Redis Streams and consumer groups
+    - Benchmark Redis performance and validate throughput and latency on Arm
+
+prerequisites:
+  - A [Microsoft Azure account](https://azure.microsoft.com/) with access to Cobalt 100 based instances (Dpsv6)
+  - Basic knowledge of Linux command-line operations
+  - Familiarity with SSH and remote server access
+  - Basic understanding of databases, caching, and messaging systems
+
+author: Pareena Verma
+
+### Tags
+skilllevels: Introductory
+subjects: Databases
+cloud_service_providers:
+  - Microsoft Azure
+
+armips:
+    - Neoverse
+
+tools_software_languages:
+    - Redis
+    - Python
+
+operatingsystems:
+    - Linux
+
+further_reading:
+  - resource:
+      title: Redis Official Website
+      link: https://redis.io
+      type: website
+  - resource:
+      title: Redis Documentation
+      link: https://redis.io/docs/
+      type: documentation
+  - resource:
+      title: Redis Streams Introduction
+      link: https://redis.io/docs/data-types/streams/
+      type: documentation
+  - resource:
+      title: Azure Cobalt 100 processors
+      link: https://techcommunity.microsoft.com/blog/azurecompute/announcing-the-preview-of-new-azure-vms-based-on-the-azure-cobalt-100-processor/4146353
+      type: documentation
+
+### FIXED, DO NOT MODIFY
+# ================================================================================
+weight: 1
+layout: "learningpathall"
+learning_path_main_page: "yes"
+---

content/learning-paths/servers-and-cloud-computing/redis-cobalt/_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-cobalt/background.md

@@ -0,0 +1,39 @@
+---
+title: "Overview of Azure Cobalt 100 and Redis"
+
+weight: 2
+
+layout: "learningpathall"
+---
+
+## Azure Cobalt 100 Arm-based processor
+
+Azure’s Cobalt 100 is Microsoft’s first-generation, in-house Arm-based processor. Built on Arm Neoverse N2, Cobalt 100 is a 64-bit CPU that delivers strong performance and energy efficiency for cloud-native, scale-out Linux workloads such as web and application servers, data analytics, open-source databases, and caching systems. Running at 3.4 GHz, Cobalt 100 allocates a dedicated physical core for each vCPU, which helps ensure consistent and predictable performance.
+
+To learn more, see the Microsoft blog [Announcing the preview of new Azure VMs based on the Azure Cobalt 100 processor](https://techcommunity.microsoft.com/blog/azurecompute/announcing-the-preview-of-new-azure-vms-based-on-the-azure-cobalt-100-processor/4146353).
+
+## Redis
+
+Redis is an open-source, in-memory data structure store used as a database, cache, and message broker. It is widely adopted for building high-performance, low-latency applications such as real-time analytics, caching layers, session stores, and event-driven systems.
+
+Redis supports multiple data structures, including strings, hashes, lists, sets, sorted sets, and streams, enabling flexible application design. Its in-memory architecture allows it to deliver sub-millisecond latency and high throughput, making it ideal for modern cloud-native workloads.
+
+To learn more, see the official [Redis documentation](https://redis.io/docs/).
+
+Redis also provides built-in support for real-time messaging and event processing through:
+
+- **Pub/Sub (Publish/Subscribe):** Enables real-time communication between producers and consumers without message persistence. It is commonly used for chat systems, notifications, and live updates.
+
+- **Redis Streams:** A persistent data structure designed for event-driven architectures. Streams allow message storage, replay, and consumer group-based processing for scalable and reliable event pipelines.
+
+- **Consumer Groups:** A feature of Redis Streams that enables distributed processing by multiple consumers, ensuring scalability and fault tolerance in production systems.
+
+Redis is commonly used in:
+
+- Real-time messaging systems  
+- Event-driven microservices architectures  
+- Data ingestion and streaming pipelines  
+- Caching and session management  
+- High-performance APIs  
+
+In this Learning Path, you'll deploy Redis on an Azure Cobalt 100 Arm64 virtual machine and build a real-time messaging and event processing system using Pub/Sub and Redis Streams. You will also benchmark Redis performance to validate its efficiency on Arm-based infrastructure.

content/learning-paths/servers-and-cloud-computing/redis-cobalt/deploy-redis-cobalt.md

@@ -0,0 +1,182 @@
+---
+title: Deploy Redis on Azure Cobalt 100
+weight: 4
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+## Deploy Redis on Azure Cobalt 100 (Arm)
+
+This section guides you through installing Redis on an Azure Cobalt 100 Arm-based virtual machine and building a real-time messaging and event processing system using Redis Pub/Sub and Streams.
+
+You will implement low-latency messaging and event-driven pipelines optimized for Arm-based infrastructure.
+
+## Update your system
+
+Update your operating system packages to the latest versions:
+
+```console
+sudo apt update && sudo apt upgrade -y
+```
+
+## Install required dependencies
+
+Install build tools and utilities required to compile and run Redis:
+
+```bash
+sudo apt install -y build-essential tcl git curl python3-pip
+```
+
+## Download and install Redis
+
+Download the latest Redis source code and compile it:
+
+```bash
+cd /tmp
+curl -O http://download.redis.io/redis-stable.tar.gz
+tar xzf redis-stable.tar.gz
+cd redis-stable
+make -j$(nproc)
+```
+
+(Optional) Run tests to validate the build:
+
+```bash
+make test
+```
+
+## Start the Redis server
+
+Start the Redis server in a new terminal.
+
+**Terminal 1:**
+
+```bash
+cd /tmp/redis-stable
+src/redis-server
+```
+
+The output shows Redis starting successfully and listening on port 6379.
+
+## Verify Redis is running
+
+Open another terminal and connect using the Redis CLI.
+
+**Terminal 2:**
+
+```bash
+cd /tmp/redis-stable
+src/redis-cli
+PING
+```
+
+The output is similar to:
+```output
+127.0.0.1:6379> ping
+PONG
+```
+
+This confirms that Redis is running and accepting connections.
+
+## Implement real-time messaging using Pub/Sub
+
+Redis Pub/Sub enables real-time communication between producers and consumers.
+
+**Terminal 2 (Subscriber):**
+
+```bash
+SUBSCRIBE chat_channel
+```
+
+The output is similar to:
+
+```output
+127.0.0.1:6379> SUBSCRIBE chat_channel
+1) "subscribe"
+2) "chat_channel"
+3) (integer) 1
+1) "message"
+2) "chat_channel"
+```
+
+**Terminal 3 (Publisher):**
+
+```bash
+cd /tmp/redis-stable
+src/redis-cli
+PUBLISH chat_channel "Hello from Cobalt Arm!"
+```
+
+After publishing the message, switch back to the subscriber terminal.
+
+The output is similar to:
+
+```output
+1) "subscribe"
+2) "chat_channel"
+3) (integer) 1
+1) "message"
+2) "chat_channel"
+3) "Hello from Cobalt Arm!"
+```
+
+This demonstrates real-time message delivery.
+
+## Build an event pipeline using Redis Streams
+
+Redis Streams provide persistent messaging with replay capability.
+
+**Terminal 3 (Producer):**
+
+```bash
+XADD mystream * user jack action login
+XADD mystream * user yan action purchase
+```
+
+The output is similar to:
+```output
+127.0.0.1:6379> XADD mystream * user jack action login
+"1774931844279-0"
+127.0.0.1:6379> XADD mystream * user yan action purchase
+"1774931858864-0"
+```
+
+**Terminal 2 (Consumer):**
+
+```bash
+XREAD COUNT 2 STREAMS mystream 0
+```
+
+The output is similar to:
+```output
+1) 1) "mystream"
+   2) 1) 1) "1774931844279-0"
+         2) 1) "user"
+            2) "jack"
+            3) "action"
+            4) "login"
+      2) 1) "1774931858864-0"
+         2) 1) "user"
+            2) "yan"
+            3) "action"
+            4) "purchase"
+```
+
+This confirms that events are stored and can be read reliably.
+
+## Key differences between Pub/Sub and Streams
+
+- Pub/Sub delivers messages in real time but does not store them
+- Streams persist messages and allow replay
+- Streams support consumer groups for scalability
+
+## What you've learned and what's next
+You have successfully:
+
+- Installed Redis on an Arm-based Cobalt 100 VM
+- Verified Redis connectivity
+- Implemented real-time messaging using Pub/Sub
+- Built an event-driven pipeline using Redis Streams
+
+You are now ready to extend this setup with consumer groups, application integration, and performance benchmarking.

content/learning-paths/servers-and-cloud-computing/redis-cobalt/images/final-vm.png

@@ -0,0 +1,72 @@
+---
+title: Create an Azure Cobalt 100 Arm64 virtual machine
+weight: 3
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+## Prerequisites and setup
+
+There are several common ways to create an Arm-based Cobalt 100 virtual machine, and you can choose the method that best fits your workflow or requirements:
+
+- The Azure Portal
+- The Azure CLI
+- An infrastructure as code (IaC) tool
+
+In this section, you'll launch the Azure Portal to create a virtual machine with the Arm-based Azure Cobalt 100 processor.
+
+This Learning Path focuses on general-purpose virtual machines in the Dpsv6 series. For more information, see the [Microsoft Azure guide for the Dpsv6 size series](https://learn.microsoft.com/en-us/azure/virtual-machines/sizes/general-purpose/dpsv6-series).
+
+While the steps to create this instance are included here for convenience, you can also refer to the [Deploy a Cobalt 100 virtual machine on Azure Learning Path](/learning-paths/servers-and-cloud-computing/cobalt/).
+
+## Create an Arm-based Azure virtual machine
+
+Creating a virtual machine based on Azure Cobalt 100 is no different from creating any other virtual machine in Azure. To create an Azure virtual machine:
+
+- Launch the Azure portal and navigate to **Virtual Machines**.
+- Select **Create**, and select **Virtual Machine** from the drop-down list.
+- Inside the **Basic** tab, fill in the instance details such as **Virtual machine name** and **Region**.
+- Select the image for your virtual machine (for example, Ubuntu Pro 24.04 LTS) and select **Arm64** as the VM architecture.
+- In the **Size** field, select **See all sizes** and select the D-Series v6 family of virtual machines.
+- Select **D4ps_v6** from the list as shown in the diagram below:
+
+![Azure Portal showing D-Series v6 VM size selection with D4ps_v6 highlighted alt-txt#center](images/instance.png "Select D4ps_v6 from the D-Series v6 family")
+
+- For **Authentication type**, select **SSH public key**.
+
+{{% notice Note %}}
+Azure generates an SSH key pair for you and lets you save it for future use. This method is fast, secure, and easy for connecting to your virtual machine.
+{{% /notice %}}
+
+- Fill in the **Administrator username** for your VM.
+- Select **Generate new key pair**, and select **RSA SSH Format** as the SSH Key Type.
+
+{{% notice Note %}}
+RSA offers better security with keys longer than 3072 bits.
+{{% /notice %}}
+
+- Give your SSH key a key pair name.
+- In the **Inbound port rules**, select **HTTP (80)** and **SSH (22)** as the inbound ports, as shown below:
+
+![Azure Portal showing inbound port rules with HTTP (80) and SSH (22) selected alt-txt#center](images/instance1.png "Configure inbound port rules for HTTP and SSH access")
+
+- Now select the **Review + Create** tab and review the configuration for your virtual machine. It should look like the following:
+
+![Azure Portal Review + Create tab showing VM configuration summary ready for deployment alt-txt#center](images/ubuntu-pro.png "Review VM configuration before creation")
+
+- When you're happy with your selection, select the **Create** button and then **Download Private key and Create Resource** button.
+
+![Azure Portal showing Create button and SSH key download dialog alt-txt#center](images/instance4.png "Download SSH key and create the virtual machine")
+
+Your virtual machine should be ready and running in a few minutes. You can SSH into the virtual machine using the private key, along with the public IP details.
+
+![Azure Portal showing successful VM deployment with confirmation details alt-txt#center](images/final-vm.png "Successful VM deployment confirmation")
+
+{{% notice Note %}}To learn more about Arm-based virtual machines in Azure, see "Getting Started with Microsoft Azure" in [Get started with Arm-based cloud instances](/learning-paths/servers-and-cloud-computing/csp/azure/).{{% /notice %}}
+
+## What you've learned and what's next
+
+You've created an Azure Cobalt 100 Arm64 virtual machine running Ubuntu 24.04 LTS with SSH authentication configured. The virtual machine is now ready for installing and running Redis workloads.
+
+Next, you'll install Redis on the VM and begin building a real-time messaging and event processing system using Pub/Sub and Redis Streams.