容器应用优雅关闭

应用上云 评论

概述

优雅关闭： 在关闭前，执行正常的关闭过程，释放连接和资源，如我们操作系统执行shutdown。

目前业务系统组件众多，互相之间调用关系也比较复杂，一个组件的下线、关闭会涉及到多个组件
对于任何一个线上应用，如何保证服务更新部署过程中从应用停止到重启恢复服务这个过程中不影响正常的业务请求，这是应用开发运维团队必须要解决的问题。传统的解决方式是通过将应用更新流程划分为手工摘流量、停应用、更新重启三个步骤，由人工操作实现客户端不对更新感知。这种方式简单而有效，但是限制较多：不仅需要使用借助网关的支持来摘流量，还需要在停应用前人工判断来保证在途请求已经处理完毕。

同时，在应用层也有一些保障应用优雅停机的机制，目前Tomcat、Spring Boot、Dubbo等框架都有提供相关的内置实现，如SpringBoot 2.3内置graceful shutdown可以很方便的直接实现优雅停机时的资源处理，同时一个普通的Java应用也可以基于Runtime.getRuntime().addShutdownHook()来自定义实现，它们的实现原理都基本一致，通过等待操作系统发送的SIGTERM信号，然后针对监听到该信号做一些处理动作。优雅停机是指在停止应用时，执行的一系列保证应用正常关闭的操作。这些操作往往包括等待已有请求执行完成、关闭线程、关闭连接和释放资源等，优雅停机可以避免非正常关闭程序可能造成数据异常或丢失，应用异常等问题。优雅停机本质上是JVM即将关闭前执行的一些额外的处理代码。

现状分析

现阶段，业务容器化后业务启动是通过shell脚本启动业务，对应的在容器内PID为1的进程为shell进程但shell 程序不转发signals，也不响应退出信号。所以在容器应用中如果应用容器中启动 shell，占据了 pid=1 的位置，那么就无法接收k8s发送的SIGTERM信号，只能等超时后被强行杀死了。

案例分析

go开发的一个Demo 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main()  {
    c := make(chan os.Signal)
    signal.Notify(c, syscall.SIGTERM, syscall.SIGINT)
    go func() {
        for s := range c {
            switch s {
            case syscall.SIGINT, syscall.SIGTERM:
                fmt.Println("退出", s)
                ExitFunc()
            default:
                fmt.Println("other", s)
            }
        }
    }()

    fmt.Println("进程启动...")
    time.Sleep(time.Duration(200000)*time.Second)
}

func ExitFunc()  {
    fmt.Println("正在退出...")
    fmt.Println("执行清理...")
    fmt.Println("退出完成...")
    os.Exit(0)
}

代码参考：https://www.jianshu.com/p/ae72ad58ecb6

1、Signal.Notify会监听括号内指定的信号，若没有指定，则监听所有信号。
2、通过switch对监听到信号进行判断，如果是SININT和SIGTERM则条用Exitfunc函数执行退出。

SHELL模式和CMD模式带来的差异性

编写应用Dockerfile文件

概述
在Dockerfile中CMD和ENTRYPOINT用来启动应用，有shell模式和exec模式，对应的使用shell模式，PID为1的进程为shell，使用exec模式PID为1的进程为业务本身。
SHELL模式

1
2
3
4
5
6
7
8
FROM golang as builder
WORKDIR /go/
COPY app.go    .
RUN go build app.go
FROM ubuntu
WORKDIR /root/
COPY --from=builder /go/app .
CMD ./app

构建镜像

1
docker build -t app:v1.0-shell ./

运行查看

1
2
3
4
5
docker exec -it app-shell ps aux
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root           1  0.7  0.0   2608   548 pts/0    Ss+  03:22   0:00 /bin/sh -c ./
root           6  0.0  0.0 704368  1684 pts/0    Sl+  03:22   0:00 ./app
root          24  0.0  0.0   5896  2868 pts/1    Rs+  03:23   0:00 ps aux

可以看见PID为1的进程是sh进程

此时执行docker stop，业务进程是接收不到SIGTERM信号的，要等待一个超时时间后被KILL

日志没有输出SIGTERM关闭指令

1
2
3
4
5
docker stop app-shell
app-shell

docker logs app-shell
进程启动...

EXEC模式

1
2
3
4
5
6
7
8
9
FROM golang as builder
WORKDIR /go/
COPY app.go    .
RUN go build app.go
FROM ubuntu
WORKDIR /root/
COPY --from=builder /go/app .
CMD ["./app"]

构建镜像

1
docker build -t app:v1.0-exec ./

运行查看

1
2
3
4
docker exec -it app-exec ps aux
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root           1  2.0  0.0 703472  1772 pts/0    Ssl+ 03:33   0:00 ./app
root          14  0.0  0.0   5896  2908 pts/1    Rs+  03:34   0:00 ps aux

可以看见PID为1的进程是应用进程

此时执行docker stop，业务进程是可以接收SIGTERM信号的，会优雅退出

1
2
3
4
5
6
7
8
9
docker stop app-exec
app-exec

docker logs app-exec
进程启动...
退出 terminated
正在退出...
执行清理...
退出完成...

注意：
1、以下测试在ubuntu做为应用启动base镜像测试成功，在alpine做为应用启动base镜像时shell模式和exec模式都一样，都是应用进程为PID 1的进程。

直接启动应用和通过脚本启动区别

在实际生产环境中，因为应用启动命令后会接很多启动参数，所以通常我们会使用一个启动脚本来启动应用，方便我们启动应用。对应的在容器内PID为1的进程为shell进程但shell 程序不转发signals，也不响应退出信号。所以在容器应用中如果应用容器中启动 shell，占据了 pid=1 的位置，那么就无法接收k8s发送的SIGTERM信号，只能等超时后被强行杀死了。
启动脚本
start.sh

1
2
3
cat > start.sh<< EOF 
#!/bin/sh
sh -c /root/app
1
2
3
4
5
6
7
8
9
FROM golang as builder
WORKDIR /go/
COPY app.go    .
RUN go build app.go
FROM alpine
WORKDIR /root/
COPY --from=builder /go/app .
ADD start.sh /root/
CMD ["/bin/sh","/root/start.sh"]

构建应用

1
docker build -t app:v1.0-script ./

查看

1
2
3
4
5
docker exec -it app-script ps aux
PID   USER     TIME  COMMAND
1     root     0:00  /bin/sh /root/start.sh
6     root     0:00  /root/app
19    root     0:00  ps aux

docker stop关闭应用

1
docker stop app-script

是登待超时后被强行KILL

1
2
docker logs app-script
进程启动...

容器应用优雅关闭方案介绍

方案介绍

正常的优雅停机可以简单的认为包括两个部分：
- 应用：应用自身需要实现优雅停机的处理逻辑，确保处理中的请求可以继续完成，资源得到有效的关闭释放，等等。针对应用层，不管是Java应用还是其他语言编写的应用，其实现原理基本一致，都提供了类似的监听处理接口，根据规范要求实现即可。
- 平台：平台层要能够将应用从负载均衡中去掉，确保应用不会再接受到新的请求连接，并且能够通知到应用要进行优雅停机处理。在传统的部署模式下，这部分工作可能需要人工处理，但是在K8s容器平台中，K8s的Pod删除默认就会向容器中的主进程发送优雅停机命令，并提供了默认30s的等待时长，若优雅停机处理超出30s以后就会强制终止。同时，有些应用在容器中部署时，并不是通过容器主进程的形式进行部署，那么K8s也提供了PreStop的回调函数来在Pod停止前进行指定处理，可以是一段命令，也可以是一个HTTP的请求，从而具备了较强的灵活性。
通过以上分析，理论上应用容器化部署以后仍然可以很好的支持优雅停机，甚至相比于传统方式实现了更多的自动化操作，本文档后面会针对该方案进行详细的方案验证。

  • 容器应用中第三方Init：在构建应用中使用第三方init如tini或dumb-init

方案一：
通过k8s的prestop参数调用容器内进程关闭脚本，实现优雅关闭。

方案二：
通过第三方init进程传递SIGTERM到进程中。

方案验证

方案一：通过k8s Prestop参数调用

在前面脚本启动的dockerfile基础上，定义一个优雅关闭的脚本，通过k8s-prestop在关闭POD前调用优雅关闭脚本，实现pod优雅关闭。

启动脚本
start.sh

1
2
3
cat > start.sh<< EOF 
#!/bin/sh
./app

stop.sh
优雅关闭脚本

1
2
#!/bin/sh
ps -ef|grep app|grep -v grep|awk '{print $1}'|xargs kill -15
1
2
3
4
5
6
7
8
9
10
FROM golang as builder
WORKDIR /go/
COPY app.go    .
RUN go build app.go
FROM alpine
WORKDIR /root/
COPY --from=builder /go/app .
ADD start.sh /root/
CMD ["/bin/sh","/root/start.sh"]

构建镜像

1
docker build -t app:v1.0-prestop ./

通过yaml部署到k8s中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-prestop
  labels:
    app: prestop
spec:
  replicas: 1
  selector:
    matchLabels:
      app: prestop
  template:
    metadata:
      labels:
        app: prestop
    spec:
      containers:
      - name: prestop
        image: 172.16.1.31/library/app:v1.0-prestop
        lifecycle:
          preStop:
            exec:
              command:
              - sh
              - /root/stop.sh

查看POD日志，然后删除pod副本

1
2
3
kubectl get pod 
NAME                            READY   STATUS    RESTARTS   AGE
app-prestop-847f5c4db8-mrbqr    1/1     Running   0          73s

查看日志

1
2
kubectl logs app-prestop-847f5c4db8-mrbqr -f
进程启动...

另外窗口删除POD

1
2
3
4
5
6
7
8
kubectl logs app-prestop-847f5c4db8-mrbqr -f
进程启动...


退出 terminated
正在退出...
执行清理...
退出完成...

可以看见执行了Prestop脚本进行优雅关闭。
同样的可以将yaml文件中的Prestop脚本取消进行对比测试可以发现就会进行强制删除。

方案二：shell脚本修改为exec执行

修改start.sh脚本

1
2
#!/bin/sh
exec ./app

shell中添加一个 exec 即可让应用进程替代当前shell进程,可将SIGTERM信号传递到业务层，让业务实现优雅关闭。

可使用上面例子，进行修改测试。

方案三：通过第三init工具启动

使用dump-init或tini做为容器的主进程，在收到退出信号的时候，会将退出信号转发给进程组所有进程。，主要适用应用本身无关闭信号处理的场景。docker –init本身也是集成的tini。

1
2
3
4
5
6
7
8
9
10
11
FROM golang as builder
WORKDIR /go/
COPY app.go    .
RUN go build app.go
FROM alpine
WORKDIR /root/
COPY --from=builder /go/app .
ADD start.sh tini /root/
RUN chmoad a+x start.sh && apk add --no-cache tini
ENTRYPOINT ["/sbin/tini", "--"]
CMD ["/root/tini", "--", /root/start.sh"]

构建镜像

1
docker build -t app:v1.0-tini ./

测试运行

1
docker run -itd --name app-tini app:v1.0-tini

查看日志

1
2
3
docker logs app-tini

进程启动...

发现容器快速停止了，但没有输出应用关闭和清理的日志

后面查阅相关资料发现

使用tini或dump-init做为应用启动的主进程。
tini和dumb-init会将关闭信号向子进程传递，但不会等待子进程完全退出后自己在退出。而是传递完后直接就退出了。

相关issue：
https://github.com/krallin/tini/issues/180

后面又查到另外一个第三方的组件smell-baron能实现等待子进程优雅关闭后在关闭本身功能。 但这个项目本身热度不是特别高，并且有很久没有维护了。 

1
2
3
4
5
6
7
8
9
10
11
12
FROM golang as builder
WORKDIR /go/
COPY app.go    .
RUN go build app.go
FROM ubuntu
WORKDIR /root/
COPY --from=builder /go/app .
ADD start.sh /root/
ADD smell-baron /bin/smell-baron
RUN chmod a+x /bin/smell-baron  && chmod a+x start.sh
ENTRYPOINT ["/bin/smell-baron"]
CMD ["/root/start.sh"]

构建镜像

1
docker build -t app:v1.0-smell-baron ./

测试

1
2
3
4
5
6
7
8
9
docker run -itd --name app-smell-baron app:v1.0-smell-baron

docker stop  app-smell-baron

进程启动...
退出 terminated
正在退出...
执行清理...
退出完成...

总结：

1、对于容器化应用启动命令建议使用EXEC模式。
2、对于应用本身代码层面已经实现了优雅关闭的业务，但有shell启动脚本，容器化后部署到k8s上建议使方案一和方案二。
3、对于应用本身代码层面没有实现优雅关闭的业务，建议使用方案三。

项目地址：
https://github.com/insidewhy/smell-baron
https://github.com/Yelp/dumb-init
https://github.com/krallin/tini