ProHoster > blog > Utawala > Jinsi ya kukusanya miradi katika Jenkins ikiwa unahitaji mazingira mengi tofauti

Jinsi ya kukusanya miradi katika Jenkins ikiwa unahitaji mazingira mengi tofauti

Jinsi ya kukusanya miradi katika Jenkins ikiwa unahitaji mazingira mengi tofauti

Kuna vifungu vingi kuhusu Habre kuhusu Jenkins, lakini ni vichache vinavyoelezea mifano ya jinsi Jenkins na mawakala wa docker hufanya kazi. Zana zote maarufu za ujenzi wa mradi kama Drone.io, Bomba la Bitbucket, GitLab, Vitendo vya GitHub na wengine, wanaweza kukusanya kila kitu katika vyombo. Lakini vipi kuhusu Jenkins?

Leo kuna suluhisho la shida: Jenkins 2 ni mzuri katika kufanya kazi naye Wakala wa Docker. Katika makala hii nataka kushiriki uzoefu wangu na kuonyesha jinsi unaweza kufanya hivyo mwenyewe.

Kwa nini nilianza kutatua tatizo hili?

Kwa kuwa tuko kwenye kampuni Citronium Kwa sababu tunatumia teknolojia nyingi tofauti, tunapaswa kuweka matoleo tofauti ya Node.JS, Gradle, Ruby, JDK na mengine kwenye mashine ya kuunganisha. Lakini mara nyingi migogoro ya matoleo haiwezi kuepukwa. Ndio, utakuwa sawa ikiwa unasema kuwa kuna wasimamizi wa matoleo anuwai kama nvm, rvm, lakini sio kila kitu ni laini kwao na suluhisho hizi zina shida:

  • kiasi kikubwa cha wakati wa kukimbia ambao watengenezaji husahau kusafisha;
  • kuna migogoro kati ya matoleo tofauti ya nyakati za kukimbia sawa;
  • Kila msanidi anahitaji seti tofauti ya vipengele.

Kuna shida zingine, lakini wacha nikuambie juu ya suluhisho.

Jenkins huko Docker

Kwa kuwa Docker sasa imeanzishwa vizuri katika ulimwengu wa maendeleo, karibu kila kitu kinaweza kuendeshwa kwa kutumia Docker. Suluhisho langu ni kuwa na Jenkins kwenye Docker na kuweza kuendesha vyombo vingine vya Docker. Swali hili lilianza kuulizwa mnamo 2013 katika nakala "Docker sasa inaweza kukimbia ndani ya Docker".

Kwa kifupi, unahitaji tu kusakinisha Docker yenyewe kwenye chombo kinachofanya kazi na kuweka faili /var/run/docker.sock.

Hapa kuna mfano wa Dockerfile ambao ulijitokeza kwa Jenkins.

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

Kwa hivyo, tulipata chombo cha Docker ambacho kinaweza kutekeleza maagizo ya Docker kwenye mashine ya mwenyeji.

Kujenga kuanzisha

Sio muda mrefu uliopita Jenkins alipata fursa ya kuelezea sheria zake kwa kutumia Pipeline syntax, ambayo inafanya kuwa rahisi sana kubadilisha hati ya ujenzi na kuihifadhi kwenye hazina.

Kwa hivyo wacha tuweke Dockerfile maalum kwenye hazina yenyewe, ambayo itakuwa na maktaba zote muhimu kwa ujenzi. Kwa njia hii, msanidi mwenyewe anaweza kuandaa mazingira yanayoweza kurudiwa na hatalazimika kuuliza OPS kusakinisha toleo maalum la Node.JS kwenye seva pangishi.

FROM node:12.10.0-alpine

RUN npm install yarn -g

Picha hii ya muundo inafaa kwa programu nyingi za Node.JS. Je, ikiwa, kwa mfano, unahitaji picha ya mradi wa JVM na skana ya Sonar iliyojumuishwa ndani? Uko huru kuchagua vipengele unavyohitaji kwa mkusanyiko.

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/

Tulielezea mazingira ya kusanyiko, lakini Jenkins ana uhusiano gani nayo? Na mawakala wa Jenkins wanaweza kufanya kazi na picha kama hizo za Docker na kuzijenga ndani. 

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"
    }
}

Maelekezo agent hutumia mali dockerambapo unaweza kubainisha:

  • jina la chombo cha kusanyiko kulingana na sera yako ya kumtaja;
  • hoja zinazohitajika kuendesha chombo cha ujenzi, ambapo kwa upande wetu tunaweka saraka ya sasa kama saraka ndani ya chombo.

Na tayari katika hatua za ujenzi tunaonyesha ni maagizo gani ya kutekeleza ndani ya wakala wa ujenzi wa Docker. Hii inaweza kuwa kitu chochote, kwa hivyo ninazindua pia upelekaji wa programu kwa kutumia busara.

Hapo chini ninataka kuonyesha Jenkinsfile ya jumla ambayo programu rahisi ya Node.JS inaweza kuunda.

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()
        }
    }

}

Nini kimetokea?

Shukrani kwa njia hii, tulitatua shida zifuatazo:

  • wakati wa usanidi wa mkutano wa mazingira umepunguzwa hadi dakika 10 - 15 kwa kila mradi;
  • mazingira ya kujenga maombi yanayorudiwa kabisa, kwani unaweza kuijenga kwa njia hii kwenye kompyuta yako ya ndani;
  • hakuna matatizo na migogoro kati ya matoleo tofauti ya zana za kusanyiko;
  • daima ni nafasi safi ya kazi ambayo haizibiki.

Suluhisho yenyewe ni rahisi na dhahiri na inakuwezesha kupata faida fulani. Ndiyo, kizingiti cha kuingia kimeongezeka kidogo ikilinganishwa na amri rahisi kwa makusanyiko, lakini sasa kuna dhamana ya kwamba itajengwa daima na msanidi mwenyewe anaweza kuchagua kila kitu ambacho ni muhimu kwa mchakato wake wa kujenga.

Unaweza pia kutumia picha niliyokusanya Jenkins + Docker. Vyanzo vyote viko wazi na viko rmuhamedgaliev/jenkins_docker.

Wakati wa kuandika nakala hii, mjadala ulitokea juu ya kutumia mawakala kwenye seva za mbali ili usipakie nodi kuu kwa kutumia programu-jalizi. docker-plugin. Lakini nitazungumza juu ya hili katika siku zijazo.

Chanzo: mapenzi.com

Kuongeza maoni