В чем разница между шардированием и репликацией?

Шардирование и репликация — это стратегии масштабирования баз данных и распределенных систем:

• Шардирование (Sharding):

  • Это горизонтальное разделение данных между разными серверами (шардами), где каждый шард хранит свою уникальную часть данных.
  • Цель: Увеличить пропускную способность (throughput) и емкость хранения, распределяя нагрузку по множеству машин.
  • Пример: База данных пользователей может быть разделена так, что пользователи с ID от 1 до 1000 хранятся на сервере A, а от 1001 до 2000 — на сервере B.

• Репликация (Replication):

  • Это копирование одних и тех же данных на несколько серверов (реплик).
  • Цель: Повысить отказоустойчивость (доступность данных при сбое одного сервера) и улучшить производительность чтения (распределяя запросы на чтение между репликами).
  • Пример: Все данные базы данных хранятся как на основном сервере (master), так и на нескольких резервных (replicas/slaves).

Ключевое отличие:

• Шардирование распределяет разные части данных для масштабирования по объему и записи.
• Репликация дублирует одни и те же данные для повышения доступности и масштабирования чтения.

Пример шардирования в Go (логика определения шарда):

import (
    "hash/fnv"
)

// getShard определяет, на какой шард должен попасть пользователь по его ID
func getShard(userID string, numShards int) int {
    h := fnv.New32a()
    h.Write([]byte(userID))
    return int(h.Sum32() % uint32(numShards)) // Например, 10 шардов
}

// В реальном приложении это будет использоваться для маршрутизации запросов
// func getUserData(userID string) (User, error) {
//     shardID := getShard(userID, 10)
//     // Подключиться к базе данных шарда shardID и получить данные
//     // ...
// }

Пример концепции репликации (упрощенно):

import (
    "fmt"
    "sync"
)

// DatabaseReplica представляет собой одну реплику базы данных
type DatabaseReplica struct {
    ID   int
    Data map[string]string
    mu   sync.RWMutex
}

func NewDatabaseReplica(id int) *DatabaseReplica {
    return &DatabaseReplica{ID: id, Data: make(map[string]string)}
}

func (r *DatabaseReplica) Write(key, value string) {
    r.mu.Lock()
    defer r.mu.Unlock()
    r.Data[key] = value
    fmt.Printf("Replica %d: Wrote %s = %sn", r.ID, key, value)
}

func (r *DatabaseReplica) Read(key string) (string, bool) {
    r.mu.RLock()
    defer r.mu.RUnlock()
    val, ok := r.Data[key]
    fmt.Printf("Replica %d: Read %s = %s (found: %t)n", r.ID, key, val, ok)
    return val, ok
}

// writeToAllReplicas имитирует запись во все реплики (для master-slave или multi-master)
func writeToAllReplicas(replicas []*DatabaseReplica, key, value string) {
    var wg sync.WaitGroup
    for _, replica := range replicas {
        wg.Add(1)
        go func(r *DatabaseReplica) {
            defer wg.Done()
            r.Write(key, value)
        }(replica)
    }
    wg.Wait()
    fmt.Println("All replicas updated.")
}

/*
func main() {
    replicas := []*DatabaseReplica{
        NewDatabaseReplica(1),
        NewDatabaseReplica(2),
        NewDatabaseReplica(3),
    }

    writeToAllReplicas(replicas, "user:1", "Alice")

    replicas[0].Read("user:1") // Чтение с одной из реплик
}
*/

Репликация повышает отказоустойчивость и читающую производительность, но может влиять на производительность записи из-за необходимости обеспечения консистентности между репликами.