Hướng Dẫn Bắt Đầu với HTTP/3 trong Golang: Hướng Dẫn Thực Tế

go version

mkdir h3-demo && cd h3-demo
go mod init example.com/h3demo

go get github.com/quic-go/quic-go/http3

mkdir cert
openssl req -x509 -newkey rsa:2048 -nodes \
  -subj "/CN=localhost" \
  -keyout cert/key.pem -out cert/cert.pem -days 365

package main
import (
 "fmt"
 "log"
 "net/http"
 "github.com/quic-go/quic-go/http3"
)
func main() {
 mux := http.NewServeMux()
 mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
  fmt.Fprintf(w, "Xin chào từ HTTP/3! Bạn đã yêu cầu %s qua %s\n", r.URL.Path, r.Proto)
 })
 addr := ":4433"
 log.Printf("Khởi động máy chủ HTTP/3 tại https://localhost%v", addr)
 if err := http3.ListenAndServeTLS(addr, "cert/cert.pem", "cert/key.pem", mux); err != nil {
  log.Fatal(err)
 }
}

go run .

2025/08/15 14:42:51 Khởi động máy chủ HTTP/3 tại https://localhost:4433

brew install curl

export PATH="/usr/local/opt/curl/bin:$PATH"

curl --version | grep -i http3

curl --http3-only -k https://localhost:4433/

Xin chào từ HTTP/3! Bạn đã yêu cầu / qua HTTP/3

go get github.com/quic-go/quic-go

package main
import (
 "crypto/tls"
 "fmt"
 "io"
 "log"
 "net/http"
 "time"
 "github.com/quic-go/quic-go/http3"
)
func main() {
 // URL của máy chủ HTTP/3
 url := "https://localhost:4433/"
 // Tạo một transport HTTP/3 (QUIC)
 transport := &http3.RoundTripper{
  TLSClientConfig: &tls.Config{
   InsecureSkipVerify: true, // Đối với phát triển cục bộ/chứng chỉ tự ký
   MinVersion:         tls.VersionTLS13,
  },
 }
 defer transport.Close()
 // Tạo client HTTP sử dụng transport HTTP/3
 client := &http.Client{
  Transport: transport,
  Timeout:   10 * time.Second,
 }
 // Gửi yêu cầu GET
 start := time.Now()
 resp, err := client.Get(url)
 if err != nil {
  log.Fatal(err)
 }
 defer resp.Body.Close()
 // Đọc nội dung phản hồi
 body, err := io.ReadAll(resp.Body)
 if err != nil {
  log.Fatal(err)
 }
 elapsed := time.Since(start)
 // Xuất kết quả
 fmt.Printf("Trạng thái   : %s\n", resp.Status)
 fmt.Printf("Giao thức : %s\n", resp.Proto) // Nên là "HTTP/3"
 fmt.Printf("Thời gian   : %v\n", elapsed)
 fmt.Println("--------- Nội Dung ---------")
 fmt.Print(string(body))
}

go run .    # từ dự án máy chủ của bạn (phục vụ trên :4433)

go run client.go

Trạng thái   : 200 OK
Giao thức : HTTP/3
Thời gian  : 6.3ms
--------- Nội Dung ---------
Xin chào từ HTTP/3!

package main
import (
 "crypto/tls"
 "fmt"
 "log"
 "net"
 "net/http"
 "github.com/quic-go/quic-go/http3" // Triển khai máy chủ HTTP/3 sử dụng QUIC
)
func main() {
 // Tạo một multiplexer để xử lý các tuyến HTTP
 mux := http.NewServeMux()
 // Trình xử lý đơn giản: trả về một thông điệp bao gồm giao thức HTTP được sử dụng
 mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
  fmt.Fprintf(w, "Xin chào từ %s!\n", r.Proto) // r.Proto: HTTP/1.1, HTTP/2, hoặc HTTP/3
 })
 // Đường dẫn đến các file chứng chỉ TLS và khóa
 certFile := "cert/cert.pem"
 keyFile := "cert/key.pem"
 // ----- HTTP/1.1 & HTTP/2 qua TCP -----
 // Thư viện chuẩn của Go tự động hỗ trợ HTTP/1.1 và HTTP/2 qua TLS
 tcpSrv := &http.Server{
  Addr:    ":4433",   // Cổng TCP cho HTTPS
  Handler: mux,      // Sử dụng multiplexer đã định nghĩa ở trên
  TLSConfig: &tls.Config{
   MinVersion: tls.VersionTLS13, // HTTP/3 yêu cầu TLS 1.3; sử dụng giống nhau để so sánh
  },
 }
 // Chạy máy chủ TCP trong một goroutine để cho phép máy chủ HTTP/3 chạy đồng thời
 go func() {
  log.Println("Phục vụ HTTP/1.1 và HTTP/2 trên https://localhost:443")
  if err := tcpSrv.ListenAndServeTLS(certFile, keyFile); err != nil {
   log.Fatal(err)
  }
 }()
 // ----- HTTP/3 qua QUIC/UDP -----
 // Giải quyết địa chỉ UDP cho máy chủ QUIC (HTTP/3)
 udpAddr, err := net.ResolveUDPAddr("udp", ":4433") // HTTP/3 sử dụng UDP
 if err != nil {
  log.Fatal(err)
 }
 // Nghe trên cổng UDP
 udpConn, err := net.ListenUDP("udp", udpAddr)
 if err != nil {
  log.Fatal(err)
 }
 // Tạo máy chủ HTTP/3 sử dụng cùng một mux
 h3Srv := http3.Server{
  Addr:      ":4433",                     // Cổng cho QUIC
  Handler:   mux,                        // Cùng một trình xử lý cho HTTP/1.1, HTTP/2, HTTP/3
  TLSConfig: &tls.Config{Certificates: loadCert(certFile, keyFile)}, // TLS cho QUIC
 }
 // Bắt đầu máy chủ HTTP/3
 log.Println("Phục vụ HTTP/3 trên https://localhost:4433")
 if err := h3Srv.Serve(udpConn); err != nil {
  log.Fatal(err)
 }
}
// loadCert tải chứng chỉ TLS và khóa từ các file
// Trả về một slice tls.Certificate yêu cầu bởi http3.Server
func loadCert(certFile, keyFile string) []tls.Certificate {
 cert, err := tls.LoadX509KeyPair(certFile, keyFile)
 if err != nil {
  log.Fatal(err)
 }
 return []tls.Certificate{cert}
}

go run .

curl --http3-only -k https://localhost:4433/
curl --http2 -k https://localhost:4433/
curl --http1.1 -k https://localhost:4433/