2024-12-25 运维 +2 devops GitLab CI-CD语法实践 6722 字 33 分钟 -- 次

GitLAB&Jenkins

最后更新于: 2026-06-24 22:08:38

GitLAB & Jenkins

实践：基于Jenkins提交流水线(测试成功)-2023.4.25

目的：掌握通过触发器将GitLab和Jenkins集成，实现提交流水线。

1、触发Jenkins构建

安装`Generic Webhook Trigger`插件

tstmp_20230423061901

重启后，进入一个Pipeline项目设置，已经可以选择这个触发器了….

tstmp_20230423061918

插件文档：https://plugins.jenkins.io/generic-webhook-trigger/

tstmp_20230423061936

Jenkins作业配置触发器

启动Generic Webhook触发器后，相当于给Jenkins加了一个新的接口（http://JENKINS_URL/generic-webhook-trigger/invoke）。

tstmp_20230423064219

调用的时候：这里要把 JENKINS_URL 换成自己真实的Jenkins 服务器地址，有端口就加上端口，是域名就写域名。下面是一个参考的URL：

1http://192.168.1.200:8080/generic-webhook-trigger/invoke

Post content parameters：获取调用接口传进来的数据

JsonPath语法文档： https://github.com/json-path/JsonPath

tstmp_20230423064424

Header parameters：获取Header中的参数

tstmp_20230423064526

tstmp_20230423064534

Request parameters：获取URL中的请求参数

1curl http://192.168.1.200:8080/generic-webhook-trigger/invoke?runopts=gitlab

tstmp_20230423064602

Token: 给URL添加一个触发的认证

1curl http://192.168.1.200:8080/generic-webhook-trigger/invoke?token=devops-service

tstmp_20230423064625

打印调试信息到日志中

tstmp_20230423064647

触发条件过滤：仅满足条件才能触发此作业

tstmp_20230423064709

创建测试项目

创建一个叫做devops-demo-service的jenkins作业（这里的作业名称和gitlab里的项目名称推荐保持一致）

要加一个唯一的token，不然会触发所有token一样的项目

把这2个选项勾选上

此时在postman里测试触发

触发url http://172.29.9.101:8080/generic-webhook-trigger/invoke?token=devops-demo-service

这里记得要加一个basic auth：

可以看到触发成功了。

演示将postman中的请求转换curl方式。

1curl --location --request POST 'http://172.29.9.101:8080/generic-webhook-trigger/invoke?token=devops-demo-service' \
2--header 'Authorization: Basic YWRtaW46YWRtaW4='

可以看到，也是能构建成功的。

解析GET/POST请求数据

传参注意，第一个参数使用?号连接，后面的参数使用&符号连接。

1?token=demo-pipeline-service&user=jenkins&a=1&b=2

解析GET数据

客户端发送Get请求，带有两个参数 version 和 username 。

1http://172.29.9.101:8080/generic-webhook-trigger/invoke?token=devops-demo-service&version=1.1.1&username=jenkins

Jenkins 配置Generic hook，获取请求参数version 和 username （参数名称要一致）

tstmp_20230423065144

验证测试（Jenkins日志中能够打印出获取的值，则正常）

哎，这里怎么没显示一些变量呢？？

这里简单写一个pipeline把。

可以看到效果了。

通过jenkinsfile读取传递的参数，再次触发

 1currentBuild.displayName = "${version}"
 2
 3println("${version}")
 4println("${username}")
 5
 6pipeline {
 7    agent any
 8
 9    stages {
10        stage('Hello') {
11            steps {
12                echo 'Hello World'
13            }
14        }
15    }
16}

再次postman触发，观察效果：（符合预期）

客户端发送请求（什么请求都可以，这里的header与请求类型无关），带有两个参数 devops和 tool-name。

Jenkins 配置Generic hook，获取请求参数devops和 tool-name 。

通过jenkinsfile读取传递的参数

注意，这里的pipeline代码如果打印tool-name变量的话，会报错的

这里要使用下划线来替换横杠：

再次触发，就正常了，符合预期。

解析POST数据

客户端发送POST请求，参数存储在body体中（参考POSTMAN中的样例）

Jenkins 配置触发器来获取Post参数。

删除之前测试的header参数，request参数。

$代表/，获取所有数据

获取name字段

Jenkinsfile中使用参数

触发：

验证：

扩展流水线解析JSON数据

安装插件： Pipeline Utility Steps

readJSON：处理json数据

 1currentBuild.displayName = "${name}"
 2
 3println("${Data}")
 4
 5NewData = readJSON text: "${Data}"
 6envName = NewData["envName"]
 7appsName = NewData["apps"]["name"]
 8
 9
10pipeline {
11    agent any
12
13    stages {
14        stage('Hello') {
15            steps {
16                script {
17                    println("${envName}")
18                    println("${appsName}")
19                }
20                    
21                
22            }
23        }
24    }
25}

再次构建：

验证：（符合预期）

`Rebuilder`插件使用

可以直接携带原触发参数进行触发，不用重复触发（不用在重复的提交代码了）。

tstmp_20230423071021

进入某一次构建后，可以点击rebuild。

tstmp_20230423071045

2、获取触发参数

1.触发器配置

Jenkins开启trigger

目的：开启trigger后，就可以实现其他系统通过一个指定的URL进行自动触发构建了；

新建一个文件夹存放对应GitLab仓库组中的流水线。这里建议用仓库组的名称作为文件夹的名称devops03;

用Gitlab项目名称与流水线命名； devops03-demo-service项目;

tstmp_20230423210432

tstmp_20230423210444

开启Generic webhook；
配置触发Token，例如：作业名称devops03-demo-service （这个token是流水线触发需要传递的）;
生成的触发URL；

tstmp_20230423210537

1http://192.168.1.200:8080/generic-webhook-trigger/invoke?token=devops03-demo-service

（此时，已经生成了触发URL，接着可以使用Curl或者Postman进行触发测试了！）

自己本次的这部分配置已经配置完成了。

这里还原下，删除之前的变量，这里只保留Data。

修改下pipeline代码

 1println("${Data}")
 2
 3NewData = readJSON text: "${Data}"
 4// envName = NewData["envName"]
 5// appsName = NewData["apps"]["name"]
 6println("${NewData}")
 7
 8
 9pipeline {
10    agent any
11
12    stages {
13        stage('Hello') {
14            steps {
15                script {
16                    println("${NewData}")
17                }
18                    
19                
20            }
21        }
22    }
23}

配置GitLab WebHook

进入GitLab项目设置，进入 webhook配置页面;

配置要触发的URL，即Jenkins触发器接口URL；
选择发生哪种GitLab事件后触发此Webhook；例如：Push提交代码、Tag创建标签等等；
在gitlab的项目里配置好webhook

http://172.29.9.101:8080/generic-webhook-trigger/invoke?token=devops-demo-service

事件：

Push 提交事件
Tag Push 创建事件
MergeRequest 合并事件
Issue 问题创建更新事件
测试模拟触发

模拟事件触发，点击test按钮选择push事件，此时去看下Jenkins是否成功被触发。

这里稍微测试下：

点击Test

触发成功则提示： Hook executed successfully: HTTP 200，此时可以看下Jenkins是否已经触发了一次构建；

Webhook问题排查调试

进入webhook添加页面的最下方，点击你所创建的webhook的 Edit按钮 ;

webhook历史记录: 此记录可以判断，当前动作提交是否产生了webhook。

点击 View details 可以看到此webhook发送给对端Jenkins的数据信息，和请求状态。

200：表示触发Jenkins请求成功；
Resend Request: 重新发送请求；（此处便于排查调试错误）
RequestBody： GitLab传递给Jenkins的数据信息；

假如请求由于xxx原因导致没有触发jenkins构建，可以在这里点击 Resend Request 按钮进行重新发送请求，而不是再次提交代码。

如果Jenkins触发成功了之后，我们可以在Jenkins的构建日志中查看效果。这些数据就是gitlab post传递过来的。

到此：你基本上已经知道了Gitlab如何触发Jenkins的了。（多看几遍，多练习几遍）

2.提交流水线优化

过滤新建分支和tag的触发

你可能发现问题了，新建一个分支或者标签也会出现构建，这个构建是没有意义的。我们需要排除掉。没错，jenkins 的 Generic webHook 也是支持的。

参考官方的说明:https://github.com/jenkinsci/generic-webhook-trigger-plugin/blob/master/src/test/resources/org/jenkinsci/plugins/gwt/bdd/gitlab/gitlab-push-ignore-create-remove-branch.feature

tstmp_20230424064510

添加三个变量，获取当前的提交信息 $object_kind $before $after

（此步骤一定要注意下参数名和值后面的空格，要去掉）

tstmp_20230424064538

通过正则表达式配置触发条件：Expression ^push\s(?!0{40}).{40}\s(?!0{40}).{40}$ Text $object_kind $before $after。 push请求只有after和before的值都不是40个0的时候触发构建（为40个0的情况是删除分支或者新建分支）

tstmp_20230424064614

本次测试过程：

我们在gitlab上新创建一个分支

可以看到，gitlab上新创建一个分支后，就会触发jenkins流水线，这不是我们所期望的，因此下面将进一步优化。

在jenlins侧如何过滤出一些构建：

before如果是40个0的话，那么可能是创建分支；

after如果是40个0的话，那么可能是合并分支；

这里先编辑jenkins上流水线的触发过滤条件

tstmp_20230424065530

\s是空格

tstmp_20230424065601

配置完成后，保存。

gitlab上再新建分支，观察是否会触发jenkins？

可以看到gitlab上已经成功触发了，但是被jenkins过滤掉了，符合预期。😘

如何支持多个分支触发构建？

方法1：创建多个gitlab webhook，设置不同的分支，最终指向同一个jenkins 作业；

tstmp_20230424070102

方法2：过滤

gitlab上设置，只允许feature开头的分支才可以进行触发：

编辑gitlab上的webhook配置：

3、自动触发Pipeline

这里写下代码

获取项目地址：

获取分支名：

下载代码：

利用片段生成器生成代码：

创建gitlab-root凭据：

生成代码：

1checkout([$class: 'GitSCM', branches: [[name: 'main']], extensions: [], userRemoteConfigs: [[credentialsId: 'gitlab-root', url: 'srcUrl']]])

继续编写代码：

 1println("${Data}")
 2
 3NewData = readJSON text: "${Data}"
 4// envName = NewData["envName"]
 5// appsName = NewData["apps"]["name"]
 6println("${NewData}")
 7
 8// Get git repo url 项目地址
 9srcUrl = NewData["project"]["git_http_url"]
10
11// Get git repo branch
12branchName = NewData["ref"] - "refs/heads/"
13
14// current build desc
15currentBuild.displayName = "${branchName}"
16currentBuild.description = "src: ${srcUrl}"
17
18pipeline {
19    agent any
20
21    stages {
22        stage('CheckOut') {
23            steps {
24                script {
25                    println("Checkout: ${srcUrl} ${branchName}")
26                    checkout([$class: 'GitSCM', 
27                        branches: [[name: "${branchName}"]], 
28                        extensions: [], 
29                        userRemoteConfigs: [[credentialsId: 'gitlab-root', url: "${srcUrl}"]]])
30                    sh 'ls -l'
31                }
32                    
33                
34            }
35        }
36    }
37}

将写好的代码保存到jekins里。

在gitlab任意分支做个提交：

我们先拉取下代码：

在feature-dev-01编辑README.md文件并推送。

 1Win@DESKTOP-VUMV922 MINGW64 ~/Desktop/demo (feature-dev-01)
 2$ cat README.md
 3情出自愿-事过无悔
 4
 5Win@DESKTOP-VUMV922 MINGW64 ~/Desktop/demo (feature-dev-01)
 6$ echo 佳 >> README.md
 7
 8Win@DESKTOP-VUMV922 MINGW64 ~/Desktop/demo (feature-dev-01)
 9$ git add .
10warning: in the working copy of 'README.md', LF will be replaced by CRLF the next time Git touches it
11
12Win@DESKTOP-VUMV922 MINGW64 ~/Desktop/demo (feature-dev-01)
13$ git commit -m "佳"
14[feature-dev-01 683b378] 佳
15 1 file changed, 1 insertion(+)
16
17Win@DESKTOP-VUMV922 MINGW64 ~/Desktop/demo (feature-dev-01)
18$ git push origin feature-dev-01
19Enumerating objects: 5, done.
20Counting objects: 100% (5/5), done.
21Delta compression using up to 8 threads
22Compressing objects: 100% (2/2), done.
23Writing objects: 100% (3/3), 287 bytes | 287.00 KiB/s, done.
24Total 3 (delta 1), reused 0 (delta 0), pack-reused 0
25remote:
26remote: To create a merge request for feature-dev-01, visit:
27remote:   http://172.29.9.101:8076/devops6/devops-demo-service/-/merge_requests/new?merge_request%5Bsource_branch%5D=feature-dev-01
28remote:
29To http://172.29.9.101:8076/devops6/devops-demo-service.git
30   7cf5639..683b378  feature-dev-01 -> feature-dev-01
31
32Win@DESKTOP-VUMV922 MINGW64 ~/Desktop/demo (feature-dev-01)
33$

此时可以看到jenkins里的流水线被触发了

这里再在新建一个分支，用于测试，看是否会触发jebnkins流水线

 1Win@DESKTOP-VUMV922 MINGW64 ~/Desktop/demo (feature-dev-01)
 2$ git checkout -b feature-003
 3Switched to a new branch 'feature-003'
 4
 5Win@DESKTOP-VUMV922 MINGW64 ~/Desktop/demo (feature-003)
 6$ ls
 7HELP.md  README.md  mvnw*  mvnw.cmd  pom.xml  src/
 8
 9Win@DESKTOP-VUMV922 MINGW64 ~/Desktop/demo (feature-003)
10$ echo "i am very hurt" > README.md
11
12Win@DESKTOP-VUMV922 MINGW64 ~/Desktop/demo (feature-003)
13$ git add .
14warning: in the working copy of 'README.md', LF will be replaced by CRLF the next time Git touches it
15
16Win@DESKTOP-VUMV922 MINGW64 ~/Desktop/demo (feature-003)
17$ git commit -m "hurt"
18[feature-003 1de466b] hurt
19 1 file changed, 1 insertion(+), 2 deletions(-)
20
21Win@DESKTOP-VUMV922 MINGW64 ~/Desktop/demo (feature-003)
22$ git push origin feature-003
23Enumerating objects: 5, done.
24Counting objects: 100% (5/5), done.
25Delta compression using up to 8 threads
26Compressing objects: 100% (2/2), done.
27Writing objects: 100% (3/3), 262 bytes | 262.00 KiB/s, done.
28Total 3 (delta 1), reused 0 (delta 0), pack-reused 0
29remote:
30remote: To create a merge request for feature-003, visit:
31remote:   http://172.29.9.101:8076/devops6/devops-demo-service/-/merge_requests/new?merge_request%5Bsource_branch%5D=feature-003
32remote:
33To http://172.29.9.101:8076/devops6/devops-demo-service.git
34 * [new branch]      feature-003 -> feature-003
35
36Win@DESKTOP-VUMV922 MINGW64 ~/Desktop/demo (feature-003)
37$

可以看到，jenkins流水线被触发了。

🍀 之前代码

tstmp_20230424073517

 1webhookData = readJSON text: "${webhook_data}"
 2
 3
 4//分支名称
 5env.branchName = webhookData["ref"] - "refs/heads/"
 6env.projectUrl = webhookData["project"]["git_http_url"]
 7env.userEmail = webhookData["user_email"]
 8
 9//修改描述信息
10currentBuild.description = "BranchName: ${env.branchName}"
11currentBuild.displayName = "${env.branchName}"
12
13
14pipeline {
15    agent { label "build01"}
16
17    stages {
18        stage('Checkout') {
19            steps {
20                script{
21
22                    //checkout 
23                    checkout([$class: 'GitSCM', 
24                              branches: [[name: "${env.branchName}"]], 
25                              extensions: [], 
26                              userRemoteConfigs: [[
27                                  credentialsId: 'd7e4e500-e5c6-4673-ae4b-d43bf4ff5d19', 
28                                  url: "${env.projectUrl}"]]])
29
30                }
31            }
32        }
33
34
35        stage('Build'){
36            steps{
37                script{
38                    sh "mvn clean package -DskipTests"
39                }
40            }
41        }
42
43
44        stage('test'){
45            steps{
46                script{
47                    sh "mvn test"
48                }
49            }
50        }
51    }
52
53    post {
54        always{
55            script{
56                EmailUser("${env.userEmail}",currentBuild.currentResult)
57            }
58        }
59    }
60}
61
62
63def EmailUser(userEmail,status){
64    emailext body: """
65            <!DOCTYPE html> 
66            <html> 
67            <head> 
68            <meta charset="UTF-8"> 
69            </head> 
70            <body leftmargin="8" marginwidth="0" topmargin="8" marginheight="4" offset="0"> 
71                <img src="http://192.168.1.200:8080/static/0eef74bf/images/headshot.avif">
72                <table width="95%" cellpadding="0" cellspacing="0" style="font-size: 11pt; font-family: Tahoma, Arial, Helvetica, sans-serif">   
73                    <tr> 
74                        <td><br /> 
75                            <b><font color="#0B610B">构建信息</font></b> 
76                        </td> 
77                    </tr> 
78                    <tr> 
79                        <td> 
80                            <ul> 
81                                <li>项目名称：${JOB_NAME}</li>         
82                                <li>构建编号：${BUILD_ID}</li> 
83                                <li>构建状态: ${status} </li>                         
84                                <li>项目地址：<a href="${BUILD_URL}">${BUILD_URL}</a></li>    
85                                <li>构建日志：<a href="${BUILD_URL}console">${BUILD_URL}console</a></li> 
86                            </ul> 
87                        </td> 
88                    </tr> 
89                    <tr>  
90                </table> 
91            </body> 
92            </html>  """,
93            subject: "Jenkins-${JOB_NAME}项目构建信息 ",
94            to: userEmail
95
96}

进一步更新代码

此时，想要commitId的前8位该如何取呢？

这样处理就好：

 1println("${Data}")
 2
 3NewData = readJSON text: "${Data}"
 4// envName = NewData["envName"]
 5// appsName = NewData["apps"]["name"]
 6println("${NewData}")
 7
 8// Get git repo url 项目地址
 9srcUrl = NewData["project"]["git_http_url"]
10
11// Get git repo branch
12branchName = NewData["ref"] - "refs/heads/"
13
14// Get short commit id 想要commitId的前8位
15env.commitId = NewData["checkout_sha"][0..7]
16
17// current build desc
18currentBuild.displayName = "${branchName}：${env.commitId}"
19currentBuild.description = "src: ${srcUrl}"
20
21
22pipeline {
23    agent any
24
25    stages {
26        stage('CheckOut') {
27            steps {
28                script {
29                    println("Checkout: ${srcUrl} ${branchName}")
30                    checkout([$class: 'GitSCM', 
31                        branches: [[name: "${branchName}"]], 
32                        extensions: [], 
33                        userRemoteConfigs: [[credentialsId: 'gitlab-root', url: "${srcUrl}"]]])
34                    sh 'ls -l'
35                }
36                    
37                
38            }
39        }
40    }
41}

触发测试：（符合预期）

4、手动触发流水线

很简单的，就是在jenkins项目里添加一些选项参数，把这些变量写死在选项参数里就好。
自动触发和手动触发的可以并存的，例如写一些If ……else，但是不推荐。
手动触发：例如有一些版本分支，这些分支名是会变的，因此不是很方便；但是如果不想每次提交都触发流水线，而是等到一个小版本后再触发，这个用手动触发也是可以的哦。

tstmp_20230424073934

 1
 2//修改描述信息
 3currentBuild.description = "BranchName: ${env.branchName}"
 4currentBuild.displayName = "${env.branchName}"
 5
 6
 7pipeline {
 8    agent { label "build01"}
 9
10    stages {
11        stage('Checkout') {
12            steps {
13                script{
14
15                    //checkout 
16                    checkout([$class: 'GitSCM', 
17                              branches: [[name: "${env.branchName}"]], 
18                              extensions: [], 
19                              userRemoteConfigs: [[
20                                  credentialsId: 'd7e4e500-e5c6-4673-ae4b-d43bf4ff5d19', 
21                                  url: "${env.projectUrl}"]]])
22
23                }
24            }
25        }
26
27
28        stage('Build'){
29            steps{
30                script{
31                    sh "mvn clean package -DskipTests"
32                }
33            }
34        }
35
36
37        stage('test'){
38            steps{
39                script{
40                    sh "mvn test"
41                }
42            }
43        }
44    }
45}

这里做下测试：

jenkins上创建项目gitlab-jenkins-service-manual，配置好选项参数。

编写pipeline代码

 1//修改描述信息
 2currentBuild.description = "BranchName: ${env.branchName}"
 3currentBuild.displayName = "${env.branchName}"
 4
 5
 6pipeline {
 7    agent { label "build01"}
 8
 9    stages {
10        stage('CheckOut') {
11            steps {
12                script {
13                    println("Checkout: ${projectUrl} ${branchName}")
14                    checkout([$class: 'GitSCM', 
15                        branches: [[name: "${branchName}"]], 
16                        extensions: [], 
17                        userRemoteConfigs: [[credentialsId: 'gitlab-root', url: "${projectUrl}"]]])
18                    sh 'ls -l'
19                }
20                    
21                
22            }
23        }        
24
25
26        stage('Build'){
27            steps{
28                script{
29                    println("mvn clean package -DskipTests") 
30                }
31            }
32        }
33
34
35        stage('test'){
36            steps{
37                script{
38                    println("mvn test")
39                }
40            }
41        }
42    }
43}

准备好一个gitlab项目就好。

测试（符合预期）

5、Jenkins消息通知

添加邮箱

邮箱是标配吧。（钉钉机器人也是可以的）

默认情况可能每个Gitlab用户没有配置邮箱的，需要Gitlab用户要配置好邮箱。

点击头像进入 edit profile

tstmp_20230424123355

添加自己邮箱：

这里需要登录到自己的邮箱去确认下：

方法1：或者按如下方式直接配置好自己的gitlab邮箱为qq邮箱：（强制更改） 本次是强制更改的。

点击Edit：

这里配置好自己的邮箱，点击保存：

可以看到这里的邮箱被确认了：

方法2：在自己的邮箱里确认。

奇怪，我这里怎么163、qq邮箱都收不到确认邮件呢？？😥

经过百度，发现是在gitlab里的配置文件要做下配置的：

 1[root@devops ~]#docker ps
 2CONTAINER ID   IMAGE                                  COMMAND                  CREATED       STATUS                  PORTS                                                                                      NAMES
 311a54a1f4a2a   gitlab/gitlab-ce:14.9.3-ce.0           "/assets/wrapper"        6 days ago    Up 28 hours (healthy)   0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp, 0.0.0.0:2222->22/tcp                             devops_tutorial_gitlab
 4f3f039aa667a   jenkins/jenkins:2.332.2-centos7-jdk8   "/sbin/tini -- /usr/…"   4 weeks ago   Up 24 hours             0.0.0.0:8080->8080/tcp, :::8080->8080/tcp, 0.0.0.0:50000->50000/tcp, :::50000->50000/tcp   jenkins
 5[root@devops ~]#docker exec -it devops_tutorial_gitlab bash
 6root@11a54a1f4a2a:/# vi /etc/gitlab/gitlab.rb
 7#搜索smtp
 8gitlab_rails['smtp_enable'] = true
 9gitlab_rails['smtp_address'] = "smtp.163.com"
10gitlab_rails['smtp_port'] = 465
11gitlab_rails['smtp_user_name'] = "onexlforyou@163.com"
12gitlab_rails['smtp_password'] = "NVSMOUfffAxxxccEMXAB"
13gitlab_rails['smtp_domain'] = "163.com"
14gitlab_rails['smtp_authentication'] = "login"
15gitlab_rails['smtp_enable_starttls_auto'] = true
16gitlab_rails['smtp_tls'] = true
17gitlab_rails['gitlab_email_from'] = 'onexlforyou@163.com'
18
19root@11a54a1f4a2a:/# gitlab-ctl reconfigure

此时，发下就可以正常识别到自己的邮箱了：

参考链接：

http://t.zoukankan.com/zgz345-p-9122146.html

在这个页面配置好邮箱地址，最好这几个email都配置上吧……最后

这里在gitlab上提交一次代码，确认post请求里的数据体是否含user_email信息

可以看到，这里的user_email数据是有了。

安装`Email Extension`插件

Jenkins需要配置邮件通知，安装插件Email Extension安装后重启Jenkins。

tstmp_20230424205619

然后进入系统管理-> 系统设置 ，先配置下全局的admin的邮箱地址。（最后配置下不然可能会出错的）

拿到邮箱授权码

登入邮箱拿到授权码

tstmp_20230424210549

1zpnchpffffvnffeqwhgecef

发送短信之后获取授权码

tstmp_20230424210610

配置`Email Extension`

->Extended E-email Notification。设置邮件系统配置信息。

这里我使用的是QQ邮箱，填写SMTP服务器地址smtp.qq.com 和端口 465注意要开启SSL，密码为授权码。

这里写下自己的qq的授权码凭证：

换个选项注意下：不选择 HTML 就是普通的文本， HTML 可以支持html网页，更加美观。这里选择 HTML

编写代码

pipeline as code , 进入片段生成器，生成邮件通知代码。

tstmp_20230424211508

1emailext body: 'hello world!....jenkins', subject: 'test.....', to: '2560350642@qq.com'

然后我们将此段代码加入到Jenkins pipeline 中运行，可以看到效果：

tstmp_20230424211545

jenkins as code 将email 写成一个函数。这个通知信息是一个html格式的。

 1
 2def EmailUser(userEmail,status){
 3 	emailext body: """
 4            <!DOCTYPE html> 
 5            <html> 
 6            <head> 
 7            <meta charset="UTF-8"> 
 8            </head> 
 9            <body leftmargin="8" marginwidth="0" topmargin="8" marginheight="4" offset="0"> 
10                <img src="http://192.168.1.200:8080/static/0eef74bf/images/headshot.avif">
11                <table width="95%" cellpadding="0" cellspacing="0" style="font-size: 11pt; font-family: Tahoma, Arial, Helvetica, sans-serif">   
12                    <tr> 
13                        <td><br /> 
14                            <b><font color="#0B610B">构建信息</font></b> 
15                        </td> 
16                    </tr> 
17                    <tr> 
18                        <td> 
19                            <ul> 
20                                <li>项目名称：${JOB_NAME}</li>         
21                                <li>构建编号：${BUILD_ID}</li> 
22                                <li>构建状态: ${status} </li>                         
23                                <li>项目地址：<a href="${BUILD_URL}">${BUILD_URL}</a></li>    
24                                <li>构建日志：<a href="${BUILD_URL}console">${BUILD_URL}console</a></li> 
25                            </ul> 
26                        </td> 
27                    </tr> 
28                    <tr>  
29                </table> 
30            </body> 
31            </html>  """,
32            subject: "Jenkins-${JOB_NAME}项目构建信息 ",
33            to: userEmail
34
35}

这里继续编写下代码

 1println("${Data}")
 2
 3NewData = readJSON text: "${Data}"
 4// envName = NewData["envName"]
 5// appsName = NewData["apps"]["name"]
 6println("${NewData}")
 7
 8// Get git repo url 项目地址
 9srcUrl = NewData["project"]["git_http_url"]
10
11// Get git repo branch
12branchName = NewData["ref"] - "refs/heads/"
13
14// Get git user email
15userEmail = NewData["user_email"]
16
17// current build desc
18currentBuild.displayName = "${branchName}"
19currentBuild.description = "src: ${srcUrl}"
20
21pipeline {
22    agent any
23
24    stages {
25        stage('CheckOut') {
26            steps {
27                script {
28                    println("Checkout: ${srcUrl} ${branchName}")
29                    checkout([$class: 'GitSCM', 
30                        branches: [[name: "${branchName}"]], 
31                        extensions: [], 
32                        userRemoteConfigs: [[credentialsId: 'gitlab-root', url: "${srcUrl}"]]])
33                    sh 'ls -l'
34                }
35                    
36                
37            }
38        }
39
40    }
41
42    post {
43        always{
44            script{
45                EmailUser(userEmail,"${currentBuild.currentResult}")
46            }
47        }
48    }
49
50}
51
52
53
54def EmailUser(userEmail,status){
55 	emailext body: """
56            <!DOCTYPE html> 
57            <html> 
58            <head> 
59            <meta charset="UTF-8"> 
60            </head> 
61            <body leftmargin="8" marginwidth="0" topmargin="8" marginheight="4" offset="0"> 
62                <img src="http://192.168.1.200:8080/static/0eef74bf/images/headshot.avif">
63                <table width="95%" cellpadding="0" cellspacing="0" style="font-size: 11pt; font-family: Tahoma, Arial, Helvetica, sans-serif">   
64                    <tr> 
65                        <td><br /> 
66                            <b><font color="#0B610B">构建信息</font></b> 
67                        </td> 
68                    </tr> 
69                    <tr> 
70                        <td> 
71                            <ul> 
72                                <li>项目名称：${JOB_NAME}</li>         
73                                <li>构建编号：${BUILD_ID}</li> 
74                                <li>构建状态: ${status} </li>                         
75                                <li>项目地址：<a href="${BUILD_URL}">${BUILD_URL}</a></li>    
76                                <li>构建日志：<a href="${BUILD_URL}console">${BUILD_URL}console</a></li> 
77                            </ul> 
78                        </td> 
79                    </tr> 
80                    <tr>  
81                </table> 
82            </body> 
83            </html>  """,
84            subject: "Jenkins-${JOB_NAME}项目构建信息 ",
85            to: userEmail
86
87}

触发测试

提交下代码，触发下

自己的测试现象（符合预期）

解决默认图片显示异常问题

可以看到这里的人图片显示异常，这里我们使用oss路径来存储图片就可以了。

本次最新代码(测试成功)

  1//打印jenkins的Generic Webhook Trigger接收到的数据，默认为字符串
  2println("${Data}")
  3
  4//格式化webhook接收的数据为json格式
  5NewData = readJSON text: "${Data}" //$表示全量数据
  6// envName = NewData["envName"]
  7// appsName = NewData["apps"]["name"]
  8println("${NewData}")
  9
 10// Get git repo url 项目地址
 11srcUrl = NewData["project"]["git_http_url"]
 12
 13// Get git repo branch 提交分支
 14branchName = NewData["ref"] - "refs/heads/"
 15
 16// Get git user email 
 17userEmail = NewData["user_email"]
 18 
 19// Get short commit id 想要commitId的前8位 commit ID
 20env.commitId = NewData["checkout_sha"][0..7]
 21//env.commitId = NewData["checkout_sha"] 
 22
 23// 提交人
 24env.commitUser = NewData["user_username"]  
 25
 26//这里为什么要使用env.定义变量呢？ 因为全局变量保险些，便于后面所有阶段间的引用；
 27
 28// current build desc
 29currentBuild.displayName = "${branchName}：${env.commitId}"
 30currentBuild.description = "src: ${srcUrl}"
 31
 32pipeline {
 33    agent any
 34
 35    stages {
 36        stage('CheckOut') {
 37            steps {
 38                script {
 39                    println("Checkout: ${srcUrl} ${branchName}")
 40                    checkout([$class: 'GitSCM', 
 41                        branches: [[name: "${branchName}"]], 
 42                        extensions: [], 
 43                        userRemoteConfigs: [[credentialsId: 'gitlab-root', url: "${srcUrl}"]]])
 44                    sh 'ls -l'
 45                }
 46                    
 47                
 48            }
 49        }
 50
 51        // 代码构建
 52        stage("Build"){
 53            steps{
 54                script{
 55                    echo "build"
 56                }
 57            }
 58        }
 59
 60        //单元测试
 61        stage("UnitTest"){
 62            steps{
 63                script{
 64                    echo "unit test"
 65                }
 66            }
 67        }
 68
 69        //部署
 70        stage("deploy"){
 71            steps {
 72                script{
 73                    echo "deploy"
 74                }
 75            }
 76        }
 77
 78
 79    }
 80
 81    post {
 82        always{
 83            script{
 84                EmailUser(userEmail,"${currentBuild.currentResult}")
 85            }
 86        }
 87    }
 88
 89}
 90
 91
 92
 93def EmailUser(userEmail,status){
 94 	emailext body: """
 95            <!DOCTYPE html> 
 96            <html> 
 97            <head> 
 98            <meta charset="UTF-8"> 
 99            </head> 
100            <body leftmargin="8" marginwidth="0" topmargin="8" marginheight="4" offset="0"> 
101                <img src="https://s1.ax1x.com/2023/04/25/p9usju8.jpg">
102                <table width="95%" cellpadding="0" cellspacing="0" style="font-size: 11pt; font-family: Tahoma, Arial, Helvetica, sans-serif">   
103                    <tr> 
104                        <td><br /> 
105                            <b><font color="#0B610B">构建信息</font></b> 
106                        </td> 
107                    </tr> 
108                    <tr> 
109                        <td> 
110                            <ul> 
111                                <li>项目名称：${JOB_NAME}</li>         
112                                <li>构建编号：${BUILD_ID}</li> 
113                                <li>构建状态: ${status} </li>                         
114                                <li>项目地址：<a href="${BUILD_URL}">${BUILD_URL}</a></li>    
115                                <li>构建日志：<a href="${BUILD_URL}console">${BUILD_URL}console</a></li> 
116                            </ul> 
117                        </td> 
118                    </tr> 
119                    <tr>  
120                </table> 
121            </body> 
122            </html>  """,
123            subject: "Jenkins-${JOB_NAME}项目构建信息 ",
124            to: userEmail
125
126}