Golang服务平滑重启

2024-09-08 13:48
文章标签 服务 golang 重启 平滑

本文主要是介绍Golang服务平滑重启，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

与重载配置相同的是我们也需要通过信号来通知server重启，但关键在于平滑重启，如果只是简单的重启，只需要kill掉，然后再拉起即可。平滑重启意味着server升级的时候可以不用停止业务。

我们先来看下Github上有没有相应的库解决这个问题，然后找到了如下三个库：

  • facebookgo/grace - Graceful restart & zero downtime deploy for Go servers.
  • fvbock/endless - Zero downtime restarts for go servers (Drop in replacement for http.ListenAndServe)
  • jpillora/overseer - Monitorable, gracefully restarting, self-upgrading binaries in Go (golang)

我们分别来学习一下，下面只讲解http server的重启。

使用方式

我们来分别使用这三个库来做平滑重启的事情，之后来对比其优缺点。
这三个库的官方都给了相应的例子，例子如下：

但三个库官方的例子不太一致，我们来统一一下：

  • grace例子 https://github.com/facebookgo/grace/blob/master/gracedemo/demo.go
  • endless例子 https://github.com/fvbock/endless/tree/master/examples
  • overseer例子 https://github.com/jpillora/overseer/tree/master/example

我们参考官方的例子分别来写下用来对比的例子：

grace

package mainimport ("time""net/http""github.com/facebookgo/grace/gracehttp"
)func main() {gracehttp.Serve(&http.Server{Addr: ":5001", Handler: newGraceHandler()},&http.Server{Addr: ":5002", Handler: newGraceHandler()},)
}func newGraceHandler() http.Handler {mux := http.NewServeMux()mux.HandleFunc("/sleep", func(w http.ResponseWriter, r *http.Request) {duration, err := time.ParseDuration(r.FormValue("duration"))if err != nil {http.Error(w, err.Error(), 400)return}time.Sleep(duration)w.Write([]byte("Hello World"))})return mux
}

endless

package mainimport ("log""net/http""os""sync""time""github.com/fvbock/endless""github.com/gorilla/mux"
)func handler(w http.ResponseWriter, r *http.Request) {duration, err := time.ParseDuration(r.FormValue("duration"))if err != nil {http.Error(w, err.Error(), 400)return}time.Sleep(duration)w.Write([]byte("Hello World"))
}func main() {mux1 := mux.NewRouter()mux1.HandleFunc("/sleep", handler)w := sync.WaitGroup{}w.Add(2)go func() {err := endless.ListenAndServe(":5003", mux1)if err != nil {log.Println(err)}log.Println("Server on 5003 stopped")w.Done()}()go func() {err := endless.ListenAndServe(":5004", mux1)if err != nil {log.Println(err)}log.Println("Server on 5004 stopped")w.Done()}()w.Wait()log.Println("All servers stopped. Exiting.")os.Exit(0)
}

overseer

package mainimport ("fmt""net/http""time""github.com/jpillora/overseer"
)//see example.sh for the use-case// BuildID is compile-time variable
var BuildID = "0"//convert your 'main()' into a 'prog(state)'
//'prog()' is run in a child process
func prog(state overseer.State) {fmt.Printf("app#%s (%s) listening...\n", BuildID, state.ID)http.Handle("/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {duration, err := time.ParseDuration(r.FormValue("duration"))if err != nil {http.Error(w, err.Error(), 400)return}time.Sleep(duration)w.Write([]byte("Hello World"))fmt.Fprintf(w, "app#%s (%s) says hello\n", BuildID, state.ID)}))http.Serve(state.Listener, nil)fmt.Printf("app#%s (%s) exiting...\n", BuildID, state.ID)
}//then create another 'main' which runs the upgrades
//'main()' is run in the initial process
func main() {overseer.Run(overseer.Config{Program: prog,Addresses: []string{":5005", ":5006"},//Fetcher: &fetcher.File{Path: "my_app_next"},Debug:   false, //display log of overseer actions})
}

对比示例的操作步骤

  • 分别构建上面的示例，并记录pid
  • 调用API，在其未返回时，修改内容(Hello World -> Hello Harry)，重新构建。查看旧API是否返回旧的内容
  • 调用新API，查看返回的内容是否是新的内容
  • 查看当前运行的pid，是否与之前一致

下面给一下操作命令

# 第一次构建项目
go build grace.go
# 运行项目，这时就可以做内容修改了
./grace &
# 请求项目，60s后返回
curl "http://127.0.0.1:5001/sleep?duration=60s" &
# 再次构建项目，这里是新内容
go build grace.go
# 重启，2096为pid
kill -USR2 2096
# 新API请求
curl "http://127.0.0.1:5001/sleep?duration=1s"# 第一次构建项目
go build endless.go
# 运行项目，这时就可以做内容修改了
./endless &
# 请求项目，60s后返回
curl "http://127.0.0.1:5003/sleep?duration=60s" &
# 再次构建项目，这里是新内容
go build endless.go
# 重启，22072为pid
kill -1 22072
# 新API请求
curl "http://127.0.0.1:5003/sleep?duration=1s"# 第一次构建项目
go build -ldflags '-X main.BuildID=1' overseer.go
# 运行项目，这时就可以做内容修改了
./overseer &
# 请求项目，60s后返回
curl "http://127.0.0.1:5005/sleep?duration=60s" &
# 再次构建项目，这里是新内容，注意版本号不同了
go build -ldflags '-X main.BuildID=2' overseer.go
# 重启，28300为主进程pid
kill -USR2 28300
# 新API请求
curl "http://127.0.0.1:5005/sleep?duration=1s"

对比结果

示例旧API返回值新API返回值旧pid新pid结论
graceHello worldHello Harry20963100旧API不会断掉，会执行原来的逻辑，pid会变化
endlessHello worldHello Harry2207222365旧API不会断掉，会执行原来的逻辑，pid会变化
overseerHello worldHello Harry2830028300旧API不会断掉，会执行原来的逻辑，主进程pid不会变化

原理分析

可以看出grace和endless是比较像的。
热重启的原理非常简单，但是涉及到一些系统调用以及父子进程之间文件句柄的传递等等细节比较多。
处理过程分为以下几个步骤：

  1. 监听信号（USR2）
  2. 收到信号时fork子进程（使用相同的启动命令），将服务监听的socket文件描述符传递给子进程
  3. 子进程监听父进程的socket，这个时候父进程和子进程都可以接收请求
  4. 子进程启动成功之后，父进程停止接收新的连接，等待旧连接处理完成（或超时）
  5. 父进程退出，升级完成

overseer是与grace和endless有些不同，主要是两点：

  1. overseer添加了Fetcher，当Fetcher返回有效的二进位流(io.Reader) 时，主进程会将它保存到临时位置并验证它，替换当前的二进制文件并启动。
    Fetcher运行在一个goroutine中，预先会配置好检查的间隔时间。Fetcher支持File、GitHub、HTTP和S3的方式。详细可查看包package fetcher
  2. overseer添加了一个主进程管理平滑重启。子进程处理连接，能够保持主进程pid不变。

如下图表示的很形象
在这里插入图片描述

细节

  • 父进程将socket文件描述符传递给子进程可以通过命令行，或者环境变量等
  • 子进程启动时使用和父进程一样的命令行，对于golang来说用更新的可执行程序覆盖旧程序
  • server.Shutdown()优雅关闭方法是go1.8的新特性
  • server.Serve(l)方法在Shutdown时立即返回，Shutdown方法则阻塞至context完成，所以Shutdown的方法要写在主goroutine中

代码

package mainimport ("context""errors""flag""log""net""net/http""os""os/exec""os/signal""syscall""time"
)var (server   *http.Serverlistener net.Listenergraceful = flag.Bool("graceful", false, "listen on fd open 3 (internal use only)")
)func handler(w http.ResponseWriter, r *http.Request) {time.Sleep(20 * time.Second)w.Write([]byte("hello world233333!!!!"))
}func main() {flag.Parse()http.HandleFunc("/hello", handler)server = &http.Server{Addr: ":9999"}var err errorif *graceful {log.Print("main: Listening to existing file descriptor 3.")// cmd.ExtraFiles: If non-nil, entry i becomes file descriptor 3+i.// when we put socket FD at the first entry, it will always be 3(0+3)f := os.NewFile(3, "")listener, err = net.FileListener(f)} else {log.Print("main: Listening on a new file descriptor.")listener, err = net.Listen("tcp", server.Addr)}if err != nil {log.Fatalf("listener error: %v", err)}go func() {// server.Shutdown() stops Serve() immediately, thus server.Serve() should not be in main goroutineerr = server.Serve(listener)log.Printf("server.Serve err: %v\n", err)}()signalHandler()log.Printf("signal end")
}func reload() error {tl, ok := listener.(*net.TCPListener)if !ok {return errors.New("listener is not tcp listener")}f, err := tl.File()if err != nil {return err}args := []string{"-graceful"}cmd := exec.Command(os.Args[0], args...)cmd.Stdout = os.Stdoutcmd.Stderr = os.Stderr// put socket FD at the first entrycmd.ExtraFiles = []*os.File{f}return cmd.Start()
}func signalHandler() {ch := make(chan os.Signal, 1)signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM, syscall.SIGUSR2)for {sig := <-chlog.Printf("signal: %v", sig)// timeout context for shutdownctx, _ := context.WithTimeout(context.Background(), 20*time.Second)switch sig {case syscall.SIGINT, syscall.SIGTERM:// stoplog.Printf("stop")signal.Stop(ch)server.Shutdown(ctx)log.Printf("graceful shutdown")returncase syscall.SIGUSR2:// reloadlog.Printf("reload")err := reload()if err != nil {log.Fatalf("graceful restart error: %v", err)}server.Shutdown(ctx)log.Printf("graceful reload")return}}
}

代码可参考：https://github.com/CraryPrimitiveMan/go-in-action/tree/master/ch4

systemd & supervisor

父进程退出之后，子进程会挂到1号进程上面。这种情况下使用systemd和supervisord等管理程序会显示进程处于failed的状态。解决这个问题有两个方法：

  • 使用pidfile，每次进程重启更新一下pidfile，让进程管理者通过这个文件感知到mainpid的变更。
  • 起一个master来管理服务进程，每次热重启master拉起一个新的进程，把旧的kill掉。这时master的pid没有变化，对于进程管理者来说进程处于正常的状态。一个简洁的实现

这篇关于Golang服务平滑重启的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1148277。

相关文章

sysmain服务可以禁用吗? 电脑sysmain服务关闭后的影响与操作指南

sysmain服务可以禁用吗? 电脑sysmain服务关闭后的影响与操作指南

《sysmain服务可以禁用吗?电脑sysmain服务关闭后的影响与操作指南》在Windows系统中，SysMain服务（原名Superfetch）作为一个旨在提升系统性能的关键组件，一直备受用户关... 在使用 Windows 系统时，有时候真有点像在「开盲盒」。全新安装系统后的「默认设置」，往往并不尽编
阅读更多...
Python 基于http.server模块实现简单http服务的代码举例

Python 基于http.server模块实现简单http服务的代码举例

《Python基于http.server模块实现简单http服务的代码举例》Pythonhttp.server模块通过继承BaseHTTPRequestHandler处理HTTP请求,使用Threa... 目录测试环境代码实现相关介绍模块简介类及相关函数简介参考链接测试环境win11专业版python
阅读更多...
Nginx中配置使用非默认80端口进行服务的完整指南

Nginx中配置使用非默认80端口进行服务的完整指南

《Nginx中配置使用非默认80端口进行服务的完整指南》在实际生产环境中,我们经常需要将Nginx配置在其他端口上运行,本文将详细介绍如何在Nginx中配置使用非默认端口进行服务,希望对大家有所帮助... 目录一、为什么需要使用非默认端口二、配置Nginx使用非默认端口的基本方法2.1 修改listen指令
阅读更多...
SysMain服务可以关吗? 解决SysMain服务导致的高CPU使用率问题

SysMain服务可以关吗? 解决SysMain服务导致的高CPU使用率问题

《SysMain服务可以关吗?解决SysMain服务导致的高CPU使用率问题》SysMain服务是超级预读取,该服务会记录您打开应用程序的模式，并预先将它们加载到内存中以节省时间，但它可能占用大量... 在使用电脑的过程中，CPU使用率居高不下是许多用户都遇到过的问题，其中名为SysMain的服务往往是罪魁
阅读更多...
MySQL按时间维度对亿级数据表进行平滑分表

MySQL按时间维度对亿级数据表进行平滑分表

《MySQL按时间维度对亿级数据表进行平滑分表》本文将以一个真实的4亿数据表分表案例为基础,详细介绍如何在不影响线上业务的情况下,完成按时间维度分表的完整过程,感兴趣的小伙伴可以了解一下... 目录引言一、为什么我们需要分表1.1 单表数据量过大的问题1.2 分表方案选型二、分表前的准备工作2.1 数据评估
阅读更多...
解决若依微服务框架启动报错的问题

解决若依微服务框架启动报错的问题

《解决若依微服务框架启动报错的问题》Invalidboundstatement错误通常由MyBatis映射文件未正确加载或Nacos配置未读取导致,需检查XML的namespace与方法ID是否匹配,... 目录ruoyi-system模块报错报错详情nacos文件目录总结ruoyi-systnGLNYpe
阅读更多...
Nginx进行平滑升级的实战指南(不中断服务版本更新)

Nginx进行平滑升级的实战指南(不中断服务版本更新)

《Nginx进行平滑升级的实战指南(不中断服务版本更新)》Nginx的平滑升级（也称为热升级）是一种在不停止服务的情况下更新Nginx版本或添加模块的方法,这种升级方式确保了服务的高可用性,避免了因升... 目录一.下载并编译新版Nginx1.下载解压2.编译二.替换可执行文件，并平滑升级1.替换可执行文件
阅读更多...
全面解析Golang 中的 Gorilla CORS 中间件正确用法

全面解析Golang 中的 Gorilla CORS 中间件正确用法

《全面解析Golang中的GorillaCORS中间件正确用法》Golang中使用gorilla/mux路由器配合rs/cors中间件库可以优雅地解决这个问题,然而,很多人刚开始使用时会遇到配... 目录如何让 golang 中的 Gorilla CORS 中间件正确工作一、基础依赖二、错误用法（很多人一开
阅读更多...
Spring Boot 与微服务入门实战详细总结

Spring Boot 与微服务入门实战详细总结

《SpringBoot与微服务入门实战详细总结》本文讲解SpringBoot框架的核心特性如快速构建、自动配置、零XML与微服务架构的定义、演进及优缺点,涵盖开发环境准备和HelloWorld实战... 目录一、Spring Boot 核心概述二、微服务架构详解1. 微服务的定义与演进2. 微服务的优缺点三
阅读更多...
RabbitMQ消息总线方式刷新配置服务全过程

RabbitMQ消息总线方式刷新配置服务全过程

《RabbitMQ消息总线方式刷新配置服务全过程》SpringCloudBus通过消息总线与MQ实现微服务配置统一刷新,结合GitWebhooks自动触发更新,避免手动重启,提升效率与可靠性,适用于配... 目录前言介绍环境准备代码示例测试验证总结前言介绍在微服务架构中，为了更方便的向微服务实例广播消息，
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2