Jenkins-自动化构建、测试和部署-学习笔记

最新推荐文章于 2024-06-01 09:00:00 发布
最新推荐文章于 2024-06-01 09:00:00 发布
阅读量2.7k 收藏 21
点赞数 1
分类专栏： docker 文章标签： docker
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fushuaiCSDN/article/details/114209125
版权

来源于黑马程序员jenkins文档笔记

1、Jenkins介绍

Jenkins 是一款流行的开源持续集成（Continuous Integration）工具，广泛用于项目开发，具有自动
化构建、测试和部署等功能。官网： http://jenkins-ci.org/。
Jenkins的特征：
开源的Java语言开发持续集成工具，支持持续集成，持续部署。
易于安装部署配置：可通过yum安装,或下载war包以及通过docker容器等快速实现安装部署，可
方便web界面配置管理。
消息通知及测试报告：集成RSS/E-mail通过RSS发布构建结果或当构建完成时通过e-mail通知，生
成JUnit/TestNG测试报告。
分布式构建：支持Jenkins能够让多台计算机一起构建/测试。
文件识别：Jenkins能够跟踪哪次构建生成哪些jar，哪次构建使用哪个版本的jar等。
丰富的插件支持：支持扩展插件，你可以开发适合自己团队使用的工具，如git，svn，maven，
docker等。

2、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后台
在这里插入图片描述
保存并完成
在这里插入图片描述
开始使用Jenkins
在这里插入图片描述
在这里插入图片描述

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

Jenkins本身不提供很多功能，我们可以通过使用插件来满足我们的使用。例如从Gitlab拉取代码，使用
Maven构建项目等功能需要依靠插件完成。接下来演示如何下载插件。
修改Jenkins插件下载地址
Jenkins国外官方插件地址下载速度非常慢，所以可以修改为国内插件地址：
Jenkins->Manage Jenkins->Manage Plugins，点击Available
在这里插入图片描述
这样做是为了把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改为国内插件下载地址

最后，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。

下载中文汉化插件

Jenkins->Manage Jenkins->Manage Plugins，点击Available，搜索"Chinese"
在这里插入图片描述

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

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

安装Role-based Authorization Strategy插件

在这里插入图片描述
授权策略切换为"Role-Based Strategy"，保存
在这里插入图片描述

创建角色

在系统管理页面进入 Manage and Assign Roles
在这里插入图片描述
点击"Manage Roles"
在这里插入图片描述
Global roles（全局角色）：管理员等高级用户可以创建基于全局的角色 Project roles（项目角色）：
针对某个或者某些项目的角色 Slave roles（奴隶角色）：节点相关的权限
我们添加以下三个角色：
baseRole：该角色为全局角色。这个角色需要绑定Overall下面的Read权限，是为了给所有用户绑
定最基本的Jenkins访问权限。注意：如果不给后续用户绑定这个角色，会报错误：用户名 is
missing the Overall/Read permission
role1：该角色为项目角色。使用正则表达式绑定"itcast."，意思是只能操作itcast开头的项目。
role2：该角色也为项目角色。绑定"itheima."，意思是只能操作itheima开头的项目。
在这里插入图片描述
保存。

创建用户

在系统管理页面进入 Manage Users
在这里插入图片描述
分别创建两个用户：jack和eric
在这里插入图片描述
给用户分配角色
系统管理页面进入Manage and Assign Roles，点击Assign Roles
绑定规则如下：
eric用户分别绑定baseRole和role1角色
jack用户分别绑定baseRole和role2角色
在这里插入图片描述
保存。

创建项目测试权限

以itcast管理员账户创建两个项目，分别为itcast01和itheima01
在这里插入图片描述
结果为：
eric用户登录，只能看到itcast01项目
jack用户登录，只能看到itheima01项目

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

凭据可以用来存储需要密文保护的数据库密码、Gitlab密码信息、Docker私有仓库密码等，以便
Jenkins可以和这些第三方的应用进行交互。

安装Credentials Binding插件

要在Jenkins使用凭证管理功能，需要安装Credentials Binding插件
在这里插入图片描述
安装插件后，左边多了"凭证"菜单，在这里管理所有凭证
在这里插入图片描述
可以添加的凭证有5种：
在这里插入图片描述
Username with password：用户名和密码
SSH Username with private key： 使用SSH用户和密钥
Secret file：需要保密的文本文件，使用时Jenkins会将文件复制到一个临时目录中，再将文件路径
设置到一个变量中，等构建结束后，所复制的Secret file就会被删除。
Secret text：需要保存的一个加密的文本串，如钉钉机器人或Github的api token
Certificate：通过上传证书文件的方式
常用的凭证类型有：Username with password（用户密码）和SSH Username with private key（SSH
密钥）
接下来以使用Git工具到Gitlab拉取项目源码为例，演示Jenkins的如何管理Gitlab的凭证。

安装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
在这里插入图片描述
这时会报错说无法连接仓库！在Credentials选择刚刚添加的凭证就不报错啦
在这里插入图片描述
保存配置后，点击构建”Build Now“ 开始构建项目
在这里插入图片描述
在这里插入图片描述
查看/var/lib/jenkins/workspace/目录，发现已经从Gitlab成功拉取了代码到Jenkins中。
在这里插入图片描述

SSH密钥类型

SSH免密登录示意图
在这里插入图片描述
1）使用root用户生成公钥和私钥

ssh-keygen -t rsa

在/root/.ssh/目录保存了公钥和使用
在这里插入图片描述
id_rsa：私钥文件
id_rsa.pub：公钥文件
2）把生成的公钥放在Gitlab中
以root账户登录->点击头像->Settings->SSH Keys
复制刚才id_rsa.pub文件的内容到这里，点击"Add Key"
在这里插入图片描述
3）在Jenkins中添加凭证，配置私钥
在Jenkins添加一个新的凭证，类型为"SSH Username with private key"，把刚才生成私有文件内容复制过来
在这里插入图片描述
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

export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk
export MAVEN_HOME=/opt/maven
export PATH=$PATH:$JAVA_HOME/bin:$MAVEN_HOME/bin

source /etc/profile 配置生效
mvn -v 查找Maven版本
全局工具配置关联JDK和Maven

Jenkins->Global Tool Configuration->JDK->新增JDK，配置如下：
在这里插入图片描述
Jenkins->Global Tool Configuration->Maven->新增Maven，配置如下：
在这里插入图片描述

添加Jenkins全局变量

Manage Jenkins->Configure System->Global Properties ，添加三个全局变量
JAVA_HOME、M2_HOME、PATH+EXTRA
在这里插入图片描述

修改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密码测试项目，修改配置
在这里插入图片描述
构建->增加构建步骤->Execute Shell
在这里插入图片描述
输入

mvn clean package

在这里插入图片描述
再次构建，如果可以把项目打成war包，代表maven环境配置成功啦！
在这里插入图片描述

持续集成环境(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

配置Tomcat用户角色权限

默认情况下Tomcat是没有配置用户角色权限的
在这里插入图片描述
在这里插入图片描述
但是，后续Jenkins部署项目到Tomcat服务器，需要用到Tomcat的用户，所以修改tomcat以下配置，
添加用户及权限

vi /opt/tomcat/conf/tomcat-users.xml

<tomcat-users>
<role rolename="tomcat"/>
<role rolename="role1"/>
<role rolename="manager-script"/>
<role rolename="manager-gui"/>
<role rolename="manager-status"/>
<role rolename="admin-gui"/>
<role rolename="admin-script"/>
<user username="tomcat" password="tomcat" roles="manager-gui,managerscript,tomcat,admin-gui,admin-script"/>
</tomcat-users>

用户和密码都是：tomcat
注意：为了能够刚才配置的用户登录到Tomcat，还需要修改以下配置

vi /opt/tomcat/webapps/manager/META-INF/context.xml

<!--
<Valve className="org.apache.catalina.valves.RemoteAddrValve"
allow="127\.\d+\.\d+\.\d+|::1|0:0:0:0:0:0:0:1" />
-->

把上面这行注释掉即可！

重启Tomcat，访问测试
/opt/tomcat/bin/shutdown.sh 停止
/opt/tomcat/bin/startup.sh 启动

访问： http://192.168.66.102:8080/manager/html ，输入tomcat和tomcat，看到以下页面代表成功
啦
在这里插入图片描述

3、Jenkins构建Maven项目

Jenkins项目构建类型(1)-Jenkins构建的项目类型介绍

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

自由风格软件项目（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插件实现
在这里插入图片描述
2）添加Tomcat用户凭证
在这里插入图片描述
3）添加构建后操作
在这里插入图片描述
在这里插入图片描述
点击"Build Now"，开始构建过程
在这里插入图片描述
4）部署成功后，访问项目
在这里插入图片描述

演示改动代码后的持续集成

1）IDEA中源码修改并提交到gitlab
2）在Jenkins中项目重新构建
3）访问Tomcat

Jenkins项目构建类型(3)-Maven项目构建

1）安装Maven Integration插件
在这里插入图片描述
2）创建Maven项目
在这里插入图片描述
3）配置项目
拉取代码和远程部署的过程和自由风格项目一样，只是"构建"部分不同
在这里插入图片描述

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

Pipeline简介

1）概念
Pipeline，简单来说，就是一套运行在 Jenkins 上的工作流框架，将原来独立运行于单个或者多个节点
的任务连接起来，实现单个任务难以完成的复杂流程编排和可视化的工作。
2）使用Pipeline有以下好处（来自翻译自官方文档）：
代码：Pipeline以代码的形式实现，通常被检入源代码控制，使团队能够编辑，审查和迭代其传送流
程。 持久：无论是计划内的还是计划外的服务器重启，Pipeline都是可恢复的。 可停止：Pipeline可接
收交互式输入，以确定是否继续执行Pipeline。 多功能：Pipeline支持现实世界中复杂的持续交付要
求。它支持fork/join、循环执行，并行执行任务的功能。 可扩展：Pipeline插件支持其DSL的自定义扩
展 ，以及与其他插件集成的多个选项。
3）如何创建 Jenkins Pipeline呢？
Pipeline 脚本是由 Groovy 语言实现的，但是我们没必要单独去学习 Groovy
Pipeline 支持两种语法：Declarative(声明式)和 Scripted Pipeline(脚本式)语法
Pipeline 也有两种创建方法：可以直接在 Jenkins 的 Web UI 界面中输入脚本；也可以通过创建一
个 Jenkinsfile 脚本文件放入项目源码库中（一般我们都推荐在 Jenkins 中直接从源代码控制(SCM)
中直接载入 Jenkinsfile Pipeline 这种方法）。

安装Pipeline插件

Manage Jenkins->Manage Plugins->可选插件
在这里插入图片描述
安装插件后，创建项目的时候多了“流水线”类型
在这里插入图片描述

Pipeline语法快速入门
1）Declarative声明式-Pipeline

创建项目
在这里插入图片描述
流水线->选择HelloWorld模板
在这里插入图片描述
生成内容如下：

pipeline {
	agent any
		stages {
			stage('Hello') {
				steps {
					echo 'Hello World'
				}
			}
		}
}

stages：代表整个流水线的所有执行阶段。通常stages只有1个，里面包含多个stage
stage：代表流水线中的某个阶段，可能出现n个。一般分为拉取代码，编译构建，部署等阶段。
steps：代表一个阶段内需要执行的逻辑。steps里面是shell脚本，git拉取代码，ssh远程发布等任意内
容。
编写一个简单声明式Pipeline：

pipeline {
	agent any
	stages {
		stage('拉取代码') {
			steps {
				echo '拉取代码'
			}
		}
		stage('编译构建') {
			steps {
				echo '编译构建'
			}
		}
		stage('项目部署') {
			steps {
				echo '项目部署'
			}
		}
	}
}

点击构建，可以看到整个构建过程
在这里插入图片描述

2）Scripted Pipeline脚本式-Pipeline

创建项目
在这里插入图片描述
这次选择"Scripted Pipeline"
在这里插入图片描述

node {
	def mvnHome
	stage('Preparation') { // for display purposes
	}
	stage('Build') {
	}
	stage('Results') {
	}
}

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

node {
	def mvnHome
	stage('拉取代码') { // for display purposes
		echo '拉取代码'
	}
	stage('编译构建') {
		echo '编译构建'
	}
	stage('项目部署') {
		echo '项目部署'
	}
}

构建结果和声明式一样！

脚本式Pipeline可以使用脚本生成器生成

在这里插入图片描述

拉取代码

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']]])
			}
		}
	}
}

编译打包

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']]])
			}
		}
	stage('编译构建') {
		steps {
			sh label: '', script: 'mvn clean package'
		}
	}
	}
}

部署

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']]])
			}
		}
		stage('编译构建') {
			steps {
				sh label: '', script: 'mvn clean package'
			}
		}
		stage('项目部署') {
			steps {
				deploy adapters: [tomcat8(credentialsId: 'afc43e5e-4a4e-4de6-984fb1d5a254e434', path: '', url: 'http://192.168.66.102:8080')], contextPath: null,
war: 'target/*.war'
		}
	}
}
}
Pipeline Script from SCM

刚才我们都是直接在Jenkins的UI界面编写Pipeline代码，这样不方便脚本维护，建议把Pipeline脚本放
在项目中（一起进行版本控制）
1）在项目根目录建立Jenkinsfile文件，把内容复制到该文件中
在这里插入图片描述
把Jenkinsfile上传到Gitlab
2）在项目中引用该文件
在这里插入图片描述

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

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

触发远程构建

在这里插入图片描述

其他工程构建后触发

1）创建pre_job流水线工程
在这里插入图片描述
2）配置需要触发的工程
在这里插入图片描述

定时构建

在这里插入图片描述
定时字符串从左往右分别为： 分 时 日 月 周

一些定时表达式的例子：
每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，是指定时扫描本地代码仓库的代码是否有变更，如果代码有变更就触发项目构建。
在这里插入图片描述
注意：这次构建触发器，Jenkins会定时扫描本地整个项目的代码，增大系统的开销，不建议使用。

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

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

安装Gitlab Hook插件

需要安装两个插件：
Gitlab Hook和GitLab
在这里插入图片描述

Jenkins设置自动构建

在这里插入图片描述
等会需要把生成的webhook URL配置到Gitlab中。

Gitlab配置webhook

1）开启webhook功能
使用root账户登录到后台，点击Admin Area -> Settings -> Network
勾选"Allow requests to the local network from web hooks and services"
在这里插入图片描述
2）在项目添加webhook
点击项目->Settings->Integrations
在这里插入图片描述
注意：以下设置必须完成，否则会报错！
Manage Jenkins->Configure System
在这里插入图片描述

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

有时在项目构建的过程中，我们需要根据用户的输入动态传入一些参数，从而影响整个构建结果，这时
我们可以使用参数化构建。
Jenkins支持非常丰富的参数类型
在这里插入图片描述
接下来演示通过输入gitlab项目的分支名称来部署不同分支项目。

项目创建分支，并推送到Gitlab上

在这里插入图片描述
新建分支：v1，代码稍微改动下，然后提交到gitlab上。
这时看到gitlab上有一个两个分支：master和v1
在这里插入图片描述

在Jenkins添加字符串类型参数

在这里插入图片描述
在这里插入图片描述

改动pipeline流水线代码

在这里插入图片描述

点击Build with Parameters

在这里插入图片描述

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
在这里插入图片描述
默认账户：admin/admin
创建token
在这里插入图片描述
token要记下来后面要使用
0151ae8c548a143eda9253e4334ad030b56047ee

Jenkins+SonarQube代码审查(2) - 实现代码审查

在这里插入图片描述

安装SonarQube Scanner插件

在这里插入图片描述

添加SonarQube凭证

在这里插入图片描述

Jenkins进行SonarQube配置

Manage Jenkins->Configure System->SonarQube servers
在这里插入图片描述

SonaQube关闭审查结果上传到SCM功能

在这里插入图片描述
在项目添加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代码审查（流水线项目）

1）项目根目录下，创建sonar-project.properties文件
在这里插入图片描述

# 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']]])
}
}
stage('编译构建') {
steps {
sh label: '', script: 'mvn clean package'
}
}
stage('SonarQube代码审查') {
steps{
script {
scannerHome = tool 'sonarqube-scanner'
}
withSonarQubeEnv('sonarqube6.7.4') {
sh "${scannerHome}/bin/sonar-scanner"
}
}
}
stage('项目部署') {
steps {
deploy adapters: [tomcat8(credentialsId: 'afc43e5e-4a4e-4de6-984fb1d5a254e434', path: '', url: 'http://192.168.66.102:8080')], contextPath: null,
war: 'target/*.war'
}
}
}
post {
always {
emailext(
subject: '构建通知：${PROJECT_NAME} - Build # ${BUILD_NUMBER} -
${BUILD_STATUS}!',
body: '${FILE,path="email.html"}',
to: '1014671449@qq.com'
)
}
}
}

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

在这里插入图片描述

4、Jenkins+Docker+SpringCloud微服务持续集成(上)

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

在这里插入图片描述
大致流程说明：
1）开发人员每天把代码提交到Gitlab代码仓库
2）Jenkins从Gitlab中拉取项目源码，编译并打成jar包，然后构建成Docker镜像，将镜像上传到
Harbor私有仓库。
3）Jenkins发送SSH远程命令，让生产部署服务器到Harbor私有仓库拉取镜像到本地，然后创建容器。
4）最后，用户可以访问到容器
服务列表(红色的软件为需要安装的软件，黑色代表已经安装)
在这里插入图片描述
SpringCloud微服务源码概述
项目架构：前后端分离
后端技术栈：SpringBoot+SpringCloud+SpringDataJpa（Spring全家桶）
微服务项目结构：
在这里插入图片描述
tensquare_parent：父工程，存放基础配置
tensquare_common：通用工程，存放工具类
tensquare_eureka_server：SpringCloud的Eureka注册中心
tensquare_zuul：SpringCloud的网关服务
tensquare_admin_service：基础权限认证中心，负责用户认证（使用JWT认证）
tensquare_gathering：一个简单的业务模块，活动微服务相关逻辑

数据库结构：
在这里插入图片描述
tensquare_user：用户认证数据库，存放用户账户数据。对应tensquare_admin_service微服务
tensquare_gathering：活动微服务数据库。对应tensquare_gathering微服务
微服务配置分析：
tensquare_eureka
tensquare_zuul
tensquare_admin_service
tensquare_gathering

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

本地运行微服务

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

本地部署微服务

1）SpringBoot微服务项目打包
必须导入该插件

<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>

打包后在target下产生jar包
2）本地运行微服务的jar包

java -jar xxx.jar

3）查看效果

本地部署(2)-前端静态web网站

前端技术栈：NodeJS+VueJS+ElementUI
使用Visual Studio Code打开源码
1）本地运行

npm run dev

2）打包静态web网站

npm run build

打包后，产生dist目录的静态文件
3）部署到nginx服务器
把dist目录的静态文件拷贝到nginx的html目录，启动nginx
4）启动nginx，并访问

环境准备(1)-Docker快速入门(请查阅我的docker笔记)

Docker简介

Docker 是一个开源的应用容器引擎，基于 Go 语言 并遵从 Apache2.0 协议开源。
Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流
行的 Linux 机器上，也可以实现虚拟化。
容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销
极低。
在这里插入图片描述
简单一句话总结：Docker技术就是让我们更加高效轻松地将任何应用在Linux服务器部署和使用。

环境准备(2)-Dockerfile镜像脚本快速入门

Dockerfile简介

Dockerfile其实就是我们用来构建Docker镜像的源码，当然这不是所谓的编程源码，而是一些命令的组
合，只要理解它的逻辑和语法格式，就可以编写Dockerfile了。
简单点说，Dockerfile的作用：它可以让用户个性化定制Docker镜像。因为工作环境中的需求各式各
样，网络上的镜像很难满足实际的需求。

Dockerfile常见命令

在这里插入图片描述

RUN、CMD、ENTRYPOINT的区别？

RUN：用于指定 docker build 过程中要运行的命令，即是创建 Docker 镜像（image）的步骤
CMD：设置容器的启动命令， Dockerfile 中只能有一条 CMD 命令，如果写了多条则最后一条生效，
CMD不支持接收docker run的参数。
ENTRYPOINT：入口程序是容器启动时执行的程序， docker run 中最后的命令将作为参数传递给入口
程序 ，ENTRYPOINY类似于 CMD 指令，但可以接收docker run的参数 。

以下是mysql官方镜像的Dockerfile示例：
FROM oraclelinux:7-slim
ARG MYSQL_SERVER_PACKAGE=mysql-community-server-minimal-5.7.28
ARG MYSQL_SHELL_PACKAGE=mysql-shell-8.0.18
# Install server
RUN yum install -y https://repo.mysql.com/mysql-community-minimal-releaseel7.rpm \
https://repo.mysql.com/mysql-community-release-el7.rpm \
&& yum-config-manager --enable mysql57-server-minimal \
&& yum install -y \
$MYSQL_SERVER_PACKAGE \
$MYSQL_SHELL_PACKAGE \
libpwquality \
&& yum clean all \
&& mkdir /docker-entrypoint-initdb.d
VOLUME /var/lib/mysql
COPY docker-entrypoint.sh /entrypoint.sh
COPY healthcheck.sh /healthcheck.sh
ENTRYPOINT ["/entrypoint.sh"]
HEALTHCHECK CMD /healthcheck.sh
EXPOSE 3306 33060
CMD ["mysqld"]
使用Dockerfile制作微服务镜像

我们利用Dockerfile制作一个Eureka注册中心的镜像
1）上传Eureka的微服务jar包到linux
2）编写Dockerfile

FROM openjdk:8-jdk-alpine
ARG JAR_FILE
COPY ${JAR_FILE} app.jar
EXPOSE 10086
ENTRYPOINT ["java","-jar","/app.jar"]

3）构建镜像

docker build --build-arg JAR_FILE=tensquare_eureka_server-1.0-SNAPSHOT.jar -t eureka:v1 .

4）查看镜像是否创建成功

docker images

5）创建容器

docker run -i --name=eureka -p 10086:10086 eureka:v1

6）访问容器

环境准备(3)-Harbor镜像仓库安装及使用

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

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-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的配置

vi 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

在这里插入图片描述
3）把Harbor地址加入到Docker信任列表

vi /etc/docker/daemon.json

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

需要重启Docker
4）再次执行推送命令，会提示权限不足

denied: requested access to the resource is denied

需要先登录Harbor，再推送镜像
5）登录Harbor

docker login -u 用户名 -p 密码 192.168.66.102:85

在这里插入图片描述

从Harbor下载镜像

在这里插入图片描述

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

在IDEA操作即可，参考之前的步骤。包括后台微服务和前端web网站代码
在这里插入图片描述

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

1）创建Jenkinsfile文件
在这里插入图片描述

//gitlab的凭证
def git_auth = "68f2087f-a034-4d39-a9ff-1f776dd3dfa8"
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']]])
}
}

2）拉取Jenkinsfile文件
在这里插入图片描述

微服务持续集成(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

注意：修改sonar.projectKey和sonar.projectName
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']]])
}
stage('代码审查') {
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']]])
}
stage('代码审查') {
def scannerHome = tool 'sonarqube-scanner'
withSonarQubeEnv('sonarqube6.7.4') {
sh """
cd ${project_name}
${scannerHome}/bin/sonar-scanner
"""
}
}
stage('编译，构建镜像') {
//定义镜像名称
def imageName = "${project_name}:${tag}"
//编译，安装公共工程
sh "mvn -f tensquare_common clean install"
//编译，构建本地镜像
sh "mvn -f ${project_name} clean package dockerfile:build"
}
}

注意：如果出现找不到父工程依赖，需要手动把父工程的依赖上传到仓库中

微服务持续集成(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']]])
}
stage('代码审查') {
def scannerHome = tool 'sonarqube-scanner'
withSonarQubeEnv('sonarqube6.7.4') {
sh """
cd ${project_name}
${scannerHome}/bin/sonar-scanner
"""
}
}
stage('编译，构建镜像') {
//定义镜像名称
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}"
}
}

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']]])
}
stage('代码审查') {
def scannerHome = tool 'sonarqube-scanner'
withSonarQubeEnv('sonarqube6.7.4') {
sh """
cd ${project_name}
${scannerHome}/bin/sonar-scanner
"""
}
}
stage('编译，构建镜像，部署服务') {
//定义镜像名称
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}"
//=====以下为远程调用进行项目部署========
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
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/

安装NodeJS插件

在这里插入图片描述

Jenkins配置Nginx服务器

Manage Jenkins->Global Tool Configuration
在这里插入图片描述

创建前端流水线项目

在这里插入图片描述
在这里插入图片描述

建立Jenkinsfile构建脚本
//gitlab的凭证
def git_auth = "68f2087f-a034-4d39-a9ff-1f776dd3dfa8"
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_front.git']]])
}
stage('打包，部署网站') {
//使用NodeJS的npm进行打包
nodejs('nodejs12'){
sh '''
npm install
npm run build
'''
}
//=====以下为远程调用进行项目部署========
sshPublisher(publishers: [sshPublisherDesc(configName: 'master_server',
transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: '',
execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes:
false, patternSeparator: '[, ]+', remoteDirectory: '/usr/share/nginx/html',
remoteDirectorySDF: false, removePrefix: 'dist', sourceFiles: 'dist/**')],
usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])
}
}

完成后，访问：http://192.168.66.103:9090 进行测试。

5、Jenkins+Docker+SpringCloud微服务持续集成(下)

Jenkins+Docker+SpringCloud部署方案优化

上面部署方案存在的问题：
1）一次只能选择一个微服务部署
2）只有一台生产者部署服务器
3）每个微服务只有一个实例，容错率低
优化方案：
1）在一个Jenkins工程中可以选择多个微服务同时发布
2）在一个Jenkins工程中可以选择多台生产服务器同时部署
3）每个微服务都是以集群高可用形式部署

Jenkins+Docker+SpringCloud集群部署流程说明

在这里插入图片描述

修改所有微服务配置

注册中心配置(*)
yml 文件,下面配置代码错误,没有缩进

# 集群版
spring:
application:
name: EUREKA-HA
---
server:
port: 10086
spring:
# 指定profile=eureka-server1
profiles: eureka-server1
eureka:
instance:
# 指定当profile=eureka-server1时，主机名是eureka-server1
hostname: 192.168.66.103
client
service-url:
# 将自己注册到eureka-server1、eureka-server2这个Eureka上面去
defaultZone:
http://192.168.66.103:10086/eureka/,http://192.168.66.104:10086/eureka/
---
server:
port: 10086
spring:
profiles: eureka-server2
eureka:
instance:
hostname: 192.168.66.104
client:
service-url:
defaultZone:
http://192.168.66.103:10086/eureka/,http://192.168.66.104:10086/eureka/

在启动微服务的时候，加入参数: spring.profiles.active 来读取对应的配置

其他微服务配置

除了Eureka注册中心以外，其他微服务配置都需要加入所有Eureka服务

# Eureka配置
eureka:
client:
service-url:
defaultZone:
http://192.168.66.103:10086/eureka,http://192.168.66.104:10086/eureka # Eureka访
问地址
instance:
prefer-ip-address: true

把代码提交到Gitlab中

设计Jenkins集群项目的构建参数

1）安装Extended Choice Parameter插件
支持多选框
在这里插入图片描述
2）创建流水线项目
在这里插入图片描述
3）添加参数
字符串参数：分支名称
在这里插入图片描述
多选框：项目名称
在这里插入图片描述
在这里插入图片描述

tensquare_eureka_server@10086,tensquare_zuul@10020,tensquare_admin_service@9001,
tensquare_gathering@9002

在这里插入图片描述
最后效果：
在这里插入图片描述

完成微服务构建镜像，上传私服

//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 {
//把选择的项目信息转为数组
def selectedProjects = "${project_name}".split(',')
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_cluster.git']]])
}
stage('代码审查') {
def scannerHome = tool 'sonarqube-scanner'
withSonarQubeEnv('sonarqube6.7.4') {
for(int i=0;i<selectedProjects.size();i++){
//取出每个项目的名称和端口
def currentProject = selectedProjects[i];
//项目名称
def currentProjectName = currentProject.split('@')[0]
//项目启动端口
def currentProjectPort = currentProject.split('@')[1]
sh """
cd ${currentProjectName}
${scannerHome}/bin/sonar-scanner
"""
echo "${currentProjectName}完成代码审查"
}
}
}
stage('编译，构建镜像，部署服务') {
//编译并安装公共工程
sh "mvn -f tensquare_common clean install"
for(int i=0;i<selectedProjects.size();i++){
//取出每个项目的名称和端口
def currentProject = selectedProjects[i];
//项目名称
def currentProjectName = currentProject.split('@')[0]
//项目启动端口
def currentProjectPort = currentProject.split('@')[1]
//定义镜像名称
def imageName = "${currentProjectName}:${tag}"
//编译，构建本地镜像
sh "mvn -f ${currentProjectName} 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}"
//=====以下为远程调用进行项目部署========
//sshPublisher(publishers: [sshPublisherDesc(configName:
'master_server', transfers: [sshTransfer(cleanRemote: false, excludes: '',
execCommand: "/opt/jenkins_shell/deployCluster.sh $harbor_url
$harbor_project_name $currentProjectName $tag $currentProjectPort", execTimeout:
120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false,
patternSeparator: '[, ]+', remoteDirectory: '', remoteDirectorySDF: false,
removePrefix: '', sourceFiles: '')], usePromotionTimestamp: false,
useWorkspaceInPromotion: false, verbose: false)])
echo "${currentProjectName}完成编译，构建镜像"
}
}
}

完成微服务多服务器远程发布

1）配置远程部署服务器
拷贝公钥到远程服务器

ssh-copy-id 192.168.66.104

系统配置->添加远程服务器
在这里插入图片描述
2）修改Docker配置信任Harbor私服地址

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

重启Docker
3）添加参数
多选框：部署服务器
在这里插入图片描述
在这里插入图片描述
最终效果：
在这里插入图片描述
4）修改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 {
//把选择的项目信息转为数组
def selectedProjects = "${project_name}".split(',')
//把选择的服务区信息转为数组
def selectedServers = "${publish_server}".split(',')
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_cluster.git']]])
}
stage('代码审查') {
def scannerHome = tool 'sonarqube-scanner'
withSonarQubeEnv('sonarqube6.7.4') {
for(int i=0;i<selectedProjects.size();i++){
//取出每个项目的名称和端口
def currentProject = selectedProjects[i];
//项目名称
def currentProjectName = currentProject.split('@')[0]
//项目启动端口
def currentProjectPort = currentProject.split('@')[1]
sh """
cd ${currentProjectName}
${scannerHome}/bin/sonar-scanner
"""
echo "${currentProjectName}完成代码审查"
}
}
}
stage('编译，构建镜像，部署服务') {
//编译并安装公共工程
sh "mvn -f tensquare_common clean install"
for(int i=0;i<selectedProjects.size();i++){
//取出每个项目的名称和端口
def currentProject = selectedProjects[i];
//项目名称
def currentProjectName = currentProject.split('@')[0]
//项目启动端口
def currentProjectPort = currentProject.split('@')[1]
//定义镜像名称
def imageName = "${currentProjectName}:${tag}"
//编译，构建本地镜像
sh "mvn -f ${currentProjectName} 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}"
//=====以下为远程调用进行项目部署========
for(int j=0;j<selectedServers.size();j++){
//每个服务名称
def currentServer = selectedServers[j]
//添加微服务运行时的参数：spring.profiles.active
def activeProfile = "--spring.profiles.active="
if(currentServer=="master_server"){
activeProfile = activeProfile+"eureka-server1"
}else if(currentServer=="slave_server1"){
activeProfile = activeProfile+"eureka-server2"
}
sshPublisher(publishers: [sshPublisherDesc(configName:
"${currentServer}", transfers: [sshTransfer(cleanRemote: false, excludes: '',
execCommand: "/opt/jenkins_shell/deployCluster.sh $harbor_url
$harbor_project_name $currentProjectName $tag $currentProjectPort
$activeProfile", execTimeout: 120000, flatten: false, makeEmptyDirs: false,
noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '',
remoteDirectorySDF: false, removePrefix: '', sourceFiles: '')],
usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])
}
echo "${currentProjectName}完成编译，构建镜像"
}
}
}

5）编写deployCluster.sh部署脚本

#! /bin/sh
#接收外部参数
harbor_url=$1
harbor_project_name=$2
project_name=$3
tag=$4
port=$5
profile=$6
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 $profile
echo "容器启动成功"

6）集群效果

Nginx+Zuul集群实现高可用网关

在这里插入图片描述
1）安装Nginx（已完成）
2）修改Nginx配置

vi /etc/nginx/nginx.conf

内容如下：

upstream zuulServer{
server 192.168.66.103:10020 weight=1;
server 192.168.66.104:10020 weight=1;
}
server {
listen 85 default_server;
listen [::]:85 default_server;
server_name _;
root /usr/share/nginx/html;
# Load configuration files for the default server block.
include /etc/nginx/default.d/*.conf;
location / {
### 指定服务器负载均衡服务器
proxy_pass http://zuulServer/;
}

3）重启Nginx： systemctl restart nginx
4）修改前端Nginx的访问地址
在这里插入图片描述

6、基于Kubernetes/K8S构建Jenkins持续集成平台(上)

Jenkins的Master-Slave分布式构建

什么是Master-Slave分布式构建
在这里插入图片描述
Jenkins的Master-Slave分布式构建，就是通过将构建过程分配到从属Slave节点上，从而减轻Master节
点的压力，而且可以同时构建多个，有点类似负载均衡的概念。

如何实现Master-Slave分布式构建

1）开启代理程序的TCP端口
Manage Jenkins -> Configure Global Security
在这里插入图片描述
2）新建节点
Manage Jenkins—Manage Nodes—新建节点
在这里插入图片描述
在这里插入图片描述
有两种在Slave节点连接Master节点的方法
在这里插入图片描述
我们选择第二种：
2）安装和配置节点
下载agent.jar，并上传到Slave节点，然后执行页面提示的命令：

java -jar agent.jar -jnlpUrl http://192.168.66.101:8888/computer/slave1/slaveagent.jnlp -secret
f2ecbb99e0c81331e8b7a7917a94d478f39cb9763fc6c66d9a9741c61f9ae6d6 -workDir
"/root/jenkins"

刷新页面
在这里插入图片描述
3）测试节点是否可用
自由风格和Maven风格的项目：
在这里插入图片描述
流水线风格的项目：

node('slave1') {
stage('check out') {
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/tensquare_back_cluster.git']]])
}
}

Kubernetes实现Master-Slave分布式构建方案

传统Jenkins的Master-Slave方案的缺陷

Master节点发生单点故障时，整个流程都不可用了
每个 Slave节点的配置环境不一样，来完成不同语言的编译打包等操作，但是这些差异化的配置导
致管理起来非常不方便，维护起来也是比较费劲
资源分配不均衡，有的 Slave节点要运行的job出现排队等待，而有的Slave节点处于空闲状态
资源浪费，每台 Slave节点可能是实体机或者VM，当Slave节点处于空闲状态时，也不会完全释放
掉资源
以上种种问题，我们可以引入Kubernates来解决！

Kubernates简介

Kubernetes（简称，K8S）是Google开源的容器集群管理系统，在Docker技术的基础上，为容器化的
应用提供部署运行、资源调度、服务发现和动态伸缩等一系列完整功能，提高了大规模容器集群管理的
便捷性。 其主要功能如下：
使用Docker对应用程序包装(package)、实例化(instantiate)、运行(run)。
以集群的方式运行、管理跨机器的容器。以集群的方式运行、管理跨机器的容器。
解决Docker跨机器容器之间的通讯问题。解决Docker跨机器容器之间的通讯问题。
Kubernetes的自我修复机制使得容器集群总是运行在用户期望的状态。

Kubernates+Docker+Jenkins持续集成架构图

在这里插入图片描述
大致工作流程：手动/自动构建 -> Jenkins 调度 K8S API -＞动态生成 Jenkins Slave pod -＞ Slave pod
拉取 Git 代码／编译／打包镜像 -＞推送到镜像仓库 Harbor -＞ Slave 工作完成，Pod 自动销毁 -＞部署
到测试或生产 Kubernetes平台。（完全自动化，无需人工干预）

Kubernates+Docker+Jenkins持续集成方案好处

服务高可用：
当 Jenkins Master 出现故障时，Kubernetes 会自动创建一个新的 Jenkins Master容器，并且将 Volume 分配给新创建的容器，保证数据不丢失，从而达到集群服务高可用。

动态伸缩，合理使用资源：
每次运行 Job 时，会自动创建一个 Jenkins Slave，Job 完成后，Slave自动注销并删除容器，资源自动释放，而且 Kubernetes 会根据每个资源的使用情况，动态分配Slave 到空闲的节点上创建，降低出现因某节点资源利用率高，还排队等待在该节点的情况。

扩展性好：
当 Kubernetes 集群的资源严重不足而导致 Job 排队等待时，可以很容易的添加一个Kubernetes Node 到集群中，从而实现扩展。

Kubeadm安装Kubernetes

Kubernetes的架构

在这里插入图片描述
API Server：用于暴露Kubernetes API，任何资源的请求的调用操作都是通过kube-apiserver提供的接口进行的。

Etcd：是Kubernetes提供默认的存储系统，保存所有集群数据，使用时需要为etcd数据提供备份计
划。

Controller-Manager：作为集群内部的管理控制中心，负责集群内的Node、Pod副本、服务端点（Endpoint）、命名空间（Namespace）、服务账号（ServiceAccount）、资源定额（ResourceQuota）的管理，当某个Node意外宕机时，Controller Manager会及时发现并执行自动化修复流程，确保集群始终处于预期的工作状态。

Scheduler：监视新创建没有分配到Node的Pod，为Pod选择一个Node。

Kubelet：负责维护容器的生命周期，同时负责Volume和网络的管理

Kube proxy：是Kubernetes的核心组件，部署在每个Node节点上，它是实现Kubernetes Service的通信与负载均衡机制的重要组件。
安装环境说明

努力敲代码买猪脚啃
关注
  • 1
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Jenkins做测试环境的自动化构建与部署-笔记
he_hezu的博客
01-11 320
---------Jenkins做测试环境的自动化构建与部署------------- 【Jenkins基础】 【Jenkins准备（在一台linux上安装）】 1.下载Jenkins War包： https://get.jenkins.io/war/2.272/jenkins.war 把war包放在linux文件夹下 在该目录下运行 2.运行Jenkins： java -jar jenkins.war 网页打开 localhost:8080 or ip:8080 粘贴linux命令窗的Jenki
Jenkins相关问题及答案（2024）
qq_43012298的博客
01-11 1297
作业定义了应该发生的事情，像是蓝图或者配方，它规定了构建所需遵循的步骤和操作。构建则是这个定义（作业）的一次具体执行，当 Jenkins 按照作业的规定进行自动化操作时，它就创建了一个构建。在 Jenkins 的日常使用中，理解这两个概念之间的关系是至关重要的，因为你可能需要配置作业以契合不同项目的需要，同时分析构建的结果以确保持续集成和持续部署的流程符合软件开发的质量和速度要求。5、如何安装和配置Jenkins？要安装和配置 Jenkins，你需要遵循一系列详细的步骤。
Jira+Jenkins+Gitlab自动化交付实践
黑色鲸鱼的博客
10-02 2180
Jira 可以帮助团队规划、分配、跟踪、报告和管理工作JiraSoftware：专为敏捷开发团队中的各个成员以及其他人员所设计，从而规划、跟踪和交付世界一流的软件。
jenkins本地打包远程部署项目
littleschemer的博客
06-01 1172
Jenkins是一款开源的持续集成工具，用于自动化构建、测试和部署软件项目。本文演示如何使用jenkins，在本地代码更新打包代码，然后再发送到远程进行部署。
持续集成Jenkins （四）Jenkins+git+maven项目构建、自动化部署
喜欢历史的码农
02-09 6155
1.2 Jenkins 配置插件 Git 在仪表盘选择Manage Jenkins>>Plugin Manager>>进入如下页面，可以选择可选的插件，安装完成后的插件在installed里面可以看到，我这里已经安装了在后面的构建过程可以看到，使用的就是 /usr/bin/git 去拉取远程 git 仓库。这里选择Git，然后如图配置：输入仓库地址，填入验证信息。其他按需更改。登录gitee账号选择仓库地址获取： 2.4 配置Credentials当前使用 username+password类型，并填写访
【黑马头条之项目部署_持续集成Jenkins】
蛋饼吧的博客
08-31 1224
Jenkins 是一款流行的开源持续集成（Continuous Integration）工具，广泛用于项目开发，具有自动化构建、测试和部署等功能。官网：Jenkins。Jenkins的特征：开源的 Java语言开发持续集成工具，支持持续集成，持续部署。易于安装部署配置：可通过 yum安装,或下载war包以及通过docker容器等快速实现安装部署，可方便web界面配置管理。
jenkins针对不同的项目组对用户进行权限分配
diangan2660的博客
04-14 357
因jenkins上存有de（开发）、te（测试）等三个不同环境的项目，同时因为项目需求，需要对不同的开发及测试人员配置不同的jenkins权限，即以项目为单位，对不同人员进行不同权限配置，要求如下： 1、项目都以 jenkins 开头，分别以-de、-te 结尾，根据三类结尾可把项目分成开发、测试 项目，同时分别对应不同的项目需求人员； 2、开发人员登录jenkins只能查看并构建d...
Jenkins进阶系列之——14配置Jenkins用户和权限
denglei3072的博客
01-16 918
今天给大家说说使用Jenkins专有用户数据库的配置，和一些常用的权限配置。 配置用户注册 在已运行的Jenkins主页中，点击左侧的系统管理—>ConfigureGlobalSecurity进入如下界面： 设置如上图，保存后系统管理中就出现管理用户的选项。页面右上角也会出现登录/注册的选项。 点击注册： 点击signup按钮，提示你现在已...
jenkins-the-definitive-guide:詹金斯读书笔记
05-02
这本书将会教你如何使用Jenkins来使你的构建，集成，发布，开发流程自动化，证明了CI可以节省你的时间，金钱和解决你许多头疼的问题。通过本书你可以：学习如何安装，配置和使你的Jenkins服务器更加安全；组织和监视...
jenkins-course:这是Jenkins关于Udemy培训的所有资源的资源库
04-13
Jenkins是一款开源的持续集成和持续部署工具，广泛应用于自动化各种软件开发任务，如构建、测试和部署。它支持多种语言和框架，使得开发团队能够实现DevOps的最佳实践，提高软件开发效率和质量。 **Jenkins与DevOps...
Java很好的学习笔记部署环境
最新发布
06-21
10. **持续集成/持续部署（CI/CD）**：通过Jenkins或GitLab CI/CD，可以自动化构建、测试和部署过程，确保代码的稳定性和一致性。学习如何配置CI/CD流程，能提高团队的开发效率。 以上只是部分内容概览，实际的学习...
【Jenkins学习笔记】玩转持续集成与持续交付
01-27
通过搭建Jenkins与Git的持续集成环境，我们可以实现从创建项目、版本控制到自动化构建和部署的无缝衔接。具体步骤包括在Linux虚拟机上安装必要的组件（如JDK、Tomcat、Maven和Jenkins），设置版本控制子系统（如...
k8s1.16的jenkins部署java项目cicd(cd手动)-kubernetes安装包和详细文档笔记整理
05-28
接下来，Jenkins作为流行的CI/CD工具，能够自动化构建、测试和发布软件。在Java项目中，Jenkins可以集成Git仓库，监听代码变更，一旦有新的提交，它会自动触发构建过程。在这个教程中，你将学习如何在Kubernetes集群...
在Jenkins中使用插件进行项目权限管理
bluemoon10086的博客
02-28 9379
在Jenkins中使用插件进行项目权限管理1、先安装插件Role-based Authorization Strategy2、Role-based Authorization Strategy插件的使用：在Configure Global Security 中启用Role-Base Strategy这样在Jenkins的系统管理中可以看到“Manage and Assign Roles”进入后会看...
jenkins-2-3分钟学会汉化
有话好好说vx：GoGsxl
01-01 184
前言 唉呀！记得刚接触 jenkins 的时候，是开发交给我们用的怎样构建，一开打jenkins~怎么都是英文的（小龙英文不好....） 不过我们可以汉化，一点也不影响使用，随时也能切换中英文及繁体。 一、插件安装 1、Manage Jenkins -->Manage Plugins -->Available 先下载好此插件，搜索：Locale 2、继续下载插件：Lo...
Jenkins 安装插件失败或者找不到按钮
weixin_45785984的博客
09-24 1345
Jenkins安装插件的失败，是因为Jenkins本身缺少了插件，需要去安装缺少的插件，我这里缺少的是Pipeline:Step API 和 Instance identity这两个插件，我们可以通过在Jenkins中的manage-jenkins-plugins中去下载这个插件，缺少其他的插件也是一样的，安装插件的按钮找不到的原因其实是按钮本身背景颜色与网页背景颜色一致了，全选网页的时候，按钮就会显示出来
使用Jenkins实现自动构建
weixin_43451374的博客
07-17 573
写在前面的话，搭建过程中有任何问题，及时百度，没有解决不了的问题，今天搞不定，就明天搞，要坚信没有搞不定的问题。 搭建过程主要在三个地方操作 服务器配置 jenkins配置 github配置 服务器配置 1.准备jar包 jenkins，tomcat，jdk，maven，git，这些jar包官网都有，不会下载的自行百度，就当学习了，我把jar包放在了 /usr/local/...
【devops】jira问题变更触发jenkins自动构建
u011360145的博客
04-08 1614
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、安装jira（k8s）二、安装jenkins （k8s）三、配置1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 通过jira工作流变更，触发jenkins自动构建 提示：以下是本篇文章正文内容，下面案例可供参考 一、安装jira（k8s） 二、安装jenkins （k8s） 三、配置 1.引入库 代码如下（示例）： import numpy as np import pandas as pd.
基于Jira的运维发布平台的设计与实现
乔克叔叔的博客
05-31 470
基于Jira的运维发布平台的设计与实现 作者：乔克 公众号：运维开发故事 上线发布是运维的日常工作，常见的发布方式有： 手动发布 Jenkins发布平台 Gitlab CI … 除此之外还有需要开源软件，他们都有非常不错的发布管理功能。 面临的问题 作为运维人员，上线发布是必不可少的一环，一个正常的发布流程是怎么样的？ 需求方提发布任务，走发布流程 供应方执行发布上线 环节看似简单，但是中间其实是有断层的。一般企业在走上线流程都是通过一些公共渠道，比如邮件、钉钉、飞书的流程，这些都很难和运维执
Jenkins参数化构建与部署实战指南
参数化构建是Jenkins的一项重要功能，它允许在构建过程中引入变量，这些变量可以在运行时由用户输入或者通过其他方式动态设定，从而实现灵活的自动化构建和部署策略。这对于多环境、多版本的项目尤其有用，能够确保...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值