Merge pull request #3354 from pareenaverma/content_review

Longhorn Tech review

Author: pareenaverma

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

@@ -50,16 +50,10 @@ This rule allows external access for:
 
 5. After filling in the details, select **Add** to save the rule.
 
-You can now access the Longhorn Web UI externally using:
-
-```text
-http://<PUBLIC_IP>:8080
-```
-
 ## What you've learned and what's next
 
-You've now configured the Azure Network Security Group to allow external traffic for SSH, Kubernetes API access, HTTP workloads, and the Longhorn Web UI.
+You've now configured the Azure Network Security Group to allow external traffic for Kubernetes API access, HTTP workloads, and the Longhorn Web UI.
 
 These firewall rules allow secure remote management of the Azure Cobalt 100 virtual machine and external access to the Kubernetes storage dashboard.
 
-Next, you'll create Persistent Volume Claims, deploy workloads using Longhorn storage, and benchmark Kubernetes storage performance on ARM64 infrastructure.
+Next, you'll install K3s Kubernetes and Longhorn on the virtual machine, then deploy and configure persistent storage.

content/learning-paths/servers-and-cloud-computing/longhorn-cobalt/install-longhorn.md

@@ -57,7 +57,8 @@ sudo systemctl status iscsid
 The output should show that the service is active:
 
 ```output
-active (running)
+Loaded: loaded (/usr/lib/systemd/system/iscsid.service; enabled; preset: enabled)
+Active: active (running) 
 ```
 
 ### Install K3s Kubernetes
@@ -70,7 +71,7 @@ curl -sfL https://get.k3s.io | sh -
 
 ### Verify Kubernetes installation
 
-Check that the Kubernetes node is ready.
+Wait a few seconds for K3s to fully initialize, then check that the Kubernetes node is ready.
 
 ```bash
 sudo kubectl get nodes
@@ -83,6 +84,10 @@ NAME             STATUS   ROLES                  AGE   VERSION
 longhorn-Arm64   Ready    control-plane,master   1m    v1.35.5+k3s1
 ```
 
+{{% notice Note %}}
+If the ROLES column shows `<none>` immediately after installation, wait 30 to 60 seconds and run the command again. Role labels are applied after the node completes initialization.
+{{% /notice %}}
+
 ### Configure kubectl access
 
 Create the Kubernetes configuration directory for the current user.
@@ -129,45 +134,39 @@ NAME             STATUS   ROLES           AGE   VERSION
 longhorn-Arm64   Ready    control-plane   5s    v1.35.5+k3s1
 ```
 
-### Create Longhorn storage directory
-
-Create a local directory that Longhorn can use for storing volume replicas on the VM.
-
-```bash
-sudo mkdir -p /longhorn
-```
-
-Set permissions for the directory:
-
-```bash
-sudo chmod 777 /longhorn
-```
+### Check available disk space
 
-Verify available disk space:
+Verify that enough disk space is available on the virtual machine before creating Longhorn volumes. Longhorn stores volume replicas in `/var/lib/longhorn` by default.
 
 ```bash
 df -h
 ```
 
-This helps confirm that enough disk space is available before creating Longhorn volumes.
-
 ### Install Longhorn
 
 Deploy Longhorn into the Kubernetes cluster using the official Longhorn manifest.
 
+{{% notice Note %}}
+The following command uses Longhorn version 1.10.0. The same approach works with other versions. Replace the version in the URL with your version of choice. To find the latest version, see [Longhorn releases on GitHub](https://github.com/longhorn/longhorn/releases).
+{{% /notice %}}
+
 ```bash
 kubectl apply -f https://raw.githubusercontent.com/longhorn/longhorn/v1.10.0/deploy/longhorn.yaml
 ```
 
 ### Verify Longhorn installation
 
-Check the Longhorn pods in the `longhorn-system` namespace.
+Longhorn deploys several components including the manager, driver, UI, and CSI controllers. These take several minutes to fully start. Monitor the pod rollout in the `longhorn-system` namespace.
 
 ```bash
-kubectl get pods -n longhorn-system
+kubectl rollout status deployment/longhorn-driver-deployer -n longhorn-system
 ```
 
-Wait until the pods are running. The output is similar to:
+Once the deployment is ready, check that all Longhorn pods are running.
+
+```bash
+kubectl get pods -n longhorn-system
+```
 
 ```output
 NAME                                                READY   STATUS    RESTARTS   AGE
@@ -193,12 +192,16 @@ longhorn-ui-77cdc466b5-dbsx5                        1/1     Running   0
 
 ### Access the Longhorn UI
 
-Expose the Longhorn frontend service using port forwarding.
+Expose the Longhorn frontend service using port forwarding. Run this command in a dedicated terminal session, as it must remain active while you use the dashboard.
 
 ```bash
 kubectl -n longhorn-system port-forward --address 0.0.0.0 service/longhorn-frontend 8080:80
 ```
 
+{{% notice Note %}}
+The port-forward connection closes when the terminal session ends. If you lose access to the dashboard, run the command again in a new terminal.
+{{% /notice %}}
+
 Open the Longhorn Web UI in your browser. Replace `<PUBLIC_IP>` with the public IP address of your Azure VM.
 
 ```text
@@ -211,32 +214,9 @@ In the Longhorn dashboard, you can view the number of volumes, available schedul
 
 ### Configure Longhorn for a single-node cluster
 
-By default, Longhorn expects multiple nodes and uses a higher replica count. Since this learning path uses a single Azure Cobalt 100 VM, configure the replica count as `1`.
-
-Inside the Longhorn UI, go to:
-
-```text
-Settings
-```
-
-Find the following setting:
-
-```text
-Default Replica Count
-```
-
-Update the values:
-
-```text
-V1 Data Engine: 1
-V2 Data Engine: 1
-```
-
-Click:
+By default, Longhorn expects multiple nodes and uses a higher replica count. Since this Learning Path uses a single Azure Cobalt 100 VM, configure the replica count to `1` so that volumes can be scheduled on a single node.
 
-```text
-Save
-```
+In the Longhorn UI, select **Settings**. Find the **Default Replica Count** setting and set both **V1 Data Engine** and **V2 Data Engine** to `1`. Select **Save**.
 
 ![Longhorn Settings page showing the Default Replica Count configuration for single-node Kubernetes deployment on Azure Cobalt 100 Arm64 virtual machine. Ensure both V1 and V2 Data Engine replica counts are configured to 1 before creating Persistent Volumes in the single-node Longhorn environment.#center](images/longhorn-replica.png "Longhorn Replica Configuration for Single-Node Kubernetes Cluster")
 

content/learning-paths/servers-and-cloud-computing/longhorn-cobalt/instance.md

@@ -61,6 +61,6 @@ Your virtual machine should be ready and running in a few minutes. You can SSH i
 
 ## What you've accomplished and what's next
 
-You've created an Azure Cobalt 100 Arm64 virtual machine running Ubuntu 24.04 LTS with K3s Kubernetes installed and networking configured for Longhorn access. The Kubernetes environment is now ready for deploying and managing persistent storage workloads.
+You've created an Azure Cobalt 100 Arm64 virtual machine running Ubuntu 24.04 LTS with SSH and HTTP access configured. The virtual machine is now ready for the next steps.
 
-Next, you'll install Longhorn on the Kubernetes cluster, configure the Longhorn Web UI, create Persistent Volumes, and validate Kubernetes-native storage functionality on Azure Cobalt 100 Arm64 infrastructure.
+Next, you'll open the additional ports required for Kubernetes and Longhorn access in the Azure Network Security Group.

content/learning-paths/servers-and-cloud-computing/longhorn-cobalt/longhorn-storage-validation-and-benchmark.md

@@ -197,7 +197,7 @@ The fio pod will install the benchmarking utility and keep the container running
 
 ### Open fio container shell
 
-Open a shell inside the fio container.
+Open a shell inside the fio container. The following commands in this section run inside the container, not on the host VM.
 
 ```bash
 kubectl exec -it fio-test -- bash
@@ -244,15 +244,13 @@ benchmark: (groupid=0, jobs=2): err= 0: pid=3344: Tue May 26 04:06:33 2026
   write: IOPS=40.5k, BW=158MiB/s (166MB/s)(10.0GiB/64649msec)
 ```
 
-The benchmark validates storage performance and confirms that Longhorn volumes are functioning correctly on the Azure Cobalt 100 Arm64 virtual machine.
+After the benchmark completes, exit the container shell.
 
-You should observe:
+```bash
+exit
+```
 
-- PVC successfully provisioned
-- Longhorn storage mounted correctly
-- Data persists after pod recreation
-- fio benchmark completes successfully
-- Stable storage performance on Arm64 Kubernetes
+The benchmark confirms that Longhorn volumes are functioning correctly on the Azure Cobalt 100 Arm64 virtual machine.
 
 ## What you've learned