【接口持续集成】详解Ubuntu搭建Jenkins实现Apifox远程触发持续集成接口自动化

一、环境准备

1、我的服务器系统,查看自己的系统配置: cat /etc/os-release

PRETTY_NAME="Ubuntu 24.04 LTS"
NAME="Ubuntu"
VERSION_ID="24.04"
VERSION="24.04 LTS (Noble Numbat)"

2、配置Jenkins 的 Debian 软件包存储库，用于自动安装和升级。要使用此存储库，请首先将密钥添加到您的系统中：

curl -fsSL https://pkg.jenkins.io/debian/jenkins.io-2023.key | sudo tee \
/usr/share/keyrings/jenkins-keyring.asc > /dev/null

3、然后添加 Jenkins apt 存储库条目：

echo deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] \
https://pkg.jenkins.io/debian binary/ | sudo tee \
/etc/apt/sources.list.d/jenkins.list > /dev/null

4、更新系统

sudo apt update
sudo apt upgrade

1、安装JDK

sudo apt install openjdk-11-jre

验证

java -version

2、安装Jenkins

sudo apt-get install -y jenkins

3、安装nodejs和npm

这个是因为使用了第三方Apifox，持续集成用到了Apifox-cli，这个下载需要npm下载。

sudo apt update
sudo apt install nodejs npm

验证

node --version
npm --version

全局下载Apifox-cli

sudo npm install -g apifox-cli

单独全局下载之后，在我们的pipeline脚本里面就不用加这条命令，可以规避很多报错问题。

4、配置环境变量

配置APIFOX_TOKEN，参考之前的文章，这个需要安装好Jenkins后配置

二、安装java

sudo apt-get update
sudo apt-get install -y openjdk-17-jdk

如果你在 /usr/lib/jvm 目录下找不到 java-17-openjdk-amd64 或相应的 bin/java 文件，那么可能是 OpenJDK 17 没有正确安装。我们可以尝试重新安装 OpenJDK 17，并确保安装过程没有出错。

上面这一步安装如果有问题，就跟着下面操作，如果没有问题直接跳到第6步，如果安装错了要卸载，跳到第8步。

1. 确认安装包

首先，确认系统中是否有 OpenJDK 17 的安装包：

sudo apt-cache search openjdk-17

你应该能看到类似如下的输出：

openjdk-17-jdk - OpenJDK Development Kit (JDK)
openjdk-17-jre - OpenJDK Java runtime, using Hotspot JIT
openjdk-17-doc - OpenJDK Development Kit (JDK) documentation
openjdk-17-source - OpenJDK Development Kit (JDK) source files

2. 安装 OpenJDK 17

如果确认有 openjdk-17-jdk 包，可以重新安装 OpenJDK 17：

sudo apt-get update
sudo apt-get install -y openjdk-17-jdk

3. 查找安装路径

安装完成后，再次检查 /usr/lib/jvm 目录，确认安装路径：

ls /usr/lib/jvm

你应该能看到 java-17-openjdk-amd64 或类似的目录。

4. 确认 Java 可执行文件路径

检查 java-17-openjdk-amd64 目录下是否有 bin/java 文件：

ls /usr/lib/jvm/java-17-openjdk-amd64/bin/java

如果文件存在，继续下一步。如果文件仍然不存在，可能是安装过程中出现了问题。

5. 更新 update-alternatives

使用正确的路径来配置 update-alternatives：

sudo update-alternatives --install /usr/bin/java java /usr/lib/jvm/java-17-openjdk-amd64/bin/java 1

然后选择 Java 版本：

sudo update-alternatives --config java

6. 设置 JAVA_HOME 环境变量

编辑你的 .bashrc 或 .bash_profile 文件，添加以下内容：

export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
export PATH=$JAVA_HOME/bin:$PATH

保存并关闭文件，然后使更改生效：

source ~/.bashrc

7. 验证 Java 版本

最后，验证 Java 是否正确安装并配置：

java -version

你应该能看到类似如下的输出：

openjdk version "17.0.x" 2024-xx-xx
OpenJDK Runtime Environment (build 17.0.x+xx-xx)
OpenJDK 64-Bit Server VM (build 17.0.x+xx-xx, mixed mode, sharing)

没有问题就不用看第8步了。

8、如果java装错了，就要卸载java，方法如下

查看 JDK 和 JRE 的安装路径

sudo update-alternatives --config java
sudo update-alternatives --config javac

查看所有 JAVA 安装版本

sudo update-java-alternatives -l

卸载java

sudo update-alternatives --remove "java" "/usr/lib/jvm/java-11-openjdk-amd64/bin/java"
sudo update-alternatives --remove "java" "/usr/lib/jvm/java-17-openjdk-amd64/bin/java"

三、Jenkins初始化配置

1、前面我们已经下载好了Jenkins，下载完成会自动启动

sudo apt-get install -y jenkins

2、如果你的服务器使用了8080端口，可能就会启动不起来，需要更改Jenkins的启动端口，文章后面也会进行配置。

3、查看自己Jenkins的启动地址和端口。

ps aux | grep jenkins

示列显示如下：

jenkins  3451305  0.8 19.9 7421080 1182584 ?     Ssl  08:02   0:59 /usr/bin/java -Djava.awt.headless=true -jar /usr/share/java/jenkins.war --webroot=/var/cache/jenkins/war --httpPort=8080
root     3529857  0.0  0.0   6544  2200 pts/0    S+   09:58   0:00 grep jenkins

可以看到端口是8080，这时候我们通过服务器地址加上这个端口就可以访问Jenkins了。

1、解锁Jenkins

进来第一个页面是需要输入密码才能访问，我们通过以下命令获取密码即可。

 cat /var/lib/jenkins/secrets/initialAdminPassword

2、自定义Jenkins

如果选择安装推荐的插件，则需要耗费很长的时间，这里我们自己选择插件来安装

点击选择插件来安装后，来到这个页面，我们点击无，点击后确认页面无勾选，最后点击安装则可以快速进入到下一步。

点击安装之后，会让你创建第一个管理员用户，这里可以根据你的实际需求来设置，也可以点击使用admin账户继续。

vincent
vincent123

3、实例配置

默认为8080端口，如果端口会有冲突，可以修改为其他端口，我这里设置为8689，注意这里不是修改的jenkins启动端口，如果要修改启动端口，需要修改配置文件，启动端口和实例配置端口最好是一致的。

4、修改Jenkins启动端口

1、关闭jenkins服务

sudo systemctl stop jenkins

2、检查jenkins服务为停止状态

sudo systemctl status jenkins

3、修改HTTP端口，找到配置文件中的Environment="JENKINS_PORT=8080"，修改为前面我们配置的8689端口。

sudo nano /usr/lib/systemd/system/jenkins.service

4、修改成功后，按 Ctrl+O 保存文件，按 Enter 确认，然后按 Ctrl+X 退出编辑器。

5、检查是否修改成功

# 查看所有内容
sudo cat  /usr/lib/systemd/system/jenkins.service
# 查看指定内容
sudo grep 'JENKINS_PORT'  /usr/lib/systemd/system/jenkins.service

6、重新加载Systemd配置，修改 jenkins.service 文件后，需要重新加载 systemd 配置以使更改生效

sudo systemctl daemon-reload

7、重启jenkins服务

sudo systemctl restart jenkins

8、验证jenkins启动状态及端口

sudo systemctl status jenkins

这里可以看到启动端口修改成了8689，通过新端口再次访问jenkins，使用管理员账号登录。

到此，Jenkins在Ubuntu系统上安装好了。

5、设置jenkins编码为utf8

为什么修改这个，是因为之前我在windows上运行输出日志的时候中文会有乱码，为了预防这个问题，可以提前配置一下。

Jenkins 的默认配置文件通常位于/usr/lib/systemd/system/jenkins.service,不同的系统可能会有所差异，具体的可以参考文末总结【关于Jenkins配置文件】

1、找到JAVA_OPTS参数，我们需要新增-Dfile.encoding=UTF-8

# 查看
sudo cat /usr/lib/systemd/system/jenkins.service
# 修改
sudo nano /usr/lib/systemd/system/jenkins.service

2、修改为如下

3、重新加载 systemd 配置、重启Jenkins服务

sudo systemctl daemon-reload
sudo systemctl restart jenkins
sudo systemctl status jenkins

4、可以看到启动的时候已经带了参数

四、Jenkins下载相关插件及配置

1、Manage Jenkins -> Plugins -> Available plugins

2、搜索下载Pipeline、Pipeline:Step API、Pipeline:Stage Step

3、等待下载完成

参考这篇，进行后面的配置即可。【接口自动化】Apifox结合Jenkins持续集成接口自动化测试

• 1、新建一个Pipeline流水线项目

• 2、编写Pipeline script

• 3、配置相关全局变量

• 4、build调试

4、Pipeline script - 新增报告展示示列（Shell命令）

pipeline {
  agent any

  stages {
    stage('下载 Apifox CLI') {
      steps {
        sh 'npm install -g apifox-cli'
      }
    }

    stage('场景一：注册新手引导全流程') {
      steps {
        sh 'apifox run --access-token $APIFOX_ACCESS_TOKEN -t 4888888 -e 22555555 -n 1 -r html,cli'
      }
    }
    stage('场景二：AI聊天-非会员上限') {
      steps {
        sh 'apifox run --access-token $APIFOX_ACCESS_TOKEN -t 4888888 -e 22222222 -n 1 -r html,cli'
      }
    }
    
    stage('场景三：AI聊天-会员过期无法聊天') {
      steps {
        sh 'apifox run --access-token $APIFOX_ACCESS_TOKEN -t 4888888 -e 22559136 -n 1 -r html,cli'
      }
    }
  }
    post {
            always {
               // 发布 HTML 报告
            publishHTML([
                reportDir: 'apifox-reports',
                reportFiles: 'apifox-report-*.html',
                reportName: 'HTML Reports',
                keepAll: true,
                alwaysLinkToLastBuild: true,
                allowMissing: false
                ])
            }
        }
}

• reportDir：报告文件所在的目录。

• reportFiles：报告文件的名称或通配符模式。

• reportName：报告的名称。

• keepAll：是否保留所有发布的报告。设置为 true 表示保留所有报告，设置为 false 表示只保留最新的报告。

• alwaysLinkToLastBuild：是否始终链接到最新的构建。设置为 true 表示始终链接到最新的构建，设置为 false 表示不这样做。

• allowMissing：是否允许报告文件缺失。设置为 true 表示允许报告文件缺失，设置为 false 表示不允许。

5、配置全局变量

Dashboard -> Manage Jenkins -> System Configuration -> System -> Global properties -> Environment variables -> Add

APIFOX_ACCESS_TOKEN:自己在Apifox里面生成加到这里

6、远程触发器构建

远程触发Jenkins启动这个任务：

需要配置好多东西，涉及到gitlab的一些内容，这个部分我交给开发弄了，要自己配的牛马就自己配吧，我不配了。

7、HTML报告展示

插件下载HTML Publisher

Dashboard -> Manage Jenkins -> Plugins -> Available plugins -> 搜索HTML Publisher，点击Install

安装完成后需要重启jenkins服务，freestyle的可以在构建后中选择这个报告进行配置，pipeline在脚本中写，前面写了。

workspace : /var/lib/jenkins/workspace/LovlingoAPITest

查看报告发现没有样式

控制台报错

解决样式问题

官方解释：Configuring Content Security Policy (jenkins.io)：

https://www.jenkins.io/doc/book/security/configuring-content-security-policy/

出现该现象的原因在于Jenkins中配置的CSP（Content Security Policy）。

简单地说，这是Jenkins的一个安全策略，默认会设置为一个非常严格的权限集，以防止Jenkins用户在workspace、/userContent、archived artifacts中受到恶意HTML/JS文件的攻击。

解决方案：

官方文档给出：

❝

If its value is the empty string, e.g. java -Dhudson.model.DirectoryBrowserSupport.CSP= -jar jenkins.war then the header will not be sent at all.

我的Jenkins是安装在Ubuntu上通过systemctl管理jenkins服务的版本，通过修改/usr/lib/systemd/system/jenkins.service, 在Environment="JAVA_OPS=-Djava.awt.headless=true后面加上 -Dhudson.model.DirectoryBrowserSupport.CSP=

然后systemctl daemon-reload重新加载配置，再systemctl restart jenkins。

Windows版本的就直接在启动的命令行中加：

java  -Dfile.encoding=UTF8  -Dhudson.model.DirectoryBrowserSupport.CSP= -jar jenkins.war

Ubutun中和修改编码格式那一样，在后面加上-Dhudson.model.DirectoryBrowserSupport.CSP=就行，记得要执行修改重启。

之后再进来报告页面就ok了

8、集成单次报告汇总发送到钉钉群

钉钉机器人配置参考：
python之钉钉机器人自动发消息——傻瓜式教程
需要注意的是，这篇文章里面是配置的screct，我们现在使用的是自定义关键字配置。简单来说，只有你发送的消息里面包含关键字，才会被运行发送到钉钉群。

Shell版本

pipeline {
  agent any
  
  environment {
        REPORT_DIR = 'apifox-reports'
    }

  stages {
  
	stage('Clean Report Directory') {
            steps {
                // 清理旧的报告目录
                sh "rm -rf ${REPORT_DIR}"
                sh "mkdir ${REPORT_DIR}"
            }
        }
		

    stage('场景一：注册新手引导全流程') {
      steps {
        sh 'apifox run --access-token $APIFOX_ACCESS_TOKEN -t 4888888 -e 2222222 -n 1 -r html,cli'
      }
    }
    stage('场景二：AI聊天-非会员上限') {
      steps {
        sh 'apifox run --access-token $APIFOX_ACCESS_TOKEN -t 4888888 -e 2222222 -n 1 -r html,cli'
      }
    }
    
    stage('场景三：AI聊天-会员过期无法聊天') {
      steps {
        sh 'apifox run --access-token $APIFOX_ACCESS_TOKEN -t 4888888 -e 2222222 -n 1 -r html,cli'
      }
    }
  }
    post {
            always {
			script {
               // 发布 HTML 报告
            publishHTML([
                reportDir: 'apifox-reports',
                reportFiles: 'apifox-report-*.html',
                reportName: 'HTML Reports',
                keepAll: false,
                alwaysLinkToLastBuild: true,
                allowMissing: true
                ])
			// 获取所有报告的 URL
			def reportUrl = "${env.JOB_URL}HTML_20Reports"
			// 获取当前时间并格式化
			def date = new Date()
			def formattedDate = date.format("yyyy-MM-dd HH:mm:ss", TimeZone.getTimeZone('Asia/Shanghai'))
		
			// 生成钉钉消息内容
			sh """
			curl "https://oapi.dingtalk.com/robot/send?access_token=976abf703dbceb5a82dc9761b1abd4c73526f782287d5aff89968532415ba8"  -H "Content-Type: application/json" -d "{'msgtype': 'markdown','markdown': {'title':'API测试报告','text': '### Build ${env.BUILD_NUMBER} completed. \\n ### API Report URL [Click To See](${reportUrl}) \\n ##### Build Time:$formattedDate '},'at': {'isAtAll': true}}"
			"""
            }
			}
        }
}

运行展示：

windows-批处理版本

pipeline {
  agent any
  
  environment {
        LANG = 'zh_CN.UTF-8'
        REPORT_DIR = 'apifox-reports'
        REPORT_FILE = "apifox-report-${env.BUILD_NUMBER}.html"
    }

  stages {
	stage('Clean Report Directory') {
            steps {
                // 清理旧的报告目录
                bat "if exist ${REPORT_DIR} rd /s /q ${REPORT_DIR}"
                bat "mkdir ${REPORT_DIR}"
            }
        }
    stage('Install Apifox CLI') {
      steps {
        bat 'npm install -g apifox-cli'
      }
    }

    stage('Running Test viptimeout') {
      steps {
        // 使用批处理命令来运行 Apifox
        withEnv(['LANG=zh_CN.UTF-8']) {
          bat 'apifox run --access-token %APIFOX_ACCESS_TOKEN% -t 4888888 -e 2222222 -n 1 -r html,cli'
        }
      }
    }
    stage('Running Test allpass') {
      steps {
        // 使用批处理命令来运行 Apifox
        withEnv(['LANG=zh_CN.UTF-8']) {
          bat 'apifox run --access-token %APIFOX_ACCESS_TOKEN% -t 4888888 -e 2222222 -n 1 -r html,cli'
        }
      }
    }
    
  }
  post {
        always {
		script {
               // 发布 HTML 报告
            publishHTML([
                reportDir: 'apifox-reports',
                reportFiles: 'apifox-report-*.html',
                reportName: 'HTML Reports',
                keepAll: false,
                alwaysLinkToLastBuild: true,
                allowMissing: true
                ])
            
		
		// 获取所有报告的 URL
        def reportUrl = "${env.JOB_URL}HTML_20Reports"
		// 获取当前时间并格式化
		def date = new Date()
		def formattedDate = date.format("yyyy-MM-dd HH:mm:ss", TimeZone.getTimeZone('Asia/Shanghai'))
		
		// 生成钉钉消息内容
		bat """
		curl "https://oapi.dingtalk.com/robot/send?access_token=976abf703dbceb5a82dc9761b1abdf4c3526f782287d5aff89968532415ba8"  -H "Content-Type: application/json" -d "{'msgtype': 'markdown','markdown': {'title':'API测试报告','text': '### Build ${env.BUILD_NUMBER} completed. \\n ### API Report URL [Click To See](${reportUrl}) \\n ##### Build Time:$formattedDate '},'at': {'isAtAll': true}}"
		"""}
		}
	}
}

apifox的值修改为自己的，钉钉的token值也改成自己的，这里的被我脱敏了。
效果展示：

报告展示

五、Jenkins用户管理

报告发送到钉钉后，别人需要查看，但肯定不能给管理员账号，这时候我们就需要创建权限仅查看的账号给用户使用。

1、下载安装插件,Role-based Authorization Strategy

2、开启权限全局安全配置，Manage Jenkins -> Security ->  Security -> Authorization 选择 Role-Based Strategy，选好后点击Sava

3、创建角色：Manage Jenkins -> Security -> Users

4、回到Security页面，找到Manage and Assign Roles

5、增加一个全局角色，勾选Overall中的read，代表仅阅读，注意这里的admin千万不要动，动了就进不来了。

三种角色

这个插件可以创建三种角色：

Global roles：全局角色，用于定义用户在整个 Jenkins 实例中的全局权限。这些权限适用于 Jenkins 的所有部分，不受特定项目或节点的限制。

• Overall: 包括 Read、Administer 等权限，控制用户对整个 Jenkins 实例的访问。

• Credentials: 管理 Jenkins 中的凭据，包括 Create、Update、Delete 等。

• Job: 全局管理所有作业的权限，包括 Create、Delete、Configure、Read、Build 等。

• View: 管理视图的权限，包括 Create、Delete、Configure、Read 等。

• SCM: 管理源代码管理系统的权限。

• Run: 管理构建的权限，包括 Delete、Update、Replay 等。

Item roles：任务角色，用于定义用户对特定项目（Job）的权限。这些角色可以控制用户对某些特定作业的操作权限。

• Job: 包括 Create、Delete、Configure、Read、Build、Workspace 等权限，控制用户对特定作业的访问和操作。

• Run: 包括 Delete、Update、Replay 等权限，控制用户对特定作业的构建记录的操作。

Agent roles：Agent 角色，用于定义用户对 Jenkins 节点（Agent）的权限。这些角色可以控制用户对特定节点的操作权限。

6、之后用仅read的账号就可以查看报告了。

总结

一、启动关闭重启jenkins相关命令

启动 Jenkins 服务：

sudo systemctl start jenkins

这里的preset: enabled: 根据系统的预设规则，Jenkins 服务默认应启用，参考第5条启用系统启动时自动启动 Jenkins 服务。

1. 检查 Jenkins 服务状态：

   sudo systemctl status jenkins
   

2. 重启 Jenkins 服务：

   sudo systemctl restart jenkins
   

3. 关闭 Jenkins 服务：

   sudo systemctl stop jenkins
   

4. 启用系统启动时自动启动 Jenkins 服务：

   sudo systemctl enable jenkins
   

   输出如下：

   > sudo systemctl enable jenkins
   > Synchronizing state of jenkins.service with SysV service script with /usr/lib/systemd/systemd-sysv-install.
   Executing: /usr/lib/systemd/systemd-sysv-install enable jenkins
   

5. 禁用系统启动时自动启动 Jenkins 服务：

   sudo systemctl disable jenkins
   

二、关于Jenkins配置文件

1、/usr/lib/systemd/system/jenkins.service

• 用途: 这是一个 systemd 服务单元文件，用于定义 Jenkins 服务的启动配置。

• 内容: 包含与服务启动相关的配置，如服务描述、启动命令、依赖关系和环境变量等。

• 适用场景: 适用于使用 systemd 作为初始化系统的 Linux 发行版（如 CentOS 7+、Ubuntu 15.04+）。

• 修改方法: 直接编辑这个文件可以修改服务的启动配置，但需要重新加载 systemd 配置（sudo systemctl daemon-reload）并重新启动服务（sudo systemctl restart jenkins）。

2、/etc/default/jenkins

• 用途: 用于定义 Jenkins 服务的环境变量和启动参数。

• 位置: 位于 /etc/default 目录下。

• 内容: 包含环境变量设置和其他与 Jenkins 启动相关的配置。

• 适用场景: 通常用于基于 Debian 的系统（如 Ubuntu），这些系统可能使用 init.d 脚本来启动服务。

• 修改方法: 编辑这个文件后，重新启动 Jenkins 服务（sudo systemctl restart jenkins 或 sudo service jenkins restart）。

3、/etc/sysconfig/jenkins

• 用途: 用于定义 Jenkins 服务的环境变量和启动参数。

• 位置: 位于 /etc/sysconfig 目录下。

• 内容: 包含环境变量设置和其他与 Jenkins 启动相关的配置。

• 适用场景: 通常用于基于 Red Hat 的系统（如 CentOS、Fedora、RHEL），这些系统可能使用 init.d 脚本或 systemd 来启动服务。

• 修改方法: 编辑这个文件后，重新启动 Jenkins 服务（sudo systemctl restart jenkins 或 sudo service jenkins restart）。

4、如何查看自己的系统

 cat /etc/os-release

输出：

PRETTY_NAME="Ubuntu 24.04 LTS"
NAME="Ubuntu"
VERSION_ID="24.04"
VERSION="24.04 LTS (Noble Numbat)"
VERSION_CODENAME=noble
ID=ubuntu
ID_LIKE=debian
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
UBUNTU_CODENAME=noble
LOGO=ubuntu-logo

看ID和ID_LIKE，我的正常来说是debian，需要修改/etc/default/jenkins文件，但我修改之后并没有生效，后面还是通过修改/usr/lib/systemd/system/jenkins.service才生效的，如果前面跟着步骤修改启动端口失败的话，可以切换文件进行修改。

三、Pipeline语法

Jenkins Pipeline 是一种基于代码的持续交付管道，使用特定的语法来定义整个构建、测试和部署过程。Jenkins 支持两种主要类型的 Pipeline 语法：Declarative Pipeline 和 Scripted Pipeline。以下是对这两种语法的详细介绍。

jenkins-pipeline语法详解 最新最全 （声明式Pipeline和脚本式）_jenkins pipeline 学习-优快云博客

1、Declarative Pipeline

Declarative Pipeline 是一种高层次的语法，提供了一个简单且易于理解的方式来定义 Pipeline。它有固定的结构和语法规则。

基本结构

pipeline {
    agent any
    stages {
        stage('Stage Name') {
            steps {
                // 构建步骤
            }
        }
    }
    post {
        always {
            // 无论构建结果如何，都会执行的步骤
        }
        success {
            // 构建成功时执行的步骤
        }
        failure {
            // 构建失败时执行的步骤
        }
    }
}

详细解释

• pipeline：定义一个新的 Pipeline。

• agent：指定在哪个节点（或哪个环境）上运行 Pipeline。any 表示可以在任何可用的节点上运行。

• stages：包含一个或多个 stage，每个 stage 代表一个独立的构建阶段。

• stage：定义一个构建阶段，包含一个名称和一组 steps。

• steps：在每个 stage 中定义具体的构建步骤。

• post：定义在构建完成后执行的步骤，可以根据构建结果（如 always、success、failure）来执行不同的操作。

示例

pipeline {
    agent any

    stages {
        stage('Build') {
            steps {
                echo 'Building...'
                sh 'make'// 假设使用 Makefile 进行构建
            }
        }

        stage('Test') {
            steps {
                echo 'Testing...'
                sh 'make test'// 假设使用 Makefile 进行测试
            }
        }

        stage('Deploy') {
            steps {
                echo 'Deploying...'
                sh 'make deploy'// 假设使用 Makefile 进行部署
            }
        }
    }

    post {
        always {
            echo 'Cleaning up...'
            sh 'make clean'// 假设使用 Makefile 进行清理
        }
        success {
            echo 'Build succeeded!'
        }
        failure {
            echo 'Build failed!'
        }
    }
}

2、Scripted Pipeline

Scripted Pipeline 是一种基于 Groovy 的更为灵活和强大的语法，适用于需要复杂逻辑的场景。

基本结构

node {
    try {
        stage('Stage Name') {
            // 构建步骤
        }
    } catch (Exception e) {
        // 处理异常
    } finally {
        // 清理步骤
    }
}

详细解释

• node：定义在 Jenkins 节点上运行的代码块。

• stage：定义一个构建阶段。

• try-catch-finally：处理异常和清理步骤。

示例

node {
    try {
        stage('Build') {
            echo 'Building...'
            sh 'make'// 假设使用 Makefile 进行构建
        }

        stage('Test') {
            echo 'Testing...'
            sh 'make test'// 假设使用 Makefile 进行测试
        }

        stage('Deploy') {
            echo 'Deploying...'
            sh 'make deploy'// 假设使用 Makefile 进行部署
        }
    } catch (Exception e) {
        echo "Build failed: ${e.message}"
    } finally {
        echo 'Cleaning up...'
        sh 'make clean'// 假设使用 Makefile 进行清理
    }
}

关键差异

• Declarative Pipeline：语法固定，易于理解和维护，适合大多数常见的 CI/CD 场景。

• Scripted Pipeline：基于 Groovy，提供更大的灵活性和控制力，适合需要复杂逻辑的高级场景。

四、Jenkins Pipeline环境变量

在 Jenkins Pipeline 中，env 是一个特殊的全局变量，用于访问和设置环境变量。通过 env，你可以在 Pipeline 中使用系统环境变量、Jenkins 环境变量、以及你自己定义的环境变量。

以下是一些常见的 env 属性：

1、常见的 Jenkins 环境变量

1. BUILD_NUMBER：当前构建的编号。

2. BUILD_ID：当前构建的唯一标识符。

3. BUILD_DISPLAY_NAME：当前构建的显示名称。

4. JOB_NAME：当前构建的作业名称。

5. JOB_BASE_NAME：不带路径的作业名称。

6. BUILD_TAG：生成的唯一标签。

7. EXECUTOR_NUMBER：当前构建的执行器编号。

8. NODE_NAME：执行当前构建的节点名称。

9. NODE_LABELS：当前节点的标签。

10. WORKSPACE：当前构建的工作区路径。

11. JENKINS_HOME：Jenkins 主目录路径。

12. JENKINS_URL：Jenkins 实例的 URL。

13. BUILD_URL：当前构建的 URL。

14. JOB_URL：当前作业的 URL。

15. GIT_COMMIT：当前 Git 提交的哈希值。

16. GIT_BRANCH：当前 Git 分支名称。

17. GIT_URL：Git 仓库的 URL。

2、自定义环境变量

你可以在 Pipeline 中定义自己的环境变量。例如：

pipeline {
    agent any

    environment {
        MY_VAR = 'my_value'
        ANOTHER_VAR = 'another_value'
    }

    stages {
        stage('Example') {
            steps {
                script {
                    echo "MY_VAR is ${env.MY_VAR}"
                    echo "ANOTHER_VAR is ${env.ANOTHER_VAR}"
                }
            }
        }
    }
}

3、使用环境变量

在 Pipeline 中，你可以通过 ${env.VAR_NAME} 访问环境变量。例如：

pipeline {
    agent any

    stages {
        stage('Example') {
            steps {
                script {
                    echo "Current build number is ${env.BUILD_NUMBER}"
                }
            }
        }
    }
}

4、设置环境变量

你可以在 environment 块中设置环境变量，或者在 script 块中使用 env 对象设置环境变量。例如：

pipeline {
    agent any

    environment {
        MY_VAR = 'initial_value'
    }

    stages {
        stage('Example') {
            steps {
                script {
                    // 设置环境变量
                    env.MY_VAR = 'updated_value'
                    echo "MY_VAR is now ${env.MY_VAR}"
                }
            }
        }
    }
}

5、其他环境变量

除了上述常见的 Jenkins 环境变量和自定义环境变量外，你还可以访问系统环境变量。例如：

pipeline {
    agent any

    stages {
        stage('Example') {
            steps {
                script {
                    echo "Home directory is ${env.HOME}"
                    echo "Path is ${env.PATH}"
                }
            }
        }
    }
}

五、报错：curl: (3) URL rejected: Port number was not a decimal number between 0 and 65535

解决方案：将url使用双引号括起来，而不是单引号。

其他很多类似的报错，都需要看引号的问题。

写在最后

使用第三方，就是这么麻烦，测试平台的目的就是减少三方参与，尽量简洁定制化，三方的内容参与的越多，后期维护越复杂，能够接手的人越少，也没人喜欢接这种烂摊子。

但是你的测试平台要是也是一坨，那结果都是一样的。

所以权衡利弊，普通人，技术，只是手段，生存，才是目的。

最后： 下方这份完整的软件测试视频教程已经整理上传完成，需要的朋友们可以自行领取【保证100%免费】

软件测试面试文档

我们学习必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有字节大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。