jenkins先容，帮助你从安装到使用jenkins

Jenkins 概述

官网地址：https://www.jenkins.io/zh/

什么是 Jenkins

Jenkins是一款开源 CI&CD 软件，用于自动化各种任务，包罗构建、测试和摆设软件。它提供了一个易于使用的图形化界面，可以通过设置简单的任务来实现自动化构建和摆设流程。Jenkins 可以与各种版本控制系统（如 Git、SVN）和构建工具（如 Maven、Gradle）集成，支持多种编程语言和平台。它还提供了丰富的插件生态系统，可以扩展其功能，以满足各种差别的自动化需求。通过使用 Jenkins，开辟团队可以更高效地进行软件开辟和交付，提高质量和稳定性。
Jenkins 的优点

Jenkins 作为一个连续集成工具，具有以下几个优点：

• 自动化构建和摆设：Jenkins 可以自动化实行构建、测试和摆设任务，减少了人工操作的错误和工作量，提高了软件交付的速度和质量。
  
• 可扩展性：Jenkins 拥有丰富的插件生态系统，可以根据必要选择和安装各种插件，扩展其功能，满足差别项目的需求。
  
• 强大的集成本领：Jenkins 可以与各种版本控制系统、构建工具、测试框架和摆设工具等集成，提供了机动的设置选项，并支持多种编程语言和平台。
  
• 可视化界面：Jenkins 提供了直观易用的图形化界面，使用户可以轻松设置和管理构建任务，查看构建结果和日志，以及监控构建状态。
  
• 异常处置处罚和报告：Jenkins 可以实时检测构建中的异常情况，如编译错误、测试失败等，提供详细的报告和日志，帮助开辟团队快速定位息争决题目。
  
• 分布式构建和摆设：Jenkins 支持分布式构建和摆设，可以将任务分发到多台计算机上并行实行，提高了服从和扩展性。
  
• 社区支持和生动度：Jenkins 是一个开源项目，拥有巨大的用户社区，有生动的开辟者和贡献者，能够实时解决题目、提供支持和更新。
  

总的来说，Jenkins 提供了一种可靠的、机动的和可定制的连续集成解决方案，帮助开辟团队实现自动化构建、测试和摆设，提高开辟服从、软件质量和交付速度。
Jenkins 的应用场景

Jenkins 的使用场景非常广泛，主要用于以下几个方面：

• 连续集成和连续交付：Jenkins 可以自动化实行构建、测试和摆设任务，实现连续集成和连续交付，帮助开辟团队快速交付高质量的软件。
  
• 自动化测试：Jenkins 可以与各种测试框架和工具集成，自动实行测试用例，生成测试报告，并实时反馈测试结果，帮助开辟团队发现息争决题目。
  
• 自动化摆设：Jenkins 可以与各种摆设工具和云平台集成，实现自动化摆设和发布，帮助开辟团队快速摆设软件到差别情况，提高交付服从。
  
• 任务调理和定时实行：Jenkins 提供了机动的任务调理功能，可以定时实行各种任务，如定时构建、备份数据、定时清理等。
  
• 构建和发布管理：Jenkins 可以管理和跟踪差别版本的构建和发布，提供了版本控制、构建历史、构建参数等功能，方便团队进行版本管理和回滚操作。
  
• 监控和报警：Jenkins 可以监控构建和摆设过程中的异常情况，如编译错误、测试失败等，实时发送报警关照，帮助开辟团队快速相应息争决题目。
  
• 多情况支持：Jenkins 支持在差别情况中实行构建和摆设任务，如开辟情况、测试情况、生产情况等，提供了机动的设置选项，适应差别的摆设需求。
  

总的来说，Jenkins 可以在软件开辟和交付过程中的各个环节发挥作用，帮助团队实现连续集成、自动化测试、自动化摆设等目标，提高开辟服从、软件质量和交付速度。
安装 Jenkins

情况预备

第一次安装使用 Jenkins，您必要以下预备：

• 机器要求：
  
  
  
  • 2 G 内存，发起大于 4G
    
  • 20 GB 的硬盘空间（用于 Jenkins 和 Docker 镜像）
    
  
  
• 必要安装以下软件：
  
  
  
  • Java 8
    
  • docker
    
  
  

原生安装方式

• 下载 Jenkins
  
• 打开终端进入到下载目次
  
• 运行下令 java -jar jenkins.war --httpPort=8080. 实在就是一个项目，直接运行即可
  
• 打开浏览器进入链接 http://localhost:8080
  
• 按照说明完成安装
  

docker 安装

• 确保有 docker 情况
  
• 安装 jenkins
  

1. # 创建挂载目录
2. mkdir -p /var/jenkins_home
3. chmod 777 /var/jenkins_home
5. # 我们把jenkins目录挂载出来，方便我们的修改和查看使用
6. # 安装jenkinsci/blueocean
7. docker run \
8.   -u root \
9.   -d \
10.   -p 8080:8080 \
11.   -p 50000:50000 \
12.   -v /var/jenkins_home:/var/jenkins_home \
13.   -v /var/run/docker.sock:/var/run/docker.sock \
14.   jenkinsci/blueocean

复制代码

• 等待安装乐成，打开浏览器访问ip地址:8000
  

• 查看登录密码，登录即可
  

1. # 方式一：docker 日志
2. docker logs -f 容器id
3. # 方式二：查看文件
4. cat /var/jenkins_home/secrets/initialAdminPassword

复制代码

• 进入插件安装页面，安装推荐的全部插件即可！假如没有这个页面，说明安装有题目！
  

1. # 插件下载慢，加速问题解决
2. cd /var/jenkins_home/updates
3. #把 “ www.google.com ”  改成  “ http://www.baidu.com/ ”
4. #全局搜索 “ updates.jenkins-ci.org/download ” 替换成 mirrors.tuna.tsinghua.edu.cn/jenkins
5. sed -i 's/https:\/\/updates.jenkins-ci.org\/download/https:\/\/mirrors.tuna.tsinghua.edu.cn\/jenkins/g' default.json
7. sed -i 's/https:\/\/www.google.com/https:\/\/www.baidu.com/g' default.json

复制代码

• 插件安装完毕，注册登录账户
  

• 设置实例的地址
  

• 进入主页面
  

• 查抄插件设置，比如我们要使用的 gitlab、docker、webhook 之类的！没有的话，必要勾选下载！全部插件都更新到最新版本
  

网络题目解决

Manage Plugins点击Advanced，把Update Site改为国内插件下载地址

1. https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json

复制代码

重启 http://192.168.0.120:8080/restart
流水线工程示例：

1. pipeline {
2.     agent { docker 'maven:3.3.3' }
3.     stages {
4.         stage('build') {
5.             steps {
6.                 sh 'mvn --version'
7.             }
8.         }
9.     }
10. }

复制代码

Jenkins 根本指令

Jenkins Pipeline（或简称为 “Pipeline”）是一套插件，将连续交付的实现和实施集成到 Jenkins 中。
连续交付 Pipeline 自动化的表达了如许一种流程：将基于版本控制管理的软件连续的交付到您的用户和消费者手中。
Jenkins Pipeline 提供了一套可扩展的工具，用于将“简单到复杂”的交付流程实现为“连续交付即代码”。Jenkins Pipeline 的界说通常被写入到一个文本文件（称为 Jenkinsfile ）中，该文件可以被放入项目的源代码控制库中。
Hello，Jenkins

1. pipeline {
2.     agent { docker 'maven:3.3.3'}
3.     stages {
4.         stage('Build') {
5.             steps {
6.                 // 具体的执行逻辑 shell mingling
7.                 sh 'mvn -version'
8.             }
9.         }
10.     }
11. }

复制代码

报错：说明 docker 插件没有下载好。
假如出现了错误，就会报错

修改为 any 的情况

1. // 最外层 pipeline
2. pipeline {
3.         // agent 环境
4.     agent any
5.     // 步骤集合
6.     stages {
7.             // 分步骤
8.         stage('Build') {
9.                 // 具体的步骤
10.             steps {
11.                 // 具体的执行逻辑 shell mingling
12.                 sh 'echo "hello,world"'
13.                 sh '''
14.                     echo "hahahahahahha"
15.                     ls -ls
16.                 '''
17.             }
18.         }
19.         
20.                 // 分步骤
21.         stage('Test') {
22.                 // 具体的步骤
23.             steps {
24.                 // 具体的执行逻辑 shell mingling
25.                 sh 'echo "Test"'
26.             }
27.         }
28.         
29.         // 分步骤
30.         stage('deploy') {
31.                 // 具体的步骤
32.             steps {
33.                 // 具体的执行逻辑 shell mingling
34.                 sh 'echo "部署"'
35.             }
36.         }
37.     }
38. }

复制代码

超时，重试

1. pipeline {
2.     agent any
3.     stages {
4.         stage('Deploy') {
5.             steps {
6.                 // 重试，连续执行多次，如果不成功就停止了。
7.                 retry(3){
8.                     // 测试脚本
9.                     sh './start.sh'
10.                 }
11.                
12.                 // 支付、回调...
13.                 // timeout ，如果该命令超过我们预期的时间，就会自动终止。
14.                 timeout(time: 3,unit: 'MINUTES'){
15.                         // 测试脚本
16.                     sh './health-check.sh'
17.                 }
18.             }
19.         }
20.     }
21. }

复制代码

钩子函数，生命周期的函数

pipeline 实行到某个步骤的时间，来做一些事情， post

1. pipeline {
2.     agent any
3.     stages {
4.         stage('Test') {
5.             steps {
6.                          sh 'echo "fail!"'
7.             }
8.         }
9.     }
10.     // 钩子函数,比如执行结果不同，我们可以处理一些善后工作
11.     post {
12.             // 行为
13.             always {
14.                     echo 'always'
15.             }
16.             success {
17.             echo 'success'
18.             }
19.             failure {
20.                     echo 'failure'
21.             }
22.             unstable {
23.                     echo 'failure'
24.             }
25.             changed {
26.                     echo 'failure'
27.             }
28.     }
29. }

复制代码

界说实行情况

您大概已经留意到每个示例中的 agent 指令。 agent 指令告诉 Jenkins 在哪里以及如何实行 Pipeline 大概 Pipeline 子集。 正如您所预料的，全部的Pipeline 都必要 agent 指令。
在实行引擎中，agent 指令会引起以下操作的实行：

• 全部在块 block 中的步骤 steps 会被 Jenkins 保存在一个实行队列中。 一旦一个实行器 executor 是可以使用的，这些步骤将会开始实行。
  
• 一个工作空间 workspace 将会被分配， 工作空间中会包罗来自长途仓库的文件和一些用于 Pipeline 的工作文件
  
• 工作目次
  

在 Pipeline 中可以很容易的运行 docker 镜像和容器。 Pipeline 可以界说下令大概应用运行必要的情况和工具， 不必要在实行代理中手动去设置各种各样的系统工具和依靠。 这种方式可以让你使用 docker 容器工具包中的任何工具。

1. pipeline{
2.     agent {docker xxxxx:@version}
4.     stages{  
6.         // 执行步骤
7.         dockerfile
8.         dockercompose
9.         shell
10.         其他程序相关的命令
11.         .....
12.     }
13. }

复制代码

1. pipeline {
2.     agent {
3.         docker { image 'node:7-alpine' }
4.     }
5.     stages {
6.         stage('Test') {
7.             steps {
8.                 sh 'node --version'
9.             }
10.         }
11.     }
12. }

复制代码

假如是其他情况，就设置其他的运行镜像即可，默认any。
情况变量

公共的情况，在全部的 step 都可以使用

1. pipeline {
2.     agent any
3.    
4.     // 环境变量的定义，在agent环境中配置的东西
5.     environment{
6.             DB_ENGINE = 'sqlite'
7.             DB_PASSWORD='123456'
8.     }
9.    
10.     stages {
11.         stage('Build') {
12.             steps {
13.                 sh 'printenv'
14.             }
15.         }
16.     }
17. }

复制代码

许多下令都会有指令，使用情况变量，可以直接使用这里界说的。
多步骤

1. pipeline {
2.     agent any
3.    
4.     stages {
5.             // 构建项目
6.         stage('Build') {
7.             steps {
8.                     // mvn  、Dockerfile、 构建相关工作
9.                 sh 'Build'
10.             }
11.         }
12.         
13.         // 测试项目
14.         stage('Test') {
15.             steps {
16.                     // shell测试、web测试、压测。。。
17.                 sh 'Test'
18.             }
19.         }
20.         
21.         // 部署
22.         stage('Deploy') {
23.                 // 访问、集群、liunx
24.             steps {
25.                 sh 'Deploy'
26.             }
27.         }
28.     }
29. }

复制代码

人工确认

通常在阶段之间，特别是差别情况阶段之间，您大概必要人工确认是否可以继续运行。 比方，判断应用步调是否在一个富足好的状态可以进入到生产情况阶段。 这可以使用 input 步骤完成。 在下面的例子中，“Sanity check” 阶段会等待人工确认，并且在没有人工确认的情况下不会继续实行。

1. pipeline {
2.     agent any
3.     stages {
4.   
5.         stage('Deploy - Staging') {
6.             steps {
7.                 echo 'curl '
8.             }
9.         }
11.         stage('Sanity check') {
12.             steps {
13.                     // 人工确认
14.                 input "Does the staging environment look ok?"
15.             }
16.         }
18.         stage('Deploy - Production') {
19.             steps {
20.                echo 'Deploy - Production'
21.             }
22.         }
23.     }
24. }

复制代码

其余指令参考官方文档即可：https://www.jenkins.io/zh/doc/pipeline/tour/post/
全部不会写的语法，全部参照流水线工程里面的语法生成器。

WebHook

关闭防火墙，容器之间互通！systemctl stop firewalld

• 构建触发器，自动触发构建！有一个 webhook 触发器！
  

逻辑：提交代码后，jenkins 能够感知到代码提交了，流水线工程（项目打包，构建镜像，运行容器，测试接口，人工确认，摆设上线）就自动实行

jenkins 就发出了一个触发器下令？gitlab 那边设置触发
gitlab 账户设置

项目中设置 webhook

在 CICD 链上，摆设、测试脚本都要提前写好，一次写好，终身运行。
示例：流水线作业

官方文档：https://www.jenkins.io/zh/doc/tutorials/build-a-java-app-with-maven/

• clone github 示例仓库到本地，然后 push 到我们的 gitlab 仓库中
  

1. git clone https://github.com/jenkins-docs/simple-java-maven-app.git
3. mv simple-java-maven-app simple-java-maven-app2
5. git clone http://192.168.0.120:8888/root/simple-java-maven-app.git
7. cp -r simple-java-maven-app2/* simple-java-maven-app/
9. git add .
10. git commit -m "add"
11. git push -u origin master

复制代码

• 在 jenkins 创建流水线项目 simple-java-maven-app
  
• 设置绑定 git
  

• 添加 git 登录凭证
  

• 然后测试构建！
  
• docker maven 十分慢，我们必要设置镜像加快，我们可以本身界说 settings 文件，然后识别！
  

• 编写一个 settings.xml 放到项目下
  

1. <?xml version="1.0" encoding="UTF-8"?>
2. <settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
3.           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.           xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
5.   <mirrors>
6.         <mirror>
7.       <id>nexus-aliyun</id>  
8.       <mirrorOf>*,!jeecg,!jeecg-snapshots</mirrorOf>  
9.       <name>Nexus aliyun</name>  
10.       <url>http://maven.aliyun.com/nexus/content/groups/public</url>  
11.     </mirror>
12.   </mirrors>
13. </settings>

复制代码

• 修改 Jenkinsfile，指定我们本身写的 settings.xml
  

1. pipeline {
2.     agent {
3.         docker {
4.             image 'maven:3-alpine'
5.             args '-v /root/.m2:/root/.m2'
6.         }
7.     }
8.     stages {
9.         stage('Build') {
10.                 # 在原来的基础上增加 -gs settings.xml 指定我们的配置
11.             steps {
12.                 sh 'mvn -B -gs settings.xml -DskipTests clean package'
13.                
14.             }
15.         }
16.     }
17. }

复制代码

• 提交到长途，再次测试构建！
  

• 乐成构建，假如出现未知主机，测试网络是否可以 ping 通，重启下 docker 一般可以解决！
  

真实企业中，原理类似的，一样提交代码后，自动构建并运行测试。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。