在多寫（多節點寫入）資料庫（例如MySQL MGR的multi-primary mode）與應用之間，往往會加一層代理元件，通過演算法調節不同節點負載，分發高併發讀寫請求。

要求代理工具具有請求轉發、負載均衡、故障轉移的功能。

在後端節點故障發生或連線因為客戶端異常、網路問題斷開時，需要及時將故障節點及時踢出負載均衡佇列或者關閉異常連線，做到故障轉移。

這就是接下來介紹的主要內容，使用golang簡單編寫一個這樣的工具，來深入學習一下負載均衡代理的實現。

## 功能一覽

### 負載均衡

將應用端的連線請求（負載）按照既定的均衡演算法轉發到不同的後端節點，服務程式建立應用（客戶端）與資料庫節點之間的通訊並保持至客戶端斷開連線。

### 故障轉移

在後端節點出現故障時，能及時檢測到故障，並將故障節點踢出負載均衡佇列，不再將應用請求路由到故障節點，做到應用無感知。在故障恢復後，能夠檢測到節點狀態恢復，將其再次加入到負載均衡佇列。

## 實現細節
### 核心功能
·請求轉發

代理需要做到將請求分發到不同的後端節點上，並保持應用與對應節點的通訊，直至其中一端退出（故障或者主動）。

·負載均衡

對應用的負載，均衡的分發不同的節點，需要對應的演算法支援。目前通用的負載均衡演算法有隨機、輪詢、加權輪詢，程式碼實現了這三種演算法。

此外還有動態判斷後端節點負載情況，根據負載情況動態調整負載分發，這需要額外的負載監控工作，這裡沒有實現。

·故障檢測

負載均衡代理需要避免向失效的節點分發請求。故障型別無疑是很多的，如果面面俱到照顧到每個故障型別，無疑增加了實現難度。

例如在分散式中，不可靠的網路增加了檢測故障難度，對於資料庫例項，在分散式中很難判斷節點到底是crash了還是網路中斷導致的。

並且節點因為負載較高無法及時響應請求，這時也很難判斷節點狀態，此時進行重試可能會加劇節點的負載。

此處並非要模糊這種判斷，而是實際情況較為複雜，因此考慮了幾種確定性較高或容易判斷的情況。

### 實現過程

其中， 轉發實現過程是在接收到請求後，定義一個後端節點的地址，並建立一個和這個地址的連線。

在開啟兩個協程，一個負責將應用（客戶端）傳送的資料包傳遞給後端的連線，另一個是將後端返回的資料傳遞給應用，這樣就在應用與後端節點之間搭建起了通訊，使之像直接通訊一樣交換資料，核心的步驟可以參考下面程式碼的實現。

```c
sConn, err := l.Accept()
dTcpAddr, _ := net.ResolveTCPAddr("tcp4", addr)
dConn, err := net.DialTCP("tcp", nil, dTcpAddr)
go io.Copy(sConn, dConn)
go io.Copy(dConn, sConn)
```

在出現連線完成既定通訊後斷開連線，或者連線因為故障退出，需要代理將客戶端的請求連線與轉發向後端的連線一同關閉。

這裡使用的方式是獲取連線傳輸資料時的狀態來判斷，即io.Copy(sConn, dConn)在出現錯誤時，連線就可以關閉了。這裡藉助channel的阻塞特性來向主執行緒通知退出。

```c
go io.Copy(sConn, dConn)
go io.Copy(dConn, sConn)
```

程式碼進行修改後如下：

```c
       // channel長度為1，任意時刻只寫入一個bool值，在其中的值未被讀取之前，處於阻塞狀態
 exitCH := make(chan bool, 1)
        // 把客戶端的的請求轉發給後端
 go func(s net.Conn, d *net.TCPConn, ex chan bool) {
  _, err := io.Copy(sConn, dConn)
  if err != nil {
   Error.Println("Send data failure: ", err)
  }
  exitCH = l {
  r.CurIndex = 0
 }
 currAddr := r.Nodes[r.CurIndex]
 r.CurIndex = (r.CurIndex + 1) % l
 return currAddr
}
```

加權輪詢演算法實現上相對複雜一些，為每個後端節點增加權重屬性，包含三個權重屬性：權重（Weight）、臨時權重（CurWeight）、有效權重（EffectWeight）。

其中CurWeight、EffectWeight初始值為0，Weight值則讀取配置檔案設定來初始化。CurWeight每輪都會變化，EffectWeight預設與Weight相同。

### 實現邏輯

1、currentWeight = currentWeight + effecitveWeight
2、選中最大的 currentWeight 節點為選中節點
3、currentWeight = currentWeight - totalWeight

```c
type WeightRoundRobin struct {
 Nodes []*node.Node
}

func (r *WeightRoundRobin) Next() *node.Node {
 var n *node.Node
 total := 0
 for i := 0; i < len(r.Nodes); i++ {
  w := r.Nodes[i]
  total += w.EffectWeight
  w.CurWeight += w.EffectWeight
  if w.EffectWeight < w.Weight {
   w.EffectWeight++
  }
  if n == nil || w.CurWeight > n.CurWeight {
   n = w
  }
 }
 if n == nil {
  return nil
 }
 n.CurWeight -= total
 return n
}
```

故障檢測 是保證負載均衡佇列中的節點是可以正常訪問並且提供可靠服務的前提，在檢測到後端節點存在故障後，需要及時的從佇列中剔除，並關閉與之對應的連線。

檢測在實際實現上使用了兩種基本方法。一種是基本的連通性檢測，一種是利用MGR或者GreatDB提供的內部檢視來判斷節點是否可寫。

這種在MGR中從當前節點查詢本節點狀態可能並不準確例如：發生網路分割槽，從當前節點檢視狀態為ONLINE，但從其他節點檢視，則當前可能為ERROR狀態，程式碼並未考慮這個情況。

後續可增加對一個節點可寫狀態判斷需要與其他節點的狀態查詢綜合考慮。

連通性檢測：

```c
_, err := net.DialTimeout("tcp", addr, time.Duration(dialtimeout)*time.Millisecond)
```

這裡藉助命令列工具實現可寫檢測，沒有使用開源的連線驅動，主要是考慮程式碼的簡潔。

可寫檢測：

```c
var CMD = "mysql"
func State(detectSql string, user string, pass string, port string, host string, cluster string) (bool, error) {
 ok, _ := CommandOk(CMD)
 if ok {
  sqlComLine := CMD + " -u" + user + " -p" + pass + " -h" + host + " -P" + port + " -NBe '"
  if cluster == "greatdb" {
   sqlComLine += detectSql + " WHERE HOST=" + "\"" + host + "\"" + "'"
  } else if cluster == "mgr" {
   sqlComLine += detectSql + " WHERE MEMBER_HOST=" + "\"" + host + "\"" + "'"
  }
  cmd := exec.Command("bash", "-c", sqlComLine)
  out, err := cmd.CombinedOutput()
  rest := strings.Replace(string(out), "\n", "", -1)
  if err == nil {
   if rest == "ONLINE" {
    return true, nil
   } else {
    return false, errors.New("instance is exists but cannot write")
   }
  }
  return false, err
 } else {
  return false, errors.New("cannot detect instance state")
 }
}

func CommandOk(c string) (bool, error) {
 command := "which " + c
 cmd := exec.Command("bash", "-c", command)
 out, err := cmd.CombinedOutput()
 if err == nil {
  context := strings.Fields(strings.Replace(string(out), "\n", "", -1))
  if len(context) > 2 {
   if context[1] == "no" {
    return false, nil
   }
  }
  return true, nil
 }
 return false, err
}
```

在檢測到後端節點連通性有問題或者節點狀態為不可寫，需要將節點踢出負載均衡佇列，這裡通過加鎖來防止併發操作佇列引入新的程式碼錯誤。

然後通過channel通知主執行緒負載均衡佇列發生了變化，需要更新。其次是通知主執行緒需要將各個協程在處理的與故障節點有關的連線，需要關閉。

```c
func DelNode(n *node.Node) {
 for i := 0; i < len(nodeList); i++ {
  if nodeList[i].Ip == n.Ip && nodeList[i].Port == n.Port {
   mu.Lock()
   nodeList = append(nodeList[:i], nodeList[i+1:]...)
   listChange

技術｜如何為MySQL MGR實現簡單的負載均衡代理？

相關文章