How to build a RESTful API and implement load balancing using Golang?

Summary: Building a RESTful API: Create a Golang project, use the http package and define route processing functions. Implement load balancing: Use the fasthttp package to build proxy middleware to forward requests to multiple backend servers. Practical combat: Start the backend server, use fasthttp to proxy requests, and observe the load balancing results.

Use Golang to build RESTful API and implement load balancing

Prerequisites

• Install Golang
• Familiar with the HTTP protocol
• Understand the principles of RESTful API

Create API project

Create a new Golang project and add the HTTP package:

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))
}

Build API Router

Use http.NewServeMux() to create the HTTP router, and use HandleFunc() to define the handler function. These handlers will handle specific HTTP paths and methods.

Achieve load balancing

In order to achieve load balancing, we need to use middleware or reverse proxy server. The fasthttp package is used below as middleware.

First, install fasthttp:

go get -u github.com/valyala/fasthttp

Then, import fasthttp and use fasthttp.Director() to define the proxy function ：

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))
}

Practical case

For demonstration, you can start multiple backend servers (for example, on different ports) and use fasthttp to proxy requests to these servers.

Backend server 1

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")
    })))
}

Backend server 2

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")
    })))
}

Test load balancing

Then , start the API server with the following command:

go run main.go

Finally, send an HTTP request to the API server, which will load balance to the backend servers:

curl http://localhost:8080

The output will alternately display "Backend Server 1" and "Backend Server 2" indicates that load balancing is working.

The above is the detailed content of How to build a RESTful API and implement load balancing using Golang?. For more information, please follow other related articles on the PHP Chinese website!