go设置后端启动_使用加权轮询算法和 Go 实现 HTTP 负载分发代理-CSDN博客

摘要：最近看到了一篇文章，细讲了各种分布式调度原理，其中加权轮询算法(Weighted Round-Robin)应该是离我们最近的一种方式了，Nginx 的 Upstream 就是用的这个算法，这个算法可以根据权重使得每个服务器能够均匀的负载请求，本篇主要就是来总结下使用这个算法以及 Go 内置的方法来实现一个简单的加权轮询的 HTTP 负载分发代理，并对负载分发及路由做一些延伸思考。

本篇主要从以下两个方面进行展开：

使用 Go 实现一个反向代理
使用 WRR 算法实现此反向代理的加权轮询

什么是代理

代理一般情况下我们是分为正向代理和反向代理两种形式

正向代理一般是配置在客户端，客户端需要知道代理的地址并自行配置

反向代理一般情况下对客户端是透明的，主要是配置在服务器上，大部分我们访问的 Web 应用都是通过反向代理进行配置的，这块主要是 Nginx 和 Apache 提供的功能，比如 Nginx：

location / {

还有一个简单区分的方式，我们可以看这个代理的作用，如果已知转发的后端，那这个应该是反向代理，如果被转发到哪里去是一个不确定性因素，那这应该是一个正向代理，这是我的个人理解，欢迎读者批评指正 :)

Go ReverseProxy

Go 提供了一个 httputil.ReverseProxy 代理框架，能够让我们快速的实现一个反向代理而无需关注其他细节。

打开reverseproxy.go源码可以看到对 ReverseProxy 的简介

// ReverseProxy is an HTTP Handler that takes an incoming request and

ReverseProxy 是一个用来转发请求的服务，并把相关的响应原封不动的返回给客户端，这个过程中 ReverseProxy 会自动给X-Forwarded-For添加或者追加客户端 IP

继续往下看

type ReverseProxy

ReverseProxy 是一个结构体，其中最重要的是 Director，我们需要实现一个 Director 函数，这个函数主要就是让我们可以定义对request的修改，比如修改协议、回源地址、路径等信息，然后传递给http.RoundTripper进行转发，RoundTripper 主要的功能就是返回响应给一个给定的请求，具体可以查看client.go源码，这里不再发散

一个简单的反向代理服务

下面是使用 ReverseProxy 实现的一个简单的反向代理服务：

package main

我们启动此服务，并且使用我自己写的一个testServer.go进行测试

// generate 3 server to handle request for test

使用命令访问curl 127.0.0.1:7788，可以看到已经将请求转发到后端127.0.0.1:7791了

以上，我们就已经实现了一个反向代理，用来对请求进行代理，但这并不是我们想要的，我们想要的是分发，所以我们继续改造此脚本，使它能够配置多个后端进行轮询

支持多个后端轮询的反向代理服务

参照源码中NewSingleHostReverseProxy函数自定义即可

package main

结果如下图

一共访问40次，分布均匀性一般般，所以接下来就是改造为加权轮询算法进行后端服务器的选择

加权轮询算法(Weighted Round-Robin)

加权轮询算法的实现可以参见 Nginx 的一次代码提交 Upstream: smooth weighted round-robin balancing.

简单来说，Nginx 的这个加权轮询算法不仅仅可以实现按照权重进行分发负载，也实现了平滑性，什么叫平滑呢，就是说你设置了这么一组带权重的后端

{HostA: "127.0.0.1:7791", Weight: 3},

比如这时来了5次访问，那么它的分发如果是AAABC，我们就不能说这个是「平滑」的，因为可能会给第一台机器造成压力过大，虽然我们认为它的性能比较好，但是还是会造成同一时间压力过大的问题。而 WRR 算法就可以实现平滑的分发，使分发变成ABACA，避免同一时间造成压力过大的问题，来看看这个算法如何实现的：

For edge

简单来说就是：

每一轮选择都用自身的权重加到当前权重
当前选中的节点的当前权重需要减去总权重

先来看看算法用 Go 的实现

package main

执行结果:

server: zoker.server.

可以看到，是比较分散的，也就是我们称之为的「平滑」

实现基于 WRR 的反向代理

了解了加权轮询算法之后，我们来改造上面的分发代理，上面是直接取随机数然后取余来达到随机的效果的，我们来改造 generateReverseProxy()使它能够具备加权分发的能力

package main

import (
"fmt"
"net/http"
"net/http/httputil"
"net/url"
)

type Nodes struct {
    node          url.URL
    weight        int
    currentWeight int
}

// config backends and weight
var nodes = []*Nodes{
    {url.URL{Host: "127.0.0.1:7791", Scheme: "http"}, 5, 0},
    {url.URL{Host: "127.0.0.1:7792", Scheme: "http"}, 1, 0},
    {url.URL{Host: "127.0.0.1:7793", Scheme: "http"}, 1, 0},
}

// using wrr to select nodes
func getBestNode() (bestNode *Nodes) {
    allWeight := 0
for _, node := range nodes {
        allWeight += node.weight
        node.currentWeight += node.weight

if bestNode == nil || node.currentWeight > bestNode.currentWeight {
            bestNode = node
        }
    }

    bestNode.currentWeight -= allWeight
    fmt.Printf("Select %s %d %d \n", bestNode.node.Host, bestNode.weight, bestNode.currentWeight)
return bestNode
}

func generateReverseProxy() *httputil.ReverseProxy {
// generate director
    director := func(req *http.Request) {
        backend := getBestNode().node
        req.URL.Scheme = backend.Scheme
        req.URL.Host = backend.Host
//fmt.Printf("Scheme: %s Host: %s Path: %s\n", req.Scheme, req.Host, req.RequestURI)
    }
return &httputil.ReverseProxy{Director: director}
}

func main() {
// generate a reverse proxy
    reverseProxy := generateReverseProxy()
    fmt.Println("Server started on port 7788...")
if err := http.ListenAndServe("127.0.0.1:7788", reverseProxy); err != nil {
        fmt.Printf("Server failed to start, error: %s \n", err.Error())
    }
}