Jenkins实现java项目CI/CD部署

其他 2021-11-19 23:11:24 阅读次数: 0

文章目录

一、Java项目基本概述

1.1 什么是Java项目

简单来说就是使用java编写的代码，我们将其称为java项目。

1.2 Java项目如何编译

由于java编写的代码是无法直接在服务器上运行，需要使用maven工具进行打包。
简单理解: Java源代码就像汽车的一堆散件，必须组装才是一辆完整的汽车。
这里的 “组装汽车的过程” 就可以理解是 “Maven编译打包” 的过程。

1.3 Java项目实现架构图

在这里插入图片描述

1.4 环境 负载均衡haproxy ,后端web集群 tomcat+java

二、手动实现War包项目的CI

先模拟开发提交java源码–>推送至gitlab–>运维使用mvn手动编译–>最后推送war至web集群

2.1 模拟开发提交代码

1.首先在gitlab创建项目仓库
2.开发本地推送项目至gitlab项目仓库
3.检查gitlab仓库是否有已提交的代码
在这里插入图片描述

2.2 模拟运维拉取代码

[root@jenkins test]# git clone git@gitlab.bertwu.com:dev/spring-hello-world-war.git

2.3模拟运维编译代码

1.安装maven

[root@jenkins ~]# yum install java maven -y

2.maven编译时会下载jar包，默认走国外，比较慢，配置为阿里源。

[root@jenkins ~]# vim/etc/maven/settings.xml
    <mirror>
    <id>alimaven</id>
    <name>aliyun maven</name>
    <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    <mirrorOf>central</mirrorOf>
  </mirror>

3.编译

[root@jenkins ~]# mvn clean # 清除缓存

[root@jenkins spring-hello-world-war]# mvn package -Dmaven.test.skip=true # 跳过测试用例

2.4 模拟运维部署代码

1.推送war包到web的/opt目录,打上时间标签
[root@jenkins spring-hello-world-war]# for i in {
    
    7..8};do scp target/*.war [email protected].$i:/opt/ROOT_$(date +%F).war;done
2.删除原有的ROOT目录
[root@jenkins spring-hello-world-war]# for i in {7..8};do  ssh [email protected].$i "rm -rf /soft/tomcat/webapps/ROOT";done
3.创建对应目录解压war包，war包解压后为分散的文件
[root@jenkins spring-hello-world-war]# for i in {7..8};do  ssh [email protected].$i "mkdir /opt/ROOT_$(date +%F) && unzip /opt/ROOT_$(date +%F).war -d /opt/ROOT_$(date +%F)";done

在这里插入图片描述

4.建立软连接，将目录连接到/soft/tomcat/webapps/ROOT下为tomcat站点的默认目录
[root@jenkins spring-hello-world-war]# for i in {
    
    7..8};do  ssh root@172.16.1.$i "ln -s /opt/ROOT_$(date +%F) /soft/tomcat/webapps/ROOT";done

5.重启tomcat
[root@jenkins spring-hello-world-war]# for i in {
    
    7..8};do  ssh root@172.16.1.$i "pkill java && /soft/tomcat/bin/startup.sh";done

三、Jenkins自动实现war包项目CI

3.1 配置Jenkins集成Maven

1.安装 Maven Integration 插件，这样才能使用Jenkins构建一个Maven的项目。
2.告诉Jenkins，JDK的安装路径：点击系统–>全局工具配置–>新增JDK，然后填写JDK路径；
在这里插入图片描述

3.告诉Jenkins，Maven的安装路径：点击系统–>全局工具配置–>新增Maven，然后填写Maven路径；
在这里插入图片描述
具体路径查看方法：

[root@jenkins target]# mvn --version
Apache Maven 3.0.5 (Red Hat 3.0.5-17)
Maven home: /usr/share/maven
Java version: 1.8.0_302, vendor: Red Hat, Inc.
Java home: /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.302.b08-0.el7_9.x86_64/jre
Default locale: en_US, platform encoding: UTF-8
OS name: "linux", version: "3.10.0-1160.el7.x86_64", arch: "amd64", family: "unix"

3.2 Jenkins创建Maven项目

1.创建一个maven项目
2.基础配置：git参数化构建
3.配置源码：填写java项目地址ssbi
4.配置Build：在Goals and options，填写package打包命令即可；

3.3 编写Shell发布脚本

1.通过Haproxy来关闭web节点；
2.停止web节点上的Tomcat服务；
3.进入工程目录中，将war包拷贝到被控端，并进行重新命名；
4.为被控端创建目录，解压到指定的目录下；
5.删除软连接，重新创建软连接
6.启动web节点上的Tomcat服务；
7.通过Haproxy加入到集群中；

[root@jenkins scripts]# cat deploy_java.sh 
#!/usr/bin/bash
Date=$(date +%F_%H_%M)
web_dir=/opt
tomcat_path=/soft/tomcat

#上锁
if [ -f /tmp/lock ];then
	echo "脚本正在执行，请不要重复执行"
	exit
fi

# 枷锁
touch /tmp/lock 

# 下线节点
lbservers_disable (){
    
    
	for lb_host in $lbservers
	do
		ssh root@$lb_host "echo 'disable server web_cluster/$1' | socat stdio /var/lib/haproxy/stats"
	done
}

# 上线节点
lbservers_enable (){
    
    
	for lb_host in $lbservers
	do
		ssh root@$lbservers "echo 'enable server web_cluster/$1' | socat stdio /var/lib/haproxy/stats"
	done
}


for host in $webservers
do
  #下线节点
	lbservers_disable $host
	#2.将war包推送到目标集群
	echo $WORKSPACE
	cd $WORKSPACE && scp target/*.war root@$host:$web_dir/ROOT_$Date.war
  # 停止tomcat
	 ssh root@$host "pkill java"
	# 删除原有ROOT目录
	 ssh root@$host "rm -rf $tomcat_path/webapps/ROOT"
	# 创建带时间戳的ROOT目录用于解压war包
		ssh root@$host "mkdir $web_dir/ROOT_$Date"
	# 将war包解压到新创建的目录
		ssh root@$host "unzip $web_dir/ROOT_$Date.war -d $web_dir/ROOT_$Date"
	# 创建软连接
		ssh root@$host "ln -s $web_dir/ROOT_$Date $tomcat_path/webapps/ROOT"
	# 重启tomcat
		ssh root@$host "$tomcat_path/bin/startup.sh"	
	# 上线节点
	lbservers_enable $host	
	
	sleep 5

done

#解锁
rm -rf /tmp/lock

传参方式如下：
在这里插入图片描述

3.4 Ansible剧本发布war包

[root@jenkins scripts]# cat deploy_java_commitid.yml 
- hosts: "{
    
    { deploy_webcluster }}"
  serial: 1
  vars:
    - web_dir: /opt
    - web_name: ROOT
    - backend_name: web_cluster
    - service_port: 8080
    - tomcat_path: /soft/tomcat

  tasks:
    - name: set system time variable
      shell:
        cmd: "date +%F:%H:%M"
      register: system_date
      delegate_to: "127.0.0.1"
    
    # 获取编译好的war绝对路径
    - name: set jenkins workspace 
      shell:
        cmd: "echo ${WORKSPACE}/target/*.war"
      register: workspace
      delegate_to: "127.0.0.1"
  
    # 获取commitid
    - name: get commit id
      shell:
        cmd: "echo ${git_commit_id} | cut -c 1-8" # 获取前8位
      register: commit_id
      delegate_to: "127.0.0.1"


    # 下线节点
    - name: stop haproxy webcluster pool node
      haproxy:
        socket: /var/lib/haproxy/stats
        backend: "backend_name"
        state: disabled
        host: "{
    
    { inventory_hostname }}"
      delegate_to: "{
    
    { item }}"
      loop: "{
    
    { groups['lbservers']}}"
  
   # 停止tomcat
    - name: stop tomcat server
      shell:
        cmd: "nohup /soft/tomcat/bin/shutdown.sh &"
        
        
  
   # 检测tomcat是否已经关闭
    - name: check tomcat port state
      wait_for:
        port: "{
    
    { service_port }}"
        state: stopped
   

   # 创建站点目录
    - name: create web sit directory
      file:
        path: "{
    
    { web_dir}}/{
    
    { web_name }}_{
    
    { system_date.stdout }}_{
    
    { commit_id.stdout }}"
        state: directory 
  


   # 解压代码到远程
    - name: unarchive code to remote
      unarchive:
        src: "{
    
    { workspace.stdout }}"
        dest: "{
    
    { web_dir }}/{
    
    { web_name }}_{
    
    { system_date.stdout }}_{
    
    { commit_id.stdout }}"

   # 删除旧的ROOT目录
    - name: delete old webserver link
      file:
        path: "{
    
    { tomcat_path }}/webapps/ROOT"
        state: absent

   # 创建新的软连接
    - name: create new webserver link
      file: 
        src: "{
    
    { web_dir}}/{
    
    { web_name }}_{
    
    { system_date.stdout }}_{
    
    { commit_id.stdout }}"
        dest: "{
    
    { tomcat_path }}/webapps/ROOT"
        state: link
 
  # 启动tomcat服务
    - name: start tomcat server
      shell:
        cmd: "nohup {
    
    { tomcat_path }}/bin/startup.sh &"

   # 检测tomcat是否已经启动，端口是否存活
    - name: check tomcat  port state
      wait_for:
        port: "{
    
    { service_port }}"
        state: started



   # 上线节点
    - name: start haproxy webcluster pool node
      haproxy:
        socket: /var/lib/haproxy/stats
        backend: "backend_name"
        state: enabled
        host: "{
    
    { inventory_hostname }}"
      delegate_to: "{
    
    { item }}" # 委派给负载均衡节点
      loop: "{
    
    { groups['lbservers']}}"

前端参数展示：
在这里插入图片描述

四、Jenkins集成Nexus制品库

4.1 Nexus作用

1.加速war包编译，先从制品库中获取编译所依赖的jar包，如果制品库没有，再去阿里云上查找，同时缓存一份在制品库，下次需要时候依然走制品库（相当于中转站）
2.开发可以手动或自动提交自定义的jar包（通过http协议下载）

4.2 Nexus安装

依赖java 和maven

[root@nexus ~]# yum install java maven -y
[root@jenkins ~]# wget nexus-3.19.1-01-unix.tar.gz # 默认很慢
[root@jenkins ~]# tar xf nexus-3.19.1-01-unix.tar.gz -C /usr/local/
[root@jenkins ~]# ln -s /usr/local/nexus-3.19.1-01/ /usr/local/nexus

4.3 Nexus配置

[root@jenkins ~]# vim /usr/local/nexus/bin/nexus.rc
run_as_user="root" # nexus进程运行用户
[root@jenkins ~]# vim /usr/local/nexus/etc/nexusdefault.properties
application-port=8081 # nexus监听端口
application-host=0.0.0.0 # nexus监听地址
[root@nexus local]# vim /usr/local/nexus/bin/nexus.vmoptions # 调整启动内存，适当调整小一点
-Xms512m 
-Xmx512m

4.4 nexus启动

[root@nexus local]# /usr/local/nexus/bin/nexus start

4.5 nexus访问

默认用户名admin密码放在下述文件中，登录进去后先修改密码

# 获取默认nexus密码，用户名默认admin
[root@nexus local]# cat /usr/local/sonatype-work/nexus3/admin.password 
ef4058e5-6c4e-4b05-834c-0ebdaf7487d6

4.6 配置NexusWeb

配置nexus的中央仓库（加速jar包的下载及缓存jar包）
1.点击 settings–> Repositories --> maven-central
2.修改 proxy–> Remote storage 为http://maven.aliyun.com/nexus/content/groups/public
3.点击 save 保存
在这里插入图片描述

4.7 配置Maven连接Nexus

在jenkis主机上修改配置

[root@jenkins ~]# vim/etc/maven/settings.xml
# 配置nexus认证
  <servers>
    <server>
      <id>nexus-snapshots</id>
      <username>admin</username>
      <password>admin</password>
    </server>
    <server>
      <id>nexus-releases</id>
      <username>admin</username>
      <password>admin</password>
    </server>
    <server>
      <id>maven-central</id>
      <username>admin</username>
      <password>admin</password>
    </server>
  </servers>


# 配置nexus仓库
<mirrors>
        <mirror>
          <id>maven-central</id>  
          <mirrorOf>*</mirrorOf>
          <url>http://nexus.bertwu.net:8081/repository/maven-central/</url>                                             
        </mirror>

        <mirror>
          <id>nexus-snapshots</id>
          <mirrorOf>*</mirrorOf>
          <url>http://nexus.bertwu.net:8081/repository/maven-snapshots/</url>
        </mirror>

        <mirror>
          <id>nexus-releases</id>
          <mirrorOf>*</mirrorOf>
          <url>http://nexus.bertwu.net:8081/repository/maven-releases/</url>
        </mirror>
  </mirrors>

maven-central 主要用作缓存，nexus-releases主要用于上传自己的jar包或war包

4.8 手动上传war包到nexus-releases

在这里插入图片描述

查看手动上传是否成功
在这里插入图片描述

4.9 自动上传war包或jar包至Nexus

项目下执行如下命令

mvn deploy:deploy-file \
-DgroupId=com.efsavage \
-DartifactId=hello-world-war \
-Dversion=1.0.0 \
-Dpackaging=war \
-Dfile=target/hello-world-war-1.0.0.war \
-Durl=http://nexus.bertwu.net:8081/repository/maven-releases/ \
-DrepositoryId=nexus-releases \
-DgeneratePom=true

[root@jenkins hello-world-war]# mvn deploy:deploy-file \
> -DgroupId=com.efsavage \
> -DartifactId=hello-world-war \
> -Dversion=1.0.0 \
> -Dpackaging=war \
> -Dfile=${
    
    WORKSPACE}/target/hello-world-war-1.0.0.war \
> -Durl=http://nexus.bertwu.net:8081/repository/maven-releases/ \
> -DrepositoryId=nexus-releases \
> -DgeneratePom=true

4.10 测试手动下载

wget --http-user=admin --http-passwd=admin \
http://nexus.bertwu.net:8081/repository/maven-releases/com/efsavage/hello-world-war/1.0.0/hello-world-war-1.0.0.war

五、Jenkins基于Nexus实现War包的CI

5.1 War包CI实现（Maven类型）

1.拉取代码
2.编译代码
3.编写脚本将jar包推送至nexus服务器
4.配置webhook自动触发器

编译完成后，增加一个执行Shell脚本功能

[root@jenkins scripts]# cat push_java.sh 
# 通过pom获取信息
groupId=$(mvn help:evaluate -Dexpression=project.groupId | egrep -v "[INFO]")
artifactId=$(mvn help:evaluate -Dexpression=project.artifactId | egrep -v "[INFO]")
version=$(mvn help:evaluate -Dexpression=project.version | egrep -v "\[INFO\]")
packaging=$(mvn help:evaluate -Dexpression=project.packaging | egrep -v "[INFO]")
# 上传至nexus
mvn deploy:deploy-file \
-DgroupId=${
    
    groupId} \
-DartifactId=${
    
    artifactId} \
-Dversion=${
    
    version} \
-Dpackaging=${
    
    packaging} \
-Dfile=target/${
    
    artifactId}-${
    
    version}.${
    
    packaging} \
-Durl=http://nexus.bertwu.net:8081/repository/maven-releases/ \
-DrepositoryId=nexus-releases \
-DgeneratePom=true

允许重复上传
在这里插入图片描述

5.2 配置Webhook触发器自动拉取代码

在这里插入图片描述

在这里插入图片描述
在gitlab上点击设置-----集成
在这里插入图片描述

六、Jenkins基于Nexus实现War包的CD（Freestyle风格，不需要编译）

6.1 基本配置

1.新建任务 Spring-Hello-Shell-CD
2.配置参数化构建
在这里插入图片描述

在这里插入图片描述
前端展示效果：
在这里插入图片描述
这样就可以部署不同版本的war包了。

6.2 编写shell脚本

[root@jenkins scripts]# cat deploy_nexus_war.sh 
#!/usr/bin/bash
web_dir=/opt
tomcat_path=/soft/tomcat
Date=$(date +%F:%H:%M)
username=admin
password=admin
#上锁
if [ -f /tmp/lock ];then
	echo "脚本正在执行，请不要重复执行"
	exit
fi

# 枷锁
touch /tmp/lock 

# 下线节点
lbservers_disable (){
    
    
	for lb_host in $lbservers
	do
		ssh root@$lb_host "echo 'disable server web_cluster/$1' | socat stdio /var/lib/haproxy/stats"
	done
}

# 上线节点
lbservers_enable (){
    
    
	for lb_host in $lbservers
	do
		ssh root@$lbservers "echo 'enable server web_cluster/$1' | socat stdio /var/lib/haproxy/stats"
	done
}


# 从制品库获取对应版本的war包

cd $web_dir && wget --http-user=$username --http-password=$password ${
    
    java_deploy_package_url} &>/dev/null


for host in $webservers
do
  #下线节点
	lbservers_disable $host

	#2.将war包推送到目标集群
	 scp $web_dir/*.war root@$host:$web_dir/
  # 停止tomcat
	 ssh root@$host "pkill java"
	# 删除原有ROOT目录
	 ssh root@$host "rm -rf $tomcat_path/webapps/ROOT"
	# 创建带时间戳的ROOT目录用于解压war包
		ssh root@$host "mkdir $web_dir/ROOT_$Date"
	# 将war包解压到新创建的目录
		ssh root@$host "unzip $web_dir/*.war -d $web_dir/ROOT_$Date"
	# 创建软连接
		ssh root@$host "ln -s $web_dir/ROOT_$Date $tomcat_path/webapps/ROOT"
	# 重启tomcat
		ssh root@$host "$tomcat_path/bin/startup.sh"	
	# 上线节点
	lbservers_enable $host	
	
	sleep 5

	# 删除/opt下war包，保证每次部署只有一个新war包
	ssh root@$host "rm -rf $web_dir/*.war"
done

# 推送完毕删除/opt下的war包
rm -rf $web_dir/*.war

#解锁
rm -rf /tmp/lock

6.3 编写Ansible

# 1.通过不同的hosts清单文件，来区分部署的环境
# 2.下载war包
# 3.获取war包名称+版本+类型
# 4.将节点从集群摘除
# 5.关闭Tomcat，并等待彻底退出
# 6.创建web站点目录，将代码解压至指定的目录
# 7.删除软连接，重建软连接
# 8.启动tomcat，并等待启动就绪
# 9.将节点接入集群

[root@jenkins scripts]# cat deploy_nexus_war.yml 
- hosts: "{
    
    { deploy_webcluster }}"
  serial: 1
  vars:
    - web_dir: /opt
    - web_name: ROOT
    - backend_name: java_cluster
    - service_port: 8080
    - tomcat_path: /soft/tomcat
    - username: admin
    - password: admin

  tasks:
    - name: output full name of war download
      shell:
        cmd: "echo ${java_deploy_package_url}"
      register: war_name
      delegate_to: "127.0.0.1"


    - name: output war pkg name
      shell:
        cmd: "echo ${java_deploy_package_url} | awk -F '/' '{print $NF}'"
      register: war_name_new
      delegate_to: "127.0.0.1"
      
    # 从制品库中下载war包
    - name: wget java war packages
      get_url:
        url: "{
    
    { war_name.stdout }}"
        dest: "{
    
    { web_dir }}/{
    
    { war_name_new.stdout }}"
        username: admin
        password: admin
      delegate_to: "127.0.0.1"

    

    # 下线节点
    - name: stop haproxy webcluster pool node
      haproxy:
        socket: /var/lib/haproxy/stats
        backend: "backend_name"
        state: disabled
        host: "{
    
    { inventory_hostname }}"
      delegate_to: "{
    
    { item }}"
      loop: "{
    
    { groups['lbservers']}}"
  
   # 停止tomcat
    - name: stop tomcat server
      shell:
        cmd: "nohup /soft/tomcat/bin/shutdown.sh &"
        
        
  
   # 检测tomcat是否已经关闭
    - name: check tomcat port state
      wait_for:
        port: "{
    
    { service_port }}"
        state: stopped
   

   # 创建站点目录
    - name: create web sit directory
      file:
        path: "{
    
    { web_dir}}/{
    
    { war_name_new.stdout }}"
        state: directory 
  


   # 解压代码到远程
    - name: unarchive code to remote
      unarchive:
        src: "{
    
    { web_dir }}/{
    
    { war_name_new.stdout }}"
        dest: "{
    
    { web_dir}}/{
    
    { war_name_new.stdout }}"

   # 删除旧的ROOT目录
    - name: delete old webserver link
      file:
        path: "{
    
    { tomcat_path }}/webapps/ROOT"
        state: absent

   # 创建新的软连接
    - name: create new webserver link
      file: 
        src: "{
    
    { web_dir}}/{
    
    { war_name_new.stdout }}"
        dest: "{
    
    { tomcat_path }}/webapps/ROOT"
        state: link
 
  # 启动tomcat服务
    - name: start tomcat server
      shell:
        cmd: "nohup {
    
    { tomcat_path }}/bin/startup.sh &"

   # 检测tomcat是否已经启动，端口是否存活
    - name: check tomcat  port state
      wait_for:
        port: "{
    
    { service_port }}"
        state: started



   # 上线节点
    - name: start haproxy webcluster pool node
      haproxy:
        socket: /var/lib/haproxy/stats
        backend: "backend_name"
        state: enabled
        host: "{
    
    { inventory_hostname }}"
      delegate_to: "{
    
    { item }}" # 委派给负载均衡节点
      loop: "{
    
    { groups['lbservers']}}"

前端展示：
在这里插入图片描述
在这里插入图片描述

6.4 完整测试CI与CD流程

1.开发更新代码，并更新pom.xml版本
2.执行Spring-Hello-CI 任务 （jenkins 读取 pom文件中的新 上传至Nexus，建议webhook自动化）
3.执行Spring-Hello-Ansible-CD 任务（Jenkins 获取 nexus 最新代码包，然后通过Shell或Ansile 推送到各个节点）
4.访问测试

七、Jenkins实现Jar包的CI与CD

7.1 Jar包CI实现（Maven类型）

# 手动编译是否正常
[root@jenkins springboot-helloworld]# mvn package

# 手动上传jar包到 nexus
[root@jenkins springboot-helloworld]# sh push_jar.sh 

[root@jenkins springboot-helloworld]# cat push_jar.sh 
#!/usr/bin/bash
groupId=$(mvn help:evaluate -Dexpression=project.groupId | egrep -v "[INFO]")
artifactId=$(mvn help:evaluate -Dexpression=project.artifactId | egrep -v "[INFO]")
version=$(mvn help:evaluate -Dexpression=project.version | egrep -v "\[INFO\]")
packaging=$(mvn  help:evaluate -Dexpression=project.packaging | egrep -v "[INFO]")

# 上传至nexus
mvn deploy:deploy-file \
-DgroupId=${
    
    groupId} \
-DartifactId=${
    
    artifactId} \
-Dversion=${
    
    version} \
-Dpackaging=${
    
    packaging} \
-Dfile=${
    
    WORKSPACE}/target/${
    
    artifactId}-${
    
    version}.${
    
    packaging} \
-Durl=http://nexus.bertwu.net:8081/repository/maven-releases/ \
-DrepositoryId=nexus-releases \
-DgeneratePom=true


# 测试手动下载
[root@jenkins springboot-helloworld]# wget -O  --http-user=admin --http-password=admin http://nexus.bertwu.net:8081/repository/maven-releases/demo/demo-service/1.0/demo-service-1.0.jar

7.2 创建项目并加入webhook

1.jekins创建项目 Spring-Hello-Naxus-Jar-CI
2.gitlab上创建项目 sprint-hello-world-jar
3.推送项目代码到远程仓库‘
4.项目配置webhook,配置maven编译，构建时执行push_jar.sh脚本将jar包推送到nexus仓库。

7.3 Jar包CD基于shell实现（Freestyle类型）

1.新建任务Spring-Hello-Jar-Shell-CD
2.参数化构建部分参数展示，执行shell脚本，从制品库拉取对应的jar包到后端服务器启动。

在这里插入图片描述
在这里插入图片描述
3.前端参数展示：
在这里插入图片描述
4.shell脚本

[root@jenkins scripts]# cat deploy_nexus_jar.sh 
#!/usr/bin/bash
web_dir=/opt
username=admin
password=admin
server_port=8899

#上锁
if [ -f /tmp/lock ];then
	echo "脚本正在执行，请不要重复执行"
	exit
fi

# 枷锁
touch /tmp/lock 


# 提取包名称例如demo-service-2.0.jar
pkg_name=$(echo ${
    
    java_deploy_package_url##*/})

# 基于包名称提取 demo-service 用于启停对应的java 进程
pkg_process_name=$(echo ${
    
    pkg_name%-*})


# 下线节点
lbservers_disable (){
    
    
	for lb_host in $lbservers
	do
		ssh root@$lb_host "echo 'disable server web_cluster/$1' | socat stdio /var/lib/haproxy/stats"
	done
}

# 上线节点
lbservers_enable (){
    
    
	for lb_host in $lbservers
	do
		ssh root@$lbservers "echo 'enable server web_cluster/$1' | socat stdio /var/lib/haproxy/stats"
	done
}


# 从制品库获取对应版本的war包
cd $web_dir && wget --http-user=$username --http-password=$password ${
    
    java_deploy_package_url} &>/dev/null

# 推送jar包到各个节点
for host in $webservers
do
  #下线节点
	lbservers_disable $host

	#2.将war包推送到目标集群
	 scp $web_dir/$pkg_name  root@$host:$web_dir/
  # 停止以前对应名称的java 服务
	 ssh root@$host "jar_pid=$(ps aux | grep $pkg_process_name | awk '{print $2}') && kill $jar_pid"

	# 启动 java jar包
	ssh root@$host "nohup java -jar $web_dir/$pkg_name --server.port=$server_port &>/dev/null &"

	# 上线节点
	lbservers_enable $host	
	
	sleep 5
done


#解锁
rm -rf /tmp/lock

7.3 Jar包CD基于Ansible实现（Freestyle类型）

[root@jenkins scripts]# cat deploy_nexus_jar.yml 
- hosts: "{
    
    { deploy_webcluster }}"
  serial: 1
  vars:
    - web_dir: /opt
    - backend_name: jar_cluster
    - service_port: 8899

  tasks:
    # 获取jar包全路径
    - name: output full name of jar download
      shell:
        cmd: "echo ${java_deploy_package_url}"
      register: jar_name
      delegate_to: "127.0.0.1"

    # 获取jia包名称例如demo-service-2.0.jar
    - name: output jar pkg name
      shell:
        cmd: "echo ${java_deploy_package_url} | awk -F '/' '{print $NF}'"
      register: jar_pkg_name
      delegate_to: "127.0.0.1"
    

    - name: print jar_pkg_name
      debug:
        msg: "{
    
    { jar_pkg_name.stdout }}"

    # 基于包名提取demo-service用于启停java进程
    - name: get java process name
      shell:
        cmd: "name=$(echo ${java_deploy_package_url} | awk -F '/' '{print $NF}') &&  echo ${name%-*} "
      register: pkg_process_name
      delegate_to: "127.0.0.1"
      
    - name: print pkg_process_name
      debug:
        msg: "{
    
    { pkg_process_name.stdout  }}"

    # 从制品库中下载jar包
    - name: wget java jar packages
      get_url:
        url: "{
    
    { jar_name.stdout }}"
        dest: "{
    
    { web_dir }}/{
    
    { jar_pkg_name.stdout }}"
        username: admin
        password: admin
      delegate_to: "127.0.0.1"

    

    # 下线节点
    - name: stop haproxy webcluster pool node
      haproxy:
        socket: /var/lib/haproxy/stats
        backend: "backend_name"
        state: disabled
        host: "{
    
    { inventory_hostname }}"
      delegate_to: "{
    
    { item }}"
      loop: "{
    
    { groups['lbservers']}}"
  
   
   # 检查对应进程是否存在
    - name: check jar process status
      shell:
        cmd: "ps aux | grep {
    
    { pkg_process_name.stdout }} | grep -v grep | awk '{print $2}'"
      register: jar_pid
      ignore_errors: yes
   
    - name: print
      debug:
        msg: "{
    
    { jar_pid.stdout }}" 

   # 停止java服务
    - name: stop java service
      shell:
        cmd: "kill {
    
    { jar_pid.stdout }}"
      ignore_errors: yes

       
  
   # 检测对应的java服务是否已经关闭
    - name: check java port state
      wait_for:
        port: "{
    
    { service_port }}"
        state: stopped
   


   # 拷贝代码到远程
    - name: cope code to remote
      copy:
        src:  "{
    
    { web_dir }}/{
    
    { jar_pkg_name.stdout }}"
        dest: "{
    
    { web_dir }}/{
    
    { jar_pkg_name.stdout }}"

 
  # 启动java服务
    - name: start java server
      shell:
        cmd: "nohup java -jar {
    
    { web_dir }}/{
    
    { jar_pkg_name.stdout }} --server.port={
    
    { service_port }} &>/dev/null &"
  
   # 检测java是否已经启动，端口是否存活
    - name: check java  port state
      wait_for:
        port: "{
    
    { service_port }}"
        state: started



   # 上线节点
    - name: start haproxy webcluster pool node
      haproxy:
        socket: /var/lib/haproxy/stats
        backend: "backend_name"
        state: enabled
        host: "{
    
    { inventory_hostname }}"
      delegate_to: "{
    
    { item }}" # 委派给负载均衡节点
      loop: "{
    
    { groups['lbservers']}}"

在这里插入图片描述

7.4 前端提交代码，自动实现CI与CD ,并且部署到测试环境

克隆Spring-Hello-Jar-Ansible-CD项目为Spring-Hello-Jar-Ansible-CD-Auto-Test-Env
也就是Spring-Hello-Jar-Ansible-CD-Auto-Test-Env 项目的构建需要依赖于Spring-Hello-Naxus-Jar-CI项目
在这里插入图片描述
七层haproxy负载均衡配置

[root@proxy01 ~]# cat /etc/haproxy/conf.d/jekins_haproxy.cfg 
frontend www
	bind *:80
	mode http

	acl html_web hdr(host) -i html.bertwu.net
	use_backend web_cluster if html_web

	acl java_web hdr(host) -i war.bertwu.net
	use_backend java_cluster if java_web
	
	acl jar_web hdr(host) -i jar.bertwu.net
	use_backend jar_cluster if jar_web


	backend web_cluster
		balance roundrobin
		server 172.16.1.7 172.16.1.7:80 check port 80
		server 172.16.1.8 172.16.1.8:80 check port 80


	backend java_cluster
		balance roundrobin
		server 172.16.1.7 172.16.1.7:8080 check port 8080
		server 172.16.1.8 172.16.1.8:8080 check port 8080
		
	backend jar_cluster
		balance roundrobin
		server 172.16.1.7 172.16.1.7:8899 check port 8899
		server 172.16.1.8 172.16.1.8:8899 check port 8899
[root@proxy01 ~]#

猜你喜欢

转载自blog.csdn.net/m0_46090675/article/details/120926318
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
周排行
Python环境安装与基础语法（1）——计算机基础知识
IMU预积分
ADAS中的LDW、FCW、BSD、LCA、ACC、AEB、APA、DMS代表的含义
B站笔试两道题
skyeye arm 硬件虚拟机环境的搭建
Web前端静态页面示例
数组-合并排序数组 II-简单
springcloud之版本问题启动报错
面向对象-------------匿名对象(六)
输入URL到页面呈现中间发生了什么？
每日归档
更多
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022