[Doc][KubeRay] Improve Kueue/KubeRay priority scheduling doc
diff --git a/.vale/styles/Vocab/General/accept.txt b/.vale/styles/Vocab/General/accept.txt
index 208355bd18fb4..bf935d68f6987 100644
--- a/.vale/styles/Vocab/General/accept.txt
+++ b/.vale/styles/Vocab/General/accept.txt
@@ -12,3 +12,6 @@ URI[s]
 [Pp]arallelization
 [Pp]erformant
 [Ss]ubclassing
+Kueue
+GKE
+namespace
diff --git a/doc/source/cluster/kubernetes/examples/rayjob-kueue-priority-scheduling.md b/doc/source/cluster/kubernetes/examples/rayjob-kueue-priority-scheduling.md
index ade131df9fee9..cc24929f2ed49 100644
--- a/doc/source/cluster/kubernetes/examples/rayjob-kueue-priority-scheduling.md
+++ b/doc/source/cluster/kubernetes/examples/rayjob-kueue-priority-scheduling.md
@@ -6,7 +6,7 @@ This guide shows how to run [Fine-tune a PyTorch Lightning Text Classifier with
 
 ## What's Kueue?
 
-[Kueue](https://kueue.sigs.k8s.io/) is a Kubernetes-native system that manages quotas
+[Kueue](https://kueue.sigs.k8s.io/) is a Kubernetes-native job queueing system that manages quotas
 and how jobs consume them. Kueue decides when:
 * To make a job wait
 * To admit a job to start, meaning that Kubernetes creates pods.
@@ -16,68 +16,32 @@ Kueue has native support for some KubeRay APIs. Specifically, you can use Kueue
 to manage resources consumed by RayJob and RayCluster. See the
 [Kueue documentation](https://kueue.sigs.k8s.io/docs/overview/) to learn more.
 
-## Create a Kubernetes cluster on GKE
+## Step 0: Create a Kubernetes cluster on GKE (Optional)
 
 If you already have a Kubernetes cluster with GPUs, you can skip this step.
+Otherwise, follow [Start Google Cloud GKE Cluster with GPUs for KubeRay](kuberay-gke-gpu-cluster-setup) to set up a Kubernetes cluster on GKE.
 
-Create a GKE cluster with autoscaling enabled:
-```bash
-gcloud container clusters create kuberay-gpu-cluster \
-    --num-nodes=1 --min-nodes 0 --max-nodes 1 --enable-autoscaling \
-    --zone=us-west1-b --machine-type e2-standard-4
-```
-
-Create a GPU node pool:
-```bash
-gcloud container node-pools create gpu-node-pool \
-  --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \
-  --zone us-west1-b \
-  --cluster kuberay-gpu-cluster \
-  --num-nodes 1 \
-  --min-nodes 1 \
-  --max-nodes 10 \
-  --enable-autoscaling \
-  --machine-type g2-standard-4
-```
-
-Configure `kubectl` to connect with your cluster:
-```bash
-gcloud container clusters get-credentials kuberay-gpu-cluster --zone us-west1-b
-``` 
-
-See [Start Google Cloud GKE Cluster with GPUs for KubeRay](kuberay-gke-gpu-cluster-setup) for more details on setting up a Kubernetes cluster on GKE.
-
-## Install the KubeRay operator
+## Step 1: Install the KubeRay operator
 
 Follow [Deploy a KubeRay operator](kuberay-operator-deploy) to install the latest stable KubeRay operator from the Helm repository.
 The KubeRay operator Pod must be on the CPU node if you set up the taint for the GPU node pool correctly.
 
-## Install Kueue
+## Step 2: Install Kueue
 
-```
-VERSION=v0.6.0-rc.1
+```bash
+VERSION=v0.6.0
 kubectl apply --server-side -f https://github.com/kubernetes-sigs/kueue/releases/download/$VERSION/manifests.yaml
 ```
 
 See [Kueue Installation](https://kueue.sigs.k8s.io/docs/installation/#install-a-released-version) for more details on installing Kueue.
 
-## Configure Kueue with priority scheduling
-
-Next, configure Kueue for a single fine-tuning RayJob to run at a time.
-Use priority classes to allow RayJobs with higher priority to preempt those with lower priority.
+## Step 3: Configure Kueue with priority scheduling
 
-### Create Kueue resources
-
-This manifest creates the following resources:
-* [ClusterQueue](https://kueue.sigs.k8s.io/docs/concepts/cluster_queue/): defines quotas and fair sharing rules
-* [LocalQueue](https://kueue.sigs.k8s.io/docs/concepts/local_queue/): a namespaced queue (belonging to a tenant) that references a ClusterQueue
-* [ResourceFlavor](https://kueue.sigs.k8s.io/docs/concepts/resource_flavor/): defines what resources are available in the cluster (typically from Nodes)
-* [WorkloadPriorityClass](https://kueue.sigs.k8s.io/docs/concepts/workload_priority_class/): defines priority for workloads
-
-This example configures Kueue with just enough quotas to run a single fine-tuning RayJob.
-There are two priority classes `dev-priority` and `prod-priority`. RayJobs using the
-`prod-priority` priority class should take precedence and preempt any running RayJobs from the `dev-priority`
-priority class.
+To understand this tutorial, it's important to understand the following Kueue concepts:
+* [ResourceFlavor](https://kueue.sigs.k8s.io/docs/concepts/resource_flavor/)
+* [ClusterQueue](https://kueue.sigs.k8s.io/docs/concepts/cluster_queue/)
+* [LocalQueue](https://kueue.sigs.k8s.io/docs/concepts/local_queue/)
+* [WorkloadPriorityClass](https://kueue.sigs.k8s.io/docs/concepts/workload_priority_class/)
 
 ```yaml
 # kueue-resources.yaml
@@ -92,7 +56,6 @@ metadata:
   name: "cluster-queue"
 spec:
   preemption:
-    reclaimWithinCohort: Any
     withinClusterQueue: LowerPriority
   namespaceSelector: {} # Match all namespaces.
   resourceGroups:
@@ -130,12 +93,24 @@ value: 100
 description: "Priority class for development jobs"
 ```
 
+The YAML manifest configures:
+
+* **ResourceFlavor**
+  * The ResourceFlavor `default-flavor` is an empty ResourceFlavor because the compute resources in the Kubernetes cluster are homogeneous. In other words, users can request 1 GPU without considering whether it's an NVIDIA A100 or a T4 GPU.
+* **ClusterQueue**
+    * The ClusterQueue `cluster-queue` only has 1 ResourceFlavor `default-flavor` with quotas for 2 CPUs, 8G memory, and 1 GPU. It exactly matches the resources requested by 1 RayJob custom resource. ***Hence, only 1 RayJob can run at a time.***
+    * The ClusterQueue `cluster-queue` has a preemption policy `withinClusterQueue: LowerPriority`. This policy allows the pending RayJob that doesn’t fit within the nominal quota for its ClusterQueue to preempt active RayJob custom resources in the ClusterQueue that have lower priority.
+* **LocalQueue**
+  * The LocalQueue `user-queue` is a namespaced object in the `default` namespace which belongs to a ClusterQueue. A typical practice is to assign a namespace to a tenant, team or user, of an organization. Users submit jobs to a LocalQueue, instead of to a ClusterQueue directly.
+* **WorkloadPriorityClass**
+  * The WorkloadPriorityClass `prod-priority` has a higher value than the WorkloadPriorityClass `dev-priority`. This means that RayJob custom resources with the `prod-priority` priority class take precedence over RayJob custom resources with the `dev-priority` priority class.  
+
 Create the Kueue resources:
 ```bash
 kubectl apply -f kueue-resources.yaml
 ```
 
-## Deploy a RayJob
+## Step 4: Deploy a RayJob
 
 Download the RayJob that executes all the steps documented in [Fine-tune a PyTorch Lightning Text Classifier](https://docs.ray.io/en/master/train/examples/lightning/lightning_cola_advanced.html). The [source code](https://github.com/ray-project/kuberay/tree/master/ray-operator/config/samples/pytorch-text-classifier) is also in the KubeRay repository.
 
@@ -144,9 +119,6 @@ curl -LO https://raw.githubusercontent.com/ray-project/kuberay/master/ray-operat
 ```
 
 Before creating the RayJob, modify the RayJob metadata with:
-* A label to assign the RayJob to the LocalQueue created earlier.
-* A label to assign the RayJob with the `dev-priority` priority class.
-* A modified name to indicate that this job is for development.
 
 ```yaml
 metadata:
@@ -156,7 +128,11 @@ metadata:
     kueue.x-k8s.io/priority-class: dev-priority
 ```
 
-Also note the resources required for this RayJob by looking at the resources requested by the nodes:
+* `kueue.x-k8s.io/queue-name: user-queue`: As the previous step mentioned, users submit jobs to a LocalQueue instead of directly to a ClusterQueue.
+* `kueue.x-k8s.io/priority-class: dev-priority`: Assign the RayJob with the `dev-priority` WorkloadPriorityClass.
+* A modified name to indicate that this job is for development.
+
+Also note the resources required for this RayJob by looking at the resources that the Ray head Pod requests:
 ```yaml
 resources:
   limits:
@@ -178,11 +154,11 @@ Verify that the RayCluster and the submitter Kubernetes Job are running:
 ```bash
 $ kubectl get pod
 NAME                                                      READY   STATUS    RESTARTS   AGE
-dev-pytorch-text-classifier-r6d4p-4nczg                   1/1     Running   0          4s
-torch-text-classifier-r6d4p-raycluster-br45j-head-8bbwt   1/1     Running   0          34s
+dev-pytorch-text-classifier-r6d4p-4nczg                   1/1     Running   0          4s  # Submitter Kubernetes Job
+torch-text-classifier-r6d4p-raycluster-br45j-head-8bbwt   1/1     Running   0          34s # Ray head Pod
 ```
 
-Delete the RayJob after verifying that the job has completed successfully:
+Delete the RayJob after verifying that the job has completed successfully.
 ```bash
 $ kubectl get rayjobs.ray.io dev-pytorch-text-classifier-r6d4p -o jsonpath='{.status.jobStatus}'
 SUCCEEDED
@@ -192,9 +168,10 @@ $ kubectl delete rayjob dev-pytorch-text-classifier-r6d4p
 rayjob.ray.io "dev-pytorch-text-classifier-r6d4p" deleted
 ```
 
-## Queuing multiple RayJob resources
+## Step 5: Queuing multiple RayJob resources
+
+Create 3 RayJob custom resources to see how Kueue interacts with KubeRay to implement job queueing.
 
-Create 3 RayJobs to see how Kueue interacts with KubeRay to implement job queueing.
 ```bash
 $ kubectl create -f ray-job.pytorch-distributed-training.yaml
 rayjob.ray.io/dev-pytorch-text-classifier-8vg2c created
@@ -212,7 +189,7 @@ You can also inspect the `ClusterQueue` to see available and used quotas:
 $ kubectl get clusterqueue
 NAME            COHORT   PENDING WORKLOADS
 cluster-queue            2
-$ kubectl get clusterqueue  cluster-queue -o yaml
+$ kubectl get clusterqueue cluster-queue -o yaml
 apiVersion: kueue.x-k8s.io/v1beta1
 kind: ClusterQueue
 ...
@@ -248,14 +225,11 @@ status:
   reservingWorkloads: 1 # Running workloads that are using quotas.
 ```
 
-## Deploy a RayJob with higher priority
+## Step 6: Deploy a RayJob with higher priority
 
 At this point there are multiple RayJob custom resources queued up but only enough quota to run a single RayJob.
 Now you can create a new RayJob with higher priority to preempt the already queued RayJob resources.
 Modify the RayJob with:
-* A label to assign the RayJob to the LocalQueue created earlier.
-* A label to assign the RayJob with the `prod-priority` priority class.
-* A modified name to indicate that this job is for production.
 
 ```yaml
 metadata:
@@ -265,6 +239,10 @@ metadata:
     kueue.x-k8s.io/priority-class: prod-priority
 ```
 
+* `kueue.x-k8s.io/queue-name: user-queue`: As the previous step mentioned, users submit jobs to a LocalQueue instead of directly to a ClusterQueue.
+* `kueue.x-k8s.io/priority-class: dev-priority`: Assign the RayJob with the `prod-priority` WorkloadPriorityClass.
+* A modified name to indicate that this job is for production.
+
 Create the new RayJob:
 ```sh
 $ kubectl create -f ray-job.pytorch-distributed-training.yaml
@@ -278,50 +256,3 @@ NAME                                                      READY   STATUS    REST
 prod-pytorch-text-classifier-gkp9b-r9k5r                  1/1     Running   0          5s
 torch-text-classifier-gkp9b-raycluster-s2f65-head-hfvht   1/1     Running   0          35s
 ```
-
-## Increasing cluster quotas
-
-As a final step, you can control the quotas available by modifying the ClusterQueue.
-Increasing the quotas signals to Kueue that it can admit more RayJob resources.
-If no resources are available to schedule new RayJobs, the Kubernetes node autoscaler,
-such as GKE Autopilot, adds additional nodes if enabled. You must enable the autoscaler
-to have this behavior.
-```yaml
-apiVersion: kueue.x-k8s.io/v1beta1
-kind: ClusterQueue
-metadata:
-  name: "cluster-queue"
-spec:
-  preemption:
-    reclaimWithinCohort: Any
-    withinClusterQueue: LowerPriority
-  namespaceSelector: {} # Match all namespaces.
-  resourceGroups:
-  - coveredResources: ["cpu", "memory", "nvidia.com/gpu"]
-    flavors:
-    - name: "default-flavor"
-      resources:
-      - name: "cpu"
-        nominalQuota: 100
-      - name: "memory"
-        nominalQuota: 100Gi
-      - name: "nvidia.com/gpu"
-        nominalQuota: 10  # Add more GPU quota.
-```
-
-RayJob resources queued from the previous steps are now admitted by Kueue:
-```bash
-$ kubectl get pods
-NAME                                                      READY   STATUS    RESTARTS   AGE
-dev-pytorch-text-classifier-7494p-snvm9                   1/1     Running   0          35s
-dev-pytorch-text-classifier-nv9h9-gnqvw                   1/1     Running   0          23s
-dev-pytorch-text-classifier-r8xwd-ksscd                   1/1     Running   0          35s
-dev-pytorch-text-classifier-vwnwk-qmgxg                   1/1     Running   0          35s
-prod-pytorch-text-classifier-gkp9b-r9k5r                  1/1     Running   0          4m53s
-torch-text-classifier-4vd7c-raycluster-jwh8p-head-l29kc   1/1     Running   0          66s
-torch-text-classifier-7494p-raycluster-c9xcs-head-4jdqm   1/1     Running   0          66s
-torch-text-classifier-gkp9b-raycluster-s2f65-head-hfvht   1/1     Running   0          5m23s
-torch-text-classifier-nv9h9-raycluster-z6zk4-head-llwkr   1/1     Running   0          36s
-torch-text-classifier-r8xwd-raycluster-l45f2-head-bvf6v   1/1     Running   0          66s
-torch-text-classifier-vwnwk-raycluster-xxffj-head-gbslc   1/1     Running   0          66s
-```

<!-- Thank you for your contribution! Please review https://github.com/ray-project/ray/blob/master/CONTRIBUTING.rst before opening a pull request. -->

<!-- Please add a reviewer to the assignee section when you create a PR. If you don't have the access to it, we will shortly find a reviewer and assign them to your PR. -->

## Why are these changes needed?

Improve the Kueue/KubeRay priority scheduling doc.

## Related issue number

<!-- For example: "Closes #1234" -->

## Checks

- [ ] I've signed off every commit(by using the -s flag, i.e., `git commit -s`) in this PR.
- [ ] I've run `scripts/format.sh` to lint the changes in this PR.
- [ ] I've included any doc changes needed for https://docs.ray.io/en/master/.
    - [ ] I've added any new APIs to the API Reference. For example, if I added a 
           method in Tune, I've added it in `doc/source/tune/api/` under the 
           corresponding `.rst` file.
- [ ] I've made sure the tests are passing. Note that there might be a few flaky tests, see the recent failures at https://flakey-tests.ray.io/
- Testing Strategy
   - [ ] Unit tests
   - [ ] Release tests
   - [ ] This PR is not tested :(
