🍁 作者：微枫Micromaple

💒 主页：欢迎关注Micromaple

📌 简介：Java程序员、后端全栈工程师

🔗 点赞👍➕收藏⭐➕留言📝 您的支持就是我前进的动力💪💪💪

一、Jenkins

Jenkins是一个用Java编写的开源的持续集成工具，Jenkins提供了软件开发的持续集成服务。

1、创建目标文件夹

$ cd /usr/local
$ mkdir docker
$ cd docker
$ mkdir jenkins
$ cd jenkins
$ vi docker-compose.yml

2、创建docker-compose.yml

内容如下：

version: '3.1'
services:
  jenkins:
    restart: always
    image: jenkins/jenkins
    container_name: jenkins
    ports:
      # 发布端口
      - 8080:8080
      # 基于 JNLP 的 Jenkins 代理通过 TCP 端口 50000 与 Jenkins master 进行通信
      - 50000:50000
    environment:
      TZ: Asia/Shanghai
    volumes:
      - ./data:/var/jenkins_home

安装过程中会出现数据卷目录权限问题，用以下命令解决：

chown -R 1000 /usr/local/docker/jenkins/data

3、启动容器

docker-compose up -d

启动完成后访问：http://ip:8080。

4、解锁 Jenkins

Jenkins 第一次启动时需要输入一个初始密码用以解锁安装流程，使用 docker logs jenkins 即可方便的查看到初始密码。也可以根据提示在容器中查看/var/jenkins_home/secrets/initialAdminPassword文件。

docker logs -f jenkins

*************************************************************
*************************************************************
*************************************************************

Jenkins initial setup is required. An admin user has been created and a password generated.
Please use the following password to proceed to installation:

67b9966bc4334a17ad7a7daef043bac8

This may also be found at: /var/jenkins_home/secrets/initialAdminPassword

*************************************************************
*************************************************************
*************************************************************

5、插件安装

插件是 Jenkins的核心，其丰富的插件可以满足不同人群的不同需求。

Jenkins 官网插件地址：https://plugins.jenkins.io/

输入初始密码后，选择自选方式安装插件。

注意：除了默认勾选的插件外，一定要勾选 Publish over SSH 插件，这是我们实现持续交付的重点插件。

点击安装后，根据网络情况，安装时间不一样，耐性等待即可。

出现部分插件安装失败时，点击重试按钮，多次重试，如果还是无法安装，记住这些插件的名字，稍后可以手动安装。

6、安装成功效果图

6.1、创建管理员账号

6.2、进入首页

7、Jenkins手动安装插件

• 如下例子为安装中文插件

• Manage Jenkins -> Manage Plugins -> Avaliable

• 右上角搜索框查找想要安装的插件，选中，点击Download now and install after restart。

• 下载好后，重启Jenkins。

  docker-compose down
  docker-compose up -d
  

8、配置 JDK & Maven

• 上传 JDK 和 Maven 的 tar 包到服务器（容器数据卷目录），进行解压缩。

• Manage Jenkins -> Global Tool Configuration（系统管理->全局工具配置）。

• 安装 JDK

  /var/jenkins_home/jdk1.8.0_152
  

• 安装Maven

• 点击保存

9、安装动态参数插件

该插件的主要目的是为了方便我们后面在做项目构建时可以按照版本进行构建（支持一键回滚）

• Manage Jenkins -> Manage Plugins -> Avaliable

• 搜索 Extended Choice Parameter

• 点击Download now and install after restart。

10、配置 Jenkins 的 GitLab SSH 免密登录

• 交互式进入 Jenkins 容器

  docker exec -it jenkins /bin/bash
  

• 生成 SSH KEY

  ssh-keygen -t rsa -C "your_email@example.com"
  

• 查看公钥

  cat /var/jenkins_home/.ssh/id_rsa.pub
  

• 复制公钥到 GitLab

• 手动克隆一次项目，该步骤的主要作用是为了生成和服务器的验证信息

  jenkins@730898bc8b96:~$ git clone ssh://git@192.168.50.131:2222/test/test.git
  Cloning into 'test'...
  The authenticity of host '[192.168.50.131]:2222 ([192.168.50.131]:2222)' can't be established.
  ECDSA key fingerprint is SHA256:x21ujjNoJ+7wXGszSI7s70szbK0/+7mTOeDP5h0saMs.
  Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
  Warning: Permanently added '[192.168.50.131]:2222' (ECDSA) to the list of known hosts.
  remote: Counting objects: 3, done.
  remote: Total 3 (delta 0), reused 0 (delta 0)
  Receiving objects: 100% (3/3), done.
  jenkins@730898bc8b96:~$ 
  

• 查看生成文件

  jenkins@730898bc8b96:~$ cd .ssh/
  jenkins@730898bc8b96:~/.ssh$ ls -al
  total 20
  drwx------  2 jenkins jenkins 4096 Apr  9 19:03 .
  drwxr-xr-x 16 jenkins root    4096 Apr  9 19:03 ..
  -rw-------  1 jenkins jenkins 2602 Apr  9 18:57 id_rsa
  -rw-r--r--  1 jenkins jenkins  572 Apr  9 18:57 id_rsa.pub
  -rw-r--r--  1 jenkins jenkins  222 Apr  9 19:03 known_hosts
  jenkins@730898bc8b96:~/.ssh$ 
  

10.1、配置 Publish over SSH

• 系统管理 -> 系统设置 -> Publish over SSH

• 点击新增，其中 Remote Directory 是指 Jenkins 可以在目标服务器操作的目录，选择 Use password, 输入目标服务器密码

• 测试能否正常通信

• 点击保存

11、持续交付 Maven 项目

11.1、为项目创建标签

在 GitLab 中为项目创建标签

11.2、在 Jenkins 中创建 Maven Project

在 Jenkins 中创建一个基于 Maven 的任务

这里没有Maven 项目选项，需要安装插件 Maven Integration 、Pipeline Maven Integration

11.3、配置第一次构建

11.3.1、构建项目

11.3.2、查看构建日志

11.4、配置正式构建

11.4.1、增加参数化构建过程

这里使用了 Groovy 脚本来查询最近的 tags 版本，代码如下：

def ver_keys = [ 'bash', '-c', 'cd /var/jenkins_home/workspace/myshop-dependencies;git pull>/dev/null; git remote prune origin >/dev/null; git tag -l|sort -r |head -10 ' ]
ver_keys.execute().text.tokenize('\n')

11.4.2、关闭源码管理

11.4.3、增加构建步骤

shell 脚本代码如下：

echo $RELEASE_VERSION
cd /var/jenkins_home/workspace/myshop-dependencies
git checkout $RELEASE_VERSION
git pull origin $RELEASE_VERSION
mvn clean package

11.4.4、使用参数化构建项目

批准 groovy 脚本

再次点击参数化构建

查看构建日志

12、发送文件或执行远程命令

• Source files：需要传输到远程目标服务器的文件

  **/*.jar,docker/**
  

• Remove prefix：删除前缀。比如传输 **/*.jar，我们打包的 .jar 文件是在 target 目录下的，传输时会一并创建 target 目录，如果不希望创建 target 目录，则可以使用该参数屏蔽掉这些前缀文件夹。

• Remote directory：在远程目标服务器创建操作目录

  myapp
  

• Exec command：在远程目标服务器执行控制台命令

  cd /usr/local/jenkins/myapp
  cp target/myapp-1.0.0-SNAPSHOT.jar docker
  cd docker
  docker build -t 192.168.50.128:5000/myapp:v1.0.0 .
  docker push 192.168.50.128:5000/myapp:v1.0.0
  docker-compose down
  docker-compose up -d
  docker image prune -f
  

简介

Jenkins是一款开源 CI&CD 软件，用于自动化各种任务，包括构建、测试和部署软件。Jenkins 支持各种运行方式，可通过系统包、Docker 或者通过一个独立的 Java 程序。
Jenkins是一个广泛用于持续构建的可视化Web工具，持续构建就是将项目自动化编译、打包、部署。通过规范化来完成，简单，繁琐，浪费时间的重复工作。

工作流程

1、开发人员提交代码到git仓库
2、Jenkins手动/定时构建项目
3、Jenkins拉取git仓库代码-》代码编译-》打包镜像-》推送到镜像仓库
4、Jenkins执行脚本/Dodckerfile在Docker主机上创建容器并发布
5、测试人员浏览项目进行测试

安装

Jenkins安装包来源

用户手册：
https://jenkins.io/zh/doc/
下载：
https://www.jenkins.io/zh/download/

或者使用本人提供的
https://download.csdn.net/download/weixin_39218464/27377641

安装命令

# 注意我们需要安装java环境
yum install -y java
yum localinstall -y /root/jenkins/jenkins-2.222.1-1.1.noarch.rpm

启动

systemctl start jenkins

验证

查看jenken服务是否开启与端口

• 如果没有则关闭防火墙

netstat -lnpt

配置域名

在C:\Windows\System32\drivers\etc目录下修改hosts文件

192.168.10.101 jenkins.liuyuanshan.top

获取登录密码

cat /var/lib/jenkins/secrets/initialAdminPassword

登录

http://jenkins.liuyuanshan.top:8080/login

登录白屏问题解决

1、在$JENKINS_HOME/hudson.model.UpdateCenter.xml文件中，默认内容如下/var/lib/jenkins/hudson.model.UpdateCenter.xml

<?xml version='1.1' encoding='UTF-8'?>
<sites>
  <site>
    <id>default</id>
    <url>http://updates.jenkins-ci.org/update-center.json</url>
  </site>
</sites>

这个地址在外国的服务器，因为墙的原因，下载初始化界面所需插件不了，就一直处于等待状态

把url改为http://mirror.xmission.com/jenkins/updates/update-center.json就解决了

重启服务

systemctl restart jenkins

安装插件的三种方法

导入扩展
扩展来源：
https://download.csdn.net/download/weixin_39218464/27377641

# 解压插件扩展
tar -zxvf jenkins_plugins.tar.gz
# 删除原有插件删除
rm -rf /var/lib/jenkins/plugins/* 
# 拷贝解压后的插件并移动
mv plugins/ /var/lib/jenkins/
# 停止服务
systemctl stop jenkins
# 查看所有插件
ls /var/lib/jenkins/plugins/
# 递归设置文件所有者是谁
chown -R jenkins.jenkins /var/lib/jenkins
# 启动服务
systemctl start jenkins
# 查看进程
ps aux | grep jenkins
# 查看日志
tail -f /var/log/jenkins/jenkins.log

在线安装插件

导入方式上传插件

隐藏界面上面的警告

系统管理-》全局安全配置-》隐藏的安全警告-》全部取消勾选

快速体验Shell操作

新建任务-》testshell-》创建一个自由风格的软件项目-》确定-》构建-》执行 shell-》编写脚本内容-》保存

立即构建

查看shell脚本执行后生成的文件

jenkins去集成我们的gitlab或者gitee

jenkins为何要集成gitlab
因为我们需要托管Jenkins将gitlab上项目获取到本地，为后续网站的代码发布工作做准备。

jenkins是如何集成gitlab的
由于Jenkins只是一个调度平台，所有需要安装与gitlab相关的插件既可以完成集成。

jenkins与gitlab的集成步骤
1）开发提交代码到Gitlab上
2）jenkins安装gitlab对应的插件
3）jenkins创建yzm项目，然后配置gitlab仓库项目对应的地址

配置ssh
在开发机上执行 ssh-keygen，把公钥放入到gitlab中

jenkins安装gitlab对应的插件

系统管理-》插件管理-》已安装

插件名称	插件作用
Credentials	允许在Jenkins中存储认证的凭据
Git Client	允许Jenkins使用git
Git Plugin	允许Jenkins集成git
Gitlab	允许Gitlab触发Jenkins构建并在Gitlab中显示
GitLab Hook	允许gitlab自动触发jenkins构建项目
Gitlab Authentiaction	gitlab身份验证插件

上文直接导入的扩展包以配置好，这里不再配置

在Jenkins服务器上安装git环境

1） 在Jenkins服务器上安装git环境

# 安装git 
yum -y install git
# 重启Jenkins服务
systemctl restart jenkins	

2）Jenkins服务中完善git的配置信息
系统管理-》全局工具配置-》git-》配置git程序执行目录位置

找到git在Jenkins服务器的安装位置

which git

jenkins创建yzm项目

新建任务-》yzm -》创建一个自由风格的软件项目-》确定-》编辑项目git配置

General
填写描述、丢弃旧的构建-》保持构建的最大个数10个

源码管理
选择-》Git-》填写Repository URL

配置host文件
如果是内网搭建的gitlab则需要在Jenkins服务器中配置解析的gitlab对应IP与域名解析配置

在Jenkins服务器中执行 ssh-keygen获取配置在Gitlab上的公钥，私钥配置在Jenkins中
1）生成公钥配置在Gitlab上

2）私钥配置在Jenkins中

进行项目初始化构建
1、立即构建yzm项目
2、通过该控制台输出可以查看最近提交的信息
3、通过工作区可以查看代码

工作区查看代码

真实拉取gitlab的项目在

 /var/lib/jenkins/workspace/

集群部署

搭建nginx集群

1、搭建3台Nginx服务器
2、映射host文件
使用192.168.10.102 www.liuyuanshan.top做映射域名，负载分发器

3、为192.168.10.102~104服务器安装nginx服务

# 备份
mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
# 下载新的CentOS-Base.repo 到/etc/yum.repos.d/
curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
# 或者
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
# 运行 yum makecache
yum makecache
# 运行yum install epel-release -y
yum install epel-release -y
yum install nginx -y
# 查找nginx.conf路径
find / -name 'nginx.conf'
# 重启nginx
systemctl restart nginx

4、编辑负载均衡分发器
vi www.liuyuanshan.top.conf

upstream html {
  server 192.168.10.103:80;
  server 192.168.10.104:80;
}

server {
   listen 80;
   server_name www.liuyuanshan.top;
   location / {
      proxy_pass http://html;
      proxy_set_header Host $http_host;
  }
}

重启nginx服务

# 重启nginx
systemctl restart nginx

访问查看是否否成功将请求分发
http://www.liuyuanshan.top/?name=test

手动把jenkins的代码拷贝到nginx里面

cd /var/lib/jenkins/workspace/yzm
scp -r ./* root@192.168.10.103:/usr/share/nginx/html

jenkins自动部署到我们集群上面

为jenkins服务下的服务器生成密码：ssh-keygen
将Jenkins服务下的pub公钥传递到nginx服务下上，进行免密登录，使得拷贝文件时避开密码校验问题

# jenkins的密钥在配置gitee时候就已经生成过，无需再次生成，看上文中的操作
#进入到ssh文件夹拷贝pub公钥
cd /root/.ssh
# 将公钥拷贝至目标服务器下-生成的文件名为authorized_keys
ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.10.103
ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.10.104

查看拷贝到目标主机的公钥内容
cat authorized_keys

写一个shell脚本
1）进入项目目录，将内容进行打包
2）将内容通过scp拷贝分发到web集群组中

在jenkins服务器中进行shell脚本编写

# 进入项目目录
cd /var/lib/jenkins/workspace/yzm
# 创建shell脚本目录存放脚本文件
mkdir scripts
# 创建并编写脚本
vi html_deploy.sh
# 赋予文件读写执行的权限
chmod 777 html_deploy.sh

html_deploy.sh脚本内容

#!/usr/bin/bash
# 初始化时间变量
DATE=$(date +%Y-%m-%d-%H-%M-%S)
# 移动代码的目标服务器IP
web_serer="192.168.10.103"
# WORKSPACE
get_code(){
	# WORKSPACE是在Jenkins中设置动态环境变量-知道有这个就行
	# WORKSPACE动态表示/var/lib/jenkins/workspace/yzm
	cd ${WORKSPACE} && \
	tar czf /opt/web-${DATE}.tar.gz ./../*
}

scp_web_server(){
# 循环遍历拷贝到目标主机
for host in ${web_serer}
do
	# 从opt中将压缩的文件拷贝到目标主机的opt目录下
	scp /opt/web-${DATE}.tar.gz root@${host}:/opt
	ssh root@${host} "mkdir -p /usr/share/nginx/html_back/web-${DATE} && \
	tar -zxf /opt/web-${DATE}.tar.gz -C /usr/share/nginx/html_back/web-${DATE} && \
	rm -rf /usr/share/nginx/html && \
	ln -s /usr/share/nginx/html_back/web-${DATE}/yzm /usr/share/nginx/html"

done
}
//方法
deploy(){
 //执行get_code方法
  get_code
  //执行scp_web_server方法
  scp_web_server
}

//触发方法
deploy

WORKSPACE是在Jenkins中设置动态环境变量-知道有这个就行
WORKSPACE动态表示/var/lib/jenkins/workspace/yzm

修改jenkins执行权限由jenkins转为root用户
查看当前jenkins服务用户权限

ps aux |grep jenkins

修改用户权限

vi /etc/sysconfig/jenkins
# 完成修改后记得重启服务
systemctl restart jenkins

进入jenkins系统yzm项目设置shell执行脚本

sh -x /var/lib/jenkins/workspace/yzm/scripts/html_deploy.sh

jenkins支持gitlab的tab

由于之前上线方式直接拉取最新代码，会造成后期回退变得困难，如果采用采用tag的方式，比如第一次上线v1.1,第二次上线v1.2，如果上线v1.2出现问题，那么可以快速回退到v1.1

思路

1.开发如果需要发布新版本，必须将当前的版本打上一个标签tag。
2.jenkis需要让其脚本支持传递，比如用户传递v1.1 拉取v1.1标签

实战jenkins部署tag版本

安装git 参数插件，引入的扩展包有，这里只是说明，没有的自行加入

在项目中配置-》勾选参数化构建过程
添加参数-》Git Parameter

源码管理-》Branches to build

修改执行脚本

sh -x /var/lib/jenkins/workspace/yzm/scripts/html_deploy_bytag.sh

这部分仅作演示用，不需要配置

在项目中配置-》勾选参数化构建过程
添加文本参数、选择参数

添加参数-》文本参数

添加参数-》选项参数

测试上边添加的参数变量

测试传值

设置rollback为2.0-》开始构建

---

修改tag的脚本： html_deploy_bytag.sh
增加版本信息

cp /var/lib/jenkins/workspace/yzm/scripts/html_deploy.sh /var/lib/jenkins/workspace/yzm/scripts/html_deploy_bytag.sh

#!/usr/bin/bash
# 初始化时间变量
DATE=$(date +%Y-%m-%d-%H-%M-%S)
# 移动代码的目标服务器IP
web_serer="192.168.10.103 192.168.10.104"
Name=${DATE}-${git_version}
# WORKSPACE
get_code(){
	# WORKSPACE是在Jenkins中设置动态环境变量-知道有这个就行
	# WORKSPACE动态表示/var/lib/jenkins/workspace/yzm
	cd ${WORKSPACE} && \
	tar czf /opt/web-${Name}.tar.gz ./../*
}

scp_web_server(){
# 循环遍历拷贝到目标主机
for host in ${web_serer}
do
	# 从opt中将压缩的文件拷贝到目标主机的opt目录下
	scp /opt/web-${Name}.tar.gz root@${host}:/opt
	ssh root@${host} "mkdir -p /usr/share/nginx/html_back/web-${Name} && \
	tar -zxf /opt/web-${Name}.tar.gz -C /usr/share/nginx/html_back/web-${Name} && \
	rm -rf /usr/share/nginx/html && \
	ln -s /usr/share/nginx/html_back/web-${Name}/yzm /usr/share/nginx/html"

done
}
//方法
deploy(){
 //执行get_code方法
  get_code
  //执行scp_web_server方法
  scp_web_server
}

//触发方法
deploy

tag 演示

1、将本地修改好的代码提交到远程仓库
2、在本地打标签后推送到远程上

# 修改前对当前版本进行版本定义
git tag -a "v1.1" -m 'v1.1版本'
git push origin v1.1
# 将修改后的文件提交到远程仓库
git add .
git commit -m "v1.2"
git push
# 对推送的代码进行打标签，以便于版本回退
git tag -a "v1.2" -m "v1.2版本"
git push origin v1.2

在Build with Parameters可以查看提交的tag版本

构建指定版本代码

部署和回滚

修改脚本： html_deploy_rollback.sh

#!/usr/bin/bash

DATE=$(date +%Y-%m-%d-%H-%M-%S)
web_serer="192.168.10.216 192.168.10.217"

Name=${DATE}-${git_version}
get_code(){
	cd ${WORKSPACE} && \
	tar czf /opt/web-${Name}.tar.gz ./../*
}

scp_web_server(){
for host in ${web_serer}
do
	scp /opt/web-${Name}.tar.gz root@${host}:/opt
	ssh root@${host} "mkdir -p /usr/share/nginx/html_back/web-${Name} && \
	tar -zxf /opt/web-${Name}.tar.gz -C /usr/share/nginx/html_back/web-${Name} && \
	rm -rf /usr/share/nginx/html && \
	ln -s /usr/share/nginx/html_back/web-${Name}/yzm /usr/share/nginx/html"

done
}

deploy(){
  get_code
  scp_web_server
}


back(){
back_file=$(ssh root@192.168.10.216 "find /usr/share/nginx/html_back/ -maxdepth 1 -type d -name "web-*-${git_version}"")
for host in $web_serer
do
        ssh root@${host} "rm -rf /usr/share/nginx/html && \
                          ln -s ${back_file}/yzm /usr/share/nginx/html"
done

}


if [ $deploy_env == "deploy" ];then
        deploy
elif [ $deploy_env == "rollback" ];then
        back
fi

修改参数配置

演示

Jenkins构建的项目类型介绍

• Jenkins中自动构建项目的类型有很多，常用的有以下三种：
  1. 自由风格软件项目（FreeStyle Project）
  2. Maven项目（Maven Project）
  3. 流水线项目（Pipeline Project）
• 每种类型的构建都可以完成一样的构建过程与结果，只是在操作方式、灵活度等方面有所区别，在实际开发中根据项目需求来选择（PS：流水线类型，灵活度非常高）

自由风格项目构建

• 自由风格项目完成项目的集成过程：

拉取代码 --> 编译 --> 打包 --> 部署

拉取代码

创建项目

#项目已拉取至本地
[root@jenkins ~]# cd /var/lib/jenkins/workspace/
web_demo_freestyle  web_demo_freestyle@tmp
[root@jenkins workspace]# cd java_demo_freestyle
[root@jenkins java_demo_freestyle]# ls
db  pom.xml  src

编译打包

• 构建 --> 添加构建步骤 --> Executor Shell

返回刚才的项目，添加配置

控制台输出构建过程

编译完成后在工作空间产生一个target目录

远程部署

• 把项目部署到Tomcat里面

安装Deploy to cintainer插件

• Jenkins本身无法实现远程部署到Tomcat的功能，需要安装Deploy to container插件实现

安装完成后回到项目，增加构建后操作

找到需要发布的war包名字

添加容器，添加Tomcat8

添加凭据，使用用户密码类型

保存后再次执行构建

点击项目，成功部署

代码改动后的持续集成

• IDEA源码修改并提交至Gitlab
• 在Jenkins中项目重新构建
• 访问Tomcat

重新构建项目

Maven项目构建

安装Maven Integration插件

新建项目

再次修改源码

执行构建后再次查看项目

Pipeline流水线项目构建

Pipeline简介

• Pipeline，简单来说，就是一套运行在 Jenkins 上的工作流框架，将原来独立运行于单个或者多个节点的任务连接起来，实现单个任务难以完成的复杂流程编排和可视化的工作

使用Pipeline有以下好处（来自翻译官方文档）

• 代码：Pipeline以代码的形式实现，通常被检入源代码控制，使团队能够编辑，审查和迭代其传送流程
• 持久：无论是计划内的还是计划外的服务器重启，Pipeline都是可恢复的
• 可停止：Pipeline可接收交互式输入，以确定是否继续执Pipeline
• 多功能：Pipeline支持现实世界中复杂的持续交付要求。它支持fork/join、循环执行，并行执行任务的功能
• 可扩展：Pipeline插件支持其DSL的自定义扩展 ，以及与其他插件集成的多个选项

如何创建 Jenkins Pipeline呢？

• Pipeline 脚本是由 Groovy 语言实现的，但是我们没必要单独去学习 Groovy
• Pipeline 支持两种语法：Declarative(声明式)和 Scripted Pipeline(脚本式)语法
• Pipeline 也有两种创建方法：可以直接在 Jenkins 的 Web UI 界面中输入脚本；也可以通过创建一个 Jenkinsfile 脚本文件放入项目源码库中（一般我们都推荐在 Jenkins 中直接从源代码控制(SCM)中直接载入 Jenkinsfile Pipeline 这种方法）

安装Pipeline插件

新建流水线任务

Pipeline基本语法

声明式语法

• stages：复数，代表所有执行阶段，通常情况下只有一个，包含多个stage
• stage：某个阶段，一个步骤为一个stage，可以有多个
• steps：可以多种步骤类型，如：shell，拉取代码，远程部署容器

#编写一个基础的声明式pipeline语法
pipeline {
    agent any

    stages {
        stage('pull code') {                #拉取代码
            steps {
                echo 'pull code'
            }
        }
        stage('build project') {            #构建项目
            steps {
                echo 'build project'
            }
        }
        stage('publish project') {          #发布项目
            steps {
                echo 'publish project'
            }
        }
    }
}

脚本式语法

• Node：节点，一个 Node 就是一个 Jenkins 节点，Master 或者 Agent，是执行 Step 的具体运行环境

#编写一个基础的脚本式pipeline语法
node {
    def mvnHome
    stage('pull code') { // for display purposes
      echo 'pull code'
    }
    stage('Build project') {
      echo 'Build project'
    }
    stage('publish project') {
      echo 'publish project'
    }
}

拉取代码

流水线脚本的编写有一定难度，可以使用工具生成

编译打包

使用片段生成器

远程部署

同样使用片段生成器

复制进流水线脚本里

管理Jenkinsfile脚本文件

• 刚才我们都是直接在Jenkins的UI界面编写Pipeline代码，这样不方便脚本维护，如果Jenkins服务器崩溃，脚本也会随即丢失
• 建议把Pipeline脚本放在项目中（一起进行版本控制）

在项目根目录建立Jenkinsfile文件，把内容复制到该文件中

将脚本文件上传至仓库

查看仓库，已添加Jenkinsfile文件

如果脚本丢失，选择使用Pipeline script from SCM方式获得Jenkinsfile脚本

Jenkins项目构建细节

• Jenkins内置4种构建触发器
  1. 触发远程构建
  2. 其他工程构建后触发（Build after other projects are build）
  3. 定时构建（Build periodically）
  4. 轮询SCM（Poll SCM）

常用构建触发器

触发远程构建

其他工程触发后构建

• 当前项目的构建行为需要前面一个项目构建完成后的触发

创建前置工程

构建完前置工程后会自动构建

定时构建

• 定时字符串从左往右分别为：分 时 日 月 周

一些定时表达式的例子

# H代表一个参数,意思是变化的,可以理解为一个起点
# 0代表整点

#每30分钟构建一次：H代表形参
H/30 * * * * 10:02 10:32

#2个小时构建一次
H H/2 * * *

#每天的8点,12点,22点,一天构建3次： (多个时间点中间用逗号隔开) 
0 8,12,22 * * *

#每天中午12点定时构建一次
H 12 * * *

#每天下午18点定时构建一次
H 18 * * *

#在每个小时的前半个小时内的每10分钟
H(0-29)/10 * * *

#每两小时一次,每个工作日上午9点到下午5点(也许是上午10:38,下午12:38,下午2:38,下午4:38)
H H(9-16)/2 * * 1-5

等待两分钟后自行开始构建

轮询SCM

• 轮询SCM，是指定时扫描本地仓库的代码是否有变更，如果代码有变更就触发项目构建
  1. 注意：这从触发构建器，Jenkins会定时扫描本地整个项目的代码，增大系统的开销，不建议使用

设置每两分钟检测一次，如果代码发生变化，则会构建新的工程，如果代码没有发生变化，则不构建

修改代码后Push至代码仓库约两分钟后，Jenkins扫描到仓库发生改变触发构建

Git hook自动触发构建

• 刚才在Jenkins的内置构建触发器中，轮询SCM可以实现Gitlab代码更新，项目自动构建，但是该方案的性能不佳，那么是否还有更好的方案？
• 利用Gitlab的webhook实现代码Push到仓库，自动触发项目自动构建

安装Gitlab Hook插件

• 需要安装两个插件

Gitlab Hook和Gitlab

Gitlab开启webhook功能，使用root用户

返回项目

Jenkins开启外部访问权限

返回Gitlab进行测试

项目同时进行了一次构建

修改代码进行测试

Push完成后触发Jenkins项目构建

Jenkins的参数化构建

• 有时在项目构建的过程中，我们需要根据用户的输入动态传入一些参数，从而影响整个构建结果，这时我们可以使用参数化构建
• Jenkins支持非常丰富的参数类型

更改Jenkinsfile脚本里面分支变量值

创建分支

添加新的分支

仓库中查看新的分支

通过v1构建项目

配置邮箱服务器发送构建结果

安装Email Extension插件

Jenkins系统配置进行相应配置

邮件设置完成后的测试

准备邮件内容

• 在项目根目录编写email.html，并把文件推送到Gitlab，内容如下

创建email.html

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>${ENV, var="JOB_NAME"}-第${BUILD_NUMBER}次构建日志</title>
</head>

<body leftmargin="8" marginwidth="0" topmargin="8" marginheight="4" offset="0">
<table width="95%" cellpadding="0" cellspacing="0"
       style="font-size: 11pt; font-family: Tahoma, Arial, Helvetica, sans- serif">
    <tr>
        <td>(本邮件是程序自动下发的，请勿回复！)</td>
    </tr>
    <tr>
        <td><h2>
            <font color="#0000FF">构建结果 - ${BUILD_STATUS}</font>
        </h2></td>
    </tr>
    <tr>
        <td><br />
            <b><font color="#0B610B">构建信息</font></b>
            <hr size="2" width="100%" align="center" /></td>
    </tr>
    <tr>
        <td>
            <ul>
                <li>项目名称&nbsp;：&nbsp;${PROJECT_NAME}</li>
                <li>构建编号&nbsp;：&nbsp;第${BUILD_NUMBER}次构建</li>
                <li>触发原因：&nbsp;${CAUSE}</li>
                <li>构建日志：&nbsp;<a href="${BUILD_URL}console">${BUILD_URL}console</a></li>
                <li>构建&nbsp;&nbsp;Url&nbsp;：&nbsp;<a href="${BUILD_URL}">${BUILD_URL}</a></li>
                <li>工作目录&nbsp;：&nbsp;<a href="${PROJECT_URL}ws">${PROJECT_URL}ws</a></li>
                <li>项目&nbsp;&nbsp;Url&nbsp;：&nbsp;<a href="${PROJECT_URL}">${PROJECT_URL}</a></li>
            </ul>
        </td>
    </tr>
    <tr>
        <td><b><font color="#0B610B">Changes Since Last Successful Build:</font></b>
            <hr size="2" width="100%" align="center" /></td>
    </tr>
    编写Jenkinsfile添加构建后发送邮件
    <tr>
        <td>
            <ul>
                <li>历史变更记录 : <a href="${PROJECT_URL}changes">${PROJECT_URL}changes</a></li>
            </ul> ${CHANGES_SINCE_LAST_SUCCESS,reverse=true, format="Changes for Build #%n:<br />%c<br />",showPaths=true,changesFormat="<pre>[%a]<br />%m</pre>",pathFormat="&nbsp;&nbsp;&nbsp;&nbsp;%p"} 
        </td> 
    </tr> 
    <tr>
        <td><b>Failed Test Results</b> 
            <hr size="2" width="100%" align="center" /></td> 
    </tr> 
    <tr>
        <td><prestyle="font-size: 11pt; font-family: Tahoma, Arial, Helvetica, sans-serif">$FAILED_TESTS</pre> <br />
        </td> 
    </tr> 
    <tr>
        <td><b><font color="#0B610B">构建日志 (最后 100行):</font></b> 
            <hr size="2" width="100%" align="center" /></td> 
    </tr> 
    <tr>
        <td><textarea cols="80" rows="30" readonly="readonly" style="font-family: Courier New">${BUILD_LOG, maxLines=100}</textarea> 
        </td> 
    </tr> 
</table> 
</body> 
</html>

推送至Gitlab代码仓库

编写Jenkinsfile添加构建后发送邮件

pipeline {
    agent any

    stages {
        stage('pull code') {
            steps {
               checkout([$class: 'GitSCM', branches: [[name: '*/${branch}']], extensions: [], userRemoteConfigs: [[credentialsId: '911f1631-98e1-49b5-93eb-f4ef6d4dafe2', url: 'git@192.168.100.88:pakho_group/java_demo.git']]])
            }
        }
        stage('build project') {
            steps {
               sh 'mvn clean package'
            }
        }
        stage('publish project') {
            steps {
               deploy adapters: [tomcat8(credentialsId: '18c54ca2-ffd9-438a-b4dc-09fab43d8ef3', path: '', url: 'http://192.168.100.90:8080')], contextPath: null, war: 'target/*.war'
            }
        }
    }
    post {                        #添加port,对应stages
          always {
             emailext (
                subject: '构建通知：${PROJECT_NAME} - Build # ${BUILD_NUMBER} - ${BUILD_STATUS}!',
                body: '${FILE,path="email.html"}',
                to: 'xxx@qq.com'
             )
          }
    }
}

更新脚本至仓库后构建项目

查看邮件