ArmDeveloperEcosystem · anupras-mohapatra-arm · Jun 5, 2026 · Jun 5, 2026 · Jun 5, 2026 · Jun 5, 2026
diff --git a/content/learning-paths/servers-and-cloud-computing/openebs-cobalt/_index.md b/content/learning-paths/servers-and-cloud-computing/openebs-cobalt/_index.md
@@ -1,24 +1,20 @@
 ---
-title: Deploy OpenEBS on Azure Cobalt 100 Arm64 virtual machines for Kubernetes-native persistent storage
+title: Use OpenEBS for Kubernetes-native persistent storage on Azure Cobalt 100-based Arm64 virtual machines 
 
-draft: true
-cascade:
-    draft: true
-
-description: Learn how to install and configure OpenEBS LocalPV on an Azure Cobalt 100 Arm64 virtual machine using K3s Kubernetes, provision persistent storage dynamically, deploy stateful applications, and validate persistent storage functionality.
+description: Learn how to install and configure OpenEBS LocalPV on an Arm64 virtual machine powered by Azure Cobalt 100 using K3s Kubernetes, provision persistent storage dynamically, deploy stateful applications, and validate persistent storage functionality.
 
 minutes_to_complete: 60
 
 who_is_this_for: This is an introductory topic for DevOps engineers, platform engineers, cloud-native developers, and Kubernetes administrators who want to deploy lightweight Kubernetes-native persistent storage on Arm-based cloud infrastructure.
 
 learning_objectives:
-    - Install and configure K3s Kubernetes on Azure Cobalt 100 Arm64 virtual machines
+    - Install and configure K3s Kubernetes on Arm64 virtual machines powered by Azure Cobalt 100
     - Deploy OpenEBS LocalPV using Helm
-    - Configure Kubernetes storage classes and Persistent Volume Claims (PVCs)
+    - Configure Kubernetes storage classes and PersistentVolumeClaims (PVCs)
     - Deploy and validate stateful Kubernetes workloads with persistent storage
 
 prerequisites:
-  - A [Microsoft Azure account](https://azure.microsoft.com/) with access to Cobalt 100 based instances (Dpsv6)
+  - 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 Kubernetes concepts and containerized applications

diff --git a/content/learning-paths/servers-and-cloud-computing/openebs-cobalt/background.md b/content/learning-paths/servers-and-cloud-computing/openebs-cobalt/background.md
@@ -1,5 +1,6 @@
 ---
-title: Understand OpenEBS on Azure Cobalt 100
+title: Understand how OpenEBS provides Kubernetes-native persistent storage on Azure 
+description: Learn how OpenEBS LocalPV uses Kubernetes-native storage provisioning to support stateful workloads on Azure Cobalt 100-based Arm64 virtual machines.
 weight: 2
 
 layout: "learningpathall"
@@ -9,33 +10,35 @@ layout: "learningpathall"
 
 OpenEBS on Arm-based Azure Cobalt 100 processors provides lightweight, Kubernetes-native persistent storage for cloud-native workloads. Azure Cobalt 100 processors deliver dedicated physical cores per vCPU, enabling consistent and predictable performance for Kubernetes storage operations and stateful applications.
 
-OpenEBS integrates directly with Kubernetes and dynamically provisions Persistent Volumes for applications using Container Storage Interface (CSI) drivers and storage engines. Running OpenEBS on Azure Cobalt 100 enables efficient Arm64-native Kubernetes storage deployments optimized for lightweight cloud-native environments.
+OpenEBS integrates directly with Kubernetes and dynamically provisions persistent volumes for applications using Container Storage Interface (CSI) drivers and storage engines. Running OpenEBS on Azure Cobalt 100 enables efficient Arm64-native Kubernetes storage deployments optimized for lightweight cloud-native environments.
 
 ## 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. These workloads include 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, ensuring consistent and predictable performance.
+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. 
+
+Running at 3.4 GHz, Cobalt 100 allocates a dedicated physical core for each vCPU, ensuring 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).
 
-## How OpenEBS improves Kubernetes storage
+## How OpenEBS provides Kubernetes storage
 
 OpenEBS is an open-source, Kubernetes-native storage platform designed for stateful workloads running inside Kubernetes clusters. Unlike traditional external storage systems, OpenEBS runs completely inside Kubernetes and dynamically provisions storage volumes directly through Kubernetes APIs.
 
-OpenEBS enables applications to retain persistent data even after pods restart, reschedule, or recreate. This makes OpenEBS ideal for databases, analytics platforms, message queues, and other stateful cloud-native applications.
-
-To learn more, see the official [OpenEBS documentation](https://openebs.io/docs).
+OpenEBS allows applications to retain persistent data on a node even after pods restart, reschedule, or recreate. This makes OpenEBS ideal for databases, analytics platforms, message queues, and other stateful cloud-native applications.
 
 OpenEBS provides key capabilities for Kubernetes-native storage management:
 
-- Dynamic Provisioning: Automatically creates Persistent Volumes using Kubernetes Persistent Volume Claims (PVCs).
-- Kubernetes-native Architecture: Runs entirely inside Kubernetes without requiring external storage appliances.
-- Lightweight Local Storage: OpenEBS LocalPV uses node-local storage optimized for lightweight Kubernetes environments.
-- CSI Integration: Integrates with Kubernetes Container Storage Interface (CSI) drivers for standard storage management.
-- Stateful Workload Support: Enables persistent storage for databases, web applications, and distributed systems.
+- Dynamic provisioning: Automatically creates persistent volumes using Kubernetes PersistentVolumeClaims (PVCs).
+- Kubernetes-native architecture: Runs entirely inside Kubernetes without requiring external storage appliances.
+- Lightweight local storage: OpenEBS LocalPV uses node-local storage optimized for lightweight Kubernetes environments.
+- CSI integration: Integrates with Kubernetes CSI drivers for standard storage management.
+- Stateful workload support: Enables persistent storage for databases, web applications, and distributed systems.
+
+To learn more, see the official [OpenEBS documentation](https://openebs.io/docs).
 
-## Why OpenEBS LocalPV for this learning path
+## Why use OpenEBS LocalPV 
 
-This learning path uses OpenEBS LocalPV because it is optimized for:
+You'll use OpenEBS LocalPV in this Learning Path because it's optimized for:
 
 - Single-node Kubernetes clusters
 - Arm64 environments
@@ -45,22 +48,8 @@ This learning path uses OpenEBS LocalPV because it is optimized for:
 
 Advanced replicated storage engines such as Mayastor are designed for multi-node production environments and are intentionally excluded from this setup.
 
-## Learning path overview
-
-In this Learning Path, you'll deploy OpenEBS LocalPV on an Azure Cobalt 100 Arm64 virtual machine using a lightweight K3s Kubernetes cluster.
-
-You'll learn how to:
-
-- Install Kubernetes using K3s
-- Deploy OpenEBS LocalPV
-- Configure Kubernetes storage classes
-- Create Persistent Volume Claims (PVCs)
-- Deploy stateful applications
-- Validate persistent storage functionality
-- Expose Kubernetes applications externally using Azure networking
-
 ## What you've learned and what's next
 
-You now understand why Azure Cobalt 100 and OpenEBS are a strong combination for lightweight Kubernetes-native persistent storage on Arm64 infrastructure.
+You now understand why Azure Cobalt 100 and OpenEBS are a strong combination for lightweight Kubernetes-native persistent storage on Arm64 infrastructure. You've also learned how OpenEBS provides persistent storage and why OpenEBS LocalPV is suited for this Learning Path.
 
 Next, you'll create an Azure Cobalt 100 Arm64 virtual machine to host the Kubernetes cluster.
diff --git a/content/learning-paths/servers-and-cloud-computing/openebs-cobalt/firewall.md b/content/learning-paths/servers-and-cloud-computing/openebs-cobalt/firewall.md
@@ -1,5 +1,6 @@
 ---
 title: Allow access to the OpenEBS application on Azure
+description: Open an Azure Network Security Group rule for a Kubernetes NodePort service and verify browser access to an OpenEBS-backed application.
 weight: 6
 
 ### FIXED, DO NOT MODIFY
@@ -8,15 +9,13 @@ layout: learningpathall
 
 ## Configure external traffic for the OpenEBS application
 
-To allow external traffic to the Kubernetes application running with OpenEBS persistent storage on an Azure virtual machine, open the Kubernetes NodePort in the Network Security Group (NSG).
+To allow external traffic to the Kubernetes application, open the Kubernetes NodePort in the Network Security Group (NSG) of your virtual machine (VM).
 
-The NSG can be attached to the virtual machine's network interface or subnet.
+{{% notice Note %}}For more information about Azure setup, see the [Getting started with Microsoft Azure Platform Learning Path](/learning-paths/servers-and-cloud-computing/csp/azure/).{{% /notice %}}
 
-{{% notice Note %}}For more information about Azure setup, see [Getting started with Microsoft Azure Platform](/learning-paths/servers-and-cloud-computing/csp/azure/).{{% /notice %}}
+### Identify the Kubernetes NodePort
 
-## Identify the Kubernetes NodePort
-
-In the previous step you exposed the NGINX deployment as a NodePort service. Run the following command on your VM to find the port that Kubernetes assigned.
+In the previous section, you exposed the NGINX deployment as a NodePort service. Run the following command on your VM to find the port that Kubernetes assigned:
 
 ```bash
 kubectl get svc
@@ -29,15 +28,15 @@ NAME            TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)
 nginx-openebs   NodePort    10.x.x.x        <none>        80:31635/TCP
 ```
 
-In this example, the NodePort exposed externally is `31635`. Kubernetes assigns this port dynamically, so your value may differ. Use the port shown in your own output in the firewall rule below.
+In this example, the NodePort is `31635`. Kubernetes assigns this port dynamically, so your value may differ. Use the port shown in your own output in the firewall rule.
 
 ### Add an inbound firewall rule in Azure
 
-To expose the Kubernetes NodePort externally, create a firewall rule.
+To expose the Kubernetes NodePort externally, create a firewall rule:
 
-1. Navigate to the [Azure portal](https://portal.azure.com), go to **Virtual Machines**, and select your virtual machine.
+1. Navigate to the [Azure portal](https://portal.azure.com), then go to **Virtual Machines**, and select your VM.
 
-![Azure Portal Virtual Machines page with the target VM selected. Check that you are opening the correct virtual machine before configuring its network access.#center](images/virtual_machine.png "Virtual Machines")
+![Azure Portal Virtual Machines page with the target VM selected. Check that you are opening the correct virtual machine before configuring its network access.#center](images/virtual_machine.png "Virtual machines")
 
 2. In the left menu, select **Networking**, then select **Network settings**.
 
@@ -49,39 +48,53 @@ To expose the Kubernetes NodePort externally, create a firewall rule.
 
 4. Configure the inbound security rule with the following settings:
 
-- **Source:** My IP address  
-- **Source IP addresses:** *(auto-populated with your current public IP)*  
-- **Source port ranges:** *  
-- **Destination:** Any  
-- **Destination port ranges:** **31635** *(replace with your actual NodePort)*  
-- **Protocol:** TCP  
-- **Action:** Allow  
-- **Name:** allow-openebs-port
+    - **Source:** My IP address  
+    - **Source IP addresses:** *(auto-populated with your current public IP)*  
+    - **Source port ranges:** `*`
+    - **Destination:** Any  
+    - **Destination port ranges:** **31635** *(replace with your actual NodePort)*  
+    - **Protocol:** TCP  
+    - **Action:** Allow  
+    - **Name:** `allow-openebs-port`
 
-{{% notice Note %}}Setting Source to My IP address restricts access to the Kubernetes application to your current machine only. Source port ranges remains * because this refers to the client's ephemeral outbound port, which is dynamically assigned. If your IP address changes or you need to access the application from another machine, update the source IP in this rule.{{% /notice %}}
+{{% notice Note %}}Setting **Source** to `My IP address` restricts access to the Kubernetes application to your current machine only. The **Source port ranges** setting remains set to `*` because this refers to the client's ephemeral outbound port, which is dynamically assigned. If your IP address changes or you need to access the application from another machine, update the source IP in this rule.{{% /notice %}}
 
-5. After filling in the details, select **Add** to save the rule.
+5. After providing the details, select **Add** to save the rule.
 
 ## Access the application
 
-Open the following URL in your browser. Replace `<VM_PUBLIC_IP>` with the public IP address of your Azure virtual machine, and replace `31635` with your actual NodePort if it differs.
+Open the following URL in your browser. Replace `<VM_PUBLIC_IP>` with the public IP address of your Azure VM, and replace `31635` with your NodePort if it differs.
 
 ```text
 http://<VM_PUBLIC_IP>:31635
 ```
 
-You should see the content written to the Persistent Volume in the previous step:
+You should see the content written to the persistent volume in the previous section:
 
 ```output
 OpenEBS on Azure Cobalt D4ps Arm64
 ```
 
 ![NGINX application running on Kubernetes with persistent storage provisioned by OpenEBS LocalPV on Azure Cobalt 100 Arm64.#center](images/openebs-browser.png "NGINX application using OpenEBS persistent storage")
 
-## What you've learned
+## (Optional) Clean up resources
+
+Delete the deployment:
+
+```bash
+kubectl delete -f nginx-openebs.yaml
+```
+
+Delete the PVC:
+
+```bash
+kubectl delete -f pvc.yaml
+```
+
+## What you've accomplished
 
 You've configured the Azure Network Security Group to allow external access to the Kubernetes application running with OpenEBS LocalPV persistent storage, and confirmed that the application is reachable from your browser.
 
-The persistent data written earlier survived pod recreation and is now served by a stateful NGINX workload backed by OpenEBS on an Azure Cobalt 100 Arm64 virtual machine.
+The persistent data that you wrote earlier survived pod recreation and is now served by a stateful NGINX workload backed by OpenEBS.
 
-In this Learning Path, you provisioned an Azure Cobalt 100 Arm64 virtual machine, installed a single-node K3s Kubernetes cluster, deployed OpenEBS LocalPV as the default storage class, created persistent volumes for a stateful application, and validated that data survived pod restarts on Arm64 infrastructure.
+You can use the workflow described in this Learning Path to add persistent storage backed by OpenEBS to your own Kubernetes applications running on Arm-based cloud infrastructure.