diff --git a/confignode/src/assembly/resources/conf/iotdb-confignode.properties b/confignode/src/assembly/resources/conf/iotdb-confignode.properties
index 43f6f79..4206734 100644
--- a/confignode/src/assembly/resources/conf/iotdb-confignode.properties
+++ b/confignode/src/assembly/resources/conf/iotdb-confignode.properties
@@ -342,25 +342,39 @@
 ####################
 
 # max payload size for a single log-sync-RPC from leader to follower
-# ratis_log_appender_buffer_size_max = 4194304
+# partition_region_ratis_log_appender_buffer_size_max = 4194304
+# schema_region_ratis_log_appender_buffer_size_max = 4194304
+# data_region_ratis_log_appender_buffer_size_max = 4194304
 
 # trigger a snapshot when ratis_snapshot_trigger_threshold logs are written
-# ratis_snapshot_trigger_threshold = 400000
+# partition_region_ratis_snapshot_trigger_threshold = 400000
+# schema_region_ratis_snapshot_trigger_threshold = 400000
+# data_region_ratis_snapshot_trigger_threshold = 400000
 
 # allow flushing Raft Log asynchronously
-# ratis_log_unsafe_flush_enable = false
+# partition_region_ratis_log_unsafe_flush_enable = false
+# schema_region_ratis_log_unsafe_flush_enable = false
+# data_region_ratis_log_unsafe_flush_enable = false
 
 # max capacity of a single Raft Log segment (by default 24MB)
-# ratis_log_segment_size_max = 25165824
+# partition_region_ratis_log_segment_size_max = 25165824
+# schema_region_ratis_log_segment_size_max = 25165824
+# data_region_ratis_log_segment_size_max = 25165824
 
 # flow control window for ratis grpc log appender
-# ratis_grpc_flow_control_window = 4194304
+# partition_region_ratis_grpc_flow_control_window = 4194304
+# schema_region_ratis_grpc_flow_control_window = 4194304
+# data_region_ratis_grpc_flow_control_window = 4194304
 
 # min election timeout for leader election
-# ratis_rpc_leader_election_timeout_min_ms = 2000
+# partition_region_ratis_rpc_leader_election_timeout_min_ms = 2000
+# schema_region_ratis_rpc_leader_election_timeout_min_ms = 2000
+# data_region_ratis_rpc_leader_election_timeout_min_ms = 2000
 
 # max election timeout for leader election
-# ratis_rpc_leader_election_timeout_max_ms = 4000
+# partition_region_ratis_rpc_leader_election_timeout_max_ms = 4000
+# schema_region_ratis_rpc_leader_election_timeout_max_ms = 4000
+# data_region_ratis_rpc_leader_election_timeout_max_ms = 4000
 
 ####################
 ### Disk Monitor
diff --git a/confignode/src/main/java/org/apache/iotdb/confignode/conf/ConfigNodeConfig.java b/confignode/src/main/java/org/apache/iotdb/confignode/conf/ConfigNodeConfig.java
index ad56aad..af1b577 100644
--- a/confignode/src/main/java/org/apache/iotdb/confignode/conf/ConfigNodeConfig.java
+++ b/confignode/src/main/java/org/apache/iotdb/confignode/conf/ConfigNodeConfig.java
@@ -132,28 +132,49 @@
   private String readConsistencyLevel = "strong";
 
   /** RatisConsensus protocol, Max size for a single log append request from leader */
-  private long ratisConsensusLogAppenderBufferSize = 4 * 1024 * 1024L;
+  private long dataRegionRatisConsensusLogAppenderBufferSize = 4 * 1024 * 1024L;
+
+  private long partitionRegionRatisConsensusLogAppenderBufferSize = 4 * 1024 * 1024L;
+  private long schemaRegionRatisConsensusLogAppenderBufferSize = 4 * 1024 * 1024L;
 
   /**
    * RatisConsensus protocol, trigger a snapshot when ratis_snapshot_trigger_threshold logs are
    * written
    */
-  private long ratisSnapshotTriggerThreshold = 400000L;
+  private long dataRegionRatisSnapshotTriggerThreshold = 400000L;
+
+  private long partitionRegionRatisSnapshotTriggerThreshold = 400000L;
+  private long schemaRegionRatisSnapshotTriggerThreshold = 400000L;
 
   /** RatisConsensus protocol, allow flushing Raft Log asynchronously */
-  private boolean ratisLogUnsafeFlushEnable = false;
+  private boolean dataRegionRatisLogUnsafeFlushEnable = false;
+
+  private boolean partitionRegionRatisLogUnsafeFlushEnable = false;
+  private boolean schemaRegionRatisLogUnsafeFlushEnable = false;
 
   /** RatisConsensus protocol, max capacity of a single Raft Log segment */
-  private long ratisLogSegmentSizeMax = 24 * 1024 * 1024L;
+  private long dataRegionRatisLogSegmentSizeMax = 24 * 1024 * 1024L;
+
+  private long partitionRegionRatisLogSegmentSizeMax = 24 * 1024 * 1024L;
+  private long schemaRegionRatisLogSegmentSizeMax = 24 * 1024 * 1024L;
 
   /** RatisConsensus protocol, flow control window for ratis grpc log appender */
-  private long ratisGrpcFlowControlWindow = 4 * 1024 * 1024L;
+  private long dataRegionRatisGrpcFlowControlWindow = 4 * 1024 * 1024L;
+
+  private long partitionRegionRatisGrpcFlowControlWindow = 4 * 1024 * 1024L;
+  private long schemaRegionRatisGrpcFlowControlWindow = 4 * 1024 * 1024L;
 
   /** RatisConsensus protocol, min election timeout for leader election */
-  private long ratisRpcLeaderElectionTimeoutMinMs = 2000L;
+  private long dataRegionRatisRpcLeaderElectionTimeoutMinMs = 2000L;
+
+  private long partitionRegionRatisRpcLeaderElectionTimeoutMinMs = 2000L;
+  private long schemaRegionRatisRpcLeaderElectionTimeoutMinMs = 2000L;
 
   /** RatisConsensus protocol, max election timeout for leader election */
-  private long ratisRpcLeaderElectionTimeoutMaxMs = 4000L;
+  private long dataRegionRatisRpcLeaderElectionTimeoutMaxMs = 4000L;
+
+  private long partitionRegionRatisRpcLeaderElectionTimeoutMaxMs = 4000L;
+  private long schemaRegionRatisRpcLeaderElectionTimeoutMaxMs = 4000L;
 
   public ConfigNodeConfig() {
     // empty constructor
@@ -436,59 +457,197 @@
     this.readConsistencyLevel = readConsistencyLevel;
   }
 
-  public long getRatisConsensusLogAppenderBufferSize() {
-    return ratisConsensusLogAppenderBufferSize;
+  public long getDataRegionRatisConsensusLogAppenderBufferSize() {
+    return dataRegionRatisConsensusLogAppenderBufferSize;
   }
 
-  public void setRatisConsensusLogAppenderBufferSize(long ratisConsensusLogAppenderBufferSize) {
-    this.ratisConsensusLogAppenderBufferSize = ratisConsensusLogAppenderBufferSize;
+  public void setDataRegionRatisConsensusLogAppenderBufferSize(
+      long dataRegionRatisConsensusLogAppenderBufferSize) {
+    this.dataRegionRatisConsensusLogAppenderBufferSize =
+        dataRegionRatisConsensusLogAppenderBufferSize;
   }
 
-  public long getRatisSnapshotTriggerThreshold() {
-    return ratisSnapshotTriggerThreshold;
+  public long getDataRegionRatisSnapshotTriggerThreshold() {
+    return dataRegionRatisSnapshotTriggerThreshold;
   }
 
-  public void setRatisSnapshotTriggerThreshold(long ratisSnapshotTriggerThreshold) {
-    this.ratisSnapshotTriggerThreshold = ratisSnapshotTriggerThreshold;
+  public void setDataRegionRatisSnapshotTriggerThreshold(
+      long dataRegionRatisSnapshotTriggerThreshold) {
+    this.dataRegionRatisSnapshotTriggerThreshold = dataRegionRatisSnapshotTriggerThreshold;
   }
 
-  public boolean isRatisLogUnsafeFlushEnable() {
-    return ratisLogUnsafeFlushEnable;
+  public boolean isDataRegionRatisLogUnsafeFlushEnable() {
+    return dataRegionRatisLogUnsafeFlushEnable;
   }
 
-  public void setRatisLogUnsafeFlushEnable(boolean ratisLogUnsafeFlushEnable) {
-    this.ratisLogUnsafeFlushEnable = ratisLogUnsafeFlushEnable;
+  public void setDataRegionRatisLogUnsafeFlushEnable(boolean dataRegionRatisLogUnsafeFlushEnable) {
+    this.dataRegionRatisLogUnsafeFlushEnable = dataRegionRatisLogUnsafeFlushEnable;
   }
 
-  public long getRatisLogSegmentSizeMax() {
-    return ratisLogSegmentSizeMax;
+  public long getDataRegionRatisLogSegmentSizeMax() {
+    return dataRegionRatisLogSegmentSizeMax;
   }
 
-  public void setRatisLogSegmentSizeMax(long ratisLogSegmentSizeMax) {
-    this.ratisLogSegmentSizeMax = ratisLogSegmentSizeMax;
+  public void setDataRegionRatisLogSegmentSizeMax(long dataRegionRatisLogSegmentSizeMax) {
+    this.dataRegionRatisLogSegmentSizeMax = dataRegionRatisLogSegmentSizeMax;
   }
 
-  public long getRatisGrpcFlowControlWindow() {
-    return ratisGrpcFlowControlWindow;
+  public long getDataRegionRatisGrpcFlowControlWindow() {
+    return dataRegionRatisGrpcFlowControlWindow;
   }
 
-  public void setRatisGrpcFlowControlWindow(long ratisGrpcFlowControlWindow) {
-    this.ratisGrpcFlowControlWindow = ratisGrpcFlowControlWindow;
+  public void setDataRegionRatisGrpcFlowControlWindow(long dataRegionRatisGrpcFlowControlWindow) {
+    this.dataRegionRatisGrpcFlowControlWindow = dataRegionRatisGrpcFlowControlWindow;
   }
 
-  public long getRatisRpcLeaderElectionTimeoutMinMs() {
-    return ratisRpcLeaderElectionTimeoutMinMs;
+  public long getDataRegionRatisRpcLeaderElectionTimeoutMinMs() {
+    return dataRegionRatisRpcLeaderElectionTimeoutMinMs;
   }
 
-  public void setRatisRpcLeaderElectionTimeoutMinMs(long ratisRpcLeaderElectionTimeoutMinMs) {
-    this.ratisRpcLeaderElectionTimeoutMinMs = ratisRpcLeaderElectionTimeoutMinMs;
+  public void setDataRegionRatisRpcLeaderElectionTimeoutMinMs(
+      long dataRegionRatisRpcLeaderElectionTimeoutMinMs) {
+    this.dataRegionRatisRpcLeaderElectionTimeoutMinMs =
+        dataRegionRatisRpcLeaderElectionTimeoutMinMs;
   }
 
-  public long getRatisRpcLeaderElectionTimeoutMaxMs() {
-    return ratisRpcLeaderElectionTimeoutMaxMs;
+  public long getDataRegionRatisRpcLeaderElectionTimeoutMaxMs() {
+    return dataRegionRatisRpcLeaderElectionTimeoutMaxMs;
   }
 
-  public void setRatisRpcLeaderElectionTimeoutMaxMs(long ratisRpcLeaderElectionTimeoutMaxMs) {
-    this.ratisRpcLeaderElectionTimeoutMaxMs = ratisRpcLeaderElectionTimeoutMaxMs;
+  public void setDataRegionRatisRpcLeaderElectionTimeoutMaxMs(
+      long dataRegionRatisRpcLeaderElectionTimeoutMaxMs) {
+    this.dataRegionRatisRpcLeaderElectionTimeoutMaxMs =
+        dataRegionRatisRpcLeaderElectionTimeoutMaxMs;
+  }
+
+  public long getPartitionRegionRatisConsensusLogAppenderBufferSize() {
+    return partitionRegionRatisConsensusLogAppenderBufferSize;
+  }
+
+  public void setPartitionRegionRatisConsensusLogAppenderBufferSize(
+      long partitionRegionRatisConsensusLogAppenderBufferSize) {
+    this.partitionRegionRatisConsensusLogAppenderBufferSize =
+        partitionRegionRatisConsensusLogAppenderBufferSize;
+  }
+
+  public long getPartitionRegionRatisSnapshotTriggerThreshold() {
+    return partitionRegionRatisSnapshotTriggerThreshold;
+  }
+
+  public void setPartitionRegionRatisSnapshotTriggerThreshold(
+      long partitionRegionRatisSnapshotTriggerThreshold) {
+    this.partitionRegionRatisSnapshotTriggerThreshold =
+        partitionRegionRatisSnapshotTriggerThreshold;
+  }
+
+  public boolean isPartitionRegionRatisLogUnsafeFlushEnable() {
+    return partitionRegionRatisLogUnsafeFlushEnable;
+  }
+
+  public void setPartitionRegionRatisLogUnsafeFlushEnable(
+      boolean partitionRegionRatisLogUnsafeFlushEnable) {
+    this.partitionRegionRatisLogUnsafeFlushEnable = partitionRegionRatisLogUnsafeFlushEnable;
+  }
+
+  public long getPartitionRegionRatisLogSegmentSizeMax() {
+    return partitionRegionRatisLogSegmentSizeMax;
+  }
+
+  public void setPartitionRegionRatisLogSegmentSizeMax(long partitionRegionRatisLogSegmentSizeMax) {
+    this.partitionRegionRatisLogSegmentSizeMax = partitionRegionRatisLogSegmentSizeMax;
+  }
+
+  public long getPartitionRegionRatisGrpcFlowControlWindow() {
+    return partitionRegionRatisGrpcFlowControlWindow;
+  }
+
+  public void setPartitionRegionRatisGrpcFlowControlWindow(
+      long partitionRegionRatisGrpcFlowControlWindow) {
+    this.partitionRegionRatisGrpcFlowControlWindow = partitionRegionRatisGrpcFlowControlWindow;
+  }
+
+  public long getPartitionRegionRatisRpcLeaderElectionTimeoutMinMs() {
+    return partitionRegionRatisRpcLeaderElectionTimeoutMinMs;
+  }
+
+  public void setPartitionRegionRatisRpcLeaderElectionTimeoutMinMs(
+      long partitionRegionRatisRpcLeaderElectionTimeoutMinMs) {
+    this.partitionRegionRatisRpcLeaderElectionTimeoutMinMs =
+        partitionRegionRatisRpcLeaderElectionTimeoutMinMs;
+  }
+
+  public long getPartitionRegionRatisRpcLeaderElectionTimeoutMaxMs() {
+    return partitionRegionRatisRpcLeaderElectionTimeoutMaxMs;
+  }
+
+  public void setPartitionRegionRatisRpcLeaderElectionTimeoutMaxMs(
+      long partitionRegionRatisRpcLeaderElectionTimeoutMaxMs) {
+    this.partitionRegionRatisRpcLeaderElectionTimeoutMaxMs =
+        partitionRegionRatisRpcLeaderElectionTimeoutMaxMs;
+  }
+
+  public long getSchemaRegionRatisConsensusLogAppenderBufferSize() {
+    return schemaRegionRatisConsensusLogAppenderBufferSize;
+  }
+
+  public void setSchemaRegionRatisConsensusLogAppenderBufferSize(
+      long schemaRegionRatisConsensusLogAppenderBufferSize) {
+    this.schemaRegionRatisConsensusLogAppenderBufferSize =
+        schemaRegionRatisConsensusLogAppenderBufferSize;
+  }
+
+  public long getSchemaRegionRatisSnapshotTriggerThreshold() {
+    return schemaRegionRatisSnapshotTriggerThreshold;
+  }
+
+  public void setSchemaRegionRatisSnapshotTriggerThreshold(
+      long schemaRegionRatisSnapshotTriggerThreshold) {
+    this.schemaRegionRatisSnapshotTriggerThreshold = schemaRegionRatisSnapshotTriggerThreshold;
+  }
+
+  public boolean isSchemaRegionRatisLogUnsafeFlushEnable() {
+    return schemaRegionRatisLogUnsafeFlushEnable;
+  }
+
+  public void setSchemaRegionRatisLogUnsafeFlushEnable(
+      boolean schemaRegionRatisLogUnsafeFlushEnable) {
+    this.schemaRegionRatisLogUnsafeFlushEnable = schemaRegionRatisLogUnsafeFlushEnable;
+  }
+
+  public long getSchemaRegionRatisLogSegmentSizeMax() {
+    return schemaRegionRatisLogSegmentSizeMax;
+  }
+
+  public void setSchemaRegionRatisLogSegmentSizeMax(long schemaRegionRatisLogSegmentSizeMax) {
+    this.schemaRegionRatisLogSegmentSizeMax = schemaRegionRatisLogSegmentSizeMax;
+  }
+
+  public long getSchemaRegionRatisGrpcFlowControlWindow() {
+    return schemaRegionRatisGrpcFlowControlWindow;
+  }
+
+  public void setSchemaRegionRatisGrpcFlowControlWindow(
+      long schemaRegionRatisGrpcFlowControlWindow) {
+    this.schemaRegionRatisGrpcFlowControlWindow = schemaRegionRatisGrpcFlowControlWindow;
+  }
+
+  public long getSchemaRegionRatisRpcLeaderElectionTimeoutMinMs() {
+    return schemaRegionRatisRpcLeaderElectionTimeoutMinMs;
+  }
+
+  public void setSchemaRegionRatisRpcLeaderElectionTimeoutMinMs(
+      long schemaRegionRatisRpcLeaderElectionTimeoutMinMs) {
+    this.schemaRegionRatisRpcLeaderElectionTimeoutMinMs =
+        schemaRegionRatisRpcLeaderElectionTimeoutMinMs;
+  }
+
+  public long getSchemaRegionRatisRpcLeaderElectionTimeoutMaxMs() {
+    return schemaRegionRatisRpcLeaderElectionTimeoutMaxMs;
+  }
+
+  public void setSchemaRegionRatisRpcLeaderElectionTimeoutMaxMs(
+      long schemaRegionRatisRpcLeaderElectionTimeoutMaxMs) {
+    this.schemaRegionRatisRpcLeaderElectionTimeoutMaxMs =
+        schemaRegionRatisRpcLeaderElectionTimeoutMaxMs;
   }
 }
diff --git a/confignode/src/main/java/org/apache/iotdb/confignode/conf/ConfigNodeDescriptor.java b/confignode/src/main/java/org/apache/iotdb/confignode/conf/ConfigNodeDescriptor.java
index c4e81b1..2167564 100644
--- a/confignode/src/main/java/org/apache/iotdb/confignode/conf/ConfigNodeDescriptor.java
+++ b/confignode/src/main/java/org/apache/iotdb/confignode/conf/ConfigNodeDescriptor.java
@@ -282,46 +282,131 @@
   }
 
   private void loadRatisConsensusConfig(Properties properties) {
-    conf.setRatisConsensusLogAppenderBufferSize(
+    conf.setDataRegionRatisConsensusLogAppenderBufferSize(
         Long.parseLong(
             properties.getProperty(
-                "ratis_log_appender_buffer_size_max",
-                String.valueOf(conf.getRatisConsensusLogAppenderBufferSize()))));
+                "data_region_ratis_log_appender_buffer_size_max",
+                String.valueOf(conf.getDataRegionRatisConsensusLogAppenderBufferSize()))));
 
-    conf.setRatisSnapshotTriggerThreshold(
+    conf.setPartitionRegionRatisConsensusLogAppenderBufferSize(
         Long.parseLong(
             properties.getProperty(
-                "ratis_snapshot_trigger_threshold",
-                String.valueOf(conf.getRatisConsensusLogAppenderBufferSize()))));
+                "partition_region_ratis_log_appender_buffer_size_max",
+                String.valueOf(conf.getPartitionRegionRatisConsensusLogAppenderBufferSize()))));
 
-    conf.setRatisLogUnsafeFlushEnable(
+    conf.setSchemaRegionRatisConsensusLogAppenderBufferSize(
+        Long.parseLong(
+            properties.getProperty(
+                "schema_region_ratis_log_appender_buffer_size_max",
+                String.valueOf(conf.getSchemaRegionRatisConsensusLogAppenderBufferSize()))));
+
+    conf.setDataRegionRatisSnapshotTriggerThreshold(
+        Long.parseLong(
+            properties.getProperty(
+                "data_region_ratis_snapshot_trigger_threshold",
+                String.valueOf(conf.getDataRegionRatisConsensusLogAppenderBufferSize()))));
+
+    conf.setPartitionRegionRatisSnapshotTriggerThreshold(
+        Long.parseLong(
+            properties.getProperty(
+                "partition_region_ratis_snapshot_trigger_threshold",
+                String.valueOf(conf.getPartitionRegionRatisSnapshotTriggerThreshold()))));
+
+    conf.setSchemaRegionRatisSnapshotTriggerThreshold(
+        Long.parseLong(
+            properties.getProperty(
+                "schema_region_ratis_snapshot_trigger_threshold",
+                String.valueOf(conf.getSchemaRegionRatisSnapshotTriggerThreshold()))));
+
+    conf.setDataRegionRatisLogUnsafeFlushEnable(
         Boolean.parseBoolean(
             properties.getProperty(
-                "ratis_log_unsafe_flush_enable",
-                String.valueOf(conf.isRatisLogUnsafeFlushEnable()))));
+                "data_region_ratis_log_unsafe_flush_enable",
+                String.valueOf(conf.isDataRegionRatisLogUnsafeFlushEnable()))));
 
-    conf.setRatisLogSegmentSizeMax(
+    conf.setPartitionRegionRatisLogUnsafeFlushEnable(
+        Boolean.parseBoolean(
+            properties.getProperty(
+                "partition_region_ratis_log_unsafe_flush_enable",
+                String.valueOf(conf.isPartitionRegionRatisLogUnsafeFlushEnable()))));
+
+    conf.setSchemaRegionRatisLogUnsafeFlushEnable(
+        Boolean.parseBoolean(
+            properties.getProperty(
+                "schema_region_ratis_log_unsafe_flush_enable",
+                String.valueOf(conf.isSchemaRegionRatisLogUnsafeFlushEnable()))));
+
+    conf.setDataRegionRatisLogSegmentSizeMax(
         Long.parseLong(
             properties.getProperty(
-                "ratis_log_segment_size_max", String.valueOf(conf.getRatisLogSegmentSizeMax()))));
+                "data_region_ratis_log_segment_size_max",
+                String.valueOf(conf.getDataRegionRatisLogSegmentSizeMax()))));
 
-    conf.setRatisGrpcFlowControlWindow(
+    conf.setPartitionRegionRatisLogSegmentSizeMax(
         Long.parseLong(
             properties.getProperty(
-                "ratis_grpc_flow_control_window",
-                String.valueOf(conf.getRatisGrpcFlowControlWindow()))));
+                "partition_region_ratis_log_segment_size_max",
+                String.valueOf(conf.getPartitionRegionRatisLogSegmentSizeMax()))));
 
-    conf.setRatisRpcLeaderElectionTimeoutMinMs(
+    conf.setSchemaRegionRatisLogSegmentSizeMax(
         Long.parseLong(
             properties.getProperty(
-                "ratis_rpc_leader_election_timeout_min_ms",
-                String.valueOf(conf.getRatisRpcLeaderElectionTimeoutMinMs()))));
+                "schema_region_ratis_log_segment_size_max",
+                String.valueOf(conf.getSchemaRegionRatisLogSegmentSizeMax()))));
 
-    conf.setRatisRpcLeaderElectionTimeoutMinMs(
+    conf.setDataRegionRatisGrpcFlowControlWindow(
         Long.parseLong(
             properties.getProperty(
-                "ratis_rpc_leader_election_timeout_max_ms",
-                String.valueOf(conf.getRatisRpcLeaderElectionTimeoutMaxMs()))));
+                "data_region_ratis_grpc_flow_control_window",
+                String.valueOf(conf.getDataRegionRatisGrpcFlowControlWindow()))));
+
+    conf.setPartitionRegionRatisGrpcFlowControlWindow(
+        Long.parseLong(
+            properties.getProperty(
+                "partition_region_ratis_grpc_flow_control_window",
+                String.valueOf(conf.getPartitionRegionRatisGrpcFlowControlWindow()))));
+
+    conf.setSchemaRegionRatisGrpcFlowControlWindow(
+        Long.parseLong(
+            properties.getProperty(
+                "schema_region_ratis_grpc_flow_control_window",
+                String.valueOf(conf.getSchemaRegionRatisGrpcFlowControlWindow()))));
+
+    conf.setDataRegionRatisRpcLeaderElectionTimeoutMinMs(
+        Long.parseLong(
+            properties.getProperty(
+                "data_region_ratis_rpc_leader_election_timeout_min_ms",
+                String.valueOf(conf.getDataRegionRatisRpcLeaderElectionTimeoutMinMs()))));
+
+    conf.setPartitionRegionRatisRpcLeaderElectionTimeoutMinMs(
+        Long.parseLong(
+            properties.getProperty(
+                "partition_region_ratis_rpc_leader_election_timeout_min_ms",
+                String.valueOf(conf.getPartitionRegionRatisRpcLeaderElectionTimeoutMinMs()))));
+
+    conf.setSchemaRegionRatisRpcLeaderElectionTimeoutMinMs(
+        Long.parseLong(
+            properties.getProperty(
+                "schema_region_ratis_rpc_leader_election_timeout_min_ms",
+                String.valueOf(conf.getSchemaRegionRatisRpcLeaderElectionTimeoutMinMs()))));
+
+    conf.setDataRegionRatisRpcLeaderElectionTimeoutMinMs(
+        Long.parseLong(
+            properties.getProperty(
+                "data_region_ratis_rpc_leader_election_timeout_max_ms",
+                String.valueOf(conf.getDataRegionRatisRpcLeaderElectionTimeoutMaxMs()))));
+
+    conf.setPartitionRegionRatisRpcLeaderElectionTimeoutMaxMs(
+        Long.parseLong(
+            properties.getProperty(
+                "partition_region_ratis_rpc_leader_election_timeout_max_ms",
+                String.valueOf(conf.getPartitionRegionRatisRpcLeaderElectionTimeoutMaxMs()))));
+
+    conf.setSchemaRegionRatisRpcLeaderElectionTimeoutMaxMs(
+        Long.parseLong(
+            properties.getProperty(
+                "schema_region_ratis_rpc_leader_election_timeout_max_ms",
+                String.valueOf(conf.getSchemaRegionRatisRpcLeaderElectionTimeoutMaxMs()))));
   }
 
   /**
diff --git a/confignode/src/main/java/org/apache/iotdb/confignode/manager/ConsensusManager.java b/confignode/src/main/java/org/apache/iotdb/confignode/manager/ConsensusManager.java
index 6f7eb10..0b35146 100644
--- a/confignode/src/main/java/org/apache/iotdb/confignode/manager/ConsensusManager.java
+++ b/confignode/src/main/java/org/apache/iotdb/confignode/manager/ConsensusManager.java
@@ -38,8 +38,11 @@
 import org.apache.iotdb.consensus.common.response.ConsensusReadResponse;
 import org.apache.iotdb.consensus.common.response.ConsensusWriteResponse;
 import org.apache.iotdb.consensus.config.ConsensusConfig;
+import org.apache.iotdb.consensus.config.RatisConfig;
 import org.apache.iotdb.rpc.TSStatusCode;
 
+import org.apache.ratis.util.SizeInBytes;
+import org.apache.ratis.util.TimeDuration;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -82,6 +85,47 @@
                 CONF.getConfigNodeConsensusProtocolClass(),
                 ConsensusConfig.newBuilder()
                     .setThisNode(new TEndPoint(CONF.getInternalAddress(), CONF.getConsensusPort()))
+                    .setRatisConfig(
+                        RatisConfig.newBuilder()
+                            .setLeaderLogAppender(
+                                RatisConfig.LeaderLogAppender.newBuilder()
+                                    .setBufferByteLimit(
+                                        CONF
+                                            .getPartitionRegionRatisConsensusLogAppenderBufferSize())
+                                    .build())
+                            .setSnapshot(
+                                RatisConfig.Snapshot.newBuilder()
+                                    .setAutoTriggerThreshold(
+                                        CONF.getPartitionRegionRatisSnapshotTriggerThreshold())
+                                    .build())
+                            .setLog(
+                                RatisConfig.Log.newBuilder()
+                                    .setUnsafeFlushEnabled(
+                                        CONF.isPartitionRegionRatisLogUnsafeFlushEnable())
+                                    .setSegmentCacheSizeMax(
+                                        SizeInBytes.valueOf(
+                                            CONF.getPartitionRegionRatisLogSegmentSizeMax()))
+                                    .build())
+                            .setGrpc(
+                                RatisConfig.Grpc.newBuilder()
+                                    .setFlowControlWindow(
+                                        SizeInBytes.valueOf(
+                                            CONF.getPartitionRegionRatisGrpcFlowControlWindow()))
+                                    .build())
+                            .setRpc(
+                                RatisConfig.Rpc.newBuilder()
+                                    .setTimeoutMin(
+                                        TimeDuration.valueOf(
+                                            CONF
+                                                .getPartitionRegionRatisRpcLeaderElectionTimeoutMinMs(),
+                                            TimeUnit.MILLISECONDS))
+                                    .setTimeoutMax(
+                                        TimeDuration.valueOf(
+                                            CONF
+                                                .getPartitionRegionRatisRpcLeaderElectionTimeoutMaxMs(),
+                                            TimeUnit.MILLISECONDS))
+                                    .build())
+                            .build())
                     .setStorageDir(CONF.getConsensusDir())
                     .build(),
                 gid -> stateMachine)
diff --git a/confignode/src/main/java/org/apache/iotdb/confignode/manager/node/NodeManager.java b/confignode/src/main/java/org/apache/iotdb/confignode/manager/node/NodeManager.java
index 2f2f658..f974a1d 100644
--- a/confignode/src/main/java/org/apache/iotdb/confignode/manager/node/NodeManager.java
+++ b/confignode/src/main/java/org/apache/iotdb/confignode/manager/node/NodeManager.java
@@ -142,13 +142,34 @@
   private void setRatisConfig(DataNodeRegisterResp dataSet) {
     final ConfigNodeConfig conf = ConfigNodeDescriptor.getInstance().getConf();
     TRatisConfig ratisConfig = new TRatisConfig();
-    ratisConfig.setAppenderBufferSize(conf.getRatisConsensusLogAppenderBufferSize());
-    ratisConfig.setSnapshotTriggerThreshold(conf.getRatisSnapshotTriggerThreshold());
-    ratisConfig.setLogUnsafeFlushEnable(conf.isRatisLogUnsafeFlushEnable());
-    ratisConfig.setLogSegmentSizeMax(conf.getRatisLogSegmentSizeMax());
-    ratisConfig.setGrpcFlowControlWindow(conf.getRatisGrpcFlowControlWindow());
-    ratisConfig.setLeaderElectionTimeoutMin(conf.getRatisRpcLeaderElectionTimeoutMinMs());
-    ratisConfig.setLeaderElectionTimeoutMax(conf.getRatisRpcLeaderElectionTimeoutMaxMs());
+
+    ratisConfig.setDataAppenderBufferSize(conf.getDataRegionRatisConsensusLogAppenderBufferSize());
+    ratisConfig.setSchemaAppenderBufferSize(
+        conf.getSchemaRegionRatisConsensusLogAppenderBufferSize());
+
+    ratisConfig.setDataSnapshotTriggerThreshold(conf.getDataRegionRatisSnapshotTriggerThreshold());
+    ratisConfig.setSchemaSnapshotTriggerThreshold(
+        conf.getSchemaRegionRatisSnapshotTriggerThreshold());
+
+    ratisConfig.setDataLogUnsafeFlushEnable(conf.isDataRegionRatisLogUnsafeFlushEnable());
+    ratisConfig.setSchemaLogUnsafeFlushEnable(conf.isSchemaRegionRatisLogUnsafeFlushEnable());
+
+    ratisConfig.setDataLogSegmentSizeMax(conf.getDataRegionRatisLogSegmentSizeMax());
+    ratisConfig.setSchemaLogSegmentSizeMax(conf.getSchemaRegionRatisLogSegmentSizeMax());
+
+    ratisConfig.setDataGrpcFlowControlWindow(conf.getDataRegionRatisGrpcFlowControlWindow());
+    ratisConfig.setSchemaGrpcFlowControlWindow(conf.getSchemaRegionRatisGrpcFlowControlWindow());
+
+    ratisConfig.setDataLeaderElectionTimeoutMin(
+        conf.getDataRegionRatisRpcLeaderElectionTimeoutMinMs());
+    ratisConfig.setSchemaLeaderElectionTimeoutMin(
+        conf.getSchemaRegionRatisRpcLeaderElectionTimeoutMinMs());
+
+    ratisConfig.setDataLeaderElectionTimeoutMax(
+        conf.getDataRegionRatisRpcLeaderElectionTimeoutMaxMs());
+    ratisConfig.setSchemaLeaderElectionTimeoutMax(
+        conf.getSchemaRegionRatisRpcLeaderElectionTimeoutMaxMs());
+
     dataSet.setRatisConfig(ratisConfig);
   }
 
diff --git a/server/src/main/java/org/apache/iotdb/db/conf/IoTDBConfig.java b/server/src/main/java/org/apache/iotdb/db/conf/IoTDBConfig.java
index 8f7787c..035a4dc 100644
--- a/server/src/main/java/org/apache/iotdb/db/conf/IoTDBConfig.java
+++ b/server/src/main/java/org/apache/iotdb/db/conf/IoTDBConfig.java
@@ -1019,19 +1019,26 @@
   /** Maximum wait time of write cache in MultiLeader consensus. Unit: ms */
   private long cacheWindowTimeInMs = 60 * 1000;
 
-  private long ratisConsensusLogAppenderBufferSizeMax = 4 * 1024 * 1024L;
+  private long dataRatisConsensusLogAppenderBufferSizeMax = 4 * 1024 * 1024L;
+  private long schemaRatisConsensusLogAppenderBufferSizeMax = 4 * 1024 * 1024L;
 
-  private long ratisConsensusSnapshotTriggerThreshold = 400000L;
+  private long dataRatisConsensusSnapshotTriggerThreshold = 400000L;
+  private long schemaRatisConsensusSnapshotTriggerThreshold = 400000L;
 
-  private boolean ratisConsensusLogUnsafeFlushEnable = false;
+  private boolean dataRatisConsensusLogUnsafeFlushEnable = false;
+  private boolean schemaRatisConsensusLogUnsafeFlushEnable = false;
 
-  private long ratisConsensusLogSegmentSizeMax = 24 * 1024 * 1024L;
+  private long dataRatisConsensusLogSegmentSizeMax = 24 * 1024 * 1024L;
+  private long schemaRatisConsensusLogSegmentSizeMax = 24 * 1024 * 1024L;
 
-  private long ratisConsensusGrpcFlowControlWindow = 4 * 1024 * 1024L;
+  private long dataRatisConsensusGrpcFlowControlWindow = 4 * 1024 * 1024L;
+  private long schemaRatisConsensusGrpcFlowControlWindow = 4 * 1024 * 1024L;
 
-  private long ratisConsensusLeaderElectionTimeoutMinMs = 2000L;
+  private long dataRatisConsensusLeaderElectionTimeoutMinMs = 2000L;
+  private long schemaRatisConsensusLeaderElectionTimeoutMinMs = 2000L;
 
-  private long RatisConsensusLeaderElectionTimeoutMaxMs = 4000L;
+  private long dataRatisConsensusLeaderElectionTimeoutMaxMs = 4000L;
+  private long schemaRatisConsensusLeaderElectionTimeoutMaxMs = 4000L;
 
   IoTDBConfig() {}
 
@@ -3273,13 +3280,13 @@
     this.cacheWindowTimeInMs = cacheWindowTimeInMs;
   }
 
-  public long getRatisConsensusLogAppenderBufferSizeMax() {
-    return ratisConsensusLogAppenderBufferSizeMax;
+  public long getDataRatisConsensusLogAppenderBufferSizeMax() {
+    return dataRatisConsensusLogAppenderBufferSizeMax;
   }
 
-  public void setRatisConsensusLogAppenderBufferSizeMax(
-      long ratisConsensusLogAppenderBufferSizeMax) {
-    this.ratisConsensusLogAppenderBufferSizeMax = ratisConsensusLogAppenderBufferSizeMax;
+  public void setDataRatisConsensusLogAppenderBufferSizeMax(
+      long dataRatisConsensusLogAppenderBufferSizeMax) {
+    this.dataRatisConsensusLogAppenderBufferSizeMax = dataRatisConsensusLogAppenderBufferSizeMax;
   }
 
   public String getConfigMessage() {
@@ -3315,54 +3322,124 @@
     return configMessage;
   }
 
-  public long getRatisConsensusSnapshotTriggerThreshold() {
-    return ratisConsensusSnapshotTriggerThreshold;
+  public long getDataRatisConsensusSnapshotTriggerThreshold() {
+    return dataRatisConsensusSnapshotTriggerThreshold;
   }
 
-  public void setRatisConsensusSnapshotTriggerThreshold(
-      long ratisConsensusSnapshotTriggerThreshold) {
-    this.ratisConsensusSnapshotTriggerThreshold = ratisConsensusSnapshotTriggerThreshold;
+  public void setDataRatisConsensusSnapshotTriggerThreshold(
+      long dataRatisConsensusSnapshotTriggerThreshold) {
+    this.dataRatisConsensusSnapshotTriggerThreshold = dataRatisConsensusSnapshotTriggerThreshold;
   }
 
-  public boolean isRatisConsensusLogUnsafeFlushEnable() {
-    return ratisConsensusLogUnsafeFlushEnable;
+  public boolean isDataRatisConsensusLogUnsafeFlushEnable() {
+    return dataRatisConsensusLogUnsafeFlushEnable;
   }
 
-  public void setRatisConsensusLogUnsafeFlushEnable(boolean ratisConsensusLogUnsafeFlushEnable) {
-    this.ratisConsensusLogUnsafeFlushEnable = ratisConsensusLogUnsafeFlushEnable;
+  public void setDataRatisConsensusLogUnsafeFlushEnable(
+      boolean dataRatisConsensusLogUnsafeFlushEnable) {
+    this.dataRatisConsensusLogUnsafeFlushEnable = dataRatisConsensusLogUnsafeFlushEnable;
   }
 
-  public long getRatisConsensusLogSegmentSizeMax() {
-    return ratisConsensusLogSegmentSizeMax;
+  public long getDataRatisConsensusLogSegmentSizeMax() {
+    return dataRatisConsensusLogSegmentSizeMax;
   }
 
-  public void setRatisConsensusLogSegmentSizeMax(long ratisConsensusLogSegmentSizeMax) {
-    this.ratisConsensusLogSegmentSizeMax = ratisConsensusLogSegmentSizeMax;
+  public void setDataRatisConsensusLogSegmentSizeMax(long dataRatisConsensusLogSegmentSizeMax) {
+    this.dataRatisConsensusLogSegmentSizeMax = dataRatisConsensusLogSegmentSizeMax;
   }
 
-  public long getRatisConsensusGrpcFlowControlWindow() {
-    return ratisConsensusGrpcFlowControlWindow;
+  public long getDataRatisConsensusGrpcFlowControlWindow() {
+    return dataRatisConsensusGrpcFlowControlWindow;
   }
 
-  public void setRatisConsensusGrpcFlowControlWindow(long ratisConsensusGrpcFlowControlWindow) {
-    this.ratisConsensusGrpcFlowControlWindow = ratisConsensusGrpcFlowControlWindow;
+  public void setDataRatisConsensusGrpcFlowControlWindow(
+      long dataRatisConsensusGrpcFlowControlWindow) {
+    this.dataRatisConsensusGrpcFlowControlWindow = dataRatisConsensusGrpcFlowControlWindow;
   }
 
-  public long getRatisConsensusLeaderElectionTimeoutMinMs() {
-    return ratisConsensusLeaderElectionTimeoutMinMs;
+  public long getDataRatisConsensusLeaderElectionTimeoutMinMs() {
+    return dataRatisConsensusLeaderElectionTimeoutMinMs;
   }
 
-  public void setRatisConsensusLeaderElectionTimeoutMinMs(
-      long ratisConsensusLeaderElectionTimeoutMinMs) {
-    this.ratisConsensusLeaderElectionTimeoutMinMs = ratisConsensusLeaderElectionTimeoutMinMs;
+  public void setDataRatisConsensusLeaderElectionTimeoutMinMs(
+      long dataRatisConsensusLeaderElectionTimeoutMinMs) {
+    this.dataRatisConsensusLeaderElectionTimeoutMinMs =
+        dataRatisConsensusLeaderElectionTimeoutMinMs;
   }
 
-  public long getRatisConsensusLeaderElectionTimeoutMaxMs() {
-    return RatisConsensusLeaderElectionTimeoutMaxMs;
+  public long getDataRatisConsensusLeaderElectionTimeoutMaxMs() {
+    return dataRatisConsensusLeaderElectionTimeoutMaxMs;
   }
 
-  public void setRatisConsensusLeaderElectionTimeoutMaxMs(
-      long ratisConsensusLeaderElectionTimeoutMaxMs) {
-    RatisConsensusLeaderElectionTimeoutMaxMs = ratisConsensusLeaderElectionTimeoutMaxMs;
+  public void setDataRatisConsensusLeaderElectionTimeoutMaxMs(
+      long dataRatisConsensusLeaderElectionTimeoutMaxMs) {
+    this.dataRatisConsensusLeaderElectionTimeoutMaxMs =
+        dataRatisConsensusLeaderElectionTimeoutMaxMs;
+  }
+
+  public long getSchemaRatisConsensusLogAppenderBufferSizeMax() {
+    return schemaRatisConsensusLogAppenderBufferSizeMax;
+  }
+
+  public void setSchemaRatisConsensusLogAppenderBufferSizeMax(
+      long schemaRatisConsensusLogAppenderBufferSizeMax) {
+    this.schemaRatisConsensusLogAppenderBufferSizeMax =
+        schemaRatisConsensusLogAppenderBufferSizeMax;
+  }
+
+  public long getSchemaRatisConsensusSnapshotTriggerThreshold() {
+    return schemaRatisConsensusSnapshotTriggerThreshold;
+  }
+
+  public void setSchemaRatisConsensusSnapshotTriggerThreshold(
+      long schemaRatisConsensusSnapshotTriggerThreshold) {
+    this.schemaRatisConsensusSnapshotTriggerThreshold =
+        schemaRatisConsensusSnapshotTriggerThreshold;
+  }
+
+  public boolean isSchemaRatisConsensusLogUnsafeFlushEnable() {
+    return schemaRatisConsensusLogUnsafeFlushEnable;
+  }
+
+  public void setSchemaRatisConsensusLogUnsafeFlushEnable(
+      boolean schemaRatisConsensusLogUnsafeFlushEnable) {
+    this.schemaRatisConsensusLogUnsafeFlushEnable = schemaRatisConsensusLogUnsafeFlushEnable;
+  }
+
+  public long getSchemaRatisConsensusLogSegmentSizeMax() {
+    return schemaRatisConsensusLogSegmentSizeMax;
+  }
+
+  public void setSchemaRatisConsensusLogSegmentSizeMax(long schemaRatisConsensusLogSegmentSizeMax) {
+    this.schemaRatisConsensusLogSegmentSizeMax = schemaRatisConsensusLogSegmentSizeMax;
+  }
+
+  public long getSchemaRatisConsensusGrpcFlowControlWindow() {
+    return schemaRatisConsensusGrpcFlowControlWindow;
+  }
+
+  public void setSchemaRatisConsensusGrpcFlowControlWindow(
+      long schemaRatisConsensusGrpcFlowControlWindow) {
+    this.schemaRatisConsensusGrpcFlowControlWindow = schemaRatisConsensusGrpcFlowControlWindow;
+  }
+
+  public long getSchemaRatisConsensusLeaderElectionTimeoutMinMs() {
+    return schemaRatisConsensusLeaderElectionTimeoutMinMs;
+  }
+
+  public void setSchemaRatisConsensusLeaderElectionTimeoutMinMs(
+      long schemaRatisConsensusLeaderElectionTimeoutMinMs) {
+    this.schemaRatisConsensusLeaderElectionTimeoutMinMs =
+        schemaRatisConsensusLeaderElectionTimeoutMinMs;
+  }
+
+  public long getSchemaRatisConsensusLeaderElectionTimeoutMaxMs() {
+    return schemaRatisConsensusLeaderElectionTimeoutMaxMs;
+  }
+
+  public void setSchemaRatisConsensusLeaderElectionTimeoutMaxMs(
+      long schemaRatisConsensusLeaderElectionTimeoutMaxMs) {
+    this.schemaRatisConsensusLeaderElectionTimeoutMaxMs =
+        schemaRatisConsensusLeaderElectionTimeoutMaxMs;
   }
 }
diff --git a/server/src/main/java/org/apache/iotdb/db/conf/IoTDBDescriptor.java b/server/src/main/java/org/apache/iotdb/db/conf/IoTDBDescriptor.java
index 57ed301..3ee6ee8 100644
--- a/server/src/main/java/org/apache/iotdb/db/conf/IoTDBDescriptor.java
+++ b/server/src/main/java/org/apache/iotdb/db/conf/IoTDBDescriptor.java
@@ -1926,13 +1926,32 @@
   }
 
   public void loadRatisConfig(TRatisConfig ratisConfig) {
-    conf.setRatisConsensusLogAppenderBufferSizeMax(ratisConfig.getAppenderBufferSize());
-    conf.setRatisConsensusSnapshotTriggerThreshold(ratisConfig.getSnapshotTriggerThreshold());
-    conf.setRatisConsensusLogUnsafeFlushEnable(ratisConfig.isLogUnsafeFlushEnable());
-    conf.setRatisConsensusLogSegmentSizeMax(ratisConfig.getLogSegmentSizeMax());
-    conf.setRatisConsensusGrpcFlowControlWindow(ratisConfig.getGrpcFlowControlWindow());
-    conf.setRatisConsensusLeaderElectionTimeoutMinMs(ratisConfig.getLeaderElectionTimeoutMin());
-    conf.setRatisConsensusLeaderElectionTimeoutMaxMs(ratisConfig.getLeaderElectionTimeoutMax());
+    conf.setDataRatisConsensusLogAppenderBufferSizeMax(ratisConfig.getDataAppenderBufferSize());
+    conf.setSchemaRatisConsensusLogAppenderBufferSizeMax(ratisConfig.getSchemaAppenderBufferSize());
+
+    conf.setDataRatisConsensusSnapshotTriggerThreshold(
+        ratisConfig.getDataSnapshotTriggerThreshold());
+    conf.setSchemaRatisConsensusSnapshotTriggerThreshold(
+        ratisConfig.getSchemaSnapshotTriggerThreshold());
+
+    conf.setDataRatisConsensusLogUnsafeFlushEnable(ratisConfig.isDataLogUnsafeFlushEnable());
+    conf.setSchemaRatisConsensusLogUnsafeFlushEnable(ratisConfig.isSchemaLogUnsafeFlushEnable());
+
+    conf.setDataRatisConsensusLogSegmentSizeMax(ratisConfig.getDataLogSegmentSizeMax());
+    conf.setSchemaRatisConsensusLogSegmentSizeMax(ratisConfig.getSchemaLogSegmentSizeMax());
+
+    conf.setDataRatisConsensusGrpcFlowControlWindow(ratisConfig.getDataGrpcFlowControlWindow());
+    conf.setSchemaRatisConsensusGrpcFlowControlWindow(ratisConfig.getSchemaGrpcFlowControlWindow());
+
+    conf.setDataRatisConsensusLeaderElectionTimeoutMinMs(
+        ratisConfig.getDataLeaderElectionTimeoutMin());
+    conf.setSchemaRatisConsensusLeaderElectionTimeoutMinMs(
+        ratisConfig.getSchemaLeaderElectionTimeoutMin());
+
+    conf.setDataRatisConsensusLeaderElectionTimeoutMaxMs(
+        ratisConfig.getDataLeaderElectionTimeoutMax());
+    conf.setSchemaRatisConsensusLeaderElectionTimeoutMaxMs(
+        ratisConfig.getSchemaLeaderElectionTimeoutMax());
   }
 
   public void initClusterSchemaMemoryAllocate() {
diff --git a/server/src/main/java/org/apache/iotdb/db/consensus/DataRegionConsensusImpl.java b/server/src/main/java/org/apache/iotdb/db/consensus/DataRegionConsensusImpl.java
index 0e493c2..df0e98b 100644
--- a/server/src/main/java/org/apache/iotdb/db/consensus/DataRegionConsensusImpl.java
+++ b/server/src/main/java/org/apache/iotdb/db/consensus/DataRegionConsensusImpl.java
@@ -96,37 +96,39 @@
                                   Snapshot.newBuilder()
                                       .setCreationGap(1)
                                       .setAutoTriggerThreshold(
-                                          conf.getRatisConsensusSnapshotTriggerThreshold())
+                                          conf.getDataRatisConsensusSnapshotTriggerThreshold())
                                       .build())
                               .setLog(
                                   RatisConfig.Log.newBuilder()
                                       .setUnsafeFlushEnabled(
-                                          conf.isRatisConsensusLogUnsafeFlushEnable())
-                                      .setSegmentCacheSizeMax(
+                                          conf.isDataRatisConsensusLogUnsafeFlushEnable())
+                                      .setSegmentSizeMax(
                                           SizeInBytes.valueOf(
-                                              conf.getRatisConsensusLogSegmentSizeMax()))
+                                              conf.getDataRatisConsensusLogSegmentSizeMax()))
                                       .build())
                               .setGrpc(
                                   RatisConfig.Grpc.newBuilder()
                                       .setFlowControlWindow(
                                           SizeInBytes.valueOf(
-                                              conf.getRatisConsensusGrpcFlowControlWindow()))
+                                              conf.getDataRatisConsensusGrpcFlowControlWindow()))
                                       .build())
                               .setRpc(
                                   RatisConfig.Rpc.newBuilder()
                                       .setTimeoutMin(
                                           TimeDuration.valueOf(
-                                              conf.getRatisConsensusLeaderElectionTimeoutMinMs(),
+                                              conf
+                                                  .getDataRatisConsensusLeaderElectionTimeoutMinMs(),
                                               TimeUnit.MILLISECONDS))
                                       .setTimeoutMax(
                                           TimeDuration.valueOf(
-                                              conf.getRatisConsensusLeaderElectionTimeoutMaxMs(),
+                                              conf
+                                                  .getDataRatisConsensusLeaderElectionTimeoutMaxMs(),
                                               TimeUnit.MILLISECONDS))
                                       .build())
                               .setLeaderLogAppender(
                                   RatisConfig.LeaderLogAppender.newBuilder()
                                       .setBufferByteLimit(
-                                          conf.getRatisConsensusLogAppenderBufferSizeMax())
+                                          conf.getDataRatisConsensusLogAppenderBufferSizeMax())
                                       .build())
                               .build())
                       .build(),
diff --git a/server/src/main/java/org/apache/iotdb/db/consensus/SchemaRegionConsensusImpl.java b/server/src/main/java/org/apache/iotdb/db/consensus/SchemaRegionConsensusImpl.java
index af95eb6f..4ae4b63 100644
--- a/server/src/main/java/org/apache/iotdb/db/consensus/SchemaRegionConsensusImpl.java
+++ b/server/src/main/java/org/apache/iotdb/db/consensus/SchemaRegionConsensusImpl.java
@@ -24,11 +24,17 @@
 import org.apache.iotdb.consensus.ConsensusFactory;
 import org.apache.iotdb.consensus.IConsensus;
 import org.apache.iotdb.consensus.config.ConsensusConfig;
+import org.apache.iotdb.consensus.config.RatisConfig;
 import org.apache.iotdb.db.conf.IoTDBConfig;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.consensus.statemachine.SchemaRegionStateMachine;
 import org.apache.iotdb.db.metadata.schemaregion.SchemaEngine;
 
+import org.apache.ratis.util.SizeInBytes;
+import org.apache.ratis.util.TimeDuration;
+
+import java.util.concurrent.TimeUnit;
+
 /**
  * We can use SchemaRegionConsensusImpl.getInstance() to obtain a consensus layer reference for
  * schemaRegion's reading and writing
@@ -55,6 +61,46 @@
                       .setThisNode(
                           new TEndPoint(
                               conf.getInternalAddress(), conf.getSchemaRegionConsensusPort()))
+                      .setRatisConfig(
+                          RatisConfig.newBuilder()
+                              .setSnapshot(
+                                  RatisConfig.Snapshot.newBuilder()
+                                      .setAutoTriggerThreshold(
+                                          conf.getSchemaRatisConsensusSnapshotTriggerThreshold())
+                                      .build())
+                              .setLog(
+                                  RatisConfig.Log.newBuilder()
+                                      .setUnsafeFlushEnabled(
+                                          conf.isSchemaRatisConsensusLogUnsafeFlushEnable())
+                                      .setSegmentSizeMax(
+                                          SizeInBytes.valueOf(
+                                              conf.getSchemaRatisConsensusLogSegmentSizeMax()))
+                                      .build())
+                              .setGrpc(
+                                  RatisConfig.Grpc.newBuilder()
+                                      .setFlowControlWindow(
+                                          SizeInBytes.valueOf(
+                                              conf.getSchemaRatisConsensusGrpcFlowControlWindow()))
+                                      .build())
+                              .setRpc(
+                                  RatisConfig.Rpc.newBuilder()
+                                      .setTimeoutMin(
+                                          TimeDuration.valueOf(
+                                              conf
+                                                  .getSchemaRatisConsensusLeaderElectionTimeoutMinMs(),
+                                              TimeUnit.MILLISECONDS))
+                                      .setTimeoutMax(
+                                          TimeDuration.valueOf(
+                                              conf
+                                                  .getSchemaRatisConsensusLeaderElectionTimeoutMaxMs(),
+                                              TimeUnit.MILLISECONDS))
+                                      .build())
+                              .setLeaderLogAppender(
+                                  RatisConfig.LeaderLogAppender.newBuilder()
+                                      .setBufferByteLimit(
+                                          conf.getSchemaRatisConsensusLogAppenderBufferSizeMax())
+                                      .build())
+                              .build())
                       .setStorageDir(conf.getSchemaRegionConsensusDir())
                       .build(),
                   gid ->
diff --git a/thrift-confignode/src/main/thrift/confignode.thrift b/thrift-confignode/src/main/thrift/confignode.thrift
index b956c66..9d95e3d 100644
--- a/thrift-confignode/src/main/thrift/confignode.thrift
+++ b/thrift-confignode/src/main/thrift/confignode.thrift
@@ -49,13 +49,26 @@
 }
 
 struct TRatisConfig {
-  1: optional i64 appenderBufferSize
-  2: optional i64 snapshotTriggerThreshold
-  3: optional bool logUnsafeFlushEnable
-  4: optional i64 logSegmentSizeMax
-  5: optional i64 grpcFlowControlWindow
-  6: optional i64 leaderElectionTimeoutMin
-  7: optional i64 leaderElectionTimeoutMax
+  1: optional i64 schemaAppenderBufferSize
+  2: optional i64 dataAppenderBufferSize
+
+  3: optional i64 schemaSnapshotTriggerThreshold
+  4: optional i64 dataSnapshotTriggerThreshold
+
+  5: optional bool schemaLogUnsafeFlushEnable
+  6: optional bool dataLogUnsafeFlushEnable
+
+  7: optional i64 schemaLogSegmentSizeMax
+  8: optional i64 dataLogSegmentSizeMax
+
+  9: optional i64 schemaGrpcFlowControlWindow
+  10: optional i64 dataGrpcFlowControlWindow
+
+  11: optional i64 schemaLeaderElectionTimeoutMin
+  12: optional i64 dataLeaderElectionTimeoutMin
+
+  13: optional i64 schemaLeaderElectionTimeoutMax
+  14: optional i64 dataLeaderElectionTimeoutMax
 }
 
 struct TDataNodeRemoveReq {