# 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 包)

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. 测试并验证效果

此文章已被阅读次数:正在加载...更新于

请我喝[茶]~( ̄▽ ̄)~*

Xu Yong 微信支付

微信支付

Xu Yong 支付宝

支付宝