摘要

主要是的当前比较流行的程序的自动化集成部署工具Jenkins。对于很多没有接触过的大型软件项目的同学来说和应届毕业生来说，没有接触过的Jenkins相关的自动化的集成部署工具的使用。本文将分jenkins的基本的介绍和，jenkins的安装和集成环境的基本的配置。同时将介绍jenkins的构建maven项目，Jenkins+Docker+SpringCloud微服务持续集成，基于Kubernetes/K8S构建Jenkins持续集成平台。从以上几个方向来帮助没有使用核想了解的同学帮助熟悉和带领大家进行jenkins的实际使用。

jenkins的基本的介绍

软件开发生命周期

软件开发生命周期又叫做SDLC ( Software Development Life Cycle )，它是集合了计划、开发、测试和部署过程的集合。如下图所示︰

• 需求分析：这是生命周期的第一阶段，根据项目需求，团队执行一个可行性计划的分析。项目需求可能是公司内部或者客户提出的。这阶段主要是对信息的收集，也有可能是对现有项目的改善和重新做一个新的项目。还要分析项目的预算多长，可以从哪方面受益及布局，这也是项目创建的目标。
• 设计：第二阶段就是设计阶段，系统架构和满意状态（就是要做成什么样子，有什么功能），和创建一个项目计划。计划可以使用图表，布局设计或者文者的方式呈现。
• 实现：第三阶段就是实现阶段，项目经理创建和分配工作给开者，开发者根据任务和在设计阶段定义的目标进行开发代码。依据项目的大小和复杂程度，可以需要数月或更长时间才能完成。
• 测试：测试人员进行代码测试，包括功能测试、代码测试、压力测试等。
• 进化：最后进阶段就是对产品不断的进化改进和维护阶段，根据用户的使用情况，可能需要对某功能进行修改，bug修复，功能增加等。

软件开发瀑布模型：

瀑布模型是最著名和最常使用的软件开发模型。瀑布模型就是一系列的软件开发过程。它是由制造业繁衍出来的。一个高度化的结构流程在一个方向上流动，有点像生产线一样。在瀑布模型创建之初，没有其它开发的模型，有很多东西全靠开发人员去猜测，去开发。这样的模型仅适用于那些简单的软件开发，但是已经不适合现在的开发了。

下图对软件开发模型的一个阐述。

什么是持续集成

持续集成(Continuous integration，简称CI)指的是，频繁地(一天多次）将代码集成到主干。持续集成的目的，就是让产品可以快速迭代，同时还能保持高质量。它的核心措施是，代码集成到主干之前，必须通过自动化测试。只要有一个测试用例失败，就不能集成。通过持续集成，团队可以快速的从一个功能到另一个功能，简而言之，敏捷软件开发很大一部分都要归功于持续集成。

根据持续集成的设计

代码从提交到生产，整个过程有以下几步。

• 提交：流程的第一步，是开发者向代码仓库提交代码。所有后面的步骤都始于本地代码的一次提交( commit )。
• 测试（第一轮)：代码仓库对commit操作配置了钩子( hook )，只要提交代码或者合并进主干，就会跑自动化测试。
• 构建：通过第一轮测试，代码就可以合并进主干，就算可以交付了。交付后，就先进行构建 ( build )，再进入第二轮测试。所谓构建，指的是将源码转换为可以运行的实际代码，比如安装依赖，配置各种资源（样式表、JS脚本、图片）等等。
• 测试（第二轮)：构建完成，就要进行第二轮测试。如果第一轮已经涵盖了所有测试内容，第二轮可以省略，当然，这时构建步骤也要移到第一轮测试前面。
• 部署：过了第二轮测试，当前代码就是一个可以直接部署的版本( artifact )。将这个版本的所有文件打包(tar filename.tar *)存档，发到生产服务器。
• 回滚：一旦当前版本发生问题，就要回滚到上一个版本的构建结果。最简单的做法就是修改一下符号链接，指向上一个版本的目录。

持续集成的组成要素

• ·一个自动构建过程，从检出代码、编译构建、运行测试、结果记录、测试统计等都是自动完成的，无需人工干预。
• ·一个代码存储库，即需要版本控制软件来保障代码的可维护性，同时作为构建过程的素材库，一般使用SVN或Git。
• ·一个持续集成服务器，Jenkins 就是一个配置简单和使用方便的持续集成服务器。

持续集成的好处

• 1、降低风险，由于持续集成不断去构建，编译和测试，可以很早期发现问题，所以修复的代价就少;
• 2、对系统健康持续检查，减少发布风险带来的问题;
• 3、减少重复性工作;
• 4、持续部署，提供可部署单元包;
• 5、持续交付可供使用的版本;
• 6、增强团队信心;

Jenkins

Jenkins是一款流行的开源持续集成( Continuous Integration)工具，广泛用于项目开发，具有自动化构建、测试和部署等功能。官网: http:/ljenkins-ci.orgL。

Jenkins的特征∶

• 开源的Java语言开发持续集成工具，支持持续集成，持续部署。
• 易于安装部署配置:可通过yum安装,或下载war包以及通过docker容器等快速实现安装部署，可方便web界面配置管理。
• ·消息通知及测试报告︰集成RSS/E-mail通过RSS发布构建结果或当构建完成时通过e-mail通知，生成Unit/TestNG测试报告。
• 分布式构建:支持Jenkins能够让多台计算机一起构建/测试。
• 文件识别:Jenkins能够跟踪哪次构建生成哪些jar，哪次构建使用哪个版本的jar等。
• 丰富的插件支持∶支持扩展插件，你可以开发适合自己团队使用的工具，如git , svn , maven ,docker等。

jenkins的安装和集成环境的基本的配置

• 1)首先，开发人员每天进行代码提交，提交到Git仓库
• 2)然后，Jenkins作为持续集成工具，使用Git工具到Git仓库拉取代码到集成服务器，再配合JDK，Maven等软件完成代码编译，代码测试与审查，测试，打包等工作，在这个过程中每一步出错，都重新再执行━次整个流程。
• 3 )最后，Jenkins把生成的jar或war包分发到测试服务器或者生产服务器，测试人员或用户就可以访问应用。

持续集成环境(1)-Jenkins安装

1）安装JDK

• Jenkins需要依赖JDK，所以先安装JDK1.8
• yum install java-1.8.0-openjdk* -y
• 安装目录为：/usr/lib/jvm

2）获取jenkins安装包

• 下载页面：https://jenkins.io/zh/download/
• 安装文件：jenkins-2.190.3-1.1.noarch.rpm

3）把安装包上传到192.168.66.101服务器，进行安装

• rpm -ivh jenkins-2.190.3-1.1.noarch.rpm

4）修改Jenkins配置

• vi /etc/syscofig/jenkins
• 修改内容如下：
• JENKINS_USER="root"
• JENKINS_PORT="8888"

5）启动Jenkins

• systemctl start jenkins

6）打开浏览器访问

• http://192.168.66.101:8888
• 注意：本服务器把防火墙关闭了，如果开启防火墙，需要在防火墙添加端口

7）获取并输入admin账户密码

• cat /var/lib/jenkins/secrets/initialAdminPassword

8）跳过插件安装

• 因为Jenkins插件需要连接默认官网下载，速度非常慢，而且经过会失败，所以我们暂时先跳过插件安装

9）添加一个管理员账户，并进入Jenkins后台

 持续集成环境(2)-Jenkins插件管理

这样做是为了把Jenkins官方的插件列表下载到本地，接着修改地址文件，替换为国内插件地址

cd /var/lib/jenkins/updates sed -i 's/http:\/\/updates.jenkinsci.org\/download/https:\/\/mirrors.tuna.tsinghua.edu.cn\/jenkins/g' default.json && sed -i 's/http:\/\/www.google.com/https:\/\/www.baidu.com/g' default.json

最后，Manage Plugins点击Advanced，把Update Site改为国内插件下载地址https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json

Sumbit后，在浏览器输入： http://192.168.66.101:8888/restart ，重启Jenkins。

持续集成环境(3)-Jenkins用户权限管理

我们可以利用Role-based Authorization Strategy 插件来管理Jenkins用户权限，安装Role-based Authorization Strategy插件

Global roles（全局角色）：管理员等高级用户可以创建基于全局的角色 Project roles（项目角色）：针对某个或者某些项目的角色 Slave roles（奴隶角色）：节点相关的权限

我们添加以下三个角色：
baseRole：该角色为全局角色。这个角色需要绑定Overall下面的Read权限，是为了给所有用户绑定最基本的Jenkins访问权限。注意：如果不给后续用户绑定这个角色，会报错误：用户名 is  missing the Overall/Read permission
role1：该角色为项目角色。使用正则表达式绑定"itcast.*"，意思是只能操作itcast开头的项目。
role2：该角色也为项目角色。绑定"itheima.*"，意思是只能操作itheima开头的项目。·

创建用户：

在系统管理页面进入 Manage Users

给用户分配角色

• 系统管理页面进入Manage and Assign Roles，点击Assign Roles

绑定规则如下：

• eric用户分别绑定baseRole和role1角色
• jack用户分别绑定baseRole和role2角色

保存。创建项目测试权限:以itcast管理员账户创建两个项目，分别为itcast01和itheima01

持续集成环境(4)-Jenkins凭证管理

凭据可以用来存储需要密文保护的数据库密码、Gitlab密码信息、Docker私有仓库密码等，以便Jenkins可以和这些第三方的应用进行交互。安装Credentials Binding插件,要在Jenkins使用凭证管理功能，需要安装Credentials Binding插件

安装Git插件和Git工具

为了让Jenkins支持从Gitlab拉取源码，需要安装Git插件以及在CentOS7上安装Git工具。

Git插件安装：

CentOS7上安装Git工具：

• yum install git -y 安装
• git --version 安装后查看版本

用户密码类型 

1）创建凭证:Jenkins->凭证->系统->全局凭证->添加凭证

选择"Username with password"，输入Gitlab的用户名和密码，点击"确定"。

2）测试凭证是否可用

创建一个FreeStyle项目：新建Item->FreeStyle Project->确定

找到"源码管理"->"Git"，在Repository URL复制Gitlab中的项目URL

SSH密钥类型

SSH免密登录示意图

 4）测试凭证是否可用:新建"test02"项目->源码管理->Git，这次要使用Gitlab的SSH连接，并且选择SSH凭证

持续集成环境(5)-Maven安装和配置

在Jenkins集成服务器上，我们需要安装Maven来编译和打包项目。
安装Maven

先上传Maven软件到192.168.66.101
tar -xzf apache-maven-3.6.2-bin.tar.gz 解压
mkdir -p /opt/maven 创建目录
mv apache-maven-3.6.2/* /opt/maven 移动文件

配置环境变量

vi /etc/profile
source /etc/profile 配置生效
mvn -v 查找Maven版本

全局工具配置关联JDK和Maven

Jenkins->Global Tool Configuration->JDK->新增JDK，配置如下：

修改Maven的settings.xml

mkdir /root/repo 创建本地仓库目录
vi /opt/maven/conf/settings.xml
本地仓库改为：/root/repo/
添加阿里云私服地址：
alimaven aliyun maven http://maven.aliyun.com/nexus/content/groups/public/ central

测试Maven是否配置成功
使用之前的gitlab密码测试项目，修改配置
 

持续集成环境(6)-Tomcat安装和配置

安装Tomcat8.5
把Tomcat压缩包上传到192.168.66.102服务器

yum install java-1.8.0-openjdk* -y 安装JDK（已完成）
tar -xzf apache-tomcat-8.5.47.tar.gz 解压
mkdir -p /opt/tomcat 创建目录
mv /root/apache-tomcat-8.5.47/* /opt/tomcat 移动文件
/opt/tomcat/bin/startup.sh 启动tomcat

注意：服务器已经关闭了防火墙，所以可以直接访问Tomcat啦。地址为：http://192.168.66.102/8080

但是，后续Jenkins部署项目到Tomcat服务器，需要用到Tomcat的用户，所以修改tomcat以下配置，

添加用户及权限：vi /opt/tomcat/conf/tomcat-users.xml

把上面这行注释掉即可！ 重启Tomcat，访问测试

/opt/tomcat/bin/shutdown.sh 停止
/opt/tomcat/bin/startup.sh 启动

访问： http://192.168.66.102:8080/manager/html ，输入tomcat和tomcat，看到以下页面代表成功啦

jenkins的构建maven项目

enkins中自动构建项目的类型有很多，常用的有以下三种：

• 自由风格软件项目（FreeStyle Project）
• Maven项目（Maven Project）
• 流水线项目（Pipeline Project）

每种类型的构建其实都可以完成一样的构建过程与结果，只是在操作方式、灵活度等方面有所区别，在实际开发中可以根据自己的需求和习惯来选择。（PS：个人推荐使用流水线类型，因为灵活度非常高）。

Jenkins项目构建类型(2)-自由风格项目构建
下面演示创建一个自由风格项目来完成项目的集成过程：拉取代码->编译->打包->部署

拉取代码

1）创建项目

2）配置源码管理，从gitlab拉取代码

编译打包

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

echo "开始编译和打包"
mvn clean package
echo "编译和打包结束"

部署

把项目部署到远程的Tomcat里面

1）安装 Deploy to container插件

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

Jenkins项目构建类型(4)-Pipeline流水线项目构建(*)

Pipeline简介

1）概念

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

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

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

3）如何创建 Jenkins Pipeline呢？

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

安装Pipeline插件

Manage Jenkins->Manage Plugins->可选插件

Pipeline语法快速入门

stages：代表整个流水线的所有执行阶段。通常stages只有1个，里面包含多个stage

stage：代表流水线中的某个阶段，可能出现n个。一般分为拉取代码，编译构建，部署等阶段。

steps：代表一个阶段内需要执行的逻辑。steps里面是shell脚本，git拉取代码，ssh远程发布等任意内容。

2）Scripted Pipeline脚本式-Pipeline

创建项目

• Node：节点，一个 Node 就是一个 Jenkins 节点，Master 或者 Agent，是执行 Step 的具体运行环境，后续讲到Jenkins的Master-Slave架构的时候用到。
• Stage：阶段，一个 Pipeline 可以划分为若干个 Stage，每个 Stage 代表一组操作，比如：Build、Test、Deploy，Stage 是一个逻辑分组的概念。
• Step：步骤，Step 是最基本的操作单元，可以是打印一句话，也可以是构建一个 Docker 镜像，由各类 Jenkins 插件提供，比如命令：sh ‘make’，就相当于我们平时 shell 终端中执行 make 命令一样。

Pipeline Script from SCM：刚才我们都是直接在Jenkins的UI界面编写Pipeline代码，这样不方便脚本维护，建议把Pipeline脚本放在项目中（一起进行版本控制）

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

Jenkins项目构建细节(1)-常用的构建触发器

Jenkins内置4种构建触发器：

• 触发远程构建
• 其他工程构建后触发（Build after other projects are build）
• 定时构建（Build periodically）
• 轮询SCM（Poll SCM）

定时字符串从左往右分别为： 分 时 日 月 周
一些定时表达式的例子：

• 每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

Jenkins项目构建细节(2)-Git hook自动触发构建(*)

刚才我们看到在Jenkins的内置构建触发器中，轮询SCM可以实现Gitlab代码更新，项目自动构建，但是该方案的性能不佳。那有没有更好的方案呢？ 有的。就是利用Gitlab的webhook实现代码push到仓库，立即触发项目自动构建。

Jenkins项目构建细节(3)-Jenkins的参数化构建

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

Jenkins项目构建细节(4)-配置邮箱服务器发送构建结果

Jenkins+SonarQube代码审查(1) - 安装SonarQube

SonaQube简介：SonarQube是一个用于管理代码质量的开放平台，可以快速的定位代码中潜在的或者明显的错误。目前支持java,C#,C/C++,Python,PL/SQL,Cobol,JavaScrip,Groovy等二十几种编程语言的代码质量管理与检测。官网：https://www.sonarqube.org/

安装SonarQube
1）安装MySQL（已完成）
2）安装SonarQube

在MySQL创建sonar数据库

下载sonar压缩包：

https://www.sonarqube.org/downloads/
解压sonar，并设置权限
yum install unzip
unzip sonarqube-6.7.4.zip 解压
mkdir /opt/sonar 创建目录
mv sonarqube-6.7.4/* /opt/sonar 移动文件
useradd sonar 创建sonar用户，必须sonar用于启动，否则报错
chown -R sonar. /opt/sonar 更改sonar目录及文件权限

修改sonar配置文件

vi /opt/sonarqube-6.7.4/conf/sonar.properties

内容如下：

sonar.jdbc.username=root sonar.jdbc.password=Root@123
sonar.jdbc.url=jdbc:mysql://localhost:3306/sonar?
useUnicode=true&characterEncoding=utf8&rewriteBatchedStatements=true&useConfigs=
maxPerformance&useSSL=false

注意：sonar默认监听9000端口，如果9000端口被占用，需要更改。

启动sonar
cd /opt/sonarqube-6.7.4
su sonar ./bin/linux-x86-64/sonar.sh start 启动
su sonar ./bin/linux-x86-64/sonar.sh status 查看状态
su sonar ./bin/linux-x86-64/sonar.sh stop 停止
tail -f logs/sonar.logs 查看日志

访问sonar：http://192.168.66.101:9000

安装SonarQube Scanner插件

Jenkins进行SonarQube配置：Manage Jenkins->Configure System->SonarQube servers

在项目添加SonaQube代码审查（非流水线项目）

添加构建步骤：

# must be unique in a given SonarQube instance
sonar.projectKey=web_demo
# this is the name and version displayed in the SonarQube UI. Was mandatory
prior to SonarQube 6.1.
sonar.projectName=web_demo
sonar.projectVersion=1.0
# Path is relative to the sonar-project.properties file. Replace "\" by "/" on
Windows.
# This property is optional if sonar.modules is set.
sonar.sources=.
sonar.exclusions=**/test/**,**/target/**
sonar.java.source=1.8
sonar.java.target=1.8
# Encoding of the source code. Default is default system encoding
sonar.sourceEncoding=UTF-8

在项目添加SonaQube代码审查（流水线项目）

# must be unique in a given SonarQube instance
sonar.projectKey=web_demo
# this is the name and version displayed in the SonarQube UI. Was mandatory
prior to SonarQube 6.1.
sonar.projectName=web_demo
sonar.projectVersion=1.0
# Path is relative to the sonar-project.properties file. Replace "\" by "/" on
Windows.
# This property is optional if sonar.modules is set.
sonar.sources=.
sonar.exclusions=**/test/**,**/target/**
sonar.java.source=1.8
sonar.java.target=1.8
# Encoding of the source code. Default is default system encoding
sonar.sourceEncoding=UTF-8

2）修改Jenkinsfile，加入SonarQube代码审查阶段

pipeline {
agent any
stages {
stage('拉取代码') {
steps {
checkout([$class: 'GitSCM', branches: [[name: '*/master']],
doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [],
userRemoteConfigs: [[credentialsId: '68f2087f-a034-4d39-a9ff-1f776dd3dfa8', url:
'git@192.168.66.100:itheima_group/web_demo.git']]])
}
} s
tage('编译构建') {
steps {
sh label: '', script: 'mvn clean package'
}
} s
tage('SonarQube代码审查') {
steps{
script {
scannerHome = tool 'sonarqube-scanner'
} w
ithSonarQubeEnv('sonarqube6.7.4') {
sh "${scannerHome}/bin/sonar-scanner"
}
}
} s
tage('项目部署') {
steps {
deploy adapters: [tomcat8(credentialsId: 'afc43e5e-4a4e-4de6-984fb1d5a254e434', path: '', url: 'http://192.168.66.102:8080')], contextPath: null,
war: 'target/*.war'
}
}
} p
ost {
always {
emailext(
subject: '构建通知：${PROJECT_NAME} - Build # ${BUILD_NUMBER} -
${BUILD_STATUS}!',
body: '${FILE,path="email.html"}',
to: '1014671449@qq.com'
)
}
}
}

3）到SonarQube的UI界面查看审查结果

Jenkins+Docker+SpringCloud微服务持续集成

Jenkins+Docker+SpringCloud持续集成流程说明

大致流程说明：

• 1）开发人员每天把代码提交到Gitlab代码仓库
• 2）Jenkins从Gitlab中拉取项目源码，编译并打成jar包，然后构建成Docker镜像，将镜像上传到Harbor私有仓库。
• 3）Jenkins发送SSH远程命令，让生产部署服务器到Harbor私有仓库拉取镜像到本地，然后创建容器。
• 4）最后，用户可以访问到容器

SpringCloud微服务源码概述

项目架构：前后端分离：后端技术栈：SpringBoot+SpringCloud+SpringDataJpa（Spring全家桶）

微服务项目结构：

本地部署(1)-SpringCloud微服务部署

本地运行微服务

• 1）逐一启动微服务
• 2）使用postman测试功能是否可用

环境准备(1)-Docker快速入门

Docker 是一个开源的应用容器引擎，基于 Go 语言 并遵从 Apache2.0 协议开源。Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销极低。Docker容器技术 vs 传统虚拟机技术。

简单一句话总结：Docker技术就是让我们更加高效轻松地将任何应用在Linux服务器部署和使用。

Docker安装

1）卸载旧版本
yum list installed | grep docker 列出当前所有docker的包
yum -y remove docker的包名称 卸载docker包rm -rf /var/lib/docker 删除docker的所有镜像和容器
2）安装必要的软件包
sudo yum install -y yum-utils \ device-mapper-persistent-data \ lvm2
3）设置下载的镜像仓库
sudo yum-config-manager \ --add-repo \ https://download.docker.com/linux/centos/dockerce.repo
4）列出需要安装的版本列表
yum list docker-ce --showduplicates | sort -r
5）安装指定版本（这里使用18.0.1版本）
sudo yum install docker-ce-18.06.1.ce
6）查看版本
docker -v
7）启动Docker
sudo systemctl start docker 启动
sudo systemctl enable docker 设置开机启动
8）添加阿里云镜像下载地址
vi /etc/docker/daemon.json
内容如下：
9）重启Docker
sudo systemctl restart docker

环境准备(3)

Harbor镜像仓库安装及使用

Harbor（港口，港湾）是一个用于存储和分发Docker镜像的企业级Registry服务器。除了Harbor这个私有镜像仓库之外，还有Docker官方提供的Registry。相对Registry，Harbor具有很多优势：

• 1. 提供分层传输机制，优化网络传输 Docker镜像是是分层的，而如果每次传输都使用全量文件(所以用FTP的方式并不适合)，显然不经济。必须提供识别分层传输的机制，以层的UUID为标识，确定传输的对象。
• 2. 提供WEB界面，优化用户体验 只用镜像的名字来进行上传下载显然很不方便，需要有一个用户界面可以支持登陆、搜索功能，包括区分公有、私有镜像。
• 3. 支持水平扩展集群 当有用户对镜像的上传下载操作集中在某服务器，需要对相应的访问压力作分解。
• 4. 良好的安全机制 企业中的开发团队有很多不同的职位，对于不同的职位人员，分配不同的权限，具有更好的安全性

Harbor安装

Harbor需要安装在192.168.66.102上面
1）先安装Docker并启动Docker（已完成）
参考之前的安装过程
2）先安装docker-compose
3）给docker-compose添加执行权限
sudo chmod +x /usr/local/bin/docker-compose
4）查看docker-compose是否安装成功
docker-compose -version
5）下载Harbor的压缩包（本课程版本为：v1.9.2）
https://github.com/goharbor/harbor/releases
6）上传压缩包到linux，并解压
tar -xzf harbor-offline-installer-v1.9.2.tgz
mkdir /opt/harbor
mv harbor/* /opt/harbor
cd /opt/harbor
7）修改Harbor的配置
sudo curl -L https://github.com/docker/compose/releases/download/1.21.2/dockercompose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-composevi harbor.yml
修改hostname和port
hostname: 192.168.66.102
port: 85
8）安装Harbor
./prepare
./install.sh
9）启动Harbor
docker-compose up -d 启动
docker-compose stop 停止
docker-compose restart 重新启动
10）访问Harbor
http://192.168.66.102:85
默认账户密码：admin/Harbor12345

在Harbor创建用户和项目

1）创建项目
Harbor的项目分为公开和私有的：

• 公开项目：所有用户都可以访问，通常存放公共的镜像，默认有一个library公开项目。
• 私有项目：只有授权用户才可以访问，通常存放项目本身的镜像。

我们可以为微服务项目创建一个新的项目：

把镜像上传到Harbor
1）给镜像打上标签
docker tag eureka:v1 192.168.66.102:85/tensquare/eureka:v1
2）推送镜像
docker push 192.168.66.102:85/tensquare/eureka:v1
这时会出现以上报错，是因为Docker没有把Harbor加入信任列表中
3）把Harbor地址加入到Docker信任列表
vi /etc/docker/daemon.json
The push refers to repository [192.168.66.102:85/tensquare/eureka]
Get https://192.168.66.102:85/v2/: http: server gave HTTP response to HTTPS
client需要重启Docker
4）再次执行推送命令，会提示权限不足
需要先登录Harbor，再推送镜像
5）登录Harbor
docker login -u 用户名 -p 密码 192.168.66.102:85
从Harbor下载镜像
需求：在192.168.66.103服务器完成从Harbor下载镜像
1）安装Docker，并启动Docker（已经完成）
2）修改Docker配置
vi /etc/docker/daemon.json
重启docker
3）先登录，再从Harbor下载镜像
docker login -u 用户名 -p 密码 192.168.66.102:85
{ "
registry-mirrors": ["https://zydiol88.mirror.aliyuncs.com"],
"insecure-registries": ["192.168.66.102:85"]
} d
enied: requested access to the resource is denied
WARNING! Using --password via the CLI is insecure. Use --password-stdin.
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store
Login Succeeded

从Harbor下载镜像

需求：在192.168.66.103服务器完成从Harbor下载镜像

1）安装Docker，并启动Docker（已经完成）
2）修改Docker配置
vi /etc/docker/daemon.json

{ "
registry-mirrors": ["https://zydiol88.mirror.aliyuncs.com"],
"insecure-registries": ["192.168.66.102:85"]
}

重启docker
3）先登录，再从Harbor下载镜像
docker login -u 用户名 -p 密码 192.168.66.102:85
{ "
registry-mirrors": ["https://zydiol88.mirror.aliyuncs.com"],
"insecure-registries": ["192.168.66.102:85"]
} d
enied: requested access to the resource is denied
WARNING! Using --password via the CLI is insecure. Use --password-stdin.
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store
Login Succeeded
{ "
registry-mirrors": ["https://zydiol88.mirror.aliyuncs.com"],
"insecure-registries": ["192.168.66.102:85"]
}docker pull 192.168.66.102:85/tensquare/eureka:v1
微服务持续集成(1)-项目代码上传到Gitlab
在IDEA操作即可，参考之前的步骤。包括后台微服务和前端web网站代码

微服务持续集成(1)-项目代码上传到Gitlab

在IDEA操作即可，参考之前的步骤。包括后台微服务和前端web网站代码

微服务持续集成(2)-从Gitlab拉取项目源码

微服务持续集成(3)-提交到SonarQube代码审查

1）创建项目，并设置参数：创建tensquare_back项目，添加两个参数

2）每个项目的根目录下添加sonar-project.properties

# must be unique in a given SonarQube instance
sonar.projectKey=tensquare_zuul
# this is the name and version displayed in the SonarQube UI. Was mandatory
prior to SonarQube 6.1.
sonar.projectName=tensquare_zuul
sonar.projectVersion=1.0
# Path is relative to the sonar-project.properties file. Replace "\" by "/" on
Windows.
# This property is optional if sonar.modules is set.
sonar.sources=.
sonar.exclusions=**/test/**,**/target/**
sonar.java.binaries=.
sonar.java.source=1.8
sonar.java.target=1.8
sonar.java.libraries=**/target/classes/**
# Encoding of the source code. Default is default system encoding
sonar.sourceEncoding=UTF-8

 3）修改Jenkinsfile构建脚本

//gitlab的凭证
def git_auth = "68f2087f-a034-4d39-a9ff-1f776dd3dfa8"
//构建版本的名称
def tag = "latest"
node {
stage('拉取代码') {
checkout([$class: 'GitSCM', branches: [[name: '*/${branch}']],
doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [],
userRemoteConfigs: [[credentialsId: "${git_auth}", url:
'git@192.168.66.100:itheima_group/tensquare_back.git']]])
} s
tage('代码审查') {
def scannerHome = tool 'sonarqube-scanner'
withSonarQubeEnv('sonarqube6.7.4') {
sh """
cd ${project_name}
${scannerHome}/bin/sonar-scanner
"""
}
}
}

微服务持续集成(4)-使用Dockerfile编译、生成镜像

利用dockerfile-maven-plugin插件构建Docker镜像，

1）在每个微服务项目的pom.xml加入dockerfile-maven-plugin插件

<plugin>
    <groupId>com.spotify</groupId>
    <artifactId>dockerfile-maven-plugin</artifactId>
    <version>1.3.6</version>
    <configuration>
    <repository>${project.artifactId}</repository>
      <buildArgs>
          <JAR_FILE>target/${project.build.finalName}.jar</JAR_FILE>
      </buildArgs>
    </configuration>
</plugin>

2）在每个微服务项目根目录下建立Dockerfile文件

#FROM java:8
FROM openjdk:8-jdk-alpine
ARG JAR_FILE
COPY ${JAR_FILE} app.jar
EXPOSE 10086
ENTRYPOINT ["java","-jar","/app.jar"]
#注意：每个项目公开的端口不一样

3）修改Jenkinsfile构建脚本

//gitlab的凭证
def git_auth = "68f2087f-a034-4d39-a9ff-1f776dd3dfa8"
//构建版本的名称
def tag = "latest"
//Harbor私服地址
def harbor_url = "192.168.66.102:85/tensquare/"
node {
stage('拉取代码') {
checkout([$class: 'GitSCM', branches: [[name: '*/${branch}']],
doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [],
userRemoteConfigs: [[credentialsId: "${git_auth}", url:
'git@192.168.66.100:itheima_group/tensquare_back.git']]])
} s
tage('代码审查') {
def scannerHome = tool 'sonarqube-scanner'
withSonarQubeEnv('sonarqube6.7.4') {
sh """
cd ${project_name}
${scannerHome}/bin/sonar-scanner
"""
}
} s
tage('编译，构建镜像') {
//定义镜像名称
def imageName = "${project_name}:${tag}"
//编译，安装公共工程注意：如果出现找不到父工程依赖，需要手动把父工程的依赖上传到仓库中

微服务持续集成(5)-上传到Harbor镜像仓库

1）修改Jenkinsfile构建脚本

/
/gitlab的凭证
def git_auth = "68f2087f-a034-4d39-a9ff-1f776dd3dfa8"
//构建版本的名称
def tag = "latest"
//Harbor私服地址
def harbor_url = "192.168.66.102:85"
//Harbor的项目名称
def harbor_project_name = "tensquare"
//Harbor的凭证
def harbor_auth = "ef499f29-f138-44dd-975e-ff1ca1d8c933"
node {
stage('拉取代码') {
checkout([$class: 'GitSCM', branches: [[name: '*/${branch}']],
doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [],
userRemoteConfigs: [[credentialsId: "${git_auth}", url:
'git@192.168.66.100:itheima_group/tensquare_back.git']]])
} s
tage('代码审查') {
def scannerHome = tool 'sonarqube-scanner'
withSonarQubeEnv('sonarqube6.7.4') {
sh """
cd ${project_name}
${scannerHome}/bin/sonar-scanner
"""
}
} s
tage('编译，构建镜像') {
//定义镜像名称
def imageName = "${project_name}:${tag}"
//编译，安装公共工程
sh "mvn -f tensquare_common clean install"
//编译，构建本地镜像
sh "mvn -f ${project_name} clean package dockerfile:build"
//给镜像打标签
sh "docker tag ${imageName}
${harbor_url}/${harbor_project_name}/${imageName}"2）使用凭证管理Harbor私服账户和密码
先在凭证建立Harbor的凭证，在生成凭证脚本代码
微服务持续集成(6)-拉取镜像和发布应用
//登录Harbor，并上传镜像
withCredentials([usernamePassword(credentialsId: "${harbor_auth}",
passwordVariable: 'password', usernameVariable: 'username')]) {
//登录
sh "docker login -u ${username} -p ${password} ${harbor_url}"
//上传镜像
sh "docker push ${harbor_url}/${harbor_project_name}/${imageName}"
} /
/删除本地镜像
sh "docker rmi -f ${imageName}"
sh "docker rmi -f ${harbor_url}/${harbor_project_name}/${imageName}"
}
}

2）使用凭证管理Harbor私服账户和密码

先在凭证建立Harbor的凭证，在生成凭证脚本代码

微服务持续集成(6)-拉取镜像和发布应用

注意：192.168.66.103服务已经安装Docker并启动

安装 Publish Over SSH 插件，安装以下插件，可以实现远程发送Shell命令

配置远程部署服务器

1）拷贝公钥到远程服务器
ssh-copy-id 192.168.66.103
2）系统配置->添加远程服务器

修改Jenkinsfile构建脚本

添加一个port参数

//gitlab的凭证
def git_auth = "68f2087f-a034-4d39-a9ff-1f776dd3dfa8"
//构建版本的名称
def tag = "latest"//Harbor私服地址
def harbor_url = "192.168.66.102:85"
//Harbor的项目名称
def harbor_project_name = "tensquare"
//Harbor的凭证
def harbor_auth = "ef499f29-f138-44dd-975e-ff1ca1d8c933"
node {
stage('拉取代码') {
checkout([$class: 'GitSCM', branches: [[name: '*/${branch}']],
doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [],
userRemoteConfigs: [[credentialsId: "${git_auth}", url:
'git@192.168.66.100:itheima_group/tensquare_back.git']]])
} s
tage('代码审查') {
def scannerHome = tool 'sonarqube-scanner'
withSonarQubeEnv('sonarqube6.7.4') {
sh """
cd ${project_name}
${scannerHome}/bin/sonar-scanner
"""
}
} s
tage('编译，构建镜像，部署服务') {
//定义镜像名称
def imageName = "${project_name}:${tag}"
//编译并安装公共工程
sh "mvn -f tensquare_common clean install"
//编译，构建本地镜像
sh "mvn -f ${project_name} clean package dockerfile:build"
//给镜像打标签
sh "docker tag ${imageName}
${harbor_url}/${harbor_project_name}/${imageName}"
//登录Harbor，并上传镜像
withCredentials([usernamePassword(credentialsId: "${harbor_auth}",
passwordVariable: 'password', usernameVariable: 'username')]) {
//登录
sh "docker login -u ${username} -p ${password} ${harbor_url}"
//上传镜像
sh "docker push ${harbor_url}/${harbor_project_name}/${imageName}"
} /
/删除本地镜像
sh "docker rmi -f ${imageName}"
sh "docker rmi -f ${harbor_url}/${harbor_project_name}/${imageName}"
//=====以下为远程调用进行项目部署========编写deploy.sh部署脚本
sshPublisher(publishers: [sshPublisherDesc(configName: 'master_server',
transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand:
"/opt/jenkins_shell/deploy.sh $harbor_url $harbor_project_name $project_name
$tag $port", execTimeout: 120000, flatten: false, makeEmptyDirs: false,
noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '',
remoteDirectorySDF: false, removePrefix: '', sourceFiles: '')],
usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])
}
}

编写deploy.sh部署脚本
 

#
! /bin/sh
#接收外部参数
harbor_url=$1
harbor_project_name=$2
project_name=$3
tag=$4
port=$5
imageName=$harbor_url/$harbor_project_name/$project_name:$tag
echo "$imageName"
#查询容器是否存在，存在则删除
containerId=`docker ps -a | grep -w ${project_name}:${tag} | awk '{print $1}'`
if [ "$containerId" != "" ] ; then
#停掉容器
docker stop $containerId
#删除容器
docker rm $containerId
echo "成功删除容器"
fi
#查询镜像是否存在，存在则删除
imageId=`docker images | grep -w $project_name | awk '{print $3}'`
if [ "$imageId" != "" ] ; then
#删除镜像
docker rmi -f $imageId
echo "成功删除镜像"
fi
# 登录Harbor私服
docker login -u itcast -p Itcast123 $harbor_url
# 下载镜像
docker pull $imageName
# 启动容器
docker run -di -p $port:$port $imageName上传deploy.sh文件到/opt/jenkins_shell目录下，且文件至少有执行权限！
chmod +x deploy.sh 添加执行权限
导入数据，测试微服务
微服务持续集成(7)-部署前端静态web网站
安装Nginx服务器
yum install epel-release
yum -y install nginx 安装
修改nginx的端口，默认80，改为9090：
vi /etc/nginx/nginx.conf
还需要关闭selinux，将SELINUX=disabled
setenforce 0 先临时关闭
vi /etc/selinux/config 编辑文件，永久关闭 SELINUX=disabled
启动Nginx
echo "容器启动成功"

上传deploy.sh文件到/opt/jenkins_shell目录下，且文件至少有执行权限！

chmod +x deploy.sh 添加执行权限

微服务持续集成(7)-部署前端静态web网站

安装Nginx服务器

yum install epel-release
yum -y install nginx 安装
修改nginx的端口，默认80，改为9090：
vi /etc/nginx/nginx.conf
    server {
        listen 9090 default_server;
        listen [::]:9090 default_server;
        server_name _;
        root /usr/share/nginx/html;

还需要关闭selinux，将SELINUX=disabled
setenforce 0 先临时关闭
vi /etc/selinux/config 编辑文件，永久关闭 SELINUX=disabled
启动Nginx
systemctl enable nginx 设置开机启动
systemctl start nginx 启动
systemctl stop nginx 停止
systemctl restart nginx 重启
访问：http://192.168.66.103:9090/

 Jenkins拉取Git远程仓库中指定目录至本地指定目录

Jenkins拉取源码是非常实用的操作，比如每天在跑自动化测试前，拉取Git远程仓库中最新的脚本至本地。那么，Jenkins如何拉取Git远程仓库中指定目录至本地指定目录呢？下面来看看具体的设置方法。

Step1：Job源码管理中，选择Git（如无Git选项则需先安装Git插件），输入仓库URL及认证信息。此时已经可以把仓库中所有文件拉取到该Job的工作空间中了，但是还没达到指定目录的要求，不够灵活。

Step2：新增Additional Behaviours，分别选择Sparse Checkout paths（对应想要拉取的Git远程仓库目录）、Check out to a sub-directory（对应拉取后想要存放的本地目录），输入路径后保存即可。

博文参考