உங்களுக்கு பல்வேறு சூழல்கள் தேவைப்பட்டால் ஜென்கின்ஸில் திட்டங்களை எவ்வாறு சேகரிப்பது

ஜென்கின்ஸ் பற்றி ஹப்ரில் பல கட்டுரைகள் உள்ளன, ஆனால் ஜென்கின்ஸ் மற்றும் டாக்கர் முகவர்கள் எவ்வாறு செயல்படுகிறார்கள் என்பதற்கான உதாரணத்தை சில மட்டுமே விவரிக்கின்றன. அனைத்து பிரபலமான திட்ட உருவாக்க கருவிகளும் போன்றவை ட்ரோன்.ஐஓ, பிட்பக்கெட் பைப்லைன், 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

இவ்வாறு, ஹோஸ்ட் கணினியில் டாக்கர் கட்டளைகளை இயக்கக்கூடிய ஒரு டாக்கர் கொள்கலன் எங்களிடம் உள்ளது.

கட்டமைப்பு அமைப்பு

சிறிது காலத்திற்கு முன்பு, ஜென்கின்ஸ் அதன் விதிகளைப் பயன்படுத்தி விவரிக்கும் திறனைப் பெற்றது பைப்லைன் தொடரியல், இது பில்ட் ஸ்கிரிப்டை மாற்றி களஞ்சியத்தில் சேமிப்பதை எளிதாக்குகிறது.

எனவே, களஞ்சியத்திலேயே ஒரு சிறப்பு Dockerfile ஐ வைப்போம், அதில் கட்டுமானத்திற்குத் தேவையான அனைத்து நூலகங்களும் உள்ளன. இந்த வழியில், டெவலப்பர் OPS ஐ ஹோஸ்டில் Node.JS இன் குறிப்பிட்ட பதிப்பை நிறுவச் சொல்லாமல் மீண்டும் மீண்டும் செய்யக்கூடிய சூழலைத் தயாரிக்க முடியும்.

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 பயன்பாட்டை உருவாக்கக்கூடிய ஒரு பொதுவான Jenkins கோப்பைக் காட்ட விரும்புகிறேன்.

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 நிமிடங்களாகக் குறைக்கப்படுகிறது;
• முழுமையாக மீண்டும் மீண்டும் செய்யக்கூடிய பயன்பாட்டு உருவாக்க சூழல், ஏனெனில் இது ஒரு உள்ளூர் கணினியிலும் உருவாக்கப்படலாம்;
• உருவாக்க கருவிகளின் வெவ்வேறு பதிப்புகளுக்கு இடையிலான மோதல்களில் எந்தப் பிரச்சினையும் இல்லை;
• எப்போதும் ஒழுங்கீனமாக இல்லாத சுத்தமான பணியிடம்.

தீர்வு எளிமையானது மற்றும் வெளிப்படையானது, மேலும் இது நன்மைகளை மட்டுமே வழங்குகிறது. ஆம், நுழைவுத் தடை எளிய உருவாக்க கட்டளைகளை விட சற்று அதிகமாக உள்ளது, ஆனால் இப்போது உருவாக்கம் எப்போதும் செயல்படும் என்பதற்கு உத்தரவாதம் உள்ளது, மேலும் டெவலப்பர் தங்கள் உருவாக்க செயல்முறைக்குத் தேவையான அனைத்தையும் தேர்வு செய்யலாம்.

நான் தொகுத்த படத்தையும் நீங்கள் பயன்படுத்தலாம். ஜென்கின்ஸ் + டாக்கர்அனைத்து ஆதாரங்களும் திறந்திருக்கும் மற்றும் அமைந்துள்ளன முகமதுகலீவ்/ஜென்கின்ஸ்_டாக்கர்.

இந்தக் கட்டுரையை எழுதும் போது, ​​ஒரு செருகுநிரலுடன் மாஸ்டர் முனையை ஏற்றுவதைத் தவிர்க்க தொலை சேவையகங்களில் முகவர்களைப் பயன்படுத்துவது பற்றி ஒரு விவாதம் இருந்தது. டாக்கர்-பிளக்இன்ஆனால் இதைப் பற்றி எதிர்காலத்தில் நான் உங்களுக்குச் சொல்வேன்.

ஆதாரம்: www.habr.com