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/144