👟 🧑🏿 🛳️ एंड्रॉइड के लिए जेनकिन्स docker का उपयोग करके निर्माण करते हैं 🌐 🌀 🙋

सभी को नमस्कार!

मैं एक एंड्रॉइड डेवलपर के रूप में काम करता हूं, और इतनी देर पहले हम अपने प्रोजेक्ट पर कुछ नियमित कार्यों में भाग नहीं लेते हैं जिन्हें हम स्वचालित करना चाहते हैं। उदाहरण के लिए, हमारे पास 5 अलग-अलग स्वाद हैं, जिनमें से प्रत्येक के लिए हमें अपने निर्माण को कपड़े पर अपलोड करने की आवश्यकता है, कभी-कभी दिन में कई बार अलग-अलग गाड़ियों के लिए। हां, यह कार्य श्रेणीबद्ध कार्य के साथ किया जा सकता है, लेकिन मैं इस प्रक्रिया को डेवलपर की मशीन पर नहीं चलाना चाहूंगा, लेकिन इसे किसी भी तरह केन्द्रित करूंगा। या उदाहरण के लिए, स्वचालित रूप से बिल्ड को google play में बीटा में अपलोड करें। खैर, मैं सिर्फ CI सिस्टम चुनना चाहता था। यह क्या हुआ, और हमने इसे कैसे सेट किया, डॉकटर क्यों है, बाद में लेख में।

मेरी समझ में, पूरा कार्य लगभग दो चरणों में विभाजित था:

एंड्रॉइड एसडीके के साथ जेनकिंस को स्वयं स्थापित और कॉन्फ़िगर करें
जेनकिंस के अंदर पहले से ही कार्य सेट करें

इस लेख में, मैं पहले बिंदु पर स्पर्श करना चाहता हूं, और यदि यह किसी के लिए भी रुचि रखता है, तो अगले लेख में मैं जेनकिंस में विधानसभा कार्यों को स्थापित करने की प्रक्रिया का वर्णन करूंगा।

तो, पहला बिंदु जेनकिंस सिस्टम की स्थापना और कॉन्फ़िगरेशन है

इस विषय पर हैबेरा का पहले से ही एक अद्भुत लेख है , लेकिन वह पहले से ही कुछ वर्षों का है, और इसमें कुछ चीजें थोड़ी पुरानी हैं (उदाहरण के लिए sdkmanager), हालांकि उसने मुझे यह पता लगाने में बहुत मदद की कि शुरुआती चरणों में क्या करना है।

यदि आप जेनकिंस स्थापित करने के लिए आधिकारिक दस्तावेज को देखते हैं, तो हम ऐसा करने के तीन अलग-अलग तरीके देखेंगे: एक तैयार किए गए डॉकटर छवि को लॉन्च करें, और एक युद्ध फ़ाइल को डाउनलोड करें, और सिस्टम में सामान्य रूप से जेनकींस भी स्थापित करें (उदाहरण के लिए, उदाहरण के लिए ubuntu का उपयोग करके apt-get install jenkins )। पहला विकल्प सबसे सही है, क्योंकि यह हमारे होस्ट सिस्टम में किसी भी अनावश्यक सेटिंग्स और निर्भरता को नहीं ले जाता है, और किसी भी समय कुछ गलत होने पर भी, सब कुछ हटाना और फिर से शुरू करना आसान और सरल है। लेकिन जेनकिंस के लिए मानक डॉकटर छवि में कुछ डेटा होते हैं जिनकी हमें आवश्यकता नहीं होती है (उदाहरण के लिए, ब्लूचियन प्लगइन) और इसमें वे शामिल नहीं हैं जिनकी हमें निश्चित रूप से आवश्यकता होगी (उदाहरण के लिए, एंड्रॉइड sdk)। हमारी खुद की डॉक छवि बनाने का निर्णय लिया गया था कि इसके अंदर युद्ध फ़ाइल डाउनलोड और चलाने के लिए, एंड्रॉइड एसडीके डाउनलोड और इंस्टॉल करना होगा, साथ ही साथ अन्य सभी सेटिंग्स को कॉन्फ़िगर करना होगा जो हमें चाहिए। इसे बाद में शुरू करने के लिए, हमें डॉकटर स्थापित के साथ एक मेजबान प्रणाली की आवश्यकता है। मैं यहां सुझाव देता हूं कि पहिया को सुदृढ़ न करें और DigitalOcean का उपयोग करें।

वर्चुअल मशीन बनाएं और कॉन्फ़िगर करें

शुरू करने के लिए, अगर कोई और वहां पंजीकृत नहीं है, तो मैं पंजीकरण करने का सुझाव देता हूं (यहां लेख लिखने के समय एक रेफरल लिंक था, लेकिन नियमों को पढ़ने के बाद मैंने इसे फेंक दिया)। पंजीकरण के बाद, आप इंटरनेट पर एक या किसी अन्य प्रचार कोड को गूगल कर सकते हैं, और शुरू करने के लिए लगभग 10 रुपये प्राप्त कर सकते हैं।

के बाद हम एक नई छोटी बूंद पाने की जरूरत है। आइटम बूंदों का चयन करें, और फिर ड्रॉपलेट बनाएँ ।

होस्ट सिस्टम Ubuntu 18.04 है। आप पहले से स्थापित और कॉन्फ़िगर किए गए डॉकर के साथ एक छवि चुन सकते हैं, लेकिन हम अपने दम पर सब कुछ करेंगे। चूंकि एंड्रॉइड बिल्ड की असेंबली अभी भी संसाधन-गहन है, इसलिए हमें कम से कम 20 रुपये के लिए एक कॉन्फ़िगरेशन चुनने की आवश्यकता है ताकि बिल्ड सामान्य रूप से और अपेक्षाकृत जल्दी से एकत्र हो सकें।

हम (जर्मनी में, उदाहरण के लिए) एक नज़दीकी स्थान चुनेंगे। फिर दो विकल्प हैं कि हम अपने वर्चुअल सर्वर से कैसे जुड़ेंगे। हम एक ssh कुंजी जोड़ सकते हैं या इसके बिना कर सकते हैं। यदि इस स्थान पर हम यह इंगित नहीं करते हैं कि किस कुंजी का उपयोग करना है, तो रूट उपयोगकर्ता के लिए पासवर्ड हमारे मेल पर भेजा जाएगा।

यहां हम सर्वर का नाम बदल सकते हैं, और क्रिएट बटन पर क्लिक करके निर्माण को पूरा कर सकते हैं।

अब हम बनाई गई छोटी बूंद में जाते हैं, और आगे के कनेक्शन और कॉन्फ़िगरेशन के लिए खुद के लिए आईपी पते की नकल करते हैं।

हमें एक ssh क्लाइंट चाहिए। यदि आप एक खसखस के तहत काम करते हैं, तो आप मानक टर्मिनल का उपयोग कर सकते हैं, अगर विंडोज के तहत हम काम करने के लिए पोटीन का उपयोग कर सकते हैं या लिनक्स सबसिस्टम (केवल विंडोज 10 के लिए) का उपयोग कर सकते हैं। मैं व्यक्तिगत रूप से बाद वाले विकल्प का उपयोग करता हूं, और यह पूरी तरह से मुझे सूट करता है।

निम्नलिखित कमांड का उपयोग करके हमारे सर्वर से कनेक्ट करें

 ssh root@YOUR_IP_ADDRESS

कंसोल आपको कुंजी को सहेजने की पेशकश करेगा, हम इससे सहमत हैं। कनेक्ट करने के बाद, हम खुद के लिए एक नया उपयोगकर्ता बनाएंगे, इसे सुपरसर्स में जोड़ें (और उसे पासवर्ड के बिना sudo का उपयोग करने का अवसर दें), उसे ssh के माध्यम से एक्सेस की कुंजी की प्रतिलिपि बनाएँ और कहें कि वह इन फ़ाइलों का स्वामी है (अन्यथा यह काम नहीं करेगा)। उपयोगकर्ता नाम आपके लिए किसी भी सुविधाजनक में बदल दिया गया है।

 useradd -m -s /bin/bash username \ && echo 'username ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers \ && mkdir /home/username/.ssh \ && cp /root/.ssh/authorized_keys /home/username/.ssh/authorized_keys \ && chown username:username -R /home/username/.ssh

कमांड से रूट से डिस्कनेक्ट करें

 exit

और हम पहले से ही बनाए गए नए उपयोगकर्ता की मदद से फिर से कनेक्ट करेंगे

 ssh username@YOUR_IP_ADDRESS

जब हम सिस्टम को अपडेट करते हैं, और हमारे सर्वर को रिबूट करते हैं (यदि अपडेट प्रक्रिया के दौरान सिस्टम आपसे कुछ पूछेगा, तो यह हमेशा इस मामले में डिफ़ॉल्ट मानों को चुनने के लिए पर्याप्त है)।

 sudo apt update && sudo apt full-upgrade -y && sudo apt autoremove -y && sudo reboot

मूल सेटअप पूरा हो गया है। युद्ध प्रणाली के दृष्टिकोण से, यह बहुत सुरक्षित नहीं है, लेकिन इस लेख के ढांचे के भीतर यह पूरी तरह से उपयुक्त है।

डॉकर स्थापित करें।

हमारे सिस्टम में डॉकर को स्थापित करने के लिए, हम आधिकारिक दस्तावेज का उपयोग करेंगे। चूंकि हमारे पास एक नया स्थापित सिस्टम है, हम इस बिंदु को छोड़ देंगे, और यदि आपके पास एक ऐसी प्रणाली है जिस पर कुछ समय से कुछ चल रहा है, डॉकर से लोगों की सिफारिश पर, संभव पुराने संस्करणों को हटा दें

 sudo apt-get remove docker docker-engine docker.io containerd runc

हमारे सर्वर पर पहले ssh के माध्यम से वापस कनेक्ट करने के लिए मत भूलना। डॉकटर की स्थापना को प्रलेखन में बहुत विस्तार से वर्णित किया गया है, मैं इसे आपके लिए आसान बनाने के लिए सामान्य आदेश दूंगा। वे जो करते हैं, वहीं पढ़ा जा सकता है। सबसे पहले रिपॉजिटरी को जोड़ें।

 sudo apt update \ && sudo apt install -y apt-transport-https ca-certificates \ curl gnupg-agent software-properties-common \ && curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - \ && sudo apt-key fingerprint 0EBFCD88 \ && sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

और उसके बाद खुद डॉकर स्थापित करें:

 sudo apt update && sudo apt install -y docker-ce docker-ce-cli containerd.io

ताकि भविष्य में हम sudo उपसर्ग के बिना docker कमांड को कॉल कर सकें, निम्नलिखित कमांड को निष्पादित करें (जो निर्देशों में भी सावधानीपूर्वक वर्णित है)।

 sudo usermod -aG docker username

इसके बाद, आपको काम करने के लिए री-लॉगइन (एग्जिट कमांड और सर्वर को फिर से कनेक्ट करना) का उपयोग करना होगा।

डॉकर स्वयं स्थापित है, जिसे हम कमांड से जांच सकते हैं

 docker run hello-world

वह परीक्षण छवि डाउनलोड करती है, इसे कंटेनर में चलाती है। कंटेनर, शुरू करने के बाद, एक सूचना संदेश प्रिंट करता है और बाहर निकलता है।

बधाई हो, हमने काम के लिए सर्वर तैयार करने का चरण पूरा कर लिया है!

आपकी डॉकर छवि बनाना

हम अपनी खुद की डॉकरफाइल लिखकर डॉकर छवि बनाएंगे। इंटरनेट पर एक वैगन और एक छोटी गाड़ी पर इसे सही तरीके से कैसे किया जाए, इसके उदाहरण मैं अपना तैयार संस्करण दिखाऊंगा, और मैं इस पर यथासंभव टिप्पणी करने का प्रयास करूंगा। Dockerfile की सही और विहित वर्तनी पर उदाहरणों के साथ docker से एक निर्देश पुस्तिका भी है।

संपादन के लिए अपना डॉकरीफिल बनाएं और खोलें

 touch Dockerfile && nano Dockerfile

इसमें, उदाहरण के लिए, हम मेरे डॉकफ़िल की सामग्री डालेंगे

टिप्पणियों के साथ मेरा पूरा कामचोर

 #    . FROM ubuntu:18.04 #      LABEL author="osipovaleks" LABEL maintainer="osipov.aleks.kr@gmail.com" LABEL version="1.0" LABEL description="Docker image for Jenkins with Android SDK" #  ,  Jenkins    ENV TZ=Europe/Kiev RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone # i386    ia32-libs RUN dpkg --add-architecture i386 #      RUN apt-get update && apt-get install -y git \ wget \ unzip \ sudo \ tzdata \ locales\ openjdk-8-jdk \ libncurses5:i386 \ libstdc++6:i386 \ zlib1g:i386 #  ,       RUN apt-get clean && rm -rf /var/lib/apt/lists /var/cache/apt #  RUN locale-gen en_US.UTF-8 ENV LANG en_US.UTF-8 ENV LANGUAGE en_US:en ENV LC_ALL en_US.UTF-8 #   Android Sdk     ARG android_home_dir=/var/lib/android-sdk/ ARG sdk_tools_zip_file=sdk-tools-linux-4333796.zip RUN mkdir $android_home_dir RUN wget https://dl.google.com/android/repository/$sdk_tools_zip_file -P $android_home_dir -nv RUN unzip $android_home_dir$sdk_tools_zip_file -d $android_home_dir RUN rm $android_home_dir$sdk_tools_zip_file && chmod 777 -R $android_home_dir # environment    ENV ANDROID_HOME=$android_home_dir ENV PATH="${PATH}:$android_home_dir/tools/bin:$android_home_dir/platform-tools" ENV JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64/ #   Android SDK RUN yes | sdkmanager --licenses #    Jenkins ENV JENKINS_HOME=/var/lib/jenkins RUN mkdir $JENKINS_HOME && chmod 777 $JENKINS_HOME #     jenkins,   ,         RUN useradd -m jenkins && echo 'jenkins ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers USER jenkins WORKDIR /home/jenkins #   war     Jenkins RUN wget http://mirrors.jenkins.io/war-stable/latest/jenkins.war -nv CMD java -jar jenkins.war #      EXPOSE 8080/tcp

कुछ स्पष्टीकरण:

शुरुआत में, ubuntu के बजाय एक लाइटर अल्पाइन का उपयोग करने की इच्छा थी, लेकिन इसमें ia32-libs समर्थन नहीं है, जो एंड्रॉइड एसडीके का उपयोग करके परियोजनाओं के निर्माण के लिए आवश्यक है।
हम Openjdk-8-jdk स्थापित करते हैं, अधिक हल्के Openjdk-8-jdk-headless नहीं, क्योंकि कुछ जेनकींस फ़ंक्शन को एक पूर्ण प्रणाली (उदाहरण के लिए, इकाई परीक्षण परिणाम प्रदर्शित करना) की आवश्यकता होती है।
स्थानों को स्थापित करने के लिए आवश्यक है, इस तथ्य के कारण कि कुछ परियोजनाओं पर, उनके बिना, स्पष्ट त्रुटियों और लॉग्स के बिना असेंबली असेंबली क्रैश हो जाती है, और मैंने इस कारण की तह तक पहुंचने के लिए कई दिन बिताए (नियमित उबंटु जो डॉक में नहीं है, सभी स्थान डिफ़ॉल्ट रूप से भरे हुए हैं) ।
हमें एंड्रॉइड एसडीके के लिए सभी लाइसेंसों को तुरंत स्वीकार करने की आवश्यकता है, ताकि निर्माण प्रक्रिया के दौरान जेनकींस स्वतंत्र रूप से उन घटकों को स्थापित कर सके जिन्हें इसकी आवश्यकता है (उदाहरण के लिए, एसडीके को एपीआई के विभिन्न संस्करणों के लिए इसकी आवश्यकता है)। यदि आवश्यक हो, तो बाद में डॉकटर कंटेनर के अंदर एसडीके को sdkmanager का उपयोग करके प्रबंधित करना संभव होगा, उदाहरण के लिए sdkmanager --list सभी उपलब्ध और सभी स्थापित घटकों को देखने की अनुमति देता है, और sdkmanager --install "platforms;android-26" एपी के संस्करण 26 के लिए एसडीके स्थापित sdkmanager --install "platforms;android-26" ।
सामान्य तौर पर, उपयोगकर्ता जेनकींस को शुरू नहीं करना, और रूट उपयोगकर्ता के साथ रहना संभव था, लेकिन किसी तरह यह बिल्कुल सही नहीं है, आप उसे सुपरसुअर अधिकार भी नहीं दे सकते हैं, लेकिन यह सुविधा के संदर्भ में किया गया था, अगर कुछ स्थापित करने की आवश्यकता है सेटअप और डिबग स्टेज पर।
छवि का मूल आकार बड़ा (लगभग 800 mb) निकला, लेकिन कुल मिलाकर मैं इस निष्कर्ष पर पहुंचा कि मेरे लिए यह बहुत महत्वपूर्ण नहीं है, और मेरे लिए इसे इस रूप में डाउनलोड करना आसान है कि वे ऐसे पैकेज खोज और निकालने में खर्च न करें जिनकी आवश्यकता नहीं है।

Dockerfile लिखने के बाद, हमें इसे Docker के लिए तैयार छवि में बदलना होगा, जिसके आधार पर कंटेनर बनाए जाएंगे। यह बस एक टीम द्वारा किया जाता है

 docker build -t jenkins-image

जहां -t jenkins-image पैरामीटर आपकी छवि के नाम के लिए जिम्मेदार है, और कमांड के अंत में डॉट इंगित करता है कि आपको इस निर्देशिका के अंदर असेंबली के लिए डॉकरफाइल देखने की जरूरत है। असेंबली प्रक्रिया में कुछ समय लगता है, और असेंबली के बाद कंसोल में ऐसा कुछ होना चाहिए।

सफलतापूर्वक 9fd8f5545c27 बनाया गया
सफलतापूर्वक टैग की गई जेनकींस-छवि: नवीनतम

जो हमें बताता है कि हमारी छवि सफलतापूर्वक इकट्ठी हो गई है, और हम अगले कदम के लिए आगे बढ़ सकते हैं, अर्थात् हमारे कंटेनर का लॉन्च

डॉकर हब और तैयार चित्र

हां, निश्चित रूप से, हम कंटेनर को लॉन्च करने के लिए अपनी तैयार की गई छवि का उपयोग कर सकते हैं, लेकिन अगर हमें कई उपकरणों से अधिक पर ऐसा करने की आवश्यकता है, तो हर बार डॉकफाइल बनाना और उससे तैयार छवि बनाना बहुत सुविधाजनक नहीं होगा। और अगर हम अपने डॉकरीफाइल की सामग्री को भी अपडेट करते हैं, तो सभी नोड्स में परिवर्तन को रोल करना सुविधाजनक नहीं होगा। इन उद्देश्यों के लिए, डॉकर हब छवियों का एक सार्वजनिक भंडार है। यह आपको प्रत्येक नोड पर हर बार एक छवि एकत्र करने की अनुमति नहीं देता है, लेकिन बस इसे सार्वजनिक रिपॉजिटरी से खुद को डाउनलोड करें, और सभी मशीनों पर समान रूप से उपयोग करें। उदाहरण के लिए, इस लेख के लिए एक उदाहरण के रूप में कार्य करने वाली छवि ऑसिपोवालेक्स / डोकर-जेनकिंस-एंड्रॉइड नामक रिपॉजिटरी में उपलब्ध है, और बाद में लेख में हम इसके साथ काम करेंगे।

यह लेख डॉकर हब का विस्तृत अध्ययन नहीं करता है, हम यह नहीं समझ पाएंगे कि वहां हमारी छवियों को कैसे अपलोड किया जाए (हालांकि यह बहुत मुश्किल नहीं है) और वहां उनके साथ क्या किया जा सकता है, हम यह नहीं समझेंगे कि अभी भी आपकी खुद की निजी सार्वजनिक या निजी रिपॉजिटरी हो सकती हैं, इसमें यदि आवश्यक हो तो सभी को स्वतंत्र रूप से हल किया जा सकता है।

कंटेनर लॉन्च

कंटेनर शुरू करने के दो तरीके हैं।

पहला तरीका, बस docker run का उपयोग करके, आप इसे निम्न तरीके से आसानी से और जल्दी से कर सकते हैं
```
 docker run --name jenkins -d -it -v jenkins-data:/var/lib/jenkins -v jenkins-home:/home/jenkins -p 8080:8080 --restart unless-stopped osipovaleks/docker-jenkins-android 
```
जहां run कमांड में निम्नलिखित पैरामीटर हैं
- --name jenkins - भविष्य के कंटेनर का नाम
- -d - पृष्ठभूमि में कंटेनर शुरू करें
- -it - STDIN और tty के साथ काम करने के लिए झंडे
- -v jenkins-data:/var/lib/jenkins -v jenkins-home:/home/jenkins - create (अगर नहीं बनाए गए) और विशेष खंड फ़ाइलों को कंटेनर के आंतरिक अनुभागों में मैप करें जो हमें पुनर्निर्माण के बाद भी अपने कॉन्फ़िगर किए गए जेनकिंस को बचाने की अनुमति देगा। पात्र
- -p 8080:8080 - कंटेनर पोर्ट में होस्ट पोर्ट को मैप करें ताकि हमारे पास वेब इंटरफ़ेस तक पहुंच हो (हाँ यह वह पोर्ट है जिसे हमने डॉकरीफाइल में निर्दिष्ट किया है)
- - --restart unless-stopped - होस्ट को रिबूट करने के बाद कंटेनर ऑटोरन पॉलिसी का विकल्प निर्धारित करता है (इस मामले में, ऑटोस्टार्ट यदि कंटेनर मैन्युअल रूप से बंद नहीं किया गया था)
- osipovaleks/docker-jenkins-android - परिनियोजन के लिए छवि।
डॉकर कंसोल से बाहर निकलने पर, हमें निर्मित कंटेनर की आईडी प्राप्त करनी चाहिए, और यह भी दिखाएगा कि छवि को सिस्टम में कैसे लोड किया गया है (बेशक, अगर यह पहले से लोड नहीं है), कुछ इस तरह से
स्थानीय रूप से छवि 'ओसिपोवलेक्स / डोकर-जेनकिंस-एंड्रॉइड: नवीनतम' खोजने में असमर्थ
नवीनतम: osipovaleks / docker-jenkins-android से पुलिंग
6cf436f81810: पूर्ण खींचो
987088a85b96: पूर्ण खींचो
b4624b3efe06: पूर्ण खींचो
d42beb8ded59: पूरा खींचो
b3896048bb8c: पूरा खींचो
8eeace4c3d64: पूर्ण खींचो
d9b74624442c: पूरा खींचो
36bb3b7da419: पूरा खींचो
31361bd508cb: पूर्ण खींचो
cee49ae4c825: पूर्ण खींचो
868ddf54d4c1: पूरा खींचो
361bd7573dd0: पूर्ण खींचो
bb7b15e36ae8: पूरा खींचो
97f19daace79: पूर्ण खींचो
1f5eb3850f3e: पूरा खींचो
651e7bbedad2: पूरा खींचो
a52705a2ded7: पूरा खींचो
डाइजेस्ट: sha256: 321453e2f2142e433817cc9559443387e9f680bb091d6369bbcc1e0201be1c5
स्थिति: osipovaleks / docker-jenkins-android: नवीनतम के लिए डाउनलोड की गई नई छवि
ef9e5512581da66d66103d9f6ea6ccd74e5bdb3776747441ce6a88a98a12b5a4
शुरू करने के दूसरे तरीके में एक विशेष कंपोज़ फ़ाइल लिखना शामिल है, जहां रन कमांड को केवल YAML भाषा का उपयोग करके वर्णित किया जाता है, और इसे डॉकर कंपोज़ का उपयोग करके लॉन्च किया जाता है।

ऐसा करने के लिए, हमें इसे स्थापित करने की आवश्यकता है:
```
 sudo apt update && sudo apt install -y docker-compose 
```
अगला, परियोजना के लिए एक निर्देशिका बनाएं (यह महत्वपूर्ण है यदि आप परवाह करते हैं कि कंटेनर के लिए स्वचालित रूप से बनाए गए संस्करणों को क्या कहा जाएगा) और उस पर जाएं
```
 mkdir jenkinsProject && cd jenkinsProject 
```
और अंदर हम कंपोज फाइल बनाते हैं और एडिट मोड में जाते हैं
```
 touch docker-compose.yml && nano docker-compose.yml 
```
और इसमें निम्नलिखित सामग्री डालें
```
 version: '3' services: jenkins: container_name: jenkins image: osipovaleks/docker-jenkins-android ports: - "8080:8080" restart: unless-stopped volumes: - "jenkins-data:/var/lib/jenkins" - "jenkins-home:/home/jenkins" volumes: jenkins-data: jenkins-home: 
```
इसमें, शायद, केवल पहली पंक्ति सवाल उठाती है ( version: '3' ) जो कंपोज़ फ़ाइल की क्षमताओं के संस्करण को इंगित करता है, साथ ही volumes ब्लॉक के साथ एक खंड जो इस कंटेनर में उपयोग किए गए लोगों को सूचीबद्ध करता है।

कमांड के साथ अपना कंटेनर चलाएं:
```
 docker-compose up -d 
```
जहाँ -d ध्वज भी इंगित करता है कि कंटेनर बनाया जाएगा और पृष्ठभूमि में लॉन्च किया जाएगा। नतीजतन, डॉकर को निम्न जैसा कुछ दिखाना चाहिए:
डिफ़ॉल्ट ड्राइवर के साथ "jenkinsproject_jenkins-data" वॉल्यूम बनाना
डिफ़ॉल्ट ड्राइवर के साथ "jenkinsproject_jenkins-home" वॉल्यूम बनाना
पुलिंग जेनकिंस (ओसिपोवलेकस / डॉक-जेनकिन्स-एंड्रॉइड: नवीनतम) ...
नवीनतम: osipovaleks / docker-jenkins-android से पुलिंग
6cf436f81810: पूर्ण खींचो
987088a85b96: पूर्ण खींचो
b4624b3efe06: पूर्ण खींचो
d42beb8ded59: पूरा खींचो
b3896048bb8c: पूरा खींचो
8eeace4c3d64: पूर्ण खींचो
d9b74624442c: पूरा खींचो
36bb3b7da419: पूरा खींचो
31361bd508cb: पूर्ण खींचो
cee49ae4c825: पूर्ण खींचो
868ddf54d4c1: पूरा खींचो
361bd7573dd0: पूर्ण खींचो
bb7b15e36ae8: पूरा खींचो
97f19daace79: पूर्ण खींचो
1f5eb3850f3e: पूरा खींचो
651e7bbedad2: पूरा खींचो
a52705a2ded7: पूरा खींचो
डाइजेस्ट: sha256: 321453e2f2142e433817cc9559443387e9f680bb091d6369bbcc1e0201be1c5
स्थिति: osipovaleks / docker-jenkins-android: नवीनतम के लिए डाउनलोड की गई नई छवि
जेनकींस का निर्माण ...
जेनकींस बनाना ... किया
याद रखें, मैंने कहा था कि बनाए गए संस्करणों का नाम परियोजना के नाम पर निर्भर करेगा? कमांड चलाएँ:
```
 docker volume ls 
```
और हमें ऐसा आउटपुट मिलता है
ड्राइवर का नाम
स्थानीय jenkinsproject_jenkins-data
स्थानीय जेनकिंसप्रोजेक्ट_जेनकिंस-होम
जहां हम देखेंगे कि इस तथ्य के बावजूद कि वॉल्यूम के लिए नाम को jenkins-home द्वारा चुना गया था, वास्तव में, परियोजना के नाम से एक उपसर्ग इसे अटक गया और नाम की मात्रा jenkinsproject _jenkins-home

कौन सा स्टार्टअप विकल्प का उपयोग करें? यहां आप अपने लिए चुन सकते हैं, यह माना जाता है कि डॉकर कम्पोज़ एक बार में कई कंटेनरों को लॉन्च करने का एक उपकरण है, जो एक-दूसरे से बंधे हैं, और यदि आपको केवल एक कंटेनर चलाने की आवश्यकता है, तो आप docker run उपयोग कर सकते हैं।

सर्वर शुरू करने और कॉन्फ़िगर करने के साथ-साथ जेनकींस के साथ कंटेनर शुरू करने के लिए इन उप-चरणों के बाद, हम इसके वैकल्पिक कॉन्फ़िगरेशन के लिए आगे बढ़ सकते हैं

प्रारंभिक जेनकिंस सेटअप

हमारे सर्वर का आईपी पता लें, हमारे द्वारा बताए गए पोर्ट 8080 को जोड़ें और ब्राउज़र में इस लिंक का पालन करें।

http://YOUR_IP_ADDRESS:8080/

यदि इससे पहले सब कुछ कॉन्फ़िगर किया गया था और सही ढंग से शुरू किया गया था, तो यहां हम निम्नलिखित चित्र देखेंगे

पहली स्थापना के लिए, हमें उस पासवर्ड को दर्ज करने की आवश्यकता है जिसे सिस्टम स्थापना के दौरान उत्पन्न करता है। ऐसा करने के लिए, हमें बस फ़ाइल /var/lib/jenkins/secrets/initialAdminPassword की सामग्री को देखना /var/lib/jenkins/secrets/initialAdminPassword । लेकिन यह फ़ाइल हमारे रनिंग कंटेनर के अंदर है, और इसे पढ़ने के लिए, हमें निम्नलिखित कमांड का उपयोग करके कंटेनर से कनेक्ट करना होगा:

 docker exec -it jenkins /bin/bash

जहां -it विकल्प docker run समान है, jenkins हमारे कंटेनर का नाम है, और /bin/bash कंटेनर में हमारे लिए /bin/bash चलाएगा और इसे एक्सेस देगा। उसके बाद, हम जेनकिन्स के लिए प्रारंभिक पासवर्ड देख सकते हैं:

 cat /var/lib/jenkins/secrets/initialAdminPassword

कंसोल में निम्न प्रकट होता है

91092b18d6ca4492a2759b1903241d2a

यह पासवर्ड है।

उपयोगकर्ता ALexhha ने इस पासवर्ड को पढ़ने के लिए एक सरल विकल्प का सुझाव दिया, बिना कंटेनर से जुड़े। तथ्य यह है कि जेनकिन्स को लॉन्च करने के समय, यह पासवर्ड लॉग में दिखाया गया है। यह पता चला है कि हम सभी की जरूरत है कंटेनर लॉग को पढ़ने के लिए है। हमारे मामले में, यह निम्नलिखित कमांड के साथ किया जाता है:

 docker logs jenkins

jenkins हमारे कंटेनर jenkins नाम है, और लॉग में आप निम्नलिखित देख सकते हैं:

************************************************** ***********
*********************************** ***********
************************************************** ***********

जेनकिंस प्रारंभिक सेटअप की आवश्यकता है। एक व्यवस्थापक उपयोगकर्ता बनाया गया है और एक पासवर्ड जनरेट किया गया है।
स्थापना के लिए आगे बढ़ने के लिए कृपया निम्न पासवर्ड का उपयोग करें:

91092b18d6ca4492a2759b1903241d2a

यह भी पाया जा सकता है: / var / lib / jenkins / सीक्रेट्स / initialAdminPassword

************************************************** ***********
************************************************** ***********

************************************************** ***********

यह विकल्प थोड़ा सरल और तेज है।

इसे कॉपी करें, इसे वेब इंटरफेस में प्रशासक पासवर्ड फ़ील्ड में पेस्ट करें और जारी रखें पर क्लिक करें। अगली स्क्रीन पर, इंस्टॉल किए गए प्लग इन का चयन करें और डिफ़ॉल्ट प्लगइन्स का एक सेट इंस्टॉल करें ।

प्लगइन्स इंस्टॉल करने के बाद, अपने लिए एक उपयोगकर्ता बनाएं और सेव एंड फिनिश पर क्लिक करें

हम इंस्टेंस कॉन्फ़िगरेशन अनुभाग से सहमत हैं, जहां हमें उस URL को भरने के लिए कहा जाता है, जिस पर जेनकिन्स काम करेगा (हमारे मामले में, सब कुछ उसी तरह छोड़ दें)

और अगली स्क्रीन पर, जेनकींस का उपयोग करते हुए पोषित प्रारंभ पर क्लिक करें

इसलिए, हमने जेनकिंस को स्थापित और लॉन्च किया!

इसके साथ काम करना पहले से ही काफी संभव है, लेकिन हमारे एंड्रॉइड बिल्ड को इकट्ठा करने के लिए, आपको कुछ और बिंदुओं को कॉन्फ़िगर करना होगा। जेनकिंस का स्थानीयकरण आपके ब्राउज़र की चयनित भाषा से संबंधित है, और निश्चित रूप से रूसी में अनुवाद पूरी तरह से समाप्त नहीं हुआ है, और हमें रूसी और अंग्रेजी का नारकीय मिश्रण मिलता है। यदि आप ठीक उसी तरह से सफल हुए, और यह आपको प्रभावित करता है, तो आप विशेष प्लग-इन का उपयोग कर सकते हैं और डिफ़ॉल्ट इंटरफ़ेस भाषा सेट कर सकते हैं। खैर, या अपने ब्राउज़र को अंग्रेजी इंटरफ़ेस पर स्विच करें।

जेनकिंस सेटिंग्स पर जाएं और सिस्टम कॉन्फ़िगरेशन चुनें ।

पर्यावरण चर की जाँच करें, और क्षेत्र में ANDROID_HOME नाम दर्ज करें, और क्षेत्र में / var / lib / android-sdk / निर्दिष्ट करें (हमने एंड्रॉइड एसडीके के लिए होम निर्देशिका के रूप में डॉकरफाइल में इस डेटा को निर्दिष्ट किया है)।

सहेजें बटन पर क्लिक करें, इस सेटिंग अनुभाग से बाहर निकलें और ग्लोबल टूल कॉन्फ़िगरेशन नामक अनुभाग पर जाएं।

JDK पार्टीशन सेट करें (जहाँ JAVA_HOME वैरिएबल भी हमारे द्वारा Dockerfile में पॉप्युलेट किया गया था, और हम इसके मूल्य / usr / lib / jvm / java-8-openjdk-amd64 / here ) का उपयोग कर सकते हैं।

यहाँ भी हमें ग्रैडल सेक्शन को भरने की आवश्यकता है। हम उन परियोजनाओं में उपयोग किए जाने वाले ग्रेड के संस्करण का चयन और स्थापित करते हैं जो आप इस CI सिस्टम का उपयोग करके बनाएंगे।आपके कई संस्करण हो सकते हैं। उदाहरण के लिए, यदि आप रिपॉजिटरी में वर्गीकृत हैं, तो आप ग्रैडल वैरिएबल को भी शुरू नहीं कर सकते।

इससे हम अपना पहला चरण समाप्त कर सकते हैं। जेनकिंस सिस्टम पूरी तरह से चालू है और हम स्वयं निर्माण कार्यों को अनुकूलित करने के लिए आगे बढ़ सकते हैं। कृपया ध्यान दें कि सिस्टम हमारी आवश्यकताओं के लिए अनुकूलित किया गया था और जो आपको आवश्यक है वह प्रदान नहीं कर सकता है - उदाहरण के लिए, परीक्षण और NDK के लिए कोई एंड्रॉइड एमुलेटर नहीं हैं।

यदि यह लेख किसी को भी रुचिकर लगता है, तो मैं दूसरे भाग में एक या दो झंझटों के उदाहरण के साथ जारी रखूंगा, मैं जेनकिंस और बिटबकेट के एकीकरण का वर्णन करूंगा (यह वह है, गितुब नहीं, क्योंकि इंटरनेट पर मुफ्त निजी रिपॉजिटरी और लेखों के साथ यह आसान है यह छोटा है, लेकिन शायद अधिक मज़ेदार है), मैं आपको बताता हूँ कि हमारे कंटेनर के लिए रिपॉजिटरी ssh कुंजी के साथ मित्र बनाने के लिए कैसे करें, ईमेल सूचनाओं के साथ-साथ कई अन्य चिप्स। सामान्य तौर पर, हमारे द्वारा कॉन्फ़िगर की गई हर चीज के बारे में।

मैं आपसे पूछता हूं कि आप ज्यादा किक न मारें, यह मेरा हैबर पर पहला लेख है। सभी को अच्छा!

एंड्रॉइड के लिए जेनकिन्स docker का उपयोग करके निर्माण करते हैं