全鏈路監(jiān)控是什么？

概念解釋

全鏈路監(jiān)控，簡單來說就是追蹤一個請求從進入系統(tǒng)到返回結果的整個過程，記錄下每個環(huán)節(jié)的調用關系、耗時等信息。

就像你點了份外賣，從商家接單、廚師做菜、騎手取餐到最終送達，全程都有記錄和追蹤。

為什么需要方法級的全鏈路監(jiān)控？

定位性能瓶頸：哪個方法耗時最長，一目了然
異常追蹤：出了問題，直接定位到具體方法
服務依賴分析：清晰了解系統(tǒng)內部調用關系
告別無效加日志：不用再到處打印日志來排查問題

一、Spring Boot 項目打包

1.1 Jar 包打包（Maven/Gradle 打包配置、依賴打包方式）

在 Spring Boot 項目中，Jar 包是一種常用的打包方式，它可以將項目的所有依賴、類文件、資源文件等打包成一個可執(zhí)行的文件，方便部署和運行。下面分別介紹 Maven 和 Gradle 的打包配置以及依賴打包方式。

Maven 打包配置

在 Maven 項目中，打包配置主要在pom.xml文件中進行。首先，確保項目的pom.xml文件中包含 Spring Boot Maven 插件，該插件提供了對 Spring Boot 項目的打包支持。示例配置如下：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>2.7.1</version>
            <configuration>
                <!-- 設置main類，可省略，Spring Boot會自動檢測 -->
                <mainClass>com.example.demo.DemoApplication</mainClass>
                <!-- 是否跳過測試，true表示跳過 -->
                <skipTests>true</skipTests>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

在上述配置中，spring-boot-maven-plugin插件的repackage目標會將項目打包成一個可執(zhí)行的 Jar 包。configuration標簽內可以設置一些打包相關的屬性，如mainClass指定項目的主類，skipTests表示是否跳過測試。

Gradle 打包配置

對于 Gradle 項目，打包配置在build.gradle文件中。同樣需要應用 Spring Boot Gradle 插件，并進行相關配置。示例如下：

plugins {
    id 'org.springframework.boot' version '2.7.1'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    id 'java'
}
springBoot {
    mainClassName = 'com.example.demo.DemoApplication'
    // 是否跳過測試，true表示跳過
    skipTests = true
}
repositories {
    mavenCentral()
}
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    // 其他依賴
}

在這個build.gradle文件中，通過plugins塊應用了 Spring Boot 插件和其他相關插件。springBoot塊中設置了主類和跳過測試的屬性。

依賴打包方式

在打包 Jar 包時，有多種依賴打包方式可供選擇：

• 打包所有依賴（默認方式）：Spring Boot Maven 和 Gradle 插件默認會將項目的所有依賴打包進 Jar 包中。這種方式的優(yōu)點是部署時只需要一個 Jar 包，無需額外處理依賴；缺點是 Jar 包體積較大。例如，在 Maven 中，使用spring-boot-maven-plugin的默認配置即可實現(xiàn)所有依賴打包。
• 僅打包必要依賴：有時候，我們可能希望只打包項目運行所必需的依賴，而將一些公共依賴（如數(shù)據(jù)庫驅動等）在運行環(huán)境中單獨提供?？梢酝ㄟ^配置 Maven 或 Gradle 來排除不需要打包的依賴。例如，在 Maven 的pom.xml文件中，可以在依賴項中使用exclusions標簽排除特定依賴：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
    <exclusions>
        <exclusion>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
        </exclusion>
    </exclusions>
</dependency>

在 Gradle 中，可以使用exclude指令排除依賴：

implementation('org.springframework.boot:spring-boot-starter-jdbc') {
    exclude group: 'com.h2database', module: 'h2'
}

• 依賴分離打包：還可以將依賴和項目代碼分開打包，例如將依賴打包到一個單獨的目錄中，項目 Jar 包只包含代碼。這種方式可以減小項目 Jar 包的體積，并且便于依賴的管理和升級。在 Maven 中，可以使用maven-dependency-plugin插件將依賴復制到指定目錄，然后在運行時通過classpath指定依賴路徑；在 Gradle 中，可以通過配置configurations和copy任務來實現(xiàn)依賴分離打包。

1.2 War 包打包（修改打包類型、配置 SpringBootServletInitializer）

有時候，我們需要將 Spring Boot 項目打包成 War 包，以便部署到外部的 Servlet 容器（如 Tomcat）中。下面介紹如何將項目打包類型改為 war，并配置SpringBootServletInitializer。

修改打包類型

首先，在項目的pom.xml（Maven 項目）或build.gradle（Gradle 項目）文件中修改打包類型為war。

• Maven 項目：在pom.xml文件中，將packaging標簽的值改為war，示例如下：

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <!-- 修改打包類型為war -->
    <packaging>war</packaging> 
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.1</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <dependencies>
        <!-- 項目依賴 -->
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.7.1</version>
            </plugin>
        </plugins>
    </build>
</project>

• Gradle 項目：在build.gradle文件中，添加war插件并配置相關屬性，示例如下：

plugins {
    id 'org.springframework.boot' version '2.7.1'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    id 'war' // 添加war插件
    id 'java'
}
group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '11'
repositories {
    mavenCentral()
}
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    // 其他依賴
}
war {
    // 配置war包名稱，可省略，默認使用項目artifactId和version
    archiveFileName.set('demo.war') 
}

配置 SpringBootServletInitializer

為了使 Spring Boot 項目能夠在外部 Servlet 容器中正確運行，需要配置SpringBootServletInitializer。SpringBootServletInitializer是 Spring Boot 提供的一個用于將 Spring Boot 應用配置為 Servlet 3.0 + 初始化的類。

• Maven 項目：在項目的主類中，繼承SpringBootServletInitializer并重寫configure方法。示例如下：

package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
@SpringBootApplication
public class DemoApplication extends SpringBootServletInitializer {
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(DemoApplication.class);
    }
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

• Gradle 項目：同樣在主類中繼承SpringBootServletInitializer并重寫configure方法，配置與 Maven 項目類似。

完成上述配置后，使用 Maven 的mvn clean package命令或 Gradle 的gradle build命令即可將項目打包成 War 包。生成的 War 包可以部署到外部 Servlet 容器中，如將 War 包放置到 Tomcat 的webapps目錄下，啟動 Tomcat 即可運行項目。

1.3 打包常見問題（依賴沖突、資源文件路徑問題）

在打包 Spring Boot 項目時，可能會遇到一些常見問題，下面主要分析依賴沖突和資源文件路徑問題及解決方法。

依賴沖突

依賴沖突是指項目中引入的多個依賴庫依賴于同一個庫的不同版本，導致在編譯或運行時出現(xiàn)問題。例如，項目中同時引入了庫 A 和庫 B，庫 A 依賴于commons-io的 1.0 版本，庫 B 依賴于commons-io的 2.0 版本，這就會產生依賴沖突。

• 原因分析：依賴沖突通常是由于傳遞性依賴導致的。在 Maven 或 Gradle 項目中，一個依賴可能會引入其他依賴，這些被引入的依賴又可能引入更多依賴，形成復雜的依賴樹。如果不同的依賴路徑引入了同一個庫的不同版本，就會出現(xiàn)依賴沖突。此外，手動指定依賴版本時，如果與傳遞性依賴的版本不一致，也可能引發(fā)沖突。
• 解決方法：
  • 使用mvn dependency:tree或gradle dependencies排查沖突：在 Maven 項目中，可以使用mvn dependency:tree命令查看項目的依賴樹，該命令會顯示所有依賴及其版本信息，通過分析依賴樹可以找出沖突的依賴。例如，執(zhí)行mvn dependency:tree后，輸出結果中如果某個依賴出現(xiàn)了多個版本，就可能存在沖突。在 Gradle 項目中，可以使用gradle dependencies命令獲取類似的依賴信息。
  • 通過exclusions標簽排除沖突依賴：在pom.xml（Maven）或build.gradle（Gradle）文件中，可以使用exclusions標簽（Maven）或exclude指令（Gradle）排除沖突的依賴。例如，在 Maven 中，如果發(fā)現(xiàn)commons-io存在版本沖突，并且希望排除某個版本，可以在相關依賴中添加如下配置：

<dependency>
    <groupId>org.example</groupId>
    <artifactId>example-library</artifactId>
    <version>1.0.0</version>
    <exclusions>
        <exclusion>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
        </exclusion>
    </exclusions>
</dependency>

在 Gradle 中，對應的配置為：

implementation('org.example:example-library:1.0.0') {
    exclude group: 'commons-io', module: 'commons-io'
}

• 強制指定依賴版本：可以在dependencyManagement（Maven）或resolutionStrategy（Gradle）中強制指定某個依賴的版本，確保所有依賴都使用指定版本。例如，在 Maven 的pom.xml文件中：

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.0</version>
        </dependency>
    </dependencies>
</dependencyManagement>

在 Gradle 的build.gradle文件中：

configurations.all {
    resolutionStrategy {
        force 'commons-io:commons-io:2.0'
    }
}

資源文件路徑問題

在打包過程中，資源文件（如配置文件、靜態(tài)資源等）的路徑也可能出現(xiàn)問題，導致項目在運行時無法正確加載資源。

• 原因分析：常見的原因包括資源文件放置位置不正確、打包插件對資源文件的處理方式不當?shù)?。例如，?Spring Boot 項目中，配置文件通常放置在src/main/resources目錄下，如果手動修改了配置文件的位置，可能會導致加載失敗。另外，某些打包插件可能會改變資源文件在打包后的路徑結構，也會引發(fā)問題。
• 解決方法：
  • 遵循 Spring Boot 資源文件約定：Spring Boot 對資源文件的加載有一定的約定，盡量遵循這些約定可以避免很多路徑問題。例如，將配置文件命名為application.properties或application.yml，并放置在src/main/resources目錄下，Spring Boot 會自動加載這些文件。對于靜態(tài)資源，如 HTML、CSS、JavaScript 文件，可以放置在src/main/resources/static目錄下，Spring Boot 會將其映射到/static路徑下供前端訪問。
  • 配置資源文件路徑：如果由于特殊原因需要修改資源文件的位置，可以在application.properties或application.yml文件中配置資源文件路徑。例如，在application.properties中配置自定義配置文件路徑：

spring.config.location=classpath:/config/,file:/data/config/

上述配置表示 Spring Boot 會從classpath:/config/和file:/data/config/這兩個路徑下加載配置文件。

• 檢查打包插件配置：確保打包插件（如 Spring Boot Maven 插件或 Gradle 插件）的配置正確，不會錯誤地處理資源文件。例如，在 Maven 的spring-boot-maven-plugin插件中，可以通過resources標簽配置資源文件的包含和排除規(guī)則：

<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.yml</include>
            </includes>
            <excludes>
                <exclude>**/*.txt</exclude>
            </excludes>
        </resource>
    </resources>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>2.7.1</version>
        </plugin>
    </plugins>
</build>

在 Gradle 中，可以通過sourceSets配置資源文件路徑：

sourceSets {
    main {
        resources {
            srcDirs 'src/main/resources', 'src/main/config'
        }
    }
}

二、項目部署方式

2.1 本地部署（Jar 包命令啟動、War 包部署到 Tomcat）

在開發(fā)和測試階段，本地部署是一種常見的方式，方便快速驗證項目的功能。下面分別介紹如何通過命令啟動 Jar 包以及將 War 包部署到 Tomcat 服務器上。

Jar 包命令啟動

在本地，我們可以使用java -jar命令來啟動 Spring Boot 項目打包生成的 Jar 包。假設項目打包后生成的 Jar 包名為demo.jar，在命令行中進入到 Jar 包所在目錄，執(zhí)行以下命令：

java -jar demo.jar

這樣，Spring Boot 項目就會以默認配置啟動，應用程序會監(jiān)聽默認端口（通常是8080）。如果需要指定啟動參數(shù)，比如設置 Java 虛擬機的初始堆大小和最大堆大小，可以使用如下命令：

java -Xms512m -Xmx1024m -jar demo.jar

上述命令中，-Xms512m表示初始堆大小為512MB，-Xmx1024m表示最大堆大小為1024MB。另外，如果項目需要指定不同的配置文件，也可以通過命令行參數(shù)來實現(xiàn)。例如，假設項目有一個application-prod.properties的生產環(huán)境配置文件，我們可以使用如下命令啟動：

java -jar -Dspring.config.name=application-prod -Dspring.config.location=classpath:/config/ demo.jar

其中，-Dspring.config.name指定配置文件的名稱，-Dspring.config.location指定配置文件的路徑。

War 包部署到 Tomcat

當項目打包成 War 包后，我們可以將其部署到 Tomcat 服務器上。首先，確保已經(jīng)安裝并啟動了 Tomcat 服務器。然后，將生成的 War 包放置到 Tomcat 的webapps目錄下。例如，如果 Tomcat 安裝在/usr/local/tomcat目錄，將demo.war包復制到/usr/local/tomcat/webapps目錄下：

cp demo.war /usr/local/tomcat/webapps

Tomcat 在啟動時會自動解壓 War 包，并將應用部署到服務器中。部署完成后，可以通過訪問http://localhost:8080/demo（假設 Tomcat 默認端口為8080，demo為 War 包的名稱，也是應用的上下文路徑）來訪問項目。如果需要修改應用的上下文路徑，可以通過修改 Tomcat 的配置文件server.xml來實現(xiàn)。在server.xml文件中，找到Host標簽，添加或修改Context標簽，例如：

<Host name="localhost"  appBase="webapps"
      unpackWARs="true" autoDeploy="true">
    <Context path="/myapp" docBase="demo" reloadable="true" crossContext="true"/>
</Host>

上述配置中，path屬性指定了應用的上下文路徑為/myapp，docBase屬性指定了 War 包的名稱（不包含.war后綴）。修改完配置文件后，重啟 Tomcat 服務器，應用就可以通過http://localhost:8080/myapp來訪問了。

2.2 Linux 服務器部署（遠程上傳、后臺啟動、日志查看）

將 Spring Boot 項目部署到 Linux 服務器上是生產環(huán)境中常見的做法，下面詳細介紹相關步驟。

遠程上傳

首先，需要將打包好的 Jar 包或 War 包上傳到 Linux 服務器。常用的上傳方式有以下幾種：

• 使用scp命令：scp（Secure Copy）是一個基于 SSH 協(xié)議的安全文件傳輸命令。假設本地 Jar 包路徑為/Users/user/demo.jar，服務器 IP 為192.168.1.100，用戶名是root，服務器上的目標路徑為/root/app，則可以使用以下命令上傳：

scp /Users/user/demo.jar root@192.168.1.100:/root/app

執(zhí)行該命令后，系統(tǒng)會提示輸入服務器的密碼，輸入正確密碼后即可開始上傳。
使用ftp或sftp工具：可以使用圖形化的ftp或sftp工具，如 FileZilla 等。打開工具后，輸入服務器的 IP 地址、用戶名和密碼，連接到服務器。然后在本地找到 Jar 包或 War 包，將其拖放到服務器的目標目錄中。

• 使用git拉取：如果項目代碼托管在git倉庫中，可以在服務器上通過git clone命令拉取代碼，然后在服務器上進行打包操作。例如：

git clone https://github.com/yourusername/yourproject.git
cd yourproject
mvn clean package

后臺啟動

在 Linux 服務器上，為了避免終端關閉后應用程序也隨之關閉，我們通常使用nohup命令將應用程序放到后臺運行。假設上傳到服務器的 Jar 包名為demo.jar，可以使用以下命令啟動：

nohup java -jar demo.jar &

nohup命令會忽略所有掛斷（SIGHUP）信號，使應用程序在后臺持續(xù)運行。&符號表示將命令放到后臺執(zhí)行。啟動后，應用程序的輸出日志會默認輸出到當前目錄下的nohup.out文件中。如果希望將日志輸出到指定文件，比如/var/log/demo.log，可以使用如下命令：

nohup java -jar demo.jar > /var/log/demo.log 2>&1 &

上述命令中，>表示將標準輸出重定向到/var/log/demo.log文件，2>&1表示將標準錯誤輸出也重定向到標準輸出，即也輸出到/var/log/demo.log文件中。

日志查看
在項目運行過程中，查看日志是了解應用程序運行狀態(tài)和排查問題的重要手段。在 Linux 服務器上，可以使用以下命令查看日志：

• 使用tail命令實時查看日志：tail命令用于查看文件的末尾內容，-f參數(shù)可以實現(xiàn)實時跟蹤文件的變化。例如，查看/var/log/demo.log文件的實時日志：

tail -f /var/log/demo.log

使用該命令后，終端會實時顯示/var/log/demo.log文件的新增內容，方便及時了解應用程序的運行情況。

• 使用less命令查看日志：less命令可以用于查看文件內容，并且支持分頁查看、搜索等功能。例如，查看/var/log/demo.log文件：

less /var/log/demo.log

在less命令界面中，可以使用上下箭頭鍵滾動查看日志內容，輸入/keyword可以搜索指定關鍵詞，按q鍵退出查看。

2.3 Docker 容器部署（編寫 Dockerfile、構建鏡像、啟動容器）

Docker 是一種容器化技術，它可以將應用程序及其依賴打包成一個獨立的容器，實現(xiàn)快速部署和遷移。下面介紹如何使用 Docker 部署 Spring Boot 項目。

編寫 Dockerfile

Dockerfile是一個文本文件，用于定義如何構建 Docker 鏡像。在 Spring Boot 項目的根目錄下創(chuàng)建一個Dockerfile文件，內容如下：

# 使用官方的OpenJDK 11基礎鏡像
FROM openjdk:11-jre-slim
# 將項目的Jar包復制到容器內
COPY target/demo.jar app.jar
# 聲明容器運行時監(jiān)聽的端口，這里假設Spring Boot項目默認端口為8080
EXPOSE 8080
# 定義容器啟動時執(zhí)行的命令，運行Jar包
CMD ["java", "-jar", "app.jar"]

上述Dockerfile中，首先指定了基礎鏡像為openjdk:11-jre-slim，這是一個精簡的 OpenJDK 11 運行時環(huán)境鏡像。然后使用COPY指令將項目打包生成的demo.jar（假設打包后的 Jar 包名為demo.jar，位于target目錄下）復制到容器內并命名為app.jar。接著使用EXPOSE指令聲明容器運行時監(jiān)聽的端口為8080。最后，通過CMD指令定義容器啟動時執(zhí)行的命令，即運行app.jar。

構建鏡像

編寫好Dockerfile后，就可以使用docker build命令來構建 Docker 鏡像。在項目根目錄下，打開命令行，執(zhí)行以下命令：

docker build -t demo:v1.0.0.

其中，-t參數(shù)用于指定鏡像的標簽（tag），格式為倉庫名:標簽，這里demo為倉庫名，v1.0.0為標簽，表示版本號。最后的.表示當前目錄，即Dockerfile所在的目錄。執(zhí)行該命令后，Docker 會根據(jù)Dockerfile的定義逐步構建鏡像，構建過程中會顯示詳細的日志信息。如果構建成功，會生成一個名為demo:v1.0.0的鏡像。

啟動容器

鏡像構建完成后，就可以使用docker run命令啟動容器。執(zhí)行以下命令：

docker run -d -p 8080:8080 demo:v1.0.0

-d參數(shù)表示將容器在后臺運行，-p參數(shù)用于端口映射，將主機的8080端口映射到容器的8080端口，這樣就可以通過訪問主機的8080端口來訪問容器內運行的 Spring Boot 應用程序。demo:v1.0.0為要啟動的鏡像名稱和標簽。啟動容器后，可以使用docker ps命令查看正在運行的容器列表，確認容器是否成功啟動。如果需要停止容器，可以使用docker stop命令，后跟容器的 ID 或名稱。

2.4 部署自動化（Jenkins 集成 Git、自動構建與部署）

使用 Jenkins 集成 Git 倉庫可以實現(xiàn)代碼的自動拉取、構建和部署，大大提高開發(fā)和部署效率，實現(xiàn)持續(xù)集成和持續(xù)交付（CI/CD）。下面介紹具體的配置步驟。

安裝 Jenkins 與相關插件

首先，需要在服務器上安裝 Jenkins。可以根據(jù)服務器的操作系統(tǒng)，參考 Jenkins 官方文檔進行安裝。安裝完成后，在瀏覽器中訪問 Jenkins 的 Web 界面（通常為http://服務器IP:8080/jenkins，8080 為 Jenkins 默認端口，可根據(jù)實際情況修改），進行初始化設置。

安裝完成后，需要安裝相關插件。在 Jenkins 的管理頁面中，選擇 “管理 Jenkins” -> “管理插件”，在 “Available” 選項卡中搜索并安裝以下插件：

• Git 插件：用于與 Git 倉庫進行交互，實現(xiàn)代碼拉取。
• Maven 插件：用于構建 Java 項目，執(zhí)行 Maven 命令。
• Publish Over SSH 插件：用于將構建生成的文件通過 SSH 上傳到遠程服務器，實現(xiàn)部署。

配置 Jenkins 與 Git 的集成

安裝好插件后，進行以下配置：

• 配置 Git：進入 Jenkins 的 “系統(tǒng)管理” -> “系統(tǒng)設置”，在 “Git” 部分，配置 Git 的路徑。如果服務器上已經(jīng)安裝了 Git 并且在系統(tǒng)路徑中，可以直接留空讓 Jenkins 自動檢測；否則，需要手動指定 Git 的安裝路徑。
• 配置 GitHub 憑證：如果 Git 倉庫是私有的，需要配置憑證以便 Jenkins 能夠訪問該倉庫。在 “系統(tǒng)管理” -> “憑證” 中，添加 GitHub 的憑證。選擇 “Kind” 類型，如 “Username with password”（使用用戶名和密碼）或 “SSH Username with private key”（使用 SSH 密鑰），輸入相應的憑據(jù)信息并保存。

配置 Jenkins 項目使用 Git

在 Jenkins 中創(chuàng)建一個新的自由風格項目或選擇一個現(xiàn)有的項目，在項目配置頁面中進行以下設置：

• 源代碼管理：選擇 “Git”，輸入 Git 倉庫的 URL，如https://github.com/yourusername/yourproject.git 或 git@github.com:yourusername/yourproject.git。選擇之前配置好的憑據(jù)（如果倉庫是私有的），并配置要構建的分支，如*/main 或 */master。
• 構建觸發(fā)器：可以配置自動觸發(fā)構建任務的方式，如勾選 “GitHub hook trigger for GITScm polling”，當 GitHub 倉庫有代碼變更時自動觸發(fā)構建；或者勾選 “Poll SCM”，并配置輪詢頻率，如H/5 * * * *表示每 5 分鐘檢查一次倉庫是否有變更。
• 構建步驟：點擊 “Add build step”，選擇 “Invoke top-level Maven targets”（如果項目使用 Maven 構建），在 “Goals” 文本框中輸入 Maven 命令，如clean install，用于清理項目、編譯代碼、運行測試并生成可部署的 Jar 包。

配置構建后操作

在項目配置頁面的 “Post-build Actions” 部分，添加構建后操作：

• 上傳文件到遠程服務器（以 Publish Over SSH 插件為例）：如果選擇使用Publish Over SSH插件進行部署，首先在 “系統(tǒng)管理” -> “系統(tǒng)設置” 中配置 SSH 服務器信息，包括服務器 IP、用戶名、密碼或 SSH 密鑰等。然后在項目配置的 “Post-build Actions” 中，選擇 “Send files or execute commands over SSH”，配置要上傳的文件路徑（如target/demo.jar）和遠程服務器的目標路徑，以及上傳完成后在遠程服務器上執(zhí)行的命令（如啟動 Jar 包的命令）。
• 其他操作：還可以根據(jù)需要添加其他構建后操作，如發(fā)送郵件通知構建結果、歸檔構建產物等。

通過以上配置，當 Git 倉庫有代碼提交時，Jenkins 會自動拉取最新代碼，執(zhí)行構建和部署操作，實現(xiàn)項目的自動化部署。

三、Spring Boot 監(jiān)控（Actuator 與 Prometheus）

3.1 Spring Boot Actuator 整合（依賴導入、端點暴露配置）

Spring Boot Actuator 是 Spring Boot 提供的一個強大功能模塊，它可以幫助我們監(jiān)控和管理 Spring Boot 應用程序。通過 Actuator，我們能夠輕松獲取應用程序的健康狀況、性能指標、環(huán)境信息等，這些功能在開發(fā)、測試以及生產環(huán)境中都非常實用。

依賴導入

首先，我們需要在項目中引入 Spring Boot Actuator 依賴。如果使用 Maven 構建項目，在pom.xml文件中添加以下依賴：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

如果使用 Gradle，在build.gradle文件中添加：

implementation 'org.springframework.boot:spring-boot-starter-actuator'

添加依賴后，Maven 或 Gradle 會自動下載并將 Actuator 相關的庫添加到項目中。

端點暴露配置

在 Spring Boot 2.x 版本中，Actuator 的端點默認只暴露了/health和/info。如果我們想要暴露更多的端點，需要在配置文件（application.properties或application.yml）中進行配置。

使用application.properties配置時：

# 暴露所有端點
management.endpoints.web.exposure.include=* 
# 或者指定暴露某些端點，如health、info、metrics
# management.endpoints.web.exposure.include=health,info,metrics 

使用application.yml配置時：

management:
  endpoints:
    web:
      exposure:
        include: '*' 
        # 或者指定暴露某些端點
        # include: health,info,metrics 

上述配置中，management.endpoints.web.exposure.include屬性用于指定要暴露的端點。*表示暴露所有端點；如果只想暴露特定端點，如health、info、metrics，則將其以逗號分隔列出即可。另外，還可以通過management.endpoints.web.exposure.exclude屬性來排除某些端點，例如：

management.endpoints.web.exposure.exclude=env

這表示不暴露/env端點，其他端點按照include的配置進行暴露。

3.2 核心端點使用（/health 健康檢查、/info 項目信息、/metrics 指標）

Spring Boot Actuator 提供了多個核心端點，每個端點都有其特定的功能，下面詳細介紹/health、/info和/metrics這三個常用端點的使用方法。

/health 健康檢查

/health端點用于檢查應用程序的健康狀況。它會返回一個 JSON 格式的響應，告知應用程序是否正常運行，以及各個組件（如數(shù)據(jù)庫連接、磁盤空間等）的健康狀態(tài)。例如，當我們訪問http://localhost:8080/actuator/health（假設應用程序運行在本地 8080 端口）時，可能得到如下響應：

{
    "status": "UP",
    "components": {
        "diskSpace": {
            "status": "UP",
            "details": {
                "total": 499763210752,
                "free": 304417739264,
                "threshold": 10485760
            }
        },
        "ping": {
            "status": "UP"
        }
    }
}

在這個響應中，status字段表示應用程序的整體健康狀態(tài)，UP表示正常，DOWN表示異常。components字段包含了各個組件的健康信息，例如diskSpace表示磁盤空間檢查結果，ping是一個簡單的心跳檢查。如果應用程序依賴數(shù)據(jù)庫，還會包含數(shù)據(jù)庫連接的健康信息。我們可以通過實現(xiàn)HealthIndicator接口來自定義健康檢查邏輯。例如，創(chuàng)建一個自定義的健康檢查類：

import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Component;
@Component
public class CustomHealthIndicator implements HealthIndicator {
    @Override
    public Health health() {
        // 自定義健康檢查邏輯，例如檢查某個服務是否可用
        boolean isServiceAvailable = checkServiceAvailability(); 
        if (isServiceAvailable) {
            return Health.up().withDetail("Service Status", "Available").build();
        } else {
            return Health.down().withDetail("Service Status", "Unavailable").build();
        }
    }
    private boolean checkServiceAvailability() {
        // 實際的服務可用性檢查邏輯
        // 這里可以是調用遠程服務的接口，檢查響應等
        return true; 
    }
}

上述代碼中，CustomHealthIndicator類實現(xiàn)了HealthIndicator接口，并重寫了health方法。在health方法中，通過調用checkServiceAvailability方法來檢查服務的可用性，并根據(jù)結果返回不同的健康狀態(tài)和詳細信息。

/info 項目信息

/info端點用于返回應用程序的自定義信息，例如應用的版本號、描述、構建時間等。默認情況下，/info端點返回一個空的 JSON 對象。我們可以通過在配置文件中添加自定義信息來豐富其返回內容。在application.properties文件中添加：

info.app.name=My Spring Boot Application
info.app.version=1.0.0
info.app.description=This is a sample Spring Boot application with Actuator.

在application.yml文件中添加：

info:
  app:
    name: My Spring Boot Application
    version: 1.0.0
    description: This is a sample Spring Boot application with Actuator.

配置完成后，訪問http://localhost:8080/actuator/info，將得到如下響應：

{
    "app": {
        "name": "My Spring Boot Application",
        "version": "1.0.0",
        "description": "This is a sample Spring Boot application with Actuator."
    }
}

此外，我們還可以通過實現(xiàn)InfoContributor接口來自定義/info端點返回的信息。例如：

import org.springframework.boot.actuate.info.Info;
import org.springframework.boot.actuate.info.InfoContributor;
import org.springframework.stereotype.Component;
import java.util.Collections;
@Component
public class CustomInfoContributor implements InfoContributor {
    @Override
    public void contribute(Info.Builder builder) {
        builder.withDetail("customInfo", Collections.singletonMap("key", "value"));
    }
}

上述代碼中，CustomInfoContributor類實現(xiàn)了InfoContributor接口，在contribute方法中，使用Info.Builder添加了自定義信息customInfo，其值為一個包含key和value的 Map。此時訪問/info端點，返回的 JSON 數(shù)據(jù)中會包含這個自定義信息。

/metrics 指標

/metrics端點提供了應用程序的各種度量指標，如內存使用情況、CPU 使用率、HTTP 請求統(tǒng)計等。訪問http://localhost:8080/actuator/metrics，會得到一個包含所有可用指標的列表，每個指標都有其對應的描述和值。例如，獲取 JVM 內存使用情況的指標：

{
    "name": "jvm.memory.used",
    "description": "The amount of used memory",
    "baseUnit": "bytes",
    "measurements": [
        {
            "statistic": "VALUE",
            "value": 1.23456789E8
        }
    ],
    "availableTags": [
        {
            "tag": "area",
            "values": ["heap", "nonheap"]
        },
        {
            "tag": "id",
            "values": ["PS Eden Space", "PS Survivor Space", "PS Old Gen", "Metaspace", "Compressed Class Space"]
        }
    ]
}

在這個響應中，name字段表示指標名稱，description是指標描述，baseUnit是指標的基本單位，measurements包含了指標的具體測量值，availableTags則列出了可以用于細分指標的標簽。如果我們只想獲取某個特定指標的數(shù)據(jù)，可以在/metrics后面加上指標名稱，例如http://localhost:8080/actuator/metrics/jvm.memory.used。我們還可以使用 Micrometer 提供的 API 來創(chuàng)建自定義指標。例如，在 Spring Boot 應用中，使用MeterRegistry來記錄一個自定義的計數(shù)器指標：

import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Counter;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class MetricController {
    private final Counter requestCounter;
    public MetricController(MeterRegistry meterRegistry) {
        this.requestCounter = meterRegistry.counter("requests_count");
    }
    @GetMapping("/metric")
    public String metric() {
        requestCounter.increment(); 
        return "Metric updated!";
    }
}

上述代碼中，MetricController類通過構造函數(shù)注入了MeterRegistry，并使用它創(chuàng)建了一個名為requests_count的計數(shù)器requestCounter。在metric方法中，每次請求都會使計數(shù)器增加 1。此時訪問/actuator/metrics/requests_count，就可以獲取到這個自定義指標的統(tǒng)計數(shù)據(jù)。

3.3 Prometheus+Grafana 整合（監(jiān)控指標采集、可視化面板配置）

Prometheus 是一個開源的系統(tǒng)監(jiān)控和警報工具包，而 Grafana 是一個開源的多平臺可視化工具，它們結合使用可以實現(xiàn)對 Spring Boot 應用的全面監(jiān)控和可視化展示。下面介紹如何將 Prometheus 與 Spring Boot 集成進行監(jiān)控指標采集，以及如何使用 Grafana 配置可視化面板。

監(jiān)控指標采集

1. 添加依賴：在 Spring Boot 項目中，為了讓 Prometheus 能夠采集到應用的指標數(shù)據(jù)，需要添加 Spring Boot Actuator 和 Micrometer Prometheus Registry 的依賴。如果使用 Maven，在pom.xml文件中添加：

<dependencies>
    <!-- Spring Boot Actuator -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <!-- Micrometer Prometheus Registry -->
    <dependency>
        <groupId>io.micrometer</groupId>
        <artifactId>micrometer-registry-prometheus</artifactId>
    </dependency>
</dependencies>

如果使用 Gradle，在build.gradle文件中添加：

implementation 'org.springframework.boot:spring-boot-starter-actuator'
implementation 'io.micrometer:micrometer-registry-prometheus'

2. 配置 Actuator：在配置文件（application.properties或application.yml）中配置 Actuator，以暴露 Prometheus 端點。使用application.properties配置：

management.endpoints.web.exposure.include=prometheus
management.metrics.export.prometheus.enabled=true

使用application.yml配置：

management:
  endpoints:
    web:
      exposure:
        include: prometheus
  metrics:
    export:
      prometheus:
        enabled: true

上述配置中，management.endpoints.web.exposure.include指定暴露prometheus端點，management.metrics.export.prometheus.enabled啟用 Prometheus 的指標導出功能。

3. 啟動 Prometheus：可以從 Prometheus 官網(wǎng)下載適用于本地操作系統(tǒng)的二進制文件，解壓后，通過命令行啟動。例如，在解壓后的目錄中執(zhí)行：

./prometheus --config.file=prometheus.yml

其中，prometheus.yml是 Prometheus 的配置文件。也可以使用 Docker 來啟動 Prometheus，執(zhí)行以下命令：

docker pull prom/prometheus
docker run --name prometheus -d -p 9090:9090 prom/prometheus

這將拉取 Prometheus 鏡像并在本地啟動一個容器，映射容器的 9090 端口到主機的 9090 端口，通過訪問http://localhost:9090可以打開 Prometheus 的 Web 界面。

4. 配置 Prometheus：在prometheus.yml配置文件中，添加 Spring Boot 應用作為監(jiān)控目標。例如：

scrape_configs:
  - job_name:'spring-boot-application'
    metrics_path: '/actuator/prometheus'
    scrape_interval: 15s
    static_configs:
      - targets: ['localhost:8080']

上述配置中，job_name是抓取任務的名稱，可自定義；metrics_path指定 Spring Boot 應用中 Prometheus 端點的路徑，默認是/actuator/prometheus；scrape_interval定義了 Prometheus 抓取指標數(shù)據(jù)的頻率，這里設置為每 15 秒抓取一次；static_configs中的targets指定了 Spring Boot 應用的地址和端口，這里假設應用運行在本地 8080 端口。配置完成后，Prometheus 會按照設定的頻率從 Spring Boot 應用的/actuator/prometheus端點抓取指標數(shù)據(jù)。

可視化面板配置

1. 安裝 Grafana：可以從 Grafana 官網(wǎng)下載安裝包進行安裝，也可以使用 Docker 安裝。使用 Docker 安裝的命令如下：

docker pull grafana/grafana
docker run -d --name=grafana -p 3000:3000 grafana/grafana

這將拉取 Grafana 鏡像并啟動一個容器，映射容器的 3000 端口到主機的 3000 端口，通過訪問http://localhost:3000可以打開 Grafana 的登錄界面，默認用戶名和密碼是admin/admin。

• 配置數(shù)據(jù)源：登錄 Grafana 后，點擊左側菜單欄的 “Configuration” -> “Data Sources”，然后點擊 “Add data source”，選擇 “Prometheus”。在配置頁面中，填寫 Prometheus 的 URL，例如http://localhost:9090，保存并測試數(shù)據(jù)源，確保連接正常。
• 創(chuàng)建可視化面板：點擊左側菜單欄的 “+” 號，選擇 “Dashboard”，然后點擊 “Add query”。在查詢編輯器中，選擇之前配置的 Prometheus 數(shù)據(jù)源，并使用 Prometheus 查詢語言（PromQL）編寫查詢語句來獲取要展示的指標數(shù)據(jù)。例如，要展示 HTTP 請求的總數(shù)，可以使用查詢語句http_server_requests_total。選擇合適的可視化類型，如柱狀圖、折線圖、儀表盤等，調整面板的樣式和參數(shù)，最后保存面板。還可以通過導入 Grafana 官方或社區(qū)提供的模板來快速創(chuàng)建可視化面板。在 Dashboard 頁面，點擊 “Import”，輸入模板 ID 或上傳模板文件，選擇數(shù)據(jù)源后即可導入模板并查看可視化效果。

3.4 告警配置（基于 Grafana 設置異常指標告警）

在 Grafana 中設置告警規(guī)則可以幫助我們及時發(fā)現(xiàn)應用程序中的異常情況，當監(jiān)控指標出現(xiàn)異常時及時發(fā)出警報。下面介紹如何在 Grafana 中進行告警配置。

1. 設置告警通知渠道：在 Grafana 中，首先需要配置告警通知渠道，以便在告警觸發(fā)時能夠將通知發(fā)送出去。常見的通知渠道有郵件、釘釘機器人、Webhook 等。以配置郵件通知為例，點擊左側菜單欄的 “Configuration” -> “Notification channels”，然后點擊 “Add channel”，選擇 “Email”。在配置頁面中，填寫郵件服務器的相關信息，如 SMTP 服務器地址、端口、用戶名、密碼等，以及接收告警通知的郵件地址，保存配置。如果要配置釘釘機器人通知，同樣在 “Add channel” 中選擇 “Webhook”，在 Webhook URL 中填寫釘釘機器人的 Webhook 地址，并根據(jù)釘釘機器人的要求設置請求頭和請求體等參數(shù)。
2. 創(chuàng)建告警規(guī)則：點擊要設置告警規(guī)則的面板，然后點擊面板右上角的 “Edit” 按鈕進入編輯模式。在編輯模式下，找到 “Alert” 選項卡，點擊 “Create alert rule”。在告警規(guī)則設置頁面，首先設置告警規(guī)則的名稱，例如 “High CPU Usage Alert”。然后選擇數(shù)據(jù)源，這里選擇之前配置的 Prometheus 數(shù)據(jù)源。接著編寫告警觸發(fā)條件，使用 PromQL 語句來定義。例如，要設置當 CPU 使用率超過 80% 時觸發(fā)告警，可以使用以下 PromQL 語句：

100 - (avg by (instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80

上述語句中，node_cpu_seconds_total{mode=“idle”}表示獲取 CPU 空閑時間指標，irate函數(shù)用于計算每秒的變化率，avg by (instance)表示按實例進行平均，最后計算出 CPU 使用率，并判斷是否大于 80%。設置告警的觸發(fā)條件后，還可以設置告警的評估周期（For），例如設置為 “5m”，表示當 CPU 使用率連續(xù) 5 分鐘超過 80% 時才觸發(fā)告警，這樣可以避免短暫的波動導致誤告警。在 “Notifications” 選項中，選擇之前配置好的通知渠道，如郵件或釘釘機器人。還可以添加一些注解（Annotations），用于在告警通知中顯示更多的信息，例如告警的原因、解決方法等。

3. 測試和啟用告警規(guī)則：完成告警規(guī)則設置后，點擊 “Test rule” 按鈕可以手動測試告警規(guī)則是否正常工作。Grafana 會模擬觸發(fā)告警條件，檢查是否能夠正確發(fā)送通知。如果測試通過，點擊 “Enable alert rule” 按鈕啟用告警規(guī)則。此后，當監(jiān)控指標滿足告警觸發(fā)條件時，Grafana 會按照配置的通知渠道發(fā)送告警通知，幫助我們及時發(fā)現(xiàn)和處理。

到此這篇關于Spring Boot從打包到監(jiān)控的全鏈路攻略的文章就介紹到這了,更多相關Spring Boot從打包到監(jiān)控內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！