[fix]: update titles and improve clarity in Kafka deployment documentation

Author: madeline-underwood

content/learning-paths/servers-and-cloud-computing/kafka-azure/_index.md

@@ -1,23 +1,19 @@
 ---
-title: Deploy Kafka on the Microsoft Azure Cobalt 100 processors 
-
-draft: true
-cascade:
-    draft: true
+title: Deploy Apache Kafka on Arm-based Microsoft Azure Cobalt 100 virtual machines 
 
 minutes_to_complete: 30   
 
-who_is_this_for: This is an advanced topic designed for software developers looking to migrate their Kafka workloads from x86_64 to Arm-based platforms, specifically on the Microsoft Azure Cobalt 100 processors.
+who_is_this_for: This is an advanced topic for developers looking to migrate their Apache Kafka workloads from x86_64 to Arm-based platforms, specifically on Microsoft Azure Cobalt 100 (arm64) virtual machines.
 
 learning_objectives: 
-    - Provision an Azure Arm64 virtual machine using Azure console, with Ubuntu Pro 24.04 LTS as the base image.
-    - Deploy Kafka on the Ubuntu virtual machine.
-    - Perform Kafka baseline testing and benchmarking on Arm64 virtual machines.
+    - Provision an Azure Arm64 virtual machine using Azure console, with Ubuntu Pro 24.04 LTS as the base image
+    - Deploy Kafka on an Ubuntu virtual machine
+    - Perform Kafka baseline testing and benchmarking on Arm64 virtual machines
 
 prerequisites:
-    - A [Microsoft Azure](https://azure.microsoft.com/) account with access to Cobalt 100 based instances (Dpsv6). 
-    - Basic understanding of Linux command line.
-    - Familiarity with the [Apache Kafka architecture](https://kafka.apache.org/) and deployment practices on Arm64 platforms.
+    - A [Microsoft Azure](https://azure.microsoft.com/) account with access to Cobalt 100 based instances (Dpsv6)
+    - Basic understanding of Linux command line
+    - Familiarity with the [Apache Kafka architecture](https://kafka.apache.org/) and deployment practices on Arm64 platforms
 
 author: Pareena Verma
 

content/learning-paths/servers-and-cloud-computing/kafka-azure/background.md

@@ -8,7 +8,7 @@ layout: "learningpathall"
 
 ## Cobalt 100 Arm-based processor
 
-Azure’s Cobalt 100 is built on Microsoft's first-generation, in-house Arm-based processor: the Cobalt 100. Designed entirely by Microsoft and based on Arm’s Neoverse N2 architecture, this 64-bit CPU delivers improved performance and energy efficiency across a broad spectrum of cloud-native, scale-out Linux workloads. These include web and application servers, data analytics, open-source databases, caching systems, and more. Running at 3.4 GHz, the Cobalt 100 processor allocates a dedicated physical core for each vCPU, ensuring consistent and predictable performance. 
+Azure’s Cobalt 100 is built on Microsoft's first-generation, in-house Arm-based processor: the Cobalt 100. Designed entirely by Microsoft and based on Arm’s Neoverse N2 architecture, this 64-bit CPU delivers improved performance and energy efficiency across a broad spectrum of cloud-native, scale-out Linux workloads. These include web and application servers, data analytics, open-source databases, caching systems, and more. Running at 3.4 GHz, the Cobalt 100 processor allocates a dedicated physical core for each virtual CPU (vCPU), ensuring consistent and predictable performance. 
 
 To learn more about Cobalt 100, refer to the blog [Announcing the preview of new Azure virtual machine 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).
 
@@ -17,4 +17,4 @@ Apache Kafka is a high-performance, open-source distributed event streaming plat
 
 It allows you to publish, subscribe to, store, and process streams of records in a fault-tolerant and scalable manner. Kafka stores data in topics, which are partitioned and replicated across a cluster to ensure durability and high availability.
 
-Kafka is widely used for messaging, log aggregation, event sourcing, real-time analytics, and integrating large-scale data systems. Learn more from the [Apache Kafka official website](https://kafka.apache.org/) and its [official documentation](https://kafka.apache.org/documentation).
+Kafka is widely used for messaging, log aggregation, event sourcing, real-time analytics, and integrating large-scale data systems. Learn more from the [Apache Kafka official website](https://kafka.apache.org/) and the [Apache Kafka documentation](https://kafka.apache.org/documentation).

content/learning-paths/servers-and-cloud-computing/kafka-azure/baseline.md

@@ -1,5 +1,5 @@
 ---
-title: Baseline Testing
+title: Run baseline testing with Kafka on Azure Arm VM
 weight: 5
 
 ### FIXED, DO NOT MODIFY
@@ -12,60 +12,64 @@ After installing Apache Kafka 4.1.0 on your Azure Cobalt 100 Arm64 virtual machi
 Kafka 4.1.0 introduces KRaft mode (Kafka Raft Metadata mode), which integrates the control and data planes, eliminating the need for ZooKeeper.
 This simplifies deployment, reduces latency, and provides a unified, self-managed Kafka cluster architecture.
 
-To perform this baseline test, you will use four terminal sessions:
-Terminal 1: Start the Kafka broker (in KRaft mode).
-Terminal 2: Create a topic.
-Terminal 3: Send messages (Producer).
-Terminal 4: Read messages (Consumer).
+To run this baseline test, open four terminal sessions:
 
-### Initial Setup: Configure & Format KRaft
-KRaft (Kafka Raft) replaces ZooKeeper by embedding metadata management directly into the Kafka broker.
-This improves scalability, reduces external dependencies, and speeds up controller failover in distributed clusters.
-Before starting Kafka in KRaft mode, configure and initialize the storage directory. These steps are required only once per broker.
+- **Terminal 1:** Start the Kafka broker in KRaft mode.
+- **Terminal 2:** Create a topic.
+- **Terminal 3:** Send messages as the producer.
+- **Terminal 4:** Read messages as the consumer.
 
-1. Edit the Configuration File
-Open the Kafka configuration file in an editor:
+Each terminal has a specific role, helping you verify that Kafka works end-to-end on your Arm64 VM.
+## Configure and format KRaft
 
-```console
-vi /opt/kafka/config/server.properties
-```
+KRaft (Kafka Raft) mode replaces ZooKeeper by managing metadata directly within the Kafka broker. This change improves scalability, reduces external dependencies, and speeds up controller failover in distributed clusters.
 
-2. Add or Modify KRaft Properties
-Ensure the following configuration entries are present for a single-node KRaft setup:
+Before you start Kafka in KRaft mode, you need to configure the broker and initialize the storage directory. You only need to do this once for each broker.
 
-```java
-process.roles=controller,broker
-node.id=1
-controller.quorum.voters=1@localhost:9093
-listeners=PLAINTEXT://:9092,CONTROLLER://:9093
-advertised.listeners=PLAINTEXT://localhost:9092
-log.dirs=/tmp/kraft-combined-logs
-```
-This configuration file sets up a single Kafka server to act as both a controller (managing cluster metadata) and a broker (handling data), running in KRaft mode. It defines the node's unique ID and specifies the local host as the sole participant in the controller quorum.
 
-3. Format the Storage Directory
-Format the metadata storage directory using the kafka-storage.sh tool. This initializes KRaft’s internal Raft logs with a unique cluster ID.
+- **Edit the configuration file**  
+    Open the Kafka configuration file in an editor:
 
-```console
-bin/kafka-storage.sh format -t $(bin/kafka-storage.sh random-uuid) -c config/server.properties
-```
-You should see output similar to:
+    ```console
+    vi /opt/kafka/config/server.properties
+    ```
 
-```output
-Formatting metadata directory /tmp/kraft-combined-logs with metadata.version 4.1-IV1.
-```
-This confirms that the Kafka storage directory has been successfully formatted and that the broker is ready to start in KRaft mode.
+- **Add or modify KRaft properties**  
+    Ensure the following configuration entries are present for a single-node KRaft setup:
+
+    ```java
+    process.roles=controller,broker
+    node.id=1
+    controller.quorum.voters=1@localhost:9093
+    listeners=PLAINTEXT://:9092,CONTROLLER://:9093
+    advertised.listeners=PLAINTEXT://localhost:9092
+    log.dirs=/tmp/kraft-combined-logs
+    ```
+    This configuration file sets up a single Kafka server to act as both a controller (managing cluster metadata) and a broker (handling data), running in KRaft mode. It defines the node's unique ID and specifies the local host as the sole participant in the controller quorum.
+
+- **Format the storage directory**  
+    Format the metadata storage directory using the kafka-storage.sh tool. This initializes KRaft’s internal Raft logs with a unique cluster ID.
+
+    ```console
+    bin/kafka-storage.sh format -t $(bin/kafka-storage.sh random-uuid) -c config/server.properties
+    ```
+    You should see output similar to:
+
+    ```output
+    Formatting metadata directory /tmp/kraft-combined-logs with metadata.version 4.1-IV1.
+    ```
+    This confirms that the Kafka storage directory has been successfully formatted and that the broker is ready to start in KRaft mode.
 
 ## Perform the Baseline Test
 With Kafka 4.1.0 installed and configured in KRaft mode, you’re now ready to run a baseline test to verify that the Kafka broker starts correctly, topics can be created, and message flow works as expected.
 
 You’ll use multiple terminals for this test:
-Terminal 1: Start the Kafka broker.
-Terminal 2: Create and verify a topic.
-Terminal 3: Send messages (Producer).
-Terminal 4: Read messages (Consumer).
+Terminal 1: start the Kafka broker
+Terminal 2: create and verify a topic
+Terminal 3: send messages (Producer)
+Terminal 4: read messages (Consumer)
 
-### Terminal 1 – Start Kafka Broker
+## Terminal 1 - start Kafka broker
 Start the Kafka broker (the main server process responsible for managing topics and handling messages) in KRaft mode:
 
 ```console
@@ -74,7 +78,7 @@ bin/kafka-server-start.sh config/server.properties
 ```
 Keep this terminal open and running. The broker process must stay active for all subsequent commands.
 
-### Terminal 2 – Create a Topic
+## Terminal 2 - create a Topic
 Open a new terminal window. Create a topic named test-topic-kafka, which acts as a logical channel where producers send and consumers receive messages:
 
 ```console
@@ -87,8 +91,21 @@ You should see output similar to:
 Created topic test-topic-kafka.
 ```
 
-**Verify Topic Creation**
-List available topics to confirm that your new topic was created successfully:
+## Verify topic creation
+List available topics to confirm that your new topic was created successfully. Run the following command:
+
+```console
+bin/kafka-topics.sh --list --bootstrap-server localhost:9092
+```
+
+The expected output is:
+
+```output
+__consumer_offsets
+test-topic-kafka
+```
+
+If you see `test-topic-kafka` in the list, your topic was created and is ready for use.
 
 ```console
 bin/kafka-topics.sh --list --bootstrap-server localhost:9092
@@ -102,7 +119,7 @@ test-topic-kafka
 Kafka is now running, and you’ve successfully created and verified a topic.
 Next, you’ll use Terminal 3 to produce messages and Terminal 4 to consume messages, completing the baseline functional test on your Arm64 environment.
 
-### Terminal 3 – Console Producer (Write Message)
+## Terminal 3 - console producer (write message)
 In this step, you’ll start the Kafka Producer, which publishes messages to the topic test-topic-kafka. The producer acts as the data source, sending messages to the Kafka broker.
 
 ```console
@@ -117,8 +134,8 @@ hello from azure arm vm
 ```
 Each line you type is sent as a message to the Kafka topic and stored on disk by the broker.
 
-### Terminal 4 – Console Consumer (Read Message)
-Next, open another terminal and start the Kafka Consumer, which subscribes to the same topic (test-topic-kafka) and reads messages from the beginning of the log.
+## Terminal 4 - console consumer (read message)
+Next, open another terminal and start the Kafka Consumer, which subscribes to the same topic (test-topic-kafka) and reads messages from the beginning of the log:
 
 ```console
 cd /opt/kafka

content/learning-paths/servers-and-cloud-computing/kafka-azure/benchmarking.md

@@ -1,5 +1,5 @@
 ---
-title: Benchmarking with Official Kafka Tools
+title: Benchmark with official Kafka tools
 weight: 6
 
 ### FIXED, DO NOT MODIFY
@@ -13,7 +13,7 @@ Apache Kafka includes official performance testing utilities that allow you to m
 ## Steps for Kafka Benchmarking 
 
 Before running the benchmarks, make sure your Kafka broker is already active in a separate terminal (as configured in the previous section).
-Now open two new terminal sessions — one for running the producer benchmark and another for the consumer benchmark.
+Now open two new terminal sessions; one for running the producer benchmark, and the other for the consumer benchmark.
 
 ### Terminal A - Producer Benchmark
 

content/learning-paths/servers-and-cloud-computing/kafka-azure/create-instance.md

@@ -1,5 +1,5 @@
 ---
-title: Create an Arm based cloud virtual machine using Microsoft Cobalt 100 CPU 
+title: Create an Arm-based cloud virtual machine using Microsoft Cobalt 100 CPU 
 weight: 3
 
 ### FIXED, DO NOT MODIFY
@@ -8,21 +8,22 @@ 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. 
+You can create an Arm-based Cobalt 100 virtual machine in several ways: using the Microsoft Azure portal, the Azure CLI, or Infrastructure as Code (IaC) tools. This Learning Path uses the Azure portal to walk you through creating a virtual machine with an Arm-based Cobalt 100 processor, which is from the D-Series v6 general-purpose virtual machines. 
 
-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.  
+These VMs are designed for a wide range of workloads and offer Arm-based performance with the Cobalt 100 CPU. To learn more about the Dpsv6 size series, see the official [Dpsv6 size series guide](https://learn.microsoft.com/en-us/azure/virtual-machines/sizes/general-purpose/dpsv6-series) from 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). 
+If you have never used the Microsoft Cloud Platform before, see the Microsoft guide on how 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 
+## 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.
+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**.
 
-![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")
+- Select **Create**, and click on **Virtual Machine** from the drop-down list.
+- Inside the **Basic** tab, fill in the Instance details such as **Virtual machine name** and **Region**.
+- Choose the image for your virtual machine (for example, Ubuntu Pro 24.04 LTS) and select **Arm64** as the VM architecture.
+- 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 showing the selection of the D-Series v6 family of virtual machines, with D4ps_v6 highlighted as the chosen size. The interface displays a list of available VM sizes, including CPU, memory, and pricing details. The wider environment is the Azure portal's virtual machine creation workflow, with a clean and organized layout. The tone is neutral and informative, focused on guiding users through the selection process. Visible text includes D-Series v6, D4ps_v6, CPU, memory, and price columns.](images/instance.png "Selecting 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.