જો તમને ઘણાં વિવિધ વાતાવરણની જરૂર હોય તો જેનકિન્સમાં પ્રોજેક્ટ્સ કેવી રીતે એકત્રિત કરવા

જેનકિન્સ વિશે હેબ્રે પર ઘણા લેખો છે, પરંતુ જેનકિન્સ અને ડોકર એજન્ટો કેવી રીતે કામ કરે છે તેના ઉદાહરણોનું વર્ણન થોડા છે. બધા લોકપ્રિય પ્રોજેક્ટ બિલ્ડ ટૂલ્સ જેવા Drone.io, બિટબકેટ પાઇપલાઇન, GitLab, GitHub ક્રિયાઓ અને અન્ય, કન્ટેનરમાં બધું એકત્રિત કરી શકે છે. પરંતુ જેનકિન્સ વિશે શું?

આજે સમસ્યાનો ઉકેલ છે: જેનકિન્સ 2 સાથે કામ કરવા માટે ઉત્તમ છે ડોકર એજન્ટો. આ લેખમાં હું મારો અનુભવ શેર કરવા માંગુ છું અને બતાવવા માંગુ છું કે તમે તે જાતે કેવી રીતે કરી શકો.

શા માટે મેં આ સમસ્યા હલ કરવાનું શરૂ કર્યું?

અમે કંપનીમાં હોવાથી સિટ્રોનિયમ કારણ કે આપણે ઘણી જુદી જુદી તકનીકોનો ઉપયોગ કરીએ છીએ, અમારે એસેમ્બલી મશીન પર Node.JS, Gradle, Ruby, JDK અને અન્યના વિવિધ સંસ્કરણો રાખવા પડશે. પરંતુ ઘણીવાર સંસ્કરણ તકરાર ટાળી શકાતી નથી. હા, જો તમે કહો કે nvm, rvm જેવા વિવિધ વર્ઝન મેનેજર્સ છે, તો તમે સાચા હશો, પરંતુ તેમની સાથે બધું એટલું સરળ નથી અને આ ઉકેલોમાં સમસ્યા છે:

• મોટી માત્રામાં રનટાઇમ કે જે વિકાસકર્તાઓ સાફ કરવાનું ભૂલી જાય છે;
• સમાન રનટાઇમના વિવિધ સંસ્કરણો વચ્ચે તકરાર છે;
• દરેક વિકાસકર્તાને ઘટકોના અલગ સેટની જરૂર હોય છે.

બીજી પણ સમસ્યાઓ છે, પરંતુ હું તમને તેના ઉકેલ વિશે જણાવું છું.

ડોકરમાં જેનકિન્સ

ડોકર હવે વિકાસની દુનિયામાં સારી રીતે સ્થાપિત થઈ ગયું હોવાથી, ડોકરનો ઉપયોગ કરીને લગભગ કંઈપણ ચલાવી શકાય છે. મારો ઉકેલ એ છે કે ડોકરમાં જેનકિન્સ હોય અને અન્ય ડોકર કન્ટેનર ચલાવવા માટે સક્ષમ હોય. આ પ્રશ્ન 2013 માં લેખમાં પૂછવામાં આવ્યો હતો.ડોકર હવે ડોકરની અંદર ચાલી શકે છે".

ટૂંકમાં, તમારે ફક્ત ડોકરને જ કામ કરતા કન્ટેનરમાં ઇન્સ્ટોલ કરવાની અને ફાઇલને માઉન્ટ કરવાની જરૂર છે /var/run/docker.sock.

અહીં ડોકરફાઇલનું ઉદાહરણ છે જે જેનકિન્સ માટે બહાર આવ્યું છે.

FROM jenkins/jenkins:lts

USER root

RUN apt-get update && 

apt-get -y install apt-transport-https 
     ca-certificates 
     curl 
     gnupg2 
     git 
     software-properties-common && 
curl -fsSL https://download.docker.com/linux/$(. /etc/os-release; echo "$ID")/gpg > /tmp/dkey; apt-key add /tmp/dkey && 
add-apt-repository 
   "deb [arch=amd64] https://download.docker.com/linux/$(. /etc/os-release; echo "$ID") 
   $(lsb_release -cs) 
   stable" && 
apt-get update && 
apt-get -y install docker-ce && 
usermod -aG docker jenkins

RUN curl -L https://github.com/docker/compose/releases/download/1.25.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose && chmod +x /usr/local/bin/docker-compose 

RUN apt-get clean autoclean && apt-get autoremove —yes && rm -rf /var/lib/{apt,dpkg,cache,log}/

USER jenkins

આમ, અમને એક ડોકર કન્ટેનર મળ્યું જે હોસ્ટ મશીન પર ડોકર આદેશો ચલાવી શકે છે.

સેટઅપ બનાવો

થોડા સમય પહેલા જેનકિન્સને તેના નિયમોનો ઉપયોગ કરીને વર્ણન કરવાની તક મળી પાઇપલાઇન વાક્યરચના, જે બિલ્ડ સ્ક્રિપ્ટને બદલવા અને તેને રીપોઝીટરીમાં સંગ્રહિત કરવાનું એકદમ સરળ બનાવે છે.

તો ચાલો રીપોઝીટરીમાં જ એક ખાસ ડોકરફાઈલ મૂકીએ, જેમાં બિલ્ડ માટે જરૂરી બધી લાઈબ્રેરીઓ હશે. આ રીતે, વિકાસકર્તા પોતે પુનરાવર્તિત વાતાવરણ તૈયાર કરી શકે છે અને હોસ્ટ પર Node.JS નું ચોક્કસ સંસ્કરણ ઇન્સ્ટોલ કરવા માટે OPSને પૂછવું પડશે નહીં.

FROM node:12.10.0-alpine

RUN npm install yarn -g

આ બિલ્ડ ઈમેજ મોટા ભાગના Node.JS એપ્લીકેશન માટે યોગ્ય છે. જો, ઉદાહરણ તરીકે, તમારે JVM પ્રોજેક્ટ માટે અંદર સોનાર સ્કેનર સાથેની છબીની જરૂર હોય તો શું? તમે એસેમ્બલી માટે જરૂરી ઘટકો પસંદ કરવા માટે સ્વતંત્ર છો.

FROM adoptopenjdk/openjdk12:latest

RUN apt update 
    && apt install -y 
        bash unzip wget

RUN mkdir -p /usr/local/sonarscanner 
    && cd /usr/local/sonarscanner 
    && wget https://binaries.sonarsource.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-3.3.0.1492-linux.zip 
    && unzip sonar-scanner-cli-3.3.0.1492-linux.zip 
    && mv sonar-scanner-3.3.0.1492-linux/* ./ 
    && rm sonar-scanner-cli-3.3.0.1492-linux.zip 
    && rm -rf sonar-scanner-3.3.0.1492-linux 
    && ln -s /usr/local/sonarscanner/bin/sonar-scanner /usr/local/bin/sonar-scanner

ENV PATH $PATH:/usr/local/sonarscanner/bin/
ENV SONAR_RUNNER_HOME /usr/local/sonarscanner/bin/

અમે એસેમ્બલી પર્યાવરણનું વર્ણન કર્યું છે, પરંતુ જેનકિન્સને તેની સાથે શું લેવાદેવા છે? અને જેનકિન્સ એજન્ટો આવી ડોકર ઈમેજો સાથે કામ કરી શકે છે અને તેને આંતરિક રીતે બનાવી શકે છે.

stage("Build project") {
    agent {
        docker {
            image "project-build:${DOCKER_IMAGE_BRANCH}"
            args "-v ${PWD}:/usr/src/app -w /usr/src/app"
            reuseNode true
            label "build-image"
        }
    }
    steps {
        sh "yarn"
        sh "yarn build"
    }
}

નિર્દેશક agent મિલકતનો ઉપયોગ કરે છે dockerજ્યાં તમે સ્પષ્ટ કરી શકો છો:

• તમારી નામકરણ નીતિ અનુસાર એસેમ્બલી કન્ટેનરનું નામ;
• બિલ્ડ કન્ટેનર ચલાવવા માટે જરૂરી દલીલો, જ્યાં અમારા કિસ્સામાં આપણે વર્તમાન ડિરેક્ટરીને કન્ટેનરની અંદર ડિરેક્ટરી તરીકે માઉન્ટ કરીએ છીએ.

અને પહેલાથી જ બિલ્ડ સ્ટેપ્સમાં અમે સૂચવીએ છીએ કે ડોકર બિલ્ડ એજન્ટની અંદર કયા આદેશો એક્ઝિક્યુટ કરવા. આ કંઈપણ હોઈ શકે છે, તેથી હું એન્સિબલનો ઉપયોગ કરીને એપ્લિકેશન જમાવટ પણ શરૂ કરું છું.

નીચે હું એક સામાન્ય જેનકિન્સફાઈલ બતાવવા માંગુ છું જે એક સરળ Node.JS એપ્લિકેશન બનાવી શકે છે.

def DOCKER_IMAGE_BRANCH = ""
def GIT_COMMIT_HASH = ""

pipeline { 
    options {
        buildDiscarder(
            logRotator(
                artifactDaysToKeepStr: "",
                artifactNumToKeepStr: "",
                daysToKeepStr: "",
                numToKeepStr: "10"
            )
        )
        disableConcurrentBuilds()
    }

    agent any

    stages {

        stage("Prepare build image") {
            steps {
                sh "docker build -f Dockerfile.build . -t project-build:${DOCKER_IMAGE_BRANCH}"
            }
        }

        stage("Build project") {
            agent {
                docker {
                    image "project-build:${DOCKER_IMAGE_BRANCH}"
                    args "-v ${PWD}:/usr/src/app -w /usr/src/app"
                    reuseNode true
                    label "build-image"
                }
            }
            steps {
                sh "yarn"
                sh "yarn build"
            }
        }

    post {
        always {
            step([$class: "WsCleanup"])
            cleanWs()
        }
    }

}

શું થયું?

આ પદ્ધતિનો આભાર, અમે નીચેની સમસ્યાઓ હલ કરી:

• પર્યાવરણ એસેમ્બલી ગોઠવણીનો સમય પ્રોજેક્ટ દીઠ 10 - 15 મિનિટ સુધી ઘટાડ્યો છે;
• સંપૂર્ણપણે પુનરાવર્તિત એપ્લિકેશન બિલ્ડ પર્યાવરણ, કારણ કે તમે તેને તમારા સ્થાનિક કમ્પ્યુટર પર આ રીતે બનાવી શકો છો;
• એસેમ્બલી ટૂલ્સના વિવિધ સંસ્કરણો વચ્ચેના સંઘર્ષમાં કોઈ સમસ્યા નથી;
• હંમેશા સ્વચ્છ કાર્યસ્થળ કે જે ભરાઈ ન જાય.

ઉકેલ પોતે જ સરળ અને સ્પષ્ટ છે અને તમને કેટલાક ફાયદાઓ મેળવવાની મંજૂરી આપે છે. હા, એસેમ્બલી માટેના સરળ આદેશોની તુલનામાં એન્ટ્રી થ્રેશોલ્ડ થોડો વધ્યો છે, પરંતુ હવે ત્યાં ગેરેંટી છે કે તે હંમેશા બનાવવામાં આવશે અને વિકાસકર્તા પોતે તેની બિલ્ડ પ્રક્રિયા માટે જરૂરી હોય તે બધું પસંદ કરી શકે છે.

તમે પણ મેં એકત્રિત કરેલી છબીનો ઉપયોગ કરી શકો છો જેનકિન્સ + ડોકર. બધા સ્ત્રોતો ખુલ્લા છે અને પર સ્થિત છે rmuhamedgaliev/jenkins_docker.

આ લેખ લખતી વખતે, રિમોટ સર્વર પર એજન્ટોનો ઉપયોગ કરવા વિશે ચર્ચા થઈ જેથી પ્લગઈનનો ઉપયોગ કરીને માસ્ટર નોડ લોડ ન થાય. ડોકર-પ્લગઇન. પરંતુ હું ભવિષ્યમાં આ વિશે વાત કરીશ.

સોર્સ: www.habr.com