掌握SpringBoot-2.3的容器探针:实战篇

蔚落 2023-02-16 04:11 94阅读 0赞

经过多篇知识积累终于来到实战章节,亲爱的读者们,请将装备就位,一起动手体验SpringBoot官方带给我们的最新技术;

关于《SpringBoot-2.3容器化技术》系列

  • 《SpringBoot-2.3容器化技术》系列,旨在和大家一起学习实践2.3版本带来的最新容器化技术,让咱们的Java应用更加适应容器化环境,在云计算时代依旧紧跟主流,保持竞争力;
  • 全系列文章分为主题和辅助两部分,主题部分如下:
  1. 《体验SpringBoot(2.3)应用制作Docker镜像(官方方案)》;
  2. 《详解SpringBoot(2.3)应用制作Docker镜像(官方方案)》;
  3. 《掌握SpringBoot-2.3的容器探针:基础篇》;
  4. 《掌握SpringBoot-2.3的容器探针:深入篇》;
  5. 《掌握SpringBoot-2.3的容器探针:实战篇》;

    • 辅助部分是一些参考资料和备忘总结,如下:
  6. 《SpringBoot-2.3镜像方案为什么要做多个layer》;

  7. 《设置非root账号不用sudo直接执行docker命令》;
  8. 《开发阶段,将SpringBoot应用快速部署到K8S》;

SpringBoot-2.3容器探针知识点小结

经过前面的知识积累,我们知道了SpringBoot-2.3新增的探针规范以及适用场景,这里做个简短的回顾:

  1. kubernetes要求业务容器提供一个名为livenessProbe的地址,kubernetes会定时访问该地址,如果该地址的返回码不在200到400之间,kubernetes认为该容器不健康,会杀死该容器重建新的容器,这个地址就是存活探针;
  2. kubernetes要求业务容器提供一个名为readinessProbe的地址,kubernetes会定时访问该地址,如果该地址的返回码不在200到400之间,kubernetes认为该容器无法对外提供服务,不会把请求调度到该容器,这个地址就是就绪探针;
  3. SpringBoot的2.3.0.RELEASE发布了两个新的actuator地址,/actuator/health/liveness和/actuator/health/readiness,前者用作存活探针,后者用作就绪探针,这两个地址的返回值来自两个新增的actuator:Liveness State和Readiness State;
  4. SpringBoot应用根据特殊环境变量是否存在来判定自己是否运行在容器环境,如果是,/actuator/health/liveness和/actuator/health/readiness这两个地址就有返回码,具体的值是和应用的状态有对应关系的,例如应用启动过程中,/actuator/health/readiness返回503,启动成功后返回200;
  5. 业务应用可以通过Spring系统事件机制来读取Liveness State和Readiness State,也可以订阅这两个actuator的变更事件;
  6. 业务应用可以通过Spring系统事件机制来修改Liveness State和Readiness State,此时/actuator/health/liveness和/actuator/health/readiness的返回值都会发生变更,从而影响kubernetes对此容器的行为(参照第一点和第二点),例如livenessProbe返回码变成503,导致kubernetes认为容器不健康,从而杀死容器;

小结完毕,接下来开始实打实的编码和操作实战,验证上述理论;

实战环境信息

本次实战有两个环境:开发和运行环境,其中开发环境信息如下:

  1. 操作系统:Ubuntu 20.04 LTS 桌面版
  2. CPU :2.30GHz × 4,内存:32G,硬盘:1T NVMe
  3. JDK:1.8.0_231
  4. MAVEN:3.6.3
  5. SpringBoot:2.3.0.RELEASE
  6. Docker:19.03.10
  7. 开发工具:IDEA 2020.1.1 (Ultimate Edition)

运行环境信息如下:

  1. 操作系统:CentOS Linux release 7.8.2003
  2. Kubernetes:1.15

事实证明,用Ubuntu桌面版作为开发环境是可行的,体验十分顺畅,IDEA、SubLime、SSH、Chrome、微信都能正常使用,下图是我的Ubuntu开发环境:
在这里插入图片描述

实战内容简介

本次实战包括以下内容:

  1. 开发SpringBoot应用,部署在kubernetes;
  2. 检查应用状态和kubernetes的pod状态的关联变化;
  3. 修改Readiness State,看kubernetes是否还会把请求调度到pod;
  4. 修改Liveness State,看kubernetes会不是杀死pod;

源码下载

  1. 本次实战用到了一个普通的SpringBoot工程,源码可在GitHub下载到,地址和链接信息如下表所示(https://github.com/zq2599/blog\_demos):

























名称 链接 备注
项目主页 https://github.com/zq2599/blog_demos 该项目在GitHub上的主页
git仓库地址(https) https://github.com/zq2599/blog_demos.git 该项目源码的仓库地址,https协议
git仓库地址(ssh) git@github.com:zq2599/blog_demos.git 该项目源码的仓库地址,ssh协议
  1. 这个git项目中有多个文件夹,本章的应用在probedemo文件夹下,如下图红框所示:
    在这里插入图片描述

开发SpringBoot应用

  1. 请在IDEA上安装lombok插件:
    在这里插入图片描述
  2. 在IDEA上新建名为probedemo的SpringBoot工程,版本选择2.3.0:
    在这里插入图片描述
  3. 该工程的pom.xml内容如下,注意要有spring-boot-starter-actuator和lombok依赖,另外插件spring-boot-maven-plugin也要增加layers节点:

    <?xml version=”1.0” encoding=”UTF-8”?>


    4.0.0

    org.springframework.boot
    spring-boot-starter-parent
    2.3.0.RELEASE


    com.bolingcavalry
    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-test
    test


    org.junit.vintage
    junit-vintage-engine




    org.springframework.boot
    spring-boot-starter-actuator



    org.projectlombok
    lombok






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



    true





  4. 应用启动类ProbedemoApplication是个最普通的启动类:

    package com.bolingcavalry.probedemo;

    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;

    @SpringBootApplication
    public class ProbedemoApplication {

    1. public static void main(String[] args) {
    2. SpringApplication.run(ProbedemoApplication.class, args);
    3. }

    }

  5. 增加一个监听类,可以监听存活和就绪状态的变化:

    package com.bolingcavalry.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;

    /* description: 监听系统事件的类
    date: 2020/6/4 下午12:57
    author: willzhao
    email: zq2599@gmail.com
    version: 1.0
    */
    @Component
    @Slf4j
    public class AvailabilityListener {

    1. /** * 监听系统消息, * AvailabilityChangeEvent类型的消息都从会触发此方法被回调 * @param event */
    2. @EventListener
    3. public void onStateChange(AvailabilityChangeEvent<? extends AvailabilityState> event) {
    4. log.info(event.getState().getClass().getSimpleName() + " : " + event.getState());
    5. }

    }

  6. 增加名为StateReader的Controller的Controller,用于获取存活和就绪状态:

    package com.bolingcavalry.probedemo.controller;

    import org.springframework.boot.availability.ApplicationAvailability;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import javax.annotation.Resource;
    import java.util.Date;

    @RestController
    @RequestMapping(“/statereader”)
    public class StateReader {

    1. @Resource
    2. ApplicationAvailability applicationAvailability;
    3. @RequestMapping(value="/get")
    4. public String state() {
    5. return "livenessState : " + applicationAvailability.getLivenessState()
    6. + "<br>readinessState : " + applicationAvailability.getReadinessState()
    7. + "<br>" + new Date();
    8. }

    }

  7. 增加名为StateWritter的Controller,用于设置存活和就绪状态:

    package com.bolingcavalry.probedemo.controller;

    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.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;

    import javax.annotation.Resource;
    import java.util.Date;

    /* description: 修改状态的controller
    date: 2020/6/4 下午1:21
    author: willzhao
    email: zq2599@gmail.com
    version: 1.0
    */
    @RestController
    @RequestMapping(“/staterwriter”)
    public class StateWritter {

    1. @Resource
    2. ApplicationEventPublisher applicationEventPublisher;
    3. /** * 将存活状态改为BROKEN(会导致kubernetes杀死pod) * @return */
    4. @RequestMapping(value="/broken")
    5. public String broken(){
    6. AvailabilityChangeEvent.publish(applicationEventPublisher, StateWritter.this, LivenessState.BROKEN);
    7. return "success broken, " + new Date();
    8. }
    9. /** * 将存活状态改为CORRECT * @return */
    10. @RequestMapping(value="/correct")
    11. public String correct(){
    12. AvailabilityChangeEvent.publish(applicationEventPublisher, StateWritter.this, LivenessState.CORRECT);
    13. return "success correct, " + new Date();
    14. }
    15. /** * 将就绪状态改为REFUSING_TRAFFIC(导致kubernetes不再把外部请求转发到此pod) * @return */
    16. @RequestMapping(value="/refuse")
    17. public String refuse(){
    18. AvailabilityChangeEvent.publish(applicationEventPublisher, StateWritter.this, ReadinessState.REFUSING_TRAFFIC);
    19. return "success refuse, " + new Date();
    20. }
    21. /** * 将就绪状态改为ACCEPTING_TRAFFIC(导致kubernetes会把外部请求转发到此pod) * @return */
    22. @RequestMapping(value="/accept")
    23. public String accept(){
    24. AvailabilityChangeEvent.publish(applicationEventPublisher, StateWritter.this, ReadinessState.ACCEPTING_TRAFFIC);
    25. return "success accept, " + new Date();
    26. }

    }

  8. 增加名为Hello的controller,此接口能返回当前pod的IP地址,在后面测试时会用到:

    package com.bolingcavalry.probedemo.controller;

    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;

    import java.net.Inet4Address;
    import java.net.InetAddress;
    import java.net.NetworkInterface;
    import java.net.SocketException;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.Enumeration;
    import java.util.List;

    /* description: hello demo
    date: 2020/6/4 下午4:38
    author: willzhao
    email: zq2599@gmail.com
    version: 1.0
    */
    @RestController
    public class Hello {

    1. /** * 返回的是当前服务器IP地址,在k8s环境就是pod地址 * @return * @throws SocketException */
    2. @RequestMapping(value="/hello")
    3. public String hello() throws SocketException {
    4. List<Inet4Address> addresses = getLocalIp4AddressFromNetworkInterface();
    5. if(null==addresses || addresses.isEmpty()) {
    6. return "empty ip address, " + new Date();
    7. }
    8. return addresses.get(0).toString() + ", " + new Date();
    9. }
    10. public static List<Inet4Address> getLocalIp4AddressFromNetworkInterface() throws SocketException {
    11. List<Inet4Address> addresses = new ArrayList<>(1);
    12. Enumeration e = NetworkInterface.getNetworkInterfaces();
    13. if (e == null) {
    14. return addresses;
    15. }
    16. while (e.hasMoreElements()) {
    17. NetworkInterface n = (NetworkInterface) e.nextElement();
    18. if (!isValidInterface(n)) {
    19. continue;
    20. }
    21. Enumeration ee = n.getInetAddresses();
    22. while (ee.hasMoreElements()) {
    23. InetAddress i = (InetAddress) ee.nextElement();
    24. if (isValidAddress(i)) {
    25. addresses.add((Inet4Address) i);
    26. }
    27. }
    28. }
    29. return addresses;
    30. }
    31. /** * 过滤回环网卡、点对点网卡、非活动网卡、虚拟网卡并要求网卡名字是eth或ens开头 * @param ni 网卡 * @return 如果满足要求则true,否则false */
    32. private static boolean isValidInterface(NetworkInterface ni) throws SocketException {
    33. return !ni.isLoopback() && !ni.isPointToPoint() && ni.isUp() && !ni.isVirtual()
    34. && (ni.getName().startsWith("eth") || ni.getName().startsWith("ens"));
    35. }
    36. /** * 判断是否是IPv4,并且内网地址并过滤回环地址. */
    37. private static boolean isValidAddress(InetAddress address) {
    38. return address instanceof Inet4Address && address.isSiteLocalAddress() && !address.isLoopbackAddress();
    39. }

    }

以上就是该SpringBoot工程的所有代码了,请确保可以编译运行;

制作Docker镜像

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

    指定基础镜像,这是分阶段构建的前期阶段

    FROM openjdk:8u212-jdk-stretch as builder

    执行工作目录

    WORKDIR application

    配置参数

    ARG JAR_FILE=target/*.jar

    将编译构建得到的jar文件复制到镜像空间中

    COPY ${JAR_FILE} application.jar

    通过工具spring-boot-jarmode-layertools从application.jar中提取拆分后的构建结果

    RUN java -Djarmode=layertools -jar application.jar extract

    正式构建镜像

    FROM openjdk:8u212-jdk-stretch
    WORKDIR application

    前一阶段从jar中提取除了多个文件,这里分别执行COPY命令复制到镜像空间中,每次COPY都是一个layer

    COPY —from=builder application/dependencies/ ./
    COPY —from=builder application/spring-boot-loader/ ./
    COPY —from=builder application/snapshot-dependencies/ ./
    COPY —from=builder application/application/ ./
    ENTRYPOINT [“java”, “org.springframework.boot.loader.JarLauncher”]

  2. 先编译构建工程,执行以下命令:

    mvn clean package -U -DskipTests

  3. 编译成功后,通过Dockerfile文件创建镜像:

    sudo docker build -t bolingcavalry/probedemo:0.0.1 .

  4. 镜像创建成功:
    在这里插入图片描述
    SpringBoot的镜像准备完毕,接下来要让kubernetes环境用上这个镜像;

将镜像加载到kubernetes环境

此时的镜像保存在开发环境的电脑上,可以有以下三种方式加载到kubernetes环境:

  1. push到私有仓库,kubernetes上使用时也从私有仓库获取;
  2. push到hub.docker.com,kubernetes上使用时也从hub.docker.com获取,目前我已经将此镜像push到hub.docker.com,您在kubernetes直接使用即可,就像nginx、tomcat这些官方镜像一样下载;
  3. 在开发环境执行docker save bolingcavalry/probedemo:0.0.1 > probedemo.tar,可将此镜像另存为本地文件,再scp到kubernetes服务器,再在kubernetes服务器执行docker load < /root/temp/202006/04/probedemo.tar就能加载到kubernetes服务器的本地docker缓存中;

以上三种方法的优缺点整理如下:

  1. 首推第一种,但是需要您搭建私有仓库;
  2. 由于springboot-2.3官方对镜像构建作了优化,第二种方法也就执行第一次的时候上传和下载很耗时,之后修改java代码重新构建时,不论上传还是下载都很快(只上传下载某个layer);
  3. 在开发阶段,使用第三种方法最为便捷,但如果kubernetes环境有多台机器,就不合适了,因为镜像是存在指定机器的本地缓存的;

我的kubernetes环境只有一台电脑,因此用的是方法三,参考命令如下(建议安装sshpass,就不用每次输入帐号密码了):

  1. # 将镜像保存为tar文件
  2. sudo docker save bolingcavalry/probedemo:0.0.1 > probedemo.tar
  3. # scp到kubernetes服务器
  4. sshpass -p 888888 scp ./probedemo.tar root@192.168.50.135:/root/temp/202006/04/
  5. # 远程执行ssh命令,加载docker镜像
  6. sshpass -p 888888 ssh root@192.168.50.135 "docker load < /root/temp/202006/04/probedemo.tar"

kubernetes部署deployment和service

  1. 在kubernetes创建名为probedemo.yaml的文件,内容如下,注意pod副本数是2,另外请关注livenessProbe和readinessProbe的参数配置:

    apiVersion: v1
    kind: Service
    metadata:
    name: probedemo
    spec:
    type: NodePort
    ports:

    1. - port: 8080
    2. nodePort: 30080

    selector:

    1. name: probedemo

    apiVersion: extensions/v1beta1
    kind: Deployment
    metadata:
    name: probedemo
    spec:
    replicas: 2
    template:

    1. metadata:
    2. labels:
    3. name: probedemo
    4. spec:
    5. containers:
    6. - name: probedemo
    7. image: bolingcavalry/probedemo:0.0.1
    8. tty: true
    9. livenessProbe:
    10. httpGet:
    11. path: /actuator/health/liveness
    12. port: 8080
    13. initialDelaySeconds: 5
    14. failureThreshold: 10
    15. timeoutSeconds: 10
    16. periodSeconds: 5
    17. readinessProbe:
    18. httpGet:
    19. path: /actuator/health/readiness
    20. port: 8080
    21. initialDelaySeconds: 5
    22. timeoutSeconds: 10
    23. periodSeconds: 5
    24. ports:
    25. - containerPort: 8080
    26. resources:
    27. requests:
    28. memory: "512Mi"
    29. cpu: "100m"
    30. limits:
    31. memory: "1Gi"
    32. cpu: "500m"
  2. 执行命令kubectl apply -f probedemo…yaml,即可创建deployment和service:
    在这里插入图片描述

  3. 这里要重点关注的是livenessProbe的initialDelaySeconds和failureThreshold参数,initialDelaySeconds等于5,表示pod创建5秒后检查存活探针,如果10秒内应用没有完成启动,存活探针不返回200,就会重试10次(failureThreshold等于10),如果重试10次后存活探针依旧无法返回200,该pod就会被kubernetes杀死重建,要是每次启动都耗时这么长,pod就会不停的被杀死重建;
  4. 执行命令kubectl apply -f probedemo.yaml,创建deployment和service,如下图,可见在第十秒的时候pod创建成功,但是此时还未就绪:
    在这里插入图片描述
  5. 继续查看状态,创建一分钟后两个pod终于就绪:
    在这里插入图片描述
  6. 用kubectl describe命令查看pod状态,事件通知显示存活和就绪探针都有失败情况,不过因为有重试,因此后来状态会变为成功:
    在这里插入图片描述
    至此,从编码到部署都完成了,接下来验证SpringBoot-2.3.0.RELEASE的探针技术;

验证SpringBoot-2.3.0.RELEASE的探针技术

  1. 监听类AvailabilityListener的作用是监听状态变化,看看pod日志,看AvailabilityListener的代码是否有效,如下图红框,在应用启动阶段AvailabilityListener被成功回调,打印了存活和就绪状态:
    在这里插入图片描述
  2. kubernetes所在机器的IP地址是192.168.50.135,因此SpringBoot服务的访问地址是http://192.168.50.135:30080/xxx
  3. 访问地址http://192.168.50.135:30080/actuator/health/liveness,返回码如下图红框,可见存活探针已开启:
    在这里插入图片描述
  4. 就绪探针也正常:
    在这里插入图片描述
  5. 打开两个浏览器,都访问:http://192.168.50.135:30080/hello,多次Ctrl+F5强刷,如下图,很快就能得到不同结果,证明响应来自不同的Pod:
    在这里插入图片描述
  6. 访问:http://192.168.50.135:30080/statereader/get,可以得到存活和就绪的状态,可见StateReader的代码已经生效,可以通过ApplicationAvailability接口取得状态:
    在这里插入图片描述
  7. 修改就绪状态,访问:http://192.168.50.135:30080/statewriter/refuse,如下图红框,可见收到请求的pod,其就绪状态已经出现了异常,证明StateWritter.java中修改就绪状态后,可以让kubernetes感知到这个pod的异常:
    在这里插入图片描述
  8. 用浏览器反复强刷hello接口,返回的Pod地址也只有一个,证明只有一个Pod在响应请求:
    在这里插入图片描述
  9. 尝试恢复服务,注意请求要在服务器后台发送,而且IP地址要用刚才被设置为refuse的pod地址:

    curl http://10.233.90.195:8080/statewriter/accept

  10. 如下图,状态已经恢复:
    在这里插入图片描述

  11. 最后再来试试将存活状态从CORRECT改成BROKEN,浏览器访问:http://192.168.50.135:30080/statewriter/broken
  12. 如下图红框,重启次数变成1,表示pod被杀死了一次,并且由于重启导致当前还未就绪,证明在SpringBoot中修改了存活探针的状态,是会触发kubernetes杀死pod的:
    在这里插入图片描述
  13. 等待pod重启、就绪探针正常后,一切恢复如初:
    在这里插入图片描述
  14. 强刷浏览器,如下图红框,两个Pod都能正常响应:
    在这里插入图片描述

官方忠告

  • 至此,《掌握SpringBoot-2.3的容器探针》系列就全部完成了,从理论到实践,咱们一起学习了SpringBoot官方带给我们的容器化技术,最后以一段官方忠告来结尾,大家一起将此忠告牢记在心:
    在这里插入图片描述
  • 我对以上内容的理解:选择外部系统的服务作为探针的时候要谨慎(外部系统可能是数据库,也可能是其他web服务),如果外部系统出现问题,会导致kubernetes杀死pod(存活探针问题),或者导致kubernetes不再调度请求到pod(就绪探针问题);(再请感谢大家容忍我的英语水平)

欢迎访问我的GitHub

  • 地址:https://github.com/zq2599/blog_demos
  • 内容:原创文章分类汇总,及配套源码,涉及Java、Docker、K8S、DevOPS等

欢迎关注我的公众号:程序员欣宸

在这里插入图片描述

发表评论

表情:
评论列表 (有 0 条评论,94人围观)

还没有评论,来说两句吧...

相关阅读

    相关 Kubernetes---容器探针

    ⒈含义   探针是由各个节点的kubelet对容器执行的定期诊断。要执行诊断,kubelet 调用由容器实现的Handler【处理程序】。有三种类型的处理程序: