平滑重启

与重载配置相同的是我们需要通过信号来通知server重启，但关键在于平滑重启，如果只是简单的重启，只需要kill掉，然后再拉起即可。

平滑重启意味着server升级的时候可以不用停止业务。

我们先来看下Github上有没有相应的库解决这个问题，然后找到了如下三个库：

• facebookgo/grace - Graceful restart & zero downtime deploy for Go servers.
• fvbock/endless - Zero downtime restarts for go servers (Drop in replacement for http.ListenAndServe)
• jpillora/overseer - Monitorable, gracefully restarting, self-upgrading binaries in Go (golang)

我们分别来学习一下，下面只讲解http server的重启。

使用方式

我们来分别使用这三个库来做平滑重启的事情，之后来对比其优缺点。

这三个库的官方都给了相应的例子，例子如下：

但三个库官方的例子不太一致，我们来统一一下：

• grace例子 https://github.com/facebookgo/grace/blob/master/gracedemo/demo.go
• endless例子 https://github.com/fvbock/endless/tree/master/examples
• overseer例子 https://github.com/jpillora/overseer/tree/master/example

我们参考官方的例子分别来写下用来对比的例子：

grace

package main

import (
    "time"
    "net/http"
    "github.com/facebookgo/grace/gracehttp"
)

func main() {
    gracehttp.Serve(
        &http.Server{Addr: ":5001", Handler: newGraceHandler()},
        &http.Server{Addr: ":5002", Handler: newGraceHandler()},
    )
}

func newGraceHandler() http.Handler {
    mux := http.NewServeMux()
    mux.HandleFunc("/sleep", func(w http.ResponseWriter, r *http.Request) {
        duration, err := time.ParseDuration(r.FormValue("duration"))
        if err != nil {
            http.Error(w, err.Error(), 400)
            return
        }
        time.Sleep(duration)
        w.Write([]byte("Hello World"))
    })
    return mux
}

endless

package main

import (
    "log"
    "net/http"
    "os"
    "sync"
    "time"

    "github.com/fvbock/endless"
    "github.com/gorilla/mux"
)

func handler(w http.ResponseWriter, r *http.Request) {
    duration, err := time.ParseDuration(r.FormValue("duration"))
    if err != nil {
        http.Error(w, err.Error(), 400)
        return
    }
    time.Sleep(duration)
    w.Write([]byte("Hello World"))
}

func main() {
    mux1 := mux.NewRouter()
    mux1.HandleFunc("/sleep", handler)

    w := sync.WaitGroup{}
    w.Add(2)
    go func() {
        err := endless.ListenAndServe(":5003", mux1)
        if err != nil {
            log.Println(err)
        }
        log.Println("Server on 5003 stopped")
        w.Done()
    }()
    go func() {
        err := endless.ListenAndServe(":5004", mux1)
        if err != nil {
            log.Println(err)
        }
        log.Println("Server on 5004 stopped")
        w.Done()
    }()
    w.Wait()
    log.Println("All servers stopped. Exiting.")

    os.Exit(0)
}

overseer

package main

import (
    "fmt"
    "net/http"
    "time"

    "github.com/jpillora/overseer"
)

//see example.sh for the use-case

// BuildID is compile-time variable
var BuildID = "0"

//convert your 'main()' into a 'prog(state)'
//'prog()' is run in a child process
func prog(state overseer.State) {
    fmt.Printf("app#%s (%s) listening...\n", BuildID, state.ID)
    http.Handle("/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        duration, err := time.ParseDuration(r.FormValue("duration"))
        if err != nil {
            http.Error(w, err.Error(), 400)
            return
        }
        time.Sleep(duration)
        w.Write([]byte("Hello World"))
        fmt.Fprintf(w, "app#%s (%s) says hello\n", BuildID, state.ID)
    }))
    http.Serve(state.Listener, nil)
    fmt.Printf("app#%s (%s) exiting...\n", BuildID, state.ID)
}

//then create another 'main' which runs the upgrades
//'main()' is run in the initial process
func main() {
    overseer.Run(overseer.Config{
        Program: prog,
        Addresses: []string{":5005", ":5006"},
        //Fetcher: &fetcher.File{Path: "my_app_next"},
        Debug:   false, //display log of overseer actions
    })
}

对比

对比示例的操作步骤

• 分别构建上面的示例，并记录pid
• 调用API，在其未返回时，修改内容(Hello World -> Hello Harry)，重新构建。查看旧API是否返回旧的内容
• 调用新API，查看返回的内容是否是新的内容
• 查看当前运行的pid，是否与之前一致

下面给一下操作命令

# 第一次构建项目
go build grace.go
# 运行项目，这时就可以做内容修改了
./grace &
# 请求项目，60s后返回
curl "http://127.0.0.1:5001/sleep?duration=60s" &
# 再次构建项目，这里是新内容
go build grace.go
# 重启，2096为pid
kill -USR2 2096
# 新API请求
curl "http://127.0.0.1:5001/sleep?duration=1s"


# 第一次构建项目
go build endless.go
# 运行项目，这时就可以做内容修改了
./endless &
# 请求项目，60s后返回
curl "http://127.0.0.1:5003/sleep?duration=60s" &
# 再次构建项目，这里是新内容
go build endless.go
# 重启，22072为pid
kill -1 22072
# 新API请求
curl "http://127.0.0.1:5003/sleep?duration=1s"


# 第一次构建项目
go build -ldflags '-X main.BuildID=1' overseer.go
# 运行项目，这时就可以做内容修改了
./overseer &
# 请求项目，60s后返回
curl "http://127.0.0.1:5005/sleep?duration=60s" &
# 再次构建项目，这里是新内容，注意版本号不同了
go build -ldflags '-X main.BuildID=2' overseer.go
# 重启，28300为主进程pid
kill -USR2 28300
# 新API请求
curl "http://127.0.0.1:5005/sleep?duration=1s"

对比结果

原理分析

可以看出grace和endless是比较像的。

• 监听信号
• 收到信号时fork子进程（使用相同的启动命令），将服务监听的socket文件描述符传递给子进程
• 子进程监听父进程的socket，这个时候父进程和子进程都可以接收请求
• 子进程启动成功之后，父进程停止接收新的连接，等待旧连接处理完成（或超时）
• 父进程退出，升级完成

overseer是与grace和endless有些不同，主要是两点：

1. overseer添加了Fetcher，当Fetcher返回有效的二进位流(io.Reader) 时，主进程会将它保存到临时位置并验证它，替换当前的二进制文件并启动。
   Fetcher运行在一个goroutine中，预先会配置好检查的间隔时间。Fetcher支持File、GitHub、HTTP和S3的方式。详细可查看包package fetcher
2. overseer添加了一个主进程管理平滑重启。子进程处理连接，能够保持主进程pid不变。

如下图表示的很形象