Hogyan lehet kiegyensúlyozni a forgalmat a szerverek között a rendszer optimális működése érdekében?

A szerverek közötti forgalom kiegyensúlyozásához általában a következő megközelítéseket használják:

1. Round Robin — egyszerű módszer, amelyben a kéréseket egymás után irányítják minden szerverhez.
2. Legkevesebb kapcsolattal rendelkező — a kérés a legkevesebb aktív kapcsolattal rendelkező szerverhez kerül.
3. IP Hash — a szerver kiválasztása a kliens IP-címének hash-én alapul, ez biztosítja az egyes munkameneteket egy szerveren.

Go-ban kész megoldások is használhatók, például a beépített net/http/httputil csomag ReverseProxy-jával egy terheléselosztót lehet létrehozni, vagy külső eszközökkel (NGINX, HAProxy).

Egyszerű Round Robin terheléselosztó példája Go-ban:

package main

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

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

var aktualis uint32

func kovetkezoSzerver() *url.URL {
    index := atomic.AddUint32(&aktualis, 1)
    szerverURL, _ := url.Parse(szerverek[int(index)%len(szerverek)])
    return szerverURL
}

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

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

Ez a terheléselosztó sorban irányítja a kéréseket a listában szereplő szerverekhez.