大家好，欢迎来到IT知识分享网。

背景

如果我们的应用在kubernetes上我们可以通过滚动更新，每次只更新一部分副本实现服务的不停机更新发布，那如果我们的项目不依托于kubernetes想要达到这种效果该如何实现呢 ？

我们想要达到的效果：

0. 不关闭现有连接（正在运行中的程序）
1. 新的进程启动并替代旧进程
2. 新的进程接管新的连接
3. 连接要随时响应用户的请求，当用户仍在请求旧进程时要保持连接，新用户应请求新进程，不会出现拒绝请求的情况

方案

什么是信号？

在Linux中，信号其实就是软中断，用来通知进程发生了事件。进程之间可以通过调用kill库函数发送软中断信号。Linux内核也可能给进程发送信号，通知进程发生了某个事件（例如内存越界）。注意，信号只是用来通知某进程发生了什么事件，无法给进程传递任何数据。

进程对信号的处理方法有三种：

0. 第一种方法是，忽略某个信号，对该信号不做任何处理，就象未发生过一样。
1. 第二种是设置中断的处理函数，收到信号后，由该函数来处理。
2. 第三种方法是，对该信号的处理采用系统的默认操作，大部分的信号的默认操作是终止进程。

kill -l 1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM 16) SIGSTKFLT 17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP 21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ 26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO 30) SIGPWR 31) SIGSYS 34) SIGRTMIN 35) SIGRTMIN+1 36) SIGRTMIN+2 37) SIGRTMIN+3 38) SIGRTMIN+4 39) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8 43) SIGRTMIN+9 44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13 48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7 58) SIGRTMAX-6 59) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2 63) SIGRTMAX-1 64) SIGRTMAX

信号的相关解释

我们可以通过监听信号量的变化来实现关闭前的一些操作。一个可行的方案如下：

为了方便我们称旧应用为old server，需要更新的应用为new server

0. old server 监听 SIGHUP 信号；
1. old server 收到信号SIGHUP时 fork 子进程（使用相同的启动命令），将服务监听的 socket 文件描述符传递给子进程 new server；
2. 子进程(new server)监听父进程(new server)的 socket，这个时候父进程和子进程都可以接收请求；
3. 子进程启动成功之后发送 SIGTERM 信号给父进程，父进程停止接收新的连接，等待旧连接处理完成（或超时）；
4. 父进程退出，此时只剩下子进程，丝滑升级完成；

编码

以下案例是比较粗糙的案例，如果是想生产环境使用建议参考文末的资料链接，有相关成熟的开源组件

package main import ( "fmt" "io" "net" "net/http" "os" "os/exec" "os/signal" "sync" "syscall" "time" ) type Server struct { http.Server //http服务器 net.Listener //监听端口 isChild bool //当前服务器是否是子进程 wg sync.WaitGroup //还剩多少请求待处理 } var srvMap = make(map[int]*Server) func main() { c := make(chan os.Signal) //监听信号 signal.Notify(c, syscall.SIGHUP, syscall.SIGTERM) pid:=syscall.Getpid() fmt.Println("当前进程号",pid) go func() { for { s := <-c fmt.Println("收到退出信号", s) switch s { case syscall.SIGHUP: fork() case syscall.SIGTERM: down() } } }() http.HandleFunc("/ok", ok) addr := "localhost:8001" server := &Server{ Server: http.Server{Addr: addr, Handler: nil}, wg: sync.WaitGroup{}, isChild: os.Getenv("CHILD") != "", } listen, err := server.listener(addr) if err != nil { fmt.Println(err) } server.Listener = listen if server.isChild { fmt.Println("当前是子进程，需要kill掉父进程", syscall.Getppid()) err := syscall.Kill(syscall.Getppid(), syscall.SIGTERM) if err != nil { fmt.Println("kill父进程失败", err) } } srvMap[pid] = server fmt.Println("启动服务器") err = server.Serve(listen) if err != nil { fmt.Println(err) } } func down() { pid:=syscall.Getpid() fmt.Println("等待服务处理完成或超时", pid) server:=srvMap[pid] server.wg.Wait() fmt.Println("所有请求完成关闭服务器", pid) server.Listener.Close() delete(srvMap,pid) os.Exit(0) } func fork() { //检查是否已经fork过了 path := os.Args[0] var args []string if len(os.Args) > 1 { args = os.Args[1:] } cmd := exec.Command(path, args...) cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr cmd.Env = append( os.Environ(), "CHILD=1", ) //接管父进程的fd pid := syscall.Getpid() fmt.Println("pid = ",pid) server := srvMap[pid] cmd.ExtraFiles = []*os.File{server.File()} err := cmd.Start() if err != nil { fmt.Println("fork进程失败", err) } fmt.Println("当前子进程号", cmd.Process.Pid) } // File 获取当前server的fd，因为我们无法多个进程同时监听一个端口，但是通过子进程的方式 func (srv *Server) File() *os.File { tl := srv.Listener.(*net.TCPListener) fl, _ := tl.File() return fl } // listener 获取监听器 func (srv *Server) listener(addr string) (ln net.Listener, err error) { if srv.isChild { //如果是子进程 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 } func ok(w http.ResponseWriter, _ *http.Request) { pid := syscall.Getpid() server:=srvMap[pid] defer server.wg.Done() fmt.Println("当前请求处理进程号", pid) server.wg.Add(1) for i := 0; i < 30; i++ { time.Sleep(time.Second) fmt.Println(pid, " 正在处理请求 ", i) } io.WriteString(w, "ok\n") }

实践

1.启动服务

go run server.go

2.开启两个或者两个以上请求接口

curl localhost:8001/ok

3.服务端打印信息显示我们的请求正在处理

当前进程号 67045 启动服务器 当前请求处理进程号 67045 67045 正在处理请求 0 67045 正在处理请求 1 67045 正在处理请求 2 67045 正在处理请求 3 67045 正在处理请求 4 67045 正在处理请求 5 67045 正在处理请求 6 67045 正在处理请求 7

3.发送信号结束进程

kill -1 67045

4.查看控制台，发现我们的服务还在进行中，并未立即结束

67045 正在处理请求 10 67045 正在处理请求 9 67045 正在处理请求 11 收到退出信号 hangup pid = 67045 当前子进程号 67055 当前进程号 67055 当前是子进程，需要kill掉父进程 67045 启动服务器 收到退出信号 terminated 等待服务处理完成或超时 67045 67045 正在处理请求 10 67045 正在处理请求 12

5.查看进程，发现开启了两个server进程（一个是子进程），当请求执行完父进程退出，只剩下子进程

mikey@mikeydeMacBook-Pro demo % ps -ef|grep server 55 474 1 0 17Nov22 ?? 0:02.26 /System/Library/CoreServices/appleeventsd --server 0 1068 1 0 17Nov22 ?? 0:00.05 /System/Library/CoreServices/CrashReporterSupportHelper server-init 0 1092 1 0 17Nov22 ?? 0:00.59 /System/Library/CoreServices/SubmitDiagInfo server-init 0 1182 1 0 17Nov22 ?? 0:00.03 /System/Library/CoreServices/osanalyticshelper server-init 0 66730 1 0 3:53PM ?? 0:00.09 /usr/sbin/systemsoundserverd 501 67059 66776 0 3:56PM ttys000 0:00.00 grep server 501 67045 62588 0 3:56PM ttys001 0:00.02 ./server 501 67055 67045 0 3:56PM ttys001 0:00.01 ./server mikey@mikeydeMacBook-Pro demo % ps -ef|grep server 55 474 1 0 17Nov22 ?? 0:02.26 /System/Library/CoreServices/appleeventsd --server 0 1068 1 0 17Nov22 ?? 0:00.05 /System/Library/CoreServices/CrashReporterSupportHelper server-init 0 1092 1 0 17Nov22 ?? 0:00.59 /System/Library/CoreServices/SubmitDiagInfo server-init 0 1182 1 0 17Nov22 ?? 0:00.03 /System/Library/CoreServices/osanalyticshelper server-init 0 66730 1 0 3:53PM ?? 0:00.09 /usr/sbin/systemsoundserverd 501 67063 66776 0 3:56PM ttys000 0:00.00 grep server 501 67055 1 0 3:56PM ttys001 0:00.01 ./server mikey@mikeydeMacBook-Pro demo % 

资料

https://github.com/fvbock/endless