Reverse Proxy in Gin Returning 502 Always

I'm in need of some advice when it comes to this service I am writing in go. In summary, the service uses Gin along with a custom NewSingleHostReverseProxy middleware for proxying file upload request to S3. Here is an example of the code for the proxy middleware:

package middleware

import (
	"crypto/tls"
	"fmt"
	"log"
	"net/http"
	"net/http/httputil"
	"net/url"

	"github.com/gin-gonic/gin"

	"my-proxy/internal/service"
)

func Proxy(proxyService *service.ProxyService) gin.HandlerFunc {
	return func(c *gin.Context) {
		proxyHeaders, _ := proxyService.NewProxyHeaders(c, bucket, key)

		remote, err := url.Parse(fmt.Sprintf("https://%s.myendpoint.com", bucket))
		if err != nil {
			panic(err)
		}

		proxy := httputil.NewSingleHostReverseProxy(remote)

		proxy.Transport = &http.Transport{
			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
		}

		proxy.Director = func(req *http.Request) {
			req.Header = proxyHeaders
			req.Host = remote.Host
			req.URL.Scheme = remote.Scheme
			req.URL.Host = remote.Host
			req.URL.Path = key
		}

		proxy.ModifyResponse = func(r *http.Response) error {
			log.Println(r.Status + "\n")
			return nil
		}

		proxy.ServeHTTP(c.Writer, c.Request)
	}
}

And here is the output I'm getting:

2023/04/13 15:05:56 200 OK

2023/04/13 15:05:56 http: proxy error: http: invalid Read on closed Body

\[GIN\] 2023/04/13 - 15:05:56 | 502 | 865.355034ms | ::1 | PUT

Any idea as to what could be causing the 502 to caused by the read on closed body. As you see, the response from s3 is successful in the ModifyResponse callback.

Currently the code I put in my post is executing the file upload successfully (I see it in s3 and the response coming back is 200). I'm mainly trying to uncover the cause for the body read after close.

The proxy alone is okay. I guess what's wrong is the handler or other middlewares executed after it attempts to read the request body, which has already been read and closed by the proxy.

Since you haven't provided other code, we can not tell what's wrong. Below is a demo to show what could be wrong. Use it like this:

$ go run main.go
$ curl -i -X POST http://localhost:8080/upload-bad -d "hello"
$ curl -i -X POST http://localhost:8080/upload-good -d "hello"

package main

import (
	"fmt"
	"log"
	"net/http"
	"net/http/httptest"
	"net/http/httputil"
	"net/url"

	"github.com/gin-gonic/gin"
)

func Proxy(target *url.URL) gin.HandlerFunc {
	return func(c *gin.Context) {
		proxy := httputil.NewSingleHostReverseProxy(target)

		proxy.ServeHTTP(c.Writer, c.Request)
	}
}

func main() {
	backendServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		buf, err := httputil.DumpRequest(r, true)
		if err != nil {
			log.Printf("[backend] failed to dump request: %v", err)
		} else {
			log.Printf("[backend]\n%s", buf)
		}
		fmt.Fprintln(w, "this call was relayed by the reverse proxy")
	}))
	defer backendServer.Close()

	rpURL, err := url.Parse(backendServer.URL)
	if err != nil {
		log.Fatal(err)
	}

	r := gin.Default()

	// == begin wrong setup
	// To apply the middleware on "/upload-bad" only.
	// It's weird to use Proxy as a middleware.
	r.Use(gin.HandlerFunc(func(c *gin.Context) {
		if c.Request.URL.Path == "/upload-bad" {
			Proxy(rpURL)(c)
		}
	}))
	// This handler tries to read the request body which already been
	// closed by the proxy middleware.
	r.POST("/upload-bad", func(c *gin.Context) {
		// err will be: failed to dump request: http: invalid Read on closed Body
		buf, err := httputil.DumpRequest(c.Request, true)
		if err != nil {
			log.Printf("[handler] failed to dump request: %v", err)
		} else {
			log.Printf("[handler]: %s", buf)
		}
	})
	// == end wrong setup

	// I think it should be used as a normal handler instead.
	r.POST("/upload-good", Proxy(rpURL))
	_ = r.Run()
}