നിങ്ങൾക്ക് നിരവധി വ്യത്യസ്ത പരിതസ്ഥിതികൾ വേണമെങ്കിൽ ജെങ്കിൻസിൽ പ്രോജക്റ്റുകൾ എങ്ങനെ ശേഖരിക്കാം

ജെൻകിൻസിനെ കുറിച്ച് ഹബ്രെയിൽ നിരവധി ലേഖനങ്ങളുണ്ട്, എന്നാൽ ജെൻകിൻസും ഡോക്കർ ഏജന്റുമാരും എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിന്റെ ഉദാഹരണങ്ങൾ ചുരുക്കം. പോലുള്ള എല്ലാ ജനപ്രിയ പ്രോജക്റ്റ് ബിൽഡ് ടൂളുകളും 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