What methods can ensure horizontal scaling of a database for even distribution of read requests?

The following methods are used for horizontal scaling of a database to evenly distribute read requests:

1. Replication — creating copies of the database (replicas) that handle only read operations. Read requests are distributed among replicas, while write operations go to the master database.

2. Sharding — dividing data horizontally into several independent databases (shards). Each shard handles a portion of data and requests, reducing the load on a single server.

3. Load Balancing — using proxies or load balancers that distribute read requests among replicas according to specific algorithms (round-robin, least connections, etc.).

4. Caching — implementing caches (e.g., Redis, Memcached) to reduce the number of database accesses.

An example of simple replication with load balancing in Go (pseudocode):

var readReplicas = []string{"db-replica1:5432", "db-replica2:5432"}

func getReadDB() *sql.DB {
    // Select replica by round-robin
    replica := selectReplica()
    db, err := sql.Open("postgres", replica)
    if err != nil {
        log.Fatal(err)
    }
    return db
}

func selectReplica() string {
    // Replica selection logic
}

Thus, horizontal scaling is achieved by distributing read load across multiple nodes.