diff --git a/docs/user_docs/kubeblocks-for-apecloud-mysql/cluster-management/create-and-connect-an-apecloud-mysql-cluster.md b/docs/user_docs/kubeblocks-for-apecloud-mysql/cluster-management/create-and-connect-an-apecloud-mysql-cluster.md
index 8768cd5f446..ae574556099 100644
--- a/docs/user_docs/kubeblocks-for-apecloud-mysql/cluster-management/create-and-connect-an-apecloud-mysql-cluster.md
+++ b/docs/user_docs/kubeblocks-for-apecloud-mysql/cluster-management/create-and-connect-an-apecloud-mysql-cluster.md
@@ -105,7 +105,7 @@ KubeBlocks supports creating two types of ApeCloud MySQL clusters: Standalone an
 
    KubeBlocks implements a `Cluster` CRD to define a cluster. Here is an example of creating a RaftGroup Cluster.
 
-   If you only have one node for deploying a RaftGroup Cluster, set `spec.affinity.topologyKeys` as `null`. But for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
+   If you only have one node for deploying a RaftGroup Cluster, configure the cluster affinity by setting `spec.schedulingPolicy` or `spec.componentSpecs.schedulingPolicy`. For details, you can refer to the [API docs](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy). But for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
 
    ```yaml
    cat <<EOF | kubectl apply -f -
@@ -197,20 +197,16 @@ KubeBlocks supports creating two types of ApeCloud MySQL clusters: Standalone an
    Create a Standalone.
 
    ```bash
-   kbcli cluster create apecloud-mysql mycluster --namespace demo
+   kbcli cluster create apecloud-mysql mycluster --set mode='standalone' --namespace demo
    ```
 
    Create a RaftGroup Cluster.
 
    ```bash
-   kbcli cluster create apecloud-mysql mycluster --replicas=3 --namespace demo
+   kbcli cluster create apecloud-mysql mycluster --set mode='raftGroup' --namespace demo
    ```
 
-   If you only have one node for deploying a RaftGroup Cluster, set the `topology-keys` as `null` when creating a RaftGroup Cluster. But you should note that for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
-
-   ```bash
-   kbcli cluster create apecloud-mysql mycluster --replicas=3 --topology-keys null --namespace demo
-   ```
+   If you only have one node for deploying a RaftGroup Cluster, you can configure the cluster affinity by setting `--pod-anti-afffinity`, `--tolerations`, and `--topology-keys` when creating a RaftGroup Cluster. But you should note that for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
 
 2. Verify whether this cluster is created successfully.
 
diff --git a/docs/user_docs/kubeblocks-for-elasticsearch/manage-elasticsearch.md b/docs/user_docs/kubeblocks-for-elasticsearch/manage-elasticsearch.md
index 180ac8507b2..66acac2943b 100644
--- a/docs/user_docs/kubeblocks-for-elasticsearch/manage-elasticsearch.md
+++ b/docs/user_docs/kubeblocks-for-elasticsearch/manage-elasticsearch.md
@@ -32,39 +32,95 @@ KubeBlocks supports the management of Elasticsearch. This tutorial illustrates h
 
 <TabItem value="kubectl" label="kubectl" default>
 
-KubeBlocks implements a `Cluster` CRD to define a cluster. Here is an example of creating an Elasticsearch cluster with single node. For more examples, refer to [the GitHub repository](https://github.com/apecloud/kubeblocks-addons/tree/main/examples/elasticsearch).
+KubeBlocks implements a `Cluster` CRD to define a cluster. Here is an example of creating an Elasticsearch cluster with multiple nodes. For more examples, refer to [the GitHub repository](https://github.com/apecloud/kubeblocks-addons/tree/main/examples/elasticsearch).
+
+If you only have one node for deploying a cluster with multiple nodes, configure the cluster affinity by setting `spec.schedulingPolicy` or `spec.componentSpecs.schedulingPolicy`. For details, you can refer to the [API docs](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy). But for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
 
 ```yaml
 cat <<EOF | kubectl apply -f -
 apiVersion: apps.kubeblocks.io/v1
 kind: Cluster
 metadata:
-  name: mycluster
-  namespace: demo
+  name: es-multinode
+  namespace: default
   annotations:
-    kubeblocks.io/extra-env: '{"mode":"single-node"}'
+    kubeblocks.io/extra-env: '{"master-roles":"master", "data-roles": "data", "ingest-roles": "ingest", "transform-roles": "transform"}'
 spec:
   terminationPolicy: Delete
   componentSpecs:
-    - name: mdit
-      componentDef: elasticsearch-8
-      serviceVersion: 8.8.2
-      replicas: 1
-      resources:
-        limits:
-          cpu: "1"
-          memory: "2Gi"
-        requests:
-          cpu: "1"
-          memory: "2Gi"
-      volumeClaimTemplates:
-        - name: data
-          spec:
-            accessModes:
-              - ReadWriteOnce
-            resources:
-              requests:
-                storage: 20Gi
+  - name: master
+    componentDef: elasticsearch-8-1.0.0
+    replicas: 3
+    resources:
+      limits:
+        cpu: '0.5'
+        memory: 2Gi
+      requests:
+        cpu: '0.5'
+        memory: 2Gi
+    volumeClaimTemplates:
+    - name: data
+      spec:
+        accessModes:
+        - ReadWriteOnce
+        resources:
+          requests:
+            storage: 20Gi
+  - name: data
+    componentDef: elasticsearch-8-1.0.0
+    replicas: 3
+    resources:
+      limits:
+        cpu: '0.5'
+        memory: 2Gi
+      requests:
+        cpu: '0.5'
+        memory: 2Gi
+    volumeClaimTemplates:
+    - name: data
+      spec:
+        accessModes:
+        - ReadWriteOnce
+        resources:
+          requests:
+            storage: 20Gi
+  - name: ingest
+    componentDef: elasticsearch-8-1.0.0
+    replicas: 1
+    resources:
+      limits:
+        cpu: '0.5'
+        memory: 2Gi
+      requests:
+        cpu: '0.5'
+        memory: 2Gi
+    volumeClaimTemplates:
+    - name: data
+      spec:
+        accessModes:
+        - ReadWriteOnce
+        resources:
+          requests:
+            storage: 20Gi
+  - name: transform
+    componentDef: elasticsearch-8-1.0.0
+    replicas: 1
+    resources:
+      limits:
+        cpu: '0.5'
+        memory: 2Gi
+      requests:
+        cpu: '0.5'
+        memory: 2Gi
+    volumeClaimTemplates:
+    - name: data
+      spec:
+        accessModes:
+        - ReadWriteOnce
+        resources:
+          requests:
+            storage: 20Gi
+EOF
 ```
 
 | Field                                 | Definition  |
@@ -101,23 +157,21 @@ kubectl get cluster mycluster -n demo -o yaml
 
 ***Steps***
 
-1. Execute the following command to create an Elasticsearch cluster.
+1. Execute the following command to create an Elasticsearch cluster with multiple nodes.
 
    ```bash
    kbcli cluster create elasticsearch mycluster -n demo
    ```
 
-:::note
-
-If you want to customize your cluster specifications, kbcli provides various options, such as setting cluster version, termination policy, CPU, and memory. You can view these options by adding `--help` or `-h` flag.
+   If you want to customize your cluster specifications, kbcli provides various options, such as setting cluster version, termination policy, CPU, and memory. You can view these options by adding `--help` or `-h` flag.
   
-```bash
-kbcli cluster create elasticsearch --help
+   ```bash
+   kbcli cluster create elasticsearch --help
 
-kbcli cluster create elasticsearch -h
-```
+   kbcli cluster create elasticsearch -h
+   ```
 
-:::
+   If you only have one node for deploying a cluster with multiple nodes, you can configure the cluster affinity by setting `--pod-anti-afffinity`, `--tolerations`, and `--topology-keys` when creating a cluster. But you should note that for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
 
 2. Check whether the cluster is created.
 
diff --git a/docs/user_docs/kubeblocks-for-kafka/cluster-management/create-a-kafka-cluster.md b/docs/user_docs/kubeblocks-for-kafka/cluster-management/create-a-kafka-cluster.md
index 8e841acc8a0..cde6aa6048d 100644
--- a/docs/user_docs/kubeblocks-for-kafka/cluster-management/create-a-kafka-cluster.md
+++ b/docs/user_docs/kubeblocks-for-kafka/cluster-management/create-a-kafka-cluster.md
@@ -67,7 +67,7 @@ This document shows how to create a Kafka cluster.
 
 <TabItem value="kubectl" label="kubectl" default>
 
-1. Create a Kafka cluster. If you only have one node for deploying a cluster with multiple replicas, set `spec.componentSpecs.affinity.topologyKeys` as `null`. But for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
+1. Create a Kafka cluster. If you only have one node for deploying a cluster with multiple replicas, configure the cluster affinity by setting `spec.schedulingPolicy` or `spec.componentSpecs.schedulingPolicy`. For details, you can refer to the [API docs](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy). But for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
 
    For more cluster examples, refer to [the GitHub repository](https://github.com/apecloud/kubeblocks-addons/tree/main/examples/kafka).
 
@@ -253,6 +253,8 @@ This document shows how to create a Kafka cluster.
    kbcli cluster create kafka -h
    ```
 
+   If you only have one node for deploying a cluster with multiple replicas, you can configure the cluster affinity by setting `--pod-anti-afffinity`, `--tolerations`, and `--topology-keys` when creating a cluster. But you should note that for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
+
 2. Verify whether this cluster is created successfully.
 
    ```bash
diff --git a/docs/user_docs/kubeblocks-for-milvus/manage-milvus.md b/docs/user_docs/kubeblocks-for-milvus/manage-milvus.md
index b426f73d6da..027af1af04b 100644
--- a/docs/user_docs/kubeblocks-for-milvus/manage-milvus.md
+++ b/docs/user_docs/kubeblocks-for-milvus/manage-milvus.md
@@ -34,7 +34,8 @@ This tutorial illustrates how to create and manage a Milvus cluster by `kbcli`,
 
 <TabItem value="kubectl" label="kubectl" default>
 
-KubeBlocks implements a `Cluster` CRD to define a cluster. Here is an example of creating a Milvus cluster.
+KubeBlocks implements a `Cluster` CRD to define a cluster. Here is an example of creating a Milvus cluster. If you only have one node for deploying a cluster with multiple replicas, configure the cluster affinity by setting `spec.schedulingPolicy` or `spec.componentSpecs.schedulingPolicy`. For details, you can refer to the [API docs](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy). But for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
+
 
 ```yaml
 cat <<EOF | kubectl apply -f -
@@ -301,17 +302,15 @@ kubectl get cluster mycluster -n demo -o yaml
    kbcli cluster create mycluster --cluster-definition=milvus-2.3.2 -n demo
    ```
 
-:::note
-
-If you want to customize your cluster specifications, `kbcli` provides various options, such as setting cluster version, termination policy, CPU, and memory. You can view these options by adding `--help` or `-h` flag.
+   If you want to customize your cluster specifications, `kbcli` provides various options, such as setting cluster version, termination policy, CPU, and memory. You can view these options by adding `--help` or `-h` flag.
 
-```bash
-kbcli cluster create milvus --help
+   ```bash
+   kbcli cluster create milvus --help
 
-kbcli cluster create milvus -h
-```
+   kbcli cluster create milvus -h
+   ```
 
-:::
+   If you only have one node for deploying a cluster with multiple replicas, you can configure the cluster affinity by setting `--pod-anti-afffinity`, `--tolerations`, and `--topology-keys` when creating a cluster. But you should note that for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
 
 2. Check whether the cluster is created successfully.
 
diff --git a/docs/user_docs/kubeblocks-for-mongodb/cluster-management/create-and-connect-to-a-mongodb-cluster.md b/docs/user_docs/kubeblocks-for-mongodb/cluster-management/create-and-connect-to-a-mongodb-cluster.md
index bf9da2b948d..fe66027fdc2 100644
--- a/docs/user_docs/kubeblocks-for-mongodb/cluster-management/create-and-connect-to-a-mongodb-cluster.md
+++ b/docs/user_docs/kubeblocks-for-mongodb/cluster-management/create-and-connect-to-a-mongodb-cluster.md
@@ -100,7 +100,7 @@ KubeBlocks supports creating two types of MongoDB clusters: Standalone and Repli
 
    KubeBlocks implements a `Cluster` CRD to define a cluster. Here is an example of creating a MongoDB Standalone.
 
-   If you only have one node for deploying a ReplicaSet Cluster, set `spec.affinity.topologyKeys` as `null`. But for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
+   If you only have one node for deploying a ReplicaSet Cluster, configure the cluster affinity by setting `spec.schedulingPolicy` or `spec.componentSpecs.schedulingPolicy`. For details, you can refer to the [API docs](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy). But for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
 
    ```yaml
    cat <<EOF | kubectl apply -f -
@@ -191,6 +191,8 @@ KubeBlocks supports creating two types of MongoDB clusters: Standalone and Repli
    kbcli cluster create mongodb -h
    ```
 
+   If you only have one node for deploying a cluster with multiple replicas, you can configure the cluster affinity by setting `--pod-anti-afffinity`, `--tolerations`, and `--topology-keys` when creating a cluster. But you should note that for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
+
 2. Verify whether this cluster is created successfully.
 
    ```bash
diff --git a/docs/user_docs/kubeblocks-for-mysql-community-edition/cluster-management/create-and-connect-a-mysql-cluster.md b/docs/user_docs/kubeblocks-for-mysql-community-edition/cluster-management/create-and-connect-a-mysql-cluster.md
index 1fabdbdbd84..6da43dec54f 100644
--- a/docs/user_docs/kubeblocks-for-mysql-community-edition/cluster-management/create-and-connect-a-mysql-cluster.md
+++ b/docs/user_docs/kubeblocks-for-mysql-community-edition/cluster-management/create-and-connect-a-mysql-cluster.md
@@ -106,7 +106,7 @@ KubeBlocks supports creating two types of MySQL clusters: Standalone and Replica
 
    KubeBlocks implements a `Cluster` CRD to define a cluster. Here is an example of creating a Replication Cluster.
 
-   If you only have one node for deploying a Replication Cluster, set `spec.affinity.topologyKeys` as `null`. But for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
+   If you only have one node for deploying a Replication Cluster, configure the cluster affinity by setting `spec.schedulingPolicy` or `spec.componentSpecs.schedulingPolicy`. For details, you can refer to the [API docs](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy). But for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
 
    ```yaml
    cat <<EOF | kubectl apply -f -
@@ -190,11 +190,7 @@ KubeBlocks supports creating two types of MySQL clusters: Standalone and Replica
    kbcli cluster create mysql -h
    ```
 
-   If you only have one node for deploying a Replication Cluster, set the `--topology-keys` as `null` when creating a Cluster. But you should note that for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
-
-   ```bash
-   kbcli cluster create mysql mycluster --topology-keys null -n demo
-   ```
+   If you only have one node for deploying a Replication Cluster, you can configure the cluster affinity by setting `--pod-anti-afffinity`, `--tolerations`, and `--topology-keys` when creating a Replication Cluster. But you should note that for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
 
 2. Verify whether this cluster is created successfully.
 
diff --git a/docs/user_docs/kubeblocks-for-postgresql/cluster-management/create-and-connect-a-postgresql-cluster.md b/docs/user_docs/kubeblocks-for-postgresql/cluster-management/create-and-connect-a-postgresql-cluster.md
index 903f24bd5ac..6e51bc25d02 100644
--- a/docs/user_docs/kubeblocks-for-postgresql/cluster-management/create-and-connect-a-postgresql-cluster.md
+++ b/docs/user_docs/kubeblocks-for-postgresql/cluster-management/create-and-connect-a-postgresql-cluster.md
@@ -104,7 +104,7 @@ KubeBlocks supports creating two types of PostgreSQL clusters: Standalone and Re
 
 <TabItem value="kubectl" label="kubectl" default>
 
-1. Create a PostgreSQL cluster.
+1. Create a PostgreSQL cluster. If you only have one node for deploying a Replication Cluster, configure the cluster affinity by setting `spec.schedulingPolicy` or `spec.componentSpecs.schedulingPolicy`. For details, you can refer to the [API docs](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy). But for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
 
    KubeBlocks implements a `Cluster` CRD to define a cluster. Here is an example of creating a Replication.
 
@@ -211,11 +211,7 @@ KubeBlocks supports creating two types of PostgreSQL clusters: Standalone and Re
    kbcli cluster create postgresql mycluster --replicas=2 -n demo
    ```
 
-   If you only have one node for deploying a Replication Cluster, set the `--topology-keys` as `null` when creating a Replication Cluster. But you should note that for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
-
-   ```bash
-   kbcli cluster create postgresql mycluster --replicas=2  --topology-keys=null -n demo
-   ```
+   If you only have one node for deploying a RaftGroup Cluster, you can configure the cluster affinity by setting `--pod-anti-afffinity`, `--tolerations`, and `--topology-keys` when creating a Replication Cluster. But you should note that for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
 
 2. Verify whether this cluster is created successfully.
 
diff --git a/docs/user_docs/kubeblocks-for-pulsar/cluster-management/create-pulsar-cluster-on-kubeblocks.md b/docs/user_docs/kubeblocks-for-pulsar/cluster-management/create-pulsar-cluster-on-kubeblocks.md
index f7f4b0a076b..fd6ea875021 100644
--- a/docs/user_docs/kubeblocks-for-pulsar/cluster-management/create-pulsar-cluster-on-kubeblocks.md
+++ b/docs/user_docs/kubeblocks-for-pulsar/cluster-management/create-pulsar-cluster-on-kubeblocks.md
@@ -78,7 +78,7 @@ Refer to the [Pulsar official document](https://pulsar.apache.org/docs/3.1.x/) f
 
 ## Create Pulsar cluster
 
-1. Create a Pulsar cluster in basic mode. For other cluster modes, check out the examples provided in [the GitHub repository](https://github.com/apecloud/kubeblocks-addons/tree/main/examples/pulsar).
+1. Create a Pulsar cluster in basic mode. For other cluster modes, check out the examples provided in [the GitHub repository](https://github.com/apecloud/kubeblocks-addons/tree/main/examples/pulsar). If you only have one node for deploying a Pulsar Cluster, configure the cluster affinity by setting `spec.schedulingPolicy` or `spec.componentSpecs.schedulingPolicy`. For details, you can refer to the [API docs](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy). But for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
 
    ```yaml
    cat <<EOF | kubectl apply -f -
diff --git a/docs/user_docs/kubeblocks-for-qdrant/manage-qdrant.md b/docs/user_docs/kubeblocks-for-qdrant/manage-qdrant.md
index ca6221238aa..4a8029e145b 100644
--- a/docs/user_docs/kubeblocks-for-qdrant/manage-qdrant.md
+++ b/docs/user_docs/kubeblocks-for-qdrant/manage-qdrant.md
@@ -34,7 +34,7 @@ KubeBlocks supports the management of Qdrant. This tutorial illustrates how to c
 
 <TabItem value="kubectl" label="kubectl" default>
 
-KubeBlocks implements a `Cluster` CRD to define a cluster. Here is an example of creating a Qdrant Replication cluster. Primary and Secondary are distributed on different nodes by default. But if you only have one node for deploying a Replication Cluster, set `spec.affinity.topologyKeys` as `null`.
+KubeBlocks implements a `Cluster` CRD to define a cluster. Here is an example of creating a Qdrant Replication cluster. Primary and Secondary are distributed on different nodes by default. But if you only have one node for deploying a Replication Cluster, configure the cluster affinity by setting `spec.schedulingPolicy` or `spec.componentSpecs.schedulingPolicy`. For details, you can refer to the [API docs](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy). But for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
 
 ```yaml
 cat <<EOF | kubectl apply -f -
@@ -43,14 +43,12 @@ kind: Cluster
 metadata:
   name: mycluster
   namespace: demo
-  annotations: {}
 spec:
   terminationPolicy: Delete
   clusterDef: qdrant
   topology: cluster
   componentSpecs:
     - name: qdrant
-      annotations: {}
       serviceVersion: 1.10.0
       replicas: 3
       resources:
@@ -119,6 +117,8 @@ kubectl get cluster mycluster -n demo -o yaml
    kbcli cluster create qdrant -h
    ```
 
+   If you only have one node for deploying a cluster with multiple replicas, you can configure the cluster affinity by setting `--pod-anti-afffinity`, `--tolerations`, and `--topology-keys` when creating a cluster. But you should note that for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
+
 2. Check whether the cluster is created.
 
    ```bash
diff --git a/docs/user_docs/kubeblocks-for-rabbitmq/manage-rabbitmq.md b/docs/user_docs/kubeblocks-for-rabbitmq/manage-rabbitmq.md
index b0f3cf621f4..3c548d846f6 100644
--- a/docs/user_docs/kubeblocks-for-rabbitmq/manage-rabbitmq.md
+++ b/docs/user_docs/kubeblocks-for-rabbitmq/manage-rabbitmq.md
@@ -22,7 +22,7 @@ KubeBlocks supports the management of RabbitMQ. This tutorial illustrates how to
 
 ## Create a cluster
 
-KubeBlocks implements a Cluster CRD to define a cluster. Here is an example of creating a RabbitMQ cluster with three replicas. Pods are distributed on different nodes by default. But if you only have one node for a cluster with three replicas, set `spec.affinity.topologyKeys` as `null`.
+KubeBlocks implements a Cluster CRD to define a cluster. Here is an example of creating a RabbitMQ cluster with three replicas. Pods are distributed on different nodes by default. But if you only have one node for a cluster with three replicas, configure the cluster affinity by setting `spec.schedulingPolicy` or `spec.componentSpecs.schedulingPolicy`. For details, you can refer to the [API docs](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy). But for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
 
 ```yaml
 cat <<EOF | kubectl apply -f -
diff --git a/docs/user_docs/kubeblocks-for-redis/cluster-management/create-and-connect-a-redis-cluster.md b/docs/user_docs/kubeblocks-for-redis/cluster-management/create-and-connect-a-redis-cluster.md
index e8876404dea..ca8205e4a33 100644
--- a/docs/user_docs/kubeblocks-for-redis/cluster-management/create-and-connect-a-redis-cluster.md
+++ b/docs/user_docs/kubeblocks-for-redis/cluster-management/create-and-connect-a-redis-cluster.md
@@ -107,7 +107,9 @@ KubeBlocks supports creating two types of Redis clusters: Standalone and Replica
 
 <TabItem value="kubectl" label="kubectl" default>
 
-KubeBlocks implements a `Cluster` CRD to define a cluster. Here is an example of creating a Replcation. KubeBlocks also supports creating a Redis cluster in other modes. You can refer to the examples provided in the [GitHub repository](https://github.com/apecloud/kubeblocks-addons/tree/main/examples/redis).
+KubeBlocks implements a `Cluster` CRD to define a cluster. Here is an example of creating a Replication cluster. KubeBlocks also supports creating a Redis cluster in other modes. You can refer to the examples provided in the [GitHub repository](https://github.com/apecloud/kubeblocks-addons/tree/main/examples/redis).
+
+If you only have one node for deploying a Replication Cluster, configure the cluster affinity by setting `spec.schedulingPolicy` or `spec.componentSpecs.schedulingPolicy`. For details, you can refer to the [API docs](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy). But for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
 
 ```yaml
 cat <<EOF | kubectl apply -f -
@@ -203,6 +205,8 @@ kubectl get cluster mycluster -n demo -o yaml
    kbcli cluster create redis -h
    ```
 
+   If you only have one node for deploying a cluster with multiple replicas, you can configure the cluster affinity by setting `--pod-anti-afffinity`, `--tolerations`, and `--topology-keys` when creating a cluster. But you should note that for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
+
 2. Verify whether this cluster is created successfully.
 
    ```bash
diff --git a/docs/user_docs/kubeblocks-for-starrocks/manage-starrocks.md b/docs/user_docs/kubeblocks-for-starrocks/manage-starrocks.md
index be6f2415f07..d0d085dec6b 100644
--- a/docs/user_docs/kubeblocks-for-starrocks/manage-starrocks.md
+++ b/docs/user_docs/kubeblocks-for-starrocks/manage-starrocks.md
@@ -32,7 +32,8 @@ This tutorial illustrates how to create and manage a StarRocks cluster by `kbcli
 
 <TabItem value="kubectl" label="kubectl" default>
 
-KubeBlocks implements a `Cluster` CRD to define a cluster. Here is an example of creating a StarRocks cluster.
+KubeBlocks implements a `Cluster` CRD to define a cluster. Here is an example of creating a StarRocks cluster. If you only have one node for deploying a cluster with multiple replicas, configure the cluster affinity by setting `spec.schedulingPolicy` or `spec.componentSpecs.schedulingPolicy`. For details, you can refer to the [API docs](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy). But for a production environment, it is not recommended to deploy all replicas on one node, which may decrease the cluster availability.
+
 
 ```yaml
 cat <<EOF | kubectl apply -f -
diff --git a/docs/user_docs/observability/monitor-database.md b/docs/user_docs/observability/monitor-database.md
index b5de408532e..70595351a72 100644
--- a/docs/user_docs/observability/monitor-database.md
+++ b/docs/user_docs/observability/monitor-database.md
@@ -113,45 +113,39 @@ Make sure `spec.componentSpecs.disableExporter` is set to `false` when creating
 
 ```yaml
 cat <<EOF | kubectl apply -f -
-apiVersion: apps.kubeblocks.io/v1alpha1
+apiVersion: apps.kubeblocks.io/v1
 kind: Cluster
 metadata:
   name: mycluster
   namespace: demo
 spec:
-  clusterDefinitionRef: postgresql
-  clusterVersionRef: postgresql-12.14.0
   terminationPolicy: Delete
-  affinity:
-    podAntiAffinity: Preferred
-    topologyKeys:
-    - kubernetes.io/hostname
-    tenancy: SharedNode
-  tolerations:
-    - key: kb-data
-      operator: Equal
-      value: 'true'
-      effect: NoSchedule
+  clusterDef: postgresql
+  topology: replication
   componentSpecs:
-  - name: postgresql
-    componentDefRef: postgresql
-    disableExporter: true # Set to `false` to enable exporter
-    replicas: 2
-    resources:
-      limits:
-        cpu: '0.5'
-        memory: 0.5Gi
-      requests:
-        cpu: '0.5'
-        memory: 0.5Gi
-    volumeClaimTemplates:
-    - name: data
-      spec:
-        accessModes:
-        - ReadWriteOnce
-        resources:
-          requests:
-            storage: 20Gi
+    - name: postgresql
+      serviceVersion: "14.7.2"
+      disableExporter: false
+      labels:
+        apps.kubeblocks.postgres.patroni/scope: mycluster-postgresql
+      replicas: 2
+      resources:
+        limits:
+          cpu: "0.5"
+          memory: "0.5Gi"
+        requests:
+          cpu: "0.5"
+          memory: "0.5Gi"
+      volumeClaimTemplates:
+        - name: data
+          spec:
+            storageClassName: ""
+            accessModes:
+              - ReadWriteOnce
+            resources:
+              requests:
+                storage: 20Gi
+
 EOF
 ```
 
diff --git a/i18n/zh-cn/user-docs/kubeblocks-for-apecloud-mysql/cluster-management/create-and-connect-an-apecloud-mysql-cluster.md b/i18n/zh-cn/user-docs/kubeblocks-for-apecloud-mysql/cluster-management/create-and-connect-an-apecloud-mysql-cluster.md
index 345294de0af..d472503b26b 100644
--- a/i18n/zh-cn/user-docs/kubeblocks-for-apecloud-mysql/cluster-management/create-and-connect-an-apecloud-mysql-cluster.md
+++ b/i18n/zh-cn/user-docs/kubeblocks-for-apecloud-mysql/cluster-management/create-and-connect-an-apecloud-mysql-cluster.md
@@ -105,7 +105,7 @@ KubeBlocks 支持创建两种类型的 ApeCloud MySQL 集群：单机版（Stand
 
    KubeBlocks 通过 `Cluster` 定义集群。以下是创建 ApeCloud MySQL 集群版的示例。
 
-   如果您只有一个节点可用于部署集群版，可将 `spec.affinity.topologyKeys` 设置为 `null`。但生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
+   如果您只有一个节点可用于部署集群版，可设置 `spec.schedulingPolicy` 或 `spec.componentSpecs.schedulingPolicy`，具体可参考 [API 文档](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy)。但生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
 
    ```yaml
    cat <<EOF | kubectl apply -f -
@@ -200,17 +200,13 @@ KubeBlocks 支持创建两种类型的 ApeCloud MySQL 集群：单机版（Stand
    kbcli cluster create apecloud-mysql -h
    ```
 
-   例如，您可以使用 `--replicas` 指定副本数，创建集群版集群。
+   例如，您可以使用 `--set mode` 指定集群形态为 `raftGroup`，创建集群版集群。
 
    ```bash
-   kbcli cluster create apecloud-mysql mycluster --replicas=3 --namespace demo
+   kbcli cluster create apecloud-mysql mycluster --set mode='raftGroup' --namespace demo
    ```
 
-   如果您只有一个节点用于部署三节点集群，可在创建集群时将 `topology-keys` 设为 `null`。但需要注意的是，生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
-
-   ```bash
-   kbcli cluster create apecloud-mysql mycluster --replicas=3 --topology-keys null --namespace demo
-   ```
+   如果您只有一个节点用于部署集群版集群，可在创建集群时配置集群亲和性，配置 `--pod-anti-afffinity`, `--tolerations` 和 `--topology-keys`。但需要注意的是，生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
 
 2. 验证集群是否创建成功。
 
diff --git a/i18n/zh-cn/user-docs/kubeblocks-for-elasticsearch/manage-elasticsearch.md b/i18n/zh-cn/user-docs/kubeblocks-for-elasticsearch/manage-elasticsearch.md
index 07354c9f4b4..22bd8d937f2 100644
--- a/i18n/zh-cn/user-docs/kubeblocks-for-elasticsearch/manage-elasticsearch.md
+++ b/i18n/zh-cn/user-docs/kubeblocks-for-elasticsearch/manage-elasticsearch.md
@@ -29,13 +29,7 @@ Elasticsearch 是一个分布式、RESTful 风格的搜索和数据分析引擎
 
 <TabItem value="kubectl" label="kubectl" default>
 
-KubeBlocks 通过 `Cluster` 定义集群。以下是创建 Elasticsearch 集群的示例。Pod 默认分布在不同节点。但如果您只有一个节点可用于部署集群，可将 `spec.affinity.topologyKeys` 设置为 `null`。
-
-:::note
-
-生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
-
-:::
+KubeBlocks 通过 `Cluster` 定义集群。以下是创建 Elasticsearch 集群的示例。KubeBlocks 还支持创建Pod 默认分布在不同节点。如果您只有一个节点可用于部署集群，可设置 `spec.schedulingPolicy` 或 `spec.componentSpecs.schedulingPolicy`，具体可参考 [API 文档](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy)。但生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
 
 ```yaml
 cat <<EOF | kubectl apply -f -
@@ -45,29 +39,83 @@ metadata:
   name: mycluster
   namespace: demo
   annotations:
-    kubeblocks.io/extra-env: '{"mode":"single-node"}'
+    kubeblocks.io/extra-env: '{"master-roles":"master", "data-roles": "data", "ingest-roles": "ingest", "transform-roles": "transform"}'
 spec:
   terminationPolicy: Delete
   componentSpecs:
-    - name: mdit
-      componentDef: elasticsearch-8
-      serviceVersion: 8.8.2
-      replicas: 1
-      resources:
-        limits:
-          cpu: "1"
-          memory: "2Gi"
-        requests:
-          cpu: "1"
-          memory: "2Gi"
-      volumeClaimTemplates:
-        - name: data
-          spec:
-            accessModes:
-              - ReadWriteOnce
-            resources:
-              requests:
-                storage: 20Gi
+  - name: master
+    componentDef: elasticsearch-8-1.0.0
+    replicas: 3
+    resources:
+      limits:
+        cpu: '0.5'
+        memory: 2Gi
+      requests:
+        cpu: '0.5'
+        memory: 2Gi
+    volumeClaimTemplates:
+    - name: data
+      spec:
+        accessModes:
+        - ReadWriteOnce
+        resources:
+          requests:
+            storage: 20Gi
+  - name: data
+    componentDef: elasticsearch-8-1.0.0
+    replicas: 3
+    resources:
+      limits:
+        cpu: '0.5'
+        memory: 2Gi
+      requests:
+        cpu: '0.5'
+        memory: 2Gi
+    volumeClaimTemplates:
+    - name: data
+      spec:
+        accessModes:
+        - ReadWriteOnce
+        resources:
+          requests:
+            storage: 20Gi
+  - name: ingest
+    componentDef: elasticsearch-8-1.0.0
+    replicas: 1
+    resources:
+      limits:
+        cpu: '0.5'
+        memory: 2Gi
+      requests:
+        cpu: '0.5'
+        memory: 2Gi
+    volumeClaimTemplates:
+    - name: data
+      spec:
+        accessModes:
+        - ReadWriteOnce
+        resources:
+          requests:
+            storage: 20Gi
+  - name: transform
+    componentDef: elasticsearch-8-1.0.0
+    replicas: 1
+    resources:
+      limits:
+        cpu: '0.5'
+        memory: 2Gi
+      requests:
+        cpu: '0.5'
+        memory: 2Gi
+    volumeClaimTemplates:
+    - name: data
+      spec:
+        accessModes:
+        - ReadWriteOnce
+        resources:
+          requests:
+            storage: 20Gi
+EOF
 ```
 
 | 字段                                   | 定义  |
@@ -115,6 +163,8 @@ kubectl get cluster mycluster -n demo -o yaml
    kbcli cluster create elasticsearch -h
    ```
 
+   如果您只有一个节点用于部署多副本集群，可在创建集群时配置集群亲和性，配置 `--pod-anti-afffinity`, `--tolerations` 和 `--topology-keys`。但需要注意的是，生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
+
 2. 查看集群是否已创建。
 
    ```bash
diff --git a/i18n/zh-cn/user-docs/kubeblocks-for-kafka/cluster-management/create-a-kafka-cluster.md b/i18n/zh-cn/user-docs/kubeblocks-for-kafka/cluster-management/create-a-kafka-cluster.md
index b2cfc921d71..159efa95142 100644
--- a/i18n/zh-cn/user-docs/kubeblocks-for-kafka/cluster-management/create-a-kafka-cluster.md
+++ b/i18n/zh-cn/user-docs/kubeblocks-for-kafka/cluster-management/create-a-kafka-cluster.md
@@ -71,7 +71,7 @@ import TabItem from '@theme/TabItem';
 
    KubeBlocks 通过 `Cluster` 定义集群。以下为创建不同模式 Kafka 集群的示例。
 
-   如果您只有一个节点可用于部署集群版，可将 `spec.affinity.topologyKeys` 设置为 `null`。但生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
+   如果您只有一个节点可用于部署多副本集群，可设置 `spec.schedulingPolicy` 或 `spec.componentSpecs.schedulingPolicy`，具体可参考 [API 文档](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy)。但生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
 
    * 创建组合模式的 Kafka 集群。
 
@@ -254,6 +254,8 @@ import TabItem from '@theme/TabItem';
    kbcli cluster create kafka -h
    ```
 
+   如果您只有一个节点用于部署多副本集群，可在创建集群时配置集群亲和性，配置 `--pod-anti-afffinity`, `--tolerations` 和 `--topology-keys`。但需要注意的是，生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
+
 2. 验证集群是否创建成功。
 
    ```bash
diff --git a/i18n/zh-cn/user-docs/kubeblocks-for-milvus/manage-milvus.md b/i18n/zh-cn/user-docs/kubeblocks-for-milvus/manage-milvus.md
index 0b0deef45cc..bb38bce571c 100644
--- a/i18n/zh-cn/user-docs/kubeblocks-for-milvus/manage-milvus.md
+++ b/i18n/zh-cn/user-docs/kubeblocks-for-milvus/manage-milvus.md
@@ -38,13 +38,7 @@ Milvus 是高度灵活、可靠且速度极快的云原生开源矢量数据库
 
 <TabItem value="kubectl" label="kubectl" default>
 
-KubeBlocks 通过 `Cluster` 定义集群。以下是创建 Milvus 集群的示例。Pod 默认分布在不同节点。但如果您只有一个节点可用于部署集群，可将 `spec.affinity.topologyKeys` 设置为 `null`。
-
-:::note
-
-生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
-
-:::
+KubeBlocks 通过 `Cluster` 定义集群。以下是创建 Milvus 集群的示例。Pod 默认分布在不同节点。如果您只有一个节点可用于部署多副本集群，可设置 `spec.schedulingPolicy` 或 `spec.componentSpecs.schedulingPolicy`，具体可参考 [API 文档](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy)。但生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
 
 ```yaml
 cat <<EOF | kubectl apply -f -
@@ -317,6 +311,8 @@ kubectl get cluster mycluster -n demo -o yaml
    kbcli cluster create milvus -h
    ```
 
+   如果您只有一个节点用于部署集群版集群，可在创建集群时配置集群亲和性，配置 `--pod-anti-afffinity`, `--tolerations` 和 `--topology-keys`。但需要注意的是，生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
+
 2. 检查集群是否已创建。
 
    ```bash
diff --git a/i18n/zh-cn/user-docs/kubeblocks-for-mongodb/cluster-management/create-and-connect-to-a-mongodb-cluster.md b/i18n/zh-cn/user-docs/kubeblocks-for-mongodb/cluster-management/create-and-connect-to-a-mongodb-cluster.md
index 04a01915dc7..4af7b4154cc 100644
--- a/i18n/zh-cn/user-docs/kubeblocks-for-mongodb/cluster-management/create-and-connect-to-a-mongodb-cluster.md
+++ b/i18n/zh-cn/user-docs/kubeblocks-for-mongodb/cluster-management/create-and-connect-to-a-mongodb-cluster.md
@@ -90,7 +90,7 @@ import TabItem from '@theme/TabItem';
 
 ### 创建集群
 
-KubeBlocks 支持创建两种 MongoDB 集群：单机版（Standalone）和主备版（ReplicaSet）。MongoDB 单机版仅支持一个副本，适用于对可用性要求较低的场景。对于高可用性要求较高的场景，建议创建主备版集群，以支持自动故障切换。为了确保高可用性，所有的副本都默认分布在不同的节点上。
+KubeBlocks 支持创建两种 MongoDB 集群：单机版（Standalone）和主备版（ReplicaSet）。MongoDB 单机版仅支持一个副本，适用于对可用性要求较低的场景。对于高可用性要求较高的场景，建议创建主备版集群，以支持自动故障切换。为了确保高可用性，所有的副本都默认分布在不同的节点上。如果您只有一个节点可用于部署主备版集群，可设置 `spec.schedulingPolicy` 或 `spec.componentSpecs.schedulingPolicy`，具体可参考 [API 文档](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy)。但生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
 
 <Tabs>
 
@@ -192,11 +192,7 @@ KubeBlocks 支持创建两种 MongoDB 集群：单机版（Standalone）和主
    kbcli cluster create mongodb mycluster --mode replicaset -n demo
    ```
 
-   如果只有一个节点用于部署主备版集群，请在创建集群时将 `topology-keys` 设置为 `null`。但需要注意的是，生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
-
-   ```bash
-   kbcli cluster create mongodb mycluster --mode replicaset --topology-keys null -n demo
-   ```
+   如果您只有一个节点用于部署主备版集群，可在创建集群时配置集群亲和性，配置 `--pod-anti-afffinity`, `--tolerations` 和 `--topology-keys`。但需要注意的是，生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
 
 2. 验证集群是否创建成功。
 
diff --git a/i18n/zh-cn/user-docs/kubeblocks-for-mysql-community-edition/cluster-management/create-and-connect-a-mysql-cluster.md b/i18n/zh-cn/user-docs/kubeblocks-for-mysql-community-edition/cluster-management/create-and-connect-a-mysql-cluster.md
index 7db741d2322..9f40690a307 100644
--- a/i18n/zh-cn/user-docs/kubeblocks-for-mysql-community-edition/cluster-management/create-and-connect-a-mysql-cluster.md
+++ b/i18n/zh-cn/user-docs/kubeblocks-for-mysql-community-edition/cluster-management/create-and-connect-a-mysql-cluster.md
@@ -103,10 +103,10 @@ KubeBlocks 支持创建两种类型的 MySQL 集群：单机版（Standalone）
 <TabItem value="kubectl" label="kubectl" default>
 
 1. 创建 MySQL 集群。
-   
+
    KubeBlocks 通过 `Cluster` 定义集群。以下是创建 MySQL 主备版的示例。
 
-   如果您只有一个节点可用于部署集群版，可将 `spec.affinity.topologyKeys` 设置为 `null`。但生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
+   如果您只有一个节点可用于部署主备版集群，可设置 `spec.schedulingPolicy` 或 `spec.componentSpecs.schedulingPolicy`，具体可参考 [API 文档](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy)。但生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
 
    ```yaml
    cat <<EOF | kubectl apply -f -
@@ -196,11 +196,7 @@ KubeBlocks 支持创建两种类型的 MySQL 集群：单机版（Standalone）
    kbcli cluster create mysql -h
    ```
 
-   例如，如果您只有一个节点可用于部署主备版，可将 `topology-keys` 设置为 `null`。
-
-   ```bash
-   kbcli cluster create mysql mycluster --topology-keys=null -n demo
-   ```
+   如果您只有一个节点用于部署主备版集群，可在创建集群时配置集群亲和性，配置 `--pod-anti-afffinity`, `--tolerations` 和 `--topology-keys`。但需要注意的是，生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
 
 2. 验证集群是否创建成功。
 
diff --git a/i18n/zh-cn/user-docs/kubeblocks-for-postgresql/cluster-management/create-and-connect-a-postgresql-cluster.md b/i18n/zh-cn/user-docs/kubeblocks-for-postgresql/cluster-management/create-and-connect-a-postgresql-cluster.md
index 22125074c49..4d88b655de3 100644
--- a/i18n/zh-cn/user-docs/kubeblocks-for-postgresql/cluster-management/create-and-connect-a-postgresql-cluster.md
+++ b/i18n/zh-cn/user-docs/kubeblocks-for-postgresql/cluster-management/create-and-connect-a-postgresql-cluster.md
@@ -108,7 +108,7 @@ KubeBlocks 支持创建两种 PostgreSQL 集群：单机版（Standalone）和
 
 1. 创建 PostgreSQL 集群。
 
-   KubeBlocks 通过 `Cluster` 定义集群。以下是创建 PostgreSQL 主备版的示例。
+   KubeBlocks 通过 `Cluster` 定义集群。以下是创建 PostgreSQL 主备版的示例。如果您只有一个节点可用于部署主备版集群，可设置 `spec.schedulingPolicy` 或 `spec.componentSpecs.schedulingPolicy`，具体可参考 [API 文档](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy)。但生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
 
    ```yaml
    cat <<EOF | kubectl apply -f -
@@ -214,11 +214,7 @@ KubeBlocks 支持创建两种 PostgreSQL 集群：单机版（Standalone）和
    kbcli cluster create postgresql mycluster --replicas=2 -n demo
    ```
 
-   如果您只有一个节点用于部署三节点集群，可在创建集群时将 `topology-keys` 设为 `null`。但需要注意的是，生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
-
-   ```bash
-   kbcli cluster create postgresql mycluster --replicas=2 --topology-keys=null -n demo
-   ```
+   如果您只有一个节点用于部署主备版集群，可在创建集群时配置集群亲和性，配置 `--pod-anti-afffinity`, `--tolerations` 和 `--topology-keys`。但需要注意的是，生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
 
 2. 验证集群是否创建成功。
 
diff --git a/i18n/zh-cn/user-docs/kubeblocks-for-qdrant/manage-qdrant.md b/i18n/zh-cn/user-docs/kubeblocks-for-qdrant/manage-qdrant.md
index 2ed40bad67c..0d0f225ddd3 100644
--- a/i18n/zh-cn/user-docs/kubeblocks-for-qdrant/manage-qdrant.md
+++ b/i18n/zh-cn/user-docs/kubeblocks-for-qdrant/manage-qdrant.md
@@ -38,13 +38,7 @@ Qdrant（读作：quadrant）是向量相似性搜索引擎和向量数据库。
 
 <TabItem value="kubectl" label="kubectl" default>
 
-KubeBlocks 通过 `Cluster` 定义集群。以下是创建 Qdrant 集群的示例。Pod 默认分布在不同节点。但如果您只有一个节点可用于部署集群，可将 `spec.affinity.topologyKeys` 设置为 `null`。
-
-:::note
-
-生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
-
-:::
+KubeBlocks 通过 `Cluster` 定义集群。以下是创建 Qdrant 集群的示例。Pod 默认分布在不同节点。如果您只有一个节点可用于部署多副本集群，可设置 `spec.schedulingPolicy` 或 `spec.componentSpecs.schedulingPolicy`，具体可参考 [API 文档](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy)。但生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
 
 ```yaml
 cat <<EOF | kubectl apply -f -
@@ -53,14 +47,12 @@ kind: Cluster
 metadata:
   name: mycluster
   namespace: demo
-  annotations: {}
 spec:
   terminationPolicy: Delete
   clusterDef: qdrant
   topology: cluster
   componentSpecs:
     - name: qdrant
-      annotations: {}
       serviceVersion: 1.10.0
       replicas: 3
       resources:
@@ -128,6 +120,8 @@ kubectl get cluster mycluster -n demo -o yaml
    kbcli cluster create qdrant -h
    ```
 
+   如果您只有一个节点用于部署多副本集群，可在创建集群时配置集群亲和性，配置 `--pod-anti-afffinity`, `--tolerations` 和 `--topology-keys`。但需要注意的是，生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
+
 2. 检查集群是否已创建。
 
    ```bash
diff --git a/i18n/zh-cn/user-docs/kubeblocks-for-rabbitmq/manage-rabbitmq.md b/i18n/zh-cn/user-docs/kubeblocks-for-rabbitmq/manage-rabbitmq.md
index aa9debbc09e..030ed7b1868 100644
--- a/i18n/zh-cn/user-docs/kubeblocks-for-rabbitmq/manage-rabbitmq.md
+++ b/i18n/zh-cn/user-docs/kubeblocks-for-rabbitmq/manage-rabbitmq.md
@@ -28,13 +28,7 @@ RabbitMQ 是可靠且成熟的消息和流处理中间件，支持在云环境
 
 ## 创建集群
 
-KubeBlocks 通过 `Cluster` 定义集群。以下是创建 RabbitMQ 集群的示例。Pod 默认分布在不同节点。但如果您只有一个节点可用于部署集群，可将 `spec.affinity.topologyKeys` 设置为 `null`。
-
-:::note
-
-生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
-
-:::
+KubeBlocks 通过 `Cluster` 定义集群。以下是创建 RabbitMQ 集群的示例。Pod 默认分布在不同节点。如果您只有一个节点可用于部署多副本集群，可设置 `spec.schedulingPolicy` 或 `spec.componentSpecs.schedulingPolicy`，具体可参考 [API 文档](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy)。但生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
 
 ```yaml
 cat <<EOF | kubectl apply -f -
diff --git a/i18n/zh-cn/user-docs/kubeblocks-for-redis/cluster-management/create-and-connect-to-a-redis-cluster.md b/i18n/zh-cn/user-docs/kubeblocks-for-redis/cluster-management/create-and-connect-to-a-redis-cluster.md
index 9607949a86e..375e770d661 100644
--- a/i18n/zh-cn/user-docs/kubeblocks-for-redis/cluster-management/create-and-connect-to-a-redis-cluster.md
+++ b/i18n/zh-cn/user-docs/kubeblocks-for-redis/cluster-management/create-and-connect-to-a-redis-cluster.md
@@ -101,7 +101,7 @@ import TabItem from '@theme/TabItem';
 
 ### 创建集群
 
-KubeBlocks 支持创建两种 Redis 集群：单机版（Standalone）和主备版（Replication）。Redis 单机版仅支持一个副本，适用于对可用性要求较低的场景。 对于高可用性要求较高的场景，建议创建主备版集群，以支持自动故障切换。为了确保高可用性，所有的副本都默认分布在不同的节点上。
+KubeBlocks 支持创建两种 Redis 集群：单机版（Standalone）和主备版（Replication）。Redis 单机版仅支持一个副本，适用于对可用性要求较低的场景。 对于高可用性要求较高的场景，建议创建主备版集群，以支持自动故障切换。为了确保高可用性，所有的副本都默认分布在不同的节点上。如果您只有一个节点可用于部署多副本集群，可设置 `spec.schedulingPolicy` 或 `spec.componentSpecs.schedulingPolicy`，具体可参考 [API 文档](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy)。但生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
 
 <Tabs>
 
@@ -217,6 +217,8 @@ KubeBlocks 支持创建两种 Redis 集群：单机版（Standalone）和主备
    kbcli cluster create redis -h
    ```
 
+   如果您只有一个节点用于部署多副本集群，可在创建集群时配置集群亲和性，配置 `--pod-anti-afffinity`, `--tolerations` 和 `--topology-keys`。但需要注意的是，生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
+
 2. 验证集群是否创建成功。
 
    ```bash
diff --git a/i18n/zh-cn/user-docs/kubeblocks-for-starrocks/manage-starrocks.md b/i18n/zh-cn/user-docs/kubeblocks-for-starrocks/manage-starrocks.md
index 05a90326fe9..1a07a38b58e 100644
--- a/i18n/zh-cn/user-docs/kubeblocks-for-starrocks/manage-starrocks.md
+++ b/i18n/zh-cn/user-docs/kubeblocks-for-starrocks/manage-starrocks.md
@@ -29,13 +29,7 @@ StarRocks 是一款高性能分析型数据仓库，使用向量化、MPP 架构
 
 <TabItem value="kubectl" label="kubectl" default>
 
-KubeBlocks 通过 `Cluster` 定义集群。以下是创建 StarRocks 集群的示例。Pod 默认分布在不同节点。但如果您只有一个节点可用于部署集群，可将 `spec.affinity.topologyKeys` 设置为 `null`。
-
-:::note
-
-生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
-
-:::
+KubeBlocks 通过 `Cluster` 定义集群。以下是创建 StarRocks 集群的示例。Pod 默认分布在不同节点。如果您只有一个节点可用于部署多副本集群，可设置 `spec.schedulingPolicy` 或 `spec.componentSpecs.schedulingPolicy`，具体可参考 [API 文档](https://kubeblocks.io/docs/preview/developer_docs/api-reference/cluster#apps.kubeblocks.io/v1.SchedulingPolicy)。但生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
 
 ```yaml
 cat <<EOF | kubectl apply -f -
@@ -121,6 +115,8 @@ kubectl get cluster mycluster -n demo -o yaml
    kbcli cluster create -h
    ```
 
+   如果您只有一个节点用于部署多副本集群，可在创建集群时配置集群亲和性，配置 `--pod-anti-afffinity`, `--tolerations` 和 `--topology-keys`。但需要注意的是，生产环境中，不建议将所有副本部署在同一个节点上，因为这可能会降低集群的可用性。
+
 2. 验证集群是否创建成功。
 
    ```bash
diff --git a/i18n/zh-cn/user-docs/observability/monitor-database.md b/i18n/zh-cn/user-docs/observability/monitor-database.md
index 2b6d99b26ad..50ddb6d11bf 100644
--- a/i18n/zh-cn/user-docs/observability/monitor-database.md
+++ b/i18n/zh-cn/user-docs/observability/monitor-database.md
@@ -113,45 +113,39 @@ import TabItem from '@theme/TabItem';
 
 ```yaml
 cat <<EOF | kubectl apply -f -
-apiVersion: apps.kubeblocks.io/v1alpha1
+apiVersion: apps.kubeblocks.io/v1
 kind: Cluster
 metadata:
   name: mycluster
   namespace: demo
 spec:
-  clusterDefinitionRef: postgresql
-  clusterVersionRef: postgresql-12.14.0
   terminationPolicy: Delete
-  affinity:
-    podAntiAffinity: Preferred
-    topologyKeys:
-    - kubernetes.io/hostname
-    tenancy: SharedNode
-  tolerations:
-    - key: kb-data
-      operator: Equal
-      value: 'true'
-      effect: NoSchedule
+  clusterDef: postgresql
+  topology: replication
   componentSpecs:
-  - name: postgresql
-    componentDefRef: postgresql
-    disableExporter: true # 将参数值设为 `false`，开启 exporter
-    replicas: 2
-    resources:
-      limits:
-        cpu: '0.5'
-        memory: 0.5Gi
-      requests:
-        cpu: '0.5'
-        memory: 0.5Gi
-    volumeClaimTemplates:
-    - name: data
-      spec:
-        accessModes:
-        - ReadWriteOnce
-        resources:
-          requests:
-            storage: 20Gi
+    - name: postgresql
+      serviceVersion: "14.7.2"
+      disableExporter: false
+      labels:
+        apps.kubeblocks.postgres.patroni/scope: mycluster-postgresql
+      replicas: 2
+      resources:
+        limits:
+          cpu: "0.5"
+          memory: "0.5Gi"
+        requests:
+          cpu: "0.5"
+          memory: "0.5Gi"
+      volumeClaimTemplates:
+        - name: data
+          spec:
+            storageClassName: ""
+            accessModes:
+              - ReadWriteOnce
+            resources:
+              requests:
+                storage: 20Gi
+
 EOF
 ```