ProHoster > Օրագիր > Վարչակազմը > Ինչպես հավաքել նախագծեր Ջենքինսում, եթե ձեզ շատ տարբեր միջավայրեր են անհրաժեշտ

Ինչպես հավաքել նախագծեր Ջենքինսում, եթե ձեզ շատ տարբեր միջավայրեր են անհրաժեշտ

Ինչպես հավաքել նախագծեր Ջենքինսում, եթե ձեզ շատ տարբեր միջավայրեր են անհրաժեշտ

Habré-ում կան բազմաթիվ հոդվածներ Ջենքինսի մասին, սակայն քչերն են նկարագրում Ջենքինսի և դոկերի գործակալների աշխատանքի օրինակները: Բոլոր հայտնի նախագծերի կառուցման գործիքները, ինչպիսիք են Drone.io, Bitbucket խողովակաշար, Գիտլաբը, GitHub գործողություններ և մյուսները, կարող են ամեն ինչ հավաքել տարաներով: Բայց ինչ վերաբերում է Ջենքինսին:

Այսօր կա խնդրի լուծում. Jenkins 2-ը հիանալի է աշխատում նրա հետ Docker գործակալներ. Այս հոդվածում ես ուզում եմ կիսվել իմ փորձով և ցույց տալ, թե ինչպես կարող եք դա անել ինքներդ:

Ինչու՞ սկսեցի լուծել այս խնդիրը:

Քանի որ մենք ընկերությունում ենք Ցիտրոնիում Քանի որ մենք օգտագործում ենք բազմաթիվ տարբեր տեխնոլոգիաներ, մենք պետք է պահենք Node.JS, Gradle, Ruby, JDK և այլ տարբերակներ հավաքման մեքենայի վրա: Բայց հաճախ տարբերակների կոնֆլիկտներից հնարավոր չէ խուսափել։ Այո, ճիշտ կլինեք, եթե ասեք, որ կան տարբեր տարբերակների մենեջերներ, ինչպիսիք են nvm, rvm, բայց ամեն ինչ այնքան էլ հարթ չէ նրանց հետ, և այս լուծումները խնդիրներ ունեն.

  • մեծ քանակությամբ գործարկման ժամանակ, որը մշակողները մոռանում են մաքրել;
  • կան հակասություններ նույն գործարկման ժամանակների տարբեր տարբերակների միջև.
  • Յուրաքանչյուր մշակողի կարիք ունի բաղադրիչների տարբեր հավաքածու:

Այլ խնդիրներ էլ կան, բայց լուծման մասին ասեմ։

Ջենկինսը Docker-ում

Քանի որ Docker-ն այժմ լավ հաստատված է զարգացման աշխարհում, գրեթե ամեն ինչ կարելի է գործարկել Docker-ի միջոցով: Իմ լուծումն այն է, որ Jenkins-ը լինի Docker-ում և կարողանա գործարկել այլ Docker կոնտեյներներ: Այս հարցը սկսեց տրվել դեռևս 2013 թվականին հոդվածում «Docker-ն այժմ կարող է աշխատել Docker-ի ներսում»:

Մի խոսքով, պարզապես անհրաժեշտ է տեղադրել Docker-ն ինքնին աշխատանքային կոնտեյներով և տեղադրել ֆայլը /var/run/docker.sock.

Ահա մի օրինակ Dockerfile, որը պարզվեց Ջենկինսի համար:

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

Այսպիսով, մենք ստացանք Docker կոնտեյներ, որը կարող է կատարել Docker հրամանները հյուրընկալող մեքենայի վրա:

Կառուցման կարգավորում

Ոչ վաղ անցյալում Ջենքինսը հնարավորություն ստացավ նկարագրելու իր կանոնները՝ օգտագործելով Խողովակաշար շարահյուսություն, որը բավականին հեշտ է դարձնում build-ի սկրիպտը փոխելը և այն պահեստում պահելը:

Այսպիսով, եկեք տեղադրենք հատուկ Dockerfile-ը հենց պահոցում, որը կպարունակի կառուցման համար անհրաժեշտ բոլոր գրադարանները: Այս կերպ ծրագրավորողն ինքը կարող է պատրաստել կրկնվող միջավայր և ստիպված չի լինի OPS-ին խնդրել հոսթի վրա տեղադրել Node.JS-ի կոնկրետ տարբերակը։

FROM node:12.10.0-alpine

RUN npm install yarn -g

Այս build պատկերը հարմար է Node.JS հավելվածների մեծ մասի համար: Իսկ եթե, օրինակ, ձեզ անհրաժեշտ է պատկեր JVM նախագծի համար, որի ներսում ներառված է Sonar սկաները: Դուք ազատ եք ընտրելու այն բաղադրիչները, որոնք անհրաժեշտ են հավաքման համար:

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/

Մենք նկարագրեցինք հավաքման միջավայրը, բայց ի՞նչ կապ ունի Ջենքինսը դրա հետ: Եվ Jenkins-ի գործակալները կարող են աշխատել նման Docker պատկերների հետ և կառուցել դրանք ներսում: 

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որտեղ կարող եք նշել.

  • հավաքման կոնտեյների անվանումը՝ ըստ ձեր անվանման քաղաքականության.
  • արգումենտներ, որոնք անհրաժեշտ են կառուցման կոնտեյները գործարկելու համար, որտեղ մեր դեպքում մենք տեղադրում ենք ընթացիկ գրացուցակը որպես գրացուցակ կոնտեյների ներսում:

Եվ արդեն կառուցման քայլերում մենք նշում ենք, թե որ հրամանները պետք է կատարվեն Docker build գործակալի ներսում։ Սա կարող է լինել ցանկացած բան, այնպես որ ես նաև գործարկում եմ հավելվածների տեղակայումը ansible-ի միջոցով:

Ստորև ես ուզում եմ ցույց տալ ընդհանուր Jenkinsfile-ը, որը կարող է ստեղծել հասարակ 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.

Այս հոդվածը գրելիս քննարկում առաջացավ հեռավոր սերվերների վրա գործակալներ օգտագործելու մասին, որպեսզի չբեռնվի հիմնական հանգույցը՝ օգտագործելով plugin docker-plugin. Բայց այս մասին կխոսեմ ապագայում։

Source: www.habr.com

Добавить комментарий