RDS Read-Write Splitting Patterns

App ──► PRIMARY ──────────────────────► STANDBY
           │                               │
           │  1. Write data                │
           │  2. Gửi data đến Standby      │
           │  3. ĐỢI Standby confirm ◄─────┤
           │  4. Return SUCCESS cho App    │

✅ Data 100% giống nhau giữa Primary và Standby
✅ Không mất data khi failover
❌ Write CHẬM hơn (phải đợi Standby confirm)

App ──► PRIMARY ──────────────────────► REPLICA
           │                               │
           │  1. Write data                │
           │  2. Return SUCCESS ngay ◄─────┤ (KHÔNG đợi)
           │  3. Gửi data đến Replica      │
           │     (background, SAU đó)      │

✅ Write NHANH (không đợi Replica)
✅ Có thể cross-region
❌ Replica có thể LAG (data cũ hơn Primary)
❌ Có thể mất data nếu Primary chết trước khi replicate

WRITER ENDPOINT:
mydb.cluster-abc123.ap-southeast-2.rds.amazonaws.com
→ Luôn trỏ đến WRITER instance
→ Dùng cho: INSERT, UPDATE, DELETE

READER ENDPOINT:
mydb.cluster-ro-abc123.ap-southeast-2.rds.amazonaws.com
→ Load balance giữa 2 READERS (tự động)
→ Dùng cho: SELECT

App Server
    │
    ├── Writes ──────────► WRITER ENDPOINT ──────► Writer Instance
    │
    └── Reads ───────────► READER ENDPOINT ──┬──► Reader 1
                           (load balanced)   └──► Reader 2

PRIMARY:
mydb.abc123.ap-southeast-2.rds.amazonaws.com

READ REPLICA 1:
mydb-replica-1.abc123.ap-southeast-2.rds.amazonaws.com

READ REPLICA 2:
mydb-replica-2.abc123.ap-southeast-2.rds.amazonaws.com

⚠️ KHÔNG có Reader Endpoint chung như Multi-AZ Cluster!
→ Bạn phải tự load balance giữa các replicas

Lambda ──► RDS Proxy (read endpoint) ──┬──► Replica 1
                                       ├──► Replica 2
                                       └──► Replica 3

RDS Proxy tự động:
• Connection pooling
• Load balancing
• Health checks

# Terraform example
resource "aws_route53_record" "read_replicas" {
  count   = 3
  zone_id = aws_route53_zone.main.zone_id
  name    = "read.mydb.example.com"
  type    = "CNAME"
  
  weighted_routing_policy {
    weight = 1
  }
  
  set_identifier = "replica-${count.index}"
  records        = [aws_db_instance.replica[count.index].address]
}

spring:
  datasource:
    writer:
      url: jdbc:mysql://mydb.cluster-xxx.rds.amazonaws.com:3306/mydb
      username: admin
      password: ${DB_PASSWORD}
      hikari:
        pool-name: writer-pool
        maximum-pool-size: 10

    reader:
      url: jdbc:mysql://mydb.cluster-ro-xxx.rds.amazonaws.com:3306/mydb
      username: admin
      password: ${DB_PASSWORD}
      hikari:
        pool-name: reader-pool
        maximum-pool-size: 20

@Configuration
public class DataSourceConfig {

    @Bean
    @ConfigurationProperties("spring.datasource.writer")
    public DataSource writerDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.reader")
    public DataSource readerDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    @Primary
    public DataSource routingDataSource(
            @Qualifier("writerDataSource") DataSource writer,
            @Qualifier("readerDataSource") DataSource reader) {
        
        RoutingDataSource routing = new RoutingDataSource();
        Map<Object, Object> dataSources = new HashMap<>();
        dataSources.put(DataSourceType.WRITER, writer);
        dataSources.put(DataSourceType.READER, reader);
        
        routing.setTargetDataSources(dataSources);
        routing.setDefaultTargetDataSource(writer);
        return routing;
    }
}

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface ReadOnly {}

@Aspect
@Component
public class DataSourceAspect {

    @Before("@annotation(ReadOnly)")
    public void setReadDataSource() {
        DataSourceContextHolder.setDataSourceType(DataSourceType.READER);
    }

    @After("@annotation(ReadOnly)")
    public void clearDataSource() {
        DataSourceContextHolder.clear();
    }
}

@Service
public class OrderService {

    // WRITE → dùng WRITER (default)
    @Transactional
    public Order createOrder(Long userId, Long productId, int quantity) {
        return orderRepository.save(new Order(...));
    }

    // READ → dùng READER
    @ReadOnly
    @Transactional(readOnly = true)
    public List<Product> getProducts(String category) {
        return productRepository.findByCategory(category);
    }

    // WRITE + READ ngay sau → dùng WRITER cho cả 2
    @Transactional
    public User updateProfile(Long userId, String newName) {
        User user = userRepository.findById(userId).orElseThrow();
        user.setName(newName);
        return userRepository.save(user);  // Trả về từ WRITER
    }
}

T+0ms    User WRITES: UPDATE balance = 1000
T+1ms    Write SUCCESS ✅
T+2ms    User READS từ REPLICA: balance = 500 ❌ (data CŨ!)
T+50ms   Replication arrives: balance = 1000 ✅