1.4.3.1 创建任务#

点击“新建任务”，输入名称（建议避免空格，防止路径解析问题），这里选择“自由风格项目”。

1.4.3.2 通用设置#

1.4.3.3 源码管理#

如果使用git来管理源码，那么可以选择git，然后填写相应参数

1.4.3.4 构建触发器#

• 触发远程构建：允许通过外部请求来触发构建，通常是通过一个带有认证令牌（Token）的特定 URL。这在需要从其他系统（如脚本、其他 CI/CD 工具或 Git 钩子）调用 Jenkins 任务时非常有用。例如：当github代码仓库有新的提交后会主动发送一个http请求到jenkins服务器指定的URL地址，然后触发构建
• 其他工程构建后触发：用于实现项目间的依赖关系。当在列表中指定的其他 Jenkins 任务（工程）成功（或失败、不稳定等）构建完成后，会自动触发当前这个任务的构建。
• 定时构建：自定义时间点进行触发构建
• GitHub hook trigger for GITScm polling:用于和 GitHub 进行集成。当你在 GitHub 上配置了 Webhook 后，一旦代码仓库发生推送（Push）等事件，GitHub 会主动通知 Jenkins，从而立即触发构建。这是一种事件驱动的即时触发方式，比轮询更高效
• 轮询 SCM:Jenkins 会按照设定的时间表，定期检查代码仓库是否有新的提交。如果检测到代码有变化，就触发一次构建；如果没有变化，则不执行任何操作。这是一种被动检查的触发方式。

1.4.3.5 环境#

• **Delete workspace before build starts：**在每次构建开始前，自动删除工作空间中的所有文件。这能确保构建在一个干净、无干扰的环境中进行，避免因上一次构建残留的文件（如旧的编译产物、缓存等）导致本次构建失败或结果不一致。
• **Use secret text(s) or file(s)：**用于安全地注入敏感信息，如密码、API密钥、证书文件等。通过此功能，可以将凭据从 Jenkins 的凭据存储中绑定到当前构建的环境变量或文件中，而无需在脚本或配置里明文写出，有效防止敏感信息泄露。
• **Inspect build log for published build scans：**这个选项通常与特定的代码质量或安全扫描插件（如 SonarQube, Checkmarx 等）配合使用。它会检查构建日志，寻找由这些插件发布的扫描结果链接或摘要，并可能在 Jenkins 界面上提供更便捷的访问入口。
• Terminate a build if it’s stuck：为构建任务设置一个超时时间。如果构建运行时间超过了预设的时长，Jenkins 会自动强制终止该任务。这可以防止因网络问题、死锁或脚本错误导致构建无限期挂起，从而浪费系统资源。
• With Ant：如果你的项目使用 Apache Ant 作为构建工具，勾选此项可以为当前任务指定一个特定版本的 Ant。Jenkins 会自动配置好 Ant 的环境变量，确保构建脚本能在正确的 Ant 环境下执行。
• 在构建日志中添加时间戳前缀：在构建日志的每一行输出前，自动添加一个时间戳。这对于分析构建过程、定位耗时较长的步骤以及排查问题非常有帮助，能让你清晰地知道每个操作发生的具体时间

1.4.3.6 构建步骤#

• **invoke ant：**调用 Apache Ant 构建工具
• **invoke gradle script：**调用 Gradle 构建工具
• **run with timeout:**这是一个包装器步骤。可以将其他构建步骤放在这个步骤内部，并为其设置一个最长运行时间。如果内部的步骤在指定时间内没有完成，整个构建就会被强制中断。这可以防止某个任务因为意外情况（如死循环、网络卡死）而无限期地运行下去。
• **Set build status to “pending” on GitHub commit：**这个步骤用于与 GitHub 集成。当构建开始时，它会向 GitHub 发送一个状态更新，将对应 Commit 的状态设置为“pending”（处理中）。这会让开发人员在 GitHub 的 Pull Request 或 Commit 页面上看到构建正在进行中，提供了即时反馈。通常与“GitHub Commit Status”插件配合使用。
• **执行Windows批处理命令：**执行 .bat 或 .cmd 批处理脚本
• **执行shell：**可以执行shell命令或shell脚本
• 调用顶层 Maven 目标：调用 Maven 命令

1.3.5.7 构建后操作#

• Aggregate downstream test results：主要用于多模块或流水线项目。它会收集并汇总所有下游（即被当前任务触发的其他任务）的测试结果，让你在一个地方看到整个流程的测试报告。
• Publish JUnit test result report：专门用于发布 JUnit 格式的测试报告（通常是 XML 文件）。配置后，Jenkins 会解析这些文件，并在界面上展示详细的测试结果，如通过/失败数量、失败堆栈信息等。
• 归档成品：将构建生成的关键文件（如 .jar, .war, .exe 等）保存到 Jenkins 服务器上。即使工作空间被清理，你依然可以在 Jenkins 的历史记录中下载这些文件。
• 记录文件的指纹用于追踪：为指定文件生成唯一的指纹（如 MD5 校验码）。Jenkins 会记录哪个构建生成了该文件，以及哪个构建使用了它，非常适合追踪依赖关系和版本溯源。
• Delete workspace when build is done：构建结束后自动删除工作空间的所有文件。这能释放磁盘空间，确保下一次构建从一个干净的环境开始。
• 构建其他工程：在当前任务成功后，自动触发一个或多个其他 Jenkins 任务的构建。这是实现任务链和复杂流水线的基础方式。
• Git Publisher：在构建成功后，将某些操作（如打 Tag、推送到特定分支）回写到 Git 仓库。
• E-mail Notification：通过 SMTP 发送标准的构建结果邮件（成功/失败）。通常需要配置收件人列表。
• Editable Email Notification：这是“E-mail Notification”的增强版。它允许你高度自定义邮件的主题、内容、收件人规则（例如：只在失败时发给开发者，成功时发给全员），并支持附件。
• Set GitHub commit status (universal)：向 GitHub 发送当前构建的最终状态（Success, Failure, Error）。这样在 GitHub 的 Commit 或 Pull Request 页面上，会显示一个绿色的对勾或红色的叉，直观地告诉开发人员代码是否通过了 CI。
• Set build status on GitHub commit [deprecated]：这是上述功能的旧版本，已不推荐使用，建议直接使用通用的版本。

• 工作空间：任务配置保存在 /var/jenkins_home/jobs/[TaskName] 目录下，构建产物位于 workspace 子目录中。
• 构建步骤：
• 源码管理：配置 Git 仓库地址、凭据及分支。
• 构建触发器：支持定时构建、SCM 轮询或远程触发。
• 构建操作：支持 Shell 脚本、批处理命令、Maven/Gradle 构建等。
• 执行与查看：点击“立即构建”触发任务。在“控制台输出”中查看日志，在“工作空间”中查看生成的文件。

快速创建一个任务：

新建任务->构建自由风格的软件项目

通用设置、源码管理、构建触发器、构建环境这些不填

构建步骤选择sehll，然后填入shell命令后保存 后，可以看到创建的任务

点击进入任务后可以，点击立即构建，等一会可以看到构建历史

查看构建控制台输出

编辑编译信息可以修改描述

修改后会在这里显示

1.4.4.1 流水线#

Pipeline 是 Jenkins 实现复杂构建逻辑的关键。

定义：流水线脚本（pipeline script）

• 脚本类型：有各种常用的流水线语法，也可以使用下方的流水线语法查看语法示例结构

  • 声明式流水线（hello world）：语法简洁、结构化，适合大多数场景。

  • 脚本式流水线（scripted pipeline）：语法灵活，适合复杂逻辑，但相对复杂。

如果流水线文件在git仓库，则可以选择以下定义，然后填写相应的选项

1.4.4.2 快速构建流水线#

在流水线页面构建好后，然后保存

之后进行构建

stages可以查看构建的各个阶段

构建完成后可以进行查看

1.4.4.3 jenkinsfile#

如果想把流水线文件也能够进行版本控制，那么就可以把流水线文件修改为jenkinfile然后跟随项目一同放入仓库

之后配置的时候流水线就是从仓库中拉取，然后配置仓库地址、仓库访问认证、构建分支、脚本路径等

1.4.5.1 关联docker#

为了能在 Jenkins 里构建 Docker 镜像，需要把宿主机的 Docker 挂载进去

或者可以配置云管理中的docker（两者选择一个）

1
docker run -d --name jenkins \
2
  -p 8080:8080 -p 50000:50000 \
3
  -v jenkins_data:/var/jenkins_home \
4
  -v /var/run/docker.sock:/var/run/docker.sock \
5
  -v /usr/bin/docker:/usr/bin/docker \
6
  jenkins/jenkins:lts-jdk17

赋予jenkins用户访问访问宿主机的 docker.sock权限

1
chmod 666 /var/run/docker.sock

1.4.5.2 安装插件#

• GitHub Integration Plugin（用于 Webhook 自动触发）
• Docker Pipeline（用于构建镜像）

1.4.5.3 配置全局工具#

根据1.4.6 进行配置全局工具，配置jdk以及maven

1.4.5.4 创建github仓库#

创建公共仓库，然后创建文件

1
<?xml version="1.0" encoding="UTF-8"?>
2
<project xmlns="http://maven.apache.org/POM/4.0.0">
3
    <modelVersion>4.0.0</modelVersion>
4
    <groupId>com.example</groupId>
5
    <artifactId>demo</artifactId>
6
    <version>1.0</version>
7
    <packaging>jar</packaging>
8

9
    <parent>
10
        <groupId>org.springframework.boot</groupId>
11
        <artifactId>spring-boot-starter-parent</artifactId>
12
        <version>3.2.0</version>
13
    </parent>
14

15
    <properties>
16
        <java.version>21</java.version> <!-- 明确指定 21 -->
17
    </properties>
18

19
    <dependencies>
20
        <dependency>
21
            <groupId>org.springframework.boot</groupId>
22
            <artifactId>spring-boot-starter-web</artifactId>
23
        </dependency>
24
        <dependency>
25
            <groupId>org.springframework.boot</groupId>
26
            <artifactId>spring-boot-starter-test</artifactId>
27
            <scope>test</scope>
28
        </dependency>
29
    </dependencies>
30

31
    <build>
32
        <plugins>
33
            <plugin>
34
                <groupId>org.springframework.boot</groupId>
35
                <artifactId>spring-boot-maven-plugin</artifactId>
36
            </plugin>
37
        </plugins>
38
    </build>
39
</project>

1
# 使用 JDK 21 的运行时镜像
2
FROM eclipse-temurin:21-jre-alpine
3
WORKDIR /app
4
# 复制 maven 打包好的 jar
5
COPY target/demo-1.0.jar app.jar
6
ENTRYPOINT ["java", "-jar", "app.jar"]

1
package com.example;
2

3
import org.springframework.boot.SpringApplication;
4
import org.springframework.boot.autoconfigure.SpringBootApplication;
5
import org.springframework.web.bind.annotation.GetMapping;
6
import org.springframework.web.bind.annotation.RestController;
7

8
@SpringBootApplication
9
@RestController
10
public class DemoApplication {
11
    public static void main(String[] args) {
12
        SpringApplication.run(DemoApplication.class, args);
13
    }
14

15
    @GetMapping("/")
16
    public String hello() {
17
        return "Hello from Jenkins CI/CD with JDK 21!";
18
    }
19
}

1
pipeline {
2
    agent any
3

4
    tools {
5
        jdk 'jdk21'
6
        maven 'maven-3.9.9'
7
    }
8

9
    environment {
10
        IMAGE_NAME = "demo-app"
11
        CONTAINER_NAME = "demo-container"
12
    }
13

14
    stages {
15
        stage('拉取代码') {
16
            steps {
17
                checkout scm
18
            }
19
        }
20

21
        stage('编译构建') {
22
            steps {
23
                sh 'mvn clean package -DskipTests'
24
            }
25
        }
26

27
        stage('Docker 清理缓存（防构建失败）') {
28
            steps {
29
                script {
30
                    // 安全清理 Docker 构建缓存，不影响运行中的容器
31
                    sh "docker builder prune -a -f"
32
                }
33
            }
34
        }
35

36
        stage('构建并运行 Docker') {
37
            steps {
38
                script {
39
                    // 1. 构建镜像
40
                    sh "docker build -t ${IMAGE_NAME} ."
41

42
                    // 2. 停止并删除旧容器
43
                    sh """
44
                        if [ \$(docker ps -aq --filter name=\${CONTAINER_NAME}) ]; then
45
                            docker stop \${CONTAINER_NAME}
46
                            docker rm \${CONTAINER_NAME}
47
                        fi
48
                    """
49

50
                    // 3. 运行新容器
51
                    sh "docker run -d -p 8081:8080 --name \${CONTAINER_NAME} \${IMAGE_NAME}"
52
                }
53
            }
54
        }
55
    }
56
}

1.4.5.5 jenkins任务配置#

1. 点击 New Item，输入任务名称，选择 Pipeline，点击 OK。
2. General -> 勾选 GitHub project，填入你的项目 URL (https://github.com/你的用户名/jenkins-practice)。

​

3. Build Triggers -> 勾选 GitHub hook trigger for GITScm polling。

   

4. Pipeline -> Definition 选择 Pipeline script from SCM

   • SCM 选择 Git。

   • Repository URL 填入你的 GitHub 仓库地址。

   • (如果需要) Credentials 填入你的 GitHub 账号密码/Token，这里是公共仓库，因此不用

   • Script Path 保持默认的 Jenkinsfile。

   • 分支为main

点击save保存

1.4.5.6 使用jenkins构建#

回到构建页面后，点击立即构建，可以看到在构建中

1.4.5.7 访问网页#

构建成功后，访问网页ip:8081，可以看到已经成功

1.4.5.8 配置webhook#

实现github提交代码后主动发送http请求到jenkins服务器，触发构建

1. 进入你的 GitHub 仓库页面，点击 Settings

2. 左侧菜单点击 Webhooks -> Add webhook。

3. Payload URL: 填写 http://你的服务器IP:8080/github-webhook/

   1. 注意：结尾的斜杠 / 不能少。
   2. 重要：如果你的服务器没有公网 IP（比如是在家里局域网），GitHub 是访问不到你的 Jenkins 的。这种情况下你需要使用 ngrok 做内网穿透，或者暂时手动测试。

4. Content type: 选择 application/json。

   

5. Which events?: 选择 Just the push event。

   

6. 点击 Add webhook。

7. 之后修改代码触发构建

1.4.5.1 maven配置#

默认设置即可

1.4.5.2 jdk安装#

填写别名和路径

路径为具体的jdk安装目录，取消自动安装

1.4.5.3 git安装#

1.4.5.4 maven安装#

如果gradle、ant、docker等工具如果需要，这可以进行配置，本文用不上，则不配置直接配置maven

1.4.6.1 Docker Cloud（动态云节点）#

利用 Docker 容器实现动态 Agent 节点，是目前主流且高效的方案。

1. 安装docker插件#

在插件管理中搜索docker然后安装，安装好以后重启jenkins

2.配置云#

新建云

因为安装docker插件，这里有了docker类型的选项

3. 创建容器与云对接#

1
# 在服务器创建一个容器
2
# 通过 socat 把宿主机的 Docker 守护进程（Unix Socket）暴露成一个 TCP 端口服务
3
docker run -itd \
4
  --restart always \
5
  --publish 127.0.0.1:2376:2375 \
6
  --name alpine \
7
  --volume /var/run/docker.sock:/var/run/docker.sock \
8
  alpine/socat tcp-listen:2375,fork,reuseaddr unix-connect:/var/run/docker.sock
9

10
  # 查看容器的ip地址
11
  docker inspect alpine

将IP地址填入Docker Host URI中

点击测试连接，如果可以显示docker的版本信息和api版本，那么就表示jenkins可以成功链接到docker的守护进程

最后，勾选enable保存确认，完成配置

4. 创建docker agent模板#

添加节点的标签，用于后续流水线文件在哪里进行构建

勾选启动后，填写名称

填写构建时使用的镜像，这里使用官方提供的两个镜像，jenkins/inbound-agent、jenkins/agent

如果不想使用官方的镜像，也可以使用其他镜像或者自己构建镜像

设置实例并发量，这里设置成 2

表示该节点最大执行2个任务，如果有3个任务分配到该节点，那么就会等待前2个完成后再执行第3个任务

最后保存，完成模板配置

5. 使用运行#

创建一个流水线脚本，里面的agent,指定为之前的agent标签，即docker_agent1

1
pipeline {
2
    agent {label 'docker_agent1'}
3

4
    stages {
5
        stage('第一阶段') {
6
            steps {
7
                echo '第一阶段'
8
            }
9
        }
10
        stage('第二阶段') {
11
            steps {
12
                echo '第二阶段'
13
            }
14
        }
15
        stage('第三阶段') {
16
            steps {
17
                echo '第三阶段'
18
            }
19
        }
20
    }
21
}

展开收起

保存后点击立即构建，可以看到运行成功

进入云管理页面查看统计的构建次数

可以看到之前构建的一些历史记录