Go 应用部署与平滑更新(优雅重启)

独立部署

由于 Go 语言已经实现了 HTTP 服务器，所以我们可以直接编译 Go 应用，并将应用运行在 Linux 系统的守护进程中。

cd $GOPATH/src/app
go build app.go
nohup ./app &

Nginx 部署

虽然 Go 语言已经实现了 HTTP 服务器，但是 Nginx 实现了功能丰富的 Web Server，我们可以借助其完成很多工作，而不必自己再重复实现一遍。
Nginx Web Server 优势：

• 静态文件服务
• 反向代理
• 负载均衡

nginx.conf 配置

server {
    listen       80;
    server_name  localhost;

    charset utf-8;
    access_log  "/path/to/log"; // Go 应用日志路径

    location /(css|js|fonts|img)/ {
        access_log off;
        expires 1d;

        root "/path/to/app/static"; // Go 应用静态文件路径
        try_files $uri @backend;
    }

    location / {
        try_files /_not_exists_ @backend;
    }

    location @backend {
        proxy_set_header X-Forwarded-For $remote_addr;
        proxy_set_header Host            $http_host;

        proxy_pass http://127.0.0.1:8080; // Go 应用监听端口
    }
}

平滑升级

因为 Go 是编译型语言，修改代码后需要重新编译可执行文件，并重新启动程序。对于面向外部的应用，重启的过程中用户无法访问应用，对应用体验造成负面影响。
Go 应用平滑更新的思路：

1. 用新的可执行文件替换旧的可执行文件（如只需优雅重启，可以跳过这一步）
2. 通过 pid 给正在运行的旧进程发送特定的信号（kill -SIGUSR2 $pid）
3. 正在运行的旧进程，接收到指定的信号后，以子进程的方式启动新的可执行文件并开始处理新请求
4. 旧进程不再接受新的请求，等待未完成的服务处理完毕，然后正常结束
5. 新进程在父进程退出后，会被init进程领养，并继续提供服务

监听信号

signalChan := make(chan os.Signal)

signal.Notify (
    signalChan,
    syscall.SIGHUP,
    syscall.SIGUSR2,
)

for {
    sig := <-signalChan:
}

启动子进程

如果某个运行中的程序已经监听某个端口，其他程序是无法再去监听这个端口的。解决的办法是使用子进程的方式启动，并将监听端口的文件描述符传递给子进程，子进程里从这个文件描述符实现对端口的监听。同时，需要维护一个环境变量来区分应用的启动方式（正常启动/子进程启动）。

func (this *Server) startNewProcess() error {
    listenerFd, err := this.listener.(*Listener).GetFd()
    if err != nil {
        return fmt.Errorf("failed to get socket file descriptor: %v", err)
    }
 
    path := os.Args[0]
 
    environList := []string{}
    for _, value := range os.Environ() {
        if value != GRACEFUL_ENVIRON_STRING {
            environList = append(environList, value)
        }
    }
    environList = append(environList, GRACEFUL_ENVIRON_STRING)
 
    execSpec := &syscall.ProcAttr{
        Env:   environList,
        Files: []uintptr{os.Stdin.Fd(), os.Stdout.Fd(), os.Stderr.Fd(), listenerFd},
    }
 
    fork, err := syscall.ForkExec(path, os.Args, execSpec)
    if err != nil {
        return fmt.Errorf("failed to forkexec: %v", err)
    }
 
    this.logf("start new process success, pid %d.", fork)
 
    return nil
}
 
func (this *Server) getNetTCPListener(addr string) (*net.TCPListener, error) {
    var ln net.Listener
    var err error
 
    if this.isGraceful {
        file := os.NewFile(3, "")
        ln, err = net.FileListener(file)
        if err != nil {
            err = fmt.Errorf("net.FileListener error: %v", err)
            return nil, err
        }
    } else {
        ln, err = net.Listen("tcp", addr)
        if err != nil {
            err = fmt.Errorf("net.Listen error: %v", err)
            return nil, err
        }
    }
    return ln.(*net.TCPListener), nil
}

父进程完成服务后退出

我们需要维护一个服务连接计数器，在成功 Accept 一个连接时计数器加1，在连接关闭时计数减1，计数器为0时则父进程可以正常退出了。Go 的 sync 包里的 WaitGroup 可以很好地实现这个功能。

type Listener struct {
    *net.TCPListener
 
    waitGroup *sync.WaitGroup
}
 
func (this *Listener) Accept() (net.Conn, error) {
 
    tc, err := this.AcceptTCP()
    if err != nil {
        return nil, err
    }
    tc.SetKeepAlive(true)
    tc.SetKeepAlivePeriod(3 * time.Minute)
 
    this.waitGroup.Add(1)
 
    conn := &Connection{
        Conn:     tc,
        listener: this,
    }
    return conn, nil
}
 
func (this *Listener) Wait() {
    this.waitGroup.Wait()
}
 
type Connection struct {
    net.Conn
    listener *Listener
 
    closed bool
}
 
func (this *Connection) Close() error {
 
    if !this.closed {
        this.closed = true
        this.listener.waitGroup.Done()
    }
 
    return this.Conn.Close()
}

参考：
github.com/tabalt/gracehttp