jenkins的job分类以及配置详解
·
Jenkins Job 创建与配置指南
Jenkins版本：2.5
学习时间：2026-04-04
所属阶段：第一阶段（基础入门）
目录
- Job概述
- Job类型
- 创建Freestyle Job
- 源码管理配置
- 构建触发器
- 构建步骤
- 构建环境配置
- 构建后操作
- 参数化构建
- 视图管理
- Job权限管理
- Job模板与复制
- 常用配置示例
- Pipeline Job创建详解
- Multibranch Pipeline配置
- Job日常管理操作
- 构建状态与结果详解
- Jenkins CLI与REST API操作Job
- Job常见问题排查
- 凭据管理详解
- Jenkins内置环境变量
- Webhook触发配置详解
一、Job概述
1.1 什么是Job
Job（任务）是Jenkins的核心执行单元，每个Job定义了：
┌─────────────────────────────────────────────────────────────────┐
│ Jenkins Job │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ├── Job名称与描述 │
│ ├── 执行节点（Master/Agent） │
│ ├── 源码管理（Git/SVN） │
│ ├── 构建触发器（定时/轮询/Webhook） │
│ ├── 构建步骤（Shell/Pipeline脚本） │
│ ├── 构建后操作（通知/归档/部署） │
│ └── 构建历史记录 │
│ │
└─────────────────────────────────────────────────────────────────┘
1.2 Job工作流程
Job执行流程：
┌─────────────────────────────────────────────────────────────────┐
│ 1. 触发构建 │
│ ├── 手动触发 │
│ ├── 定时触发（Cron） │
│ ├── 代码提交触发（Webhook） │
│ └── 上游Job触发 │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ 2. 检出代码 │
│ └── 从Git/SVN拉取源码 │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ 3. 执行构建 │
│ ├── 预处理脚本 │
│ ├── 编译构建 │
│ └── 测试执行 │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ 4. 构建后处理 │
│ ├── 结果归档 │
│ ├── 通知发送 │
│ └── 部署触发 │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ 5. 完成记录 │
│ └── 保存构建历史、测试报告、产物 │
└─────────────────────────────────────────────────────────────────┘
二、Job类型
2.1 Jenkins 2.5 支持的Job类型
| 类型 | 说明 | 使用场景 |
|---|---|---|
| Freestyle Project | 自由风格，最基本的Job类型 | 简单构建任务 |
| Pipeline | 流水线，支持复杂工作流 | 复杂CI/CD流程 |
| Multi-configuration Project | 多配置项目 | 矩阵式构建（多平台/多浏览器） |
| Folder | 文件夹，用于组织Job | Job分类管理 |
| Multibranch Pipeline | 多分支流水线 | Gitflow工作流 |
| Organization Folder | 组织文件夹 | GitHub/GitLab组织扫描 |
2.2 Job类型对比
| 特性 | Freestyle | Pipeline | Multi-configuration |
|---|---|---|---|
| 配置复杂度 | 低 | 中 | 高 |
| 灵活性 | 中 | 高 | 中 |
| 版本控制 | ❌ | ✅ | ❌ |
| 条件执行 | 有限 | 完整 | 有限 |
| 并行执行 | 手动配置 | 原生支持 | 配置矩阵 |
| 构建矩阵 | ❌ | 可模拟 | ✅ 原生支持 |
| 适用场景 | 简单任务 | 复杂流程 | 多环境测试 |
2.3 选择建议
Job类型选择指南：
┌─────────────────────────────────────────────────────────────────┐
│ 简单构建任务 │
│ (编译、测试、打包) │
│ ↓ │
│ Freestyle Project │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 复杂CI/CD │
│ (多阶段、条件分支) │
│ ↓ │
│ Pipeline Job │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 多环境测试 │
│ (Windows/Linux/macOS) │
│ ↓ │
│ Multi-configuration Project │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Git多分支管理 │
│ (main/feature/release) │
│ ↓ │
│ Multibranch Pipeline Job │
└─────────────────────────────────────────────────────────────────┘
三、创建Freestyle Job
3.1 创建入口
创建Job步骤：
1. 点击Jenkins首页左侧 "新建任务" / "New Item"
2. 输入任务名称
3. 选择任务类型
4. 点击 "确定" / "OK"
3.2 基础配置
Job基础配置页面：
┌─────────────────────────────────────────────────────────────────┐
│ 配置名称 │
│ ├── 任务名称：my-first-job │
│ ├── 任务描述：这是一个示例任务 │
│ └── 旧构建保留策略 │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 丢弃旧构建 │
│ ├── 保持构建天数：7 │
│ └── 保持构建的最大个数：10 │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 此项目配置为参数化构建过程 │
│ └── 添加参数类型 │
└─────────────────────────────────────────────────────────────────┘
3.3 限制构建运行节点
构建执行位置配置：
┌─────────────────────────────────────────────────────────────────┐
│ 勾选 "限制项目的运行节点" │
│ │
│ 标签表达式： │
│ ├── any (任何节点) │
│ ├── linux (指定标签) │
│ ├── java11 && maven (组合条件) │
│ └── !windows (排除条件) │
│ │
│ 示例： │
│ ├── "java11" - 标签为java11的节点 │
│ ├── "master" - Master节点 │
│ ├── "docker && amd64" - 同时满足两个标签 │
│ └── "ubuntu-20.04 || centos-8" - 满足任一标签 │
└─────────────────────────────────────────────────────────────────┘
3.4 配置截图说明
配置页面的Tab顺序（Jenkins 2.5）：
┌─────────────────────────────────────────────────────────────────┐
│ General [General] │
│ 源码管理 [Source Code Mgmt] │
│ 构建触发器 [Build Triggers] │
│ 构建环境 [Build Environment] │
│ 构建步骤 [Build Steps] │
│ 构建后操作 [Post-build Actions]│
└─────────────────────────────────────────────────────────────────┘
四、源码管理配置
4.1 Git配置
Git配置项：
┌─────────────────────────────────────────────────────────────────┐
│ 源码管理：Git │
│ │
│ Repository URL: │
│ └── https://github.com/company/my-project.git │
│ │
│ Credentials: │
│ └── 选择已配置的Git凭证 │
│ │
│ Branches to build: │
│ ├── Branch Specifier (blank for 'any'): │
│ ├── */main ← 主分支 │
│ ├── */feature/* ← 功能分支 │
│ ├── ${BRANCH_NAME} ← 参数化分支 │
│ └── */release/* ← 发布分支 │
│ │
│ 行为 (Behaviors): │
│ ├── ✓ Clean before checkout 检出前清理 │
│ ├── ✓ Clean after checkout 检出后清理 │
│ ├── ✓ Recursively update submodules 更新子模块 │
│ └── ✓ Prune stale remote tracking branches 清理远程追踪分支 │
└─────────────────────────────────────────────────────────────────┘
4.2 Git Branch与Tag语法
| 语法 | 说明 | 示例 |
|---|---|---|
*/main |
主分支（*/前缀匹配远程分支） |
主线开发 |
*/develop |
开发分支 | 开发主线 |
*/feature/* |
功能分支 | feature/login |
*/release/* |
发布分支 | release/1.0.0 |
*/hotfix/* |
热修复分支 | hotfix/bug-001 |
** |
匹配所有分支（含Tag） | 通配所有 |
origin/pr/*/head |
GitHub Pull Request | PR构建 |
${PARAM} |
参数化 | 使用构建参数 |
4.3 Subversion配置
Subversion配置项：
┌─────────────────────────────────────────────────────────────────┐
│ 源码管理：Subversion │
│ │
│ Repository URL: │
│ └── svn://192.168.1.100/project/trunk │
│ │
│ Credentials: │
│ └── 选择已配置的SVN凭证 │
│ │
│ Local module directory (SCM): │
│ └── . (当前目录) │
│ │
│ Externals: │
│ └── 配置外部引用 │
│ │
│ 检出策略: │
│ ├── ✓ 使用 'svn update' as much as possible │
│ └── ○ Always check out a fresh copy │
└─────────────────────────────────────────────────────────────────┘
4.4 Git高级配置
┌─────────────────────────────────────────────────────────────────┐
│ Shallow Clone（浅克隆，加速大仓库检出） │
│ │
│ Git → Behaviors → Add → Advanced clone behaviours │
│ ├── Shallow clone depth: 1 │
│ └── 只拉取最近1次提交，大幅减少克隆时间 │
│ │
│ ⚠️ 注意：浅克隆可能导致部分Git操作失败 │
│ ├── git log 无法查看完整历史 │
│ ├── git blame 无法正常工作 │
│ └── 适用于只做构建不需要历史的场景 │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Sparse Checkout（稀疏检出，只检出指定目录） │
│ │
│ Git → Behaviors → Add → Sparse Checkout paths │
│ ├── 输入要检出的路径（每行一个）： │
│ │ src/main │
│ │ pom.xml │
│ └── 适用于monorepo（单仓多项目）场景 │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Git LFS（大文件存储） │
│ │
│ 前提：服务器和构建节点都需安装 git-lfs │
│ ├── Git → Behaviors → Add → Git LFS pull after checkout │
│ └── 检出代码后自动拉取LFS管理的文件 │
│ │
│ 安装Git LFS（Linux）： │
│ ├── curl -s https://packagecloud.io/install/repositories/github/│
│ │ git-lfs/script.deb.sh | sudo bash │
│ └── sudo apt-get install git-lfs && git lfs install │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Checkout到子目录 │
│ │
│ Git → Additional Behaviours → Check out to a sub-directory │
│ ├── Local sub-directory for repo: src │
│ └── 代码将检出到 $WORKSPACE/src 目录下 │
│ │
│ 多SCM场景：同一Job检出多个仓库到不同子目录 │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Pipeline中的Git高级配置 │
│ │
│ checkout([ │
│ $class: 'GitSCM', │
│ branches: [[name: '*/main']], │
│ extensions: [ │
│ [$class: 'CloneOption', depth: 1, shallow: true], │
│ [$class: 'SparseCheckoutPaths', │
│ sparseCheckoutPaths: [[path: 'src/main']]], │
│ [$class: 'GitLFSPull'], │
│ [$class: 'RelativeTargetDirectory', │
│ relativeTargetDir: 'src'], │
│ [$class: 'CleanBeforeCheckout'], │
│ ], │
│ userRemoteConfigs: [[ │
│ url: 'https://github.com/company/project.git', │
│ credentialsId: 'github-ssh-key' │
│ ]] │
│ ]) │
└─────────────────────────────────────────────────────────────────┘
五、构建触发器
5.1 定时构建（Build Triggers）
定时构建配置：
┌─────────────────────────────────────────────────────────────────┐
│ 触发远程构建 (例如，使用脚本) │
│ ├── 身份验证令牌：MY_TOKEN │
│ └── 访问URL: http://jenkins/job/my-job/build?token=MY_TOKEN │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 其他项目构建后触发 │
│ ├── 监听的其他项目: other-job │
│ ├── ✓ 构建后触发 │
│ └── ✓ 即使构建失败也触发 │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 定时构建 │
│ └── 日程表：H 2 * * * │
└─────────────────────────────────────────────────────────────────┘
5.2 Cron表达式详解
Cron表达式格式：
┌───────────── 分钟 (0-59)
│ ┌───────────── 小时 (0-23)
│ │ ┌───────────── 日 (1-31)
│ │ │ ┌───────────── 月 (1-12)
│ │ │ │ ┌───────────── 星期 (0-7, 0和7都是周日)
│ │ │ │ │
* * * * *
常用示例：
┌─────────────────────────────────────────────────────────────────┐
│ H 2 * * * 每天凌晨2点构建 │
│ H H * * * 每天任意时间构建 │
│ H/15 * * * * 每15分钟构建 │
│ H H(0-8) * * * 凌晨0点到8点之间任意时间 │
│ H H 1,15 * * 每月1日和15日构建 │
│ H H * * 1-5 工作日每天一次（随机时间）构建 │
│ H * * * 1-5 工作日每小时构建 │
│ 30 9 * * 1-5 周一到周五9:30构建 │
│ 0 18 * * * 每天下午6点构建 │
└─────────────────────────────────────────────────────────────────┘
特殊字符：
┌─────────────────────────────────────────────────────────────────┐
│ * 任意值 │
│ , 值列表分隔符 (1,3,5) │
│ - 范围 (1-5 表示1到5) │
│ / 步长 (*/15 表示每15个单位) │
│ H 哈希值（用于分散构建时间，避免高峰期） │
└─────────────────────────────────────────────────────────────────┘
5.3 GitHub/Webhook触发
GitHub Pull Request Builder配置：
┌─────────────────────────────────────────────────────────────────┐
│ GitHub Pull Request Builder │
│ │
│ ✓ 使用GitHub Pull Request Builder触发构建 │
│ │
│ Admin list: │
│ └── GitHub账号白名单 │
│ │
│ Cron: │
│ └── H/5 * * * * 每5分钟检查PR更新 │
│ │
│ Trigger Setup: │
│ ├── ✓ 关闭构建 SSL 验证 (测试环境) │
│ └── 公司GitHub需要配置GitHub Token │
└─────────────────────────────────────────────────────────────────┘
5.4 轮询SCM
轮询SCM配置：
┌─────────────────────────────────────────────────────────────────┐
│ 轮询SCM │
│ │
│ 日程表：H/5 * * * * │
│ └── 每5分钟检查代码更新，有更新才构建 │
│ │
│ 注意：与定时构建的区别 │
│ ├── 定时构建：无论代码是否变化，到了时间就构建 │
│ └── 轮询构建：检测到代码变化才构建 │
└─────────────────────────────────────────────────────────────────┘
5.5 触发器对比
| 触发方式 | 配置位置 | 实时性 | 资源消耗 |
|---|---|---|---|
| 定时构建 | Jenkins | ⭐⭐ | 低 |
| 轮询SCM | Jenkins | ⭐⭐ | 中 |
| Webhook | Git服务器 | ⭐⭐⭐⭐⭐ | 低 |
| 上游Job | Jenkins | ⭐⭐⭐⭐ | 低 |
| 远程触发 | 外部系统 | ⭐⭐⭐⭐ | 低 |
六、构建步骤
6.1 执行Windows批处理命令
Windows批处理构建步骤：
┌─────────────────────────────────────────────────────────────────┐
│ 构建步骤 │
│ ├── 执行Windows批处理命令 │
│ └── 命令内容： │
│ │
│ cd %WORKSPACE% │
│ call mvn clean package -DskipTests │
│ │
│ 常用命令： │
│ ├── set PATH=C:\maven\bin;%PATH% 设置环境变量 │
│ ├── call mvn clean install 调用Maven │
│ ├── if exist dist\*.zip del dist\*.zip 条件执行 │
│ └── echo Build completed 输出信息 │
└─────────────────────────────────────────────────────────────────┘
6.2 执行Shell
Shell构建步骤：
┌─────────────────────────────────────────────────────────────────┐
│ 构建步骤 │
│ └── 执行shell │
│ │
│ 命令内容： │
│ #!/bin/bash │
│ cd ${WORKSPACE} │
│ mvn clean package -DskipTests │
│ tar -czf dist.tar.gz target/*.jar │
└─────────────────────────────────────────────────────────────────┘
6.3 调用Maven
Maven构建步骤：
┌─────────────────────────────────────────────────────────────────┐
│ 构建步骤 │
│ └── 顶层Maven目标 │
│ │
│ Maven版本: │
│ └── 选择已配置的Maven (MAVEN_HOME) │
│ │
│ Goals: │
│ └── clean package -DskipTests │
│ │
│ POM文件: │
│ └── pom.xml (留空使用默认) │
│ │
│ 构建属性: │
│ ├── JAVA_HOME=/path/to/jdk8 │
│ └── MAVEN_OPTS=-Xmx1024m │
└─────────────────────────────────────────────────────────────────┘
6.4 调用Gradle
Gradle构建步骤：
┌─────────────────────────────────────────────────────────────────┐
│ 构建步骤 │
│ └── 调用Gradle │
│ │
│ Gradle版本: │
│ └── 选择已配置的Gradle │
│ │
│ Tasks: │
│ └── build -x test │
└─────────────────────────────────────────────────────────────────┘
6.5 Windows PowerShell
PowerShell构建步骤：
┌─────────────────────────────────────────────────────────────────┐
│ 构建步骤 │
│ └── Windows PowerShell │
│ │
│ 脚本内容： │
│ $ErrorActionPreference = "Stop" │
│ cd $env:WORKSPACE │
│ & "C:\maven\bin\mvn.cmd" clean package │
│ if ($LASTEXITCODE -ne 0) { │
│ Write-Host "Build failed with exit code $LASTEXITCODE" │
│ exit 1 │
│ } │
└─────────────────────────────────────────────────────────────────┘
七、构建环境配置
重要：这是Job配置中容易被忽略但非常关键的环节，直接影响构建能否成功执行。
7.1 构建前清理Workspace
┌─────────────────────────────────────────────────────────────────┐
│ 构建环境 → 勾选 "Delete workspace before build starts" │
│ │
│ 作用：每次构建前清空工作空间，确保干净的构建环境 │
│ │
│ 适用场景： │
│ ├── 构建产物残留导致打包错误 │
│ ├── 缓存文件导致测试结果不准确 │
│ ├── 切换分支后旧文件干扰 │
│ └── 排查构建问题时确保环境干净 │
│ │
│ ⚠️ 注意： │
│ ├── 会增加构建时间（需要重新检出代码） │
│ ├── 大型项目慎用（检出耗时长） │
│ └── 推荐用 Git Clean 代替（只清理未跟踪文件） │
└─────────────────────────────────────────────────────────────────┘
7.2 构建工具自动安装
┌─────────────────────────────────────────────────────────────────┐
│ 构建环境 → 勾选需要的工具 │
│ │
│ 可选工具（需在全局工具配置中预先定义）： │
│ ├── ☑ JDK 选择JDK版本 │
│ ├── ☑ Maven 选择Maven版本 │
│ ├── ☑ Gradle 选择Gradle版本 │
│ ├── ☑ Ant 选择Ant版本 │
│ └── ☑ NodeJS 选择Node.js版本 │
│ │
│ 全局工具配置路径： │
│ Manage Jenkins → Global Tool Configuration │
│ │
│ 配置示例（JDK）： │
│ ├── Name: JDK11 │
│ ├── JAVA_HOME: /usr/lib/jvm/java-11-openjdk │
│ └── 或勾选 "Install automatically" 自动安装 │
│ │
│ 配置示例（Maven）： │
│ ├── Name: Maven-3.8 │
│ ├── MAVEN_HOME: /opt/maven-3.8 │
│ └── 或勾选 "Install automatically" 从Apache下载 │
└─────────────────────────────────────────────────────────────────┘
7.3 环境变量配置
┌─────────────────────────────────────────────────────────────────┐
│ 方式1：Job级别环境变量 │
│ 构建环境 → 勾选 "Inject environment variables to the build process" │
│ │
│ Properties Content: │
│ JAVA_HOME=/usr/lib/jvm/java-11 │
│ MAVEN_OPTS=-Xmx1024m -XX:MaxMetaspaceSize=256m │
│ BUILD_ENV=production │
│ │
│ 方式2：使用EnvInject插件 │
│ ├── 安装 Environment Injector 插件 │
│ ├── 勾选 "Prepare an environment for the run" │
│ └── 可从文件加载环境变量：.env文件路径 │
│ │
│ 方式3：全局环境变量 │
│ Manage Jenkins → Configure System → Global properties │
│ ├── 勾选 "Environment variables" │
│ └── 添加键值对：如 DOCKER_REGISTRY=registry.example.com │
└─────────────────────────────────────────────────────────────────┘
7.4 构建超时与并发控制
┌─────────────────────────────────────────────────────────────────┐
│ 构建超时（防止构建卡死） │
│ 构建环境 → 勾选 "Abort the build if it's stuck" │
│ │
│ Time-out strategy: │
│ ├── Absolute 绝对超时（如60分钟） │
│ ├── Elastic 弹性超时（根据历史构建时间动态调整） │
│ └── Likely stuck 检测卡住（无输出超时） │
│ │
│ Time-out variable: BUILD_TIMEOUT=true │
│ Action after timeout: │
│ ├── Abort the build 中止构建 │
│ └── Fail the build 标记为失败 │
│ │
│ ───────────────────────────────────────────── │
│ │
│ 并发构建控制 │
│ 勾选 "Execute concurrent builds if necessary" │
│ │
│ ├── ✅ 勾选：允许同一Job同时运行多个构建 │
│ │ 适用：参数化构建，不同参数可并行 │
│ │ 注意：需要确保Workspace不冲突！ │
│ │ │
│ └── ❌ 不勾选：同一Job同时只能运行一个构建 │
│ 适用：部署类Job、有共享资源冲突的Job │
│ 新构建会排队等待 │
└─────────────────────────────────────────────────────────────────┘
7.5 构建时间戳与控制台编码
┌─────────────────────────────────────────────────────────────────┐
│ 构建环境常用选项： │
│ │
│ ☑ Add timestamps to the Console Output │
│ → 在控制台输出中添加时间戳 │
│ → 需要安装 Timestamper 插件 │
│ → 方便排查构建各阶段耗时 │
│ │
│ ☑ Set Build Name │
│ → 自定义构建名称（默认为#1, #2...） │
│ → 示例：${ENV,var="BRANCH"}-#${BUILD_NUMBER} │
│ → 需要安装 Build Name Setter 插件 │
│ │
│ Console Output Encoding: │
│ → 如果构建日志中文乱码，设置编码为UTF-8 │
│ → 在Jenkins启动参数中添加: │
│ -Dfile.encoding=UTF-8 -Dsun.jnu.encoding=UTF-8 │
│ → 或在Job的构建步骤开头添加: │
│ export JAVA_TOOL_OPTIONS="-Dfile.encoding=UTF-8" │
└─────────────────────────────────────────────────────────────────┘
7.6 静默期（Quiet Period）
┌─────────────────────────────────────────────────────────────────┐
│ 静默期配置 │
│ General → ☑ Quiet period │
│ │
│ 秒数：5 │
│ └── 触发构建后等待5秒，期间如有新的提交则合并构建 │
│ │
│ 适用场景： │
│ ├── 多人频繁提交到同一分支，避免重复构建 │
│ ├── 多个Webhook短时间内连续触发 │
│ └── 与SCM Skip配合使用效果更佳 │
│ │
│ 全局默认值配置： │
│ Manage Jenkins → Configure System → Quiet period │
│ └── 设置全局默认静默期（如5秒） │
│ │
│ Pipeline中配置： │
│ options { quietPeriod(5) } │
└─────────────────────────────────────────────────────────────────┘
7.7 忽略SCM变更（Skip SCM Changes）
┌─────────────────────────────────────────────────────────────────┐
│ 忽略SCM变更触发 │
│ General → ☑ Ignore post-commit hooks │
│ └── 忽略Git post-commit hook触发的构建 │
│ │
│ ☑ Disable automatic SCM triggering │
│ └── 禁止SCM变更自动触发构建（只允许手动触发） │
│ │
│ Pipeline中配置： │
│ properties([pipelineTriggers([])]) │
│ → 清空所有自动触发器，只保留手动触发 │
└─────────────────────────────────────────────────────────────────┘
八、构建后操作
8.1 归档构建产物
归档产物配置：
┌─────────────────────────────────────────────────────────────────┐
│ 构建后操作 │
│ └── 归档构建产物 │
│ │
│ 文件留待归档： │
│ └── target/*.jar │
│ │
│ 归档方式： │
│ ├── ✓ 始终归档，不考虑构建结果 │
│ └── ○ 只归档成功构建 │
│ │
│ 压缩归档文件： │
│ └── ✓ 启用压缩 │
└─────────────────────────────────────────────────────────────────┘
常用归档模式：
┌─────────────────────────────────────────────────────────────────┐
│ target/*.jar 所有JAR文件 │
│ target/**/*.jar 所有JAR包括子目录 │
│ build/dist/*.zip 所有ZIP文件 │
│ "**/target/*.{jar,war,ear}" 多类型 │
│ !target/test-*.jar 排除特定文件 │
└─────────────────────────────────────────────────────────────────┘
8.2 邮件通知
邮件通知配置：
┌─────────────────────────────────────────────────────────────────┐
│ 构建后操作 │
│ └── Editable Email Notification │
│ │
│ Project From Address: │
│ └── jenkins@company.com │
│ │
│ Default Subject: │
│ └── [$PROJECT_NAME] - Build #%BUILD_NUMBER - %STATUS% │
│ │
│ Default Content: │
│ └── 详见下方模板 │
│ │
│ 触发条件： │
│ ├── ✓ Always 总是发送 │
│ ├── ✓ Failure - New 失败且是首次失败 │
│ ├── ✓ Failure - Any 任何失败 │
│ ├── ✓ Success 成功 │
│ └── ✓ Unstable 不稳定 │
└─────────────────────────────────────────────────────────────────┘
8.3 邮件内容模板
邮件内容模板示例：
<!DOCTYPE html>
<html>
<head>
<style>
body { font-family: Arial, sans-serif; }
.success { color: green; }
.failure { color: red; }
</style>
</head>
<body>
<h2>构建通知 - ${PROJECT_NAME}</h2>
<p><b>构建结果：</b> <span class="${BUILD_STATUS}">${BUILD_STATUS}</span></p>
<p><b>构建编号：</b> #${BUILD_NUMBER}</p>
<p><b>触发方式：</b> ${CAUSE}</p>
<h3>构建信息</h3>
<ul>
<li><b>构建耗时：</b> ${BUILD_DURATION}</li>
<li><b>代码分支：</b> ${GIT_BRANCH}</li>
<li><b>提交记录：</b> ${GIT_COMMIT}</li>
</ul>
<h3>控制台输出</h3>
<p><a href="${BUILD_URL}console">点击查看完整日志</a></p>
<h3>变更记录</h3>
${CHANGES}
</body>
</html>
8.4 钉钉/企业微信通知
钉钉机器人通知配置：
┌─────────────────────────────────────────────────────────────────┐
│ 构建后操作 │
│ └── 钉钉机器人通知 │
│ │
│ Webhook地址： │
│ └── https://oapi.dingtalk.com/robot/send?access_token=xxx │
│ │
│ 通知内容： │
│ └── 构建通知：${BUILD_STATUS} - ${PROJECT_NAME} #${BUILD_NUMBER}│
│ │
│ 触发条件： │
│ ├── ✓ Always 总是发送 │
│ └── ✓ On Failure 仅失败时 │
└─────────────────────────────────────────────────────────────────┘
8.5 触发其他Job
触发参数化构建：
┌─────────────────────────────────────────────────────────────────┐
│ 构建后操作 │
│ └── 在其他项目构建后触发 │
│ │
│ 项目名称：deploy-job │
│ │
│ 触发稳定构建： │
│ └── ✓ 触发即使构建不稳定 │
│ │
│ 触发参数化构建： │
│ └── ✓ 触发参数化构建 │
│ │
│ 参数： │
│ └── ARTIFACT_PATH=target/app.jar │
│ └── DEPLOY_ENV=production │
└─────────────────────────────────────────────────────────────────┘
8.6 构建产物指纹（Fingerprint）
┌─────────────────────────────────────────────────────────────────┐
│ 构建后操作 → Record fingerprints of files to track usage │
│ │
│ 作用：对构建产物计算MD5指纹，跟踪产物在哪些Job中被使用 │
│ │
│ 配置： │
│ ├── Files to fingerprint: target/*.jar │
│ └── Fingerprint all archived artifacts: ☑ │
│ │
│ 使用场景： │
│ ├── 跟踪某个JAR包被哪些下游Job部署了 │
│ ├── 查看某个war包的完整构建→部署链路 │
│ └── 排查"线上版本对应哪次构建"的问题 │
│ │
│ 查看指纹信息： │
│ ├── 构建详情页 → Fingerprints │
│ └── Manage Jenkins → Fingerprints → 搜索MD5 │
│ │
│ Pipeline中使用： │
│ fingerprint 'target/*.jar' │
│ → 自动对归档产物记录指纹 │
└─────────────────────────────────────────────────────────────────┘
九、参数化构建
9.1 参数化构建概述
参数化构建允许在构建时传入动态参数：
┌─────────────────────────────────────────────────────────────────┐
│ 参数化构建配置 │
│ │
│ 此项目配置为参数化构建过程 │
│ └── 点击 "添加参数" 按钮添加参数 │
└─────────────────────────────────────────────────────────────────┘
9.2 常用参数类型
┌─────────────────────────────────────────────────────────────────┐
│ String Parameter (字符串参数) │
├─────────────────────────────────────────────────────────────────┤
│ 名称：BRANCH │
│ 默认值：main │
│ 描述：请输入代码分支名称 │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Choice Parameter (选择参数) │
├─────────────────────────────────────────────────────────────────┤
│ 名称：ENV │
│ 选项： │
│ ├── dev │
│ ├── test │
│ └── prod │
│ 描述：选择部署环境 │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Boolean Parameter (布尔参数) │
├─────────────────────────────────────────────────────────────────┤
│ 名称：SKIP_TEST │
│ 默认值：false │
│ 描述：是否跳过测试 │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Password Parameter (密码参数) │
├─────────────────────────────────────────────────────────────────┤
│ 名称：DB_PASSWORD │
│ 默认值： │
│ 描述：数据库密码（构建时会加密显示） │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ File Parameter (文件参数) │
├─────────────────────────────────────────────────────────────────┤
│ 文件路径：upload.jar │
│ 描述：上传要部署的JAR文件 │
└─────────────────────────────────────────────────────────────────┘
9.3 Pipeline中使用参数
// Jenkinsfile中使用参数
pipeline {
agent any
parameters {
string(name: 'BRANCH', defaultValue: 'main', description: '代码分支')
choice(name: 'ENV', choices: ['dev', 'test', 'prod'], description: '部署环境')
booleanParam(name: 'SKIP_TEST', defaultValue: false, description: '跳过测试')
}
stages {
stage('Build') {
steps {
echo "Building ${params.BRANCH} for ${params.ENV}"
sh "mvn clean package -DskipTests=${params.SKIP_TEST}"
}
}
}
}
十、视图管理
10.1 视图类型
| 视图类型 | 说明 |
|---|---|
| List View | 列表视图，最常用 |
| My View | 我的视图，显示用户关注的Job |
| Sectioned View | 分区视图，可自定义布局 |
| Nested View | 嵌套视图，支持多层级 |
10.2 创建视图
创建视图步骤：
1. 点击Jenkins首页左侧 "视图" / "Views"
2. 点击 "+" 添加新视图
3. 输入视图名称
4. 选择视图类型
5. 配置视图内容
10.3 视图配置
List View配置：
┌─────────────────────────────────────────────────────────────────┐
│ 视图名称：CI/CD Pipeline │
│ │
│ 列配置： │
│ ├── ✓ 状态 │
│ ├── ✓ 名称 │
│ ├── ✓ 最后成功构建 │
│ ├── ✓ 最后失败构建 │
│ ├── ✓ 最后持续时间 │
│ └── ✓ 构建参数 │
│ │
│ 筛选器： │
│ └── ✓ 使用正则表达式匹配Jobs │
│ 正则：.*-pipeline|.*-deploy │
└─────────────────────────────────────────────────────────────────┘
10.4 视图分组
使用Folder组织Job：
1. 创建Folder：mkdir project-folder
2. 在Folder中创建Job
3. 创建Folder视图
┌─────────────────────────────────────────────────────────────────┐
│ Jenkins首页 │
│ ├── All (默认视图) │
│ ├── CI/CD │
│ ├── 我的视图 │
│ └── 业务线 Folder │
│ ├── project-a │
│ ├── project-b │
│ └── project-c │
└─────────────────────────────────────────────────────────────────┘
十一、Job权限管理
11.1 授权策略
Jenkins授权策略配置 (Manage Jenkins → Configure Global Security):
┌─────────────────────────────────────────────────────────────────┐
│ 安全realm │
│ └── Jenkins专有用户数据库 │
│ │
│ 授权策略： │
│ ├── ○ 任何用户可以做任何事 (不推荐) │
│ ├── ○ Legacy mode │
│ ├── ○ Logged-in users can do anything │
│ └── ● 项目矩阵授权策略 │
└─────────────────────────────────────────────────────────────────┘
11.2 项目矩阵授权
项目矩阵授权配置：
┌─────────────────────────────────────────────────────────────────┐
│ 项目矩阵授权策略 │
│ │
│ 用户/组 │ Overall │ Repository │ Jobs │ Run │
│ ──────────────────────────────────────────────────────────── │
│ admin │ Admin │ Admin │ Admin │ Admin │
│ developer │ Read │ Read │ Read │ Read │
│ deployer │ Read │ None │ Read │ Update │
│ anonymous │ None │ None │ None │ None │
└─────────────────────────────────────────────────────────────────┘
权限说明：
┌─────────────────────────────────────────────────────────────────┐
│ Overall (全局权限) │
│ ├── Admin 管理员权限 │
│ ├── Read 读取权限 │
│ └── UploadPlugins 上传插件 │
├─────────────────────────────────────────────────────────────────┤
│ Repository (仓库权限) │
│ ├── Create 创建 │
│ ├── Delete 删除 │
│ └── Update 更新 │
├─────────────────────────────────────────────────────────────────┤
│ Jobs (任务权限) │
│ ├── Create 创建 │
│ ├── Delete 删除 │
│ ├── Configure 配置 │
│ ├── Read 读取 │
│ ├── Build 构建 │
│ └── Workspace 工作空间 │
├─────────────────────────────────────────────────────────────────┤
│ Run (构建记录权限) │
│ ├── Update 更新 │
│ └── Delete 删除 │
└─────────────────────────────────────────────────────────────────┘
11.3 Role-based Authorization
安装 Role-based Authorization Strategy 插件后：
┌─────────────────────────────────────────────────────────────────┐
│ 角色管理 (Manage and Assign Roles) │
│ │
│ Global Roles: │
│ ├── admin 管理员 │
│ └── developer 开发者 │
│ │
│ Item/Roles (项目角色): │
│ ├── developer 匹配: .*-dev.* │
│ ├── tester 匹配: .*-test.* │
│ └── operator 匹配: .* │
│ │
│ Assign Roles: │
│ ├── user1 → admin + developer │
│ └── user2 → developer + tester │
└─────────────────────────────────────────────────────────────────┘
十二、Job模板与复制
12.1 复制Job
复制已有Job：
1. 在Job列表页面，点击Job右侧 "复制" / "Copy"
2. 输入新Job名称
3. 点击 "确定"
用途：
├── 快速创建类似配置的Job
├── 备份Job配置
└── 实验性配置
12.2 Job配置导出
使用Jenkins CLI导出配置：
# 导出Job配置
java -jar jenkins-cli.jar -s http://localhost:8080 get-job my-job > config.xml
# 导入Job配置
java -jar jenkins-cli.jar -s http://localhost:8080 create-job new-job < config.xml
# 批量创建
for /f %i in (jobs.txt) do (
java -jar jenkins-cli.jar -s http://localhost:8080 get-job template-job > config.xml
java -jar jenkins-cli.jar -s http://localhost:8080 create-job %i < config.xml
)
12.3 使用Seed Job生成Job
使用Seed Job + DSL插件批量创建Job：
1. 安装 "Job DSL" 插件
2. 创建Seed Job
3. 配置Seed Job的构建步骤：
┌─────────────────────────────────────────────────────────────────┐
│ 构建步骤 │
│ └── Process Job DSLs │
│ │
│ DSL Scripts: │
│ └── job.groovy │
└─────────────────────────────────────────────────────────────────┘
4. job.groovy内容：
job('example-pipeline') {
description('Generated pipeline job')
scm {
git('https://github.com/company/project.git')
}
steps {
maven('clean package')
}
publishers {
archiveArtifacts('target/*.jar')
mailer('team@company.com')
}
}
十三、常用配置示例
13.1 Java Maven项目
配置示例 - Java Maven项目：
┌─────────────────────────────────────────────────────────────────┐
│ General │
│ ├── 任务名称：java-maven-app │
│ ├── 描述：Java Maven构建项目 │
│ └── 丢弃旧构建：保留30天，最大100个 │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 源码管理：Git │
│ ├── Repository URL: git@github.com:company/app.git │
│ ├── Credentials: (GitHub Deploy Key) │
│ └── Branch: */main │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 构建触发器 │
│ └── 定时构建：H 2 * * * │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 构建步骤 │
│ └── 调用顶层Maven目标 │
│ ├── Maven版本：Maven-3.8.6 │
│ └── Goals：clean package -DskipTests │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 构建后操作 │
│ ├── 归档构建产物：target/*.jar │
│ └── Editable Email Notification │
│ └── 收件人：dev-team@company.com │
└─────────────────────────────────────────────────────────────────┘
13.2 Node.js前端项目
配置示例 - Node.js前端项目：
┌─────────────────────────────────────────────────────────────────┐
│ General │
│ ├── 任务名称：frontend-app │
│ └── 丢弃旧构建：保留7天，最大20个 │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 源码管理：Git │
│ ├── Repository URL: git@github.com:company/frontend.git │
│ └── Branch: */develop │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 构建环境 │
│ └── ✓ Delete workspace before build starts │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 构建步骤 │
│ └── 执行Windows批处理命令 │
│ │
│ call npm install │
│ call npm run build │
│ if errorlevel 1 exit /b 1 │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 构建后操作 │
│ ├── 归档构建产物：dist/** │
│ └── Windows PowerShell │
│ │
│ $webDir = "C:\inetpub\wwwroot\frontend" │
│ Remove-Item -Path "$webDir\*" -Recurse -Force │
│ Copy-Item -Path "dist\*" -Destination $webDir -Recurse │
└─────────────────────────────────────────────────────────────────┘
13.3 Python项目
配置示例 - Python项目：
┌─────────────────────────────────────────────────────────────────┐
│ 构建触发器 │
│ └── 轮询SCM：H/10 * * * * │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 构建步骤 │
│ └── 执行Shell │
│ │
│ python3 -m venv venv │
│ source venv/bin/activate │
│ pip install -r requirements.txt │
│ pytest tests/ --junitxml=report.xml │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 构建后操作 │
│ ├── 归档构建产物：report.xml, coverage.xml │
│ └── 发布HTML报告：target/site/coverag │
└─────────────────────────────────────────────────────────────────┘
13.4 多阶段流水线Job
配置示例 - 多阶段流水线：
┌─────────────────────────────────────────────────────────────────┐
│ Job名称：app-pipeline │
│ │
│ 阶段1：Build (构建) │
│ └── mvn clean package │
│ │
│ 阶段2：Test (测试) │
│ └── mvn test │
│ │
│ 阶段3：Deploy-Dev (部署开发环境) │
│ └── ./deploy.sh dev │
│ │
│ 阶段4：Deploy-Prod (需手动确认) │
│ └── ./deploy.sh prod │
└─────────────────────────────────────────────────────────────────┘
十四、Pipeline Job创建详解
Pipeline是Jenkins 2.x的核心特性，也是现代CI/CD的首选Job类型。
14.1 创建Pipeline Job
创建步骤：
1. Jenkins首页 → 新建任务
2. 输入名称，选择 "Pipeline" 类型
3. 点击确定进入配置页面
14.2 Pipeline定义方式
┌─────────────────────────────────────────────────────────────────┐
│ Pipeline → Definition 配置项 │
│ │
│ 方式1：Pipeline script │
│ ├── 直接在Jenkins界面编写Pipeline脚本 │
│ ├── 适合：简单测试、快速验证 │
│ └── 缺点：无法版本控制 │
│ │
│ 方式2：Pipeline script from SCM ⭐推荐 │
│ ├── 从Git仓库的Jenkinsfile加载Pipeline脚本 │
│ ├── 适合：正式项目、团队协作 │
│ └── 优点：版本控制、代码审查 │
│ │
│ 方式3：Pipeline script from SCM (light checkout) │
│ ├── 轻量检出，只获取Jenkinsfile │
│ └── 适合：大仓库加速 │
└─────────────────────────────────────────────────────────────────┘
14.3 Pipeline script from SCM 配置
┌─────────────────────────────────────────────────────────────────┐
│ Definition: Pipeline script from SCM │
│ │
│ SCM: Git │
│ ├── Repository URL: https://gitlab.com/group/project.git │
│ ├── Credentials: gitlab-ssh-key │
│ ├── Branches to build: */main │
│ └── Script Path: Jenkinsfile │
│ ├── 默认值：Jenkinsfile（项目根目录） │
│ ├── 可指定子目录：ci/Jenkinsfile │
│ └── 可使用变量：Jenkinsfile.${BRANCH_NAME} │
│ │
│ Lightweight checkout: ☑ │
│ → 只拉取Jenkinsfile，不拉取整个仓库 │
│ → 后续 checkout 步骤再拉取完整代码 │
└─────────────────────────────────────────────────────────────────┘
14.4 声明式Pipeline完整模板
pipeline {
agent any
environment {
APP_NAME = 'my-app'
VERSION = "${env.BUILD_ID}"
}
options {
timeout(time: 30, unit: 'MINUTES')
buildDiscarder(logRotator(numToKeepStr: '10'))
timestamps()
disableConcurrentBuilds()
}
parameters {
string(name: 'BRANCH', defaultValue: 'main', description: '代码分支')
choice(name: 'ENV', choices: ['dev', 'test', 'prod'], description: '部署环境')
}
triggers {
pollSCM('H/5 * * * *')
}
stages {
stage('Checkout') {
steps {
checkout scm
}
}
stage('Build') {
steps {
sh 'mvn clean package -DskipTests'
}
}
stage('Test') {
steps {
sh 'mvn test'
}
post {
always {
junit 'target/surefire-reports/**/*.xml'
}
}
}
stage('Deploy') {
when {
branch 'main'
}
steps {
sh "./deploy.sh ${params.ENV}"
}
}
}
post {
success {
echo 'Build succeeded!'
}
failure {
echo 'Build failed!'
}
always {
archiveArtifacts artifacts: 'target/*.jar', allowEmptyArchive: true
cleanWs()
}
}
}
14.5 Pipeline配置页面与Jenkinsfile的对应关系
┌─────────────────────────────────────────────────────────────────┐
│ Freestyle配置项 → Pipeline对应语法 │
│ ───────────────────────────────────────────────────────────── │
│ 丢弃旧构建 → options { buildDiscarder(...) } │
│ 参数化构建 → parameters { ... } │
│ 构建触发器 → triggers { ... } │
│ 限制运行节点 → agent { label 'xxx' } │
│ 构建环境-超时 → options { timeout(...) } │
│ 构建环境-时间戳 → options { timestamps() } │
│ 构建环境-并发控制 → options { disableConcurrentBuilds() } │
│ 构建步骤 → stages { stage(...) { steps {...} } }│
│ 构建后操作 → post { always/failure/success {...} } │
│ 环境变量 → environment { ... } │
└─────────────────────────────────────────────────────────────────┘
十五、Multibranch Pipeline配置
Multibranch Pipeline自动为每个分支创建Pipeline Job，是Gitflow工作流的最佳搭档。
15.1 创建Multibranch Pipeline
创建步骤：
1. Jenkins首页 → 新建任务
2. 输入名称，选择 "Multibranch Pipeline" 类型
3. 点击确定进入配置页面
15.2 Branch Sources配置
┌─────────────────────────────────────────────────────────────────┐
│ Branch Sources → Add source → Git │
│ │
│ 项目仓库配置： │
│ ├── Repository URL: https://gitlab.com/group/project.git │
│ ├── Credentials: gitlab-credentials │
│ └── Includes: * │
│ Excludes: │
│ │
│ ─── 或使用 GitLab / GitHub ─── │
│ │
│ Branch Sources → Add source → GitLab（需安装插件） │
│ ├── Server: gitlab-server │
│ ├── Owner: group-name │
│ ├── Project: project-name │
│ └── 自动发现分支和MR │
└─────────────────────────────────────────────────────────────────┘
15.3 分支发现策略
┌─────────────────────────────────────────────────────────────────┐
│ Discover branches: │
│ ├── All branches 发现所有分支 │
│ ├── Only master branch 仅发现主分支 │
│ └── Exclude branches that are also filed as PR │
│ 排除已提交PR的分支 │
│ │
│ Discover MR from origin: │
│ ├── Merge request from origin 发现源仓库的MR │
│ └── 配置MR的构建策略 │
│ │
│ Filter by name (with regular expression): │
│ ├── Include: (feature|bugfix|hotfix)/.* │
│ └── 只发现匹配正则的分支 │
└─────────────────────────────────────────────────────────────────┘
15.4 扫描配置
┌─────────────────────────────────────────────────────────────────┐
│ Scan Multibranch Pipeline Triggers │
│ │
│ ☑ Periodically if not otherwise run │
│ ├── Interval: 5 minutes │
│ └── 每5分钟自动扫描仓库，发现新分支/删除旧分支 │
│ │
│ 手动触发扫描： │
│ └── Multibranch Pipeline首页 → Scan Multibranch Pipeline Now │
│ │
│ 扫描结果： │
│ ├── 新分支 → 自动创建Pipeline Job │
│ ├── 已删除分支 → 自动删除对应Job │
│ └── Jenkinsfile变更 → 自动更新Pipeline配置 │
└─────────────────────────────────────────────────────────────────┘
15.5 与普通Pipeline的区别
| 特性 | Pipeline | Multibranch Pipeline |
|---|---|---|
| 分支管理 | 手动指定分支 | 自动发现所有分支 |
| Job数量 | 1个Job | 每个分支1个Job |
| Jenkinsfile | 可内联或SCM | 必须在仓库根目录 |
| PR/MR构建 | 需手动配置 | 自动支持 |
| 分支删除 | 手动清理 | 自动清理 |
| 适用场景 | 单分支/简单流程 | Gitflow/GitHub Flow |
十六、Job日常管理操作
日常运维中频繁使用的Job管理操作，很多新手容易忽略。
16.1 禁用与启用Job
┌─────────────────────────────────────────────────────────────────┐
│ 禁用Job │
│ ├── 方式1：Job首页 → 左侧菜单 "Disable Project" │
│ ├── 方式2：Job配置页 → 顶部勾选 "Disabled" │
│ └── 效果：Job变灰，不会响应任何触发器 │
│ │
│ 启用Job │
│ ├── 方式1：Job首页 → 左侧菜单 "Enable Project" │
│ └── 方式2：Job配置页 → 取消勾选 "Disabled" │
│ │
│ 适用场景： │
│ ├── 临时维护时暂停构建 │
│ ├── 依赖服务不可用时暂停 │
│ └── 废弃但暂时保留的Job │
└─────────────────────────────────────────────────────────────────┘
16.2 重命名与移动Job
┌─────────────────────────────────────────────────────────────────┐
│ 重命名Job │
│ ├── Job首页 → 左侧菜单 "Rename" │
│ ├── 输入新名称 → 点击确认 │
│ └── ⚠️ 注意： │
│ ├── 会影响所有引用该Job的上游/下游Job │
│ ├── URL会变化，外部链接会失效 │
│ └── 建议在低峰期操作 │
│ │
│ 移动Job到Folder │
│ ├── Job首页 → 左侧菜单 "Move" │
│ ├── 选择目标Folder │
│ └── ⚠️ 注意：URL路径会变化 │
└─────────────────────────────────────────────────────────────────┘
16.3 删除Job
┌─────────────────────────────────────────────────────────────────┐
│ 删除Job │
│ ├── 方式1：Job首页 → 左侧菜单 "Delete Project" │
│ ├── 方式2：Jenkins首页 → Job行 → 下拉菜单 → Delete │
│ └── ⚠️ 不可恢复！建议先备份config.xml │
│ │
│ 批量删除（使用Script Console）： │
│ Manage Jenkins → Script Console │
│ ───────────────────────────────────────────── │
│ // 删除所有以 "test-" 开头的Job │
│ Jenkins.instance.getAllItems(Job.class).each { job -> │
│ if (job.name.startsWith('test-')) { │
│ job.delete() │
│ println "Deleted: ${job.name}" │
│ } │
│ } │
└─────────────────────────────────────────────────────────────────┘
16.4 清理构建历史
┌─────────────────────────────────────────────────────────────────┐
│ 单个Job清理 │
│ ├── Job首页 → 左侧菜单 "Wipe Out Current Workspace" │
│ │ → 清理工作空间文件 │
│ └── Job首页 → 构建历史 → 逐个删除或批量清理 │
│ │
│ 批量清理旧构建（Script Console）： │
│ ───────────────────────────────────────────── │
│ // 清理所有Job的旧构建，只保留最近10次 │
│ Jenkins.instance.getAllItems(Job.class).each { job -> │
│ job.getBuilds().byTimestamp(0, │
│ System.currentTimeMillis() - 30*24*60*60*1000) │
│ .each { build -> │
│ build.delete() │
│ } │
│ println "Cleaned: ${job.name}" │
│ } │
│ │
│ 配置自动清理（推荐）： │
│ Job配置 → 勾选 "Discard old builds" │
│ ├── Days to keep builds: 30 │
│ ├── Max # of builds to keep: 50 │
│ ├── Days to keep artifacts: 7 │
│ └── Max # of builds to keep with artifacts: 10 │
└─────────────────────────────────────────────────────────────────┘
16.5 重新构建与中断构建
┌─────────────────────────────────────────────────────────────────┐
│ 重新构建 │
│ ├── Job首页 → 构建历史 → 点击构建号 → "Replay" │
│ │ → Pipeline Job支持修改脚本后重新执行 │
│ └── Job首页 → "Build Now" 触发新构建 │
│ │
│ 中断构建 │
│ ├── 构建详情页 → 左侧 "Abort Build" / 点击红色X按钮 │
│ ├── 效果：发送中断信号，构建进程收到SIGTERM/SIGINT │
│ └── ⚠️ 注意： │
│ ├── 中断可能不会立即生效（进程可能忽略信号） │
│ ├── 可能产生僵尸进程（需要手动kill） │
│ └── 中断的构建状态为 ABORTED（黄色） │
└─────────────────────────────────────────────────────────────────┘
十七、构建状态与结果详解
理解Jenkins的构建状态是排查问题和配置通知的前提。
17.1 构建状态分类
┌─────────────────────────────────────────────────────────────────┐
│ Jenkins构建状态一览 │
│ │
│ 🔵 SUCCESS (蓝色) │
│ ├── 构建完全成功 │
│ ├── 所有步骤正常完成 │
│ └── 触发条件：exit code = 0 │
│ │
│ 🟡 UNSTABLE (黄色) │
│ ├── 构建成功但测试失败 │
│ ├── 编译/打包成功，但测试用例有失败 │
│ └── 触发条件：测试框架报告失败（如JUnit失败） │
│ │
│ 🔴 FAILURE (红色) │
│ ├── 构建失败 │
│ ├── 编译错误、脚本执行失败、步骤异常 │
│ └── 触发条件：exit code ≠ 0 或步骤抛出异常 │
│ │
│ ⚪ ABORTED (灰色) │
│ ├── 构建被手动中止 │
│ ├── 超时被自动中止 │
│ └── 触发条件：用户点击Abort或超时 │
│ │
│ 🔶 NOT_BUILT (灰色) │
│ ├── 该阶段未执行 │
│ ├── 多出现在Pipeline的when条件不满足时 │
│ └── 触发条件：stage被跳过 │
└─────────────────────────────────────────────────────────────────┘
17.2 状态转换与触发条件
构建状态转换流程：
开始构建
│
▼
┌─────────┐ exit 0 + 测试全通过 ┌──────────┐
│ 执行中 │ ──────────────────────→ │ SUCCESS │
│ (BUILDING)│ └──────────┘
└─────────┘ exit 0 + 测试失败 ┌──────────┐
│ ──────────────────────→ │ UNSTABLE │
│ └──────────┘
│ exit ≠ 0 / 异常 ┌──────────┐
├────────────────────────────→ │ FAILURE │
│ └──────────┘
│ 手动中止 / 超时 ┌──────────┐
└────────────────────────────→ │ ABORTED │
└──────────┘
17.3 在Pipeline中设置构建结果
pipeline {
agent any
stages {
stage('Test') {
steps {
script {
def testResult = runTests()
if (testResult.failCount > 0) {
currentBuild.result = 'UNSTABLE'
echo "Tests failed: ${testResult.failCount}"
}
}
}
}
stage('Deploy') {
when {
expression { currentBuild.result != 'UNSTABLE' }
}
steps {
sh './deploy.sh'
}
}
}
post {
unstable {
echo 'Build is UNSTABLE - tests failed!'
mail to: 'team@example.com',
subject: "UNSTABLE: ${env.JOB_NAME} #${env.BUILD_NUMBER}",
body: 'Test failures detected'
}
}
}
17.4 构建状态与通知配置对照
| 构建状态 | 邮件通知 | 钉钉/企微 | 触发下游Job |
|---|---|---|---|
| SUCCESS | ✅ 可选 | ✅ 可选 | ✅ 触发 |
| UNSTABLE | ✅ 推荐 | ✅ 推荐 | ⚠️ 可配置 |
| FAILURE | ✅ 必须 | ✅ 必须 | ❌ 不触发 |
| ABORTED | ❌ 通常不发 | ❌ 通常不发 | ❌ 不触发 |
十八、Jenkins CLI与REST API操作Job
批量管理Job时，命令行和API比Web界面高效得多。
18.1 Jenkins CLI
# 下载CLI jar
curl -LO http://jenkins-server:8080/jnlpJars/jenkins-cli.jar
# 基本格式
java -jar jenkins-cli.jar -s http://jenkins-server:8080/ -auth user:token <command>
# 常用Job操作
java -jar jenkins-cli.jar -s http://localhost:8080 list-jobs
java -jar jenkins-cli.jar -s http://localhost:8080 get-job my-job
java -jar jenkins-cli.jar -s http://localhost:8080 create-job new-job < config.xml
java -jar jenkins-cli.jar -s http://localhost:8080 copy-job template new-job
java -jar jenkins-cli.jar -s http://localhost:8080 delete-job my-job
java -jar jenkins-cli.jar -s http://localhost:8080 build my-job
java -jar jenkins-cli.jar -s http://localhost:8080 build my-job -p BRANCH=dev
java -jar jenkins-cli.jar -s http://localhost:8080 disable-job my-job
java -jar jenkins-cli.jar -s http://localhost:8080 enable-job my-job
18.2 REST API操作
⚠️ 重要：Jenkins默认启用CSRF保护，所有POST请求必须携带Crumb头！
获取Crumb：
curl -s -u user:token "http://localhost:8080/crumbIssuer/api/json"
返回示例：{"crumb":"abc123","crumbRequestField":"Jenkins-Crumb"}
在后续POST请求中添加Header：
-H "Jenkins-Crumb: abc123"
# 获取Job列表
curl -s -u user:token "http://localhost:8080/api/json?pretty=true"
# 获取Job详情
curl -s -u user:token "http://localhost:8080/job/my-job/api/json?pretty=true"
# 触发构建（需要Crumb）
CRUMB=$(curl -s -u user:token "http://localhost:8080/crumbIssuer/api/json" | python3 -c "import sys,json; print(json.load(sys.stdin)['crumb'])")
curl -X POST -u user:token -H "Jenkins-Crumb: $CRUMB" "http://localhost:8080/job/my-job/build"
# 参数化构建
curl -X POST -u user:token -H "Jenkins-Crumb: $CRUMB" \
"http://localhost:8080/job/my-job/buildWithParameters?BRANCH=dev&ENV=test"
# 获取构建日志
curl -s -u user:token "http://localhost:8080/job/my-job/1/consoleText"
# 获取构建状态
curl -s -u user:token "http://localhost:8080/job/my-job/1/api/json" | \
python3 -c "import sys,json; print(json.load(sys.stdin)['result'])"
# 创建Job（需要Crumb + config.xml）
curl -X POST -u user:token -H "Jenkins-Crumb: $CRUMB" -H "Content-Type: application/xml" \
--data-binary @config.xml \
"http://localhost:8080/createItem?name=new-job"
# 更新Job配置
curl -X POST -u user:token -H "Jenkins-Crumb: $CRUMB" -H "Content-Type: application/xml" \
--data-binary @config.xml \
"http://localhost:8080/job/my-job/config.xml"
# 删除Job
curl -X POST -u user:token -H "Jenkins-Crumb: $CRUMB" "http://localhost:8080/job/my-job/doDelete"
# 启用/禁用Job
curl -X POST -u user:token -H "Jenkins-Crumb: $CRUMB" "http://localhost:8080/job/my-job/enable"
curl -X POST -u user:token -H "Jenkins-Crumb: $CRUMB" "http://localhost:8080/job/my-job/disable"
18.3 批量操作脚本
#!/bin/bash
# batch_job_ops.sh - Jenkins Job批量操作脚本
JENKINS_URL="http://localhost:8080"
USER="admin"
TOKEN="your-api-token"
# 批量禁用匹配的Job
disable_jobs() {
local pattern=$1
curl -s -u "$USER:$TOKEN" "$JENKINS_URL/api/json?tree=jobs[name]" | \
python3 -c "
import sys, json
jobs = json.load(sys.stdin)['jobs']
for job in jobs:
if '$pattern' in job['name']:
print(job['name'])
" | while read job; do
curl -X POST -u "$USER:$TOKEN" "$JENKINS_URL/job/$job/disable"
echo "Disabled: $job"
done
}
# 批量触发构建
trigger_builds() {
local pattern=$1
curl -s -u "$USER:$TOKEN" "$JENKINS_URL/api/json?tree=jobs[name]" | \
python3 -c "
import sys, json
jobs = json.load(sys.stdin)['jobs']
for job in jobs:
if '$pattern' in job['name']:
print(job['name'])
" | while read job; do
curl -X POST -u "$USER:$TOKEN" "$JENKINS_URL/job/$job/build"
echo "Triggered: $job"
done
}
# 使用示例
# disable_jobs "test-"
# trigger_builds "deploy-"
十九、Job常见问题排查
Job使用中的高频问题与解决方案。
19.1 构建卡住不动
┌─────────────────────────────────────────────────────────────────┐
│ 症状：构建一直运行，不结束也不输出 │
│ │
│ 排查步骤： │
│ 1. 查看控制台输出 │
│ → 是否卡在某个步骤（如等待输入、下载依赖） │
│ 2. 检查执行器占用 │
│ → Manage Jenkins → 节点列表 → 查看执行器状态 │
│ 3. 检查是否等待用户输入 │
│ → Pipeline的input步骤会暂停等待 │
│ 4. 检查网络问题 │
│ → 下载外部依赖超时（Maven/npm） │
│ │
│ 解决方案： │
│ ├── 配置构建超时（Abort the build if it's stuck） │
│ ├── 检查代理设置（HTTP_PROXY等） │
│ ├── 配置Maven/npm镜像源加速 │
│ └── 手动Abort后检查是否有僵尸进程 │
│ → ps aux | grep java │
│ → kill -9 <pid> │
└─────────────────────────────────────────────────────────────────┘
19.2 Workspace问题
┌─────────────────────────────────────────────────────────────────┐
│ 问题1：Workspace磁盘空间不足 │
│ ├── df -h 查看磁盘使用 │
│ ├── 清理旧Workspace： │
│ │ find /var/lib/jenkins/workspace -mtime +30 -exec rm -rf {} \;│
│ └── 配置Workspace自动清理 │
│ │
│ 问题2：Workspace文件权限错误 │
│ ├── ls -la 查看文件权限 │
│ ├── chown -R jenkins:jenkins workspace/ │
│ └── 检查Docker容器挂载的权限映射 │
│ │
│ 问题3：Workspace残留导致构建失败 │
│ ├── 勾选 "Delete workspace before build starts" │
│ ├── 或在Pipeline中添加： │
│ │ steps { │
│ │ cleanWs() │
│ │ } │
│ └── 或使用Git clean： │
│ steps { │
│ checkout([$class: 'GitSCM', ..., extensions: [ │
│ [$class: 'CleanBeforeCheckout'], │
│ [$class: 'CleanAfterCheckout'], │
│ ]]) │
│ } │
└─────────────────────────────────────────────────────────────────┘
19.3 构建权限问题
┌─────────────────────────────────────────────────────────────────┐
│ 问题1：用户无法触发构建 │
│ ├── 检查用户是否有 Job/Build 权限 │
│ ├── 检查项目矩阵授权配置 │
│ └── 检查Role-based Strategy的角色分配 │
│ │
│ 问题2：构建无法访问Git仓库 │
│ ├── 检查Credentials配置是否正确 │
│ ├── 检查SSH密钥是否有效（ssh -T git@github.com） │
│ ├── 检查网络是否可达 │
│ └── 检查仓库权限（用户是否有读权限） │
│ │
│ 问题3：构建无法执行Shell命令 │
│ ├── 检查jenkins用户是否有执行权限 │
│ ├── 检查脚本是否有+x权限 │
│ ├── 检查sudo配置（jenkins用户是否在sudoers中） │
│ └── 使用绝对路径执行命令 │
└─────────────────────────────────────────────────────────────────┘
19.4 构建环境问题
┌─────────────────────────────────────────────────────────────────┐
│ 问题1：Java版本不匹配 │
│ ├── 在Job配置中指定JDK版本 │
│ ├── 或在Shell步骤开头设置： │
│ │ export JAVA_HOME=/usr/lib/jvm/java-11 │
│ │ export PATH=$JAVA_HOME/bin:$PATH │
│ └── 全局工具配置中管理多个JDK版本 │
│ │
│ 问题2：Maven构建OOM │
│ ├── 增大MAVEN_OPTS： │
│ │ MAVEN_OPTS="-Xmx2048m -XX:MaxMetaspaceSize=512m" │
│ ├── 检查Jenkins节点内存是否充足 │
│ └── 考虑使用独立构建节点而非Master │
│ │
│ 问题3：中文乱码 │
│ ├── Jenkins启动参数添加： │
│ │ -Dfile.encoding=UTF-8 -Dsun.jnu.encoding=UTF-8 │
│ ├── Shell步骤开头添加： │
│ │ export LANG=en_US.UTF-8 │
│ └── 检查系统locale设置 │
└─────────────────────────────────────────────────────────────────┘
二十、凭据管理详解
凭据（Credentials）是Job访问外部系统（Git、Docker Registry、SSH等）的认证信息，安全管理凭据是Jenkins运维的基础。
20.1 凭据类型
| 类型 | 说明 | 使用场景 |
|---|---|---|
| Username with password | 用户名+密码 | Git HTTP认证、API Token |
| SSH Username with private key | SSH用户名+私钥 | Git SSH克隆、远程部署 |
| Secret text | 单一秘密文本 | API Token、Webhook Secret |
| Secret file | 秘密文件 | 证书文件、配置文件 |
| Certificate | PKCS12证书 | 双向TLS认证 |
20.2 创建凭据
创建凭据步骤：
1. Manage Jenkins → Credentials → System → Global credentials
2. 点击 "Add Credentials"
3. 选择类型并填写信息
4. 点击 "Create"
凭据作用域：
├── Global 全局可用（任何Job都能引用）
└── System 仅Jenkins系统内部使用（如Master节点连接Agent）
20.3 常用凭据配置示例
┌─────────────────────────────────────────────────────────────────┐
│ 示例1：Git SSH密钥 │
│ ├── Kind: SSH Username with private key │
│ ├── ID: github-ssh-key │
│ ├── Username: git │
│ ├── Private Key: ☑ Enter directly │
│ │ └── 粘贴 ~/.ssh/id_rsa 内容 │
│ └── Passphrase: （如有设置则填写） │
│ │
│ 示例2：Docker Registry │
│ ├── Kind: Username with password │
│ ├── ID: docker-registry-creds │
│ ├── Username: admin │
│ ├── Password: ******** │
│ └── Description: Harbor镜像仓库认证 │
│ │
│ 示例3：API Token │
│ ├── Kind: Secret text │
│ ├── ID: vault-api-token │
│ ├── Secret: s.xxxxxxxxxxxxx │
│ └── Description: Vault访问令牌 │
└─────────────────────────────────────────────────────────────────┘
20.4 在Pipeline中使用凭据
pipeline {
agent any
stages {
stage('Git Checkout') {
steps {
git credentialsId: 'github-ssh-key',
url: 'git@github.com:company/project.git',
branch: 'main'
}
}
stage('Docker Push') {
steps {
withCredentials([usernamePassword(
credentialsId: 'docker-registry-creds',
usernameVariable: 'DOCKER_USER',
passwordVariable: 'DOCKER_PASS'
)]) {
sh 'echo $DOCKER_PASS | docker login -u $DOCKER_USER --password-stdin'
sh 'docker push my-app:latest'
}
}
}
stage('Deploy') {
steps {
withCredentials([sshUserPrivateKey(
credentialsId: 'deploy-ssh-key',
keyFileVariable: 'SSH_KEY',
usernameVariable: 'SSH_USER'
)]) {
sh "ssh -i $SSH_KEY $SSH_USER@prod-server 'deploy.sh'"
}
}
}
}
}
20.5 凭据安全最佳实践
┌─────────────────────────────────────────────────────────────────┐
│ ⚠️ 凭据安全注意事项： │
│ │
│ 1. 永远不要在Jenkinsfile中硬编码密码 │
│ ❌ sh 'curl -u admin:password123 ...' │
│ ✅ withCredentials([...]) { sh 'curl -u $USER:$PASS ...' } │
│ │
│ 2. 使用最小权限原则 │
│ ├── Git仓库：只读权限的Deploy Key │
│ └── Docker Registry：只推送到指定仓库的账号 │
│ │
│ 3. 定期轮换凭据 │
│ ├── 更新凭据后ID不变，Job自动使用新值 │
│ └── 建议每90天轮换一次密码/Token │
│ │
│ 4. 控制凭据可见性 │
│ ├── Job权限中 "Credentials" 权限需谨慎授予 │
│ └── 避免在构建日志中泄露凭据（Credentials Binding插件） │
│ │
│ 5. 使用凭据ID而非明文 │
│ ├── 每个凭据都有唯一ID（如 github-ssh-key） │
│ └── 引用时使用ID，不使用用户名密码 │
└─────────────────────────────────────────────────────────────────┘
二十一、Jenkins内置环境变量
Jenkins提供了大量内置环境变量，在构建步骤和Pipeline中可直接引用，是自动化脚本的关键支撑。
21.1 核心环境变量列表
| 变量名 | 说明 | 示例值 |
|---|---|---|
BUILD_NUMBER |
当前构建编号 | 42 |
BUILD_ID |
当前构建ID（等同BUILD_NUMBER） | 42 |
BUILD_TAG |
构建标签（jenkins-Job名-编号） | jenkins-my-job-42 |
BUILD_URL |
当前构建的完整URL | http://jenkins/job/my-job/42/ |
JOB_NAME |
Job名称 | my-project |
JOB_URL |
Job的URL | http://jenkins/job/my-project/ |
WORKSPACE |
工作空间绝对路径 | /var/lib/jenkins/workspace/my-project |
JENKINS_URL |
Jenkins服务器URL | http://jenkins/ |
JENKINS_HOME |
Jenkins主目录 | /var/lib/jenkins |
NODE_NAME |
执行构建的节点名 | master 或 agent-01 |
NODE_LABELS |
节点标签 | linux docker maven |
EXECUTOR_NUMBER |
执行器编号 | 0 |
CVS_BRANCH |
CVS分支 | - |
21.2 Git相关环境变量
| 变量名 | 说明 | 前提条件 |
|---|---|---|
GIT_COMMIT |
当前提交的SHA | 使用Git SCM |
GIT_BRANCH |
当前分支名 | 使用Git SCM |
GIT_PREVIOUS_COMMIT |
上次构建的SHA | 使用Git SCM |
GIT_PREVIOUS_SUCCESSFUL_COMMIT |
上次成功构建的SHA | 使用Git SCM |
GIT_URL |
Git仓库URL | 使用Git SCM |
GIT_LOCAL_BRANCH |
本地分支名 | 使用Git SCM |
21.3 Pipeline专用变量
| 变量名 | 说明 | 示例 |
|---|---|---|
env.BUILD_NUMBER |
Pipeline中引用构建号 | "${env.BUILD_NUMBER}" |
env.JOB_NAME |
Pipeline中引用Job名 | "${env.JOB_NAME}" |
env.WORKSPACE |
Pipeline中引用工作空间 | "${env.WORKSPACE}" |
currentBuild.result |
当前构建结果 | SUCCESS/FAILURE |
currentBuild.displayName |
构建显示名 | #42 - main |
currentBuild.description |
构建描述 | Deployed to prod |
params.XXX |
引用参数 | "${params.BRANCH}" |
env.XXX |
引用environment定义的变量 | "${env.APP_NAME}" |
21.4 在Shell中使用环境变量
#!/bin/bash
echo "Job: ${JOB_NAME}"
echo "Build: #${BUILD_NUMBER}"
echo "Workspace: ${WORKSPACE}"
echo "Node: ${NODE_NAME}"
echo "Git Commit: ${GIT_COMMIT:0:8}"
echo "Git Branch: ${GIT_BRANCH}"
echo "Build URL: ${BUILD_URL}"
# Windows批处理中使用
# echo Job: %JOB_NAME%
# echo Build: #%BUILD_NUMBER%
# echo Workspace: %WORKSPACE%
二十二、Webhook触发配置详解
Webhook是实现"代码推送即构建"的核心机制，比轮询SCM更实时、更高效。
22.1 Webhook工作原理
Webhook触发流程：
┌──────────────┐ HTTP POST ┌──────────────┐ 触发构建 ┌──────────────┐
│ Git服务器 │ ──────────────→ │ Jenkins │ ────────────→ │ Job执行 │
│ (GitHub等) │ push事件通知 │ Webhook端点 │ │ │
└──────────────┘ └──────────────┘ └──────────────┘
关键配置要素：
├── Jenkins公网可访问的URL（或使用内网穿透）
├── Job中启用Webhook触发
└── Git服务器配置Webhook URL
22.2 GitHub Webhook配置
步骤1：Jenkins Job配置
├── 构建触发器 → ☑ GitHub hook trigger for GITScm polling
└── （需要安装 GitHub plugin 和 Git plugin）
步骤2：GitHub仓库配置
├── 仓库 → Settings → Webhooks → Add webhook
├── Payload URL: http://jenkins-server:8080/github-webhook/
├── Content type: application/json
├── Secret: （可选，用于验证签名）
├── Events: ☑ Just the push event（或自定义）
└── Active: ☑
触发URL格式：
└── http://<jenkins-url>/github-webhook/
22.3 GitLab Webhook配置
步骤1：Jenkins Job配置
├── 构建触发器 → ☐ Build when a change is pushed to GitLab
├── 勾选需要的触发事件：
│ ├── ☑ Push Events
│ ├── ☑ Opened Merge Request Events
│ ├── ☑ Approved Merge Request Events
│ └── ☑ Tag Push Events
├── 设置 Secret token（点击Generate生成）
└── （需要安装 GitLab plugin）
步骤2：GitLab仓库配置
├── 仓库 → Settings → Webhooks → Add new webhook
├── URL: http://jenkins-server:8080/project/my-job
├── Secret token: （填入Jenkins中生成的token）
├── Trigger: ☑ Push events / ☑ Tag push events
├── SSL verification: ☐ （测试环境可关闭）
└── 点击 "Add webhook" → 测试 "Test" → "Push events"
触发URL格式：
└── http://<jenkins-url>/project/<job-name>
22.4 Gitee Webhook配置
步骤1：Jenkins Job配置
├── 构建触发器 → ☑ Gitee WebHook 触发构建
├── 勾选触发事件：
│ ├── ☑ Push
│ ├── ☑ Pull Request
│ └── ☑ Tag Push
├── Gitee WebHook 密码：点击Generate生成
└── （需要安装 Gitee plugin）
步骤2：Gitee仓库配置
├── 仓库 → 管理 → WebHooks → 添加WebHook
├── URL: http://jenkins-server:8080/gitee-project/my-job
├── 密码：填入Jenkins中生成的密码
├── 勾选事件：Push / Pull Request / Tag Push
└── 点击 "添加" → "测试推送"
22.5 通用Webhook（Generic Webhook Trigger）
使用 Generic Webhook Trigger 插件（支持任意Git平台）：
步骤1：安装插件
└── Generic Webhook Trigger Plugin
步骤2：Job配置
├── 构建触发器 → ☑ Generic Webhook Trigger
├── Token: my-job-token（自定义，用于区分不同Job）
├── Post content parameters:
│ ├── Variable: REF
│ │ Expression: $.ref
│ │ └── 从JSON payload中提取ref字段
│ └── Variable: COMMIT_MSG
│ Expression: $.commits[0].message
│ └── 提取提交信息
├── Optional filter:
│ ├── Expression: refs/heads/(main|develop)
│ └── Text: $REF
│ └── 只在main/develop分支推送时触发
└── Print post content: ☑（调试用）
步骤3：触发URL
└── http://<jenkins-url>/generic-webhook-trigger/invoke?token=my-job-token
测试：
curl -X POST http://jenkins:8080/generic-webhook-trigger/invoke \
-H "Content-Type: application/json" \
-d '{"ref":"refs/heads/main","commits":[{"message":"test"}]}'
22.6 Webhook常见问题
┌─────────────────────────────────────────────────────────────────┐
│ 问题1：Webhook无法触发构建 │
│ ├── 检查Jenkins是否可从公网访问 │
│ ├── 检查防火墙是否放行Jenkins端口 │
│ ├── 检查Webhook URL是否正确 │
│ └── 检查Job中是否启用了对应的触发器 │
│ │
│ 问题2：Jenkins在内网，Git服务器在公网 │
│ ├── 方案1：使用内网穿透（ngrok/frp）暴露Jenkins │
│ ├── 方案2：使用轮询SCM代替Webhook │
│ └── 方案3：使用Git平台的中转服务（如GitLab CI触发Jenkins） │
│ │
│ 问题3：Webhook触发但构建未执行 │
│ ├── 检查分支过滤条件是否匹配 │
│ ├── 检查Job是否被禁用 │
│ └── 查看Jenkins日志：Manage Jenkins → System Log │
└─────────────────────────────────────────────────────────────────┘
附录A：Job常用URL
Jenkins Job相关URL：
┌─────────────────────────────────────────────────────────────────┐
│ Job相关URL │
├─────────────────────────────────────────────────────────────────┤
│ Job首页： /job/{job-name}/ │
│ Job配置： /job/{job-name}/configure │
│ Job删除： /job/{job-name}/doDelete │
│ Job复制： /job/{job-name}/clone │
│ Job重命名： /job/{job-name}/rename │
│ │
│ 构建相关URL： │
│ ├── 构建列表： /job/{job-name}/ │
│ ├── 触发构建： /job/{job-name}/build │
│ ├── 控制台输出： /job/{job-name}/{n}/console │
│ ├── 构建产物： /job/{job-name}/{n}/artifact │
│ └── 删除构建： /job/{job-name}/{n}/doDelete │
│ │
│ API： │
│ └── JSON API： /job/{job-name}/api/json │
└─────────────────────────────────────────────────────────────────┘
附录B：Jenkins 2.5 特性
Jenkins 2.5 新特性：
┌─────────────────────────────────────────────────────────────────┐
│ Pipeline相关 │
│ ├── Pipeline as Code (Jenkinsfile) │
│ ├── Blue Ocean UI (Beta) │
│ └── Pipeline Support Improvements │
│ │
│ 安全相关 │
│ ├── 改进了凭证存储 │
│ ├── 更严格的CSRF防护 │
│ └── 加密存储增强 │
│ │
│ 用户体验 │
│ ├── 改进了构建队列UI │
│ ├── 更好的历史记录搜索 │
│ └── Favorite Views │
│ │
│ 性能优化 │
│ ├── 更快的首页加载 │
│ └── 改进了大列表渲染性能 │
└─────────────────────────────────────────────────────────────────┘
腾讯云面向开发者汇聚海量精品云计算使用和开发经验，营造开放的云计算技术生态圈。
更多推荐
5
0- 0
已为社区贡献2条内容
所有评论(0)