go语言 反向代理

实现简单的http反向代理 还没有加入负载均衡 新手推荐

下游服务器代码

package main

import (
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"
)

type RealServer struct {
	Addr string
}

func (r *RealServer) Run() {
	log.Println("Starting httpserver at " + r.Addr)
	mux := http.NewServeMux()
	mux.HandleFunc("/", r.HelloHandler)
	mux.HandleFunc("/base/error", r.ErrorHandler)
	mux.HandleFunc("/test_http_string/test_http_string/aaa", r.TimeoutHandler)
	server := &http.Server{
		Addr:         r.Addr,
		WriteTimeout: time.Second * 3,
		Handler:      mux,
	}
	go func() {
		log.Fatal(server.ListenAndServe())
	}()
}

func (r *RealServer) HelloHandler(w http.ResponseWriter, req *http.Request) {

	upath := fmt.Sprintf("http://%s%s\n", r.Addr, req.URL.Path)
	realIP := fmt.Sprintf("RemoteAddr=%s,X-Forwarded-For=%v,X-Real-Ip=%v\n", req.RemoteAddr, req.Header.Get("X-Forwarded-For"), req.Header.Get("X-Real-Ip"))
	header := fmt.Sprintf("headers =%v\n", req.Header)
	io.WriteString(w, upath)
	io.WriteString(w, realIP)
	io.WriteString(w, header)

}

func (r *RealServer) ErrorHandler(w http.ResponseWriter, req *http.Request) {
	upath := "error handler"
	w.WriteHeader(500)
	io.WriteString(w, upath)
}

func (r *RealServer) TimeoutHandler(w http.ResponseWriter, req *http.Request) {
	time.Sleep(6 * time.Second)
	upath := "timeout handler"
	w.WriteHeader(200)
	io.WriteString(w, upath)
}

func main() {
	rs1 := &RealServer{Addr: "127.0.0.1:2003"}
	rs1.Run()
	rs2 := &RealServer{Addr: "127.0.0.1:2004"}
	rs2.Run()

	//监听关闭信号
	quit := make(chan os.Signal)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit
}

反向代理代码

主要的思路是拿到httputil.ReverseProxy,修改里面内置的一些方法
该结构体有ServeHttp接口 因此可以直接使用到funhandlc中

package main

import (
	"bytes"
	"errors"
	"fmt"
	"io"
	"log"
	"net/http"
	"net/http/httputil"
	"net/url"
	"regexp"
	"strings"
)

// 当前服务器地址
var addr = "127.0.0.1:2222"

func main() {

	//设置下游的地址
	rs1 := "http://127.0.0.1:2003"
	url1, err := url.Parse(rs1)
	if err != nil {
		log.Println(err)
	}

	proxy := NewSingleHostReverseProxy(url1)
	log.Println("Starting httpserver at " + addr)
	log.Fatal(http.ListenAndServe(addr, proxy))
}

func NewSingleHostReverseProxy(target *url.URL) *httputil.ReverseProxy {
	targetQuery := target.RawQuery

	//设置新的请求信息
	director := func(req *http.Request) {
		//url_rewrite
		//127.0.0.1:2002/dir/abc ==> 127.0.0.1:2003/base/abc ??
		//127.0.0.1:2002/dir/abc ==> 127.0.0.1:2002/abc
		//127.0.0.1:2002/abc ==> 127.0.0.1:2003/base/abc
		re, _ := regexp.Compile("^/dir(.*)")
		req.URL.Path = re.ReplaceAllString(req.URL.Path, "$1")

		req.URL.Scheme = target.Scheme
		req.URL.Host = target.Host

		//target.Path : /base
		//req.URL.Path : /dir
		req.URL.Path = 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 {
			req.Header.Set("User-Agent", "")
		}
	}

	//修改返回值
	modifyFunc := func(res *http.Response) error {
		if res.StatusCode != 200 {
			return errors.New("error statusCode")

		}
		oldPayload, err := io.ReadAll(res.Body)
		if err != nil {
			return err
		}
		newPayLoad := []byte("hello " + string(oldPayload))
		res.Body = io.NopCloser(bytes.NewBuffer(newPayLoad))
		res.ContentLength = int64(len(newPayLoad))
		res.Header.Set("Content-Length", fmt.Sprint(len(newPayLoad)))
		return nil
	}
	//错误处理
	errorHandler := func(res http.ResponseWriter, req *http.Request, err error) {
		res.Write([]byte(err.Error()))
	}
	return &httputil.ReverseProxy{Director: director, ModifyResponse: modifyFunc, ErrorHandler: errorHandler}
}

// 重新组合URL
func singleJoiningSlash(a, b string) string {
	aslash := strings.HasSuffix(a, "/")
	bslash := strings.HasPrefix(b, "/")
	switch {
	case aslash && bslash:
		return a + b[1:]
	case !aslash && !bslash:
		return a + "/" + b
	}
	return a + b
}

通过反向代理修改返回结果 添加了hello

oldPayload, err := io.ReadAll(res.Body)
		if err != nil {
			return err
		}
		newPayLoad := []byte("hello " + string(oldPayload))
		res.Body = io.NopCloser(bytes.NewBuffer(newPayLoad))
		res.ContentLength = int64(len(newPayLoad))
		res.Header.Set("Content-Length", fmt.Sprint(len(newPayLoad)))

在这里插入图片描述

X-Forwarded-For 头部

记录整个代理过程的IP
可能会被仿造 也就是发送请求的时候改变X-Forwarded-For的内容
在这里插入图片描述

X-Real-IP 头部

拿到请求的真实服务器的IP
每次代理都会被覆盖,只需要在第一层代理设置转发
不会被伪造
在这里插入图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Golang中实现WebSocket反向代理相对简单。你可以使用`gorilla/websocket`包来处理WebSocket连接,并使用`net/http/httputil`包来实现反向代理。 首先,你需要安装`gorilla/websocket`包。可以使用以下命令来安装: ``` go get github.com/gorilla/websocket ``` 接下来,你可以使用以下代码来创建一个WebSocket反向代理: ```go package main import ( "log" "net/http" "net/http/httputil" "net/url" "github.com/gorilla/websocket" ) func main() { // 创建一个反向代理的目标URL backendURL := "ws://localhost:8081/ws" targetURL, err := url.Parse(backendURL) if err != nil { log.Fatal(err) } // 创建WebSocket代理 proxy := httputil.NewSingleHostReverseProxy(targetURL) // WebSocket处理函数 websocketHandler := func(w http.ResponseWriter, r *http.Request) { // 升级HTTP连接到WebSocket连接 upgrader := websocket.Upgrader{} conn, err := upgrader.Upgrade(w, r, nil) if err != nil { http.Error(w, "Failed to upgrade to WebSocket", http.StatusInternalServerError) return } defer conn.Close() // 反向代理WebSocket连接 proxy.ServeHTTP(w, r) } // 注册WebSocket处理函数 http.HandleFunc("/ws", websocketHandler) // 启动HTTP服务器 log.Println("Starting server on :8080") err = http.ListenAndServe(":8080", nil) if err != nil { log.Fatal(err) } } ``` 以上代码创建了一个简单的WebSocket反向代理,将所有连接到`/ws`路径的WebSocket连接转发到`ws://localhost:8081/ws`。你可以根据实际需求修改代理的目标URL和端口。 请注意,这只是一个简单的示例,你可能需要根据你的具体需求进行修改和扩展。此外,你还可以添加身份验证、错误处理等功能来完善代理。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值