Gong服務實作平滑重啟分析-有解無憂

平滑重啟是指能讓我們的程式在重啟的程序不中斷服務，新老行程無縫銜接，實作零停機時間(Zero-Downtime)部署；

平滑重啟是建立在優雅退出的基礎之上的，之前一篇文章介紹了相關實作：Golang中使用Shutdown特性對http服務進行優雅退出使用總結

目前實作平滑重啟的主要策略有兩種：

方案一：我們的服務如果是多機器部署，可以通過網關程式，將即將重啟服務的機器從網關下線，重啟完成后再重新上線，該方案適合多機器部署的企業級應用；

方案二：讓我們的程式實作自啟動，重啟子行程來實作平滑重啟，核心策略是通過拷貝檔案描述符實作子行程和父行程切換，適合單機器部署應用；

今天我們就主要介紹方案二，讓我們的程式擁有平滑重啟的功能，相關實作參考一個開源庫：https://github.com/fvbock/endless

實作原理介紹

http 連接介紹：

我們知道，http 服務也是基于 tcp 連接，我們通過 golang http 包原始碼也能看到底層是通過監聽 tcp 連接實作的；

func (srv *Server) ListenAndServe() error {
    if srv.shuttingDown() {
        return ErrServerClosed
    }
    addr := srv.Addr
    if addr == "" {
        addr = ":http"
    }
    ln, err := net.Listen("tcp", addr)
    if err != nil {
        return err
    }
    return srv.Serve(tcpKeepAliveListener{ln.(*net.TCPListener)})
}

復用 socket：

當程式開啟 tcp 連接監聽時會創建一個 socket 并回傳一個檔案描述符 handler 給我們的程式；

通過拷貝檔案描述符檔案可以使 socket 不關閉繼續使用原有的埠，自然 http 連接也不會斷開，啟動一個相同的行程也不會出現埠被占用的問題；

通過如下代碼進行測驗：

package main

import (
    "fmt"
    "net/http"
    "context"
    "time"
    "os"
    "os/signal"
    "syscall"
    "net"
    "flag"
    "os/exec"
)

var (
    graceful = flag.Bool("grace", false, "graceful restart flag")
    procType = ""
)

func main() {
    flag.Parse()
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {

        fmt.Fprintln(w, fmt.Sprintf("Hello world! ===> %s", procType))
    })
    server := &http.Server{
        Addr:         ":8080",
        Handler:      mux,

    }

    var err error
    var listener net.Listener
    if *graceful {
        f := os.NewFile(3, "")
        listener, err = net.FileListener(f)
        procType = "fork process"
    } else {
        listener, _ = net.Listen("tcp", server.Addr)
        procType = "main process"

        //主程式開啟5s 后 fork 子行程
        go func() {
            time.Sleep(5*time.Second)
            forkSocket(listener.(*net.TCPListener))
        }()

    }

    err=server.Serve(listener.(*net.TCPListener))

    fmt.Println(fmt.Sprintf("proc exit %v", err))
}


func forkSocket(tcpListener *net.TCPListener) error {
    f, err := tcpListener.File()
    if err != nil {
        return err
    }

    args := []string{"-grace"}
    fmt.Println(os.Args[0], args)
    cmd := exec.Command(os.Args[0], args...)
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    // put socket FD at the first entry
    cmd.ExtraFiles = []*os.File{f}
    return cmd.Start()
}

該程式啟動后，等待 5s 會自動 fork 子行程，通過 ps 命令查看如圖可以看到有兩個行程同時共存：

然后我們可以通過瀏覽器訪問 http://127.0.0.1/ 可以看到會隨機顯示主行程或子行程的輸出；

寫一個測驗代碼進行回圈請求：

package main

import (
    "net/http"
    "io/ioutil"
    "fmt"
    "sync"
)

func main(){

    wg:=sync.WaitGroup{}
    wg.Add(100)
    for i:=0; i<100; i++ {
        go func(index int) {
            result:=getUrl(fmt.Sprintf("http://127.0.0.1:8080?%d", i))
            fmt.Println(fmt.Sprintf("loop:%d %s", index, result))
            wg.Done()
        }(i)
    }
    wg.Wait()
}

func getUrl(url string) string{
    resp, _ := http.Get(url)
    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    return string(body)
}

能看到回傳的資料也是有些是主行程有些是子行程，

切換程序：

在開啟新的行程和老行程退出的瞬間，會有一個短暫的瞬間是同時有兩個行程使用同一個檔案描述符，此時這種狀態，通過http請求訪問，會隨機請求到新行程或老行程上，這樣也沒有問題，因為請求不是在新行程上就是在老行程上；當老行程結束后請求就會全部到新行程上進行處理，通過這種方式即可實作平滑重啟；

綜上，我們可以將核心的實作總結如下：

1.監聽退出信號；

2.監聽到信號后 fork 子行程，使用相同的命令啟動程式，將檔案描述符傳遞給子行程；

3.子行程啟動后，父行程停止服務并處理正在執行的任務（或超時）退出；

4.此時只有一個新的行程在運行，實作平滑重啟，

一個完整的 demo 代碼，通過發送 USR1 信號，程式會自動創建子行程并關閉主行程，實作平滑重啟：

package main

import (
    "fmt"
    "net/http"
    "context"
    "os"
    "os/signal"
    "syscall"
    "net"
    "flag"
    "os/exec"
)

var (
    graceful = flag.Bool("grace", false, "graceful restart flag")
)

func main() {
    flag.Parse()
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {

        fmt.Fprintln(w, "Hello world!")
    })
    server := &http.Server{
        Addr:         ":8080",
        Handler:      mux,

    }

    var err error
    var listener net.Listener
    if *graceful {
        f := os.NewFile(3, "")
        listener, err = net.FileListener(f)
    } else {
        listener, err = net.Listen("tcp", server.Addr)
    }
    if err != nil{
        fmt.Println(fmt.Sprintf("listener error %v", err))
        return
    }

    go listenSignal(context.Background(), server, listener)

    err=server.Serve(listener.(*net.TCPListener))
    fmt.Println(fmt.Sprintf("proc exit %v", err))
}


func forkSocket(tcpListener *net.TCPListener) error {
    f, err := tcpListener.File()
    if err != nil {
        return err
    }

    args := []string{"-grace"}
    fmt.Println(os.Args[0], args)
    cmd := exec.Command(os.Args[0], args...)
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    // put socket FD at the first entry
    cmd.ExtraFiles = []*os.File{f}
    return cmd.Start()
}




func listenSignal(ctx context.Context, httpSrv *http.Server, listener net.Listener) {
    sigs := make(chan os.Signal, 1)
    signal.Notify(sigs, syscall.USR1)


    select {
    case <-sigs:
        forkSocket(listener.(*net.TCPListener))
        httpSrv.Shutdown(ctx)
        fmt.Println("http shutdown")
    }
}

使用 apache 的 ab 壓測工具進行驗證一下，執行 ab -c 50 -t 20 http://127.0.0.1:8080/ 持續 50 的并發 20s，在壓測的期間向程式運行的pid發送 USR1 信號，可以看到壓測結果，沒有失敗的請求，由此可知，該方案實作平滑重啟是木有問題的，

最后給大家安利一個 Web 開發框架，該框架已經將平滑重啟進行的封裝，開箱即用，快速構建一個帶平滑重啟的 Web 服務，

框架原始碼：https://gitee.com/zhucheer/orange

檔案：https://www.kancloud.cn/chase688/orange_framework/1448035

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/38557.html

標籤：Go

上一篇：go實作java虛擬機01

下一篇：GO的方法值和方法運算式用法