ನಿಮಗೆ ವಿವಿಧ ಪರಿಸರಗಳ ಅಗತ್ಯವಿದ್ದರೆ ಜೆಂಕಿನ್ಸ್‌ನಲ್ಲಿ ಯೋಜನೆಗಳನ್ನು ಹೇಗೆ ಸಂಗ್ರಹಿಸುವುದು

ಜೆಂಕಿನ್ಸ್ ಬಗ್ಗೆ ಹ್ಯಾಬ್ರೆಯಲ್ಲಿ ಅನೇಕ ಲೇಖನಗಳಿವೆ, ಆದರೆ ಕೆಲವರು ಜೆಂಕಿನ್ಸ್ ಮತ್ತು ಡಾಕರ್ ಏಜೆಂಟ್‌ಗಳು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತಾರೆ ಎಂಬುದರ ಉದಾಹರಣೆಗಳನ್ನು ವಿವರಿಸುತ್ತಾರೆ. ಎಲ್ಲಾ ಜನಪ್ರಿಯ ಪ್ರಾಜೆಕ್ಟ್ ನಿರ್ಮಾಣ ಸಾಧನಗಳು Drone.io, ಬಿಟ್ಬಕೆಟ್ ಪೈಪ್ಲೈನ್, ಗಿಟ್ಲಾಬ್, 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