Cả bài trong một trang: ý chính, sơ đồ, điểm phỏng vấn.
Replication primary–replica và tách đọc/ghi: replication lag, read-your-writes và failover
1Replica để làm gì
Primary nhận mọi lệnh ghi, replica là bản sao phục vụ đọc. Web điển hình đọc 90–95%: một primary với hai replica gần gấp ba năng lực đọc.
Chia tải đọc, không đổi schema hay truy vấn
Có bản sao ở máy khác để failover
Chạy báo cáo, backup không đụng primary
Nghẽn ở ghi thì vô ích: cần sharding
2Replication chạy thế nào
Primary ghi thay đổi vào log tuần tự, replica kéo về và phát lại đúng thứ tự. Vị trí trong log là GTID (MySQL) hoặc LSN (PostgreSQL).
flowchart TD
A["App ghi"] --> P["Primary commit"]
P --> L["binlog hoặc WAL"]
L -->|"bất đồng bộ"| R["Replica phát lại"]
R --> Q["App đọc thường"]
3Bất đồng bộ hay đồng bộ
Primary chờ replica càng nhiều thì càng ít mất dữ liệu khi failover, nhưng commit càng chậm và dễ treo khi replica lỗi.
Chế độ
Commit trả về khi
Mất dữ liệu
Bất đồng bộ
Primary ghi xong log
Có thể mất
Bán đồng bộ MySQL
Một replica đã nhận
Không mất
PG remote_apply
Standby đã áp dụng
Không, đọc thấy ngay
4Lag và read-your-writes
Replication lag thường dưới một giây, có thể lên hàng phút. User sửa hồ sơ rồi đọc replica thấy tên cũ; cần read-your-writes.
Cách
Đánh đổi
Đọc primary sau khi ghi
Dễ, hay quên màn hình kế
Ghim primary 5 giây
Sai khi lag vượt p99
Mang LSN/GTID theo request
Chính xác, phải theo dõi replica
5Định tuyến trong Spring Boot
@Transactional(readOnly = true) đi replica, còn lại đi primary. Phải bọc LazyConnectionDataSourceProxy, vì connection bị lấy trước khi cờ read-only có tác dụng.
Chọn replica có GTID/LSN mới nhất, nâng lên primary, fencing primary cũ, rồi đổi đường đi của client. Thiếu fencing là split-brain: hai primary cùng nhận ghi.
Nhiều thành phần cùng xác nhận primary chết
Bất đồng bộ: giao dịch chưa tới replica là mất
Primary cũ quay lại làm replica bằng pg_rewind
💡 Ghi nhớ
Replica scale đọc, không scale ghi.
Bán đồng bộ không sửa replication lag.
Mặc định đi primary; replica chỉ khi chấp nhận dữ liệu cũ.
Replica không phải backup: DROP TABLE cũng được sao chép.
⭐ Điểm phỏng vấn
Tự trả lời trước, rồi bấm từng câu để xem đáp án.
Giữ read-your-writes thế nào?
Đọc primary sau ghi, hoặc chờ LSN/GTID.
Bất đồng bộ khác bán đồng bộ?
Bán đồng bộ chờ một replica nhận log.
Khi nào thêm replica không giúp?
Nghẽn ở ghi; cần sharding.
Xong phần tự kiểm tra, bài này đã được đánh dấu đã học ✓
⚠️ Lỗi thường gặp
Kiểm tra email trùng hay tồn kho trên replica rồi ghi lên primary.
Quên LazyConnectionDataSourceProxy, mọi transaction vẫn đi primary.
Failover không fencing, hai primary cùng nhận ghi.
Hệ thống đọc nhiều hơn ghi thường thêm read replica trước khi nghĩ tới sharding. Bài này giải thích replication chạy thế nào, vì sao đọc từ replica sinh ra bug “vừa lưu xong đã mất”, và cách định tuyến đọc/ghi, failover cho đúng. Nên đọc trước nguyên tắc CAP, PACELC và scalability.
Sơ đồ tóm tắt:
flowchart LR
App[Ứng dụng] -->|ghi| P[(Primary)]
App -->|đọc thường| R1[(Replica 1)]
App -->|đọc thường| R2[(Replica 2)]
App -->|đọc ngay sau khi ghi| P
P -->|"binlog / WAL, bất đồng bộ"| R1
P -->|"binlog / WAL"| R2
F{Primary chết?} -->|promote| R1
F -.->|fencing| P
1. Vì sao cần replica
Ý chính: replica giải quyết ba việc: chia tải đọc, có bản sao dữ liệu ở máy khác để failover, và chạy truy vấn nặng (báo cáo, backup) không đụng primary. Nó không giúp khi nghẽn ở ghi.
Ứng dụng web điển hình đọc 90–95%, ghi 5–10%. Một primary với hai replica gần như gấp ba năng lực đọc.
Thêm replica rẻ hơn sharding nhiều: không đổi schema, không đổi truy vấn, chỉ đổi chỗ gửi câu SELECT.
Nghẽn ở ghi (CPU, I/O của primary vì INSERT/UPDATE) thì replica vô ích, vì mỗi replica cũng phải phát lại mọi lệnh ghi. Lúc đó mới tới sharding.
Mô hình
Nơi ghi
Nơi đọc
Nhất quán
Dùng khi
Một database
1
1
mạnh
còn chịu được tải
Primary + replica
1
N
primary mạnh, replica trễ
đọc nhiều
Multi-primary
N
N
phải giải xung đột
ghi ở nhiều vùng, chấp nhận phức tạp
Sharding (+ replica mỗi shard)
N (mỗi key một nơi)
N
mạnh trong một shard
dữ liệu hoặc ghi vượt một máy
2. Replication chạy thế nào
Ý chính: primary ghi mọi thay đổi vào một log tuần tự; replica kéo log đó về và phát lại theo đúng thứ tự. Khác nhau giữa MySQL và PostgreSQL nằm ở loại log và cách phát lại.
MySQL: mỗi transaction commit ghi vào binlog. Replica có luồng I/O nhận binlog vào relay log, và luồng applier phát lại. Mặc định binlog_format=ROW: log chứa thay đổi của từng dòng, không phải câu SQL, nên NOW() hay UUID() không cho ra giá trị khác trên replica. Từ 8.0.27 applier chạy song song (replica_parallel_workers mặc định 4).
PostgreSQL: replica (standby) nhận WAL qua streaming replication (walsender trên primary, walreceiver trên standby) và áp dụng ở mức trang dữ liệu. Standby đọc được gọi là hot standby.
Vị trí trong log có tên: MySQL dùng GTID (id toàn cục của transaction), PostgreSQL dùng LSN (vị trí byte trong WAL). Đây là thứ bạn dùng để hỏi “replica đã có lần ghi của tôi chưa”.
2.1. Bất đồng bộ, bán đồng bộ, đồng bộ
Ý chính: primary chờ replica càng nhiều thì càng ít mất dữ liệu khi failover, nhưng mỗi commit càng chậm và càng dễ bị treo khi replica gặp sự cố.
Chế độ
Commit trả về khi
Mất dữ liệu khi primary chết
Cái giá
Bất đồng bộ (mặc định)
primary ghi xong log của nó
có thể mất các giao dịch replica chưa nhận
không thêm độ trễ
Bán đồng bộ MySQL (AFTER_SYNC)
ít nhất một replica xác nhận đã nhận vào relay log
không mất giao dịch đã trả về cho client
thêm một RTT; quá rpl_semi_sync_source_timeout thì tự lùi về bất đồng bộ
PostgreSQL synchronous_commit = on + synchronous_standby_names
standby đồng bộ đã flush WAL
không mất
thêm RTT + fsync của standby; mất standby đồng bộ là ghi bị treo
PostgreSQL remote_apply
standby đồng bộ đã áp dụng
không mất, và đọc trên standby đó thấy ngay
chậm nhất
3. Replication lag và các bug nó gây ra
Ý chính: lag bình thường là vài mili giây tới dưới một giây, nhưng có thể nhảy lên hàng phút khi có transaction lớn, DDL, hay truy vấn dài trên replica. Bug xuất hiện ở mọi chỗ code ngầm giả định “vừa ghi xong là đọc thấy”.
Ba dạng bug kinh điển:
Mất lần ghi của chính mình: user sửa hồ sơ, trang chuyển hướng và đọc từ replica, thấy tên cũ. User sửa lại lần nữa.
Thời gian chạy lùi: hai lần F5 rơi vào hai replica trễ khác nhau; bình luận vừa thấy lại biến mất.
Quyết định sai: kiểm tra “email đã tồn tại chưa” hoặc “còn hàng không” trên replica, thấy chưa có, rồi ghi lên primary. Hai request song song cùng qua.
Nguyên nhân lag hay gặp:
Một transaction cập nhật hàng triệu dòng: replica phải phát lại cả cục, và lag tăng đúng bằng thời gian đó.
DDL lớn (thêm cột, tạo index) không online: chặn applier.
Truy vấn dài trên hot standby của PostgreSQL xung đột với WAL đang áp dụng: standby chờ tối đa max_standby_streaming_delay (mặc định 30 giây) rồi huỷ truy vấn. Bật hot_standby_feedback thì không huỷ, nhưng primary phải giữ dead tuple lâu hơn (bảng phình).
Replica yếu hơn primary hoặc applier không theo kịp tải ghi.
Đo replication lag trên MySQL và PostgreSQL
MySQL 8:
-- trên replicaSHOW REPLICA STATUS\G-- Seconds_Behind_Source: ước lượng theo timestamp của event đang phát lại, = NULL khi luồng dừng-- Retrieved_Gtid_Set / Executed_Gtid_Set: đã nhận và đã thực thi tới đâu
Seconds_Behind_Source báo 0 khi luồng I/O bị kẹt (replica không nhận gì nên tưởng đã kịp). Đo chắc hơn bằng bảng heartbeat: primary ghi NOW(6) mỗi giây (pt-heartbeat), replica lấy hiệu với giờ hiện tại.
PostgreSQL:
-- trên primary: mỗi standby trễ bao nhiêu byte và bao lâuSELECT application_name, state, pg_wal_lsn_diff(pg_current_wal_lsn(), replay_lsn) AS replay_lag_bytes, write_lag, flush_lag, replay_lagFROM pg_stat_replication;-- trên standbySELECT pg_last_wal_replay_lsn(), now() - pg_last_xact_replay_timestamp() AS lag;
now() - pg_last_xact_replay_timestamp() tăng dần khi primary không có ghi nào, dù standby không trễ thật; đọc nó cùng với lag tính bằng byte.
4. Giữ read-your-writes
Ý chính: chọn cách theo độ chính xác cần có: đọc primary ngay sau khi ghi là đơn giản nhất; mang vị trí log (LSN/GTID) theo request là chính xác nhất; chấp nhận dữ liệu cũ chỉ cho màn hình không ai so sánh.
Cách
Làm thế nào
Ưu
Nhược
Đọc primary trong cùng luồng nghiệp vụ
Sau khi ghi, trả luôn dữ liệu vừa ghi, hoặc đọc lại bằng connection của primary
Đúng, dễ
Dễ quên ở màn hình kế tiếp
Ghim vào primary một khoảng thời gian
Ghi xong đặt cookie/Redis pin_primary_until = now + 5s; đọc trong khoảng đó đi primary
Không cần đổi query
Chọn số giây theo lag p99; lag vượt mức là sai
Mang LSN/GTID của lần ghi
Ghi xong lưu LSN; đọc chỉ gửi tới replica có replay_lsn ≥ LSN, không có thì về primary hoặc chờ
Chính xác
Phải lấy LSN sau commit và theo dõi replica
Chấp nhận eventual consistency
Đọc replica luôn
Rẻ nhất
Chỉ hợp feed, thống kê, trang công khai
Monotonic reads (không thấy thời gian chạy lùi): gắn mỗi user vào một replica cố định (hash theo user id) thay vì chọn ngẫu nhiên mỗi lần.
MySQL có WAIT_FOR_EXECUTED_GTID_SET(gtid_set, timeout) để replica chờ tới khi có giao dịch đó; PostgreSQL thì so pg_last_wal_replay_lsn() với LSN cần có.
5. Định tuyến đọc/ghi trong Spring Boot
Ý chính: đặt định tuyến ở tầng DataSource: transaction readOnly = true đi replica, còn lại đi primary. Phải bọc bằng LazyConnectionDataSourceProxy, nếu không connection đã được lấy trước khi Spring kịp đánh dấu transaction là read-only.
AbstractRoutingDataSource.determineCurrentLookupKey() được gọi lúc lấy connection. Với JpaTransactionManager, connection bị lấy ngay khi transaction bắt đầu, trước khi cờ read-only có tác dụng cho định tuyến; proxy lười trì hoãn việc lấy connection tới câu SQL đầu tiên.
Mặc định đi primary. Chỉ đánh dấu đọc replica khi chắc chắn chấp nhận dữ liệu cũ.
Phương án ngoài ứng dụng: proxy hiểu SQL (ProxySQL, MySQL Router, Pgpool-II) hoặc endpoint đọc của dịch vụ quản lý (Aurora reader endpoint). Ít code hơn, nhưng proxy không biết ngữ cảnh “user này vừa ghi”.
Cấu hình routing DataSource đầy đủ
public class ReadWriteRoutingDataSource extends AbstractRoutingDataSource { @Override protected Object determineCurrentLookupKey() { boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly(); boolean pinned = PrimaryPin.isPinned(); // ThreadLocal đặt từ filter theo cookie/Redis return (readOnly && !pinned) ? "replica" : "primary"; }}@Configurationclass DataSourceConfig { @Bean @ConfigurationProperties("app.datasource.primary") HikariDataSource primaryDataSource() { return new HikariDataSource(); } @Bean @ConfigurationProperties("app.datasource.replica") HikariDataSource replicaDataSource() { return new HikariDataSource(); } @Bean @Primary DataSource dataSource(HikariDataSource primaryDataSource, HikariDataSource replicaDataSource) { ReadWriteRoutingDataSource routing = new ReadWriteRoutingDataSource(); routing.setTargetDataSources(Map.of("primary", primaryDataSource, "replica", replicaDataSource)); routing.setDefaultTargetDataSource(primaryDataSource); routing.afterPropertiesSet(); return new LazyConnectionDataSourceProxy(routing); // bắt buộc, xem giải thích ở trên }}@Serviceclass ProfileService { @Transactional(readOnly = true) // đi replica public ProfileView view(long id) { ... } @Transactional // đi primary public ProfileView update(long id, UpdateProfile cmd) { ... PrimaryPin.pinFor(Duration.ofSeconds(5)); // các request đọc sau đó của user này đi primary return ProfileView.from(saved); // trả luôn dữ liệu vừa ghi }}
Hai điều cần nhớ: transaction lồng nhau REQUIRED dùng lại connection của transaction ngoài, nên một phương thức readOnly gọi từ trong transaction ghi vẫn đi primary (đúng ý muốn). Replica nên có user database chỉ có quyền SELECT, để lỡ định tuyến sai thì lỗi ngay thay vì ghi được vào replica (MySQL đặt super_read_only=ON trên replica).
6. Failover: khi primary chết
Ý chính: failover là chọn replica mới nhất, nâng nó lên primary, chặn primary cũ ghi tiếp (fencing), rồi đưa client sang địa chỉ mới. Phần khó không phải promote mà là không mất dữ liệu và không có hai primary cùng nhận ghi.
Phát hiện: nhiều thành phần cùng xác nhận primary chết (không tin một health check), vì mạng chập chờn rất giống primary chết.
Chọn ứng viên: replica có GTID/LSN mới nhất. Với bất đồng bộ, các giao dịch chưa tới replica nào là mất (RPO > 0).
Fencing: tước quyền ghi của primary cũ (tắt máy, gỡ IP, thu hồi lease) trước khi mở ghi ở primary mới. Thiếu bước này là split-brain: hai primary cùng nhận ghi, dữ liệu rẽ hai nhánh.
Đổi đường đi của client: DNS, virtual IP, hoặc proxy. Pool connection phải bỏ connection cũ; JVM còn có cache DNS (networkaddress.cache.ttl).
Đưa primary cũ quay lại làm replica: PostgreSQL dùng pg_rewind hoặc dựng lại từ đầu, vì nó có thể có giao dịch chưa từng sang primary mới.
Công cụ: Patroni (PostgreSQL, giữ khoá leader trong etcd/Consul), Orchestrator hoặc MySQL Group Replication / InnoDB Cluster, dịch vụ quản lý (RDS Multi-AZ, Aurora, Cloud SQL).
Multi-primary: vì sao hiếm khi là lựa chọn đầu tiên
Multi-primary (multi-master) cho ghi ở nhiều node, thường để ghi ở nhiều vùng địa lý. Hai node cùng sửa một dòng là xung đột ghi:
Last-write-wins theo timestamp: đơn giản, nhưng lặng lẽ mất một lần ghi, và đồng hồ lệch làm sai thứ tự.
Certification (Galera, MySQL Group Replication ở chế độ multi-primary): khi commit, transaction được kiểm tra xung đột với các node khác; bên thua bị rollback và ứng dụng phải retry. Độ trễ commit bằng một vòng đồng thuận.
Chia quyền ghi theo key (mỗi vùng sở hữu một tập user): thực chất là sharding theo vùng, tránh xung đột từ thiết kế.
Hầu hết hệ thống nghiệp vụ chọn một primary cộng replica, và chỉ chuyển sang sharding hay database phân tán (CockroachDB, Spanner, Aurora DSQL) khi thật sự phải ghi ở nhiều nơi. Xem chọn database.
Bài tập
Bài 1: Định tuyến đọc theo LSN
Viết ReadRouter giữ LSN của lần ghi cuối theo từng user. Hàm routeRead(user, replicas) trả về một replica đã phát lại tới ít nhất LSN đó, không có thì trả primary. Kiểm tra với: alice ghi ở LSN 10 và 30, bob ghi ở LSN 20; hai replica ở LSN 25 và 30; rồi trường hợp cả hai replica chỉ ở 25 và 28.
Lời giải Bài 1
import java.util.*;public class ReadRouter { record Replica(String name, long replayedLsn) {} // LSN cuối cùng mỗi user đã ghi (thực tế: lưu trong session/cookie hoặc Redis) private final Map<String, Long> lastWriteLsn = new HashMap<>(); private long primaryLsn = 0; long write(String user) { primaryLsn += 10; // mỗi lần ghi đẩy WAL/binlog đi một đoạn lastWriteLsn.put(user, primaryLsn); return primaryLsn; } /** Đọc từ replica nào đã replay tới ít nhất LSN của lần ghi cuối của user; không có thì về primary. */ String routeRead(String user, List<Replica> replicas) { long need = lastWriteLsn.getOrDefault(user, 0L); return replicas.stream() .filter(r -> r.replayedLsn() >= need) .max(Comparator.comparingLong(Replica::replayedLsn)) .map(Replica::name) .orElse("primary"); } public static void main(String[] args) { ReadRouter router = new ReadRouter(); router.write("alice"); // LSN 10 router.write("bob"); // LSN 20 long a = router.write("alice"); // LSN 30 List<Replica> replicas = List.of(new Replica("replica-1", 25), new Replica("replica-2", 30)); System.out.println("alice (cần " + a + ") -> " + router.routeRead("alice", replicas)); System.out.println("bob (cần 20) -> " + router.routeRead("bob", replicas)); System.out.println("carol (chưa ghi) -> " + router.routeRead("carol", replicas)); List<Replica> lagging = List.of(new Replica("replica-1", 25), new Replica("replica-2", 28)); System.out.println("alice, cả hai replica trễ -> " + router.routeRead("alice", lagging)); }}
Chạy bằng java ReadRouter.java (JDK 21):
alice (cần 30) -> replica-2bob (cần 20) -> replica-2carol (chưa ghi) -> replica-2alice, cả hai replica trễ -> primary
Bản thật: LSN lấy bằng SELECT pg_current_wal_lsn() (PostgreSQL) hoặc @@gtid_executed (MySQL) ngay sau commit, lưu vào cookie ký hoặc Redis theo user; replayedLsn của từng replica được một job hỏi mỗi giây. Chọn max cho dễ đọc; production nên chọn ngẫu nhiên trong các replica đủ điều kiện để chia tải, hoặc theo hash user id để giữ monotonic reads.
Bài 2: Chọn chiến lược cho ba màn hình
Hệ thống thương mại điện tử có primary + 2 replica, lag p99 là 800 ms. Chọn nơi đọc cho: (a) trang “đơn hàng của tôi” ngay sau khi đặt hàng, (b) trang danh sách sản phẩm công khai, (c) API kiểm tra mã giảm giá còn lượt dùng trước khi áp vào đơn.
Lời giải Bài 2
(a) Read-your-writes bắt buộc: ghim user vào primary 3–5 giây sau khi đặt hàng (lớn hơn vài lần lag p99), hoặc trả dữ liệu đơn hàng ngay trong response đặt hàng để trang kế tiếp không cần đọc lại. Không dùng monotonic hash một mình, vì nó không đảm bảo replica đã có lần ghi.
(b) Replica, thậm chí cache/CDN vài chục giây: dữ liệu cũ một giây không ai nhận ra.
(c) Đây là “đọc để quyết định ghi”: đọc và trừ lượt trên primary trong cùng transaction (UPDATE coupon SET used = used + 1 WHERE code = ? AND used < max_uses, kiểm tra số dòng bị ảnh hưởng). Replica ở đây sai cả khi lag bằng 0, vì hai request song song vẫn cùng thấy còn lượt.
Ghi nhớ
Giải thích được vì sao replica scale đọc mà không scale ghi.
Phân biệt được bất đồng bộ, bán đồng bộ, đồng bộ theo hai câu hỏi: mất dữ liệu khi failover không, và đọc replica có thấy ngay không.
Kể được ba bug do replication lag và cách giữ read-your-writes cho từng màn hình.
Biết vì sao routing DataSource cần LazyConnectionDataSourceProxy.
Mô tả được các bước failover và vì sao fencing chặn split-brain.
Câu hỏi phỏng vấn
Junior
Master–slave (primary–replica) là gì và dùng để làm gì?
Một database primary nhận mọi lệnh ghi và sao chép thay đổi sang các replica; replica phục vụ đọc. Dùng để tăng năng lực đọc, có bản sao để failover, và chạy báo cáo hay backup không ảnh hưởng primary.
Ngày nay thường gọi là primary–replica (hoặc leader–follower). Replica không nhận ghi; muốn scale ghi phải sharding.
Replication lag là gì? Cho một ví dụ bug.
Là khoảng trễ giữa lúc primary commit và lúc replica phát lại xong thay đổi đó; trong khoảng ấy đọc replica thấy dữ liệu cũ.
Ví dụ: user đổi ảnh đại diện, trang hồ sơ đọc từ replica nên vẫn hiện ảnh cũ, user tưởng lưu lỗi và bấm lại.
Mid
Bạn đảm bảo read-your-writes khi đọc từ replica thế nào?
Hoặc đọc primary cho các request ngay sau khi user ghi (ghim vài giây), hoặc mang LSN/GTID của lần ghi theo request và chỉ đọc từ replica đã phát lại tới đó.
Đơn giản nhất: trả luôn dữ liệu vừa ghi trong response, màn hình kế tiếp khỏi đọc lại.
Ghim theo thời gian phải chọn lớn hơn lag p99 và chấp nhận sai khi lag bất thường.
Theo LSN là chính xác nhất, nhưng cần theo dõi vị trí của từng replica.
Chống “thời gian chạy lùi” thì gắn user vào một replica cố định.
Bất đồng bộ và bán đồng bộ khác nhau thế nào?
Bất đồng bộ: commit trả về khi primary ghi xong, replica nhận sau, nên failover có thể mất các giao dịch cuối. Bán đồng bộ (MySQL): commit chờ ít nhất một replica xác nhận đã nhận log, nên giao dịch đã báo thành công không mất khi failover.
Bán đồng bộ thêm một RTT mỗi commit, và tự lùi về bất đồng bộ khi replica không trả lời quá rpl_semi_sync_source_timeout. Nó không làm replica đọc được dữ liệu mới ngay, vì chỉ chờ nhận, chưa chờ phát lại.
Cấu hình Spring Boot đọc replica, ghi primary thế nào? Hay sai chỗ nào?
AbstractRoutingDataSource chọn khoá theo TransactionSynchronizationManager.isCurrentTransactionReadOnly(), bọc trong LazyConnectionDataSourceProxy, và đánh dấu @Transactional(readOnly = true) cho phương thức đọc.
Hay sai: thiếu proxy lười nên mọi thứ đi primary (connection lấy trước khi biết read-only); quên @Transactional nên định tuyến không chạy; đánh readOnly cho phương thức đọc để quyết định ghi; cho user của replica quyền ghi nên định tuyến sai mà không ai biết.
Senior
Primary chết. Mô tả failover đúng và các rủi ro.
Xác nhận primary chết bằng nhiều nguồn, chọn replica mới nhất, fencing primary cũ, promote, đổi đường đi của client, rồi dựng lại primary cũ thành replica. Rủi ro chính là mất giao dịch chưa sao chép và split-brain.
Với bất đồng bộ, RPO > 0: giao dịch commit trên primary cũ mà chưa tới replica nào là mất. Cần RPO = 0 thì bán đồng bộ / đồng bộ.
Split-brain: primary cũ chỉ bị cô lập mạng, vẫn nhận ghi. Fencing (tắt máy, thu hồi lease trong etcd, gỡ IP) phải xong trước khi primary mới nhận ghi.
Client: DNS TTL, cache DNS của JVM, pool giữ connection cũ. Kiểm tra bằng diễn tập failover định kỳ.
Primary cũ có thể có giao dịch “tương lai” không có ở primary mới: pg_rewind hoặc dựng lại, không cho nó nhập lại như cũ.
Lag replica tăng từ 200 ms lên 10 phút vào lúc 2 giờ sáng mỗi đêm. Bạn điều tra gì?
Nghi một job ghi lớn chạy theo lịch: một transaction cập nhật hàng triệu dòng (hoặc DDL) mà replica phải phát lại cả khối. Xác nhận bằng log/metric rồi chia nhỏ job.
Đối chiếu thời điểm với cron/batch: xoá dữ liệu cũ, tính lại bảng tổng hợp, ALTER TABLE.
MySQL: xem SHOW REPLICA STATUS (applier đang ở giao dịch nào), binlog có event lớn không; PostgreSQL: pg_stat_replication.replay_lag, truy vấn dài trên standby đang chờ.
Sửa: chia theo batch vài nghìn dòng mỗi transaction, có nghỉ giữa các batch, theo dõi lag và tự dừng khi lag vượt ngưỡng; dùng công cụ đổi schema online (gh-ost, pt-online-schema-change).
Trong lúc chờ sửa: định tuyến đọc về primary khi lag vượt ngưỡng, thay vì phục vụ dữ liệu cũ 10 phút.
Khi nào thêm replica không giúp, và bạn làm gì thay?
Khi nghẽn ở ghi, khi dữ liệu vượt dung lượng một máy, hoặc khi truy vấn đọc chậm do thiếu index. Replica phát lại mọi lệnh ghi nên không giảm tải ghi.
Truy vấn chậm: sửa query/index trước, nhân bản một truy vấn tệ ra năm máy vẫn là năm truy vấn tệ.
Đọc lặp lại nhiều: cache.
Ghi nghẽn: gom ghi theo batch, đẩy việc không gấp qua hàng đợi, tách bảng ghi nóng sang kho phù hợp, cuối cùng là sharding.
Đọc phân tích nặng: đẩy sang kho phân tích (columnar) bằng CDC thay vì chạy trên replica.
Từ vựng tiếng Anh
Term
Phát âm
Nghĩa
Ví dụ câu tiếng Anh dùng trong phỏng vấn
primary / replica
/ˈpraɪ.mer.i/ /ˈrep.lɪ.kə/
bản chính / bản sao
“All writes go to the primary; replicas serve reads.”
replication lag
/ˌrep.lɪˈkeɪ.ʃən læɡ/
độ trễ sao chép
“Replication lag spiked during the nightly batch.”
asynchronous
/eɪˈsɪŋ.krə.nəs/
bất đồng bộ
“With asynchronous replication, failover can lose the last few commits.”
semi-synchronous
/ˌsem.iˈsɪŋ.krə.nəs/
bán đồng bộ
“Semi-sync waits until one replica has received the transaction.”
read-your-writes
/riːd jɔːr raɪts/
đọc thấy lần ghi của mình
“We pin the user to the primary for five seconds to keep read-your-writes.”
failover
/ˈfeɪlˌoʊ.vɚ/
chuyển sang bản dự phòng
“Failover promotes the most up-to-date replica.”
promote
/prəˈmoʊt/
nâng lên làm primary
“Patroni promoted the standby in about thirty seconds.”
split-brain
/splɪt breɪn/
hai primary cùng nhận ghi
“Without fencing, a network partition can cause split-brain.”
fencing
/ˈfen.sɪŋ/
chặn node cũ
“We fence the old primary before opening writes on the new one.”
point-in-time recovery
/pɔɪnt ɪn taɪm rɪˈkʌv.ɚ.i/
khôi phục về một thời điểm
“A replica is not a backup; we rely on point-in-time recovery.”
Ghi chép tự tổng hợp từ tài liệu chính thức và kinh nghiệm thực tế.