网络代理【5】代理实现4种负载均衡策略

小咪咪 2023-02-14 10:06 14阅读 0赞

`正在更新`  
**目录**:  
拓展ReverseProxy功能:

*  一、Random随机负载
 *  二、RoundRobin轮询负载
 *  三、工厂类封装
 *  四、代理调用负载策略

**一、Random随机负载**  
随机挑选一台机器访问

package lbalance
    import (
    	"errors"
    	"math/rand"
    )
    type RandomBalance struct { 
    	curIndex int
    	rss      []string
    }
    func (r *RandomBalance) Add(params ...string) error { 
    	if len(params) == 0 { 
    		return errors.New("param len 1 at least")
    	}
    	r.rss = append(r.rss, params[0])
    	return nil
    }
    func (r *RandomBalance) Next() string { 
    	if len(r.rss) == 0 { 
    		return ""
    	}
    	r.curIndex = rand.Intn(len(r.rss))
    	return r.rss[r.curIndex]
    }
    func (r *RandomBalance) Get(key string) (string, error) { 
    	return r.Next(), nil
    }

**二、RoundRobin轮询负载**  
对后端主机有序轮流访问

package lbalance
    import "errors"
    
    type RoundRobinBalance struct { 
    	curIndex int
    	rss      []string
    }
    func (r *RoundRobinBalance) Add(params ...string) error { 
    	if len(params) == 0 { 
    		return errors.New("param len 1 at least")
    	}
    	r.rss = append(r.rss, params[0])
    	return nil
    }
    func (r *RoundRobinBalance) Next() string { 
    	if len(r.rss) == 0 { 
    		return ""
    	}
    	length := len(r.rss)
    	if r.curIndex >= length { 
    		r.curIndex = 0
    	}
    	curAddr := r.rss[r.curIndex]
    	r.curIndex = r.curIndex + 1
    	return curAddr
    }
    func (r *RoundRobinBalance) Get(key string) (string, error) { 
    	return r.Next(), nil
    }

**三、工厂类封装**

package lbalance
    // LbType ...
    type LbType int
    const (
    	LbRandom = iota
    	LbRoundRobin
    )
    type LoadBalance interface { 
    	Add(params ...string) error
    	Next() string
    	Get(key string) (string, error)
    }
    func LoadBalanceFactory(lbType LbType) LoadBalance { 
    	switch lbType { 
    	case LbRandom:
    		return &RandomBalance{ }
    	case LbRoundRobin:
    		return &RoundRobinBalance{ }
    	default:
    		return &RandomBalance{ }
    	}
    }

**四、代理调用负载策略**

package main
    // 反向代理服务器
    import (
    	"bytes"
    	"fmt"
    	"gateway/proxy/lbalance"
    	"gateway/utils"
    	"io/ioutil"
    	"log"
    	"net/http"
    	"net/http/httputil"
    	"net/url"
    )
    
    type Proxy struct { 
    	lb lbalance.LoadBalance
    }
    
    // Director 构造请求器，这里可以修改请求的内容(包括目标、路由)
    func (p *Proxy) Director(req *http.Request) { 
    	// 负载均衡
    	nextAddr, err := p.lb.Get(req.URL.String()) // 基于请求的路径，也可以基于客户端IP(req.RemoteAddr)
    	log.Println("nextAddr: ", nextAddr)
    	if err != nil { 
    		log.Fatal("get next addr fail", err)
    	}
    	target, err := url.Parse(nextAddr)
    	if err != nil { 
    		log.Fatal(err)
    	}
    	// 重组请求参数
    	targetQuery := target.RawQuery
    	req.URL.Scheme = target.Scheme
    	req.URL.Host = target.Host
    	req.URL.Path = utils.SingleJoiningSlash(target.Path, req.URL.Path)
    	if targetQuery == "" || req.URL.RawQuery == "" { 
    		req.URL.RawQuery = targetQuery + req.URL.RawQuery
    	} else { 
    		req.URL.RawQuery = targetQuery + "&" + req.URL.RawQuery
    	}
    	if _, ok := req.Header["User-Agent"]; !ok { 
    		// explicitly disable User-Agent so it's not set to default value
    		req.Header.Set("User-Agent", "")
    	}
    }
    
    // ModifyResponse 更改返回体
    // 功能: 如果状态码为500加个标签
    func (p *Proxy) ModifyResponse(resp *http.Response) (err error) { 
    	if resp.StatusCode == 500 { 
    		// 1.将内容拷贝出来, 并加料
    		data, _ := ioutil.ReadAll(resp.Body)
    		data = []byte("BlackLivesMatter " + string(data))
    		// 2.修改返回头信息
    		resp.ContentLength = int64(len(data))
    		resp.Header.Set("Content-Length", fmt.Sprint(len(data)))
    		resp.Body = ioutil.NopCloser(bytes.NewBuffer(data))
    	}
    	return
    }
    
    func NewMultiHostReverseProxy(lb lbalance.LoadBalance) (*httputil.ReverseProxy, error) { 
    	proxy := &Proxy{ lb: lb}
    	return &httputil.ReverseProxy{ 
    		Director:       proxy.Director,
    		ModifyResponse: proxy.ModifyResponse,
    	}, nil
    }
    
    func main(){ 
    	rb := lbalance.LoadBalanceFactory(lbalance.LbRoundRobin)
    	if err := rb.Add("http://192.168.27.128:2000", "10"); err != nil { 
    		log.Fatal(err)
    	}
    	if err := rb.Add("http://192.168.27.128:3000/append", "20"); err != nil { 
    		log.Fatal(err)
    	}
    	reverse, err := NewMultiHostReverseProxy(rb)
    	if err != nil { 
    		log.Fatal(err)
    	}
    	server := http.Server{ 
    		Addr:         "192.168.27.128:80",
    		WriteTimeout: time.Second * 3,
    		Handler:      reverse,
    	}
    	log.Fatal(server.ListenAndServe())
    }