Replication — 비동기 복제와 데이터 동기화

# redis.conf (레플리카 측)
replicaof 192.168.1.100 6379

# 또는 런타임에 설정
127.0.0.1:6380> REPLICAOF 192.168.1.100 6379
OK

# 복제 해제 (독립 마스터로 전환)
127.0.0.1:6380> REPLICAOF NO ONE
OK

# 레플리카 설정
masterauth "마스터비밀번호"
masteruser "마스터사용자"   # Redis 6.0+ ACL

# 마스터에서
127.0.0.1:6379> INFO replication
# role:master
# connected_slaves:2
# slave0:ip=192.168.1.101,port=6380,state=online,offset=1234,lag=0
# slave1:ip=192.168.1.102,port=6381,state=online,offset=1234,lag=0
# master_replid:abc123...
# master_repl_offset:1234

# 레플리카에서
127.0.0.1:6380> INFO replication
# role:slave
# master_host:192.168.1.100
# master_port:6379
# master_link_status:up
# slave_repl_offset:1234

1. 레플리카 → 마스터: PSYNC <replid> <offset>
   (처음이면 PSYNC ? -1)

2. 마스터: FULLRESYNC 응답 + RDB 생성 시작
   - 백그라운드에서 fork() → RDB 파일 생성
   - RDB 생성 중 들어오는 쓰기는 replication buffer에 저장

3. 마스터 → 레플리카: RDB 파일 전송
   - 네트워크를 통해 RDB 파일을 스트리밍

4. 레플리카: RDB 로드
   - 기존 데이터 삭제 후 RDB 로드
   - (Redis 7.0+ diskless: 직접 메모리로 로드 가능)

5. 마스터 → 레플리카: buffer에 쌓인 명령 전송
   - RDB 생성 이후의 쓰기 명령을 전달

6. 이후부터 실시간 명령 전파

# 마스터에서 디스크에 RDB를 쓰지 않고 직접 소켓으로 전송
repl-diskless-sync yes

# 여러 레플리카가 동시에 요청하면 모아서 한 번에 처리
repl-diskless-sync-delay 5  # 5초 대기 후 시작

# 레플리카에서도 디스크 없이 직접 메모리로 로드 (Redis 7.0+)
repl-diskless-load on-empty-db  # 빈 DB일 때만
# repl-diskless-load swapdb    # 새 데이터를 임시 DB에 로드 후 교체

# 백로그 크기 설정 (기본 1MB)
repl-backlog-size 256mb

# 백로그 유지 시간 (모든 레플리카 연결 해제 후)
repl-backlog-ttl 3600  # 1시간

1. 레플리카 재연결: PSYNC <replid> <last_offset>
2. 마스터: 백로그에 해당 offset 이후의 데이터가 있는지 확인
   - 있으면: CONTINUE 응답 + 누락 명령만 전송
   - 없으면: FULLRESYNC 응답 → 전체 동기화

필요 크기 = (초당 쓰기 바이트) × (예상 최대 연결 끊김 시간)

예: 초당 10MB 쓰기, 최대 60초 끊김 예상
→ 10MB × 60 = 600MB
→ repl-backlog-size 768mb (여유 있게)

127.0.0.1:6379> INFO replication
# master_replid:  abc123...  (현재 ID)
# master_replid2: def456...  (이전 마스터의 ID)
# master_repl_offset: 12345

# 최소 2개 레플리카가 확인할 때까지 최대 1000ms 대기
127.0.0.1:6379> SET important-data "value"
OK
127.0.0.1:6379> WAIT 2 1000
(integer) 2    # 2개 레플리카가 확인함

# 타임아웃 시 실제로 확인한 수 반환
127.0.0.1:6379> WAIT 3 500
(integer) 1    # 500ms 내에 1개만 확인됨

// Java에서 WAIT 사용
public void setWithWait(String key, String value, int numReplicas) {
    redisTemplate.opsForValue().set(key, value);
    // WAIT 실행
    Long confirmed = redisTemplate.execute((RedisCallback<Long>) connection ->
        connection.waitForReplication(numReplicas, 1000)
    );
    if (confirmed < numReplicas) {
        log.warn("{}개 레플리카만 확인됨 (요청: {})", confirmed, numReplicas);
    }
}

# 레플리카의 lag 확인 (초 단위)
127.0.0.1:6379> INFO replication
# slave0:ip=...,lag=0   # lag=0이면 거의 동기화됨

# REPLCONF GETACK으로 정확한 오프셋 확인
# (마스터가 주기적으로 레플리카에 확인)

// 전략 1: 쓰기 직후에는 마스터에서 읽기
public User getUser(Long userId, boolean afterWrite) {
    String key = "user:" + userId;
    if (afterWrite) {
        // 마스터에서 읽기
        return masterRedisTemplate.opsForValue().get(key);
    }
    // 레플리카에서 읽기
    return replicaRedisTemplate.opsForValue().get(key);
}

// 전략 2: WAIT로 동기화 확인 후 레플리카에서 읽기
public void updateAndRead(Long userId, UserDto dto) {
    masterRedisTemplate.opsForValue().set("user:" + userId, dto);
    masterRedisTemplate.execute((RedisCallback<Long>) conn ->
        conn.waitForReplication(1, 500));
    // 이제 레플리카에서 읽어도 안전
}

# 레플리카에서 읽기 허용 (기본값: yes)
replica-read-only yes

# stale 데이터 제공 허용 (마스터 연결 끊겼을 때)
replica-serve-stale-data yes  # yes: 오래된 데이터라도 응답
                               # no: LOADING 또는 MASTERDOWN 에러

Master → Replica1 → Sub-Replica1
                  → Sub-Replica2
       → Replica2

# 최소 레플리카 수가 충족되지 않으면 쓰기 거부
min-replicas-to-write 1    # 최소 1개 레플리카가 연결되어야 쓰기 허용
min-replicas-max-lag 10    # 레플리카의 lag가 10초 이내여야 함