Erstellen eines einfachen Load Balancers in Go

Load Balancer sind in der modernen Softwareentwicklung von entscheidender Bedeutung. Wenn Sie sich jemals gefragt haben, wie Anfragen auf mehrere Server verteilt werden oder warum sich bestimmte Websites selbst bei hohem Datenverkehr schneller anfühlen, liegt die Antwort oft in einem effizienten Lastausgleich.

In diesem Beitrag erstellen wir einen einfachen Anwendungs-Load-Balancer mit dem Round-Robin-Algorithmus in Go. Ziel dieses Beitrags ist es, Schritt für Schritt zu verstehen, wie ein Load Balancer unter der Haube funktioniert.

Was ist ein Load Balancer?

Ein Load Balancer ist ein System, das eingehenden Netzwerkverkehr auf mehrere Server verteilt. Dadurch wird sichergestellt, dass kein einzelner Server zu stark ausgelastet ist, wodurch Engpässe verhindert und das Benutzererlebnis insgesamt verbessert werden. Der Lastausgleichsansatz stellt außerdem sicher, dass der Datenverkehr bei Ausfall eines Servers automatisch auf einen anderen verfügbaren Server umgeleitet werden kann, wodurch die Auswirkungen des Ausfalls verringert und die Verfügbarkeit erhöht werden.

Warum verwenden wir Load Balancer?

• Hohe Verfügbarkeit: Durch die Verteilung des Datenverkehrs stellen Load Balancer sicher, dass der Datenverkehr auch bei einem Serverausfall an andere fehlerfreie Server weitergeleitet werden kann, wodurch die Anwendung ausfallsicherer wird.
• Skalierbarkeit: Mit Load Balancern können Sie Ihr System horizontal skalieren, indem Sie bei steigendem Datenverkehr weitere Server hinzufügen.
• Effizienz: Es maximiert die Ressourcennutzung, indem sichergestellt wird, dass alle Server die Arbeitslast gleichmäßig teilen.

Lastausgleichsalgorithmen

Es gibt verschiedene Algorithmen und Strategien zur Verteilung des Datenverkehrs:

• Round Robin: Eine der einfachsten verfügbaren Methoden. Es verteilt Anfragen sequentiell auf die verfügbaren Server. Sobald es den letzten Server erreicht, beginnt es erneut von vorne.
• Gewichteter Round-Robin-Algorithmus: Ähnlich dem Round-Robin-Algorithmus, außer dass jedem Server eine feste numerische Gewichtung zugewiesen wird. Dieses gegebene Gewicht wird verwendet, um den Server für die Weiterleitung des Datenverkehrs zu bestimmen.
• Kleinste Verbindungen: Leitet den Datenverkehr an den Server mit den wenigsten aktiven Verbindungen weiter.
• IP-Hashing: Wählen Sie den Server basierend auf der IP-Adresse des Clients aus.

In diesem Beitrag konzentrieren wir uns auf die Implementierung eines Round Robin Load Balancers.

Was ist ein Round-Robin-Algorithmus?

Ein Round-Robin-Algorithmus sendet jede eingehende Anfrage zirkulär an den nächsten verfügbaren Server. Wenn Server A die erste Anfrage bearbeitet, bearbeitet Server B die zweite und Server C die dritte. Sobald alle Server eine Anfrage erhalten haben, beginnt es erneut bei Server A.

Jetzt lasst uns in den Code springen und unseren Load Balancer erstellen!

Schritt 1: Definieren Sie den Load Balancer und den Server

type LoadBalancer struct {
    Current int
    Mutex   sync.Mutex
}

Wir definieren zunächst eine einfache LoadBalancer-Struktur mit einem Current-Feld, um zu verfolgen, welcher Server die nächste Anfrage bearbeiten soll. Der Mutex stellt sicher, dass unser Code sicher gleichzeitig verwendet werden kann.

Jeder Server, den wir auslasten, wird durch die Serverstruktur definiert:

type Server struct {
    URL       *url.URL
    IsHealthy bool
    Mutex     sync.Mutex
}

Hier hat jeder Server eine URL und ein IsHealthy-Flag, das angibt, ob der Server für die Bearbeitung von Anfragen verfügbar ist.

Schritt 2: Round-Robin-Algorithmus

Das Herzstück unseres Load Balancers ist der Round-Robin-Algorithmus. So funktioniert es:

func (lb *LoadBalancer) getNextServer(servers []*Server) *Server {
    lb.Mutex.Lock()
    defer lb.Mutex.Unlock()

    for i := 0; i < len(servers); i++ {
        idx := lb.Current % len(servers)
        nextServer := servers[idx]
        lb.Current++

        nextServer.Mutex.Lock()
        isHealthy := nextServer.IsHealthy
        nextServer.Mutex.Unlock()

        if isHealthy {
            return nextServer
        }
    }

    return nil
}

• Diese Methode durchläuft die Liste der Server im Round-Robin-Verfahren. Wenn der ausgewählte Server fehlerfrei ist, wird er zur Verarbeitung der eingehenden Anfrage an diesen Server zurückgegeben.
• Wir verwenden Mutex, um sicherzustellen, dass jeweils nur eine Goroutine auf das aktuelle Feld des Load Balancers zugreifen und es ändern kann. Dadurch wird sichergestellt, dass der Round-Robin-Algorithmus ordnungsgemäß funktioniert, wenn mehrere Anforderungen gleichzeitig verarbeitet werden.
• Jeder Server verfügt außerdem über einen eigenen Mutex. Wenn wir das Feld IsHealthy überprüfen, sperren wir den Mutex des Servers, um den gleichzeitigen Zugriff mehrerer Goroutinen zu verhindern.
• Ohne Mutex-Sperre ist es möglich, dass eine andere Goroutine den Wert ändert, was dazu führen könnte, dass falsche oder inkonsistente Daten gelesen werden.
• Wir entsperren den Mutex, sobald wir das Current-Feld aktualisiert oder den IsHealthy-Feldwert gelesen haben, um den kritischen Abschnitt so klein wie möglich zu halten. Auf diese Weise verwenden wir Mutex, um jegliche Race-Bedingung zu vermeiden.

Schritt 3: Konfigurieren des Load Balancers

Unsere Konfiguration wird in einer config.json-Datei gespeichert, die die Server-URLs und Integritätsprüfungsintervalle enthält (mehr dazu im folgenden Abschnitt).

type Config struct {
    Port                string   `json:"port"`
    HealthCheckInterval string   `json:"healthCheckInterval"`
    Servers             []string `json:"servers"`
}

Die Konfigurationsdatei könnte so aussehen:

{
  "port": ":8080",
  "healthCheckInterval": "2s",
  "servers": [
    "http://localhost:5001",
    "http://localhost:5002",
    "http://localhost:5003",
    "http://localhost:5004",
    "http://localhost:5005"
  ]
}

Step 4: Health Checks

We want to make sure that the servers are healthy before routing any incoming traffic to them. This is done by sending periodic health checks to each server:

func healthCheck(s *Server, healthCheckInterval time.Duration) {
    for range time.Tick(healthCheckInterval) {
        res, err := http.Head(s.URL.String())
        s.Mutex.Lock()
        if err != nil || res.StatusCode != http.StatusOK {
            fmt.Printf("%s is down\n", s.URL)
            s.IsHealthy = false
        } else {
            s.IsHealthy = true
        }
        s.Mutex.Unlock()
    }
}

Every few seconds (as specified in the config), the load balancer sends a HEAD request to each server to check if it is healthy. If a server is down, the IsHealthy flag is set to false, preventing future traffic from being routed to it.

Step 5: Reverse Proxy

When the load balancer receives a request, it forwards the request to the next available server using a reverse proxy. In Golang, the httputil package provides a built-in way to handle reverse proxying, and we will use it in our code through the ReverseProxy function:

func (s *Server) ReverseProxy() *httputil.ReverseProxy {
    return httputil.NewSingleHostReverseProxy(s.URL)
}

What is a Reverse Proxy?

A reverse proxy is a server that sits between a client and one or more backend severs. It receives the client's request, forwards it to one of the backend servers, and then returns the server's response to the client. The client interacts with the proxy, unaware of which specific backend server is handling the request.

In our case, the load balancer acts as a reverse proxy, sitting in front of multiple servers and distributing incoming HTTP requests across them.

Step 6: Handling Requests

When a client makes a request to the load balancer, it selects the next available healthy server using the round robin algorithm implementation in getNextServer function and proxies the client request to that server. If no healthy server is available then we send service unavailable error to the client.

http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        server := lb.getNextServer(servers)
        if server == nil {
            http.Error(w, "No healthy server available", http.StatusServiceUnavailable)
            return
        }
        w.Header().Add("X-Forwarded-Server", server.URL.String())
        server.ReverseProxy().ServeHTTP(w, r)
    })

The ReverseProxy method proxies the request to the actual server, and we also add a custom header X-Forwarded-Server for debugging purposes (though in production, we should avoid exposing internal server details like this).

Step 7: Starting the Load Balancer

Finally, we start the load balancer on the specified port:

log.Println("Starting load balancer on port", config.Port)
err = http.ListenAndServe(config.Port, nil)
if err != nil {
        log.Fatalf("Error starting load balancer: %s\n", err.Error())
}

Working Demo

TL;DR

In this post, we built a basic load balancer from scratch in Golang using a round robin algorithm. This is a simple yet effective way to distribute traffic across multiple servers and ensure that your system can handle higher loads efficiently.

There's a lot more to explore, such as adding sophisticated health checks, implementing different load balancing algorithms, or improving fault tolerance. But this basic example can be a solid foundation to build upon.

You can find the source code in this GitHub repo.

Das obige ist der detaillierte Inhalt vonErstellen eines einfachen Load Balancers in Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!