独立部署
由于 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 应用平滑更新的思路：
- 用新的可执行文件替换旧的可执行文件（如只需优雅重启，可以跳过这一步）
- 通过 pid 给正在运行的旧进程发送特定的信号（kill -SIGUSR2 $pid）
- 正在运行的旧进程，接收到指定的信号后，以子进程的方式启动新的可执行文件并开始处理新请求
- 旧进程不再接受新的请求，等待未完成的服务处理完毕，然后正常结束
- 新进程在父进程退出后，会被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()
}
