Tech review of OpenEBS LP

Author: pareenaverma

content/learning-paths/servers-and-cloud-computing/openebs-cobalt/background.md

@@ -63,4 +63,4 @@ You'll learn how to:
 
 You now understand why Azure Cobalt 100 and OpenEBS are a strong combination for lightweight Kubernetes-native persistent storage on Arm64 infrastructure.
 
-Next, you'll configure Azure networking to allow external access to the Kubernetes application deployed with OpenEBS persistent storage.
+Next, you'll create an Azure Cobalt 100 Arm64 virtual machine to host the Kubernetes cluster.

content/learning-paths/servers-and-cloud-computing/openebs-cobalt/firewall.md

@@ -1,6 +1,6 @@
 ---
 title: Allow access to the OpenEBS application on Azure
-weight: 5
+weight: 6
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
@@ -14,9 +14,9 @@ The NSG can be attached to the virtual machine's network interface or subnet.
 
 {{% notice Note %}}For more information about Azure setup, see [Getting started with Microsoft Azure Platform](/learning-paths/servers-and-cloud-computing/csp/azure/).{{% /notice %}}
 
-## Verify the Kubernetes service
+## Identify the Kubernetes NodePort
 
-Check the Kubernetes service to identify the exposed 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.
 
 ```bash
 kubectl get svc
@@ -29,7 +29,7 @@ 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`.
+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.
 
 ### Add an inbound firewall rule in Azure
 
@@ -53,7 +53,7 @@ To expose the Kubernetes NodePort externally, create a firewall rule.
 - **Source IP addresses:** *(auto-populated with your current public IP)*  
 - **Source port ranges:** *  
 - **Destination:** Any  
-- **Destination port ranges:** **31635**  
+- **Destination port ranges:** **31635** *(replace with your actual NodePort)*  
 - **Protocol:** TCP  
 - **Action:** Allow  
 - **Name:** allow-openebs-port
@@ -62,12 +62,26 @@ To expose the Kubernetes NodePort externally, create a firewall rule.
 
 5. After filling in the details, select **Add** to save the rule.
 
-You can now access the Kubernetes application externally using the NodePort.
+## Access the application
 
-## What you've learned and what's next
+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.
 
-You've now configured the Azure Network Security Group to allow external access to the Kubernetes application running with OpenEBS LocalPV persistent storage.
+```text
+http://<VM_PUBLIC_IP>:31635
+```
+
+You should see the content written to the Persistent Volume in the previous step:
+
+```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
+
+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.
 
-This firewall rule enables external browser access to the application deployed on your single-node Kubernetes cluster running on Azure Cobalt 100 Arm64.
+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.
 
-Next, you'll install OpenEBS LocalPV on Kubernetes and configure persistent storage provisioning for stateful workloads.
+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.

content/learning-paths/servers-and-cloud-computing/openebs-cobalt/openebs-installation.md

@@ -1,6 +1,6 @@
 ---
 title: Deploy OpenEBS on Azure Cobalt 100
-weight: 5
+weight: 4
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
@@ -75,7 +75,7 @@ sudo chown $USER:$USER ~/.kube/config
 
 Set the Kubernetes configuration environment variable:
 
-```bahs
+```bash
 export KUBECONFIG=$HOME/.kube/config
 ```
 
@@ -128,15 +128,22 @@ Add the official OpenEBS Helm repository:
 helm repo add openebs https://openebs.github.io/openebs
 ```
 
-## Update Helm repositories:
+## Update Helm repositories
 
 ```bash
 helm repo update
 ```
 
+The output will look similar to:
+
+```output
+...Successfully got an update from the "openebs" chart repository
+Update Complete. ⎈Happy Helming!⎈
+```
+
 ## Deploy OpenEBS LocalPV
 
-Create the OpenEBS namespace
+Create the `openebs` namespace that will hold all OpenEBS components.
 
 ```bash
 kubectl create namespace openebs
@@ -146,6 +153,10 @@ kubectl create namespace openebs
 
 This deployment installs only OpenEBS LocalPV components and disables Mayastor, Loki, Alloy, and observability services, which are unnecessary for a single-node setup.
 
+{{% notice Note %}}
+The following command installs the latest available OpenEBS chart. To pin to a specific version, add `--version <version>` to the command. To find available versions, run `helm search repo openebs/openebs --versions`.
+{{% /notice %}}
+
 ```bash
 helm install openebs openebs/openebs \
   --namespace openebs \
@@ -157,7 +168,13 @@ helm install openebs openebs/openebs \
 
 ### Verify OpenEBS installation
 
-Check the OpenEBS pods:
+OpenEBS components take a moment to start. Wait for the pods to become ready before continuing.
+
+```bash
+kubectl wait --for=condition=Ready pod -l app=openebs-localpv-provisioner -n openebs --timeout=120s
+```
+
+Then check all OpenEBS pods are running.
 
 ```bash
 kubectl get pods -n openebs
@@ -233,4 +250,4 @@ At this stage, OpenEBS LocalPV is successfully configured and ready to provision
 
 You now have a lightweight single-node Kubernetes cluster running on Azure Cobalt 100 Arm64 with OpenEBS LocalPV configured as the default storage class.
 
-Next, you'll create Persistent Volume Claims (PVCs), deploy a stateful NGINX application, and validate persistent storage functionality using OpenEBS.
+Next, you'll create a Persistent Volume Claim, deploy a stateful NGINX application, validate data persistence, and expose the application so you can open the required port in the Azure Network Security Group.

content/learning-paths/servers-and-cloud-computing/openebs-cobalt/openebs-persistent-storage-validation.md

@@ -1,6 +1,6 @@
 ---
 title: Validate Persistent Storage with OpenEBS on Azure Cobalt 100
-weight: 6
+weight: 5
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
@@ -38,6 +38,12 @@ Apply the PVC:
 kubectl apply -f pvc.yaml
 ```
 
+The output is similar to:
+
+```output
+persistentvolumeclaim/openebs-pvc created
+```
+
 Verify:
 
 ```bash
@@ -94,6 +100,11 @@ Deploy the application:
 kubectl apply -f nginx-openebs.yaml
 ```
 
+The output is similar to:
+```output
+deployment.apps/nginx-openebs created
+```
+
 ## Verify Kubernetes resources
 
 Check the pod status:
@@ -201,15 +212,15 @@ This confirms that the Persistent Volume retains data even after the pod is dele
 
 ## Expose the application
 
-Create a NodePort service:
+Create a NodePort service to expose the NGINX application externally. Kubernetes assigns the external port dynamically — you'll use the assigned port to open the corresponding firewall rule in the next step.
 
 ```bash
 kubectl expose deployment nginx-openebs \
   --type NodePort \
   --port 80
 ```
 
-Verify the service:
+Verify the service and note the NodePort assigned.
 
 ```bash
 kubectl get svc
@@ -219,25 +230,11 @@ The output is similar to:
 
 ```output
 NAME            TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
-kubernetes      ClusterIP   10.x.x.x      <none>        443/TCP        143m
-nginx-openebs   NodePort    10.x.x.x  <none>        80:31635/TCP   7s
+kubernetes      ClusterIP   10.x.x.x       <none>        443/TCP        143m
+nginx-openebs   NodePort    10.x.x.x       <none>        80:31635/TCP   7s
 ```
 
-## Access the application
-
-Open the following URL in your browser:
-
-```text
-http://<VM_PUBLIC_IP>:31635
-```
-
-You should see:
-
-```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")
+Note the NodePort value (in this example `31635`). You'll need it to create the Azure firewall rule in the next step. Your value may differ because Kubernetes assigns NodePorts dynamically.
 
 ## Cleanup resources
 
@@ -257,4 +254,6 @@ kubectl delete -f pvc.yaml
 
 You successfully created dynamically provisioned Persistent Volumes using OpenEBS LocalPV on a single-node Kubernetes cluster running on Azure Cobalt 100 Arm64.
 
-You validated persistent storage functionality by recreating application pods while preserving data across restarts.
+You validated persistent storage functionality by recreating application pods while preserving data across restarts, and exposed the application as a Kubernetes NodePort service.
+
+Next, you'll open the NodePort in the Azure Network Security Group so the application is reachable from your browser.