Como pode equilibrar o tráfego entre servidores para o funcionamento ótimo do sistema?

Para equilibrar o tráfego entre servidores, geralmente utilizam-se as seguintes abordagens:

1. Round Robin — método simples em que as solicitações são enviadas sequencialmente para cada servidor.
2. Menos Conexões — a solicitação é enviada ao servidor com o menor número de conexões ativas.
3. Hash IP — seleção do servidor com base no hash do IP do cliente, garantindo uma sessão em um único servidor.

Em Go, pode-se usar soluções prontas, como o pacote embutido net/http/httputil com ReverseProxy para criar um balanceador, ou ferramentas externas (NGINX, HAProxy).

Exemplo de um balanceador simples em Go com Round Robin:

package main

import (
    "log"
    "net/http"
    "net/http/httputil"
    "net/url"
    "sync/atomic"
)

var servers = []string{
    "http://localhost:8081",
    "http://localhost:8082",
}

var current uint32

func getNextServer() *url.URL {
    idx := atomic.AddUint32(&current, 1)
    serverURL, _ := url.Parse(servers[int(idx)%len(servers)])
    return serverURL
}

func handler(w http.ResponseWriter, r *http.Request) {
    target := getNextServer()
    proxy := httputil.NewSingleHostReverseProxy(target)
    proxy.ServeHTTP(w, r)
}

func main() {
    http.HandleFunc("/", handler)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Este balanceador irá encaminhar sequencialmente as solicitações para os servidores da lista.