Replicar é guardar o mesmo dado em vários nós. Resolve duas coisas: se um nó morre o dado sobrevive, e dá pra servir leitura da réplica mais perto do usuário. O preço é decidir o que fazer quando as cópias discordam.
Quórum é a regra: a escrita só confirma depois que W nós aceitam, a leitura consulta R nós e fica com a versão mais nova que viu. Se W+R > N, o conjunto que você escreveu e o conjunto que você lê obrigatoriamente compartilham pelo menos um nó, e esse nó tem o valor recente. É casa dos pombos. O Dynamo da Amazon deixou N, W e R na mão de quem usa justamente pra você escolher onde quer ficar entre consistência, latência e disponibilidade.
| Config | O que você ganha |
|---|
| W+R > N | leitura sempre vê a última escrita |
| W+R ≤ N | leitura pode vir stale (eventual) |
| sync | durável, latência do nó mais lento |
| async | rápida, risco de perda se o líder cair |
Quórum em Go (pseudo)
func write(reps []*Replica, val Value, W int) error {
val.Version = nextVersion()
acks := 0
for _, r := range reps {
if r.Send(val) { // propaga
acks++
if acks >= W { return nil } // quórum fechado
}
}
return ErrQuorumUnreachable
}
func read(reps []*Replica, R int) (Value, error) {
var latest Value
got := 0
for _, r := range reps {
v, ok := r.Get()
if !ok { continue }
got++
if v.Version > latest.Version { latest = v }
if got >= R { break }
}
if got < R { return latest, ErrQuorumUnreachable }
return latest, nil // se W+R>N, latest é a última escrita
}
// consistência forte exige interseção dos quóruns
func strong(N, W, R int) bool { return W+R > N }