掌握SpringBoot-2.3的容器探針：實戰篇

時間 2020-06-11

標籤掌握 springboot 2.3 容器探針實戰欄目 Spring 简体版

原文原文鏈接

歡迎訪問個人GitHub

https://github.com/zq2599/blog_demosjava

內容：原創文章分類彙總，及配套源碼，涉及Java、Docker、K8S、DevOPS等
通過多篇知識積累終於來到實戰章節，親愛的讀者們，請將裝備就位，一塊兒動手體驗SpringBoot官方帶給咱們的最新技術；

關於《SpringBoot-2.3容器化技術》系列

《SpringBoot-2.3容器化技術》系列，旨在和你們一塊兒學習實踐2.3版本帶來的最新容器化技術，讓我們的Java應用更加適應容器化環境，在雲計算時代依舊緊跟主流，保持競爭力；
全系列文章分爲主題和輔助兩部分，主題部分以下：

輔助部分是一些參考資料和備忘總結，以下：

SpringBoot-2.3容器探針知識點小結

通過前面的知識積累，咱們知道了SpringBoot-2.3新增的探針規範以及適用場景，這裏作個簡短的回顧：node

kubernetes要求業務容器提供一個名爲livenessProbe的地址，kubernetes會定時訪問該地址，若是該地址的返回碼不在200到400之間，kubernetes認爲該容器不健康，會殺死該容器重建新的容器，這個地址就是存活探針；
kubernetes要求業務容器提供一個名爲readinessProbe的地址，kubernetes會定時訪問該地址，若是該地址的返回碼不在200到400之間，kubernetes認爲該容器沒法對外提供服務，不會把請求調度到該容器，這個地址就是就緒探針；
SpringBoot的2.3.0.RELEASE發佈了兩個新的actuator地址，/actuator/health/liveness和/actuator/health/readiness，前者用做存活探針，後者用做就緒探針，這兩個地址的返回值來自兩個新增的actuator：Liveness State和Readiness State；
SpringBoot應用根據特殊環境變量是否存在來斷定本身是否運行在容器環境，若是是，/actuator/health/liveness和/actuator/health/readiness這兩個地址就有返回碼，具體的值是和應用的狀態有對應關係的，例如應用啓動過程當中，/actuator/health/readiness返回503，啓動成功後返回200；
業務應用能夠經過Spring系統事件機制來讀取Liveness State和Readiness State，也能夠訂閱這兩個actuator的變動事件；
業務應用能夠經過Spring系統事件機制來修改Liveness State和Readiness State，此時/actuator/health/liveness和/actuator/health/readiness的返回值都會發生變動，從而影響kubernetes對此容器的行爲（參照第一點和第二點），例如livenessProbe返回碼變成503，致使kubernetes認爲容器不健康，從而殺死容器；

小結完畢，接下來開始實打實的編碼和操做實戰，驗證上述理論；nginx

實戰環境信息

本次實戰有兩個環境：開發和運行環境，其中開發環境信息以下：git

操做系統：Ubuntu 20.04 LTS 桌面版
CPU ：2.30GHz × 4，內存：32G，硬盤：1T NVMe
JDK：1.8.0_231
MAVEN：3.6.3
SpringBoot：2.3.0.RELEASE
Docker：19.03.10
開發工具：IDEA 2020.1.1 (Ultimate Edition)

運行環境信息以下：程序員

操做系統：CentOS Linux release 7.8.2003
Kubernetes：1.15

事實證實，用Ubuntu桌面版做爲開發環境是可行的，體驗十分順暢，IDEA、SubLime、SSH、Chrome、微信都能正常使用，下圖是個人Ubuntu開發環境：github

實戰內容簡介

本次實戰包括如下內容：web

開發SpringBoot應用，部署在kubernetes；
檢查應用狀態和kubernetes的pod狀態的關聯變化；
修改Readiness State，看kubernetes是否還會把請求調度到pod；
修改Liveness State，看kubernetes會不是殺死pod；

源碼下載

本次實戰用到了一個普通的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協議

這個git項目中有多個文件夾，本章的應用在probedemo文件夾下，以下圖紅框所示：

開發SpringBoot應用

請在IDEA上安裝lombok插件：

在IDEA上新建名爲probedemo的SpringBoot工程，版本選擇2.3.0：

該工程的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/> <!-- lookup parent from repository -->
    </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>
                <!--該配置會在jar中增長layer描述文件，以及提取layer的工具-->
                <configuration>
                    <layers>
                        <enabled>true</enabled>
                    </layers>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

應用啓動類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);
    }
}

增長一個監聽類，能夠監聽存活和就緒狀態的變化：

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());
    }
}

增長名爲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();
    }
}

增長名爲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();
    }

}

增長名爲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工程的全部代碼了，請確保能夠編譯運行；spring

製做Docker鏡像

在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"]

先編譯構建工程，執行如下命令：

mvn clean package -U -DskipTests

編譯成功後，經過Dockerfile文件建立鏡像：

sudo docker build -t bolingcavalry/probedemo:0.0.1 .

鏡像建立成功：

SpringBoot的鏡像準備完畢，接下來要讓kubernetes環境用上這個鏡像；docker

將鏡像加載到kubernetes環境

此時的鏡像保存在開發環境的電腦上，能夠有如下三種方式加載到kubernetes環境：shell

push到私有倉庫，kubernetes上使用時也從私有倉庫獲取；
push到hub.docker.com，kubernetes上使用時也從hub.docker.com獲取，目前我已經將此鏡像push到hub.docker.com，您在kubernetes直接使用便可，就像nginx、tomcat這些官方鏡像同樣下載；
在開發環境執行docker save bolingcavalry/probedemo:0.0.1 > probedemo.tar，可將此鏡像另存爲本地文件，再scp到kubernetes服務器，再在kubernetes服務器執行docker load < /root/temp/202006/04/probedemo.tar就能加載到kubernetes服務器的本地docker緩存中；

以上三種方法的優缺點整理以下：

首推第一種，可是須要您搭建私有倉庫；
因爲springboot-2.3官方對鏡像構建做了優化，第二種方法也就執行第一次的時候上傳和下載很耗時，以後修改java代碼從新構建時，不論上傳仍是下載都很快（只上傳下載某個layer）；
在開發階段，使用第三種方法最爲便捷，但若是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

在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"

執行命令kubectl apply -f probedemo..yaml，便可建立deployment和service：

這裏要重點關注的是livenessProbe的initialDelaySeconds和failureThreshold參數，initialDelaySeconds等於5，表示pod建立5秒後檢查存活探針，若是10秒內應用沒有完成啓動，存活探針不返回200，就會重試10次(failureThreshold等於10)，若是重試10次後存活探針依舊沒法返回200，該pod就會被kubernetes殺死重建，要是每次啓動都耗時這麼長，pod就會不停的被殺死重建；
執行命令kubectl apply -f probedemo.yaml，建立deployment和service，以下圖，可見在第十秒的時候pod建立成功，可是此時還未就緒：

繼續查看狀態，建立一分鐘後兩個pod終於就緒：

用kubectl describe命令查看pod狀態，事件通知顯示存活和就緒探針都有失敗狀況，不過由於有重試，所以後來狀態會變爲成功：

至此，從編碼到部署都完成了，接下來驗證SpringBoot-2.3.0.RELEASE的探針技術；

驗證SpringBoot-2.3.0.RELEASE的探針技術

監聽類AvailabilityListener的做用是監聽狀態變化，看看pod日誌，看AvailabilityListener的代碼是否有效，以下圖紅框，在應用啓動階段AvailabilityListener被成功回調，打印了存活和就緒狀態：

kubernetes所在機器的IP地址是192.168.50.135，所以SpringBoot服務的訪問地址是http://192.168.50.135:30080/xxx
訪問地址http://192.168.50.135:30080/actuator/health/liveness，返回碼以下圖紅框，可見存活探針已開啓：

就緒探針也正常：

打開兩個瀏覽器，都訪問：http://192.168.50.135:30080/hello，屢次Ctrl+F5強刷，以下圖，很快就能獲得不一樣結果，證實響應來自不一樣的Pod：

訪問：http://192.168.50.135:30080/statereader/get，能夠獲得存活和就緒的狀態，可見StateReader的代碼已經生效，能夠經過ApplicationAvailability接口取得狀態：

修改就緒狀態，訪問：http://192.168.50.135:30080/statewriter/refuse，以下圖紅框，可見收到請求的pod，其就緒狀態已經出現了異常，證實StateWritter.java中修改就緒狀態後，可讓kubernetes感知到這個pod的異常：

用瀏覽器反覆強刷hello接口，返回的Pod地址也只有一個，證實只有一個Pod在響應請求：

嘗試恢復服務，注意請求要在服務器後臺發送，並且IP地址要用剛纔被設置爲refuse的pod地址：

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

以下圖，狀態已經恢復：

最後再來試試將存活狀態從CORRECT改爲BROKEN，瀏覽器訪問：http://192.168.50.135:30080/statewriter/broken
以下圖紅框，重啓次數變成1，表示pod被殺死了一次，而且因爲重啓致使當前還未就緒，證實在SpringBoot中修改了存活探針的狀態，是會觸發kubernetes殺死pod的：