description
HTTP2与HTTP3的支持

绝大部分的浏览器都已支持http2，后端支持http2仅需要更新nginx版本，调整配置则可。golang的http模块已支持http2的处理，下面主要介绍如何使用Elton支持http2。

生成证书

浏览器只支持通过https方式使用http2，为了开发方便，可以生成开发环境使用的证书，mkcert仅需几条命令则可生成多域名证书。

  1. // 生成证书
  2. mkcert me.dev localhost 127.0.0.1 ::1
  3. // 安装证书
  4. mkcert -install

启动服务

因为golang本身http模块已支持http2，则只需要以https的方式启动服务则可。

  1. package main
  3. import (
  4.     "bytes"
  6.     "github.com/vicanso/elton"
  7. )
  9. func main() {
  10.     e := elton.New()
  11.     e.GET("/", func(c *elton.Context) error {
  12.         c.BodyBuffer = bytes.NewBufferString("Hello, World!")
  13.         return nil
  14.     })
  16.     certFile := "/tmp/me.dev+3.pem"
  17.     keyFile := "/tmp/me.dev+3-key.pem"
  18.     err := e.ListenAndServeTLS(":3000", certFile, keyFile)
  19.     if err != nil {
  20.         panic(err)
  21.     }
  22. }

上面例子中证书是以文件的形式保存，实际使用时证书都统一存储，加密访问（如保存在数据库等），下面的例子讲解如果使用[]byte来初始化TLS：

  1. package main
  3. import (
  4.     "bytes"
  5.     "crypto/tls"
  6.     "io/ioutil"
  8.     "github.com/vicanso/elton"
  9. )
  11. // 获取证书内容
  12. func getCert() (cert []byte, key []byte, err error) {
  13.     // 此处仅简单从文件中读取，在实际使用，是从数据库中读取
  14.     cert, err = ioutil.ReadFile("/tmp/me.dev+3.pem")
  15.     if err != nil {
  16.         return
  17.     }
  18.     key, err = ioutil.ReadFile("/tmp/me.dev+3-key.pem")
  19.     if err != nil {
  20.         return
  21.     }
  22.     return
  23. }
  25. func main() {
  26.     e := elton.New()
  27.     cert, key, err := getCert()
  28.     if err != nil {
  29.         panic(err)
  30.     }
  31.     // 先初始化tls配置，生成证书
  32.     tlsConfig := &tls.Config{}
  33.     tlsConfig.Certificates = make([]tls.Certificate, 1)
  34.     tlsConfig.Certificates[0], err = tls.X509KeyPair(cert, key)
  35.     if err != nil {
  36.         panic(err)
  37.     }
  38.     e.Server.TLSConfig = tlsConfig
  40.     e.GET("/", func(c *elton.Context) error {
  41.         c.BodyBuffer = bytes.NewBufferString("hello world!")
  42.         return nil
  43.     })
  45.     err = e.ListenAndServeTLS(":3000", "", "")
  46.     if err != nil {
  47.         panic(err)
  48.     }
  49. }

h2c

golang默认的HTTP2需要在以https的方式提供，对于内部系统间的调用，如果希望以http的方式使用http2，那么可以考虑h2c的处理。下面的代码示例包括了服务端与客户端怎么使用以http的方式使用http2。

  1. package main
  3. import (
  4.     "crypto/tls"
  5.     "fmt"
  6.     "net"
  7.     "net/http"
  8.     "time"
  10.     "github.com/vicanso/elton"
  11.     "github.com/vicanso/elton/middleware"
  12.     "golang.org/x/net/http2"
  13.     "golang.org/x/net/http2/h2c"
  14. )
  16. var http2Client = &http.Client{
  17.     // 强制使用http2
  18.     Transport: &http2.Transport{
  19.         // 允许使用http的方式
  20.         AllowHTTP: true,
  21.         // tls的dial覆盖
  22.         DialTLS: func(network, addr string, cfg *tls.Config) (net.Conn, error) {
  23.             return net.Dial(network, addr)
  24.         },
  25.     },
  26. }
  28. func main() {
  29.     go func() {
  30.         time.Sleep(time.Second)
  31.         resp, err := http2Client.Get("http://127.0.0.1:3000/")
  32.         if err != nil {
  33.             panic(err)
  34.         }
  35.         fmt.Println(resp.Proto)
  36.     }()
  38.     e := elton.New()
  40.     e.Use(middleware.NewDefaultResponder())
  42.     e.GET("/", func(c *elton.Context) error {
  43.         c.Body = "Hello, World!"
  44.         return nil
  45.     })
  46.     // http1与http2均支持
  47.     e.Server = &http.Server{
  48.         Handler: h2c.NewHandler(e, &http2.Server{}),
  49.     }
  51.     err := e.ListenAndServe(":3000")
  52.     if err != nil {
  53.         panic(err)
  54.     }
  55. }
  1. curl -v --http2-prior-knowledge http://127.0.0.1:3000/
  2. *   Trying 127.0.0.1...
  3. * TCP_NODELAY set
  4. * Connected to 127.0.0.1 (127.0.0.1) port 3000 (#0)
  5. * Using HTTP2, server supports multi-use
  6. * Connection state changed (HTTP/2 confirmed)
  7. * Copying HTTP/2 data in stream buffer to connection buffer after upgrade: len=0
  8. * Using Stream ID: 1 (easy handle 0x7f8d9a804600)
  9. > GET / HTTP/2
  10. > Host: 127.0.0.1:3000
  11. > User-Agent: curl/7.54.0
  12. > Accept: */*
  13. >
  14. * Connection state changed (MAX_CONCURRENT_STREAMS updated)!
  15. < HTTP/2 200

http3

http3现在支持的浏览器只有chrome canary以及firefox最新版本，golang的http模块也未支持http3，http3的前景虽然并不确定，但是还是可以先尝尝鲜，需要注意http3还是试验性质，不要在正式环境中大规模使用。下面是使用quic-go使用http3的示例：

  1. package main
  3. import (
  4.     "bytes"
  5.     "crypto/tls"
  6.     "io/ioutil"
  7.     "log"
  8.     "net/http"
  9.     "time"
  11.     "github.com/lucas-clemente/quic-go/http3"
  12.     "github.com/vicanso/elton"
  13. )
  15. const listenAddr = ":4000"
  17. // 获取证书内容
  18. func getCert() (cert []byte, key []byte, err error) {
  19.     // 此处仅简单从文件中读取，在实际使用，是从数据库中读取
  20.     cert, err = ioutil.ReadFile("/tmp/me.dev+3.pem")
  21.     if err != nil {
  22.         return
  23.     }
  24.     key, err = ioutil.ReadFile("/tmp/me.dev+3-key.pem")
  25.     if err != nil {
  26.         return
  27.     }
  28.     return
  29. }
  31. func http3Get() {
  32.     client := &http.Client{
  33.         Transport: &http3.RoundTripper{},
  34.     }
  35.     resp, err := client.Get("https://127.0.0.1" + listenAddr + "/")
  36.     if err != nil {
  37.         log.Fatalln("http3 get fail ", err)
  38.         return
  39.     }
  40.     log.Println("http3 get success", resp.Proto, resp.Status, resp.Header)
  41. }
  43. func main() {
  44.     // 延时一秒后以http3的访问访问
  45.     go func() {
  46.         time.Sleep(time.Second)
  47.         http3Get()
  48.     }()
  50.     e := elton.New()
  52.     cert, key, err := getCert()
  53.     if err != nil {
  54.         panic(err)
  55.     }
  56.     // 先初始化tls配置，生成证书
  57.     tlsConfig := &tls.Config{}
  58.     tlsConfig.Certificates = make([]tls.Certificate, 1)
  59.     tlsConfig.Certificates[0], err = tls.X509KeyPair(cert, key)
  60.     if err != nil {
  61.         panic(err)
  62.     }
  63.     e.Server.TLSConfig = tlsConfig.Clone()
  65.     // 初始化http3服务
  66.     http3Server := http3.Server{
  67.         Server: &http.Server{
  68.             Handler: e,
  69.             Addr:    listenAddr,
  70.         },
  71.     }
  72.     http3Server.TLSConfig = tlsConfig.Clone()
  74.     e.Use(func(c *elton.Context) error {
  75.         http3Server.SetQuicHeaders(c.Header())
  76.         return c.Next()
  77.     })
  79.     e.GET("/", func(c *elton.Context) error {
  80.         c.BodyBuffer = bytes.NewBufferString("hello " + c.Request.Proto + "!")
  81.         return nil
  82.     })
  84.     go func() {
  85.         // http3
  86.         err := http3Server.ListenAndServe()
  87.         if err != nil {
  88.             panic(err)
  89.         }
  90.     }()
  92.     // https
  93.     err = e.ListenAndServeTLS(listenAddr, "", "")
  94.     if err != nil {
  95.         panic(err)
  96.     }
  97. }

curl可以自己编译支持http3的版本，编译方法可参考curl http3，下面是使用curl的调用示例：

  1. curl3 --http3 'https://me.dev:4000/' -v
  2. *   Trying 127.0.0.1:4000...
  3. * Sent QUIC client Initial, ALPN: h3-24h3-23
  4. * h3 [:method: GET]
  5. * h3 [:path: /]
  6. * h3 [:scheme: https]
  7. * h3 [:authority: me.dev:4000]
  8. * h3 [user-agent: curl/7.68.0-DEV]
  9. * h3 [accept: */*]
  10. * Using HTTP/3 Stream ID: 0 (easy handle 0x7fad4f011e00)
  11. > GET / HTTP/3
  12. > Host: me.dev:4000
  13. > user-agent: curl/7.68.0-DEV
  14. > accept: */*
  15. >
  16. < HTTP/3 200
  17. < content-length: 13
  18. < alt-srv: h3-24=":4000"; ma=86400
  19. <
  20. * Connection #0 to host me.dev left intact
  21. hello HTTP/3!