Jenkins

---

前言

最近压测工作中使用的工具，以及测试环境的部署。

---

提示：以下是本篇文章正文内容，下面案例可供参考

首先整体的流程如下：

Jenkins流水线部署好了之后脚本拉取本地环境（包括机器人，测试case）；

Jenkins连接远程服务器，在所需要进行压测的服务器上通过脚本自动化部署测试机器人，释放压力；

Xshell连接测试服并监听收集进程数据和CPU的性能反馈；

一、Jenkins使用

流水线部署：

构造器配置：

服务器配置：

Build结束以后 显示：

接下来是key_name, stage_name和update：

最后是流水线以及脚本目录：

结束了Build，我们就准备开始压测环境的部署了

脚本拉取本地环境然后部署至远程服务器开始数据采集 （大约8min）；

构造结束意味着脚本部署结束，正式开始压测；

压测的时间根据不同的case会有不同的时间长度；

四台服务器采集到的数据将存储在data server上；

日志的路径也在这里：

如果不使用脚本部署，我们将需要自己手动去部署机器人：

• 第一步：在需要做压测的服务器上找到本地测试代码bptest；cd /data/bptest/robot/test
• 第二步：把需要压测的case的配置文件复制到机器人的配置； cp ./bptests/robot/不良人3\ -\ 压测脚本配置/${params.case}/BPTest.properties ./bptests/robot/BPTest.properties — 实际操作为根据case配置值vim进机器人这里手动改写：
• $ vim BPTest.properties
• 第三步：$ sh start.sh 启动机器人；
• 具体操作如图：
  

过程中可以启用对于data server代理:

等数据采集一段时间后，我们需要停止采集·关闭nmon进程
数据会导入路径 data server path（大约2min）；

如果我们不需要采集本次压测的数据，只是想要单纯地关闭压测进程 （大约10s）：

二、使用脚本

1.本地环境拉取

代码如下（示例）：

首先最外层是一个本地环境的打包，将这个环境包发配给各个需要进行压测的服务器，那么具体包里面包含什么,继续往下；

stages {
        stage('本地环境配置拉取') {
            environment {
                PATH = "/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/JDK_18151/bin" // overrides pipeline level NAME env variable
            }
            //切到上层目录将代码打包 然后 传递到每个服务器里  服务器是按照参数来配置吧
            steps {
                script {

构造的 console output：

我们看到走的是流水线的路径

正式开始第一步：拉key，服务器IP，case和数据库；

                    sh "cd .."
                    sh "echo 当前节点位置"
                    sh "pwd"
                    //开始参数化
                    sh "echo ${params.key_name}"
                    sh "echo ${params.ips}"
                    def ips = params.ips.split("\\,")
                    sh "echo ${ips}"
                    if(params.case !="")
                    {
                        sh "echo 当前开始执行case ${params.case}"
                        sh "\\cp ./bptests/robot/不良人3\\ -\\ 压测脚本配置/${params.case}/BPTest.properties ./bptests/robot/BPTest.properties"
                    }
                    if(params.dict !="")
                    {
                        sh "echo 当前开始执行dict ${params.dict}"
                        sh "\\cp ./bptests/robot/${params.dict} ./bptests/robot/dict.properties"
                    }

构造的 console output：

第二步就是对stage的判断了：如果走的是开始压测，branches生成分支，之后就有四条线分别调node_ip(ip);

                    if(params.update == "update")
                    {
                        def branches = [:]
                        ips.each { ip ->
                            branches[ip] = { ->
                                sh "echo 开始拷贝节点 ${ip}"
                                node_ip(ip)
                                sh "echo 完成拷贝节点 ${ip}"
                            }
                        }
                        //开始设置并发节点
                        sh "echo 开始执行并发节点"
                        parallel branches
                        sh "echo 完成并发节点"
                    }

构造的 console output：

第三步：node_ip(ip) : 就是拷贝每一个IP底下的目录，并将上一次的内容给删除，即为覆盖之前的内容；

def node_ip(ip) {
    def key_name = params.key_name
    //获取master节点工作目录
    String node_master_location = sh(script: "pwd", returnStdout: true).trim()
    //删除当前节点的目录
    String node_location = node_do("robot_${ip}", 2)
    //开始传递当前路径文件到指定目录
    scp_node(ip, node_master_location, node_location, key_name)
}

确认节点位置需要node_do() : 返回一个地址；

接着看这步底下scp() ：拷贝路径至我们指定的路径中并且授权；

def scp_node(param, node_master_location, node_location, key_name) {
    sh "cd ${node_master_location}"
    sh "pwd"
    sh "echo 当前目录 进行拷贝"
    sh "chmod 600 ${key_name}"
    //拷贝全部的吧  到时候可以选择拷贝也行 反正是自动化 而且是并发节点
    sh "scp -o StrictHostKeyChecking=no -P 11022  -i ${key_name}  -r ./ zhangsunqian@${param}:${node_location}"
}

构造的 console output：

接着走 nodes_do() 中 run_type==1: 调用 node_dos() 并且继续parallel branches；

node_dos():

def node_dos(ip,do_id,BPPath)
{
    node("robot_${ip}") {
        env.PATH="/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/JDK_18151/bin"
        script {
            if(do_id=="run") {
                node_run(BPPath)
            }else if(do_id =="stop") {
                node_stop(BPPath)
            }
        }
    }
}

调用node_run()即为正式开始在各个服务器上部署。

---

回到第二步：如果不走更新走停止 (run_type=2)，没有并行，那依然四个服务器直接调nodes_do()；

def nodes_do(ips,run_type,do_id,BPPath) {
    script {

        if (run_type == 1) {
            def branches = [:]
            ips.each { ip ->
                branches[ip] = { ->
                    sh "echo 开始执行并发节点${ip}"
                    node_dos(ip, do_id,BPPath)
                    sh "echo 完成当前并发节点${ip}"
                }
            }
            sh "echo 开始全部的并发节点"
            parallel branches
            sh "echo 完成全部的并发节点"
        } else {
            ips.each { ip ->
                sh "echo 开始执行串行的节点 ${ip}"
                node_dos(ip, do_id,BPPath)
                sh "echo 完成串行节点 ${ip}"
            }
        }
    }
}
然后走底下else，然后 node_stop()最终结束。

构造的 console output：

2.远程服务器部署

代码如下（示例）：

其实cp那步就是部署远程服务器了，用vim可以查到在本地修改过的channelID只有跑起来才能在压测服上检测到变动，这就是在部署：

在node_dos里面调用，
用来生成目录保存case位置；
用来把远程服务器上机器人 start——all；

def node_run(BPPath)
{
    sh  """
    sudo su root
    echo "${USER}"
    if [ ! -d /data${BPPath} ];then sudo mkdir /data${BPPath};fi
    sudo \\cp -f -r bptests/ /data${BPPath}
    cd /data${BPPath}/bptests/robot
    pwd
    sudo sh all.sh
    sudo sh start_all.sh /data${BPPath}/bptests/robot
    """
}

data server上的 start和 stop：

def node_server_run(path,time) {
    withEnv(['JENKINS_NODE_COOKIE=dontkillme']) {
        sh  """
    mkdir ${path}
    /work/script/nmon -f -s 10 -c ${time} -m ${path} &
    """
    }
}
def node_server_stop(path,logPath) {
    sh  """
    cp ${logPath} ${path} 
    """
}

构造的 console output：

（stop）