記一次http超時引發的事故

前言

我們使用的是golang標準庫的http client,對於一些http請求,我們在處理的時候,會考慮加上超時時間,防止http請求一直在請求,導致業務長時間阻塞等待。

最近同事寫了一個超時的元件,這幾天訪問量上來了,網路也出現了波動,造成了介面在報錯超時的情況下,還是出現了請求結果的成功。

分析下具體的程式碼實現

  1. type request struct {
  2. method string
  3. url string
  4. value string
  5. ps *params
  6. }
  7. type params struct {
  8. timeout int //超時時間
  9. retry int //重試次數
  10. headers map[string]string
  11. contentType string
  12. }
  13. func (req *request) Do(result interface{}) ([]byte, error) {
  14. res, err := asyncCall(doRequest, req)
  15. if err != nil {
  16. return nil, err
  17. }
  18. if result == nil {
  19. return res, nil
  20. }
  21. switch req.ps.contentType {
  22. case "application/xml":
  23. if err := xml.Unmarshal(res, result); err != nil {
  24. return nil, err
  25. }
  26. default:
  27. if err := json.Unmarshal(res, result); err != nil {
  28. return nil, err
  29. }
  30. }
  31. return res, nil
  32. }
  33. type timeout struct {
  34. data []byte
  35. err error
  36. }
  37. func doRequest(request *request) ([]byte, error) {
  38. var (
  39. req *http.Request
  40. errReq error
  41. )
  42. if request.value != "null" {
  43. buf := strings.NewReader(request.value)
  44. req, errReq = http.NewRequest(request.method, request.url, buf)
  45. if errReq != nil {
  46. return nil, errReq
  47. }
  48. } else {
  49. req, errReq = http.NewRequest(request.method, request.url, nil)
  50. if errReq != nil {
  51. return nil, errReq
  52. }
  53. }
  54. // 這裡的client沒有設定超時時間
  55. // 所以當下面檢測到一次超時的時候,會重新又發起一次請求
  56. // 但是老的請求其實沒有被關閉,一直在執行
  57. client := http.Client{}
  58. res, err := client.Do(req)
  59. ...
  60. }
  61. // 重試呼叫請求
  62. // 當超時的時候發起一次新的請求
  63. func asyncCall(f func(request *request) ([]byte, error), req *request) ([]byte, error) {
  64. p := req.ps
  65. ctx := context.Background()
  66. done := make(chan *timeout, 1)
  67. for i := 0; i < p.retry; i++ {
  68. go func(ctx context.Context) {
  69. // 傳送HTTP請求
  70. res, err := f(req)
  71. done <- &timeout{
  72. data: res,
  73. err: err,
  74. }
  75. }(ctx)
  76. // 錯誤主要在這裡
  77. // 如果超時重試為3,第一次超時了,馬上又發起了一次新的請求,但是這裡錯誤使用了超時的退出
  78. // 具體看上面
  79. select {
  80. case res := <-done:
  81. return res.data, res.err
  82. case <-time.After(time.Duration(p.timeout) * time.Millisecond):
  83. }
  84. }
  85. return nil, ecode.TimeoutErr
  86. }

錯誤的原因

1、超時重試,之後過了一段時間沒有拿到結果就認為是超時了,但是http請求沒有被關閉;

2、錯誤使用了http的超時,具體的做法要通過contexthttp.client去實現,見下文;

修改之後的程式碼

  1. func doRequest(request *request) ([]byte, error) {
  2. var (
  3. req *http.Request
  4. errReq error
  5. )
  6. if request.value != "null" {
  7. buf := strings.NewReader(request.value)
  8. req, errReq = http.NewRequest(request.method, request.url, buf)
  9. if errReq != nil {
  10. return nil, errReq
  11. }
  12. } else {
  13. req, errReq = http.NewRequest(request.method, request.url, nil)
  14. if errReq != nil {
  15. return nil, errReq
  16. }
  17. }
  18. // 這裡通過http.Client設定超時時間
  19. client := http.Client{
  20. Timeout: time.Duration(request.ps.timeout) * time.Millisecond,
  21. }
  22. res, err := client.Do(req)
  23. ...
  24. }
  25. func asyncCall(f func(request *request) ([]byte, error), req *request) ([]byte, error) {
  26. p := req.ps
  27. // 重試的時候只有上一個http請求真的超時了,之後才會發起一次新的請求
  28. for i := 0; i < p.retry; i++ {
  29. // 傳送HTTP請求
  30. res, err := f(req)
  31. // 判斷超時
  32. if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
  33. continue
  34. }
  35. return res, err
  36. }
  37. return nil, ecode.TimeoutErr
  38. }

服務設定超時

http.Server有兩個設定超時的方法:

  • ReadTimeout

ReadTimeout的時間計算是從連線被接受(accept)到request body完全被讀取(如果你不讀取body,那麼時間截止到讀完header為止)

  • WriteTimeout

WriteTimeout的時間計算正常是從request header的讀取結束開始,到response write結束為止 (也就是ServeHTTP方法的生命週期)

  1. srv := &http.Server{
  2. ReadTimeout: 5 * time.Second,
  3. WriteTimeout: 10 * time.Second,
  4. }
  5. srv.ListenAndServe()

net/http包還提供了TimeoutHandler返回了一個在給定的時間限制內執行的handler

  1. func TimeoutHandler(h Handler, dt time.Duration, msg string) Handler

第一個引數是Handler,第二個引數是time.Duration(超時時間),第三個引數是string型別,當到達超時時間後返回的資訊

  1. func handler(w http.ResponseWriter, r *http.Request) {
  2. time.Sleep(3 * time.Second)
  3. fmt.Println("測試超時")
  4. w.Write([]byte("hello world"))
  5. }
  6. func server() {
  7. srv := http.Server{
  8. Addr: ":8081",
  9. WriteTimeout: 1 * time.Second,
  10. Handler: http.TimeoutHandler(http.HandlerFunc(handler), 5*time.Second, "Timeout!\n"),
  11. }
  12. if err := srv.ListenAndServe(); err != nil {
  13. os.Exit(1)
  14. }
  15. }

客戶端設定超時

http.client

最簡單的我們通過http.ClientTimeout欄位,就可以實現客戶端的超時控制

http.client超時是超時的高層實現,包含了從DialResponse Body的整個請求流程。http.client的實現提供了一個結構體型別可以接受一個額外的time.Duration型別的Timeout屬性。這個引數定義了從請求開始到響應訊息體被完全接收的時間限制。

  1. func httpClientTimeout() {
  2. c := &http.Client{
  3. Timeout: 3 * time.Second,
  4. }
  5. resp, err := c.Get("http://127.0.0.1:8081/test")
  6. fmt.Println(resp)
  7. fmt.Println(err)
  8. }

context

net/http中的request實現了context,所以我們可以藉助於context本身的超時機制,實現httprequest的超時處理

  1. func contextTimeout() {
  2. ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
  3. defer cancel()
  4. req, err := http.NewRequest("GET", "http://127.0.0.1:8081/test", nil)
  5. if err != nil {
  6. log.Fatal(err)
  7. }
  8. resp, err := http.DefaultClient.Do(req.WithContext(ctx))
  9. fmt.Println(resp)
  10. fmt.Println(err)
  11. }

使用context的優點就是,當父context被取消時,子context就會層層退出。

http.Transport

通過Transport還可以進行一些更小維度的超時設定

  • net.Dialer.Timeout 限制建立TCP連線的時間

  • http.Transport.TLSHandshakeTimeout 限制 TLS握手的時間

  • http.Transport.ResponseHeaderTimeout 限制讀取response header的時間

  • http.Transport.ExpectContinueTimeout 限制client在傳送包含 Expect: 100-continue的header到收到繼續傳送body的response之間的時間等待。注意在1.6中設定這個值會禁用HTTP/2(DefaultTransport自1.6.2起是個特例)

  1. func transportTimeout() {
  2. transport := &http.Transport{
  3. DialContext: (&net.Dialer{}).DialContext,
  4. ResponseHeaderTimeout: 3 * time.Second,
  5. }
  6. c := http.Client{Transport: transport}
  7. resp, err := c.Get("http://127.0.0.1:8081/test")
  8. fmt.Println(resp)
  9. fmt.Println(err)
  10. }

問題

如果在客戶端在超時的臨界點,觸發了超時機制,這時候服務端剛好也接收到了,http的請求

這種服務端還是可以拿到請求的資料,所以對於超時時間的設定我們需要根據實際情況進行權衡,同時我們要考慮介面的冪等性。

總結

1、所有的超時實現都是基於DeadlineDeadline是一個時間的絕對值,一旦設定他們永久生效,不管此時連線是否被使用和怎麼用,所以需要每手動設定,所以如果想使用SetDeadline建立超時機制,需要每次在Read/Write操作之前呼叫它。

2、使用context進行超時控制的好處就是,當父context超時的時候,子context就會層層退出。

參考

【[譯]Go net/http 超時機制完全手冊】https://colobu.com/2016/07/01/the-complete-guide-to-golang-net-http-timeouts/

【Go 語言 HTTP 請求超時入門】https://studygolang.com/articles/14405

【使用 timeout、deadline 和 context 取消引數使 Go net/http 服務更靈活】https://jishuin.proginn.com/p/763bfbd2fb6a