Параллельное выполнение Jenkins на основе количества ядер с декларативным конвейером

Question

Я использую Jenkins с декларативным конвейером. У меня есть машина Jenkins с 8 ядрами, выполняющими любое количество шагов (скажем, 20) параллельно. Проблема в том, что слишком много задач выполняются параллельно, а некоторые тесты не выполняются из-за проблем с тайм-аутом.

Мне нужен способ, чтобы Дженкинс выполнил 20 тестов параллельно, но только 8 одновременно. Таким образом, сначала я сделаю более длинные шаги, а затем более быстрые. Как только он завершает один из более длинных шагов, он должен немедленно начать следующий, пока остальные 7 еще работают. Примерно так, но только по 8 за раз:

            steps {
                parallel(
                    runtest1:
                    {
                        dostep()
                    },
                    runtest2:
                    {
                        dostep()
                    },
                    runtest3: 
                    {
                        dostep()
                    },
                    runtest4: 
                    {
                        dostep()
                    },
                    runtest5:
                    {
                        dostep()
                    },
                    runtest6:
                    {
                        dostep()
                    },
                    runtest7:
                    {
                        dostep()
                    },
                    runtest8:
                    {
                        dostep()
                    },
                    runtest9:
                    {
                        dostep()
                    }
                    runtest10:
                    {
                        dostep()
                    },
                    runtest11:
                    {
                        dostep()
                    },
                    runtest12:
                    {
                        dostep()
                    },
                    runtest13: 
                    {
                        dostep()
                    },
                    runtest14: 
                    {
                        dostep()
                    },
                    runtest15:
                    {
                        dostep()
                    },
                    runtest16:
                    {
                        dostep()
                    },
                    runtest17:
                    {
                        dostep()
                    },
                    runtest18:
                    {
                        dostep()
                    },
                    runtest19:
                    {
                        dostep()
                    },
                    runtest20:
                    {
                        dostep()
                    }
                )

            }
        }

Сегодня с параллельным () он будет запускать все тесты только тогда, когда он будет сделан со всем, он go перейдет на следующий этап, на котором он будет выполните следующие параллельные шаги.

Answer 1

Ваш код попытается запустить все эти тесты параллельно на одном агенте. Это может быть не то, что вы хотите. Вы можете попробовать запустить все этапы параллельно на разных агентах: https://jenkins.io/blog/2017/09/25/declarative-1/

stages {
    stage('Run Tests') {
        parallel {
            stage('Test 1') {
                agent { label "8-core-agent" }
                steps {
                    doTheTest()
                }
            }
            stage('Test 2') {
                agent { label "8-core-agent" }
                steps {
                    doTheTest()
                }
            }
        }
...

Если вы просто запускаете сборку на главном сервере или на одном агенте, вы, вероятно, можете использовать Приведенный выше метод делит ваши тесты на этапы: stage('test 1-8') ... stage('test 9-16') et c

Если вы установите число исполнителей на 8-core-agent на 8, Дженкинс должен запланировать 8 из этих задач за один раз, пока они все не сделали.