Post Binary data (application/octet-stream)

i want to upload a file with content-type set to application/octet-stream and the binary data of the File in the body of the Request. how would i do that in golang here is my starting code:

package main

import (
	"fmt"
	"log"
	"net/http"
	"net/http/httputil"
	"os"
)

func main() {
	file, err := os.Open("file.pdf")
	if err != nil {
		log.Fatalln(err)
	}

	req, err := http.NewRequest("POST", fmt.Sprintf("https://example.com/upload"), nil)
	req.Header.Add("Content-Type", "application/octet-stream")

	if err != nil {
		log.Fatalln(err)
	}

	client := &http.Client{
		Transport: &http.Transport{
			DisableCompression: true,
		},
	}

	resp, err := client.Do(req)
	if err != nil {
		log.Fatalln(err)
	}
	defer resp.Body.Close()

	reqDump, err := httputil.DumpRequest(req, true)
	if err != nil {
		log.Fatalln(err)
	}

	fmt.Println(reqDump)
}

I put together an answer that could help you to figure out the problem. All of the code belongs to the main.go file just for the sake of the demo. It has two main parts: the handler and the main function. Let's start with the handler.

The HTTP handler

func HandleFile(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		w.WriteHeader(http.StatusMethodNotAllowed)
		return
	}
	fmt.Println("HandleFile")
	data, err := io.ReadAll(r.Body)
	if err != nil {
		panic(err)
	}
	defer r.Body.Close()
	w.Write(data)
}

Here, I just relied on what you used (only the Go standard library: http, io, and fmt packages). We only need to write on the response stream the incoming payload we read from the HTTP request.

The main function

func main() {
	r := http.NewServeMux()
	r.HandleFunc("/example", HandleFile)
	srv := http.Server{
		Addr:    ":8000",
		Handler: r,
	}

	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		defer wg.Done()
		if err := srv.ListenAndServe(); err != nil {
			fmt.Println(err.Error())
		}
	}()

	file, err := os.Open("file.txt")
	if err != nil {
		panic(err)
	}
	defer file.Close()
	req, err := http.NewRequest(http.MethodPost, "http://localhost:8000/example", file)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", "application/octet-stream")
	client := &http.Client{
		Transport: &http.Transport{
			DisableCompression: true,
		},
	}
	res, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	data, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(string(data))

	srv.Shutdown(context.Background())
	wg.Wait()
}

Conversely, the main function has more logic to deal with. Let's recap them in a list:

1. It creates an HTTP server to serve the incoming requests. We instrument it to reply to the request against the /example endpoint with the HandleFile handler we created before.
2. We used the sync.WaitGroup to run the server in a separate goroutine. Thanks to this, the server is up and running but we can continue our program and send HTTP requests within it.
3. We prepare an HTTP Request with the content of a file read from the local file system (in our case file.txt). We set the Content-Type header to application/octet-stream and we pass to the NewRequest function the handle to the file.
4. We issue the request and we print the content of the HTTP response payload.
5. We shutdown the server and tell to the WaitGroup to wait for all of the goroutines with the method wg.Wait.

Final Considerations

The code written down here could be improved for sure. Anyway, just for the sake of the demo, I preferred to let it be as close as I can to the original one to let you understand better how to post a binary file on an HTTP server and how to simultaneously run a client and server within the same program. If something is not clear, just let me know, thanks!