Updare RabbitMQ GCP and Azure content based on testing and feedback

Author: madeline-underwood

content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/azure_baseline.md

@@ -1,17 +1,17 @@
 ---
-title: RabbitMQ Baseline Testing
+title: Validate RabbitMQ on Azure
 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**.  
+## Run a baseline test with RabbitMQ
+This section shows you how to validate 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.
+All steps use the command line and are suitable for baseline verification.
 
-### Verify RabbitMQ Service Status
+## Verify RabbitMQ service status
 
 ```console
 sudo systemctl status rabbitmq

content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/azure_installation.md

@@ -1,5 +1,5 @@
 ---
-title: Install RabbitMQ on Microsoft Azure Cobalt 100
+title: Install RabbitMQ on Azure Cobalt 100
 weight: 4
 
 ### FIXED, DO NOT MODIFY
@@ -53,7 +53,8 @@ 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`.
+
+Download the official RabbitMQ 4.2.0 generic Unix distribution and install it under `/opt/rabbitmq`.
 
 ```console
 cd ~
@@ -66,17 +67,19 @@ 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.
+## Update PATH environment variable
+
+Make RabbitMQ CLI tools available in the current shell. Add this to `~/.bashrc` or `~/.profile` for persistence across 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.
+## Configure RabbitMQ systemd service
+
+Configure RabbitMQ to run as a managed systemd service, enabling automatic startup and controlled lifecycle management.
 
 Create `/etc/systemd/system/rabbitmq.service`:
 

content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/azure_instance.md

@@ -39,7 +39,7 @@ Creating a virtual machine based on Azure Cobalt 100 is no different from creati
 
 ![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.
+Your virtual machine deploys within a few minutes. SSH into the virtual machine using the downloaded private key and the public IP address.
 
 ![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")
 

content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_instance.md

@@ -1,5 +1,5 @@
 ---
-title: Create a Google Axion C4A Arm virtual machine on GCP 
+title: Create a Google Axion C4A virtual machine
 weight: 7
 
 ### FIXED, DO NOT MODIFY
@@ -8,8 +8,7 @@ layout: learningpathall
 
 ## Overview
 
-In this section, you 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.  
-We will then use this GCP VM to execute a few RabbitMQ use cases.
+In this section, you'll 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. You will then use this GCP VM to execute a few RabbitMQ use cases.
 
 {{% notice Note %}}
 For support on GCP setup, see the Learning Path [Getting started with Google Cloud Platform](/learning-paths/servers-and-cloud-computing/csp/google/).
@@ -23,18 +22,16 @@ Under **Machine configuration**, populate fields such as **Instance name**, **Re
 
    ![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")
 
-Under **OS and Storage**, select **Change**, then choose an Arm64-based OS image. For this Learning Path, use **SUSE Linux Enterprise Server**. Select "Pay As You Go" for the license type and press **Select**.
+Under **OS and Storage**, select **Change**, then choose an Arm64-based OS image. For this Learning Path, use **SUSE Linux Enterprise Server**. Select **Pay As You Go** for the license type and select **Select**.
 
 Under **Networking**, enable **Allow HTTP traffic** and add "allow-tcp-15672" as a network tag in the **Network tags** text field.
 
 ![Adding the TCP/15672 firewall rule to the VM](images/network-config.png "Adding the TCP/15672 firewall rule to the VM")
 
-Select **Create** to launch the instance. Once created, you see an **SSH** option and the public IP address for your VM in the list of VM instances. Save the public IP address as you need it in the next step. Select the **SSH** option to launch an SSH shell into your VM instance.
+Select **Create** to launch the instance. After the instance is created, the **SSH** option and public IP address appear in the VM instances list. Save the public IP address for later use. Select the **SSH** option to open an SSH shell to your VM instance.
 
 ![Invoke an SSH session via your browser alt-text#center](images/gcp-pubip-ssh.png "Invoke an SSH session into your running VM instance")
 
-A window opens from your browser and you see a shell into your VM instance.
+A browser window opens with a shell session to your VM instance.
 
 ![Terminal Shell in your VM instance alt-text#center](images/gcp-shell.png "Terminal shell in your VM instance")
-
-Next, install RabbitMQ.

content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_use_case1.md

@@ -1,5 +1,5 @@
 ---
-title: RabbitMQ Use Case 1 – Event Processing with Python Workers
+title: Implement event processing with Python workers
 weight: 10
 
 ### FIXED, DO NOT MODIFY

content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_use_case2.md

@@ -6,25 +6,25 @@ weight: 11
 layout: learningpathall
 ---
 
+## Overview
 
-## WhatsApp Notification Use Case using RabbitMQ  
-This document demonstrates a **real-world asynchronous messaging use case** where RabbitMQ is used to process WhatsApp notifications reliably using a worker-based architecture.
+In this section you'll implement a real-world asynchronous messaging pattern where RabbitMQ processes WhatsApp notifications reliably using a worker-based architecture.
 
-### Use case overview
+## Why use RabbitMQ for WhatsApp notification
 
-In many production systems, sending WhatsApp notifications must be:
+In production systems, sending WhatsApp notifications must be:
 - Reliable
 - Asynchronous
 - Independent of the main application flow
 
-RabbitMQ is used as a **message broker** to decouple message production from message consumption.
+RabbitMQ acts as a message broker to decouple message production from message consumption.
 
-### Architecture flow
+The architecture follows this flow:
 
-1. Application publishes a message to RabbitMQ
-2. RabbitMQ routes the message to a queue
-3. A Python worker consumes the message
-4. The worker simulates sending a WhatsApp notification
+- Application publishes a message to RabbitMQ
+- RabbitMQ routes the message to a queue
+- A Python worker consumes the message
+- The worker simulates sending a WhatsApp notification
 
 ### Prerequisites
 
@@ -34,34 +34,35 @@ RabbitMQ is used as a **message broker** to decouple message production from mes
 - Python 3.8+
 - `pika` Python client library installed
 
-### Install Python dependencies
-Installs Python and the RabbitMQ Python client needed to build a consumer.
+## Install Python dependencies
+
+Install Python and the RabbitMQ Python client needed to build a consumer.
 
 ```console
 sudo zypper install -y python3 python3-pip
 pip3 install pika
 ```
 
-### RabbitMQ topology
+## Understand the RabbitMQ topology
+
 This use case uses a direct exchange topology for exact-match routing.
 
-**Exchanges**
-- **notifications (direct):** Routes WhatsApp notification messages based on an exact routing key match.
+**Exchanges:**
+- `notifications` (direct): Routes WhatsApp notification messages based on an exact routing key match.
+
+**Queue:**
+- `whatsapp.notifications` (durable): Stores WhatsApp messages persistently until they are consumed by a worker.
 
-**Queue**
-- **whatsapp.notifications (durable):** Stores WhatsApp messages persistently until they are consumed by a worker.
+**Binding:**
+- Exchange: `notifications`
+- Routing key: `whatsapp` 
+- Queue: `whatsapp.notifications`
 
-**Binding**
-- Exchange: **notifications** – Connects the exchange to the WhatsApp notification queue.
-- Routing key: **whatsapp** – Ensures only WhatsApp-related messages are routed.
-- Queue: **whatsapp.notifications**– Final destination where messages are delivered for processing.
+This ensures only WhatsApp-related messages are routed to the final destination for processing.
 
-### Declare RabbitMQ resources
-Creates the required exchange, queue, and binding for WhatsApp notifications.
+## Declare RabbitMQ resources
 
-- `Declare exchange`: Creates a durable direct exchange named notifications to route messages using exact routing keys.
-- `Declare queue`: Creates a durable queue whatsapp.notifications to persist WhatsApp notification messages until consumed.
-- `Declare binding`: Links the notifications exchange to the whatsapp.notifications queue using the whatsapp routing key.
+Create the required exchange, queue, and binding for WhatsApp notifications.
 
 ```console
 ./rabbitmqadmin declare exchange \
@@ -78,11 +79,12 @@ Creates the required exchange, queue, and binding for WhatsApp notifications.
   destination=whatsapp.notifications \
   routing_key=whatsapp
 ```
-Each command confirms successful creation with messages like **exchange declared, queue declared, and binding declared**.
 
-**Validate the setup:**
+Each command confirms successful creation.
 
-Validates that RabbitMQ resources exist and are correctly connected.
+## Validate the setup
+
+Verify that RabbitMQ resources exist and are correctly connected.
 
 ```console
 ./rabbitmqadmin list queues name messages
@@ -94,14 +96,14 @@ Validates that RabbitMQ resources exist and are correctly connected.
 - `list exchanges` lists all exchanges and their types, allowing verification of correct exchange configuration.
 - `list bindings` shows how exchanges, queues, and routing keys are connected.
 
-**Output shows:**
+The output shows you the following:
 
-- notifications exchange of type direct
-- whatsapp.notifications durable queue
-- Correct routing key binding (whatsapp)
+- `notifications` exchange of type direct
+- `whatsapp.notifications` durable queue
+- Correct routing key binding (`whatsapp`)
 - Zero or more queued messages
 
-Confirms topology correctness before consuming messages.
+This confirms topology correctness before consuming messages.
 
 ```output
 > ./rabbitmqadmin list queues name messages
@@ -142,12 +144,11 @@ Confirms topology correctness before consuming messages.
 +---------------+------------------------+------------------------+
 ```
 
-### WhatsApp worker implementation
-The worker attaches as a **blocking consumer** to the `whatsapp.notifications` queue and processes incoming messages.
+## Implement the WhatsApp worker
 
-Create a `whatsapp_worker.py` file with the content below:
+Create a Python consumer (worker) that processes WhatsApp notification messages from the queue.
 
-This Python script implements a **RabbitMQ consumer (worker)** that processes WhatsApp notification messages from a queue in a reliable and controlled manner.
+Create a file named `whatsapp_worker.py` with the following code:
 
 ```python
 import pika
@@ -202,16 +203,17 @@ print("[DEBUG] Starting consumer loop (this should block)...")
 channel.start_consuming()
 ```
 
-### Start the worker
+## Start the worker
+
 Run the worker in a dedicated terminal session:
 
 ```console
 python3 whatsapp_worker.py
 ```
 
-The worker is running correctly and waiting for messages without exiting.
+The worker runs correctly and waits for messages without exiting.
 
-**output:**
+The output is similar to:
 
 ```output
 [DEBUG] Connecting to RabbitMQ...
@@ -221,10 +223,11 @@ WhatsApp Worker started. Waiting for messages...
 [DEBUG] Starting consumer loop (this should block)...
 ```
 
-The process must block without returning to the shell prompt.
+The process blocks without returning to the shell prompt.
+
+## Publish a test message
 
-### Publish a test message
-From another SSH terminal: Publishes a WhatsApp notification message to RabbitMQ.
+Open another SSH terminal and publish a WhatsApp notification message to RabbitMQ.
 
 ```console
 ./rabbitmqadmin publish \
@@ -233,16 +236,17 @@ From another SSH terminal: Publishes a WhatsApp notification message to RabbitMQ
   payload='{"phone":"+911234567890","message":"Hello from RabbitMQ"}'
 ```
 
-You should see the following output from whatsapp_worker.py that is running in the first SSH terminal:
+The output appears in the first terminal running `whatsapp_worker.py`:
 
 ```output
 [Worker] Sending WhatsApp message to +911234567890
 [Worker] Message content: Hello from RabbitMQ
 [Worker] Message sent successfully
 ```
 
-### Message consumption validation
-The worker terminal displays logs similar to:
+## Validate message consumption
+
+The worker terminal displays the complete log:
 
 ```output
 [DEBUG] Connecting to RabbitMQ...
@@ -254,21 +258,22 @@ WhatsApp Worker started. Waiting for messages...
 [Worker] Message content: Hello from RabbitMQ
 [Worker] Message sent successfully
 ```
-**What this confirms:**
+
+This confirms:
 
 - Message routing works correctly
 - Queue consumption is successful
 - Manual acknowledgments are applied
 
 This validates the end-to-end message flow.
 
-### Verify queue state
+## Verify queue state
 
 ```console
 ./rabbitmqadmin list queues name messages consumers
 ```
 
-Expected output is similar to:
+The output is similar to:
 
 ```output
 +------------------------+----------+-----------+
@@ -281,8 +286,19 @@ Expected output is similar to:
 +------------------------+----------+-----------+
 ```
 
-This confirms that:
+This confirms:
 
 - Messages were consumed successfully
 - One active consumer is connected
 - No backlog remains in the queue
+
+## What you've accomplished
+
+In this use case, you:
+- Configured a direct exchange topology for exact-match routing
+- Created durable queues and bindings for WhatsApp notifications
+- Implemented a Python worker using the `pika` library
+- Published test messages and validated end-to-end message flow
+- Confirmed reliable message consumption with manual acknowledgments
+
+This pattern demonstrates how RabbitMQ enables asynchronous, decoupled communication for notification systems on Arm-based cloud platforms.