ArmDeveloperEcosystem · odidev · Dec 18, 2025
diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/_index.md b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/_index.md
@@ -1,21 +1,20 @@
 ---
-title: Deploy RabbitMQ on Google Cloud C4A (Arm-based Axion VMs)
-
-draft: true
-cascade:
-    draft: true
+title: Deploy RabbitMQ on Arm64 Cloud Platforms (Azure & GCP)
 
 minutes_to_complete: 30
 
-who_is_this_for: This is an introductory topic for software engineers and platform engineers migrating messaging and event-driven workloads from x86_64 to Arm-based servers, specifically on Google Cloud C4A virtual machines powered by Axion processors.
+who_is_this_for: This is an introductory topic for software engineers and platform engineers migrating messaging and event-driven workloads from x86_64 to Arm-based servers, specifically on Microsoft Azure Cobalt 100 Arm processors and Google Cloud C4A virtual machines powered by Axion processors. 
 
 learning_objectives:
+  - Provision Arm-based Linux virtual machines on Google Cloud (C4A with Axion processors) and Microsoft Azure (Cobalt 100)
   - Provision an Arm-based SUSE SLES virtual machine on Google Cloud (C4A with Axion processors)
-  - Install and configure RabbitMQ on a SUSE Arm64 (C4A) instance
-  - Validate RabbitMQ deployment using baseline messaging tests
-  - Implement real-world RabbitMQ use cases such as event-driven processing and notification pipelines
+  - Install and configure RabbitMQ on Arm64 Linux (SUSE SLES on GCP and Ubuntu Pro 24.04 on Azure)
+  - Build and configure required Erlang versions for RabbitMQ on Arm64
+  - Validate RabbitMQ deployments using baseline messaging and connectivity tests
+  - Implement practical RabbitMQ use cases such as event-driven processing and notification pipelines on Arm-based infrastructure
 
 prerequisites:
+  - A [Microsoft Azure](https://azure.microsoft.com/) account with access to Cobalt 100-based instances (Dpsv6).
   - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled
   - Basic understanding of message queues and messaging concepts (publishers, consumers)
   - Familiarity with Linux command-line operations
@@ -25,7 +24,6 @@ author: Pareena Verma
 ##### Tags
 skilllevels: Introductory
 subjects: Databases
-cloud_service_providers: Google Cloud
 
 armips:
   - Neoverse
@@ -48,6 +46,11 @@ further_reading:
       link: https://cloud.google.com/docs
       type: documentation
 
+  - resource:
+      title: Azure Virtual Machines documentation
+      link: https://learn.microsoft.com/azure/virtual-machines/
+      type: documentation    
+
   - resource:
       title: RabbitMQ documentation
       link: https://www.rabbitmq.com/documentation.html 

diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/azure_baseline.md b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/azure_baseline.md
@@ -0,0 +1,141 @@
+---
+title: RabbitMQ Baseline Testing
+weight: 5
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+## Run a Baseline Test With RabbitMQ 
+This section validates a working **RabbitMQ 4.2.0** installation with **Erlang OTP 26** on an **Azure Ubuntu Arm64 VM**.  
+
+All steps are **CLI-only** and suitable for baseline verification.
+
+### Verify RabbitMQ Service Status
+
+```console
+sudo systemctl status rabbitmq
+```
+
+### Verify Erlang Version
+RabbitMQ depends on Erlang. This step ensures the broker is using Erlang OTP 26.
+
+```console
+erl -eval 'io:format("~s~n", [erlang:system_info(system_version)]), halt().' -noshell
+```
+
+### Verify RabbitMQ Version
+Confirm the installed RabbitMQ version.
+
+```console
+rabbitmqctl version
+```
+
+### Verify Enabled Plugins
+List all enabled plugins and confirm that the management plugins are active.
+
+```console
+rabbitmq-plugins list -e
+```
+
+```output
+Listing plugins with pattern ".*" ...
+ Configured: E = explicitly enabled; e = implicitly enabled
+ | Status: * = running on rabbit@lpprojectubuntuarm64
+ |/
+[E*] rabbitmq_management       4.2.0
+[e*] rabbitmq_management_agent 4.2.0
+[e*] rabbitmq_web_dispatch     4.2.0
+````
+
+This confirms that:
+
+- The management UI is enabled
+- Required supporting plugins are running
+
+### Check RabbitMQ Node Health
+Retrieve detailed runtime and resource information for the RabbitMQ node.
+
+```console
+rabbitmqctl status
+```
+This confirms that:
+
+- Node is running
+- No alarms are reported
+- Erlang version matches OTP 26
+
+### Ensure RabbitMQ Configuration Directory Permissions
+RabbitMQ requires write access to its configuration directory for plugin management.
+
+```console
+sudo mkdir -p /opt/rabbitmq/etc/rabbitmq
+sudo chown -R azureuser:azureuser /opt/rabbitmq/etc/rabbitmq
+```
+
+### Create a Baseline Test Virtual Host
+Create an isolated virtual host for baseline testing.
+
+```console
+rabbitmqctl add_vhost test_vhost
+rabbitmqctl set_permissions -p test_vhost guest ".*" ".*" ".*"
+```
+
+This ensures:
+
+- Tests do not interfere with default workloads
+- Full permissions are available for validation
+
+### Download RabbitMQ Admin CLI
+Download the `rabbitmqadmin` CLI tool from the management endpoint.
+
+```console
+wget http://localhost:15672/cli/rabbitmqadmin -O ~/rabbitmqadmin
+chmod +x ~/rabbitmqadmin
+```
+
+This CLI is used to perform queue and message operations.
+
+### Declare a Test Queue
+Create a non-durable test queue in the test virtual host.
+
+```console
+~/rabbitmqadmin -V test_vhost declare queue name=test durable=false
+```
+
+### Publish a Test Message
+Publish a sample message to the test queue using the default exchange.
+
+```console
+~/rabbitmqadmin -V test_vhost publish \
+  exchange=amq.default \
+  routing_key=test \
+  payload="Hello RabbitMQ"
+```
+
+This validates:
+
+- Message routing
+- Exchange-to-queue binding behavior
+
+### Consume The Test Message
+Retrieve and remove the message from the queue.
+
+```console
+~/rabbitmqadmin -V test_vhost get queue=test count=1
+```
+
+You should see an output similar to:
+
+```output
++-------------+----------+---------------+----------------+---------------+------------------+------------+-------------+
+| routing_key | exchange | message_count |    payload     | payload_bytes | payload_encoding | properties | redelivered |
++-------------+----------+---------------+----------------+---------------+------------------+------------+-------------+
+| test        |          | 0             | Hello RabbitMQ | 14            | string           |            | False       |
++-------------+----------+---------------+----------------+---------------+------------------+------------+-------------+
+```
+
+- Message payload: Hello RabbitMQ
+- Queue becomes empty after consumption
+
+This baseline validates a healthy RabbitMQ 4.2.0 deployment running on Erlang/OTP 26 on an Azure Ubuntu Arm64 VM. Core components, plugins, and node health were verified, followed by successful message publish and consume operations.
diff --git a/...t/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/azure_installation.md b/...t/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/azure_installation.md
@@ -0,0 +1,155 @@
+---
+title: Install RabbitMQ on Microsoft Azure Cobalt 100
+weight: 4
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+## Install RabbitMQ on Azure Cobalt 100
+This guide describes the end-to-end installation of RabbitMQ 4.2.0 on an Azure Cobalt 100 (Arm-based) Ubuntu Pro 24.04 virtual machine. It covers system preparation, Erlang installation, RabbitMQ setup, service configuration, and validation with the management plugin enabled.
+
+### Update system and install build dependencies
+This step ensures the operating system is up to date and installs all required packages needed to build Erlang and run RabbitMQ reliably.
+
+```console
+sudo apt update
+sudo apt install -y build-essential libssl-dev libncurses-dev libtinfo-dev \
+                    libgl1-mesa-dev libglu1-mesa-dev libpng-dev libssh-dev \
+                    unixodbc-dev wget tar xz-utils git
+```
+
+### Build and install Erlang OTP 26
+RabbitMQ 4.2.0 requires Erlang OTP 26. This section builds Erlang from source to ensure full compatibility on Arm64.
+
+```console
+# Clone Erlang source
+git clone https://github.com/erlang/otp.git
+cd otp
+
+# Checkout OTP 26 branch
+git checkout OTP-26
+
+# Clean previous builds
+make clean
+
+# Configure build with SSL/crypto support
+./configure --prefix=/usr/local/erlang-26 \
+            --enable-smp-support \
+            --enable-threads \
+            --enable-kernel-poll \
+            --with-ssl
+
+# Build and install
+make -j$(nproc)
+sudo make install
+```
+### Make Erlang PATH persistent (IMPORTANT)
+This step ensures the Erlang binaries are permanently available in the system PATH across sessions and reboots.
+
+```console
+echo 'export ERLANG_HOME=/usr/local/erlang-26' | sudo tee /etc/profile.d/erlang.sh
+echo 'export PATH=$ERLANG_HOME/bin:$PATH' | sudo tee -a /etc/profile.d/erlang.sh
+```
+
+### Download and install RabbitMQ
+This section downloads the official RabbitMQ 4.2.0 generic Unix distribution and installs it under `/opt/rabbitmq`.
+
+```console
+cd ~
+wget https://github.com/rabbitmq/rabbitmq-server/releases/download/v4.2.0/rabbitmq-server-generic-unix-4.2.0.tar.xz
+sudo mkdir -p /opt/rabbitmq
+sudo tar -xvf rabbitmq-server-generic-unix-4.2.0.tar.xz -C /opt/rabbitmq --strip-components=1
+
+# Create directories for logs and database
+sudo mkdir -p /var/lib/rabbitmq /var/log/rabbitmq
+sudo chown -R $USER:$USER /var/lib/rabbitmq /var/log/rabbitmq
+```
+
+#### Update PATH environment variable
+This step makes RabbitMQ CLI tools available in the current shell and should be persisted for future sessions.
+
+```console
+export PATH=/usr/local/erlang-26/bin:/opt/rabbitmq/sbin:$PATH
+```
+
+Add this line to `~/.bashrc` or `~/.profile` for persistence.
+
+### Configure RabbitMQ systemd service
+This section configures RabbitMQ to run as a managed systemd service, enabling automatic startup and controlled lifecycle management.
+
+Create `/etc/systemd/system/rabbitmq.service`:
+
+```ini
+[Unit]
+Description=RabbitMQ broker
+After=network.target
+
+[Service]
+Type=simple
+User=azureuser
+Group=azureuser
+
+Environment=HOME=/home/azureuser
+Environment=RABBITMQ_HOME=/opt/rabbitmq
+Environment=RABBITMQ_MNESIA_BASE=/var/lib/rabbitmq
+Environment=RABBITMQ_LOG_BASE=/var/log/rabbitmq
+Environment=PATH=/usr/local/erlang-26/bin:/opt/rabbitmq/sbin:/usr/bin
+
+ExecStart=/opt/rabbitmq/sbin/rabbitmq-server
+ExecStop=/opt/rabbitmq/sbin/rabbitmqctl shutdown
+
+Restart=on-failure
+RestartSec=10
+LimitNOFILE=65536
+
+[Install]
+WantedBy=multi-user.target
+```
+
+Reload systemd and start RabbitMQ:
+
+```console
+sudo systemctl daemon-reload
+sudo systemctl enable rabbitmq
+sudo systemctl start rabbitmq
+sudo systemctl status rabbitmq
+```
+
+### Enable RabbitMQ management plugin
+This step enables the RabbitMQ management plugin, which provides a web-based UI and HTTP API for monitoring and administration.
+
+```console
+# Ensure config directory exists
+sudo mkdir -p /opt/rabbitmq/etc/rabbitmq
+sudo chown -R $USER:$USER /opt/rabbitmq/etc/rabbitmq
+
+# Enable management plugin
+rabbitmq-plugins enable rabbitmq_management
+```
+
+### Verify installation
+This section validates that both Erlang and RabbitMQ are installed correctly and running with the expected versions.
+
+**Erlang version:**
+
+```console
+erl -eval 'io:format("~s~n", [erlang:system_info(system_version)]), halt().' -noshell
+```
+
+You should see an output similar to:
+```output
+Erlang/OTP 26 [erts-14.2.5.12] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1] [jit]
+```
+
+**Verify RabbitMQ version:**
+
+```console
+rabbitmqctl version
+```
+
+You should see an output similar to:
+```output
+4.2.0
+```
+RabbitMQ 4.2.0 is successfully installed on an Azure Cobalt 100 Ubuntu Pro 24.04 Arm64 VM with systemd management, persistent storage, logging, and the management plugin enabled.
diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/azure_instance.md b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/azure_instance.md
@@ -0,0 +1,50 @@
+---
+title: Create an Arm based cloud virtual machine using Microsoft Cobalt 100 CPU 
+weight: 3
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+## Introduction
+
+There are several ways to create an Arm-based Cobalt 100 virtual machine: the Microsoft Azure console, the Azure CLI tool, or using your choice of IaC (Infrastructure as Code). This guide will use the Azure console to create a virtual machine with Arm-based Cobalt 100 Processor. 
+
+This learning path focuses on the general-purpose virtual machine of the D series. Please read the guide on [Dpsv6 size series](https://learn.microsoft.com/en-us/azure/virtual-machines/sizes/general-purpose/dpsv6-series) offered by Microsoft Azure.  
+
+If you have never used the Microsoft Cloud Platform before, please review the microsoft [guide to Create a Linux virtual machine in the Azure portal](https://learn.microsoft.com/en-us/azure/virtual-machines/linux/quick-create-portal?tabs=ubuntu). 
+
+#### 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".
+1. Select "Create", and click on "Virtual Machine" from the drop-down list.
+2. Inside the "Basic" tab, fill in the Instance details such as "Virtual machine name" and "Region".
+3. Choose the image for your virtual machine (for example, Ubuntu Pro 24.04 LTS) and select “Arm64” as the VM architecture.
+4. In the “Size” field, click on “See all sizes” and select the D-Series v6 family of virtual machines. Select “D4ps_v6” from the list.
+
+![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/instance.png "Figure 1: Select the D-Series v6 family of virtual machines")
+
+5. Select "SSH public key" as an Authentication type. Azure will automatically generate an SSH key pair for you and allow you to store it for future use. It is a fast, simple, and secure way to connect to your virtual machine.
+6. Fill in the Administrator username for your VM.
+7. Select "Generate new key pair", and select "RSA SSH Format" as the SSH Key Type. RSA could offer better security with keys longer than 3072 bits. Give a Key pair name to your SSH key.
+8. In the "Inbound port rules", select HTTP (80) and SSH (22) as the inbound ports.
+
+![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/instance1.png "Figure 2: Allow inbound port rules")
+
+9. Click on the "Review + Create" tab and review the configuration for your virtual machine. It should look like the following:
+
+![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/ubuntu-pro.png "Figure 3: Review and Create an Azure Cobalt 100 Arm64 VM")
+
+10. Finally, when you are confident about your selection, click on the "Create" button, and click on the "Download Private Key and Create Resources" button.
+
+![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/instance4.png "Figure 4: Download Private key and Create Resources")
+
+11. Your virtual machine should be ready and running within no time. You can SSH into the virtual machine using the private key, along with the Public IP details.
+
+![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/final-vm.png "Figure 5: VM deployment confirmation in Azure portal")
+
+{{% notice Note %}}
+
+To learn more about Arm-based virtual machines in Azure, refer to “Getting Started with Microsoft Azure” in [Get started with Arm-based cloud instances](/learning-paths/servers-and-cloud-computing/csp/azure).
+
+{{% /notice %}}