Continuous Integration के लिए Jenkins का उपयोग – Jenkins का परिचय और सेटअप

Continuous Integration (CI) डेवऑप्स की एक महत्वपूर्ण प्रक्रिया है, जो डेवलपर्स को अपने कोड को बार-बार और तेजी से मर्ज करने की सुविधा देती है। इस प्रक्रिया में Jenkins का उपयोग बेहद प्रभावी होता है, जो कोड बिल्डिंग और टेस्टिंग को ऑटोमेट करता है।

इस पोस्ट में हम समझेंगे कि Jenkins क्या है, इसे कैसे सेटअप किया जाता है, और Continuous Integration (CI) के लिए इसका उपयोग कैसे किया जा सकता है। Jenkins का सही तरीके से उपयोग करने से आपकी डिलीवरी प्रोसेस तेज़ हो जाती है और मैन्युअल त्रुटियों को कम किया जा सकता है।

Continuous Integration क्या है? (What is Continuous Integration?)

Continuous Integration (CI) एक ऐसी प्रैक्टिस है जिसमें डेवलपर्स लगातार अपने कोड को साझा रिपॉज़िटरी (Repository) में मर्ज करते रहते हैं। जैसे ही नया कोड मर्ज होता है, स्वचालित रूप से बिल्ड और टेस्ट चलाए जाते हैं, ताकि तुरंत यह जांचा जा सके कि कोई त्रुटि (Error) या बग (Bug) तो नहीं है। इस प्रक्रिया का उद्देश्य सॉफ़्टवेयर डेवेलपमेंट को तेज़ और अधिक विश्वसनीय बनाना है।

CI का मुख्य लाभ यह है कि यह डेवलपर्स को अपने कोड में बदलाव करने की स्वतंत्रता देता है, जबकि यह सुनिश्चित करता है कि उन बदलावों से सिस्टम में कोई गंभीर समस्या न हो। यदि किसी मर्ज किए गए कोड में कोई बग होता है, तो वह तुरंत पकड़ लिया जाता है और डेवलपर उसे ठीक कर सकता है, जिससे लंबे समय बाद बड़े बग्स से बचा जा सकता है।

Continuous Integration के मुख्य लाभ:

1. बग्स का जल्दी पता लगना:
   हर बार कोड को मर्ज करने के बाद स्वचालित टेस्टिंग के ज़रिए बग्स का तुरंत पता लग जाता है।
2. तेज़ी से डिलीवरी:
   कोड को बार-बार मर्ज और टेस्ट किया जाता है, जिससे सॉफ़्टवेयर की डिलीवरी तेज़ हो जाती है।
3. बेहतर सहयोग:
   सभी डेवलपर्स लगातार कोड के एक ही संस्करण पर काम करते हैं, जिससे टीम में बेहतर सहयोग और तालमेल बना रहता है।

Continuous Integration के बिना, डेवलपर्स को बड़े बदलावों के लिए लंबा इंतजार करना पड़ता है, जिससे मैन्युअल टेस्टिंग में समय लगता है और बग्स ढूंढना मुश्किल हो जाता है। CI डेवेलपर्स के लिए प्रक्रिया को तेज़ और कुशल बनाता है, जिससे वे जल्दी-जल्दी और छोटे-छोटे बदलाव कर सकते हैं।

Jenkins का इंस्टॉलेशन और सेटअप (Installing Jenkins)

Jenkins एक ओपन-सोर्स ऑटोमेशन टूल है जो Continuous Integration (CI) और Continuous Delivery (CD) को सक्षम बनाता है। Jenkins को सेटअप करना आसान है, और यह विभिन्न ऑपरेटिंग सिस्टम्स जैसे Windows, Linux, और macOS पर चल सकता है। इस सेक्शन में हम आपको Jenkins के इंस्टॉलेशन और सेटअप की प्रक्रिया समझाएंगे।

Jenkins को इंस्टॉल करने के लिए स्टेप्स:

1. Jenkins डाउनलोड करें:
   Jenkins को Jenkins की आधिकारिक वेबसाइट से डाउनलोड करें। आप अपने ऑपरेटिंग सिस्टम के लिए सही वर्ज़न चुनें (Windows, macOS, या Linux)।
2. Java इंस्टॉल करें:
   Jenkins को चलाने के लिए आपके सिस्टम में Java Development Kit (JDK) का इंस्टॉलेशन होना जरूरी है। आप JDK को Oracle या OpenJDK से डाउनलोड और इंस्टॉल कर सकते हैं।
   • Linux पर Java इंस्टॉलेशन:

     sudo apt update
     sudo apt install openjdk-11-jdk
     

      

   • Windows/macOS पर Java इंस्टॉलेशन:
     Oracle से JDK डाउनलोड करके सामान्य इंस्टॉलेशन प्रक्रिया को फॉलो करें।
3. Jenkins इंस्टॉल करें:
   • Windows पर इंस्टॉलेशन:
     • Jenkins डाउनलोड की गई .msi फ़ाइल को चलाएं और इंस्टॉलेशन गाइड को फॉलो करें।
   • Linux पर इंस्टॉलेशन (Ubuntu):

     sudo apt update
     sudo apt install jenkins
     

      

   • macOS पर इंस्टॉलेशन:
     • brew के माध्यम से Jenkins को इंस्टॉल करें:

       brew install jenkins-lts
       

        

4. Jenkins सर्वर को स्टार्ट करें:
   • Windows/macOS:
     इंस्टॉलेशन के बाद Jenkins सर्वर को स्टार्ट करें। डिफ़ॉल्ट रूप से यह आपके लोकलहोस्ट पर http://localhost:8080 पर एक्सेस किया जा सकता है।
   • Linux:

     sudo systemctl start jenkins
     sudo systemctl status jenkins
     

     अब आप Jenkins सर्वर को ब्राउज़र में http://localhost:8080 पर एक्सेस कर सकते हैं।

5. 1. इनीशियल एडमिन पासवर्ड: जब आप पहली बार Jenkins को एक्सेस करेंगे, तो यह आपसे इनीशियल एडमिन पासवर्ड मांगेगा। यह पासवर्ड आपके सिस्टम में /var/lib/jenkins/secrets/initialAdminPassword फाइल में स्टोर किया गया होता है। आप इस फाइल से पासवर्ड कॉपी करके ब्राउज़र में डाल सकते हैं।
   2. Jenkins को कस्टमाइज़ करें:
      • Suggested प्लगइन्स इंस्टॉल करें: Jenkins की इनीशियल सेटअप प्रक्रिया के दौरान, यह आपको “Suggested Plugins” इंस्टॉल करने का विकल्प देगा। इन प्लगइन्स को इंस्टॉल करें ताकि आपको बेसिक Jenkins फीचर्स का इस्तेमाल आसानी से मिल सके।
      • Admin यूज़र क्रिएट करें: Jenkins सेटअप के बाद, एक Admin यूज़र क्रिएट करें जिससे आप भविष्य में Jenkins को मैनेज कर सकें।

    

Jenkins सेटअप पूरा हो गया है!

अब Jenkins का सेटअप पूरा हो चुका है, और आप अपनी पहली Jenkins जॉब बनाने के लिए तैयार हैं। अगले सेक्शन में हम देखेंगे कि Jenkins में Continuous Integration (CI) के लिए जॉब कैसे सेट की जाती है।

Jenkins को Git के साथ इंटीग्रेट करना (Integrating Jenkins with Git)

Continuous Integration (CI) प्रक्रिया को प्रभावी ढंग से संचालित करने के लिए Jenkins को Git के साथ इंटीग्रेट करना बेहद जरूरी होता है। Jenkins और Git का इंटीग्रेशन यह सुनिश्चित करता है कि जब भी डेवलपर अपने कोड को Git रिपॉज़िटरी में मर्ज करता है, Jenkins उसे ऑटोमेटेड तरीके से बिल्ड और टेस्ट कर सके। इस सेक्शन में हम Git और Jenkins को इंटीग्रेट करने की प्रक्रिया को समझेंगे।

Jenkins और Git को इंटीग्रेट करने के लिए स्टेप्स:

1. Git प्लगइन इंस्टॉल करें:
   • सबसे पहले, Jenkins में Git प्लगइन इंस्टॉल करना जरूरी है। इसके लिए आप निम्नलिखित स्टेप्स फॉलो कर सकते हैं:
     • Jenkins डैशबोर्ड पर जाएं।
     • “Manage Jenkins” विकल्प पर क्लिक करें।
     • “Manage Plugins” चुनें।
     • “Available” टैब में जाकर “Git Plugin” सर्च करें और इसे इंस्टॉल करें।
2. Git को Jenkins सर्वर पर इंस्टॉल करें:
   • Jenkins को Git कमांड्स को समझने के लिए आपके सिस्टम पर Git का इंस्टॉलेशन होना चाहिए।
   • Linux पर Git इंस्टॉल करें:

     sudo apt-get install git
     

      

   • Windows/macOS पर Git इंस्टॉल करें:
     Git Git की आधिकारिक वेबसाइट से डाउनलोड और इंस्टॉल करें।
3. Jenkins जॉब में Git रिपॉज़िटरी को कॉन्फ़िगर करें:
   • Jenkins डैशबोर्ड में जाकर “New Item” पर क्लिक करें और एक नई जॉब बनाएं।
   • “Freestyle Project” का चयन करें और अपनी जॉब को नाम दें।
   • जॉब के सेटअप में, “Source Code Management” सेक्शन में “Git” को चुनें।
   • Git रिपॉज़िटरी का URL दर्ज करें (यह आपके GitHub, GitLab या किसी अन्य Git रिपॉज़िटरी का URL हो सकता है)।
     • उदाहरण:

       https://github.com/yourusername/yourrepository.git
       

        

     • यदि आपकी रिपॉज़िटरी प्राइवेट है, तो आपको अपने Git क्रेडेंशियल्स को भी एड करने की जरूरत होगी। “Add” बटन पर क्लिक करके अपने GitHub/GitLab यूज़रनेम और पासवर्ड को दर्ज करें।
4. ब्रांच स्पेसिफिकेशन (Branch Specification) सेट करें:
   • यदि आप किसी विशेष ब्रांच पर काम कर रहे हैं, तो आप “Branches to build” सेक्शन में उस ब्रांच का नाम डाल सकते हैं। डिफ़ॉल्ट रूप से, Jenkins “master” या “main” ब्रांच को ट्रैक करता है।
   • उदाहरण:

     */main
     

      

5. Build ट्रिगर सेट करें:
   • अब आप Jenkins को सेट कर सकते हैं कि वह कब बिल्ड चलाए। इसके लिए “Build Triggers” सेक्शन में जाएं।
   • “Poll SCM” विकल्प को सेलेक्ट करें और समय का पैटर्न सेट करें। उदाहरण के लिए, अगर आप चाहते हैं कि Jenkins हर 15 मिनट में Git रिपॉज़िटरी चेक करे, तो क्रॉन पैटर्न इस प्रकार होगा:

     H/15 * * * *
     

      

6. बिल्ड स्टेप्स कॉन्फ़िगर करें:
   • “Build” सेक्शन में, आप अपने प्रोजेक्ट के लिए बिल्ड कमांड्स सेट कर सकते हैं। उदाहरण के लिए, यदि आप Maven या Gradle का उपयोग कर रहे हैं, तो आप संबंधित बिल्ड स्टेप्स सेट कर सकते हैं।
   • यदि आप एक साधारण स्क्रिप्ट चलाना चाहते हैं, तो आप “Execute Shell” विकल्प का उपयोग कर सकते हैं और अपने बिल्ड कमांड्स डाल सकते हैं।
7. जॉब को सेव करें और बिल्ड करें:
   • अपनी जॉब की सेटिंग्स को सेव करें और “Build Now” पर क्लिक करके मैन्युअल रूप से बिल्ड करें। यदि सब कुछ सही सेट किया गया है, तो Jenkins Git रिपॉज़िटरी से कोड को क्लोन करेगा और बिल्ड प्रक्रिया को शुरू करेगा।

Jenkins और Git का इंटीग्रेशन सफल हुआ!

अब जब भी आप अपने कोड को Git में पुश करेंगे, Jenkins उसे ऑटोमेटेड तरीके से बिल्ड और टेस्ट करेगा। इस इंटीग्रेशन से डेवलपर्स लगातार अपने कोड में सुधार कर सकते हैं और Continuous Integration प्रक्रिया को पूरी तरह से ऑटोमेट कर सकते हैं।

Jenkinsfile के द्वारा पाइपलाइन (Pipeline as Code with Jenkinsfile)

Jenkins में Pipeline as Code की अवधारणा का प्रमुख हिस्सा Jenkinsfile है। Jenkinsfile एक टेक्स्ट फाइल होती है जिसमें Jenkins पाइपलाइन कोड लिखा जाता है। इसका सबसे बड़ा फायदा यह है कि आप अपने पाइपलाइन को वर्शन कंट्रोल सिस्टम (जैसे Git) में सेव कर सकते हैं, जिससे आप पाइपलाइन के इतिहास और बदलावों को ट्रैक कर सकते हैं। Jenkinsfile के ज़रिए Continuous Integration और Continuous Delivery (CI/CD) की पूरी प्रक्रिया को ऑटोमेट किया जा सकता है।

Jenkinsfile क्या है?

Jenkinsfile एक स्क्रिप्टेड या डिक्लेयरेटिव पाइपलाइन होती है, जो Jenkins को यह बताती है कि बिल्ड, टेस्ट, और डिलीवरी प्रोसेस कैसे ऑटोमेट किया जाए। Jenkinsfile कोड फाइल के रूप में Git रिपॉज़िटरी में सेव किया जाता है, जिससे पाइपलाइन कोड में किसी भी तरह के बदलाव आसानी से ट्रैक किए जा सकते हैं।

Jenkinsfile के प्रकार:

1. डिक्लेयरेटिव पाइपलाइन (Declarative Pipeline):
   • यह Jenkinsfile लिखने का सबसे सरल तरीका है और इसे पढ़ना और समझना आसान होता है। इसमें pipeline ब्लॉक के साथ पाइपलाइन को परिभाषित किया जाता है।

   उदाहरण:

   pipeline {
       agent any
       stages {
           stage('Build') {
               steps {
                   echo 'Building...'
               }
           }
           stage('Test') {
               steps {
                   echo 'Testing...'
               }
           }
           stage('Deploy') {
               steps {
                   echo 'Deploying...'
               }
           }
       }
   }
   

    

2. स्क्रिप्टेड पाइपलाइन (Scripted Pipeline):
   • स्क्रिप्टेड पाइपलाइन Jenkinsfile का एक अधिक फ्लेक्सिबल रूप है। इसमें Groovy स्क्रिप्ट का उपयोग करके पाइपलाइन को लिखा जाता है। यह अधिक कंट्रोल और कस्टमाइज़ेशन प्रदान करता है।

   उदाहरण:

   node {
       stage('Build') {
           echo 'Building...'
       }
       stage('Test') {
           echo 'Testing...'
       }
       stage('Deploy') {
           echo 'Deploying...'
       }
   }
   

    

Jenkinsfile को कैसे उपयोग करें:

1. Git रिपॉज़िटरी में Jenkinsfile बनाएं:
   • सबसे पहले, अपनी Git रिपॉज़िटरी में एक फाइल बनाएं और उसका नाम Jenkinsfile रखें। इसमें अपने पाइपलाइन के स्टेप्स लिखें, जैसे कि Build, Test, और Deploy स्टेजेज़।
2. Jenkins में पाइपलाइन जॉब बनाएं:
   • Jenkins डैशबोर्ड में जाएं और “New Item” पर क्लिक करें।
   • “Pipeline” प्रोजेक्ट चुनें और इसे एक नाम दें।
   • “Pipeline Definition” सेक्शन में “Pipeline script from SCM” का चयन करें।
   • इसके बाद अपने Git रिपॉज़िटरी का URL दर्ज करें, जहाँ आपने Jenkinsfile को सेव किया है।
3. ब्रांच और क्रेडेंशियल्स सेट करें:
   • यदि आप किसी विशेष ब्रांच पर काम कर रहे हैं, तो आप ब्रांच का नाम सेट कर सकते हैं।
   • यदि रिपॉज़िटरी प्राइवेट है, तो क्रेडेंशियल्स भी जोड़ें।
4. जॉब को सेव करें और बिल्ड करें:
   • जॉब सेटिंग्स को सेव करें और “Build Now” पर क्लिक करें। Jenkins आपके Jenkinsfile को पढ़ेगा और उसमें परिभाषित स्टेजेज़ को ऑटोमेट करेगा।

Jenkinsfile के फायदे:

• पाइपलाइन का वर्शन कंट्रोल: Jenkinsfile को Git रिपॉज़िटरी में सेव किया जा सकता है, जिससे पाइपलाइन के बदलावों को ट्रैक और मैनेज करना आसान होता है।
• दोबारा उपयोग करना: एक बार Jenkinsfile सेटअप हो जाने के बाद, इसे आसानी से अन्य प्रोजेक्ट्स के लिए भी उपयोग किया जा सकता है।
• Collaborative Development: पूरी टीम एक ही पाइपलाइन स्क्रिप्ट पर काम कर सकती है और इसे रिपॉज़िटरी में अपडेट कर सकती है।