Heim Backend-Entwicklung Golang Informationen zur http/2-Serverfunktion der Go-Sprache und zur Verwendung des Clients

Informationen zur http/2-Serverfunktion der Go-Sprache und zur Verwendung des Clients

Oct 09, 2020 pm 02:14 PM
go

Die folgende Golang-Tutorial-Kolumne führt Sie in die http/2-Serverfunktionen und die Client-Nutzung der Go-Sprache ein. Ich hoffe, dass sie Freunden in Not hilfreich sein wird!

Vorwort

Wie wir alle wissen, unterstützt der HTTP-Server der Standardbibliothek von Go standardmäßig HTTP/2. Nun, in diesem Artikel werden wir zunächst die http/2-Serverfunktionen von Go vorstellen und erklären, wie man sie als Clients verwendet.

In diesem Artikel stellen wir zunächst die http/2-Serverfunktionen von Go vor und erklären, wie man sie als Clients verwendet. Der HTTP-Server der Standardbibliothek von Go unterstützt standardmäßig HTTP/2.

Weiter unten gibt es nicht viel zu sagen, werfen wir einen Blick auf die detaillierte Einführung

HTTP/2-Server

Erstellen wir zunächst einen http/2-Server in Go! Laut http/2-Dokumentation wird alles automatisch für uns konfiguriert und wir müssen nicht einmal das Standardbibliotheks-http2-Paket von Go importieren:

HTTP/2 erzwingt TLS. Um dies zu erreichen, benötigen wir zunächst einen privaten Schlüssel und ein Zertifikat. Unter Linux führt der folgende Befehl diese Aufgabe aus.

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

Dieser Befehl generiert zwei Dateien: server.key und server.crt

Für den Servercode verwenden wir nun in seiner einfachsten Form den HTTP-Server der Standardbibliothek von Go und aktivieren TLS mit der generierten SSL-Datei .

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"))
}
Nach dem Login kopieren

HTTP/2-Client

In go wird der Standard-http.Client auch für http/2-Anfragen verwendet. Der einzige Unterschied besteht darin, dass im Transportfeld des Clients http2.Transport anstelle von http.Transport verwendet wird.

Das von uns generierte Serverzertifikat ist „selbstsigniert“, d. h. es ist nicht von einer bekannten Zertifizierungsstelle (CA) signiert. Dies führt dazu, dass unser Client es nicht glaubt:

package main

import (
 "fmt"
 "net/http"
)

const url = "https://localhost:8000"

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

Versuchen wir es auszuführen:

$ go run h2-client.go 
Get https://localhost:8000: x509: certificate signed by unknown authority
Nach dem Login kopieren

Im Serverprotokoll sehen wir auch, dass der Client (Remote) einen Fehler hat:

http: TLS-Handshake-Fehler von [: :1]:58228: Remote-Fehler: tls: schlechtes Zertifikat


Um dieses Problem zu lösen, können wir unseren Client mit einer benutzerdefinierten TLS-Konfiguration konfigurieren. Wir werden die Serverzertifikatdatei zum „Zertifikatpool“ des Clients hinzufügen, da wir ihr vertrauen, auch wenn sie nicht von einer bekannten Zertifizierungsstelle signiert ist.

Wir werden außerdem eine Option hinzufügen, mit der Sie basierend auf Befehlszeilen-Flags zwischen HTTP/1.1- und HTTP/2-Transporten wählen können.

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)
 )
}
Nach dem Login kopieren

Dieses Mal erhalten wir die richtige Antwort:

$ go run h2-client.go 
Got response 200: HTTP/2.0 Hello
Nach dem Login kopieren

Im Serverprotokoll sehen wir die richtige Protokollzeile: Verbindung hergestellt: HTTP/2.0!!

Aber was passiert, wenn wir versuchen, HTTP/1.1-Transport zu verwenden?

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

Unser Server verfügt über keine spezifischen HTTP/2-Funktionen und unterstützt daher HTTP/1.1-Verbindungen. Dies ist wichtig für die Abwärtskompatibilität. Darüber hinaus gibt das Serverprotokoll an, dass die Verbindung HTTP/1.1 ist: Verbindung erhalten: HTTP/1.1.

Erweiterte HTTP/2-Funktionen

Wir haben eine HTTP/2-Client-Server-Verbindung erstellt und genießen die Vorteile einer sicheren und effizienten Verbindung. Aber HTTP/2 bietet noch viel mehr Funktionen, erkunden wir sie!

Server Push

HTTP/2 ermöglicht Server Push, „eine synthetische Anfrage unter Verwendung des angegebenen Ziels zu erstellen“.

Dies kann einfach im Server-Handler implementiert werden (siehe 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"))
}
Nach dem Login kopieren

Mit Server Push

Lassen Sie uns den Server erneut ausführen und den Client testen.

Für HTTP/1.1-Clients:

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

Das Serverprotokoll zeigt:

Verbindung erhalten: HTTP/1.1Handling 1st

Kann nicht an Client übertragen werden

HTTP/1.1-Client-Transportverbindung ergibt einen HTTP-ResponseWriter implementiert http.Pusher nicht, was Sinn macht. In unserem Servercode können wir auswählen, was in dieser Client-Situation geschehen soll.

Für HTTP/2-Clients:

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

Das Serverprotokoll zeigt:

Verbindung erhalten: HTTP/2.0Handling 1st

Push fehlgeschlagen: Funktion nicht unterstützt

Das ist seltsam. Unser HTTP/2-Transportclient erhielt nur die erste „Hallo“-Antwort. Aus den Protokollen geht hervor, dass die Verbindung die http.Pusher-Schnittstelle implementiert – aber sobald wir die Push()-Funktion tatsächlich aufrufen, schlägt sie fehl.

Bei der Fehlerbehebung wurde festgestellt, dass die HTTP/2-Clientübertragung ein HTTP/2-Einstellungsflag setzt, was darauf hinweist, dass Push deaktiviert ist.

Daher gibt es derzeit keine Möglichkeit, den Go-Client für die Nutzung von Server-Push zu verwenden.

Nebenbei bemerkt, Google Chrome als Client kann Server-Push verarbeiten.

Das Serverprotokoll zeigt, was wir erwarten, der Handler wird zweimal aufgerufen, für Pfad / und /2nd, obwohl der Client eigentlich nur Anfragen für Pfad / hat:

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
Nach dem Login kopieren

我们把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)
}
Nach dem Login kopieren

服务器将从请求正文读取器复制到写入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)
}
Nach dem Login kopieren

总结

Go支持与服务器推送和全双工通信的HTTP/2连接,这也支持HTTP/1.1与标准库的标准TLS服务器的连接——这太不可思议了。对于标准的库HTTP客户端,它不支持服务器推送,但是支持标准库的标准HTTP的全双工通信。以上就是本篇的内容,大家有什么疑问可以在文章下面留言沟通。

Das obige ist der detaillierte Inhalt vonInformationen zur http/2-Serverfunktion der Go-Sprache und zur Verwendung des Clients. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn

Heiße KI -Werkzeuge

Undresser.AI Undress

Undresser.AI Undress

KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover

AI Clothes Remover

Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool

Undress AI Tool

Ausziehbilder kostenlos

Clothoff.io

Clothoff.io

KI-Kleiderentferner

Video Face Swap

Video Face Swap

Tauschen Sie Gesichter in jedem Video mühelos mit unserem völlig kostenlosen KI-Gesichtstausch-Tool aus!

Heiße Werkzeuge

Notepad++7.3.1

Notepad++7.3.1

Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version

SublimeText3 chinesische Version

Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1

Senden Sie Studio 13.0.1

Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6

Dreamweaver CS6

Visuelle Webentwicklungstools

SublimeText3 Mac-Version

SublimeText3 Mac-Version

Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Heiße Themen

Java-Tutorial
1662
14
PHP-Tutorial
1261
29
C#-Tutorial
1234
24
Wie sende ich Go WebSocket-Nachrichten? Wie sende ich Go WebSocket-Nachrichten? Jun 03, 2024 pm 04:53 PM

In Go können WebSocket-Nachrichten mit dem Paket gorilla/websocket gesendet werden. Konkrete Schritte: Stellen Sie eine WebSocket-Verbindung her. Senden Sie eine Textnachricht: Rufen Sie WriteMessage(websocket.TextMessage,[]byte("message")) auf. Senden Sie eine binäre Nachricht: Rufen Sie WriteMessage(websocket.BinaryMessage,[]byte{1,2,3}) auf.

Der Unterschied zwischen Golang und Go-Sprache Der Unterschied zwischen Golang und Go-Sprache May 31, 2024 pm 08:10 PM

Go und die Go-Sprache sind unterschiedliche Einheiten mit unterschiedlichen Eigenschaften. Go (auch bekannt als Golang) ist bekannt für seine Parallelität, schnelle Kompilierungsgeschwindigkeit, Speicherverwaltung und plattformübergreifende Vorteile. Zu den Nachteilen der Go-Sprache gehören ein weniger umfangreiches Ökosystem als andere Sprachen, eine strengere Syntax und das Fehlen dynamischer Typisierung.

Wie kann ich Zeitstempel mithilfe regulärer Ausdrücke in Go abgleichen? Wie kann ich Zeitstempel mithilfe regulärer Ausdrücke in Go abgleichen? Jun 02, 2024 am 09:00 AM

In Go können Sie reguläre Ausdrücke verwenden, um Zeitstempel abzugleichen: Kompilieren Sie eine Zeichenfolge mit regulären Ausdrücken, z. B. die, die zum Abgleich von ISO8601-Zeitstempeln verwendet wird: ^\d{4}-\d{2}-\d{2}T \d{ 2}:\d{2}:\d{2}(\.\d+)?(Z|[+-][0-9]{2}:[0-9]{2})$ . Verwenden Sie die Funktion regexp.MatchString, um zu überprüfen, ob eine Zeichenfolge mit einem regulären Ausdruck übereinstimmt.

Wie vermeidet man Speicherlecks bei der technischen Leistungsoptimierung von Golang? Wie vermeidet man Speicherlecks bei der technischen Leistungsoptimierung von Golang? Jun 04, 2024 pm 12:27 PM

Speicherlecks können dazu führen, dass der Speicher des Go-Programms kontinuierlich zunimmt, indem: Ressourcen geschlossen werden, die nicht mehr verwendet werden, wie z. B. Dateien, Netzwerkverbindungen und Datenbankverbindungen. Verwenden Sie schwache Referenzen, um Speicherlecks zu verhindern, und zielen Sie auf Objekte für die Garbage Collection ab, wenn sie nicht mehr stark referenziert sind. Bei Verwendung von Go-Coroutine wird der Speicher des Coroutine-Stapels beim Beenden automatisch freigegeben, um Speicherverluste zu vermeiden.

Was ist zu beachten, wenn Golang-Funktionen Kartenparameter empfangen? Was ist zu beachten, wenn Golang-Funktionen Kartenparameter empfangen? Jun 04, 2024 am 10:31 AM

Beim Übergeben einer Karte an eine Funktion in Go wird standardmäßig eine Kopie erstellt und Änderungen an der Kopie haben keinen Einfluss auf die Originalkarte. Wenn Sie die Originalkarte ändern müssen, können Sie sie über einen Zeiger übergeben. Leere Karten müssen mit Vorsicht behandelt werden, da es sich technisch gesehen um Nullzeiger handelt und die Übergabe einer leeren Karte an eine Funktion, die eine nicht leere Karte erwartet, einen Fehler verursacht.

Wie verwende ich den Fehler-Wrapper von Golang? Wie verwende ich den Fehler-Wrapper von Golang? Jun 03, 2024 pm 04:08 PM

In Golang können Sie mit Fehler-Wrappern neue Fehler erstellen, indem Sie Kontextinformationen an den ursprünglichen Fehler anhängen. Dies kann verwendet werden, um die von verschiedenen Bibliotheken oder Komponenten ausgelösten Fehlertypen zu vereinheitlichen und so das Debuggen und die Fehlerbehandlung zu vereinfachen. Die Schritte lauten wie folgt: Verwenden Sie die Funktion „errors.Wrap“, um die ursprünglichen Fehler in neue Fehler umzuwandeln. Der neue Fehler enthält Kontextinformationen zum ursprünglichen Fehler. Verwenden Sie fmt.Printf, um umschlossene Fehler auszugeben und so mehr Kontext und Umsetzbarkeit bereitzustellen. Wenn Sie verschiedene Fehlertypen behandeln, verwenden Sie die Funktion „errors.Wrap“, um die Fehlertypen zu vereinheitlichen.

Wie erstelle ich eine priorisierte Goroutine in Go? Wie erstelle ich eine priorisierte Goroutine in Go? Jun 04, 2024 pm 12:41 PM

Es gibt zwei Schritte zum Erstellen einer Prioritäts-Goroutine in der Go-Sprache: Registrieren einer benutzerdefinierten Goroutine-Erstellungsfunktion (Schritt 1) ​​und Angeben eines Prioritätswerts (Schritt 2). Auf diese Weise können Sie Goroutinen mit unterschiedlichen Prioritäten erstellen, die Ressourcenzuteilung optimieren und die Ausführungseffizienz verbessern.

Eine Anleitung zum Unit-Testen gleichzeitiger Go-Funktionen Eine Anleitung zum Unit-Testen gleichzeitiger Go-Funktionen May 03, 2024 am 10:54 AM

Das Testen gleichzeitiger Funktionen in Einheiten ist von entscheidender Bedeutung, da dies dazu beiträgt, ihr korrektes Verhalten in einer gleichzeitigen Umgebung sicherzustellen. Beim Testen gleichzeitiger Funktionen müssen grundlegende Prinzipien wie gegenseitiger Ausschluss, Synchronisation und Isolation berücksichtigt werden. Gleichzeitige Funktionen können Unit-Tests unterzogen werden, indem Rennbedingungen simuliert, getestet und Ergebnisse überprüft werden.

See all articles