Wie erstellt man eine RESTful-API und implementiert den Lastausgleich mit Golang?

Zusammenfassung: Erstellen einer RESTful-API: Erstellen Sie ein Golang-Projekt, verwenden Sie das http-Paket und definieren Sie Routenverarbeitungsfunktionen. Implementieren Sie den Lastausgleich: Verwenden Sie das Fasthttp-Paket, um Proxy-Middleware zu erstellen, um Anforderungen an mehrere Backend-Server weiterzuleiten. Praktischer Kampf: Starten Sie den Backend-Server, verwenden Sie die Fasthttp-Proxy-Anfrage und beobachten Sie die Ergebnisse des Lastausgleichs.

Verwenden Sie Golang, um eine RESTful-API zu erstellen und den Lastausgleich zu implementieren.

Voraussetzungen

Erstellen Sie ein neues Golang-Projekt , und fügen Sie das HTTP-Paket hinzu:

• package main
  
  import (
      "fmt"
      "log"
      "net/http"
  )
  
  func main() {
      // 创建 HTTP 路由器
      mux := http.NewServeMux()
  
      // 定义路由处理函数
      mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
          fmt.Fprintln(w, "Hello, World!")
      })
  
      //启动 HTTP 服务器
      log.Fatal(http.ListenAndServe(":8080", mux))
  }

Erstellen Sie den API-Router
Verwenden Sie http.NewServeMux(), um den HTTP-Router zu erstellen, und verwenden Sie HandleFunc(), um ihn zu definieren Verarbeitungsfunktion. Diese Handler verarbeiten bestimmte HTTP-Pfade und -Methoden.
Lastausgleich erreichen

Um einen Lastausgleich zu erreichen, müssen wir Middleware oder einen Reverse-Proxy-Server verwenden. Als Middleware wird im Folgenden das Paket fasthttp verwendet.

Installieren Sie zunächst fasthttp:

go get -u github.com/valyala/fasthttp

Dann importieren Sie fasthttp und verwenden Sie fasthttp.Director(), um die Proxy-Funktion zu definieren:

package main

import (
    "fmt"
    "log"
    "net/http"

    "github.com/valyala/fasthttp"
)

func main() {
    // 创建 fasthttp 代理中间件
    director := fasthttp.Director{
        // 定义要代理到后端服务器的地址
        Addrs: []string{"localhost:8081"},
    }

    // 创建 HTTP 路由器
    mux := http.NewServeMux()

    // 将代理中间件作为全局处理器添加到路由器
    mux.Use(func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            director.ServeHTTP(w, r)
            return
        })
    })

    // 定义路由处理函数，处理 HTTP 请求后
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Hello, World!")
    })

    // 启动 HTTP 服务器
    log.Fatal(http.ListenAndServe(":8080", mux))
}

Übungsfall http.NewServeMux() 创建 HTTP 路由器，并使用 HandleFunc() 定义处理函数。这些处理函数将处理特定的 HTTP 路径和方法。

实现负载均衡

为了实现负载均衡，我们需要使用中间件或反向代理服务器。下面使用 fasthttp 包作为中间件。

首先，安装 fasthttp：

package main

import (
    "fmt"
    "log"
    "net/http"
)

func main() {
    // 在端口 8081 上启动一个 HTTP 服务器
    log.Fatal(http.ListenAndServe(":8081", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Backend Server 1")
    })))
}

然后，导入 fasthttp 并使用 fasthttp.Director()

Zur Demonstration können Sie mehrere Backend-Server starten (z. B. auf verschiedenen Ports) und fasthttp verwenden, um Anfragen an diese Server zu weiterleiten. „Backend-Server 1“ Lastausgleich Zum Backend-Server:

package main

import (
    "fmt"
    "log"
    "net/http"
)

func main() {
    // 在端口 8082 上启动另一个 HTTP 服务器
    log.Fatal(http.ListenAndServe(":8082", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Backend Server 2")
    })))
}

In der Ausgabe wird abwechselnd „Backend-Server 1“ und „Backend-Server 2“ angezeigt, was darauf hinweist, dass der Lastausgleich funktioniert.

Das obige ist der detaillierte Inhalt vonWie erstellt man eine RESTful-API und implementiert den Lastausgleich mit Golang?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!