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

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

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

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

*  《SpringBoot-2.3容器化技术》系列，旨在和大家一起学习实践2.3版本带来的最新容器化技术，让咱们的Java应用更加适应容器化环境，在云计算时代依旧紧跟主流，保持竞争力；
 *  全系列文章分为主题和辅助两部分，主题部分如下：

1.  [《体验SpringBoot(2.3)应用制作Docker镜像(官方方案)》][SpringBoot_2.3_Docker]；
2.  [《详解SpringBoot(2.3)应用制作Docker镜像(官方方案)》][SpringBoot_2.3_Docker 1]；
3.  [《掌握SpringBoot-2.3的容器探针：基础篇》][SpringBoot-2.3]；
4.  [《掌握SpringBoot-2.3的容器探针：深入篇》][SpringBoot-2.3 1]；
5.  [《掌握SpringBoot-2.3的容器探针：实战篇》][SpringBoot-2.3 2]；

*  辅助部分是一些参考资料和备忘总结，如下：

1.  [《SpringBoot-2.3镜像方案为什么要做多个layer》][SpringBoot-2.3_layer]；
2.  [《设置非root账号不用sudo直接执行docker命令》][root_sudo_docker]；
3.  [《开发阶段，将SpringBoot应用快速部署到K8S》][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开发环境：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center]

### 实战内容简介 ###

本次实战包括以下内容：

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)：

<table> 
 <thead> 
  <tr> 
   <th align="left">名称</th> 
   <th align="left">链接</th> 
   <th align="left">备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">项目主页</td> 
   <td align="left">https://github.com/zq2599/blog_demos</td> 
   <td align="left">该项目在GitHub上的主页</td> 
  </tr> 
  <tr> 
   <td align="left">git仓库地址(https)</td> 
   <td align="left">https://github.com/zq2599/blog_demos.git</td> 
   <td align="left">该项目源码的仓库地址，https协议</td> 
  </tr> 
  <tr> 
   <td align="left">git仓库地址(ssh)</td> 
   <td align="left">git@github.com:zq2599/blog_demos.git</td> 
   <td align="left">该项目源码的仓库地址，ssh协议</td> 
  </tr> 
 </tbody> 
</table>

1.  这个git项目中有多个文件夹，本章的应用在probedemo文件夹下，如下图红框所示：  
    ![在这里插入图片描述][20200607212339345.png]

### 开发SpringBoot应用 ###

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

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.3.0.RELEASE</version>
            <relativePath/> 
        </parent>
        <groupId>com.bolingcavalry</groupId>
        <artifactId>probedemo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>probedemo</name>
        <description>Demo project for Spring Boot</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.vintage</groupId>
                        <artifactId>junit-vintage-engine</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <version>2.3.0.RELEASE</version>
                    
                    <configuration>
                        <layers>
                            <enabled>true</enabled>
                        </layers>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </project>

1.  应用启动类ProbedemoApplication是个最普通的启动类：

package com.bolingcavalry.probedemo;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class ProbedemoApplication { 
        public static void main(String[] args) { 
            SpringApplication.run(ProbedemoApplication.class, args);
        }
    }

1.  增加一个监听类，可以监听存活和就绪状态的变化：

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: 监听系统事件的类 <br> * date: 2020/6/4 下午12:57 <br> * author: willzhao <br> * email: zq2599@gmail.com <br> * version: 1.0 <br> */
    @Component
    @Slf4j
    public class AvailabilityListener { 
    
        /** * 监听系统消息， * AvailabilityChangeEvent类型的消息都从会触发此方法被回调 * @param event */
        @EventListener
        public void onStateChange(AvailabilityChangeEvent<? extends AvailabilityState> event) { 
            log.info(event.getState().getClass().getSimpleName() + " : " + event.getState());
        }
    }

1.  增加名为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 { 
    
        @Resource
        ApplicationAvailability applicationAvailability;
    
        @RequestMapping(value="/get")
        public String state() { 
            return "livenessState : " + applicationAvailability.getLivenessState()
                   + "<br>readinessState : " + applicationAvailability.getReadinessState()
                   + "<br>" + new Date();
        }
    }

1.  增加名为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 <br> * date: 2020/6/4 下午1:21 <br> * author: willzhao <br> * email: zq2599@gmail.com <br> * version: 1.0 <br> */
    @RestController
    @RequestMapping("/staterwriter")
    public class StateWritter { 
    
        @Resource
        ApplicationEventPublisher applicationEventPublisher;
    
        /** * 将存活状态改为BROKEN（会导致kubernetes杀死pod） * @return */
        @RequestMapping(value="/broken")
        public String broken(){ 
            AvailabilityChangeEvent.publish(applicationEventPublisher, StateWritter.this, LivenessState.BROKEN);
            return "success broken, " + new Date();
        }
    
        /** * 将存活状态改为CORRECT * @return */
        @RequestMapping(value="/correct")
        public String correct(){ 
            AvailabilityChangeEvent.publish(applicationEventPublisher, StateWritter.this, LivenessState.CORRECT);
            return "success correct, " + new Date();
        }
    
        /** * 将就绪状态改为REFUSING_TRAFFIC（导致kubernetes不再把外部请求转发到此pod） * @return */
        @RequestMapping(value="/refuse")
        public String refuse(){ 
            AvailabilityChangeEvent.publish(applicationEventPublisher, StateWritter.this, ReadinessState.REFUSING_TRAFFIC);
            return "success refuse, " + new Date();
        }
    
        /** * 将就绪状态改为ACCEPTING_TRAFFIC（导致kubernetes会把外部请求转发到此pod） * @return */
        @RequestMapping(value="/accept")
        public String accept(){ 
            AvailabilityChangeEvent.publish(applicationEventPublisher, StateWritter.this, ReadinessState.ACCEPTING_TRAFFIC);
            return "success accept, " + new Date();
        }
    
    }

1.  增加名为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 <br> * date: 2020/6/4 下午4:38 <br> * author: willzhao <br> * email: zq2599@gmail.com <br> * version: 1.0 <br> */
    @RestController
    public class Hello { 
    
        /** * 返回的是当前服务器IP地址，在k8s环境就是pod地址 * @return * @throws SocketException */
        @RequestMapping(value="/hello")
        public String hello() throws SocketException { 
            List<Inet4Address> addresses = getLocalIp4AddressFromNetworkInterface();
            if(null==addresses || addresses.isEmpty()) { 
                return  "empty ip address, " + new Date();
            }
    
            return addresses.get(0).toString() + ", " + new Date();
        }
    
        public static List<Inet4Address> getLocalIp4AddressFromNetworkInterface() throws SocketException { 
            List<Inet4Address> addresses = new ArrayList<>(1);
            Enumeration e = NetworkInterface.getNetworkInterfaces();
            if (e == null) { 
                return addresses;
            }
            while (e.hasMoreElements()) { 
                NetworkInterface n = (NetworkInterface) e.nextElement();
                if (!isValidInterface(n)) { 
                    continue;
                }
                Enumeration ee = n.getInetAddresses();
                while (ee.hasMoreElements()) { 
                    InetAddress i = (InetAddress) ee.nextElement();
                    if (isValidAddress(i)) { 
                        addresses.add((Inet4Address) i);
                    }
                }
            }
            return addresses;
        }
    
        /** * 过滤回环网卡、点对点网卡、非活动网卡、虚拟网卡并要求网卡名字是eth或ens开头 * @param ni 网卡 * @return 如果满足要求则true，否则false */
        private static boolean isValidInterface(NetworkInterface ni) throws SocketException { 
            return !ni.isLoopback() && !ni.isPointToPoint() && ni.isUp() && !ni.isVirtual()
                    && (ni.getName().startsWith("eth") || ni.getName().startsWith("ens"));
        }
    
        /** * 判断是否是IPv4，并且内网地址并过滤回环地址. */
        private static boolean isValidAddress(InetAddress address) { 
            return address instanceof Inet4Address && address.isSiteLocalAddress() && !address.isLoopbackAddress();
        }
    }

以上就是该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"]

1.  先编译构建工程，执行以下命令：

mvn clean package -U -DskipTests

1.  编译成功后，通过Dockerfile文件创建镜像：

sudo docker build -t bolingcavalry/probedemo:0.0.1 .

1.  镜像创建成功：  
    ![在这里插入图片描述][20200607213403492.png]  
    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，就不用每次输入帐号密码了)：

# 将镜像保存为tar文件
    sudo docker save bolingcavalry/probedemo:0.0.1 > probedemo.tar
    
    # scp到kubernetes服务器
    sshpass -p 888888 scp ./probedemo.tar root@192.168.50.135:/root/temp/202006/04/ 
      
    # 远程执行ssh命令，加载docker镜像
    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:
        - port: 8080
          nodePort: 30080
      selector:
        name: probedemo
    ---
    apiVersion: extensions/v1beta1
    kind: Deployment
    metadata:
      name: probedemo
    spec:
      replicas: 2
      template:
        metadata:
          labels:
            name: probedemo
        spec:
          containers:
            - name: probedemo
              image: bolingcavalry/probedemo:0.0.1
              tty: true
              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
              ports:
                - containerPort: 8080
              resources:
                requests:
                  memory: "512Mi"
                  cpu: "100m"
                limits:
                  memory: "1Gi"
                  cpu: "500m"

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

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

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

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

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

### 官方忠告 ###

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

### 欢迎访问我的GitHub ###

*  地址：[https://github.com/zq2599/blog\_demos][https_github.com_zq2599_blog_demos]
 *  内容：原创文章分类汇总，及配套源码，涉及Java、Docker、K8S、DevOPS等

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

![在这里插入图片描述][format_png]

[SpringBoot_2.3_Docker]: https://blog.csdn.net/boling_cavalry/article/details/106597358
[SpringBoot_2.3_Docker 1]: https://blog.csdn.net/boling_cavalry/article/details/106598189
[SpringBoot-2.3]: https://blog.csdn.net/boling_cavalry/article/details/106605264
[SpringBoot-2.3 1]: https://blog.csdn.net/boling_cavalry/article/details/106606442
[SpringBoot-2.3 2]: https://blog.csdn.net/boling_cavalry/article/details/106607225
[SpringBoot-2.3_layer]: https://blog.csdn.net/boling_cavalry/article/details/106600620
[root_sudo_docker]: https://blog.csdn.net/boling_cavalry/article/details/106590784
[SpringBoot_K8S]: https://blog.csdn.net/boling_cavalry/article/details/106594392
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200607210533567.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70#pic_center
[20200607212339345.png]: https://img-blog.csdnimg.cn/20200607212339345.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200607212358481.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70
[20200607212411158.png]: https://img-blog.csdnimg.cn/20200607212411158.png
[20200607213403492.png]: https://img-blog.csdnimg.cn/20200607213403492.png
[20200607214007965.png]: https://img-blog.csdnimg.cn/20200607214007965.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020060721411219.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200607214125172.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200607214141251.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200607214232883.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200607214315331.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200607214329913.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/2020060721434892.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200607214413224.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200607214457868.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20200607214507677.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20200607214555794.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70
[20200607214711376.png]: https://img-blog.csdnimg.cn/20200607214711376.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/2020060721475937.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/20200607214811987.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 14]: https://img-blog.csdnimg.cn/20200607214855160.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70
[https_github.com_zq2599_blog_demos]: https://github.com/zq2599/blog_demos
[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL3pxMjU5OS9ibG9nX2RlbW9zL21hc3Rlci9maWxlcy9hYmMuanBn?x-oss-process=image/format,png