# Jenkins Nexus 实践
# 1. Nexus 制品库介绍
# 1.1 Nexus 基本介绍
Nexus 是⼀个制品库管理⼯具,类似于 yum 仓库。它能够加速项⽬的构建过程,提⾼团队的开发效率。Nexus 提供了⼀个集中式的制品库,开发⼈员可以通过⼿动或⾃动的⽅式将编译⽣成的 jar、war 包等上传⾄ Nexus。这样⼀来,其他开发⼈员或团队就能⽅便地获取和使⽤这些制品,避免了重复构建和下载,从⽽节省了时间和资源。
官⽅站点: https://www.sonatype.com/products/sonatype-nexus-repository
# 1.2 Nexus 安装
1、安装 java 环境
OracleJdk 下载地址:https://www.oracle.com/java/technologies/downloads/#java11
[root@nexus ~]# wget https://www.oracle.com/java/technologies/downloads/#license-lightbox | |
[root@nexus ~]# tar xf jdk-11.0.29_linux-x64_bin.tar.gz -C /usr/local/ | |
[root@nexus ~]# ln -s /usr/local/jdk-11.0.29/ /usr/local/jdk | |
#添加环境变量 | |
[root@nexus ~]# cat /etc/profile.d/jdk.sh | |
export JAVA_HOME=/usr/local/jdk | |
export PATH=$PATH:$JAVA_HOME/bin | |
export JRE_HOME=$JAVA_HOME/jre | |
export CLASSPATH=$JAVA_HOME/lib/:$JRE_HOME/lib/ | |
[root@nexus ~]# source /etc/profile | |
[root@nexus ~]# java -version |
2、安装 Nexus
[root@nexus ~]# wget https://download.sonatype.com/nexus/3/nexus-3.67.1-01-java11-unix.tar.gz | |
[root@nexus ~]# tar xf nexus-3.67.1-01-java11-unix.tar.gz -C /usr/local/ | |
[root@nexus ~]# ln -s /usr/local/nexus-3.67.1-01/ /usr/local/nexus |
3、配置 Nexus
[root@nexus ~]# vim /usr/local/nexus/bin/nexus.rc | |
run_as_user="root" # nexus 进程运⾏⽤户 | |
[root@nexus ~]# vim /usr/local/nexus/bin/nexus.vmoptions | |
-Xms512m # 初始堆内存 | |
-Xmx512m # 最⼤推内存 | |
[root@nexus ~]# vim /usr/local/nexus/etc/nexus-default.properties | |
application-port=80 # nexus 监听端⼝,默认 8081 | |
application-host=0.0.0.0 # nexus 监听地址 |
4、启动 Nexus
[root@nexus ~]# /usr/local/nexus/bin/nexus start | |
# 查看⽇志 | |
[root@nexus ~]# tail -f /usr/local/sonatype-work/nexus3/log/nexus.log |
# 1.3 Nexus 访问
1、获取 nexus 默认密码,⽤户名默认为 admin;
[root@nexus ~]# cat /usr/local/sonatype-work/nexus3/admin.password |
2、通过浏览器访问(会有向导⻚⾯提示,然后根据提示对管理员密码进⾏修改。)

# 1.4 Nexus 配置
1、配置 nexus 的中央仓库(加速 jar 包的下载及缓存 jar 包)
- 1、点击 settings--> Repositories --> maven-central
- 2、修改 proxy--> Remote storage 为 https://maven.aliyun.com/nexus/content/groups/public
- 3、点击 save 保存

2、重复发布⼀个项⽬对应的版本,默认是不允许的,因此我们可以配置 maven-releases 仓库,允许重复上传相同版本
- 1、点击 settings--> Repositories --> maven-releases
- 2、选择 Deployment policy ,修改为 Allow redeploy
- 3、点击 Save 保存

# 2. Nexus 基本使⽤
# 2.1 安装 maven
[root@jenkins ~]# wget https://mirrors.tuna.tsinghua.edu.cn/apache/maven/maven-3/3.9.11/binaries/apache-maven-3.9.11-bin.tar.gz | |
[root@jenkins ~]# tar xf apache-maven-3.9.11-bin.tar.gz -C /usr/local/ | |
[root@jenkins ~]# ln -s /usr/local/apache-maven-3.9.11 /usr/local/maven | |
[root@jenkins ~]# cat /etc/profile.d/maven.sh | |
export MAVEN_HOME=/usr/local/maven | |
export PATH=$MAVEN_HOME/bin:$PATH | |
[root@jenkins ~]# source /etc/profile.d/maven.sh | |
[root@jenkins ~]# mvn -v |
# 2.2 配置 Maven 连接 Nexus
[root@jenkins ~]# vim /usr/local/maven/conf/settings.xml | |
# 配置 nexus 仓库认证 | |
<servers> | |
<server> | |
<id>maven-central</id> | |
<username>admin</username> | |
<password>talent</password> | |
</server> | |
<server> | |
<id>nexus-snapshots</id> | |
<username>admin</username> | |
<password>talent</password> | |
</server> | |
<server> | |
<id>nexus-releases</id> | |
<username>admin</username> | |
<password>talent</password> | |
</server> | |
</servers> | |
# 配置 nexus 仓库地址 | |
<mirrors> | |
<mirror> | |
<id>maven-central</id> | |
<mirrorOf>*</mirrorOf> | |
<url>http://nexus.hmallleasing.com/repository/maven-central/</url> | |
</mirror> | |
<mirror> | |
<id>nexus-snapshots</id> | |
<mirrorOf>*</mirrorOf> | |
<url>http://nexus.hmallleasing.com/repository/maven-snapshots/</url> | |
</mirror> | |
<mirror> | |
<id>nexus-releases</id> | |
<mirrorOf>*</mirrorOf> | |
<url>http://nexus.hmallleasing.com/repository/maven-releases/</url> | |
</mirror> | |
</mirrors> |
# 2.3 上传 War 包⾄ Nexus
1、编译代码,编译后将项⽬上传⾄ Nexus 质品库(可以⼿动上传,也可以通过如下⽅式上传)
# war | |
[root@jenkins ~]# mvn package | |
[root@jenkins ~]# mvn deploy:deploy-file \ | |
-DgroupId=devops \ | |
-DartifactId=xuyong-war \ | |
-Dversion=2.0.0 \ | |
-Dpackaging=war \ | |
-Dfile=target/xuyong-war-2.0.0.war \ | |
-Durl=http://nexus.hmallleasing.com/repository/maven-releases/ \ | |
-DrepositoryId=nexus-releases \ | |
-DgeneratePom=true | |
# jar | |
[root@jenkins ~]# mvn package | |
[root@jenkins ~]# mvn deploy:deploy-file \ | |
-DgroupId=devops \ | |
-DartifactId=oldxu-jar \ | |
-Dversion=1.0.0 \ | |
-Dpackaging=jar \ | |
-Dfile=target/oldxu-jar-1.0.0.jar \ | |
-Durl=http://nexus.hmallleasing.com/repository/maven-releases/ \ | |
-DrepositoryId=nexus-releases \ | |
-DgeneratePom=true |
2、登陆 Nexus 检查上传后的结果

# 2.4 ⼿动上传上传 War 包⾄ Nexus

# 2.5 下载 Nexus 中的 War 包
1、登录 Nexus 制品库,复制需要下载包的路径

2、使⽤ wget 传递⽤户名和密码,即可完成下载
# wget \ | |
--http-user=admin \ | |
--http-passwd=talent \ | |
http://nexus.hmallleasing.com/repository/maven-releases/devops/xuyong-war/2.0.0/xuyong-war-2.0.0.war |
# 3. Jenkins 基于 Nexus 实现 CI
# 3.1 JenkinsCI 实现思路
1、创建⼀个 Maven 的项⽬,名称叫 devops_demo_nexus-CI ,然后填写对应的仓库地址;
2、在 Build 阶段填写 package ,完成应⽤的打包;
3、在 Post Steps 阶段,增加执⾏ Shell 脚本,使其能将构建的包推送⾄ Nexus 制品库;
4、如果 CI 阶段测试整体没有问题,可以为其添加⼀个 WebHook ,使其⾃动打
包、并⾃动推送 Nexus 制品库;
# 3.2 JenkinsCI 项⽬配置
1、安装 Maven Integration 插件,这样才能使⽤ Jenkins 构建⼀个 Maven 的项⽬。
2、告诉 Jenkins,Maven 的安装路径:点击系统 --> 全局⼯具配置 --> 新增 Maven,然后填写 Maven 路径;
[root@jenkins ~]# mvn -version | |
Apache Maven 3.9.11 (3e54c93a704957b63ee3494413a2b544fd3d825b) | |
Maven home: /usr/local/maven | |
Java version: 17.0.17, vendor: Oracle Corporation, runtime: /usr/local/jdk-17.0.17 | |
Default locale: en_US, platform encoding: UTF-8 | |
OS name: "linux", version: "3.10.0-957.el7.x86_64", arch: "amd64", family: "unix" |

3、告诉 Jenkins,java 的安装路径:点击系统 --> 全局⼯具配置 --> 新增 jdk,然后填写 java 路径;

4、创建项⽬,然后填写对应项⽬地址

5、配置 Build 阶段,在 Goals and options 段填写 package -Dmaven.test.skip=true 进⾏编译;

6、配置 Post Steps 节点,增加执⾏ Shell 脚本,将构建后产⽣的 war 推送⾄ Nexus

脚本如下所示:
[root@jenkins ~]# cat /scripts/push_nexus.sh | |
#!/usr/bin/bash | |
# 从 pom.xml 提取信息(-q 静默、fourceStdout 输出到屏幕) | |
groupId=$(mvn help:evaluate -Dexpression=project.groupId -q -DforceStdout) | |
artifactId=$(mvn help:evaluate -Dexpression=project.artifactId -q -DforceStdout) | |
version=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout) | |
packaging=$(mvn help:evaluate -Dexpression=project.packaging -q -DforceStdout) | |
# 上传至 nexus | |
mvn deploy:deploy-file \ | |
-DgroupId=${groupId} \ | |
-DartifactId=${artifactId} \ | |
-Dversion=${version} \ | |
-Dpackaging=${packaging} \ | |
-Dfile=${WORKSPACE}/target/${artifactId}-${version}.${packaging} \ | |
-Durl=http://nexus.hmallleasing.com/repository/maven-releases/ \ | |
-DrepositoryId=nexus-releases \ | |
-DgeneratePom=true |
# 3.3 JenkinsCI 全⾃动 Webhook
1、配置 Jenkins(启⽤构建触发器,然后点击⾼级,⽣成对应的 token)


2、配置 Gitlab(选择对应的项⽬,设置 -->webhook)

3、更新代码、然后将 pom.xml 中的版本号修改为 2.2.0,最后检查 Nexus 是否有对应版本 war 包


# 4. Jenkins 基于 Nexus 实现 CD
# 4.1 JenkinsCD 实现思路
1、创建⼀个名为 devops_demo_nexus-CD 的项⽬,使⽤ FreeStyle 类型;
2、使⽤ Extensible Choice Parameter 插件获取 Nexus 仓库中 war 包完整路径,⽽后完整路径赋值给 java_deploy_url 变量;
3、编写 Shell 或 Ansible 脚本,通过 java_deploy_url 变量提取 WAR 包的完整下载路径,然后下载⾄本地;
4、编写 Shell 或 Ansible 脚本,按照此前部署逻辑进⾏后续脚本的编写(摘节点、更新代码、上线节点)
# 4.2 JenkinsCD 项⽬配置
1、创建项⽬,然后配置 Extensible Choice Parameter ,⾸先配置 Nexus 仓库地址、⽤户名、密码等信息
- 变量名: java_deploy_url
- Choice Provider: Nexus3 Artifact Choice Parameter
- Nexus Server URL: http://nexus.hmallleasing.com (该域名要确保 jenkins 服务器能正常解析)
- Credentials: nexus ⽤户名和密码

2、然后继续配置(项⽬的 GroupID、ArtifactID、Packaging 等信息)
- RepositoryId: maven-releases (war 包存放的具体仓库,可以不填写)
- GroupId: devops
- ArtifactId: xuyong-war
- Packaging: war

3、在 Jenkins 前端⻚⾯就可以选择要部署的项⽬所对应的版本

# 5. Jenkins 调⽤ Shell 实现 CD 部署
# 5.1 脚本实现思路
- 1、通过 java_deploy_url 变量,提取⽤户选择要部署的 war 包地址以及对应的版本;
- 2、通过 wget 下载对应的 war 包,推送 war 包;
- 3、从负载均衡摘掉节点,然后更新代码,最后上线节点;
# 5.2 Shell 脚本内容

[root@jenkins ~]# cat /scripts/shell_deploy_nexus_war.sh | |
#!/usr/bin/bash | |
#1. 定义变量 | |
app_dir=/opt | |
tomcat_dir=/app/tomcat | |
#获取完整的包名称:xuyong-war-1.0.0.war | |
app_full_name=$(echo ${java_deploy_url##*/}) | |
#基于完整包名称提取的名称 xuyong-war-1.0.0 | |
app_name=$(echo ${app_full_name%.*}) | |
#2. 下载 nexus 制品库中的 war 包到指定的路径 | |
wget -O ${app_dir}/${app_full_name} --http-user=admin --http-passwd=talent ${java_deploy_url} | |
#3. 将包推送到各个集群节点 | |
for host in ${webservers} | |
do | |
scp ${app_dir}/${app_full_name} root@${host}:${app_dir}/ | |
done | |
#4.haproxy 的函数 | |
lb_server_disable(){ | |
for i in ${lbservers} | |
do | |
ssh root@${i} "echo 'disable server java_cluster/$1' | socat stdio /var/lib/haproxy/stats" | |
done | |
} | |
lb_server_enable(){ | |
for i in ${lbservers} | |
do | |
ssh root@${i} "echo 'enable server java_cluster/$1' | socat stdio /var/lib/haproxy/stats" | |
done | |
} | |
#5. 执行部署逻辑 | |
for host in ${webservers} | |
do | |
# 从负载均衡中摘除节点 | |
lb_server_disable ${host} | |
ssh root@${host} "${tomcat_dir}/bin/shutdown.sh || true && \ | |
mkdir -p ${app_dir}/${app_name} && \ | |
unzip ${app_dir}/${app_full_name} -d ${app_dir}/${app_name} && \ | |
rm -f ${app_dir}/${app_full_name} && \ | |
rm -f ${tomcat_dir}/webapps/ROOT && \ | |
ln -s ${app_dir}/${app_name} ${tomcat_dir}/webapps/ROOT && \ | |
${tomcat_dir}/bin/startup.sh" | |
sleep 10 | |
# 将节点加⼊负载均衡资源池 | |
lb_server_enable ${host} | |
sleep 10 | |
done |
# 5.3 测试并验证结果
1、Jenkins 前端构建效果(Shell 脚本需要额外传递 lbservers 和 webservers 变量)。

2、检查⽣产环境部署效果;

# 6. Jenkins 调⽤ Ansible 实现 CD 部署
# 6.1 Ansible 实现思路
- 1、通过不同的 hosts 清单⽂件,来区分部署的环境
- 2、通过 java_deploy_url 变量,获取 war 包的完整 URL 地址;
- 3、基于 java_deploy_url 变量,提取对应的包名称,例如: oldxu-war-1.0.0.war
- 4、使⽤ get_url 模块,下载对应的 war 包到 jenkins 本地,因此该操作需要委派给 jenkins 服务器执⾏;
- 5、将节点从集群摘除、关闭 Tomcat,并等待彻底退出
- 6、创建 web 站点⽬录,将代码解压⾄指定的⽬录
- 7、删除软连接,重建软连接
- 8、启动 tomcat,并等待启动就绪,然后将节点接⼊集群
# 6.2 Ansible 脚本内容


[root@jenkins ~]# cat /scripts/ansible_deploy_nexus_war.yml | |
- hosts: webservers | |
vars: | |
- app_dir: /opt | |
- app_name: ROOT | |
- app_port: 8080 | |
- tomcat_dir: /app/tomcat | |
serial: 1 # 控制一次操作多少台机器 | |
tasks: | |
- name: "1.获取war包的完整url地址" | |
shell: | |
cmd: "echo ${java_deploy_url}" | |
register: java_deploy_url | |
delegate_to: 127.0.0.1 | |
- name: "2.基于完整的Url地址提取war名称" | |
shell: | |
cmd: "echo ${java_deploy_url} | awk -F '/' '{print $NF}'" | |
register: app_full_name | |
delegate_to: 127.0.0.1 | |
- name: "3.下载Nexus仓库中指定 包到本地" | |
get_url: | |
url: "" | |
dest: "/" | |
username: admin | |
password: talent | |
delegate_to: 127.0.0.1 | |
- name: "4.摘除需要更新的节点( ),将操作委派给Haproxy负载均衡" | |
haproxy: | |
socket: /var/lib/haproxy/stats | |
state: disabled | |
backend: "java_cluster" | |
host: '' | |
delegate_to: "" | |
loop: "" | |
- name: "5.停止节点 Tomcat服务" | |
shell: | |
cmd: "/bin/shutdown.sh" | |
- name: "6.检查节点 Tomcat服务是否关闭成功" | |
wait_for: | |
port: "" | |
state: stopped | |
delay: 3 | |
- name: "7.创建站点目录 " | |
file: | |
path: "/" | |
state: directory | |
- name: "8.将 war 包解压到节点的 目录中" | |
unarchive: | |
src: "/" | |
dest: "/" | |
- name: "9.删除软链接" | |
file: | |
path: "/webapps/" | |
state: absent | |
- name: "10.重建软链接" | |
file: | |
src: "/" | |
dest: "/webapps/" | |
state: link | |
- name: "11.启动节点 Tomcat服务" | |
shell: | |
cmd: "nohup /bin/startup.sh &" | |
- name: "12.检查节点 Tomcat服务是否启动成功" | |
wait_for: | |
port: "" | |
state: started | |
delay: 3 | |
- name: "13.上线节点( ),将操作委派给Haproxy负载均衡" | |
haproxy: | |
socket: /var/lib/haproxy/stats | |
state: enabled | |
backend: "java_cluster" | |
host: '' | |
delegate_to: "" | |
loop: "" |
# 6.3 测试并验证结果
1、开发更新代码,并更新 pom.xml 版本
2、⾃动执⾏ devops_demo_nexus-CI 任务(jenkins 读取 pom ⽂件,并⾃动上传⾄ Nexus)
3、⼿动执⾏ devops_demo_nexus-Ansible-CD 任务(Jenkins 获取 nexus
版本,然后通过 Ansile 推送到各个节点)

4、部署到⽣产环境,然后访问⽣产环境的域名

# 7. Jenkins 基于 Nexus 实现 Jar 包 CICD
# 7.1 实现思路
jar 包实现思路与 war 基本没有区别,war 包依赖于 Tomcat 运⾏,⽽ jar 包可以直接运⾏;
项目链接地址:http://file.oldxu.net/jenkins/springboot-devops-demo-jar-java17.tar.gz
CI 阶段:
- 1、gitlab 创建 springboot_devops_jar_CI 仓库,将对应的 jar 包推送到仓库 springboot-devops-demo-jar-java17.tar.gz;
- 2、创建⼀个 Maven 的项⽬,名称叫 hello_world_jar-CI ,然后填写对应的仓库地址;
- 3、在 Build 阶段填写 package ,完成应⽤的打包;
- 4、在 Post Steps 阶段,增加执⾏ Shell 脚本,使其能将构建的 jar 包推送⾄ Nexus 服务器;
- 5、如果 CI 阶段测试整体没有问题,可以为其添加⼀个 WebHook ,使其⾃动打包、并推送 Nexus 制品库;
CD 阶段:
- 1、创建⼀个名为 springboot_devops_jar_CD 的项⽬,使⽤ FreeStyle 类型;
- 2、通过 Extensible Choice Parameter 插件获取到 Nexus 仓库中的 war 包完整路径,⽽后完整路径赋值给对应的 jar_deploy_url 变量名;
- 3、编写 Shell 或 Ansible 脚本,通过 jar_deploy_url 变量提取 WAR 包的完整下载路径,然后下载⾄本地;
- 4、编写 Shell 或 Ansible 脚本,按照此前部署逻辑进⾏后续脚本的编写(摘节点、更新代码、上线节点)
# 7.2 集群环境构建
1、测试环境的负载均衡
[root@proxy02 ~]# cat /etc/haproxy/haproxy.cfg | |
#--------------------------------------------------------------------- | |
# Global settings | |
#--------------------------------------------------------------------- | |
global | |
log 127.0.0.1 local2 | |
chroot /var/lib/haproxy | |
pidfile /var/run/haproxy.pid | |
maxconn 4000 | |
user haproxy | |
group haproxy | |
daemon | |
# turn on stats unix socket | |
stats socket /var/lib/haproxy/stats level admin | |
#nbproc 4 | |
nbthread 8 | |
cpu-map 1 0 | |
cpu-map 2 1 | |
cpu-map 3 2 | |
cpu-map 4 3 | |
defaults | |
mode http | |
log global | |
option httplog | |
option dontlognull | |
option http-server-close | |
option forwardfor except 127.0.0.0/8 | |
option redispatch | |
retries 3 | |
timeout http-request 10s | |
timeout queue 1m | |
timeout connect 10s | |
timeout client 1m | |
timeout server 1m | |
timeout http-keep-alive 10s | |
timeout check 10s | |
maxconn 3000 | |
##listen | |
listen stats | |
mode http | |
bind 0.0.0.0:9999 | |
stats enable | |
log global | |
stats uri /haproxy-status | |
stats auth xuyong:123456 | |
stats admin if TRUE | |
#--------------------------------------------------------------------- | |
# main frontend which proxys to the backends | |
#--------------------------------------------------------------------- | |
frontend war | |
bind *:80 | |
mode http | |
acl test_war_domain hdr_reg(host) -i test-war.hmallleasing.com | |
use_backend java_cluster if test_war_domain | |
backend java_cluster | |
balance roundrobin | |
option httpchk HEAD / HTTP/1.1\r\nHost:\ test-war.hmallleasing.com | |
server 172.16.1.9 172.16.1.9:8080 check port 8080 inter 3s rise 2 fall 3 | |
frontend jar | |
bind *:80 | |
mode http | |
acl test_jar_domain hdr_reg(host) -i test-jar.hmallleasing.com | |
use_backend jar_cluster if test_jar_domain | |
backend jar_cluster | |
balance roundrobin | |
option httpchk HEAD / HTTP/1.1\r\nHost:\ test-jar.hmallleasing.com | |
server 172.16.1.9 172.16.1.9:8081 check port 8081 inter 3s rise 2 fall 3 |
2、⽣产环境的负载均衡配置
[root@proxy01 ~]# cat /etc/haproxy/haproxy.cfg | |
#--------------------------------------------------------------------- | |
# Global settings | |
#--------------------------------------------------------------------- | |
global | |
log 127.0.0.1 local2 | |
chroot /var/lib/haproxy | |
pidfile /var/run/haproxy.pid | |
maxconn 4000 | |
user haproxy | |
group haproxy | |
daemon | |
# turn on stats unix socket | |
stats socket /var/lib/haproxy/stats level admin | |
#nbproc 4 | |
nbthread 8 | |
cpu-map 1 0 | |
cpu-map 2 1 | |
cpu-map 3 2 | |
cpu-map 4 3 | |
defaults | |
mode http | |
log global | |
option httplog | |
option dontlognull | |
option http-server-close | |
option forwardfor except 127.0.0.0/8 | |
option redispatch | |
retries 3 | |
timeout http-request 10s | |
timeout queue 1m | |
timeout connect 10s | |
timeout client 1m | |
timeout server 1m | |
timeout http-keep-alive 10s | |
timeout check 10s | |
maxconn 3000 | |
##listen | |
listen stats | |
mode http | |
bind 0.0.0.0:9999 | |
stats enable | |
log global | |
stats uri /haproxy-status | |
stats auth xuyong:123456 | |
stats admin if TRUE | |
#--------------------------------------------------------------------- | |
# main frontend which proxys to the backends | |
#--------------------------------------------------------------------- | |
frontend war | |
bind *:80 | |
mode http | |
acl war_domain hdr_reg(host) -i war.hmallleasing.com | |
use_backend java_cluster if war_domain | |
backend java_cluster | |
balance roundrobin | |
option httpchk HEAD / HTTP/1.1\r\nHost:\ war.hmallleasing.com | |
server 172.16.1.7 172.16.1.7:8080 check port 8080 inter 3s rise 2 fall 3 | |
server 172.16.1.8 172.16.1.8:8080 check port 8080 inter 3s rise 2 fall 3 | |
frontend jar | |
bind *:80 | |
mode http | |
acl jar_domain hdr_reg(host) -i jar.hmallleasing.com | |
use_backend jar_cluster if jar_domain | |
backend jar_cluster | |
balance roundrobin | |
option httpchk HEAD / HTTP/1.1\r\nHost:\ jar.hmallleasing.com | |
server 172.16.1.7 172.16.1.7:8081 check port 8081 inter 3s rise 2 fall 3 | |
server 172.16.1.8 172.16.1.8:8081 check port 8081 inter 3s rise 2 fall 3 |
# 7.3 Shell 发布脚本
- 1、通过 jar_deploy_url 变量获取对应的完整 URL 地址;
- 2、使⽤ wget 下载对应的 Jar 包到本地;
- 3、下线对应的节点,停⽌对应的 jar 包这个服务;
- 4、启动 jar 包,加⼊到负载均衡;
1. 编写脚本
[root@jenkins ~]# cat /scripts/shell_deploy_jar.sh | |
#!/usr/bin/bash | |
#1. 定义变量 | |
# 基于完整的 URL 提取对应的 Jar 包名称 | |
jar_name=$(echo ${jar_deploy_url} | awk -F '/' '{print $NF}') | |
jar_dir=/opt | |
jar_port=8081 | |
nexus_user=admin | |
nexus_passwd=talent | |
#2.haproxy 的函数 | |
lb_server_disable(){ | |
for i in ${lbservers} | |
do | |
ssh root@${i} "echo 'disable server jar_cluster/$1' | socat stdio /var/lib/haproxy/stats" | |
done | |
} | |
lb_server_enable(){ | |
for i in ${lbservers} | |
do | |
ssh root@${i} "echo 'enable server jar_cluster/$1' | socat stdio /var/lib/haproxy/stats" | |
done | |
} | |
#3. 下载对应的 Jar 包到指定的路径 | |
wget -O ${jar_dir}/${jar_name} --http-user=${nexus_user} --http-passwd=${nexus_passwd} ${jar_deploy_url} | |
#4. 将 jar 包推送给对应的节点 | |
for host in ${webservers} | |
do | |
scp ${jar_dir}/${jar_name} root@${host}:${jar_dir} | |
done | |
#5. 部署服务 | |
for host in ${webservers} | |
do | |
# 将节点从集群环境中摘除 | |
lb_server_disable ${host} | |
# 停止 jar 服务(注意外单、内双、awk 的 $ 需要转义) | |
ssh root@${host} 'jar_proc=$(ps aux|grep oldxu-jar | grep -v grep | awk "{print \$2}") && \ | |
kill ${jar_proc}' | |
# 启动 jar 服务 | |
ssh root@${host} "java -jar ${jar_dir}/${jar_name} --server.port=${jar_port} &>/var/log/jar.log &" | |
sleep 3 | |
# 将节点加入集群环境 | |
lb_server_enable ${host} | |
done |
2.Jenkins 前端构建效果(Shell 脚本需要额外传递 lbservers 和 webservers 变量)

3. 测试并验证效果

# 7.4 Ansible 发布脚本
- 1、通过不同的 hosts 清单⽂件,来区分部署的环境;
- 2、基于 jar_deploy_url 变量,提取的 jar 包的名称;
- 3、下载 jar 包到指定的路径,然后将 jar 拷⻉到各个节点;
- 4、将节点从集群中摘除;
- 5、检查进程是否存在,存在则 kill,不存在则直接启动服务;
- 6、将节点接⼊负载均衡;
1. 通过不同的 hosts 清单⽂件,来区分部署的环境

2. 配置 Ansible 脚本发布应用

3.Jenkins 前端构建效果

4. 编写 ansible 脚本
[root@jenkins ~]# cat /scripts/deploy_nexus_jar.yml
- hosts: "webservers"
vars:
- jar_dir: /opt
- java_port: "8081"
- web_backend: jar_cluster
- nexus_user: admin
- nexus_passwd: talent
serial: 1 # 控一次操作多少台主机
tasks:
- name: "1.获取jar包的完整路径"
shell:
cmd: "echo ${jar_deploy_url}"
register: jar_deploy_url
delegate_to: "127.0.0.1"
- name: "1.获取jar包的完整URL路径"
shell:
cmd: if [ -z ${jar_deploy_url} ];then
curl -s -uadmin:talent "http://nexus.hmallleasing.com/service/rest/v1/search?repository=maven-releases&maven.groupId=devops&maven.artifactId=oldxu-jar&maven.extension=jar" | grep downloadUrl | grep 'jar\",' | tail -1 | awk -F '"' '{print $4}';
else
echo ${jar_deploy_url};
fi
register: jar_deploy_url
delegate_to: 127.0.0.1
- name: "debug"
debug:
msg: "获取最终的值:{{ jar_deploy_url.stdout }}"
- name: "2.获取jar包的名称"
debug:
msg: "{{ jar_deploy_url.stdout.split('/')[-1] }}"
register: jar_name
delegate_to: 127.0.0.1
- name: "debug"
debug:
msg: "获取最终的值:{{ jar_name.msg }}"
- name: "3.通过http协议下载Jar包"
get_url:
url: "{{ jar_deploy_url.stdout }}"
dest: "{{ jar_dir }}/{{ jar_name.msg }}"
username: "{{ nexus_user }}"
password: "{{ nexus_passwd }}"
delegate_to: 127.0.0.1
- name: "4.拷贝Jar包至对应节点"
copy:
src: "{{ jar_dir }}/{{ jar_name.msg }}"
dest: "{{ jar_dir }}/{{ jar_name.msg }}"
- name: "5.摘除需要更新的节点( {{ inventory_hostname }} ),将操作委派给Haproxy负载均衡"
haproxy:
socket: /var/lib/haproxy/stats
backend: "{{ web_backend }}"
state: disabled
host: "{{ inventory_hostname }}" # 获取当前操作节点主机名称
delegate_to: "{{ item }}" # 下线节点任务委派给负载均衡节点
loop: "{{ groups['lbservers']}}"
- name: "6.Check Jar Process Status"
shell:
cmd: "ps -ef | grep -v grep | grep {{ java_port }} | awk '{print $2}'"
register: jar_process
ignore_errors: yes
- name: "7.停止Jar进行运行"
shell:
cmd: "kill {{ jar_process.stdout }}"
ignore_errors: yes
- name: "8.检查进程是否存活"
wait_for:
port: "{{ java_port }}"
state: stopped
- name: "9.Start Jar Server"
shell:
cmd: "nohup java -jar {{ jar_dir }}/{{ jar_name.msg }} --server.port={{ java_port }} &>/dev/null &"
- name: "10.检查Jar程序是否启动成功"
wait_for:
port: "{{ java_port }}"
state: started
- name: "11.上线节点( {{ inventory_hostname }} ),将操作委派给Haproxy负载均衡"
haproxy:
socket: /var/lib/haproxy/stats
backend: "{{ web_backend }}"
state: enabled
host: "{{ inventory_hostname }}"
delegate_to: "{{ item }}" # 上线节点任务委派给负载均衡节点
loop: "{{ groups['lbservers']}}"
5. 配置 CI 构建后触发 CD

6. 测试并验证效果

