背景
如果我们的应用在kubernetes上我们可以通过滚动更新，每次只更新一部分副本实现服务的不停机更新发布，那如果我们的项目不依托于kubernetes想要达到这种效果该如何实现呢 ？
我们想要达到的效果：
- 不关闭现有连接（正在运行中的程序）
- 新的进程启动并替代旧进程
- 新的进程接管新的连接
- 连接要随时响应用户的请求，当用户仍在请求旧进程时要保持连接，新用户应请求新进程，不会出现拒绝请求的情况
方案
什么是信号？
在Linux中，信号其实就是软中断，用来通知进程发生了事件。进程之间可以通过调用kill库函数发送软中断信号。Linux内核也可能给进程发送信号，通知进程发生了某个事件（例如内存越界）。注意，信号只是用来通知某进程发生了什么事件，无法给进程传递任何数据。
进程对信号的处理方法有三种：
- 第一种方法是，忽略某个信号，对该信号不做任何处理，就象未发生过一样。
- 第二种是设置中断的处理函数，收到信号后，由该函数来处理。
- 第三种方法是，对该信号的处理采用系统的默认操作，大部分的信号的默认操作是终止进程。
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信号的相关解释
Signal Name | Number | Description | Signal Name | Number | Description |
SIGHUP | 1 | Hangup (POSIX) 终端控制进程结束(终端连接断开) | SIGSTKFLT | 16 | Stack fault |
SIGINT | 2 | Terminal interrupt (ANSI) | SIGCHLD | 17 | Child process has stopped or exited, changed (POSIX) |
SIGQUIT | 3 | Terminal quit (POSIX) | SIGCONT | 18 | Continue executing, if stopped (POSIX) |
SIGILL | 4 | Illegal instruction (ANSI) | SIGSTOP | 19 | Stop executing(can’t be caught or ignored) (POSIX) |
SIGTRAP | 5 | Trace trap (POSIX) | SIGTSTP | 20 | Terminal stop signal (POSIX) |
SIGIOT | 6 | IOT Trap (4.2 BSD) | SIGTTIN | 21 | Background process trying to read, from TTY (POSIX) |
SIGBUS | 7 | BUS error (4.2 BSD) | SIGTTOU | 22 | Background process trying to write, to TTY (POSIX) |
SIGFPE | 8 | Floating point exception (ANSI) | SIGURG | 23 | Urgent condition on socket (4.2 BSD) |
SIGKILL | 9 | Kill(can’t be caught or ignored) (POSIX) | SIGXCPU | 24 | CPU limit exceeded (4.2 BSD) |
SIGUSR1 | 10 | User defined signal 1 (POSIX) | SIGXFSZ | 25 | File size limit exceeded (4.2 BSD) |
SIGSEGV | 11 | Invalid memory segment access (ANSI) | SIGVTALRM | 26 | Virtual alarm clock (4.2 BSD) |
SIGUSR2 | 12 | User defined signal 2 (POSIX) | SIGPROF | 27 | Profiling alarm clock (4.2 BSD) |
SIGPIPE | 13 | Write on a pipe with no reader, Broken pipe (POSIX) | SIGWINCH | 28 | Window size change (4.3 BSD, Sun) |
SIGALRM | 14 | Alarm clock (POSIX) | SIGIO | 29 | I/O now possible (4.2 BSD) |
SIGTERM | 15 | Termination (ANSI) | SIGPWR | 30 | Power failure restart (System V) |
我们可以通过监听信号量的变化来实现关闭前的一些操作。一个可行的方案如下：
为了方便我们称旧应用为old server，需要更新的应用为new server
- old server 监听 SIGHUP 信号；
- old server 收到信号SIGHUP时 fork 子进程（使用相同的启动命令），将服务监听的 socket 文件描述符传递给子进程 new server；
- 子进程(new server)监听父进程(new server)的 socket，这个时候父进程和子进程都可以接收请求；
- 子进程启动成功之后发送 SIGTERM 信号给父进程，父进程停止接收新的连接，等待旧连接处理完成（或超时）；
- 父进程退出，此时只剩下子进程，丝滑升级完成；
编码
以下案例是比较粗糙的案例，如果是想生产环境使用建议参考文末的资料链接，有相关成熟的开源组件
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.go2.开启两个或者两个以上请求接口
curl localhost:8001/ok3.服务端打印信息显示我们的请求正在处理
当前进程号 67045
启动服务器
当前请求处理进程号 67045
67045 正在处理请求 0
67045 正在处理请求 1
67045 正在处理请求 2
67045 正在处理请求 3
67045 正在处理请求 4
67045 正在处理请求 5
67045 正在处理请求 6
67045 正在处理请求 73.发送信号结束进程
kill -1 670454.查看控制台，发现我们的服务还在进行中，并未立即结束
67045 正在处理请求 10
67045 正在处理请求 9
67045 正在处理请求 11
收到退出信号 hangup
pid = 67045
当前子进程号 67055
当前进程号 67055
当前是子进程，需要kill掉父进程 67045
启动服务器
收到退出信号 terminated
等待服务处理完成或超时 67045
67045 正在处理请求 10
67045 正在处理请求 125.查看进程，发现开启了两个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