మీకు అనేక విభిన్న వాతావరణాలు అవసరమైతే జెంకిన్స్‌లో ప్రాజెక్ట్‌లను ఎలా సేకరించాలి

జెంకిన్స్ గురించి హబ్రేలో చాలా కథనాలు ఉన్నాయి, అయితే జెంకిన్స్ మరియు డాకర్ ఏజెంట్లు ఎలా పని చేస్తారో కొన్ని ఉదాహరణలు వివరిస్తాయి. వంటి అన్ని ప్రముఖ ప్రాజెక్ట్ బిల్డ్ టూల్స్ 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