如何优雅地关闭和更新Golang服务?

发表时间: 2022-11-25 17:08


背景

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

我们想要达到的效果:

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

方案

什么是信号?

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

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

  1. 第一种方法是,忽略某个信号,对该信号不做任何处理,就象未发生过一样。
  2. 第二种是设置中断的处理函数,收到信号后,由该函数来处理。
  3. 第三种方法是,对该信号的处理采用系统的默认操作,大部分的信号的默认操作是终止进程。
kill -l 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP 6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR111) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM16) SIGSTKFLT   17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP21) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ26) SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGIO       30) SIGPWR31) SIGSYS      34) SIGRTMIN    35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+338) SIGRTMIN+4  39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+843) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+1348) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-1253) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-758) SIGRTMAX-6  59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-263) 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

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

编码

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

package mainimport (  "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启动服务器当前请求处理进程号 6704567045  正在处理请求  067045  正在处理请求  167045  正在处理请求  267045  正在处理请求  367045  正在处理请求  467045  正在处理请求  567045  正在处理请求  667045  正在处理请求  7

3.发送信号结束进程

kill -1 67045

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

67045  正在处理请求  1067045  正在处理请求  967045  正在处理请求  11收到退出信号 hanguppid =  67045当前子进程号 67055当前进程号 67055当前是子进程,需要kill掉父进程 67045启动服务器收到退出信号 terminated等待服务处理完成或超时 6704567045  正在处理请求  1067045  正在处理请求  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 ./servermikey@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 ./servermikey@mikeydeMacBook-Pro demo % 

资料

https://github.com/fvbock/endless