(एजेंट कोई नहीं) एक कथात्मक पाइपलाइन चरण के लिए एक हल्के निष्पादक का प्रयोग करें

Question

मैं कथात्मक वाक्य रचना के साथ जेनकींस पाइपलाइन का उपयोग कर रहा है निम्न चरणों के साथ वर्तमान में,:

2. बिल्ड (दो समानांतर चरणों के सेट तैयार करें)
3. टेस्ट (भी दो कदम के समानांतर सेट)
4. अगर/जहां
5. तैनात

तैनात करने के लिए पूछें

चरण 1, 2, 3, और 5 के लिए मुझे आवश्यकता है और एजेंट (एक निष्पादक) क्योंकि वे कार्यक्षेत्र पर वास्तविक कार्य करते हैं। चरण 4 के लिए, मुझे एक की आवश्यकता नहीं है, और मैं उपयोगकर्ता इनपुट की प्रतीक्षा करते समय अपने उपलब्ध निष्पादकों को अवरुद्ध नहीं करना चाहता हूं। इसे क्लासिक, लिखित वाक्यविन्यास के लिए या तो "फ्लाईवेट" या "लाइटवेट" निष्पादक के रूप में जाना जाता है, लेकिन मुझे घोषणात्मक वाक्यविन्यास के साथ इसे प्राप्त करने के तरीके के बारे में कोई जानकारी नहीं मिल रही है।

अब तक मैं कोशिश की है:

1. सीधे एक एजेंट की स्थापना पाइप लाइन विकल्प में, और उसके बाद मंच पर agent none की स्थापना। इसका कोई प्रभाव नहीं पड़ता है, और पाइपलाइन मानक के रूप में चलती है, इनपुट के इंतजार के दौरान निष्पादक को अवरुद्ध करती है। दस्तावेज में यह भी उल्लेख किया गया है कि इसका कोई प्रभाव नहीं पड़ेगा, लेकिन मैंने सोचा कि मैं इसे एक शॉट भी दूंगा।
2. पाइपलाइन विकल्पों में agent none सेट करना, और फिर # 4 को छोड़कर प्रत्येक चरण के लिए एजेंट सेट करना। दुर्भाग्यवश, लेकिन उम्मीद है कि, यह हर चरण के लिए एक नया कार्यक्षेत्र आवंटित करता है, जिसके बदले में मुझे छेड़छाड़ और अनावश्यकता की आवश्यकता होती है। यह दोनों गन्दा है और मुझे समानांतर चरणों (2 और 3) में और समस्याएं देता है क्योंकि मेरे पास parallel निर्माण के बाहर कोड नहीं हो सकता है। मुझे लगता है कि समान कार्यक्षेत्र में समानांतर कदम चलते हैं, इसलिए दोनों में छेड़छाड़/अस्थिरता के दुर्भाग्यपूर्ण परिणाम होंगे।

यहाँ मेरी Jenkinsfile की एक रूपरेखा है:

pipeline { 
    agent { 
     label 'build-slave' 
    } 
    stages { 
     stage("Prepare build") { 
      steps { 
       // ... 
      } 
     } 
     stage("Build") { 
      steps { 
       parallel(
        frontend: { 
         // ... 
        }, 
        backend: { 
         // ... 
        } 
       ) 
      } 
     } 
     stage("Test") { 
      steps { 
       parallel(
        jslint: { 
         // ... 
        }, 
        phpcs: { 
         // ... 
        }, 
       ) 
      } 
      post { 
       // ... 
      } 
     } 
     stage("Select deploy target") { 
      steps { 
       script { 
        // ... code that determines choiceParameterDefinition based on branch name ... 
        try { 
         timeout(time: 5, unit: 'MINUTES') { 
          deployEnvironment = input message: 'Deploy target', parameters: [choiceParameterDefinition] 
         } 
        } catch(ex) { 
         deployEnvironment = null 
        } 
       } 
      } 
     } 
     stage("Deploy") { 
      when { 
       expression { 
        return binding.variables.get("deployEnvironment") 
       } 
      } 
      steps { 
       // ... 
      } 
     } 
    } 
    post { 
     // ... 
    } 
} 

मैं यहाँ कुछ कमी कर रहा हूँ, या यह वर्तमान संस्करण में सिर्फ नहीं हो सकता है?

Answer 1

input मंच पर फिर से हर स्तर पर शीर्ष स्तर पर स्थापना agent none, तो agent { label 'foo' }, agent none साथ के रूप में मेरे लिए उम्मीद से काम करने लगता है।

यानी प्रत्येक चरण जो कुछ काम करता है उसी एजेंट पर चलता है, जबकि input चरण किसी भी एजेंट पर निष्पादक का उपभोग नहीं करता है।

pipeline { 
    agent none 
    stages { 
     stage("Prepare build") { 
      agent { label 'some-agent' } 
      steps { 
       echo "prepare: ${pwd()}" 
      } 
     } 
     stage("Build") { 
      agent { label 'some-agent' } 
      steps { 
       parallel(
        frontend: { 
         echo "frontend: ${pwd()}" 
        }, 
        backend: { 
         echo "backend: ${pwd()}" 
        } 
       ) 
      } 
     } 
     stage("Test") { 
      agent { label 'some-agent' } 
      steps { 
       parallel(
        jslint: { 
         echo "jslint: ${pwd()}" 
        }, 
        phpcs: { 
         echo "phpcs: ${pwd()}" 
        }, 
       ) 
      } 
     } 
     stage("Select deploy target") { 
      agent none 
      steps { 
       input message: 'Deploy?' 
      } 
     } 
     stage("Deploy") { 
      agent { label 'some-agent' } 
      steps { 
       echo "deploy: ${pwd()}" 
      } 
     } 
    } 
} 

हालांकि, वहाँ कोई गारंटी नहीं कि एक पाइप लाइन के भीतर एक ही एजेंट लेबल का उपयोग हमेशा की तरह, जैसे एक ही कार्यक्षेत्र का उपयोग कर खत्म हो जाएगा रहे हैं जैसा कि पहला निर्माण एक ही नौकरी का निर्माण करता है जबकि पहला निर्माण input पर इंतजार कर रहा है।

बिल्ड चरणों के बाद आपको stash का उपयोग करना होगा। जैसा कि आप ध्यान देते हैं, इस समय यह सामान्य रूप से parallel के साथ नहीं किया जा सकता है, इसलिए आपको समानांतर चरणों के बाद/पहले छेड़छाड़/अनस्टैशिंग के लिए स्क्रिप्टेड पाइपलाइन का स्निपेट लिखने के लिए script ब्लॉक का अतिरिक्त उपयोग करना होगा।