ਜੇ ਤੁਹਾਨੂੰ ਬਹੁਤ ਸਾਰੇ ਵੱਖ-ਵੱਖ ਵਾਤਾਵਰਣ ਦੀ ਲੋੜ ਹੈ ਤਾਂ ਜੇਨਕਿੰਸ ਵਿੱਚ ਪ੍ਰੋਜੈਕਟ ਕਿਵੇਂ ਇਕੱਠੇ ਕੀਤੇ ਜਾਣ

ਜੇਨਕਿੰਸ ਬਾਰੇ ਹੈਬਰੇ 'ਤੇ ਬਹੁਤ ਸਾਰੇ ਲੇਖ ਹਨ, ਪਰ ਕੁਝ ਉਦਾਹਰਣਾਂ ਦਾ ਵਰਣਨ ਕਰਦੇ ਹਨ ਕਿ ਜੇਨਕਿੰਸ ਅਤੇ ਡੌਕਰ ਏਜੰਟ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ। ਸਾਰੇ ਪ੍ਰਸਿੱਧ ਪ੍ਰੋਜੈਕਟ ਬਿਲਡ ਟੂਲ ਜਿਵੇਂ 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.

ਇਸ ਲੇਖ ਨੂੰ ਲਿਖਣ ਵੇਲੇ, ਰਿਮੋਟ ਸਰਵਰਾਂ 'ਤੇ ਏਜੰਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਬਾਰੇ ਚਰਚਾ ਹੋਈ ਤਾਂ ਜੋ ਪਲੱਗਇਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਾਸਟਰ ਨੋਡ ਨੂੰ ਲੋਡ ਨਾ ਕੀਤਾ ਜਾ ਸਕੇ। docker-ਪਲੱਗਇਨ. ਪਰ ਮੈਂ ਇਸ ਬਾਰੇ ਭਵਿੱਖ ਵਿੱਚ ਗੱਲ ਕਰਾਂਗਾ।

ਸਰੋਤ: www.habr.com