Go語言HTTP/2探險之旅

在這篇文章中，我們將首先展示Go的http/2伺服器功能，並解釋如何將它們作為客戶端使用。Go的標準庫HTTP伺服器預設支援HTTP/2。

首先，讓我們在Go中建立一個http/2伺服器！根據http/2文件，所有東西都是為我們自動配置的，我們甚至不需要匯入Go的標準庫http2包：

HTTP/2強制使用TLS。為了實現這一點，我們首先需要一個私鑰和一個證書。在Linux上，下面的命令執行這個任務。

openssl req -newkey rsa:2048 -nodes -keyout server.key -x509 -days 365 -out server.crt

該命令將生成兩個檔案：server.key 以及 server.crt

現在，對於伺服器程式碼，以最簡單的形式，我們將使用Go的標準庫HTTP伺服器，並啟用TLS與生成的SSL檔案。

package main

import (
    "log"
    "net/http"
)
	
func main() {
    // 在 8000 埠啟動伺服器
    // 確切地說，如何執行HTTP/1.1伺服器。

    srv := &http.Server{Addr:":8000", Handler: http.HandlerFunc(handle)}
    // 用TLS啟動伺服器，因為我們執行的是http/2，它必須是與TLS一起執行。
    // 確切地說，如何使用TLS連線執行HTTP/1.1伺服器。     log.Printf("Serving on )
    log.Fatal(srv.ListenAndServeTLS("server.crt", "server.key")) }

func handle(w http.ResponseWriter, r *http.Request) {
    // 記錄請求協議     log.Printf("Got connection: %s", r.Proto)
    // 向客戶傳送一條訊息     w.Write([]byte("Hello")) }

package main

import (
    "fmt"
    "net/http"
)

const url = "

func main() {     _, err := http.Get(url)
    fmt.Println(err) }

讓我們試著執行它：

$ go run h2-client.go  Get 

在伺服器日誌中，我們還將看到客戶端（遠端）有一個錯誤：

http: TLS handshake error from [::1]:58228: remote error: tls: bad certificate

為了解決這個問題，我們可以用定製的TLS配置去配置我們的客戶端。我們將把伺服器證書檔案新增到客戶端“證書池”中，因為我們信任它，即使它不是由已知CA簽名的。

我們還將新增一個選項，根據命令列標誌在HTTP/1.1和HTTP/2傳輸之間進行選擇。

package main

import (
	"crypto/tls" 	"crypto/x509" 	"flag" 	"fmt" 	"io/ioutil" 	"log" 	"net/http" 	"golang.org/x/net/http2"
)
	
const url = "

var httpVersion = flag.Int("version", 2, "HTTP version")  func main() { 	flag.Parse() 	client := &http.Client{}
	// Create a pool with the server certificate since it is not signed 	// by a known CA 	caCert, err := ioutil.ReadFile("server.crt")
        if err != nil {
 		log.Fatalf("Reading server certificate: %s", err) 	} 	caCertPool := x509.NewCertPool() 	caCertPool.AppendCertsFromPEM(caCert)
	// Create TLS configuration with the certificate of the server 	tlsConfig := &tls.Config{ 		RootCAs: caCertPool, 	}
 	// Use the proper transport in the client 	switch *httpVersion {
 	case 1: 		client.Transport = &http.Transport{ 			TLSClientConfig: tlsConfig, 		}
	case 2: 		client.Transport = &http2.Transport{ 			TLSClientConfig: tlsConfig, 		} 	}
	// Perform the request 	resp, err := client.Get(url)
 	if err != nil {
 		log.Fatalf("Failed get: %s", err) 	} 	defer resp.Body.Close() 	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
 		log.Fatalf("Failed reading response body: %s", err) 	} 	fmt.Printf(
		"Got response %d: %s %s\n", 		resp.StatusCode, resp.Proto, string(body)
        ) }

這一次我們得到了正確的回應：

$ go run h2-client.go  Got response 200: HTTP/2.0 Hello

在伺服器日誌中，我們將看到正確的日誌線：獲得連線：Got connection: HTTP/2.0!！
但是當我們嘗試使用HTTP/1.1傳輸時，會發生什麼呢？

$ go run h2-client.go -version 1 Got response 200: HTTP/1.1 Hello

我們的伺服器對HTTP/2沒有任何特定的東西，所以它支援HTTP/1.1連線。這對於向後相容性很重要。此外，伺服器日誌表明連線是HTTP/1.1：Got connection: HTTP/1.1。

func handle(w http.ResponseWriter, r *http.Request) {
	// Log the request protocol 	log.Printf("Got connection: %s", r.Proto)
	// Handle 2nd request, must be before push to prevent recursive calls. 	// Don't worry - Go protect us from recursive push by panicking. 	if r.URL.Path == "/2nd" {
 		log.Println("Handling 2nd") 		w.Write([]byte("Hello Again!"))
		return 	}
 	// Handle 1st request 	log.Println("Handling 1st")
	// Server push must be before response body is being written. 	// In order to check if the connection supports push, we should use 	// a type-assertion on the response writer. 	// If the connection does not support server push, or that the push 	// fails we just ignore it - server pushes are only here to improve 	// the performance for HTTP/2 clients. 	pusher, ok := w.(http.Pusher)
 	if !ok {
 		log.Println("Can't push to client") 	} else { 		err := pusher.Push("/2nd", nil)
              if err != nil {
 			log.Printf("Failed push: %v", err) 		} 	}
	// Send response body 	w.Write([]byte("Hello")) }

$ go run ./h2-client.go -version 1 Got response 200: HTTP/1.1 Hello

伺服器日誌將顯示：

Got connection: HTTP/1.1Handling 1st Can't push to client

HTTP/1.1客戶端傳輸連線產生一個 http.ResponseWriter 沒有實現http.Pusher，這是有道理的。在我們的伺服器程式碼中，我們可以選擇在這種客戶機的情況下該做什麼。

對於HTTP/2客戶：

go run ./h2-client.go -version 2 Got response 200: HTTP/2.0 Hello

伺服器日誌將顯示：

Got connection: HTTP/2.0Handling 1st Failed push: feature not supported

這很奇怪。我們的HTTP/2傳輸的客戶端只得到了第一個“Hello”響應。日誌表明連線實現了 http.Pusher 介面——但是一旦我們實際呼叫 Push() 函式——它就失敗了。

排查發現，HTTP/2客戶端傳輸設定了一個HTTP/2設定標誌，表明推送是禁用的。

因此，目前沒有選擇使用Go客戶機來使用伺服器推送。

作為一個附帶說明，google chrome作為一個客戶端可以處理伺服器推送。

伺服器日誌將顯示我們所期望的，處理程式被呼叫兩次，路徑 / 和 /2nd，即使客戶實際上只對路徑 /：

Got connection: HTTP/2.0Handling 1st Got connection: HTTP/2.0Handling 2nd

$ curl -i -XPUT --http2 

type flushWriter struct { 	w io.Writer }  func (fw flushWriter) Write(p []byte) (n int, err error) { 	n, err = fw.w.Write(p)
	// Flush - send the buffered written data to the client 	if f, ok := fw.w.(http.Flusher); ok { 		f.Flush() 	}
        return
}

func echoCapitalHandler(w http.ResponseWriter, r *http.Request) {
	// First flash response headers 	if f, ok := w.(http.Flusher); ok { 		f.Flush() 	}
 	// Copy from the request body to the response writer and flush 	// (send to client) 	io.Copy(flushWriter{w: w}, r.Body) }

const url = "

func main() {
        // Create a pipe - an object that implements `io.Reader` and `io.Writer`.          // Whatever is written to the writer part will be read by the reader part.

        pr, pw := io.Pipe()	        // Create an `http.Request` and set its body as the reader part of the         // pipe - after sending the request, whatever will be written to the pipe,         // will be sent as the request body.        // This makes the request content dynamic, so we don't need to define it         // before sending the request. 	req, err := http.NewRequest(http.MethodPut, url, ioutil.NopCloser(pr))
 	if err != nil {
 		log.Fatal(err) 	}
	         // Send the request 	resp, err := http.DefaultClient.Do(req)		if err != nil {
 	        	log.Fatal(err)         	}
	log.Printf("Got: %d", resp.StatusCode)	 	// Run a loop which writes every second to the writer part of the pipe 	// the current time. 	go func() {		for {    			time.Sleep(1 * time.Second) 			fmt.Fprintf(pw, "It is now %v\n", time.Now()) 		} 	}()	

        // Copy the server's response to stdout. 	_, err = io.Copy(os.Stdout, res.Body)
 	log.Fatal(err) }