统一实现rpc,grpc,tcp,http等协议简单的负载均衡
**
统一实现rpc,grpc,tcp,http等协议简单的负载均衡
**
利用:zookeeper或者etcd来实现.(zookeeper的源码为java,etcd的源码为go)
本文选用zookeeper来实现服务之间的调用负(有机会再发etcd的,不过都很简单,过程都是差不多的)。（部署自行google 不管是哪个系统都容易的很）
实现思路:
程序之所以能调用肯定是分为了serve以及client,那么就得先从这两个方面下手.serve:
serve注册时，需要将 serveName，以及对应的servePath:port creat到zookeeper的node，node方式为 /goods/域名:port（每一个服务都需要注册）
当serve挂掉时，zookeeper会自动检测serve port是否存在，如果不存在则消除 node 对应的 path。
默认几秒检测忘了，我测试了下三秒以内是肯定会检测出来的，不过这样就会有一个弊端，如果serve调用频繁，这个serve跨掉的三秒内调用了很多次,咋办？这个时候肯定就不能凉拌了,而是可以通过我们的当前serve进行一个实时跟新，zookeeper既然有creat，那必然也有delete，我们可以监控当前程序，写一个监控，监控当前程序是什么状态，当前程序如果要退出之前，我们会进行一个zookeeper node path 的释放,这样就能实时的跟新zookeeper 存储的 path
client:
例如http类型的调用时，就很简单,直接通过zookeeper获取 node path就行，自己写一个随机或负载的机制，进行调用。
如是长链接tcp等，如上 获取到当前的 path ，用自己的机制进行轮换，不同点是，需要监控zookeeper，如果zookeeper的节点path有变动，则需要作出对应的变化。
这种方式能够实现的负载肯定是很多的，我目前用到的协议连接都是支持的。
简易度：中等吧，如果是http很多人直接走个nginx，或者阿里云的负载就行了，甚至还有更简单的方式。而比较流行的就是 docker+k8s负载了 其他的没去了解，个人觉得zookeeper操作起来，是易于上手的。
提供一段go zookeeper http负载源码:
分为三个模块
一 : common（公用）
package common
import (
"fmt"
"github.com/go-zookeeper/zk"
"time"
)
func GetConnect() (conn *zk.Conn, err error) {
hosts := []string{"localhost:2181"}
conn, _, err = zk.Connect(hosts, 5*time.Second)
if err != nil {
fmt.Println(err)
return nil, err
}
return
}
func RegistServer(conn *zk.Conn, host string) (err error) {
//conn.Delete("") 可以自主删除
_, err = conn.Create("/go_servers/"+host, nil, zk.FlagEphemeral, zk.WorldACL(zk.PermAll))
return err
}
func GetServerList(conn *zk.Conn) (list []string, err error) {
list, _, err = conn.Children("/go_servers")
fmt.Println("list:", list)
return
}
//watch机制，服务器有断开或者重连，收到消息
func WatchServerList(conn *zk.Conn, path string) (chan []string, chan error) {
snapshots := make(chan []string)
errors := make(chan error)
go func() {
for {
snapshot, _, events, err := conn.ChildrenW(path)
if err != nil {
errors <- err
return
}
snapshots <- snapshot
evt := <-events
if evt.Err != nil {
errors <- evt.Err
return
}
}
}()
return snapshots, errors
}
//watch机制，监听配置文件变化的过程
func WatchGetDat(conn *zk.Conn, path string) (chan []byte, chan error) {
snapshots := make(chan []byte)
errors := make(chan error)
go func() {
for {
dataBuf, _, events, err := conn.GetW(path)
if err != nil {
errors <- err
return
}
snapshots <- dataBuf
evt := <-events
if evt.Err != nil {
errors <- evt.Err
return
}
}
}()
return snapshots, errors
}
func CheckError(err error) {
if err != nil {
fmt.Println("err:", err)
//panic(err)
}
}
二 ： client(客户端模块)
package main
import (
"core.sincere/common/log"
request "core.sincere/common/request"
"core.sincere/test/zookeeper/common"
"errors"
"fmt"
"math/rand"
"time"
)
var serverList []string
func main() {
conn, err := common.GetConnect()
if err != nil {
fmt.Printf(" connect zk error: %s \n ", err)
return
}
defer conn.Close()
serverList, err = common.GetServerList(conn)
if err != nil {
fmt.Printf(" get server list error: %s \n", err)
return
}
count := len(serverList)
if count == 0 {
err = errors.New("server list is empty \n")
return
}
//用来实时监听服务的上线与下线功能，serverList时刻保持最新的在线服务
//获取最新地址
snapshots, errors := common.WatchServerList(conn, "/go_servers")
go func() {
for {
select {
case serverList = <-snapshots:
fmt.Printf("1111:%+v\n", serverList)
case err := <-errors:
fmt.Printf("2222:%+v\n", err)
}
}
}()
configs, errors := common.WatchGetDat(conn, "/config")
go func() {
for {
select {
case configData := <-configs:
fmt.Printf("333:%+v\n", string(configData))
case err := <-errors:
fmt.Printf("4444:%+v\n", err)
}
}
}()
//for {
// time.Sleep(1 * time.Second)
//}
for i := 0; i < 100; i++ {
fmt.Println("start Client :", i)
startClient()
time.Sleep(1 * time.Second)
}
}
func startClient() {
defer func() {
if err := recover(); err != nil {
fmt.Println("err:", err)
}
}()
// service := "127.0.0.1:8899"
//获取地址
serverHost, err := getServerHost()
if err != nil {
fmt.Printf("get server host fail: %s \n", err)
return
}
//serverHost := "127.0.0.1:8899" 此处是自己封住的包,就不做过多的解释了 自己去发http请求
fmt.Println("connect host: " + serverHost)
h := request.NewHttpSend(request.GetUrlBuild("http://"+serverHost+"/api",nil))
_, err = h.Get()
if err != nil {
log.Error("请求错误:", err)
} else {
log.Error("正常返回")
}
//tcpAddr, err := net.ResolveTCPAddr("tcp4", serverHost)
//checkError(err)
//conn, err := net.Dial("tcp", serverHost)
//common.CheckError(err)
//defer conn.Close()
//fmt.Println("connect ok")
//_, err = conn.Write([]byte("timestamp"))
//common.CheckError(err)
//fmt.Println("write ok")
// result, err := ioutil.ReadAll(conn)
// checkError(err)
// fmt.Println("recv:", string(result))
return
}
func getServerHost() (host string, err error) {
//随机选中一个返回
r := rand.New(rand.NewSource(time.Now().UnixNano()))
host = serverList[r.Intn(3)]
return
}
三 ：serve(服务端模块)
package main
/**
客户端doc地址：github.com/samuel/go-zookeeper/zk
**/
import (
"core.sincere/test/zookeeper/common"
"fmt"
"net/http"
)
func main() {
go starServer("127.0.0.1:9897")
go starServer("127.0.0.1:9898")
go starServer("127.0.0.1:9899")
a := make(chan bool, 1)
<-a
}
func starServer(port string) {
//engin := gin.Default()
//engin.GET("/api", func(context *gin.Context) {
// fmt.Println("因为懒 就不多写了")
//})
//注册zk节点q
conn, err := common.GetConnect()
if err != nil {
fmt.Printf(" connect zk error: %s ", err)
return
}
defer conn.Close()
//当注册时 首先需要创建一级节点 go_servers
//节点必须一节一节创建，不能直接就创建二级
err = common.RegistServer(conn, port)
if err != nil {
fmt.Printf(" regist node error: %s ", err)
return
}
mux1 := http.NewServeMux()
mux1.HandleFunc("/api", sayhelloName)
http.ListenAndServe(port, mux1)
需要自己开服务,zookeeper会自动检测
//http.HandleFunc("/hello", sayhelloName) //设置访问的路由
//err = http.ListenAndServe(port, nil) //设置监听的端口
//if err != nil {
// log.Fatal("ListenAndServe: ", err)
//}
//阻塞程序
//select {}
}
func sayhelloName(w http.ResponseWriter, r *http.Request) {
r.ParseForm() //解析参数，默认是不会解析的
//fmt.Println(r.Form) //这些信息是输出到服务器端的打印信息
//fmt.Println("path", r.URL.Path)
//fmt.Println("scheme", r.URL.Scheme)
//fmt.Println(r.Form["url_long"])
//for k, v := range r.Form {
// fmt.Println("key:", k)
// fmt.Println("val:", strings.Join(v, ""))
//}
fmt.Println("因为懒就没写什么了：",r.URL, r.Host)
fmt.Fprintf(w, "Hello Wrold!") //这个写入到w的是输出到客户端的
}