背景

如果我们的应用在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.启动服务

1	`go run server.go`

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

1	`curl localhost:8001/ok`

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

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

3.发送信号结束进程

1	`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

编程语言 > Golang > 学习笔记

Golang-如何实现服务的优雅关停/更新

https://mikeygithub.github.io/2022/11/24/yuque/Golang篇-如何实现服务的优雅关停!更新/

作者

Mikey

发布于

2022年11月24日

许可协议

Golang篇-pprof性能调优工具上一篇

Nginx+Keepalived实现高可用案例下一篇