Cụm bài Redis: 1. Redis bên trong: vì sao nhanh · 2. Persistence, replication, Sentinel và Cluster · 3. Chọn cấu trúc dữ liệu cho bài toán thật
Redis chạy trên RAM nên phải trả lời ba câu: restart còn gì (persistence), máy chết thì sao (replication, failover), vượt một máy thì chia thế nào (Cluster). Đọc xong, bạn nói được mỗi cấu hình mất gì, vì sao, và chọn được chế độ triển khai. Đọc trước phần 1 nếu chưa rõ event loop đơn luồng và vai trò của fork().
1. Persistence: RDB, AOF và hybrid
Ý chính: RDB chụp cả dataset định kỳ (mất vài phút), AOF ghi từng lệnh (mất ~1 giây), hybrid gộp cả hai. Chọn theo vai trò của Redis.
1.1. RDB: chụp nhanh toàn bộ
Ý chính: BGSAVE fork() ra tiến trình con để ghi snapshot trong khi cha vẫn phục vụ; cái giá là mỗi lần chụp là một lần fork() nặng.
SAVE: luồng chính tự ghi file, chặn mọi lệnh tới khi xong. Gần như không dùng trên production.BGSAVE: tiến trình con ghi snapshot từ bản sao bộ nhớ của nó, cha tiếp tục nhận lệnh.- Lịch tự động theo
save, mặc định Redis 7:save 3600 1 300 100 60 10000(1 giờ ≥1 thay đổi, 5 phút 100, hoặc 1 phút 10.000).
flowchart LR
M[Tiến trình chính] -->|fork| C[Tiến trình con]
M -->|tiếp tục nhận lệnh ghi| MEM[Trang bộ nhớ bị sửa được copy]
C -->|đọc snapshot bộ nhớ tại lúc fork| F[dump.rdb.tmp]
F -->|rename nguyên tử| R[dump.rdb]
Copy-on-write — cha và con dùng chung trang bộ nhớ, chỉ trang nào cha sửa sau khi fork mới bị copy. Ghi càng nhiều lúc chụp, bộ nhớ càng tăng, xấu nhất gần gấp đôi.
Ưu: file gọn, nạp nhanh (đọc tuần tự, không chạy lại lệnh), tiện backup và chuyển đi. Nhược: mất mọi thay đổi từ lần chụp cuối (có thể vài phút).
1.2. AOF: ghi lại từng lệnh
Ý chính: AOF (append-only file — file chỉ ghi nối đuôi) ghi mọi lệnh ghi theo thứ tự chạy trước, log sau. appendfsync quyết định mất bao nhiêu khi máy chết.
flowchart LR
CMD[Lệnh ghi] --> EXE[Chạy trên bộ nhớ]
EXE --> BUF[AOF buffer]
BUF -->|write trước khi trả lời vòng sau| OS[Page cache của OS]
OS -->|fsync theo appendfsync| DISK[(Disk)]
appendfsync |
Ý nghĩa | Mất tối đa khi máy chết |
|---|---|---|
always |
fsync sau mỗi vòng event loop có lệnh ghi | gần như không (vài lệnh trong vòng hiện tại) |
everysec (mặc định) |
fsync mỗi giây ở luồng nền | ~1 giây, tới 2 giây nếu disk chậm |
no |
để OS tự flush (Linux thường ~30 giây) | vài chục giây |
Tiến trình Redis chết (kill, crash) thì phần đã write() vào page cache vẫn còn, OS sẽ ghi xuống. Chỉ khi cả máy chết (mất điện, kernel panic) phần chưa fsync mới mất.
Nhược: file to hơn RDB, nạp chậm hơn (chạy lại lệnh), và always hay disk nghẽn có thể làm chậm luồng chính.
Vì sao log sau khi chạy, AOF rewrite, multi-part AOF và khi disk chậm chặn luồng chính
Log sau khi chạy có hai lợi (slide có nhắc): không phải kiểm tra cú pháp trước (lệnh sai bị từ chối khi chạy nên không vào log), và việc ghi log không làm chậm chính lệnh đó. Cái giá: chết giữa lúc chạy xong và chưa log thì mất lệnh đó.
AOF lớn dần, nên Redis rewrite định kỳ (BGREWRITEAOF, tự động theo auto-aof-rewrite-percentage 100 và auto-aof-rewrite-min-size 64mb): tiến trình con ghi lại trạng thái hiện tại bằng ít lệnh nhất (1.000 lần INCR thành một SET).
Từ Redis 7, AOF là multi-part: một file base, các file incr và một manifest, trong thư mục appendonlydir. Rewrite chỉ tạo base mới và mở incr mới, không còn phải giữ buffer rewrite trong bộ nhớ như trước.
1.3. Hybrid: RDB ở đầu, AOF ở đuôi
Ý chính: khi rewrite AOF, phần base ghi ở định dạng RDB, lệnh mới nối tiếp dạng AOF. Nạp nhanh gần như RDB, mất ít như AOF.
aof-use-rdb-preamble có từ Redis 4.0, mặc định yes từ 5.0. Khởi động thì nạp phần RDB rồi chạy lại phần lệnh còn lại. Nhược điểm slide nêu: file không đọc được bằng mắt (đầu là nhị phân), và Redis trước 4.0 không đọc được; điều thứ hai nay gần như vô nghĩa.
2. Replication
Ý chính: một master nhận mọi lệnh ghi và stream bất đồng bộ cho các replica. Được trải đọc và bản dự phòng nóng; mất tính nhất quán và có thể mất ghi khi failover.
2.1. Cách hoạt động
Ý chính: replica xin đồng bộ bằng PSYNC; lần đầu hoặc tụt quá xa thì full sync (gửi cả RDB), đứt ngắn thì partial sync từ backlog.
Replication tự nó không failover; đưa replica lên thay là việc của Sentinel hoặc Cluster.
Các bước PSYNC, full sync, partial sync và bẫy backlog 1 MB
- Replica (slide gọi là slave, tên cũ đổi từ 5.0) kết nối, gửi
PSYNC <replid> <offset>. - Lần đầu hoặc tụt quá xa: full sync. Master tạo RDB và gửi; trong lúc đó gom lệnh mới vào buffer, gửi tiếp sau khi replica nạp xong. Từ Redis 7, mặc định
repl-diskless-sync yes: stream thẳng qua socket, không ghi file. - Sau đó master stream từng lệnh ghi, bất đồng bộ.
- Đứt ngắn: partial sync. Replication backlog — bộ đệm vòng chứa lệnh gần nhất (mặc định
repl-backlog-size 1mb). Offset replica còn trong backlog thì chỉ gửi phần thiếu.
2.2. Bất đồng bộ nghĩa là có thể mất dữ liệu
Ý chính: master trả “OK” trước khi replica nhận lệnh. Master chết ngay sau đó và replica lên thay thì lệnh mất, dù client đã thấy thành công.
sequenceDiagram
participant C as Client
participant M as Master
participant R as Replica
C->>M: SET order:1 paid
M-->>C: OK
Note over M: master chết trước khi gửi lệnh
Note over R: replica được bầu làm master mới
C->>R: GET order:1
R-->>C: nil
Hai công cụ giảm rủi ro chứ không loại bỏ:
WAIT numreplicas timeout: client chặn tới khi lệnh ghi trước đó được ít nhất N replica xác nhận. “Gần đồng bộ”, nhưng xác nhận là đã nhận, chưa chắc đã fsync; timeout thì lệnh vẫn đã chạy trên master.min-replicas-to-write N+min-replicas-max-lag S: master từ chối ghi nếu ít hơn N replica có độ trễ ≤ S giây. Giới hạn cửa sổ mất dữ liệu khi master bị cô lập (split brain — hai node cùng tưởng mình là master).
2.3. Đọc từ replica
Ý chính: đọc từ replica trải tải đọc nhưng có thể thấy dữ liệu cũ vài ms tới vài giây.
Hợp với dữ liệu chấp nhận trễ (danh mục sản phẩm, bảng xếp hạng); sai cho read-your-writes (đọc lại ngay thứ mình vừa ghi) như hồ sơ vừa sửa. Lettuce chọn bằng ReadFrom.REPLICA_PREFERRED hoặc ReadFrom.UPSTREAM.
3. Sentinel: tự động failover
Ý chính: Sentinel là các tiến trình riêng (thường 3 hoặc 5, trên máy khác nhau) giám sát master, tự đưa replica lên khi master chết, và chỉ cho client master hiện tại.
- Giám sát master và replica bằng
PING. - Tự động failover: quá
down-after-millisecondskhông trả lời thì một sentinel đánh dấu SDOWN (subjectively down — “mình thấy nó chết”). Đủ quorum đồng ý thì thành ODOWN (objectively down). Sentinel bầu leader (cần đa số tuyệt đối, kiểu Raft); leader promote replica tốt nhất. - Service discovery: client không hard-code master mà hỏi
SENTINEL get-master-addr-by-name mymaster. Lettuce, Jedis hỗ trợ sẵn và tự chuyển khi failover.
flowchart TB
S1[Sentinel 1] -.giám sát.-> M[Master]
S2[Sentinel 2] -.giám sát.-> M
S3[Sentinel 3] -.giám sát.-> M
M -->|replication| R1[Replica 1]
M -->|replication| R2[Replica 2]
APP[Ứng dụng] -->|hỏi master hiện tại| S1
APP -->|đọc, ghi| M
Master mới lên trong vài giây tới vài chục giây. Nhược: vẫn bất đồng bộ (failover có thể mất ghi), thêm tiến trình phải vận hành, và mọi lệnh ghi dồn vào một master nên không mở rộng ghi hay dung lượng.
Leader chọn replica nào để promote
Thứ tự ưu tiên: replica-priority, rồi offset replication lớn nhất (dữ liệu mới nhất), rồi run ID nhỏ nhất. Leader gửi REPLICAOF NO ONE cho replica được chọn, rồi cấu hình các replica còn lại theo master mới.
4. Redis Cluster: chia dữ liệu ra nhiều master
Ý chính: Cluster chia keyspace cho nhiều master, mỗi master có replica riêng và tự failover không cần Sentinel. Đổi lại, lệnh nhiều key chỉ chạy khi mọi key cùng một slot.
4.1. Hash slot
Ý chính: có 16.384 hash slot; key thuộc slot CRC16(key) mod 16384, mỗi master giữ một tập slot.
flowchart TB
K1["CRC16(key2) mod 16384 = 4998"] --> M1["Master 1: slot 0-5460"]
K2["CRC16(key1) mod 16384 = 9189"] --> M2["Master 2: slot 5461-10922"]
K3["CRC16(foo) mod 16384 = 12182"] --> M3["Master 3: slot 10923-16383"]
M1 --> S1[Replica 1]
M2 --> S2[Replica 2]
M3 --> S3[Replica 3]
Các node nói chuyện qua cluster bus (cổng dữ liệu + 10000) bằng gossip — mỗi node kể cho vài node khác ai sống, ai giữ slot nào, tin lan dần ra cả cụm. Đa số master thấy một master im lặng quá cluster-node-timeout thì replica của nó xin bầu và lên thay.
Vì sao 16.384 slot, và vì sao slot thay vì consistent hashing
Vì sao 16.384 mà không phải 65.536 (CRC16 cho tới 65.536 giá trị)? Mỗi gói heartbeat mang bitmap slot của node gửi: 16.384 bit = 2 KB, 65.536 bit = 8 KB, quá nặng cho gói gửi liên tục. Cluster thiết kế cho tối đa ~1.000 master, nên 16.384 slot là đủ mịn.
Vì sao slot mà không phải consistent hashing? Slot cho phép di chuyển từng slot tường minh (resharding, cân bằng), và trạng thái “slot nào ở đâu” là một bảng nhỏ mọi node và client đều cache được.
4.2. Client tìm đúng node: MOVED và ASK
Ý chính: client gửi tới node bất kỳ; node không giữ slot thì trả lời chuyển hướng. MOVED = slot đã chuyển hẳn (cập nhật bảng), ASK = slot đang chuyển dở (chỉ chuyển lần này).
-MOVED 3999 10.0.0.2:6379: client cập nhật bảng slot rồi gửi lại. Client tốt (Lettuce, JedisJedisCluster) tải bảng slot lúc khởi động bằngCLUSTER SHARDSvà gửi đúng node ngay từ đầu.-ASK 3999 10.0.0.3:6379: key này đã sang node mới. Client gửiASKINGrồi lệnh tới node mới một lần, không cập nhật bảng.
4.3. Lệnh nhiều key và hash tag
Ý chính: lệnh đụng nhiều key chỉ chạy khi mọi key cùng slot. Hash tag — phần {...} không rỗng trong key — làm chỉ phần đó được băm, nên các key liên quan rơi vào cùng slot.
Các lệnh bị ảnh hưởng: MGET, SUNION, RENAME, transaction MULTI, script Lua. Khác slot thì Redis trả CROSSSLOT Keys in request don't hash to the same slot.
Ví dụ: user_profile:34 và user_session:34 ở slot 11933 và 12053 (có thể hai node), nên MGET hai key lỗi. Thêm tag {34} thì cả hai cùng slot 9745.
Hàm băm slot bằng Java, và bẫy hash tag quá thô
Mình viết lại hàm băm của Redis bằng Java để kiểm tra:
static int slot(String key) {
int open = key.indexOf('{');
if (open >= 0) {
int close = key.indexOf('}', open + 1);
if (close > open + 1) key = key.substring(open + 1, close); // chỉ băm phần trong {}
}
return crc16(key.getBytes(StandardCharsets.UTF_8)) & 16383; // = mod 16384
}
crc16("123456789") = 0x31C3 (đúng giá trị chuẩn CRC16-XMODEM trong tài liệu Redis)
foo -> 12182
user_profile:34 -> 11933
user_session:34 -> 12053
user_profile:{34} -> 9745
user_session:{34} -> 9745
{}user:34 -> 3665 (ngoặc rỗng: băm cả key)
4.4. Những thứ Cluster không cho
Ý chính: thêm master là mở rộng được cả đọc, ghi lẫn dung lượng, nhưng mất vài tính năng của Redis một node.
- Chỉ database 0, không có
SELECT. - Lệnh nhiều key, transaction, Lua chỉ trong một slot.
KEYS/SCANchỉ trên từng node; duyệt toàn bộ phải lặp qua mọi master.- Pub/sub thường phát tới mọi node (từ 7.0 có sharded pub/sub
SPUBLISHgiới hạn theo slot). - Client phải hỗ trợ cluster; vài thư viện cũ hoặc proxy không hỗ trợ.
Nhược khác: vẫn bất đồng bộ (mất ghi khi failover), vận hành phức tạp hơn (resharding, cân bằng slot).
5. Chọn chế độ triển khai
Ý chính: slide khuyến nghị Cluster; mình nghĩ nên chọn theo nhu cầu. Vừa một máy thì Sentinel thường đủ. Cách tính “vừa một máy” (số lệnh mỗi giây, giới hạn ~32 GB mỗi instance) và chỗ Redis nằm giữa các tầng cache ở Cache nhiều tầng và bộ đếm quy mô lớn.
Bài tập
Bài 1: chọn persistence và chế độ cho ba Redis
Đề: hệ thống đặt vé có ba nhu cầu Redis: (a) cache kết quả tìm chuyến bay, 8 GB; (b) session đăng nhập của 2 triệu user, 3 GB, mất session thì user phải đăng nhập lại; (c) giữ ghế tạm 10 phút trước khi thanh toán, 200 MB, mất thì có thể bán trùng ghế. Chọn persistence, chế độ HA và eviction cho từng cái.
Lời giải Bài 1
- (a) Cache tìm kiếm: không persistence (hoặc RDB thưa để tránh cache lạnh),
allkeys-lru, Sentinel hoặc một master + replica. Mất hết chỉ làm DB nóng lên một lúc; nên có cơ chế chống stampede khi khởi động lại. - (b) Session: AOF
everysec+ hybrid,noeviction(không được tự bỏ session để nhường chỗ), Sentinel 3 node. Mất 1 giây session mới khi máy chết là chấp nhận được (user đăng nhập lại). - (c) Giữ ghế: Redis không nên là nguồn sự thật. Ghế phải được giữ trong database bằng câu lệnh có điều kiện hoặc
SELECT ... FOR UPDATE(xem giữ ghế đồng thời); Redis chỉ làm lớp chắn nhanh phía trước hoặc bộ hẹn giờ hết hạn. Lý do: failover bất đồng bộ có thể làm mất một bản ghi giữ ghế vừa ghi, và hai người cùng mua một ghế. Nếu vẫn dùng Redis, tách instance riêng,noeviction, AOF,min-replicas-to-write 1, và DB vẫn kiểm tra lần cuối.
Bài 2: tính kích thước backlog
Đề: master ghi trung bình 8 MB/giây lệnh replication, cao điểm 20 MB/giây. Mạng giữa hai vùng có thể chập chờn tới 30 giây. Đặt repl-backlog-size bao nhiêu?
Lời giải Bài 2
Để partial sync vẫn được sau 30 giây ở cao điểm cần 20 MB × 30 = 600 MB, cộng biên an toàn thành khoảng 1 GB. Backlog chỉ cấp phát một lần trên master (dùng chung cho mọi replica) nên 1 GB là chi phí chấp nhận được so với một lần full sync dataset hàng chục GB.
Đồng thời nới client-output-buffer-limit replica để full sync (nếu vẫn xảy ra) không bị cắt giữa chừng, và theo dõi master_repl_offset so với offset của replica để cảnh báo trễ.
Ghi nhớ
- Nói được mỗi cấu hình (RDB, AOF
always/everysec/no, hybrid) mất bao nhiêu dữ liệu khi tiến trình chết và khi cả máy chết. - Giải thích được vì sao
fork()chặn luồng chính và làm bộ nhớ tăng, và cách giảm. - Giải thích được vì sao lệnh đã trả “OK” vẫn mất khi failover, và
WAIT/min-replicas-to-writegiúp tới đâu. - Biết vì sao cần ít nhất 3 sentinel, và quorum khác đa số thế nào.
- Phân biệt MOVED với ASK, biết dùng hash tag và biết khi nào chọn Sentinel thay vì Cluster.
Câu hỏi phỏng vấn
Mid
RDB và AOF khác nhau thế nào?
RDB là snapshot định kỳ (nạp nhanh, mất từ lần chụp cuối); AOF ghi từng lệnh (mất ~1 giây với everysec, nhưng file to và nạp chậm).
RDB tạo bằng BGSAVE (fork tiến trình con), file gọn. AOF fsync theo appendfsync (mặc định mỗi giây) và cần rewrite định kỳ. Hybrid (mặc định từ 5.0 khi bật AOF) ghi phần base dạng RDB rồi nối lệnh dạng AOF.
BGSAVE có chặn Redis không?
Phần ghi file thì không, nhưng bản thân fork() có chặn luồng chính.
fork() copy bảng trang, tỷ lệ với RAM (hàng chục tới hàng trăm ms với instance lớn). Copy-on-write còn làm bộ nhớ tăng theo lượng ghi trong lúc snapshot. SAVE thì chặn hoàn toàn.
Replication trong Redis đồng bộ hay bất đồng bộ? Hệ quả là gì?
Bất đồng bộ: master trả lời client trước khi replica nhận lệnh.
Hệ quả: đọc từ replica có thể thấy dữ liệu cũ, và khi master chết rồi replica lên thay, các lệnh đã trả “OK” nhưng chưa sang replica bị mất. WAIT và min-replicas-to-write giảm rủi ro nhưng không biến nó thành đồng bộ thật.
Hash tag trong Redis Cluster là gì?
Phần {...} không rỗng trong key: chỉ phần đó được băm CRC16 để chọn slot.
Dùng để đặt các key liên quan (user_profile:{34}, user_session:{34}) vào cùng slot, nhờ đó chạy được lệnh nhiều key, transaction và Lua trên chúng. Tag quá thô sẽ dồn nhiều key vào một node.
Senior
Sentinel failover diễn ra thế nào? Cần bao nhiêu sentinel?
SDOWN → đủ quorum thành ODOWN → bầu leader bằng đa số → leader promote replica tốt nhất. Cần ít nhất 3 sentinel trên 3 máy độc lập.
Mỗi sentinel ping master; quá down-after-milliseconds không trả lời thì đánh dấu SDOWN. Leader chọn replica (priority, offset lớn nhất, run ID), promote nó, cấu hình replica còn lại và báo client qua service discovery. Ba sentinel để vẫn còn đa số khi mất một máy.
Vì sao Redis Cluster có 16.384 slot?
Vì heartbeat mang bitmap slot: 16.384 bit là 2 KB, còn 65.536 bit là 8 KB, quá nặng khi gửi liên tục.
Cluster nhắm tối đa ~1.000 master nên 16.384 slot đủ mịn để chia đều. Slot cũng cho phép di chuyển dữ liệu từng phần tường minh khi resharding.
MOVED và ASK khác nhau thế nào?
MOVED: slot đã thuộc node khác vĩnh viễn, client cập nhật bảng slot. ASK: slot đang di chuyển, client chuyển hướng chỉ cho lần này.
Với ASK, key cụ thể đã sang node đích; client gửi ASKING rồi lệnh tới node đích, không cập nhật bảng slot vì slot vẫn chính thức thuộc node nguồn tới khi chuyển xong.
Khi nào chọn Sentinel thay vì Cluster?
Khi dữ liệu vừa một node và lượng ghi vừa một luồng chạy lệnh.
Sentinel cho failover tự động mà vẫn giữ mọi lệnh nhiều key, nhiều database và Lua không giới hạn slot, client đơn giản hơn. Chọn Cluster khi cần mở rộng ghi hoặc dung lượng vượt một node, hoặc muốn instance nhỏ để fork nhanh, và chấp nhận thiết kế key bằng hash tag.
Redis có thể dùng làm kho dữ liệu chính được không?
Được, với dữ liệu vừa RAM và chấp nhận mất một chút; không cho dữ liệu mà lệnh ghi đã xác nhận không được mất.
Mất khoảng 1 giây với AOF everysec, nhiều hơn khi failover do replication bất đồng bộ. Không hợp cho tiền, tồn kho, hay dữ liệu cần truy vấn phức tạp, quan hệ, transaction nhiều bảng. Khi đó Redis là cache hoặc lớp tăng tốc phía trước database; hoặc dùng dịch vụ có log bền như MemoryDB.
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 |
|---|---|---|---|
| snapshot | /ˈsnæpʃɒt/ | ảnh chụp dữ liệu tại một thời điểm | “RDB takes a point-in-time snapshot in a forked child process.” |
| append-only file | /əˈpend ˈəʊnli faɪl/ | file chỉ ghi nối đuôi | “The append-only file is fsynced once per second by default.” |
| fsync | /ˈef sɪŋk/ | ép dữ liệu xuống disk | “Losing the process is fine; losing the machine loses what wasn’t fsynced.” |
| copy-on-write | /ˈkɒpi ɒn raɪt/ | chép trang khi bị ghi | “Heavy writes during a snapshot inflate memory through copy-on-write.” |
| replication backlog | /ˌreplɪˈkeɪʃn ˈbæklɒɡ/ | bộ đệm lệnh để đồng bộ một phần | “A bigger backlog turns a full resync into a partial one.” |
| failover | /ˈfeɪləʊvə/ | chuyển sang node dự phòng | “Sentinel promotes the most up-to-date replica during failover.” |
| quorum | /ˈkwɔːrəm/ | số phiếu tối thiểu để đồng ý | “Quorum marks the master down, but electing a leader needs a majority.” |
| split brain | /splɪt breɪn/ | hai node cùng tưởng mình là master | “min-replicas-to-write limits writes lost to a split brain.” |
| hash slot | /hæʃ slɒt/ | ô băm của Cluster | “Every key maps to one of 16,384 hash slots.” |
| resharding | /riːˈʃɑːdɪŋ/ | chia lại dữ liệu giữa các node | “During resharding, clients may get ASK redirects.” |
| hash tag | /hæʃ tæɡ/ | phần {} quyết định slot |
“We use a hash tag per user so multi-key commands work.” |
| gossip protocol | /ˈɡɒsɪp ˈprəʊtəkɒl/ | giao thức lan truyền trạng thái | “Cluster nodes exchange health and slot ownership over a gossip protocol.” |
Ghi chép dựa trên khoá Advanced Backend (Ronin Engineer), viết lại theo cách hiểu của mình.