다음 golang 튜토리얼 칼럼에서는 Go 언어의 http/2 서버 기능과 클라이언트 사용법을 소개하겠습니다. 도움이 필요한 친구들에게 도움이 되길 바랍니다!
서문
우리 모두 알고 있듯이 Go의 표준 라이브러리 HTTP 서버는 기본적으로 HTTP/2를 지원합니다. 이 글에서는 먼저 Go의 http/2 서버 기능을 소개하고 이를 클라이언트로 사용하는 방법을 설명하겠습니다.
이 글에서는 먼저 Go의 http/2 서버 기능을 소개하고 이를 클라이언트로 사용하는 방법을 설명하겠습니다. Go의 표준 라이브러리 HTTP 서버는 기본적으로 HTTP/2를 지원합니다.
아래에서 할 말은 없지만 자세한 소개를 살펴보겠습니다
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 서버를 사용하고 생성된 SSL 파일로 TLS를 활성화합니다. .
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 https://0.0.0.0:8000")
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"))
}HTTP/2 클라이언트
Go에서는 표준 http.Client가 http/2 요청에도 사용됩니다. 유일한 차이점은 클라이언트의 전송 필드에서 http.Transport 대신 http2.Transport가 사용된다는 것입니다.
우리가 생성하는 서버 인증서는 "자체 서명"되어 있습니다. 즉, 알려진 인증 기관(CA)에서 서명하지 않았다는 의미입니다. 이렇게 하면 클라이언트가 이를 믿지 않게 됩니다.
package main
import (
"fmt"
"net/http"
)
const url = "https://localhost:8000"
func main() {
_, err := http.Get(url)
fmt.Println(err)
}실행해 보겠습니다.
$ go run h2-client.go Get https://localhost:8000: x509: certificate signed by unknown authority
서버 로그에서 클라이언트(원격)에 오류가 있음도 확인할 수 있습니다.
http: [:의 TLS 핸드셰이크 오류 :1]:58228: 원격 오류: tls: 잘못된 인증서
이 문제를 해결하려면 사용자 정의된 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 = "https://localhost:8000"
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임을 나타냅니다. 연결 있음: HTTP/1.1.
HTTP/2 고급 기능
우리는 HTTP/2 클라이언트-서버 연결을 만들었으며 안전하고 효율적인 연결의 이점을 누리고 있습니다. 그러나 HTTP/2는 더 많은 기능을 제공하므로 이를 살펴보겠습니다!
서버 푸시
HTTP/2를 사용하면 서버 푸시를 통해 "주어진 대상을 사용하여 합성 요청을 구성"할 수 있습니다.
이것은 서버 핸들러에서 쉽게 구현할 수 있습니다(github에서 확인):
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"))
}Using Server Push
서버를 다시 실행하고 클라이언트를 테스트해 보겠습니다.
HTTP/1.1 클라이언트의 경우:
$ go run ./h2-client.go -version 1 Got response 200: HTTP/1.1 Hello
서버 로그에 다음이 표시됩니다.
연결 확인: HTTP/1.1Handling 1st
클라이언트에 푸시할 수 없습니다
HTTP/1.1 클라이언트 전송 연결은 http를 생성합니다. http.Pusher를 구현하지 않습니다. 이는 의미가 있습니다. 서버 코드에서는 이 클라이언트 상황에서 무엇을 할지 선택할 수 있습니다.
HTTP/2 클라이언트의 경우:
go run ./h2-client.go -version 2 Got response 200: HTTP/2.0 Hello
서버 로그에 다음이 표시됩니다.
연결됨: HTTP/2.0 첫 번째 처리
푸시 실패: 기능이 지원되지 않음
이상합니다. 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
全双工通信
Go HTTP/2演示页面有一个echo示例，它演示了服务器和客户机之间的全双工通信。
让我们先用CURL来测试一下：
$ curl -i -XPUT --http2 https://http2.golang.org/ECHO -d hello HTTP/2 200 content-type: text/plain; charset=utf-8 date: Tue, 24 Jul 2018 12:20:56 GMT HELLO
我们把curl配置为使用HTTP/2，并将一个PUT/ECHO发送给“hello”作为主体。服务器以“HELLO”作为主体返回一个HTTP/2 200响应。但我们在这里没有做任何复杂的事情，它看起来像是一个老式的HTTP/1.1半双工通信，有不同的头部。让我们深入研究这个问题，并研究如何使用HTTP/2全双工功能。
服务器实现
下面是HTTP echo处理程序的简化版本（不使用响应）。它使用 http.Flusher 接口，HTTP/2添加到http.ResponseWriter。
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)
}服务器将从请求正文读取器复制到写入ResponseWriter和 Flush() 的“冲洗写入器”。同样，我们看到了笨拙的类型断言样式实现，冲洗操作将缓冲的数据发送给客户机。
请注意，这是全双工，服务器读取一行，并在一个HTTP处理程序调用中重复写入一行。
GO客户端实现
我试图弄清楚一个启用了HTTP/2的go客户端如何使用这个端点，并发现了这个Github问题。提出了类似于下面的代码。
const url = "https://http2.golang.org/ECHO"
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)
}总结
Go支持与服务器推送和全双工通信的HTTP/2连接，这也支持HTTP/1.1与标准库的标准TLS服务器的连接——这太不可思议了。对于标准的库HTTP客户端，它不支持服务器推送，但是支持标准库的标准HTTP的全双工通信。以上就是本篇的内容，大家有什么疑问可以在文章下面留言沟通。
위 내용은 Go 언어의 http/2 서버 기능과 클라이언트 사용법에 대해의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!
![[웹 프런트엔드] Node.js 빠른 시작](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
