1
# Quorum 读写伪代码
2
class AuroraQuorum:
3
    TOTAL_REPLICAS = 6
4
    WRITE_QUORUM = 4
5
    READ_QUORUM = 3
6

7
    def write(self, log_record):
8
        """写入：至少 4 个副本确认"""
9
        acks = 0
10
        for replica in self.replicas:
11
            if replica.append_log(log_record):
12
                acks += 1
13
                if acks >= self.WRITE_QUORUM:
14
                    return True  # 写入成功
15
        return False  # 写入失败
16

17
    def read(self, lsn):
18
        """读取：至少 3 个副本返回，取最高 LSN"""
19
        responses = []
20
        for replica in self.replicas:
21
            resp = replica.read_lsn()
22
            responses.append(resp)
23
            if len(responses) >= self.READ_QUORUM:
24
                # 取最高 LSN 的响应
25
                return max(responses, key=lambda r: r.lsn)

1
传统数据库写入流程：
2
  1. 写 Redo Log（WAL）
3
  2. 写数据页到磁盘
4
  3. 写 Undo Log
5
  总 I/O：3 次写操作
6

7
Aurora 写入流程：
8
  1. 写 Redo Log 到存储层（6 副本，4 确认）
9
  2. 完成！
10
  总 I/O：1 次写操作（日志）
11

12
存储节点后台操作：
13
  1. 接收 Redo Log
14
  2. 将日志重放为数据页（后台异步）
15
  3. 定期生成 Checkpoint
16
  4. 垃圾回收旧版本

1
-- Aurora 只读副本
2
-- 创建只读副本（秒级完成）
3
-- AWS CLI
4
aws rds create-db-instance-read-replica \
5
    --db-instance-identifier aurora-reader-1 \
6
    --source-db-instance-identifier aurora-cluster
7

8
-- 只读副本特点：
9
-- 1. 共享同一存储卷，无需数据拷贝
10
-- 2. 延迟通常 < 20ms
11
-- 3. 最多 15 个只读副本
12
-- 4. 自动负载均衡（Reader Endpoint）
13

14
-- 连接写入节点
15
mysql -h aurora-cluster.cluster-xxxxx.rds.amazonaws.com
16

17
-- 连接只读副本（自动路由）
18
mysql -h aurora-cluster.cluster-ro-xxxxx.rds.amazonaws.com

1
# Neon 分支：秒级创建数据库分支
2
# 类似 Git 的分支概念，但用于数据库
3

4
# 创建分支（基于当前时间点）
5
neon branch create my-branch --parent main
6

7
# 创建分支（基于特定时间点）
8
neon branch create my-branch --parent main --timestamp "2026-06-15T10:00:00Z"
9

10
# 创建分支（基于特定 LSN）
11
neon branch create my-branch --parent main --lsn 0/1A2B3C4D
12

13
# 列出所有分支
14
neon branch list
15

16
# 删除分支
17
neon branch delete my-branch

1
# Neon 分支的工作原理
2
# 1. 分支共享父分支的存储（Copy-on-Write）
3
# 2. 新写入的数据独立存储
4
# 3. 读取时：先查自己的数据，再查父分支的数据
5

6
class NeonBranch:
7
    def __init__(self, parent_lsn, page_server):
8
        self.parent_lsn = parent_lsn  # 分支点的 LSN
9
        self.page_server = page_server
10
        self.own_wal = []  # 分支自己的 WAL
11

12
    def read_page(self, page_id):
13
        """读取页面：先查自己的 WAL，再查父分支"""
14
        # 1. 在自己的 WAL 中查找
15
        for record in reversed(self.own_wal):
16
            if record.page_id == page_id:
17
                return record.data
18

19
        # 2. 在父分支中查找（LSN <= parent_lsn）
20
        return self.page_server.get_page(page_id, self.parent_lsn)
21

22
    def write_page(self, page_id, data):
23
        """写入页面：追加到自己的 WAL"""
24
        self.own_wal.append(WalRecord(page_id, data))

1
# Neon Serverless 配置
2
compute:
3
  # 自动挂起：无流量时缩容到零
4
  auto_suspend: 300  # 5 分钟无活动后挂起
5

6
  # 自动恢复：有连接时自动启动
7
  auto_resume: true
8

9
  # 计算规格范围
10
  min_cu: 0.25  # 最小 0.25 Compute Unit
11
  max_cu: 8     # 最大 8 Compute Unit
12

13
  # 冷启动时间
14
  cold_start: ~500ms  # 从挂起到可用

1
// Aurora 本地缓存策略
2
type AuroraBufferPool struct {
3
    shared    *SharedStorage     // 共享存储层
4
    local     *LRUCache          // 本地 Buffer Pool
5
    cacheSize int               // 缓存大小
6
}
7

8
func (bp *AuroraBufferPool) ReadPage(pageID PageID) (*Page, error) {
9
    // 1. 查本地缓存
10
    if page, ok := bp.local.Get(pageID); ok {
11
        return page, nil  // 缓存命中，微秒级
12
    }
13

14
    // 2. 缓存未命中，从共享存储读取
15
    page, err := bp.shared.ReadPage(pageID)
16
    if err != nil {
17
        return nil, err  // 毫秒级延迟
18
    }
19

20
    // 3. 放入本地缓存
21
    bp.local.Put(pageID, page)
22
    return page, nil
23
}
24

25
func (bp *AuroraBufferPool) WritePage(pageID PageID, data []byte) error {
26
    // 写入不需要立即写数据页！
27
    // 只写 Redo Log 到共享存储
28
    // 数据页在本地缓存中修改，后续异步刷回
29
    bp.local.Put(pageID, NewPage(data))
30
    return bp.shared.AppendLog(pageID, data)
31
}

1
场景：3 节点 MySQL 集群，1TB 数据
2

3
传统 RDS（3 × db.r5.xlarge）：
4
  计算：3 × $0.34/h = $734/月
5
  存储：3 × 1TB × $0.115/GB = $345/月
6
  总计：$1,079/月
7

8
Aurora（1 写 + 2 读）：
9
  计算：3 × $0.34/h = $734/月
10
  存储：1 × 1TB × $0.10/GB = $100/月
11
  I/O：~$50/月（估算）
12
  总计：$884/月（节省 18%）
13

14
Neon Serverless：
15
  计算：按需 ~$200/月（开发/测试场景）
16
  存储：1TB × $0.12/GB = $120/月
17
  总计：$320/月（节省 70%）

1
-- Aurora 性能优化
2
-- 1. 增大 Buffer Pool 提高缓存命中率
3
-- 参数：innodb_buffer_pool_size（建议 75% 可用内存）
4

5
-- 2. 使用 Aurora Global Database 减少跨区域延迟
6
aws rds create-global-cluster \
7
    --global-cluster-identifier aurora-global \
8
    --engine aurora-mysql
9

10
-- 3. 使用 Aurora Parallel Query 加速分析查询
11
SET aurora_parallel_query=ON;
12

13
SELECT /*+ PQ */ COUNT(*), SUM(amount)
14
FROM orders
15
WHERE created_at >= '2026-01-01';

1
# Neon 性能优化
2
# 1. 预热计算节点（减少冷启动）
3
neon compute start --project-id my-project
4

5
# 2. 调整 Page Server 缓存大小
6
# pageserver 配置
7
[pageserver]
8
page_cache_size = "4GB"          # 页面缓存
9
max_file_descriptors = 8192      # 文件描述符
10
eviction_policy = "lru"          # 淘汰策略
11

12
# 3. Safekeeper WAL 持久化配置
13
[safekeeper]
14
wal_keep_size = "1GB"            # 保留的 WAL 大小
15
backup_parallelism = 4           # S3 上传并行度