印刻数据库

外观

Neo4j 读写分离 ​

Neo4j 集群架构 ​

核心组件 ​

核心节点（Core Nodes） ​

  • 处理写操作和事务提交
  • 维护数据一致性和完整性
  • 参与选举和事务共识
  • 最少需要3个节点，推荐奇数个节点

只读副本（Read Replicas） ​

  • 只处理读操作
  • 从核心节点同步数据
  • 不参与选举和事务共识
  • 可以水平扩展，数量不限

集群拓扑 ​

基础集群架构 ​

扩展集群架构 ​

数据同步机制 ​

事务复制 ​

  • 核心节点之间使用 Raft 协议进行事务共识
  • 事务提交后，通过复制协议同步到所有核心节点
  • 只读副本从核心节点拉取事务日志进行数据同步
  • 支持异步和半同步两种复制模式

复制延迟 ​

  • 异步复制：存在一定的复制延迟，适用于对数据一致性要求不高的场景
  • 半同步复制：确保至少有一个副本同步完成后才返回，适用于对数据一致性要求较高的场景
  • 复制延迟受网络带宽、节点负载和数据量影响

读写分离配置 ​

核心节点配置 ​

txt
# neo4j.conf - 核心节点配置

# 启用集群模式
dbms.mode=CORE

# 集群名称
dbms.cluster.cluster_name=neo4j-cluster

# 核心节点列表
dbms.cluster.initial_hosts=core1:5000,core2:5000,core3:5000

# 集群通信端口
dbms.connector.bolt.enabled=true
dbms.connector.bolt.listen_address=0.0.0.0:7687
dbms.connector.bolt.advertised_address=core1:7687

# 集群内部通信端口
dbms.connector.cluster.enabled=true
dbms.connector.cluster.listen_address=0.0.0.0:5000
dbms.connector.cluster.advertised_address=core1:5000

# HTTP 端口
dbms.connector.http.enabled=true
dbms.connector.http.listen_address=0.0.0.0:7474
dbms.connector.http.advertised_address=core1:7474

# HTTPS 端口
dbms.connector.https.enabled=true
dbms.connector.https.listen_address=0.0.0.0:7473
dbms.connector.https.advertised_address=core1:7473

# 事务日志配置
dbms.tx_log.rotation.size=256M
dbms.tx_log.rotation.retention_policy=100M size

只读副本配置 ​

txt
# neo4j.conf - 只读副本配置

# 启用只读副本模式
dbms.mode=READ_REPLICA

# 集群名称
dbms.cluster.cluster_name=neo4j-cluster

# 核心节点列表（用于数据同步）
dbms.cluster.initial_hosts=core1:5000,core2:5000,core3:5000

# 集群通信端口
dbms.connector.bolt.enabled=true
dbms.connector.bolt.listen_address=0.0.0.0:7687
dbms.connector.bolt.advertised_address=replica1:7687

# HTTP 端口
dbms.connector.http.enabled=true
dbms.connector.http.listen_address=0.0.0.0:7474
dbms.connector.http.advertised_address=replica1:7474

# HTTPS 端口
dbms.connector.https.enabled=true
dbms.connector.https.listen_address=0.0.0.0:7473
dbms.connector.https.advertised_address=replica1:7473

# 只读副本特定配置
dbms.read_replica.update_interval=1000ms  # 数据更新间隔
dbms.read_replica.pull_interval=500ms     # 拉取事务日志间隔
dbms.read_replica.max_replication_lag=5000ms  # 最大复制延迟

负载均衡配置 ​

HAProxy 配置示例 ​

txt
# haproxy.cfg - 读写分离配置

global
    log 127.0.0.1 local0
    maxconn 4000
    daemon

defaults
    log global
    mode tcp
    option tcplog
    option dontlognull
    retries 3
    timeout connect 5s
    timeout client 50s
    timeout server 50s

# 写请求负载均衡器
frontend neo4j-write
    bind *:7688
    default_backend neo4j-core-nodes

# 读请求负载均衡器
frontend neo4j-read
    bind *:7689
    default_backend neo4j-read-replicas

# 核心节点后端（处理写请求）
backend neo4j-core-nodes
    balance roundrobin
    server core1 core1:7687 check port 7687 inter 2000 rise 2 fall 3
    server core2 core2:7687 check port 7687 inter 2000 rise 2 fall 3
    server core3 core3:7687 check port 7687 inter 2000 rise 2 fall 3

# 只读副本后端（处理读请求）
backend neo4j-read-replicas
    balance roundrobin
    server replica1 replica1:7687 check port 7687 inter 2000 rise 2 fall 3
    server replica2 replica2:7687 check port 7687 inter 2000 rise 2 fall 3
    server replica3 replica3:7687 check port 7687 inter 2000 rise 2 fall 3
    server replica4 replica4:7687 check port 7687 inter 2000 rise 2 fall 3
    server replica5 replica5:7687 check port 7687 inter 2000 rise 2 fall 3
    server replica6 replica6:7687 check port 7687 inter 2000 rise 2 fall 3

Nginx 配置示例 ​

txt
# nginx.conf - 读写分离配置

worker_processes auto;
events {
    worker_connections 1024;
}

stream {
    # 写请求负载均衡器
    upstream neo4j-write {
        server core1:7687;
        server core2:7687;
        server core3:7687;
        least_conn;
    }

    # 读请求负载均衡器
    upstream neo4j-read {
        server replica1:7687;
        server replica2:7687;
        server replica3:7687;
        server replica4:7687;
        server replica5:7687;
        server replica6:7687;
        least_conn;
    }

    # 写请求监听
    server {
        listen 7688;
        proxy_pass neo4j-write;
        proxy_connect_timeout 1s;
        proxy_timeout 3s;
    }

    # 读请求监听
    server {
        listen 7689;
        proxy_pass neo4j-read;
        proxy_connect_timeout 1s;
        proxy_timeout 3s;
    }
}

客户端实现读写分离 ​

Java 客户端示例 ​

使用官方驱动实现读写分离 ​

java
import org.neo4j.driver.*;

public class Neo4jReadWriteSplitExample {

    // 写操作会话配置
    private static final SessionConfig WRITE_SESSION_CONFIG = SessionConfig.builder()
            .withDefaultAccessMode(AccessMode.WRITE)
            .build();

    // 读操作会话配置
    private static final SessionConfig READ_SESSION_CONFIG = SessionConfig.builder()
            .withDefaultAccessMode(AccessMode.READ)
            .build();

    public static void main(String[] args) {
        // 连接到 Neo4j 集群
        try (Driver driver = GraphDatabase.driver(
                "neo4j://localhost:7687",
                AuthTokens.basic("neo4j", "password"))
        ) {
            // 执行写操作
            writeExample(driver);
            
            // 执行读操作
            readExample(driver);
        }
    }

    private static void writeExample(Driver driver) {
        try (Session session = driver.session(WRITE_SESSION_CONFIG)) {
            String cypher = "CREATE (u:User {name: $name, email: $email}) RETURN u";
            User user = session.writeTransaction(tx -> {
                Result result = tx.run(cypher, Values.parameters("name", "Alice", "email", "alice@example.com"));
                return result.single().get("u").asNode().asObject(User.class);
            });
            System.out.println("Created user: " + user.getName());
        }
    }

    private static void readExample(Driver driver) {
        try (Session session = driver.session(READ_SESSION_CONFIG)) {
            String cypher = "MATCH (u:User) RETURN u.name AS name, u.email AS email";
            session.readTransaction(tx -> {
                Result result = tx.run(cypher);
                while (result.hasNext()) {
                    Record record = result.next();
                    System.out.println("User: " + record.get("name").asString() + ", Email: " + record.get("email").asString());
                }
                return null;
            });
        }
    }
}

Python 客户端示例 ​

使用 neo4j-driver 实现读写分离 ​

python
from neo4j import GraphDatabase, basic_auth

# 连接配置
URI = "neo4j://localhost:7687"
AUTH = basic_auth("neo4j", "password")

# 创建驱动实例
driver = GraphDatabase.driver(URI, auth=AUTH)

# 写操作函数
def create_user(name, email):
    with driver.session(database="neo4j", default_access_mode="WRITE") as session:
        result = session.execute_write(
            lambda tx: tx.run(
                "CREATE (u:User {name: $name, email: $email}) RETURN u",
                name=name, email=email
            ).single()
        )
        if result:
            user = result["u"]
            print(f"Created user: {user["name"]}")

# 读操作函数
def get_all_users():
    with driver.session(database="neo4j", default_access_mode="READ") as session:
        result = session.execute_read(
            lambda tx: tx.run("MATCH (u:User) RETURN u.name AS name, u.email AS email").data()
        )
        for user in result:
            print(f"User: {user["name"]}, Email: {user["email"]}")

# 测试读写分离
if __name__ == "__main__":
    # 执行写操作
    create_user("Bob", "bob@example.com")
    
    # 执行读操作
    get_all_users()
    
    # 关闭驱动
    driver.close()

Node.js 客户端示例 ​

使用 neo4j-driver 实现读写分离 ​

javascript
const neo4j = require('neo4j-driver');

// 连接配置
const URI = 'neo4j://localhost:7687';
const AUTH = neo4j.auth.basic('neo4j', 'password');

// 创建驱动实例
const driver = neo4j.driver(URI, AUTH);

// 写操作函数
async function createUser(name, email) {
    const session = driver.session({
        database: 'neo4j',
        defaultAccessMode: neo4j.session.WRITE
    });
    
    try {
        const result = await session.executeWrite(tx => 
            tx.run(
                'CREATE (u:User {name: $name, email: $email}) RETURN u',
                { name, email }
            )
        );
        
        const user = result.records[0].get('u').properties;
        console.log(`Created user: ${user.name}`);
    } finally {
        await session.close();
    }
}

// 读操作函数
async function getAllUsers() {
    const session = driver.session({
        database: 'neo4j',
        defaultAccessMode: neo4j.session.READ
    });
    
    try {
        const result = await session.executeRead(tx => 
            tx.run('MATCH (u:User) RETURN u.name AS name, u.email AS email')
        );
        
        result.records.forEach(record => {
            console.log(`User: ${record.get('name')}, Email: ${record.get('email')}`);
        });
    } finally {
        await session.close();
    }
}

// 测试读写分离
async function main() {
    // 执行写操作
    await createUser('Charlie', 'charlie@example.com');
    
    // 执行读操作
    await getAllUsers();
    
    // 关闭驱动
    await driver.close();
}

main();

数据一致性与延迟 ​

一致性级别 ​

强一致性 ​

  • 读操作始终返回最新写入的数据
  • 适用于对数据一致性要求高的场景
  • 实现方式：
    cypher
    // 确保读取最新数据
:USE DATABASE neo4j
:TRANSACTION READ WRITE
MATCH (u:User {id: 1}) RETURN u;

最终一致性 ​

  • 读操作可能返回较旧的数据，但最终会一致
  • 适用于对数据一致性要求不高的场景
  • 实现方式：默认的读操作行为

处理复制延迟 ​

复制延迟监控 ​

cypher
// 监控复制延迟
CALL dbms.cluster.overview()
YIELD address, role, databases
RETURN address, role, databases
bash
# 使用 Neo4j 监控工具查看复制延迟
neo4j-admin metrics query --metrics=neo4j.cluster.read_replica.replication_delay

降低复制延迟的方法 ​

  1. 优化网络连接：

    • 使用高速网络连接核心节点和只读副本
    • 减少网络延迟和丢包
    • 考虑将节点部署在同一数据中心

  2. 调整复制配置：

    txt
    # 减少复制延迟的配置
dbms.read_replica.update_interval=500ms  # 缩短更新间隔
dbms.read_replica.pull_interval=250ms     # 缩短拉取间隔
dbms.tx_log.rotation.size=128M           # 减小事务日志大小

  3. 优化核心节点性能：

    • 确保核心节点有足够的资源处理写操作
    • 优化核心节点的 JVM 配置
    • 减少核心节点的负载

  4. 合理规划只读副本数量：

    • 根据核心节点的能力合理规划只读副本数量
    • 避免过多的只读副本导致核心节点负载过高

解决读写冲突 ​

乐观锁机制 ​

cypher
// 使用版本号实现乐观锁
MATCH (u:User {id: 1}) 
WHERE u.version = $expectedVersion
SET u.name = $newName, u.version = u.version + 1
RETURN u;

重试机制 ​

java
// 实现重试机制处理并发冲突
public void updateUserWithRetry(Driver driver, long userId, String newName, int maxRetries) {
    int retryCount = 0;
    while (retryCount < maxRetries) {
        try (Session session = driver.session(WRITE_SESSION_CONFIG)) {
            session.writeTransaction(tx -> {
                // 读取当前版本
                Result result = tx.run("MATCH (u:User {id: $id}) RETURN u.version AS version", 
                                      Values.parameters("id", userId));
                if (!result.hasNext()) {
                    throw new RuntimeException("User not found");
                }
                long version = result.single().get("version").asLong();
                
                // 更新用户信息，同时更新版本号
                Result updateResult = tx.run(
                    "MATCH (u:User {id: $id, version: $version}) " +
                    "SET u.name = $name, u.version = u.version + 1 " +
                    "RETURN u",
                    Values.parameters("id", userId, "version", version, "name", newName)
                );
                
                if (!updateResult.hasNext()) {
                    throw new TransientException("Concurrent update detected");
                }
                
                return updateResult.single().get("u").asNode();
            });
            return; // 更新成功，退出循环
        } catch (TransientException e) {
            retryCount++;
            if (retryCount >= maxRetries) {
                throw new RuntimeException("Failed to update user after " + maxRetries + " retries", e);
            }
            // 等待一段时间后重试
            try {
                Thread.sleep(100 * retryCount); // 指数退避
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt();
                throw new RuntimeException("Interrupted during retry", ie);
            }
        }
    }
}

监控与优化 ​

监控指标 ​

集群健康状态 ​

cypher
// 查看集群健康状态
CALL dbms.cluster.overview()
YIELD address, role, databases
RETURN address, role, databases;

读写请求分布 ​

bash
# 使用 Neo4j 监控工具查看读写请求分布
neo4j-admin metrics query --metrics=neo4j.bolt.requests.read,neo4j.bolt.requests.write

复制延迟监控 ​

cypher
// 监控只读副本的复制延迟
CALL dbms.metrics.list()
YIELD name, value
WHERE name CONTAINS 'replication_delay'
RETURN name, value;

节点负载监控 ​

bash
# 查看节点的 CPU 和内存使用情况
neo4j-admin metrics query --metrics=system.cpu.usage,neo4j.jvm.memory.heap.used

性能优化 ​

查询优化 ​

  1. 创建合适的索引：

    cypher
    // 创建索引加速查询
CREATE INDEX idx_user_email FOR (u:User) ON (u.email);
CREATE INDEX idx_product_name FOR (p:Product) ON (p.name);

  2. 优化查询语句：

    cypher
    // 优化前：全图扫描
MATCH (u:User) WHERE u.name = 'Alice' RETURN u;

// 优化后：使用索引
MATCH (u:User {name: 'Alice'}) RETURN u;

  3. 使用参数化查询：

    cypher
    // 使用参数化查询提高缓存命中率
MATCH (u:User {id: $id}) RETURN u;

节点配置优化 ​

  1. 核心节点配置优化：

    txt
    # 核心节点 JVM 配置优化
dbms.memory.heap.initial_size=16g
dbms.memory.heap.max_size=16g
dbms.memory.pagecache.size=32g
dbms.jvm.additional=-XX:+UseG1GC
dbms.jvm.additional=-XX:MaxGCPauseMillis=200

  2. 只读副本配置优化：

    txt
    # 只读副本 JVM 配置优化
dbms.memory.heap.initial_size=8g
dbms.memory.heap.max_size=8g
dbms.memory.pagecache.size=48g  # 只读副本可以分配更多内存给页缓存
dbms.jvm.additional=-XX:+UseG1GC
dbms.jvm.additional=-XX:MaxGCPauseMillis=200

  3. 连接池优化：

    txt
    # 连接池配置优化
dbms.connector.bolt.thread_pool_max_size=200
dbms.connector.http.thread_pool_max_size=100
dbms.connector.https.thread_pool_max_size=100

负载均衡优化 ​

  1. 选择合适的负载均衡算法：

    • 轮询（Round Robin）：适用于节点性能相近的场景
    • 最少连接（Least Connections）：适用于节点性能差异较大的场景
    • IP 哈希（IP Hash）：适用于需要会话保持的场景

  2. 调整负载均衡权重：

    txt
    # HAProxy 调整权重示例
server replica1 replica1:7687 weight 100 check port 7687 inter 2000 rise 2 fall 3
server replica2 replica2:7687 weight 200 check port 7687 inter 2000 rise 2 fall 3  # 权重更高，处理更多请求

  3. 实现智能路由：

    • 根据查询类型自动路由到合适的节点
    • 根据节点负载动态调整路由策略
    • 考虑数据位置进行路由优化

故障处理 ​

节点故障处理 ​

核心节点故障 ​

  1. 故障检测：

    • 集群自动检测节点故障
    • 通过监控系统告警
    • 检查节点状态：
      bash
      neo4j status

  2. 故障恢复：

    • 如果是临时故障，等待节点自动恢复
    • 如果是永久故障，替换故障节点：
      bash
      # 停止故障节点
neo4j stop

# 移除故障节点（从其他核心节点执行）
cypher-shell -u neo4j -p password -c "CALL dbms.cluster.removeNode('core2:5000')"

# 添加新节点
# 配置新节点的 neo4j.conf，然后启动
neo4j start

只读副本故障 ​

  1. 故障检测：

    • 负载均衡器检测节点故障
    • 通过监控系统告警

  2. 故障恢复：

    • 自动从负载均衡池中移除故障节点
    • 恢复故障节点或添加新节点：
      bash
      # 重启故障的只读副本
neo4j restart

# 或添加新的只读副本
# 配置新节点的 neo4j.conf，然后启动
neo4j start

数据不一致处理 ​

检测数据不一致 ​

cypher
// 检测数据不一致
CALL dbms.cluster.overview()
YIELD address, databases
UNWIND databases AS db
RETURN address, db.name AS database, db.status AS status, db.defaultAccessMode AS accessMode;

修复数据不一致 ​

bash
# 修复数据不一致
neo4j-admin debug consistency --database=neo4j

# 如果需要，从备份恢复
neo4j-admin restore --from=/backup/neo4j --database=neo4j --force

切换主节点 ​

手动切换主节点 ​

cypher
// 查看当前主节点
CALL dbms.cluster.overview()
YIELD address, role, databases
RETURN address, role, databases
WHERE role = 'LEADER';

// 手动触发选举（从核心节点执行）
CALL dbms.cluster.rotateLeader()

读写分离最佳实践 ​

1. 合理规划集群规模 ​

  • 核心节点数量：

    • 最少3个节点，推荐奇数个节点
    • 核心节点数量根据写负载和可用性要求确定
    • 通常3-7个核心节点足够满足大多数场景

  • 只读副本数量：

    • 根据读负载确定只读副本数量
    • 可以从2个开始，根据负载情况逐步增加
    • 考虑核心节点的复制能力，避免过多的只读副本导致核心节点负载过高

2. 优化客户端连接 ​

  • 使用连接池：

    java
    // 配置连接池
Config config = Config.builder()
        .withConnectionPoolSize(100)  // 连接池大小
        .withMaxConnectionLifetime(Duration.ofHours(1))
        .withConnectionAcquisitionTimeout(Duration.ofSeconds(30))
        .build();

Driver driver = GraphDatabase.driver("neo4j://localhost:7687", AuthTokens.basic("neo4j", "password"), config);

  • 合理设置会话超时：

    txt
    # 配置会话超时
dbms.transaction.timeout=30s

3. 实现智能路由 ​

  • 根据查询类型路由：

    • 写操作路由到核心节点
    • 读操作路由到只读副本
    • 关键读操作可以路由到核心节点以获取最新数据

  • 根据数据位置路由：

    • 考虑数据分片情况进行路由
    • 避免跨分片查询导致的性能问题

4. 监控和告警 ​

  • 建立完善的监控体系：

    • 监控集群健康状态
    • 监控读写请求分布
    • 监控复制延迟
    • 监控节点负载

  • 设置合理的告警阈值：

    • 复制延迟超过5秒告警
    • 节点CPU使用率超过80%告警
    • 连接池使用率超过90%告警

5. 定期测试和演练 ​

  • 定期测试故障恢复流程：

    • 模拟节点故障，测试自动恢复能力
    • 测试手动恢复流程
    • 记录恢复时间，优化恢复流程

  • 定期测试读写分离效果：

    • 测试读请求是否正确路由到只读副本
    • 测试写请求是否正确路由到核心节点
    • 测试复制延迟是否在可接受范围内

6. 考虑数据一致性要求 ​

  • 根据业务需求选择一致性级别：

    • 对一致性要求高的业务使用强一致性
    • 对一致性要求不高的业务使用最终一致性

  • 实现合适的冲突处理机制：

    • 使用乐观锁处理并发冲突
    • 实现合理的重试机制
    • 考虑使用分布式锁处理复杂冲突

案例分析 ​

电商网站读写分离实践 ​

业务场景 ​

  • 读请求：商品查询、订单查询、用户信息查询
  • 写请求：订单创建、商品更新、用户注册
  • 读写比例：约10:1

架构设计 ​

  • 3个核心节点处理写操作
  • 6个只读副本处理读操作
  • 使用 HAProxy 实现负载均衡
  • 客户端使用官方驱动实现读写分离

优化效果 ​

  • 系统吞吐量提高了3倍
  • 主节点负载降低了60%
  • 系统可用性达到99.99%
  • 读请求响应时间降低了40%

社交媒体平台读写分离实践 ​

业务场景 ​

  • 读请求：帖子查询、用户信息查询、消息查询
  • 写请求：帖子发布、评论、点赞
  • 读写比例：约20:1

架构设计 ​

  • 5个核心节点处理写操作
  • 10个只读副本处理读操作
  • 使用 Nginx 实现负载均衡
  • 实现智能路由，根据查询类型和负载情况动态路由

优化效果 ​

  • 系统可以处理10万+并发请求
  • 主节点负载保持在合理水平
  • 系统可用性达到99.99%
  • 读请求响应时间稳定在毫秒级

常见问题（FAQ） ​

Q1: Neo4j 读写分离适合所有场景吗？ ​

A1: 不是所有场景都适合读写分离。读写分离主要适合读多写少的应用场景，如内容管理系统、电商网站等。对于写多读少或数据一致性要求极高的场景，可能不适合使用读写分离，或者需要特殊的一致性处理机制。

Q2: 如何处理读写分离中的数据一致性问题？ ​

A2: 可以通过以下方式处理数据一致性问题：

  • 选择合适的一致性级别：强一致性或最终一致性
  • 监控复制延迟，确保在可接受范围内
  • 实现乐观锁机制处理并发冲突
  • 对关键业务使用读写都走核心节点的方式
  • 实现合理的重试机制

Q3: Neo4j 支持自动读写分离吗？ ​

A3: Neo4j 驱动程序支持自动读写分离，通过设置会话的访问模式（READ/WRITE），驱动程序会自动将请求路由到合适的节点。同时，也可以通过负载均衡器（如 HAProxy、Nginx）实现外部的读写分离。

Q4: 只读副本的数量越多越好吗？ ​

A4: 不是。只读副本的数量受限于核心节点的复制能力和网络带宽。过多的只读副本会导致核心节点负载过高，增加复制延迟。建议根据实际读负载和核心节点能力，合理规划只读副本数量，通常从2-3个开始，逐步扩展。

Q5: 如何监控 Neo4j 读写分离的性能？ ​

A5: 可以监控以下关键指标：

  • 集群健康状态和节点角色
  • 读写请求分布和响应时间
  • 复制延迟和同步状态
  • 节点 CPU、内存、磁盘 I/O 使用情况
  • 连接池使用情况

使用 Neo4j 内置监控工具、Prometheus + Grafana 或其他第三方监控工具都可以实现这些指标的监控。

Q6: 核心节点故障会影响读写分离吗？ ​

A6: 核心节点故障会影响写操作，但不会直接影响读操作。Neo4j 集群会自动处理核心节点故障，通过 Raft 协议重新选举新的领导者。在故障转移期间，写操作可能会暂时不可用，但读操作可以继续由只读副本处理。

Q7: 如何优化 Neo4j 读写分离的性能？ ​

A7: 可以从以下几个方面优化：

  • 合理规划集群规模和节点配置
  • 优化客户端连接池设置
  • 调整复制配置降低延迟
  • 为查询创建合适的索引
  • 优化 Cypher 查询语句
  • 根据业务需求选择合适的负载均衡算法

Q8: 从单实例迁移到读写分离集群需要注意什么？ ​

A8: 迁移时需要注意：

  • 做好充分的测试和验证
  • 制定详细的迁移计划和回滚方案
  • 确保数据一致性
  • 调整应用程序以支持读写分离
  • 逐步迁移流量，监控系统性能
  • 准备好监控和告警机制