登录
转载

Jenkins-Pipeline单stage控制并发构建流程,限制并发线程数量

发布于 2021-03-19 阅读 732
  • 前端
  • JavaScript
  • HTML
转载

一、这是一个demo

不单单用作并发构建docker镜像,因为使用sh'''  也是shell,也可作用其他类似用途

Jenkins并发还有另一个写法(详情看 在下面第四个)(不好扩展,新增并发步骤需要写上)

而单stage并发可让传入的参数个数去控制流程步骤,如传入S1-S18会有18个步骤,传入S1-S5就会生成5个

 

二、pipeline

def build_docker(service) {
    stages = {
        def thing = null
        waitUntil {
            // 获取一个资源
            thing = latch.pollFirst();
            return thing != null;
        }
        try {
            // 执行步骤 
            stage("构建${service}服务Docker镜像") {
                withEnv(["service=${service}"]){
                sh '''
                    echo "正在构建 ${service} 镜像"
                    sleep 15
                '''
                }
            }
        }
        finally {
            // 释放一个资源
            latch.offer(thing)
        }        
    }
    return stages
}

pipeline {
    agent {
        node {
            label "master"
        }
    }

    environment {
        // 规范:从Jenkins传入的变量,必须在这里填写后在引用
        build_com = "${build_com}"
    }
            
    parameters {
        // 参数化构建
        string defaultValue: 'S1 S2 S3 S4 S5 S6 S7 S8 S9 S10 S11 S12 S13 S14 S15 S16 S17 S18', description: '需要构建的服务', name: 'build_com', trim: true
    }
 
    options {
        // 添加控制台时间戳
        timestamps()
        // 超时时间/分
        timeout(30)
        // 不允许并发编译
        disableConcurrentBuilds()
    }

    stages {
        stage("开始") {
            steps {
                script {
                    sh '''
                         echo "start"
                    '''
                }
            }
        }
        
        stage("并发进行构建Docker镜像") {
            steps {
                script {
                    def stages = [:]
                    // 并行进程数量
                    MAX_CONCURRENT = 5
                    // 创建fifo
                    latch = new java.util.concurrent.LinkedBlockingDeque(MAX_CONCURRENT)
                     
                    // 往fifo中,填入最大个数元素
                    for(int i=0; i<MAX_CONCURRENT; i++)
                        latch.offer("$i")
                    
                    // 循环获取传入的值
                    for (service in build_com.tokenize(' ')){
                        stages[service] = build_docker(service)
                    }
                    // 并行步骤
                    parallel stages
                }
            }
        }
        
        stage("结束") {
            steps {
                script {
                    sh '''
                        echo "done"
                    '''
                }
            }
        }
        
    }
}

注意项:不要勾选使用 Groovy 沙盒

不然会出错误

org.jenkinsci.plugins.scriptsecurity.sandbox.RejectedAccessException: Scripts not permitted to use new java.util.concurrent.LinkedBlockingDeque int

三、结果图

 

 

四、另一种Jenkins并发写法

pipeline {

    agent {
            node {
                label "master"
            }
    }

    stages {

        stage('开始') {
            steps {
                sh '''
                    echo "start"
                '''
            }
        }

        stage('并发步骤') {
            parallel {
                stage('步骤1') {
                    steps {
                        sh '''
                            echo "步骤1"
                        '''
                    }
                }

                stage('步骤2') {
                    steps {
                        sh '''
                            echo "步骤2"
                        '''
                        }
                    }

                }
            }
        }

        stage('结束') {
            steps {
                sh '''
                    echo "done"
                '''
            }
        }
                
    }
}

 

评论区

励志做一条安静的咸鱼,从此走上人生巅峰。

0

0

0

举报