负载均衡器在 Web 架构中扮演着非常重要的角色,被用于为多个后端分发流量负载,提升服务的伸缩性。负载均衡器后面配置了多个服务,在某个服务发生故障时,负载均衡器可以很快地选择另一个可用的服务,所以整体的服务可用性得到了提升。
自研负载均衡器的工作原理
负载均衡器在向后端服务分发流量负载时可以使用几种策略。
- 轮询(Round Robin)——均匀地分发流量负载,假设所有后端服务都具有同样的处理能力;
- 加权轮询(Weighted Round Robin)——根据后端服务的处理能力加权;
- 最少连接(Least Connections)——优先把流量负载分发给连接最少的后端。
我打算实现最简单的策略,即轮询。
一、轮询选择
轮询的原理非常简单,后端服务有平等的机会处理任务。
如上图所示,轮询过程是循环不断的,但我们不能直接使用这种方式。
如果其中的一个后端发生故障该怎么办?我们当然不希望把流量定向给它。我们只能把流量路由给正常运行的服务。
二、定义结构体
我们需要知道所有后端服务器的状态,比如一个服务是死了还是活着,还要跟踪它们的 url。
我们可以定义一个结构体来保存后端的信息。
type Backend struct {
URL *url.URL
Alive bool
mux sync.RWMutex
ReverseProxy *httputil.ReverseProxy
}
我们还需要一种方式来跟踪所有后端,以及一个计算器变量。
type ServerPool struct {
backends []*Backend
current uint64
}
三、使用 ReverseProxy
之前说过,负载均衡器的作用是将流量负载分发到后端的服务器上,并将结果返回给客户端。
根据 Go 语言文档的描述:
这刚好是我们想要的,所以我们没有必要重复发明轮子。我们可以直接使用 ReverseProxy 来中继初始请求。
u, _ := url.Parse("http://localhost:8080")
rp := httputil.NewSingleHostReverseProxy(u)
// 初始化服务器,并添加处理器
http.HandlerFunc(rp.ServeHTTP)
我们使用 httputil.NewSingleHostReverseProxy(url) 初始化一个反向代理,这个反向代理可以将请求中继到指定的 url。在上面的例子中,所有的请求都会被中继到 localhost:8080,结果被发送给初始客户端。
如果看一下 ServeHTTP 方法的签名,我们会发现它返回的是一个 HTTP 处理器,所以我们可以将它传给 http 的 HandlerFunc。
在我们的例子中,可以使用 Backend 里的 URL 来初始化 ReverseProxy,这样反向代理就会把请求路由给指定的 URL。
四、选择的过程
在选择下一个服务器时,我们需要跳过已经死掉的服务器,但不管怎样,我们都需要一个计数器。
因为有很多客户端连接到负载均衡器,所以发生竟态条件是不可避免的。为了防止这种情况,我们需要使用 mutex 给 ServerPool 加锁。但这样做对性能会有影响,更何况我们并不是真想要给 ServerPool 加锁,我们只是想要更新计数器。
最理想的解决方案是使用原子操作,Go 语言的 atomic 包为此提供了很好的支持。
func (s *ServerPool) NextIndex() int {
return int(atomic.AddUint64(&s.current, uint64(1)) % uint64(len(s.backends)))
}
我们通过原子操作递增 current 的值,并通过对 slice 的长度取模来获得当前索引值。所以,返回值总是介于 0 和 slice 的长度之间,毕竟我们想要的是索引值,而不是总的计数值。
五、选择可用的后端
我们需要循环将请求路由到后端的每一台服务器上,但要跳过已经死掉的服务。
GetNext() 方法总是返回一个介于 0 和 slice 长度之间的值,如果这个值对应的服务器不可用,我们需要遍历一遍 slice。
遍历一遍 slice
如上图所示,我们将从 next 位置开始遍历整个列表,但在选择索引时,需要保证它处在 slice 的长度之内,这个可以通过取模运算来保证。
在找到可用的服务器后,我们将它标记为当前可用服务器。
上述操作对应的代码如下。
// GetNextPeer 返回下一个可用的服务器
func (s *ServerPool) GetNextPeer() *Backend {
// 遍历后端列表,找到可用的服务器
next := s.NextIndex()
l := len(s.backends) + next // 从 next 开始遍历
for i := next; i < l; i++ {
idx := i % len(s.backends) // 通过取模计算获得索引
// 如果找到一个可用的服务器,将它作为当前服务器。如果不是初始的那个,就把它保存下来
if s.backends[idx].IsAlive() {
if i != next {
atomic.StoreUint64(&s.current, uint64(idx)) // 标记当前可用服务器
}
return s.backends[idx]
}
}
return nil
}
六、避免竟态条件
我们还需要考虑到一些情况,比如不同的 goroutine 会同时访问 Backend 结构体里的一个变量。
我们知道,读取这个变量的 goroutine 比修改这个变量的要多,所以我们使用 RWMutex 来串行化对 Alive 的访问操作。
// SetAlive
func (b *Backend) SetAlive(alive bool) {
b.mux.Lock()
b.Alive = alive
b.mux.Unlock()
}
// 如果后端还活着,IsAlive 返回 true
func (b *Backend) IsAlive() (alive bool) {
b.mux.RLock()
alive = b.Alive
b.mux.RUnlock()
return
}
七、对请求进行负载均衡
在有了上述的这些东西之后,接下来就可以用下面这个简单的办法来对请求进行负载均衡。只有当所有的后端服务都死掉它才会退出。
// lb 对入向请求进行负载均衡
func lb(w http.ResponseWriter, r *http.Request) {
peer := serverPool.GetNextPeer()
if peer != nil {
peer.ReverseProxy.ServeHTTP(w, r)
return
}
http.Error(w, "Service not available", http.StatusServiceUnavailable)
}
这个方法可以作为 HandlerFunc 传给 http 服务器。
server := http.Server{
Addr: fmt.Sprintf(":%d", port),
Handler: http.HandlerFunc(lb),
}
八、只将流量路由给活跃的服务器
现在的 lb 方法存在一个严重的问题,我们并不知道后端服务是否处于正常的运行状态。为此,我们需要尝试发送请求,检查一下它是否正常。
我们可以通过两种方法来达到目的:
- 主动(Active):在处理当前请求时,如果发现当前的后端没有响应,就把它标记为已宕机。
- 被动(Passive):在固定的时间间隔内对后端服务器执行 ping 操作,以此来检查服务器的状态。
九、主动模式
在发生错误时,ReverseProxy 会触发 ErrorHandler 回调函数,我们可以利用它来检查故障。
1
proxy.ErrorHandler = func(writer http.ResponseWriter, request *http.Request, e error) {
log.Printf("[%s] %s\n", serverUrl.Host, e.Error())
retries := GetRetryFromContext(request)
if retries < 3 {
select {
case <-time.After(10 * time.Millisecond):
ctx := context.WithValue(request.Context(), Retry, retries+1)
proxy.ServeHTTP(writer, request.WithContext(ctx))
}
return
}
// 在三次重试之后,把这个后端标记为宕机
serverPool.MarkBackendStatus(serverUrl, false)
// 同一个请求在尝试了几个不同的后端之后,增加计数
attempts := GetAttemptsFromContext(request)
log.Printf("%s(%s) Attempting retry %d\n", request.RemoteAddr, request.URL.Path, attempts)
ctx := context.WithValue(request.Context(), Attempts, attempts+1)
lb(writer, request.WithContext(ctx))
}
我们使用强大的闭包来实现错误处理器,它可以捕获外部变量错误。它会检查重试次数,如果小于 3,就把同一个请求发送给同一个后端服务器。之所以要进行重试,是因为服务器可能会发生临时错误,在经过短暂的延迟(比如服务器没有足够的 socket 来接收请求)之后,服务器又可以继续处理请求。我们使用了一个计时器,把重试时间间隔设定在 10 毫秒左右。
在重试失败之后,我们就把这个后端标记为宕机。
接下来,我们要找出新的可用后端。我们使用 context 来维护重试次数。在增加重试次数后,我们把它传回 lb,选择一个新的后端来处理请求。
但我们不能不加以限制,所以我们会在进一步处理请求之前检查是否达到了最大的重试上限。
我们从请求里拿到重试次数,如果已经达到最大上限,就终结这个请求。
// lb 对传入的请求进行负载均衡
func lb(w http.ResponseWriter, r *http.Request) {
attempts := GetAttemptsFromContext(r)
if attempts > 3 {
log.Printf("%s(%s) Max attempts reached, terminating\n", r.RemoteAddr, r.URL.Path)
http.Error(w, "Service not available", http.StatusServiceUnavailable)
return
}
peer := serverPool.GetNextPeer()
if peer != nil {
peer.ReverseProxy.ServeHTTP(w, r)
return
}
http.Error(w, "Service not available", http.StatusServiceUnavailable)
}
十、context 的使用
我们可以利用 context 在 http 请求中保存有用的信息,用它来跟踪重试次数。
首先,我们需要为 context 指定键。我们建议使用不冲突的整数值作为键,而不是字符串。Go 语言提供了 iota 关键字,可以用来实现递增的常量,每一个常量都包含了唯一值。这是一种完美的整型键解决方案。
const (
Attempts int = iota
Retry
)
然后我们就可以像操作 HashMap 那样获取这个值。默认返回值要视情况而定。
// GetAttemptsFromContext 返回尝试次数
func GetRetryFromContext(r *http.Request) int {
if retry, ok := r.Context().Value(Retry).(int); ok {
return retry
}
return 0
}
十一、被动模式
被动模式就是定时对后端执行 ping 操作,以此来检查它们的状态。
我们通过建立 TCP 连接来执行 ping 操作。如果后端及时响应,我们就认为它还活着。当然,如果你喜欢,也可以改成直接调用某个端点,比如 /status。切记,在执行完操作后要关闭连接,避免给服务器造成额外的负担,否则服务器会一直维护连接,最后把资源耗尽。
// isAlive 通过建立 TCP 连接检查后端是否还活着
func isBackendAlive(u *url.URL) bool {
timeout := 2 * time.Second
conn, err := net.DialTimeout("tcp", u.Host, timeout)
if err != nil {
log.Println("Site unreachable, error: ", err)
return false
}
_ = conn.Close() // 不需要维护连接,把它关闭
return true
}
现在我们可以遍历服务器,并标记它们的状态。
// HealthCheck 对后端执行 ping 操作,并更新状态
func (s *ServerPool) HealthCheck() {
for _, b := range s.backends {
status := "up"
alive := isBackendAlive(b.URL)
b.SetAlive(alive)
if !alive {
status = "down"
}
log.Printf("%s [%s]\n", b.URL, status)
}
}
我们可以启动定时器来定时发起 ping 操作。
// healthCheck 返回一个 routine,每 2 分钟检查一次后端的状态
func healthCheck() {
t := time.NewTicker(time.Second * 20)
for {
select {
case <-t.C:
log.Println("Starting health check...")
serverPool.HealthCheck()
log.Println("Health check completed")
}
}
}
在上面的例子中,<-t.C 每 20 秒返回一个值,select 会检测到这个事件。在没有 default case 的情况下,select 会一直等待,直到有满足条件的 case 被执行。
最后,使用单独的 goroutine 来执行。
go healthCheck()
十二、测试
负载均衡代码
1 package main
2
3 import (
4 "context"
5 "flag"
6 "fmt"
7 "log"
8 "net"
9 "net/http"
10 "net/http/httputil"
11 "net/url"
12 "strings"
13 "sync"
14 "sync/atomic"
15 "time"
16 )
17
18 const (
19 Attempts int = iota
20 Retry
21 )
22
23 //定义结构体
24 //后端保存关于服务器的数据
25 type Backend struct {
26 URL *url.URL
27 Alive bool
28 mux sync.RWMutex
29 ReverseProxy *httputil.ReverseProxy
30 }
31
32 //跟踪所有后端,以及一个计算器变量
33 type ServerPool struct {
34 backends []*Backend
35 current uint64
36 }
37
38 // SetAlive
39 func (b *Backend) SetAlive(alive bool) {
40 b.mux.Lock()
41 b.Alive = alive
42 b.mux.Unlock()
43 }
44
45 // 如果后端还活着,IsAlive 返回 true
46 func (b *Backend) IsAlive() (alive bool) {
47 b.mux.RLock()
48 alive = b.Alive
49 b.mux.RUnlock()
50 return
51 }
52
53 // lb 对入向请求进行负载均衡
54 func lb(w http.ResponseWriter, r *http.Request) {
55 //重试次数,如果已经达到最大上限,就终结这个请求
56 attempts := GetAttemptsFromContext(r)
57 if attempts > 3 {
58 log.Printf("%s(%s) Max attempts reached, terminating\n", r.RemoteAddr, r.URL.Path)
59 http.Error(w, "Service not available", http.StatusServiceUnavailable)
60 return
61 }
62
63 peer := serverPool.GetNextPeer()
64 if peer != nil {
65 peer.ReverseProxy.ServeHTTP(w, r)
66 return
67 }
68 http.Error(w, "Service not available", http.StatusServiceUnavailable)
69 }
70
71 // 自动增加计数器并返回一个索引,使用atomic 保证原子性
72 //通过原子操作递增 current 的值,并通过对 slice 的长度取模来获得当前索引值。所以,返回值总是介于 0 和 slice 的长度之间,毕竟我们想要的是索引值,而不是总的计数值。
73 func (s *ServerPool) NextIndex() int {
74 return int(atomic.AddUint64(&s.current, uint64(1)) % uint64(len(s.backends)))
75 }
76
77 // GetNextPeer返回下一个活动的对等点以获取连接
78 //找到可用的服务器后,我们将它标记为当前可用服务器。
79 func (s *ServerPool) GetNextPeer() *Backend {
80 // 循环整个后端,找出一个活动后端
81 next := s.NextIndex()
82 l := len(s.backends) + next // 从next开始移动一个完整的周期
83 for i := next; i < l; i++ {
84 idx := i % len(s.backends) // take an index by modding
85 if s.backends[idx].IsAlive() { // if we have an alive backend, use it and store if its not the original one
86 if i != next {
87 atomic.StoreUint64(&s.current, uint64(idx))
88 }
89 return s.backends[idx]
90 }
91 }
92 return nil
93 }
94
95 // GetAttemptsFromContext 返回尝试次数
96 func GetRetryFromContext(r *http.Request) int {
97 if retry, ok := r.Context().Value(Retry).(int); ok {
98 return retry
99 }
100 return 0
101 }
102
103 // healthCheck runs a routine for check status of the backends every 2 mins
104 // healthCheck 返回一个 routine,每 2 分钟检查一次后端的状态
105 func healthCheck() {
106 t := time.NewTicker(time.Second * 20)
107 for {
108 select {
109 case <-t.C:
110 log.Println("Starting health check...")
111 serverPool.HealthCheck()
112 log.Println("Health check completed")
113 }
114 }
115 }
116
117 // HealthCheck ping后端并更新状态
118 func (s *ServerPool) HealthCheck() {
119 for _, b := range s.backends {
120 status := "up"
121 alive := isBackendAlive(b.URL)
122 b.SetAlive(alive)
123 if !alive {
124 status = "down"
125 }
126 log.Printf("%s [%s]\n", b.URL, status)
127 }
128 }
129
130 // isAlive checks whether a backend is Alive by establishing a TCP connection
131 // isAlive 通过建立 TCP 连接检查后端是否还活着
132 func isBackendAlive(u *url.URL) bool {
133 timeout := 2 * time.Second
134 conn, err := net.DialTimeout("tcp", u.Host, timeout)
135 if err != nil {
136 log.Println("Site unreachable, error: ", err)
137 return false
138 }
139 _ = conn.Close() // 不需要维护连接,把它关闭
140 return true
141 }
142
143 // GetAttemptsFromContext returns the attempts for request
144 func GetAttemptsFromContext(r *http.Request) int {
145 if attempts, ok := r.Context().Value(Attempts).(int); ok {
146 return attempts
147 }
148 return 1
149 }
150
151 // AddBackend to the server pool
152 func (s *ServerPool) AddBackend(backend *Backend) {
153 s.backends = append(s.backends, backend)
154 }
155
156 // MarkBackendStatus changes a status of a backend
157 func (s *ServerPool) MarkBackendStatus(backendURL *url.URL, alive bool) {
158 for _, b := range s.backends {
159 if b.URL.String() == backendURL.String() {
160 b.SetAlive(alive)
161 break
162 }
163 }
164 }
165
166 var serverPool ServerPool
167
168 func main() {
169 var serverList string
170 var port int
171 flag.StringVar(&serverList, "backends", "http://localhost:3302,http://localhost:3303,http://localhost:3304", "Load balanced backends, use commas to separate")
172 flag.IntVar(&port, "port", 3031, "Port to serve")
173 flag.Parse()
174
175 if len(serverList) == 0 {
176 log.Fatal("Please provide one or more backends to load balance")
177 }
178
179 // 解析服务器
180 tokens := strings.Split(serverList, ",")
181 //range类似迭代器,可以遍历
182 for _, tok := range tokens {
183 serverURL, err := url.Parse(tok)
184 if err != nil {
185 log.Fatal(err)
186 }
187
188 //使用 httputil.NewSingleHostReverseProxy(url) 初始化一个反向代理
189 proxy := httputil.NewSingleHostReverseProxy(serverURL)
190
191 //在发生错误时,ReverseProxy 会触发 ErrorHandler 回调函数,我们可以利用它来检查故障。
192 proxy.ErrorHandler = func(writer http.ResponseWriter, request *http.Request, e error) {
193 log.Printf("[%s] %s\n", serverURL.Host, e.Error())
194 retries := GetRetryFromContext(request)
195 if retries < 3 {
196 select {
197 case <-time.After(10 * time.Millisecond):
198 ctx := context.WithValue(request.Context(), Retry, retries+1)
199 proxy.ServeHTTP(writer, request.WithContext(ctx))
200 }
201 return
202 }
203
204 // 在三次重试之后,把这个后端标记为宕机
205 serverPool.MarkBackendStatus(serverURL, false)
206
207 // 同一个请求在尝试了几个不同的后端之后,增加计数
208 attempts := GetAttemptsFromContext(request)
209 log.Printf("%s(%s) Attempting retry %d\n", request.RemoteAddr, request.URL.Path, attempts)
210 ctx := context.WithValue(request.Context(), Attempts, attempts+1)
211 lb(writer, request.WithContext(ctx))
212 }
213
214 serverPool.AddBackend(&Backend{
215 URL: serverURL,
216 Alive: true,
217 ReverseProxy: proxy,
218 })
219 log.Printf("Configured server: %s\n", serverURL)
220
221 }
222 // 初始化服务器,并添加处理器
223 // create http server
224 server := http.Server{
225 Addr: fmt.Sprintf(":%d", port),
226 Handler: http.HandlerFunc(lb),
227 }
228
229 // start health checking
230 go healthCheck()
231
232 log.Printf("Load Balancer started at :%d\n", port)
233 if err := server.ListenAndServe(); err != nil {
234 log.Fatal(err)
235 }
236 }
View Code
直接运行就好了
web服务器代码
package main
import (
"flag"
"fmt"
"log"
"net/http"
"strconv"
)
func sayhelloName(w http.ResponseWriter, r *http.Request) {
r.ParseForm() //解析参数,默认是不会解析的
fmt.Fprintln(w, "Hello moon!") //这个写入到w的是输出到客户端的
fmt.Fprintln(w, "count:"+strconv.Itoa(port)) //这个写入到w的是输出到客户端的
count++
fmt.Fprintln(w, "count:"+strconv.Itoa(count)) //这个写入到w的是输出到客户端的
}
var port int
var count int
func main() {
flag.IntVar(&port, "port", 3302, "duan端口号,默认3302")
// 【必须调用】从 arguments 中解析注册的 flag
flag.Parse()
fmt.Printf("port=%v \n", port)
http.HandleFunc("/", sayhelloName) //设置访问的路由
err := http.ListenAndServe(":"+strconv.Itoa(port), nil) //设置监听的端口
if err != nil {
log.Fatal("ListenAndServe: ", err)
}
}
View Code
使用方法
go run web.go -port=3302
go run web.go -port=3303
go run web.go -port=3304
这里web.go是代码文件名
测试
访问http://localhost:3031/并刷新
十三、结论
这篇文章提到了很多东西:
- 轮询;
- Go 语言标准库里的 ReverseProxy;
- mutex;
- 原子操作;
- 闭包;
- 回调;
- select。
这个简单的负载均衡器还有很多可以改进的地方:
- 使用堆来维护后端的状态,以此来降低搜索成本;
- 收集统计信息;
- 实现加权轮询或最少连接策略;
- 支持文件配置。