spring boot 应用在 k8s 中的健康检查(三)

一、概述

在 spring boot 2.3 中引入了容器探针,也就是增加了 /actuator/health/liveness/actuator/health/readiness 这两个健康检查路径,对于部署在 k8s 中的应用,spring-boot-actuator 将通过这两个路径自动进行健康检查。本文主要根据官方文档的描述实践并记录使用流程,从如下几个方面进行介绍:

  1. k8s 中的健康检查
  2. spring-boot-actuator 中的 k8s 探针
  3. spring boot 健康检查在 k8s 中的实践

二、spring boot 健康检查在 k8s 中的实践

本次实践的思路来自下文的参考文章,这里使用 spring boot 2.5.1 进行实践

1. 实践环境

  • 开发工具:IntelliJ IDEA 2021.1.1 (Ultimate Edition)
  • jdk 1.8
  • Apache Maven 3.6.3
  • docker 20.10.5
  • minikube v1.18.1
  • spring boot 2.5.1

    2. 创建一个 spring boot 项目

    1. 使用 idea 创建一个 spring boot 项目:

spring boot 应用在 k8s 中的健康检查(三)_第1张图片

2. pom.xml 的依赖配置如下:



    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.5.1
         
    
    com.example
    probedemo
    0.0.1-SNAPSHOT
    probedemo
    Demo project for Spring Boot
    
        1.8
    
    
        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            org.springframework.boot
            spring-boot-starter-actuator
        

        
            org.projectlombok
            lombok
            true
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
            
        
    


3. 创建一个监听类,可以监听存活和就绪状态的变化:

package com.example.probedemo.listener;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.availability.AvailabilityChangeEvent;
import org.springframework.boot.availability.AvailabilityState;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

/**
 * 监听系统事件的类
 *
 * @className: AvailabilityListener
 * @date: 2021/6/15 10:44
 */
@Slf4j
@Component
public class AvailabilityListener {

    /**
     * 基于 spring 的事件监听机制,监听系统的消息
     * 当监听到 AvailabilityChangeEvent 事件会触发此方法的调用
     * 这里使用日志记录事件的状态
     * @param event
     */
    @EventListener
    public void onStateChange(AvailabilityChangeEvent event) {
        log.info(event.getState().getClass().getSimpleName() + ": " + event.getState());
    }

}

@EventListener 注解说明:

将方法标记为应用程序事件侦听器的注解。

如果带注解的方法支持单个事件类型,则该方法可以声明一个反映要侦听的事件类型的参数。如果带注解的方法支持多个事件类型,则此注解可以使用classes属性引用一个或多个受支持的事件类型。有关详细信息,请参见类javadoc。

事件可以是ApplicationEvent实例,也可以是任意对象。

@EventListener注解的处理通过内部EventListenerMethodProcessor bean执行,该bean在使用Java config时自动注册,或者通过或者使用XML配置时的元素。

带注解的方法可能具有非void返回类型。当它们这样做时,方法调用的结果将作为新事件发送。如果返回类型是数组或集合,则每个元素将作为新的单个事件发送。

此注解可用作元注解,以创建自定义组合注解。

  • 异常处理:虽然事件侦听器可以声明它抛出任意异常类型,但是从事件侦听器抛出的任何选中的异常都将包装在未声明的ThrowableException中,因为事件发布器只能处理运行时异常。
  • 异步侦听器:如果希望某个特定的侦听器异步处理事件,可以使用Spring的@Async支持,但在使用异步事件时要注意以下限制。如果异步事件侦听器抛出异常,则不会将其传播到调用方。有关详细信息,请参阅AsyncUncaughtExceptionHandler。异步事件侦听器方法无法通过返回值来发布后续事件。如果需要作为处理结果发布另一个事件,请插入ApplicationEventPublisher以手动发布该事件。
  • 排序侦听器:还可以定义调用某个事件的侦听器的顺序。为此,将Spring的公共@Order注解添加到这个事件侦听器注解旁边。

4. 创建一个 stateController 用来修改状态

package com.example.probedemo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.availability.AvailabilityChangeEvent;
import org.springframework.boot.availability.LivenessState;
import org.springframework.boot.availability.ReadinessState;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

/**
 * 测试修改状态的 controller
 *
 * @className: StateWriter
 * @date: 2021/6/15 14:17
 */
@RestController
@RequestMapping("/state")
public class StateController {

    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;

    /**
     * 将存活状态改为 BROKEN
     * 这会导致 k8s 杀死 pod,并根据重启策略重启 pod
     *
     * @return
     */
    @GetMapping("broken")
    public String broken() {
        AvailabilityChangeEvent.publish(applicationEventPublisher, this, LivenessState.BROKEN);
        return "success broken, " + new Date();
    }

    /**
     * 将存活状态修改为 correct
     * @return
     */
    @GetMapping("correct")
    public String correct() {
        AvailabilityChangeEvent.publish(applicationEventPublisher, this, LivenessState.CORRECT);
        return "success correct, " + new Date();
    }

    /**
     * 将就绪状态修改为 ACCEPTING_TRAFFIC (接受流量)
     * k8s 会将外部请求转发到此 pod
     * @return
     */
    @GetMapping("accept")
    public String accept() {
        AvailabilityChangeEvent.publish(applicationEventPublisher, this, ReadinessState.ACCEPTING_TRAFFIC);
        return "success accept, " + new Date();
    }

    /**
     * 将就绪状态修改为 REFUSING_TRAFFIC
     * k8s 通过将 service 对应的后端 endpoint 中此 pod 的ip移除来拒绝外部请求
     * @return
     */
    @GetMapping("refuse")
    public String refuse() {
        AvailabilityChangeEvent.publish(applicationEventPublisher, this, ReadinessState.REFUSING_TRAFFIC);
        return "success refuse, " + new Date();
    }


}

5. 制作 docker 镜像

在pom.xml所在目录创建文件Dockerfile,内容如下:

# 指定基础镜像,这是多阶段构建的前期阶段
FROM openjdk:11-jre-slim as builder
# 指定工作目录,目录不存在会自动创建
WORKDIR /app
# 将生成的 jar 复制到容器镜像中
COPY target/*.jar application.jar
# 通过工具spring-boot-jarmode-layertools从application.jar中提取拆分后的构建结果
RUN java -Djarmode=layertools -jar application.jar extract

# 正式构建镜像
FROM openjdk:11-jre-slim
# 指定工作目录,目录不存在会自动创建
WORKDIR /app
# 前一阶段从jar中提取除了多个文件,这里分别执行COPY命令复制到镜像空间中,每次COPY都是一个layer
COPY --from=builder app/dependencies ./
COPY --from=builder app/spring-boot-loader ./
COPY --from=builder app/snapshot-dependencies ./
COPY --from=builder app/application ./
# 指定时区
ENV TZ="Asia/Shanghai"
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# 定义一些环境变量,方便环境变量传参
ENV JVM_OPTS=""
ENV JAVA_OPTS=""
# 指定暴露的端口,起到说明的作用,不指定也会暴露对应端口
EXPOSE 8080
# 启动 jar 的命令
ENTRYPOINT ["sh","-c","java $JVM_OPTS $JAVA_OPTS org.springframework.boot.loader.JarLauncher"]

使用以下命令编译构建项目:

mvn clean package -U -DskipTests

使用以下命令构建 docker 镜像(最后有一个 . 表示当前目录作为docker构建的上下文环境):

docker build -t probedemo:1.0.0 .

使用下面的命令将 docker 镜像推送到远程仓库(这里推送到docker hub仓库,需要自己注册一个账号):

# 给镜像打一个标签,[仓库地址/镜像名:镜像标签]
docker tag probedemo:1.0.0 wangedison98/probedemo:1.0.0
# 推送到远程仓库
docker push wangedison98/probedemo:1.0.0

6. k8s 部署 deployment 和 service

创建名为probedemo.yaml的文件:


apiVersion: apps/v1
kind: Deployment
metadata:
  name: probedemo
  labels:
    app: probedemo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: probedemo
  template:
    metadata:
      labels:
        app: probedemo
    spec:
      containers:
        - name: probedemo
          imagePullPolicy: IfNotPresent
          image: wangedison98/probedemo:1.0.0
          ports:
            - containerPort: 8080
          resources:
            requests:
              memory: "512Mi"
              cpu: "100m"
            limits:
              memory: "1Gi"
              cpu: "500m"
          livenessProbe:
            httpGet:
              path: /actuator/health/liveness
              port: 8080
            initialDelaySeconds: 5
            failureThreshold: 10
            timeoutSeconds: 10
            periodSeconds: 5
          readinessProbe:
            httpGet:
              path: /actuator/health/readiness
              port: 8080
            initialDelaySeconds: 5
            timeoutSeconds: 10
            periodSeconds: 5


---
apiVersion: v1
kind: Service
metadata:
  name: probedemo
spec:
  ports:
    - port: 8080
      targetPort: 8080
  selector:
    app: probedemo
  type: NodePort

这里要重点关注的是 livenessProbeinitialDelaySecondsfailureThreshold 参数,initialDelaySeconds 等于5,表示 pod 创建5秒后检查存活探针,如果10秒内应用没有完成启动,存活探针不返回200,就会重试10次(failureThreshold等于10),每一次等待 5 秒(periodSeconds 等于5),如果重试10次,也就是50秒后,存活探针依旧无法返回200,该pod就会被kubernetes杀死重建,要是每次启动都耗时这么长,pod就会不停的被杀死重建,这种情况下可以考虑延长 failureThreshold 失败重试的次数。

使用如下命令创建 deployment 和 service:

kubectl apply -f probedemo.yaml

查看运行的 pod:

spring boot 应用在 k8s 中的健康检查(三)_第2张图片

使用如下命令暴露服务端口:

kubectl port-forward service/probedemo 8080 8080

调用存活性检查的 broken 事件,地址如下:

curl http://localhost:8080/state/broken

等待大概一分钟,发现 pod 已经重启一次

spring boot 应用在 k8s 中的健康检查(三)_第3张图片

请求拒绝流量,地址如下:

curl http://localhost:8080/state/refuse

可以看到服务已经处于未准备状态:

spring boot 应用在 k8s 中的健康检查(三)_第4张图片

查看 pod 的事件:

kubectl describe  probedemo-86cb7cc84b-djrjn

spring boot 应用在 k8s 中的健康检查(三)_第5张图片

当再次调用接受流量的请求:

curl http://localhost:8080/state/accept

发现服务已经恢复正常:

spring boot 应用在 k8s 中的健康检查(三)_第6张图片

根据这个特性,可以通过程序控制什么时候对外提供服务,当处理一些异常情况时,可以手动拒绝请求,待恢复正常后再提供服务。

三、总结

通过上面的实践,我们测试了spring boot 应用在 k8s 中的健康检查,配置非常简单:

  1. 只需要引入 spring-boot-starter-actuator 依赖即可,不需要其他额外配置
  2. 在 k8s 的部署清单中根据官方文档做如下配置:

spring boot 应用在 k8s 中的健康检查(三)_第7张图片

参考文章

https://blog.csdn.net/boling_...

https://docs.spring.io/spring...

你可能感兴趣的:(spring boot 应用在 k8s 中的健康检查(三))