Jenikins

一.Jenkins 概念

  1. 什么是 Jenkins？
    Jenkins 是 Java 语言开发的一款开源 CI/CD 软件，用于自动化各种任务，包括项目的拉取、项目构建、以及项目部署等功能。
    中文官网地址
  2. 持续集成的流程说明
  • 首先开发人员代码提交到仓库；
  • 然后 Jenkins 作为持续集成工具，使用 Git 工具到仓库拉取代码到集成服务器，再配合 JDK，Maven 等完成代码编
    译、测试、审查、打包等工作；
  • 最后 Jenkins 把生成的 jar 或 war 包分发到测试服务器或者生产服务器，测试人员或用户就可以访问应用；
  1. Jenkins 版本介绍
    jenkins LTS（长期支持）：每 3 个月更新一次，适合在企业生产环境使 用
    jenkins 普通版：每周更新一次，适合开发人员测试使用
    清华大学下载 Jenkins 稳定版地址

二.Jenkins 安装

  1. 安装 jdk 环境
    Jenkins 需要依赖 JDK，安装 jdk 环境（fontconfig 是 Jenkins web 界面字体包）
1
yum install fontconfig java-11-openjdk -y
  1. 安装 Jenkins
1
2
3
4
5
yum localinstall jenkins-2.332.3-1.1.noarch.rpm -y
#docekr 安装 Jenkins
docker run -id -p 8089:8080 --name jenkins --restart=always -v
/opt/jenkins/data:/var/jenkins_home jenkins/jenkins:2.332.3
docker pull jenkins/jenkins:2.433-jdk11
  1. 启动 jenkins
1
systemctl start jenkins && systemctl enable jenkins
  1. 访问
1
ip:8080
  1. 配置参数
1
2
3
4
5
/etc/sysconfig/jenkins #主配置文件，主要配置 Jenkins 的工作目录、启动用户、启动端口。
/var/lib/jenkins/plugins/ #插件存放目录
/var/lib/jenkins/users/ #用户信息存放目录
/var/lib/jenkins #默认的 Jenkins 家目录（存放项目及插件）
/var/log/jenkins #日志文件目录
  1. 初始配置
    Jenkins 是一个引擎，他本身的功能很简单，是通过各种不同的插件实现编译部署项目， 例如从 Gitlab 拉取代码，使用 Maven 构建项目等功能需要依靠插件完成 。
    如果选择安装推荐的插件，这样大部分常用的插件将会被安装，如果你对 Jenkins 很熟悉可以自定义插件安装

三.构建任务 1.创建 Item

Jenkins 的任务可以让我们实现很多工作流程的自动化，例如 打包、持续集成、部署、定时运行等工作，点击左侧栏
新建 Item（新建任务） 2.构建一个简单的 web 项目

  1. 创建新 Item
    点击新建 Item——》输入一个名称——》选择 Freestyle project——》点击确定

  2. 选择复选框 Discard old builds
    在 General（常规）：复选框中 Discard old builds（丢弃旧版本）每次构建都会生成很多构建产物，如果频繁建会占用很多的空间，可以通过这几个选项控制构建产物的保留，一般建议选择保留最近 5-10 天的构建历史记录为宜。

  3. 配置 git
    点击 git，把仓库地址复制进去，然后添加 Credentials 凭证，（Jenkins 主机需要安装一下 git 工具）——》点击 build now 测试是否可以拉取代码，构建成功后代码会拉取到/var/lib/jenkins/workspace/choujiang

  4. 准备应用机
    准备好一台装应用服务器，用来部署拉取的代码，安装好相应的环境，我这里使用 Nginx

  5. 创建脚本
    创建一个脚本，让 Jenkins 通过 shell 脚本进行部署,此操作在 Jenkins 服务器执行 #默认端口：8080（可修改）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#创建一个目录，用于存放项目的发布脚本
[root@jenkins ~]# mkdir /var/lib/jenkins/script && cd /var/lib/jenkins/script
#以下是项目发布的脚本内容
cat jenkins-nginx.sh
#!/bin/bash
#发布项目到Nginx
#定义Nginx网页根目录
WEB_DIR=/usr/share/nginx
#定义Jenkins项目所在路径
CODE_DIR=/var/lib/jenkins/workspace/choujiang
#项目发布时间
TIME=`date +%F-%H-%M`
#打包项目
cd $CODE_DIR && tar -zcf /tmp/web-$TIME.tar.gz ./*
#发布项目
for IP in `cat /var/lib/jenkins/script/nginx.txt`
do
scp /tmp/web-$TIME.tar.gz root@$IP:$WEB_DIR
ssh root@$IP "cd $WEB_DIR && mkdir web-$TIME"
ssh root@$IP "cd $WEB_DIR && tar -xf web-$TIME.tar.gz -C web-$TIME && rm -rf
web-$TIME.tar.gz"
ssh root@$IP "cd $WEB_DIR && rm -rf html && ln -s web-$TIME html"
done
#把nginx主机的IP地址写到这个文件里
vim nginx.txt
server_ip
#添加执行权限
chmod +x jenkins-nginx.sh
  1. 配置 Jenkins 用户免密发布项目到 Nginx 的服务器
1
2
3
4
5
6
7
8
9
#切换到Jenkins用户
usermod -s /bin/sh jenkins && su - jenkins
#生成密钥文件
-sh-4.2$ ssh-keygen
#将公钥传给Nginx
-sh-4.2$ ssh-copy-id root@server_ip
#切换到脚本路径执行脚本（主要是首次连接需要确认yes，否则Jenkins直接 构建会失败）
-sh-4.2$ cd script/
-sh-4.2$ ./jenkins-nginx.sh
  1. 构建 shell 脚本执行
    回到 Jenkins 的 choujiang 任务点击 设置 → 构建 → 增加构建步骤 →Execute shell（shell 命令）→ 保存 → 点击 build now 测试
  2. Jenkins+GitLab 自动发布项目
    本实验实现只要 GitLab 的 master 分支有新代码提交，Jenkins 自动触发 Build New（立即构建）功能，实现代码自动发布。
    安装 GitLab 构建触发器插件 → 点击左侧 Manage Jenkins→Manage Plugins→ 可选插件 → 安装（gitlab 和 Generic Webhook Trigger）
    构建 webhook 触发器：选择构建触发器 → 勾选 Build when a change is pushed to GitLab. GitLab webhook→ 高级
    → 勾选 Filter branches by name 填写 Include（master 分支）→ 点击 Secret token 里面的 generate→ 保存
    GitLab 设置 webhook：
    回到 GitLab 的 choujiang 项目中点击左侧 设置 →webhooks 粘贴 Jenkins 的令牌到 Secret token 处 → 网址填写 Jenkins
    项目中的网址
  3. jenkins 返回构建状态到 GitLab
    Jenkins 每次自动构建完成后可以把构建的结果反馈给 Gitlab，这样在 Gitlab 上就可以查看每一次构建的结果。
    首先在 Jenkins 上配置，打开 Manage jenkins（管理 Jenkins）→confifigure System（系统设置）下拉找到 GitLab 部分 → 自定义名称 →gitlab 服务器地址 → 再去 gitlab 生成一个 apitoken
    Jenkins 增加构建后操作步骤：进到任务中点击 配置 → 构建后操作

四.java 项目发布

1.maven

maven 是 Apache 基金会开源的一款项目综合管理工具，主要是服务 java 项目构建，依赖管理等工作。
官网
下载地址（这里使用 apache-maven-3.8.1-bin.tar.gz）

  1. maven 安装
1
2
3
4
5
6
7
8
9
10
11
# 上传安装包并解压
[root@jenkins ~]# tar -xf apache-maven-3.8.1-bin.tar.gz
#移动解压后的 maven 并改名
[root@jenkins ~]# mv apache-maven-3.8.1 /usr/local/maven
#将 maven 添加到环境变量
[root@jenkins ~]# vim /etc/profile
export PATH=/usr/local/maven/bin/:$PATH
#在文件末尾添加 #使用 source 使配置生效
[root@jenkins ~]# source /etc/profile
#验证
[root@jenkins ~]# mvn -v
  1. maven 目录结构
  • bin：该目录包含了 mvn 运行的脚本，在命令行输入任何一条 mvn 命令时，实际上就是在调用这些脚本。
  • boot：该目录只包含一个文件 plexus-classworlds-2.5.2.jar 是一个类加载器框架，Maven 使用该框架加载自己的类库，对于一般的 Maven 用户来说，不必关心该文件。
  • conf：该目录包含了一个非常重要的 settings.xml 文件，是 Maven 的全局配置文件。
  • lib：该目录包含了所有 Maven 运行时需要的 Java 类库。
  • LICENSE：记录了 Maven 使用的软件许可证 。
  • NOTICE：记录了 Maven 包含的第三方软件。
  • README.txt：包含了 Maven 的简要介绍，包括安装需求及如何安装的简要指令等。
  1. maven 基本操作
    命令 功能
    mvn package 生成 jar/war 包
    — —
    mvn clean 清空生成的文件

    找一个 java 源码包上传到 Jenkins 服务器，解压并进入

1
2
3
4
5
6
7
8
[root@jenkins ~]# unzip spring-source-mvc-ano-v1.0.zip
[root@jenkins ~]# cd spring-source-mvc-ano-v1.0
# 先进行清理
[root@jenkins spring-source-mvc-ano-v1.0]# mvn clean
# 在进行打包
[root@jenkins spring-source-mvc-ano-v1.0]# mvn package
# 打包后再 target 里面
[root@jenkins spring-source-mvc-ano-v1.0]# ls target/

配置 maven 仓库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# maven 默认下载的依赖存放在 root 家目录里面的.m2/repository/里面
[root@jenkins ~]# ll -a
drwxr-xr-x. 3 root root 24 7 月 16 19:24 .m2
# 配置远程仓库
[root@jenkins ~]# vim /usr/local/maven/conf/settings.xml
<!-- 阿里云仓库 -->
<mirrors>
  <mirror>
    <id>alimaven</id>
    <mirrorOf>central</mirrorOf>
    <name>aliyun maven</name>
    <url>http://maven.aliyun.com/nexus/content/repositories/ce ntral/</url>
  </mirror>
</mirrors>

2.推送项目到 gitlab

先在 gitlab 创建一个仓库，创建前先把 java 包上传到 gitlab，方便上传到仓库

仓库名 地址
maven git@192.168.92.19:root/maven.git
把项目推送到 gitlab 仓库 
1
2
3
4
5
6
# 将上传的 java 项目上传解压后进到目录操作一下步骤
git init
git remote add origin git@192.168.92.19:root/maven.git
git add .
git commit -m "第一次提交"
git push -u origin --all

3.Jenkins 安装 maven 插件

在 Plugin Manager 里面可选插件中搜索 maven，选择 Maven Integration 进行安装

4.构建 Maven 项目

点击新建 Itme，即可看到 构建一个 maven 项目，输入任务名称后点击构建一个 maven 项目点击确定。
配置 git 拉取项目
配置 build 构建项目
构建后项目地址

1
2
3
4
[root@jenkins ~]# ls /var/lib/jenkins/workspace/maven-job/target/
spring-source-mvc-ano-1.0-SNAPSHOT.war #这个 war 包就是构建 出来的 web 项目
JAR 包：就是 Java 项目的依赖工具
WAR 包：Java 项目都是打成 war 包进行发布，将 war 包放在 tomcat 的 webapps 下，并且 tomcat 服务器能够自动识别，能够对war 包进行自动解压

5.部署 Tomcat

准备一台机器安装 Tomcat 服务（实验环境可以跟前边的 Nginx 部署在同一台机器，不冲突）

1
2
3
4
5
6
# java 项目需要先安装 jdk
[root@tomcat ~]# yum -y install java-1.8.0-openjdk
# 下载 Tomcat 包上传并解压
[root@tomcat ~]# tar -xf apache-tomcat-8.0.30.tar -C /usr/local/tomcat
# 启动 Tomcat
[root@tomcat ~]# /usr/local/tomcat/bin/startup.sh

设置 tomcat 随机自启

1
2
3
[root@tomcat ~]# vim /etc/rc.local
/usr/local/tomcat/bin/startup.sh
[root@tomcat ~]# chmod +x /etc/rc.d/rc.local

6.Jenkins 发布 Java 项目

准备脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
vim /var/lib/jenkins/script/jenkins-tomcat.sh
#!/bin/bash #发布项目到 tomcat #定义 tomcat 网页根目录
WEB*DIR=/usr/local/tomcat/webapps/ #定义 Jenkins 项目所在路径
CODE_DIR=/var/lib/jenkins/workspace/maven-job/target #项目发布时间
TIME=`date +%F-%H-%M-%S` #打包项目
cd $CODE_DIR && tar -zcf /tmp/web-$TIME.tar.gz ./*.war #发布项目
for IP in `cat /var/lib/jenkins/script/tomcat.txt`
do
scp /tmp/web-$TIME.tar.gz root@$IP:$WEB_DIR
ssh root@$IP "cd $WEB_DIR && mkdir web-$TIME"
ssh root@$IP "cd $WEB_DIR && tar -xf web-$TIME.tar.gz -C web-$TIME && rm -rf
web-$TIME.tar.gz"
ssh root@$IP "cd $WEB_DIR && rm -rf ROOT_ && \cp web-$TIME/\*.war ROOT.war"
ssh root@$IP "/usr/local/tomcat/bin/shutdown.sh"
sleep 3
ssh root@$IP "/usr/local/tomcat/bin/startup.sh"
done

准备 for 循环的主机地址

1
echo 192.168.92.129 > /var/lib/jenkins/script/tomcat.txt

给脚本执行权限

1
chmod +x /var/lib/jenkins/script/jenkins-tomcat.sh

7.到 Jenkins 任务中增加构建步骤

回到任务中，点击配置，添加 Jenkins 执行 shell 脚本命令

五.Pipeline

Jenkins Pipeline（流水线） 简单来说就是将多个任务连接起来的一套工作流程。

  1. Jenkinsfifile 介绍
    Jenkinsfifile 是用来编写 Pipeline 的脚本语法，在一个 Pipeline 中有如下几个基础概念：
    • pipeline：声明此语法是声明式（Declarative）式语法（还有一种脚本式的语法）
    • agent：是指定执行 Step 的具体节点，any 表示所有（在 Jenkins 分布式环境下可以指定具体节点去执行任务）。
    • stages：代表构建项目的阶段开头，里边包含多个 stage。
    • Stage（阶段）：一个 Pipeline 由多个 Stage 组成，每个 Stage（阶段）可包含多个 Step（步骤）。
    • Steps（步骤）：可以是拉取代码、构建项目、发布项目等。

      示例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    pipeline {
     agent any
     stages {
       stage('Build') {
         steps {
           echo "hh"
         }
       }
       stage('Test') {
         steps {
           echo "start"
         }
       }
       stage('Deploy') {
         steps {
           echo "stop"
         }
       }
     }
    }
  2. Pipeline Job 示例
    创建一个 Pipeline（流水线）项目，点击新建 Item→ 选择 pipeline→ 流水线
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
pipeline {
	agent any
	stages {
		stage('Build') {
			steps {
				echo "hh"
			}
		}
		stage('Test') {
			steps {
				echo "start"
			}
		}
		stage('Deploy') {
			steps {
				echo "stop"
			}
		}
	}

六、docker 部署

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
version: '3.7'

services:
  jenkins:
    image: 'jenkins/jenkins:2.433-jdk11'
    container_name: jenkins
    user: root
    privileged: true
    restart: always
    ports:
      - '8888:8080'
    volumes:
      - '/opt/jenkins/data:/var/jenkins_home'
      - '/var/run/docker.sock:/var/run/docker.sock'
      - '/usr/bin/docker:/usr/bin/docker